26 PYTHON 설치, 문자열, 문자함수

https://www.python.org/

Welcome to Python.org

 

https://www.anaconda.com/download

Free Download | Anaconda

Anaconda3-2023.09-0-Windows-x86_64
Python 3.11 



< Anaconda Prompt >

Anaconda Prompt = CMD

# 버전확인
> python --version
> python  -V


# 파이썬 접속
>python
>v_str = 'oracle'
>type(v_str)

> v_str = 100
> type(v_str)


# 파이썬 종료
> quit()

 

---

 

< Spyder >

Spyder 실행

 

consol

한줄씩 실행 F9

변수 상태

라이브러리

 

---

 

1990 귀도 반 로섬(Guido Van Rossum) 개발한 인터프리터 언어
Interpreter Language : 한줄씩 소스코드를 해석해서 바로 실행해 결과를 확인할 수 있는 언어

특징
1. 문법이 쉽다.
2. 가독성 좋다.
3. 무료이다.
4. 이식성이 좋다.
- 쉽게 라이브러리를 추가할 수 있다.
- 운영체제에 종속되지 않습니다.
5. 풍부한 라이브러리
        - Numpy : 수학, 과학 모듈
        - Pandas : 데이터 검색 모듈
        - Matplotlib : 시각화 모듈
        - Beautiful Soup : 웹스크래핑 모듈
        - Scikit-learn : 머신러닝 모듈
6. 동적 타이밍
        - 런타임시에 type 체크하는 동적타이밍을 지원
        - 자동으로 메모리 관리

예) PYTHON v_str = 'oracle' print(v_str) 또는 v_str # python 변수의 타입은 값을 입력하는 순간 결정된다.(동적타이밍)

예) PL/SQL DECLARE         v_str varchar2(10); BEGIN         v_str := 'oracle';         DBMS_OUTPUT.PUT_LINE(v_str); END; /

 

---

 

■ PYTHON 버젼 확인
import sys
print('User Current Version : ',sys.version)
print('User Current Version : ',sys.version_info)
# User Current Version :  3.11.5 | packaged by Anaconda, Inc. | 
# (main, Sep 11 2023, 13:26:23) [MSC v.1916 64 bit (AMD64)]

from platform import python_version
print('User Current Version : ',python_version())
# User Current Version :  3.11.5

 

---

 

■ 문자열
'문자열' 또는 "문자열" : 작은따옴표 또는 큰따옴표

print('Hello, world!')


- sep=' ', print separator 옵션
print('h','e','l','l','o')          # h e l l o
print('h','e','l','l','o', sep=' ') # 기본값
print('h','e','l','l','o', sep='')  # hello
print('h','e','l','l','o', sep=',') # h,e,l,l,o

print('2003','11','13',sep='-')     # 2003-11-13


- end=' ' 옵션을 이용해서 서로 다른 출력을 하나의 출력문자로 출력할 수 있다.
print('환영합니다.')
print('itwill에')
print('잘 오셨습니다.')       # 연속출력 시 3줄

print('환영합니다.',end=' ')
print('itwill에',end=' ')
print('잘 오셨습니다.')       # 연속출력 시 1줄


- .foramt()
'{} and {}' .format('you','me')                 # 'you and me'
'{0} and {1} and {0}' .format('you','me')       # 'you and me and you'
'{a} and {b} and {a}' .format(a='you',b='me')   # 'you and me and you'



★ 사칙연산
1+2
2-1
2*3
7/2
7//2                # 몫
7%2                 # 나머지

2**3                # 8 , 제곱연산
type(2**3)          # int

import math
math.pow(2,3)       # 8.0
type(math.pow(2,3)) # float



- 연산자 우선 순위
1. **
2. *, /, //, %
3. +, -

(1 + (2 * (3**3)))



- 연산자 축약
x = 1
x = x + 1
↓
x += 1      
x -= 1
x *= 1
x /= 2      # 나누기
x //= 3     # 몫
x %= 3      # 나머지

---

■ 변수 Variable
- 데이터를 저장할 수 있는 메모리 공간
- 첫글자 : 영문, 한글, _(밑줄)
- 두번째 글자 : 영문, 한글, 숫자, _(밑줄)
- 대소문자 구분
- 예약어는 사용할 수 없다.
    
import keyword
keyword.kwlist          # 예약어목록
type(keyword.kwlist)    # List = 1차원 배열 [ ]
                        
x = 10
type(x)     # int

dir()       # 메모리에 생성된 변수, 함수, 클래스, 객체들 확인

del x       # 변수 삭제

[문제] ATM 지급액 단위가 오만원, 만원, 천원 단위로 구분되어 있다. 고객이 128000원을 입력하면 오만원 2장, 만원 2장, 천원 8장을 지급하기 위해서 출력.

amount = 128000 mn50 = amount // 50000 amount %= 50000 mn10 = amount // 10000 amount %= 10000 mn1 = amount // 1000 print('오만원 : {}, 만원 : {}, 천원 : {}'.format(mn50,mn10,mn1))

- input() : 입력 처리하는 함수, 문자값으로 받는다.
amount = input('Enter amount to withdraw : ')
type(amount)                    # str = 문자형 -> 계산불가


★ int() : 문자숫자를 정수형으로 변환
amount = int(amount)
type(amount)                    # int

amount = int(input('Enter amount to withdraw : '))
type(amount)                    # int


★ float() : 문자숫자를 실수형으로 변환하는 함수
amount = float(input('Enter amount to withdraw : '))
type(amount)                    # float


★ divmod( , ) : 몫과 나머지 값을 리턴하는 함수. 변수1, 변수2 = (몫(//), 나머지(%))
divmod(amount,50000)            # (2.0, 25000.0)
type(divmod(amount,50000))      # tuple 자료형

↓
amount = int(input('Enter amount to withdraw : '))
mn50, r = divmod(amount,50000)
mn10, r = divmod(r,10000)
mn1, r = divmod(r,1000)
print('오만원 : {}, 만원 : {}, 천원 : {}'.format(mn50,mn10,mn1))



x = 996
y = 8
q, r = divmod(x,y)      # q : 몫, r : 나머지 대입
print(x,y,q,r)

print('{}를 {}로 나누면 몫은 {}이고 나머지는 {}입니다.'.format(x,y,q,r))


- %s 문자형 포맷
print('%s를 %s로 나누면 몫은 %s이고 나머지는 %s입니다.' %(x,y,q,r))


- %d 정수 숫자형 포맷
print('%d를 %d로 나누면 몫은 %d이고 나머지는 %d입니다.' %(x,y,q,r))



x = 3.141592
print('원주율은 {}'.format(x))
print('원주율은 %s' %(x))       # $s : 문자
print('원주율은 %d' %(x))       # %d : 정수
print('원주율은 %f' %(x))       # %f : 실수



- '''문자열''' 또는 """문자열""" : 장문 문자열 줄바꿈가능
v_str = '''대한민국
짝짝짝'''

v_str = """대한민국
짝짝짝"""
v_str



★ escape code
v_str = '대한민국\n짝짝짝'     # \n : 줄바꿈(enter key)
print(v_str)

v_str = '대한민국\t짝짝짝'     # \t : tab key
print(v_str)

v_str = '대한민국\0짝짝짝'     # \0 : null
print(v_str)

v_str = '대한민국\'짝짝짝\''   # \' : '를 문자로 인식
print(v_str)
또는
" 문자 '열' "
' 문자 "열" '



x = '지금은'
y = '파이썬 개발자'

★ 문자 + 문자 = 문자 : 연결연산자      # 연산자에 대한 오버로딩
print(x + y)            # 지금은파이썬 개발자
print(x + ' ' + y)      # 지금은 파이썬 개발자


★ 문자 * 숫자 = 복사
(x + ' 오라클엔지니어') * 10
# 지금은 오라클엔지니어지금은 오라클... 연속으로 반복

---

■ 비교연산자

PYTHON >> 변수 = 값    # = 할당연산자
PL/SQL >> 변수 := 값   # := 할당연산자
x = 1
y = 2

x == y      # 같다, PL/SQL x = y
x > y
x >= y
x < y
x <= y
x != y      # 같지않다, PL/SQL 동일



★ bool 자료형 : True, False
type(x == y)    # bool
type(x != y)    # bool



■ 논리연산자
True and True       # True
True and False      # False

True or True        # True
True or False       # True

not True            # False
not False           # True

---

■ Indexing 인덱싱, 위치

- 변수[위치(인덱스)]
x = '오라클엔지니어'
x[0]    # '오' : 0으로 시작
x[1]    # '라'
...
x[6]    # '어'

x[-1]   # '어' : 제일 뒤에 위치
x[-7]   # '오'

 오 라 클 엔 지 니 어
 0  1  2  3  4  5  6    : 앞에서부터 위치
-7 -6 -5 -4 -3 -2 -1    : 뒤에서부터 위치

# pl/sql : 1번부터 시작





■ slicing 슬라이싱

- 변수[시작인덱스:종료인덱스-1]
x = '오라클엔지니어'
x[0:2]      # 오라
x[3:]       # 엔지니어
x[2:-1]     # 클엔지니


- 변수[시작인덱스:종료인덱스:증가분]
x = '0123456789'
x[:]        # 0123456789
x[::1]      # 기본값
x[::2]      # 02468
x[::3]      # 0369
x[1::3]     # 147
x[1:7:2]    # 135
x[::-1]     # 9876543210 : 역순으로 출력


X = '파리썬'
x[1] = '이'  # 인덱스 번호를 이용해서 문자를 수정할 수 없다.
             # TypeError: 'bool' object does not support item assignment
x[0] + '이' + x[2]

---

■ 문자함수

x = '파리썬 파리썬'

- replace(old, new) : 문자를 치환하는 함수(미리보기)
x.replace('리', '이')     # 파이썬 파이썬'

x = x.replace('리', '이')     # 변수에 대입해야 저장된거임
x



x = 'hello world'

- startswith() : 원본 문자열이 입력한 문자로 시작되는지 체크하는 함수
x[0] == 'h'         # True
x.startswith('h')   # True
x.startswith('H')   # False


- endswith() : 원본 문자열이 입력한 문자로 종료되는지 체크하는 함수
x[-1] == 'd'        # True
x.endswith('d')     # True

x[-2:] == 'ld'      # True
x.endswith('ld')    # True


- find() : 원본 문자열에서 입력한 문자가 존재하는 위치(인덱스)를 리턴하는 함수
find(찾는문자열,시작인덱스(0:기본값))
x.find('w')         # 6
x[x.find('w')]      # 'w'
x.find('W')         # 찾는 문자열이 없으면 -1로 리턴
x.find('o')         # 4 : 처음으로 찾은 위치 값
x.find('o',0)       # 기본값 : 0
x.find('o',5)       # 7
x.find('o',8)       # -1

- index() : find()와 비슷
x.index('o')        # 4
x.index('o',5)      # 7
x.index('o',8)      # ValueError: substring not found

x.find('z')         # 찾는 문자열이 없으면 -1
x.index('z')        # 찾는 문자열이 없으면 오류


- 변수에 찾는 문자열이 있으면 True, 없으면 False
x.find('o') > 0     # True
x.find('z') > 0     # False


- 찾는값 in 문자열
'o' in x        # True
'z' in x        # False


- 대문자로 변환하는 함수
x.upper()       # 'HELLO WORLD'


- 소문자로 변환하는 함수
x.lower()


- 문장을 기준으로 첫글자 대문자, 나머지는 소문자로 리턴하는 함수
x.capitalize()  # 'Hello world'


- 공백을 기준으로 첫글자 대문자, 나머지는 소문자로 리턴하는 함수
x.title()       # 'Hello World'


- 대문자를 소문자로, 소문자는 대문자로 변환하는 함수
x.swapcase()    # 'hELLO wORLD'


- 자리수를 고정시킨 후 중앙, 왼쪽, 오른쪽에 배치하는 함수
x.center(20)    # '    Hello World     '
x.ljust(20)     # 'Hello World         '
x.rjust(20)     # '         Hello World'

x.center(20).replace(' ','#').upper()   # '####HELLO#WORLD#####'


- 양쪽, 오른쪽, 왼쪽 공백을 제거하는 함수
x = '     hello     '
x.strip()       # 'hello' = x.strip(' ') 기본값 : 공백
x.lstrip()      # 'hello     '
x.rstrip()      # '     hello'


- 문자열을 찾아서 제거하는 함수
x.strip(' ')
x.lstrip(' ')
x.rstrip(' ')


- 접두(앞), 접미(뒤) 연속되는 문자 제거
x = 'wwhelloww'
x.strip('w')    # 'hello'
x.lstrip('w')   # 'helloww'
x.rstrip('w')   # 'wwhello'



x = 'hello'
y = 'hello2023'
z = '안녕하세요'

- 문자열안에 알파벳, 한글로만 이루어져있는지 확인하는 함수
x.isalpha()     # True
y.isalpha()     # False
z.isalpha()     # True

- 문자열안에 알파벳, 한글, 숫자로 이루어져있는지 확인하는 함수
x.isalnum()     # True
y.isalnum()     # True
z.isalnum()     # True

- 문자열안에 숫자로만 이루어져있는지 확인하는 함수
x.isnumeric()   # False
y.isnumeric()   # False
z.isnumeric()   # False

x = 'O1234'     # 맨 앞에 대문자 O 
x.isnumeric()   # False

x = '01234'     # 
x.isnumeric()   # True


- split() : 특정한 문자열을 기준으로 분할하는 함수
x = 'hello,world'
x.split(',')    # ['hello', 'world'] : 리스트 자료형

x = 'hello world'
x.split(' ')    # ['hello', 'world']

z = x.split(' ')
type(z)     # list
z[0]        # 'hello'
z[1]        # 'world'


x = 'abc'
'abc' -> 'a,b,c' -> 'a' 'b' 'c'

x[0] + ',' + x[1] + ',' + x[2]  # 'a,b,c'

- join() : 문자열 사이사이에 특정한 문자를 붙이는 함수
','.join(x)                 # 'a,b,c'
''.join(x)                  # 'abc'

' '.join(x).split()         # ['a', 'b', 'c']