파이썬 기초(문자열함수, 주석, 연산자, 변수, 문자함수, 자료형)

▣ 주요 키워드 ▣

1. 파이썬이란?
2. 문자열
3. 주석
4. 연산자
5. 변수
6. 논리연산자
7. 문자함수
8. 자료형

---

★파이썬(Python)

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

★파이썬 특징

• 문법이 쉬움
• 가독성이 좋음
• 무료 소프트웨어
• 이식성이 좋음
  • 쉽게 라이브러리를 추가 가능
  • 운영체제에 종속되지 않음
• 풍부한 라이브러리
  • numpy : 수학, 과학 모듈
  • pandas : 데이터 검색 모듈
  • matplotlib : 시각화 모듈
  • beautiple soup : 웹스크래핑 모듈
  • scikit-learn : 머신러닝 모듈 등
• 동적 타이밍
  • 런타임 시에 type 체크하는 동적 타이밍을 지원
  • 메모리 관리를 자동으로 함

---

★주석

# 한 줄 주석

'''
여러행 주석
'''

"""
여러행 주석
"""

★연산자

1 + 2 # 더하기
2 - 1 # 빼기
2 * 3 # 곱하기
7 / 2 # 나누기
7 // 2 # 몫
7 % 2 # 나머지
2**3 # 제곱

import math
math.pow(2,3) # == 2**3 / math패키지의 pow함수 : 제곱, float 형식으로 출력

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

 

★변수

• 데이터를 저장할 수 있는 메모리 공간
• 첫 글자 영문, (한글), _(밑줄)
• 두 번째 글자부터는 영문, 한글, 숫자, _
• 대소문자 구분
• 예약어는 사용불가

키워드 확인하는 패키지 함수, 다른 용도로 사용 불가능한 문자열 즉 예약어
import keyword
keyword.kwlist

kwlist 결과

x = 10 # x변수에 10을 할당

type(x) # type() : 타입을 확인할 수 있는 함수

dir() # 메모리에 생성되어 있는 객체 확인

del x # 메모리에 생성되어 있는 객체 삭제 x변수 삭제

e = 10.4e3 # 지수표현 == 10.4 * 10**3

# 연산자 축약
x = 1
x = x+1 -> x += 1
x = x-1 -> x -= 1
x = x*1 -> x *= 1
x = x/1 -> x /= 1
x = x//1 -> x //= 1
x = x%1 -> x %= 1

 

★논리 연산자

x = 1
y = 2
x == y # 같다
x != y # 같지 않다
x > y # 크다
x >= y # 크거나 같다
x < y # 작다
x <= y # 작거나 같다

True and True # True
True and False # False
True or True # True
True or False # True

 

★문자열

print("오늘 하루도 행복하자") # 큰 따옴표
print('오늘 하루도 행복하자!') # 작은 따옴표

★ escape code
- \n : 줄바꿈
str = '대한민국\n짝짝짝'
str # \n를 그대로 출력
print(str) # \n를 적용하여 출력

- \t : tab key
- \0 : null
- \' : 작은 따옴표를 문자로 표현
- \" : 큰 따옴교를 문자로 표현

str 출력

print(str) 출력

★ 문자 복제
x = "홍길동"
y = "파이썬 개발자"
x + ' ' + y # 문자 + 문자 = 문자, 연결연산자
(x + ' ' + y) * 100 # 문자를 100번 복제

x + ' ' + y

(x + ' ' + y) * 100

★ 문자열에서 변수, 함수 출력
x = "홍길동"
y = "발라드"

- {} 위치
print("안녕하세요,{}입니다. 즐겨듣는 음악은 {}입니다.".format(x,y))

- %s 문자의 위치
print("안녕하세요,%s입니다. 즐겨듣는 음악은 %s입니다."%(x,y))

- f-string
print(f'안녕하세요,{x}입니다. 즐겨듣는 음악은 {y}입니다')

# 문자 사칙연산(+) 문자 = 연결연산자
# 문자 사칙연산(+) 숫자 = 오류

※ divmod : 몫과 나머지를 동시에 출력해주는 함수

x = 10
y = 3
divmod(x,y) # 10 / 3의 몫과 나머지값 출력
i, j = divmod(x,y) # 튜플형식으로 나온 몫과 나머지를 각각 i = 몫, j = 나머지 저장

print("%s를 %s로 나누면 몫은 %s 나머지는 %s가 출력됨"%(x,y,i,j))

divmod(x,y) 출력

※ 숫자 출력

● %d
print('%d'%100)
print('%5d'%100) # 5자리까지 출력, 빈자리는 공백
print('%05d'%100) # 5자리까지 출력, 빈자리는 0
print('{:5}'.format(100)) # 5자리까지 출력, 빈자리는 공백
print('{:05}'.format(100)) # 5자리까지 출력, 빈자리는 공백

● %f
print('%.4f'%(3.141592)) # 소수점 4째자리까지 출력(5째에서 반올림)
print('{:.5}'.format(3.141592)) #소수점 4째자리까지 출력(5째에서 반올림)
print('%08.3f'%(3.141592)) # 8자리 출력(점 포함, 소숫점3째자리까지 포함, 빈공간은 0)
print('%8.3f'%(3.141592)) # 8자리 출력(점 포함, 소숫점3째자리까지 포함, 빈공간은 공백)

※ len : 문자의 길이

x = "행복한 하루를 보내자"
len(x) # 11 <- 공백까지 포함된 길이

 

★ 인덱스

x = "행복한 하루를 보내자"

x[0] # 0번 인덱스 : 행
x[1] # 1번 인덱스 : 복
x[-1] # 뒤에서부터 첫번째(마지막 인덱스) : 자
x[-2] # 뒤에서 두번째 : 내
x[:] # 처음부터 끝까지
x[0:3] # [시작인덱스:종료인덱스+1]
x[4:] # 4번 인덱스에서 끝까지
x[4:6] # 4번 인덱스에서 5번 인덱스까지 출력
x[4:-5] # 4번 인덱스에서 뒤에서 여섯번째 인덱스까지 출력

x = '0123456789'
x[:] # 첫 인덱스부터 마지막 인덱스까지 출력
x[::1] # 첫 인덱스부터 마지막 인덱스까지 
x[::2] # 첫 인덱스부터 마지막 인덱스까지 +2(인덱스)
x[0:7:2] # [시작인덱스:종료인덱스:증가분]
x[5::2] # 5번인덱스:끝까지:2씩증가
x[::-1] # 역순 출력

x = '파리썬' # x[1] ='이' 인덱스 번호를 이용해서 문자를 수정할 수 없다.
x[0] + '이' + x[2] # 이런 방식으로 수정 가능

 

★ 문자 함수

- replace : 문자를 치환하는 함수

x = ' 파리썬 파리썬'
x = x.replace('리','이') # '리'를 '이'로 치환( 모두 찾아서 치환)하고 x에 저장해야 적용
x

- startswith : 원본 문자열이 입력한 문자로 시작되는지 판단하는 함수

x = 'hello world'
x[0] =='h' # 0번째 인덱스가 h이면 true 아니면 false 출력
x.startswith('h') # 시작문자가 h이면 true 아니면 false 출력
x[0] =='H' # 대소문자 구분으로 false 출력
x.startswith('H') # 대소문자 구분으로 false 출력

- endswith : 원본 문자열이 입력한 문자로 끝나는지 판단하는 함수

x = 'hello world'
x[len(x)-1] =='d' # x의 마지막 인덱스 값이 d이면 true 
x.endswith('d') # x의 마지막 인덱스 값이 d이면 true
x[-2:] == 'ld' # x의-2번째 인덱스부터 마지막인덱스까지 값이 ld이면 true
x.endswith('ld') # ld로 마지막이 끝나면 true

- find, index : 원본 문자열에서 입력한 문자가 존재하는 위치를 찾아내는 함수

x = 'hello world'
x.find('o')
x.index('o')
x.find('o',5) # 5번 인덱스부터 'o'를 찾기
x.index('o',5)

# 변수에 문자열이 있는지 True, False를 출력하고싶을 때
x.find('o') >= 1 # True
x.find('o') < 0 # False
'o' in x
'O' in x # in연산자도 대소문자 구분

- count : 입력한 문자열이 몇 번 나오는지를 리턴하는 함수

x = 'hello world'
x.count('o') # x변수에 'o' 문자가 2개 있음

- upper, lower, capitalize : 대문자, 소문자, 첫 글자 대문자 변환 함수

x.upper()
x.lower()
x.capitalize()

- title : 공백 문자를 기준으로 첫 글자를 대문자로 변환

- swapcase : 대문자는 소문자, 소문자는 대문자로 변환

x.title()
y = 'Hello World'
y.swapcase()

- center, ljust, rjust : 자릿수를 고정시키고 문자열을 중앙, 왼쪽, 오른쪽에 고정시키는 함수

x.center(20) # 20자리에서 x변수값은 중앙에 고정
x.ljust(20) # x변수를 왼쪽에 고정하고 나머지부분은 공백
x.rjust(20) # x변수를 오른쪽에 고정하고 나머지부분은 공백

# 자리수 고정시킨 후 왼쪽 정렬
x.ljust(10)
f'{x:10}'
f'{x:<10}'

# 자리수 고정시킨 후 오른쪽 정렬
x.rjust(10)
f'{x:>10}'

# 자리수 고정시킨 후 가운데 정렬
x.center(10)
f'{x:^10}'

- lstrip, strip, rstrip : 왼쪽, 양쪽, 오른쪽 문자열 제거

y = x.center(20)
len(y)
y.lstrip() # 왼쪽 공백 제거
y.rstrip() # 오른쪽 공백제거
y.strip() # 양쪽 공백제거
y.lstrip(' ')
y.strip(' ')
y.rstrip(' ')

y = 'aapythonaa'
y.lstrip('a') 
y.strip('a')
x.rstrip('a')
y = 'a apythona a'
y.lstrip('a')
y.strip('a')

- isalpha : 문자열 안에 알파벳, 한글로 이루어져 있는지 확인하는 함수

- isalnum : 문자열안에 알파벳, 한글, 숫자로 이루어져있는지 확인하는 함수

- isnumeric : 문자열안에 숫자로 이루어져있는지 확인하는 함수

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

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

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

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


d = '2022'
type(d) # str
d.isalpha() # False
d.isalnum() # True 
d.isnumeric() # True / d변수는 문자지만 숫자형식의 문자로 취급됨

- split, join : 분할하는 함수, 문자 사이에 문자 넣는 함수

x = 'hello world,hi'
x.split(' ') # 공백으로 분할하여 리스트로 출력
x.split(',')

x = 'abc'
x[0] + ',' + x[1] + ','  + x[2] # 각 문자 사이사이에 , 삽입
z=','.join(x) # 각 문자 사이사이에 , 삽입
z.split(',') # ,로 분할

---

★ 파이썬 자료형

1. list(리스트)

1. list
- 데이터의 목록을 다루는 자료형
- 서로다른 데이터 타입을 가질 수 있는 자료형
- 중첩할 수 있다.
- []
- list()

x = []
type(x1)
x1 =list()
type(x1)

x = [10,20,30]
x
type(x)
len(x)
x[0] # 첫번째 인덱스
x[1] # 두번째 인덱스
x[2] # 마지막 인덱스
x[-1] # 마지막 인덱스
x[-2] # 두번째 인덱스
x[-3] # 첫번째 인덱스
x[0:2] # 0~1번 인덱스 값 출력
x[1:] # 1부터 끝 인덱스까지 출력
x[:-1] # 처음부터 끝 전 인덱스까지 출력

- 리스트 값 수정

- append, extend : 리스트 값 추가 

- insert(인덱스, 추가할 값) : 인덱스를 이용해서 특정한 위치에 값을 입력하는 함수

리스트 값 수정
x = [10,20,30]
x[0] = 100
x
x[1:3] = [200,300]
x

리스트 값 추가
x.append(400)
x
x.extend([600,700]) # extend : 리스트형식의 값만 넣을 수 있으며 일반 int값 하나만은 넣을 수 없다.
x
인덱스를 이용해서 특정한 위치에 값을 입력하는 함수
x[4]
x.insert(4,500) # 4번째 인덱스 위치에 500 삽입, 원래자리에 있던 값은 뒤로 밀려남
x[4]

- 서로 다른 리스트 결합

x = [100,200,300]
x1 = [400,500]
z = x + x1
z

- pop : 마지막 값 추출, 기존 변수에서는 삭제

z[:-1]
del z[-1] # 마지막 값 삭제
z

z.pop()
z
z.pop(2) # 2번째 인덱스 값 삭제

x = ['사랑','우정','하트','사랑','우정']
x.index('사랑')
x.find('사랑') # 리스트 변수는 find함수를 사용할 수 없다. 오류

#리스트 변수 값 제거하기
del x[x.index('사랑')]
x
x.pop(x.index('사랑'))
x
x.remove('하트')
x

-  중첩 리스트

x = [1,2,3,['a','b','c'],4,5]
x
x[0]
x[3]
x[3][0]

- clear : 변수 안에 값들 모두 제거

- id : 변수의 메모리 확인

x.clear()
x
id(x)
del x # x변수 메모리에서 삭제

- sort, sorted : 정렬(변수에 바로 적용), 정렬(미리 보기, 변수에 적용해주어야 함)

x = [5,2,1,4,3]
x.sort() # 오름차순으로 정렬(x변수에 바로 적용)
x.sort(reverse=True)  # 내림차순으로 정렬(x변수에 바로 적용)

x = [5,2,1,4,3]
sorted(x) # 오름차순 미리보기 
sorted(x,reverse=True) # 내림차순 미리보기

- reverse : 역순 출력

x = [5,1,3,2,4]
x[::-1] # 미리보기
x.reverse() # x변수에 바로 적용
x

2. tuple(튜플)

2. tuple
- 리스트와 유사하지만 수정, 삭제, 추가를 할 수 없다.
- ()

x = ()
type(x)
x = 10, 20
type(x)
x = (10,)
type(x)
x = (1,2,3,4,5)
type(x)
x = ('a','b',('ab','bc'))
type(x)
x[2][0]
x = (1,2,('ab','bc'))
type(x[0])
type(x[2])

x = (1,2,3)
y = (4,5,6)
z = x + y # 1,2,3,4,5,6
type(z) # tuple

# 튜플에서 안되는 함수, 연산
z + [7,8,9] # 튜플에 리스트를 추가할 수 없다. 오류
z[0] = 100  # 튜플은 수정 불가능. 오류
del z[0] # 튜플은 삭제 불가능. 오류
z.remove(1) # 오류
z.pop() # 오류
z.append(4) # 삽입 불가능. 오류
z.sort() # 정렬도 불가능. 오류

# 튜플에서 사용가능한 함수, 연산
sorted(z)
sorted(z,reverse=True)
z[::-1]
z.index(1)
z.count(1)

del z # 변수 자체 삭제는 가능

# 여러개의 값을 여러개의 변수에 한번에 넣기
x = 1,2,3
x,y,z = x
x
y
z

q,r = divmod(11,2)
q #몫
r #나머지

3. dictionary

3. dictionary
- key, value 값을 가지는 자료형이다.
- {}
- {key1:value1,key2:value2,,,,,}

- dictionary.keys() : 키값 출력

- dictionary.values() : value값 출력

- dictionary.items() : 키, value값 모두 출력

# dictionary 형식 표현방법
dic = {}
type(dic)

dic = {'이름' : '홍길동', '전화번호' : '010-0000-0001','주소' : '서울'}
dic
dic['이름'] # '이름'키에 맞는 value값 출력
dic['전화번호'] 

dic.keys() # 키값 출력 
dic.values() # 키에 맞는 value값 출력
dic.items() # 모두 출력

- 키, value 값 추가

# 키, value 값 추가
dic['이메일'] = 'abc@gmail.com'
dic

# 한 개의 키 값에 여러 value값 넣기 가능
dic['이름'] = ['진선미','고등어','마징가']

# value값이 있는지 확인
'서울' in dic.values() 
# value값 제거
dic['이메일'] = []

 

4. set

set
- 집합
- 리스트와 비슷하다. 단 인덱스가 없다.
- 중복을 허용하지 않는다.
- {}

s = {1,2,3,2,1,1,1,5,6,5,5,5,4,4,4}
type(s)

# 리스트와 set 비교
lst = [1,2,3,2,1,1,1,5,6,5,5,5,4,4,4]
list(set(lst)) # lst값을 set형식으로 중복제거하고 다시 list형식

lst[0]
s[0] # 오류, set은 인덱스x

lst.count(1) # lst리스트형 변수에서 1이 몇개인지 찾는 함수

- 합집합 union()

x = {1,2,3,6}
y = {1,2,3,4,5}

z = [1,2,3,6]
w = [1,2,3,4,5]

# 합집합(중복x) : union()
x.union(y) 
z.union(w) # 오류 : union함수는 set형식만 수행가능
set(z).union(set(w)) # list형식을 set형식으로 변환해서 수행가능
x|y

- 교집합 : intersection()

# 교집합
x.intersection(y)
x & y

- 차집합 : difference()

# 차집합 : difference()
x.difference(y) # x - y
y.difference(x) # y - x
x - y
y - x

- 대칭 차집합() : symmetric_difference()

# 대칭차집합() : symmetric_difference()
(x-y) | (y-x) # x와 y의 교집합을 뺀 나머지(x에만 있고 y에만 있는 값들)
(x-y).union(y-x)
x.symmetric_difference(y)

- 서로소 집합 : isdisjoint() - 두 집합에 공통된 원소가 없는 집합 체크

{1,2,3}.isdisjoint({1,2,3})
{1,2,3}.isdisjoint({4,5,6})

- 부분집합 : issubset()

# 부분집합 : issubset
{1,2,3}.issubset({1,2,3,4}) # {1,2,3,4}에 {1,2,3}이 속하는지
{1,2,3}.issubset({4,5,6})
{1,2,3} <= {1,2,3,4}
{1,2,3} <= {5,6,7,7}

# 상위집합 : issuperset()
x = {1,2,3}
y = {1,2,3,4}
y.issuperset(x) # True
x.issuperset(y) # False

- 집합의 값 추가, 제거

x.remove(1)
x.add(1)
x.update([4,5])
# x[0] 인덱스는 사용불가
# 집합에 있는 값은 수정할 수 없기 때문에 지우고 다시 추가해야함

5. bool

- 참(True), 거짓(False)을 나타내는 자료형

x = True
y = False
type(x)
type(y)

# 조건제어문에서 True 표현 방법
bool(1)
bool(100)
bool(-1)
bool('홍길동')
bool('python')
bool([1,2,3])
bool((1,2,3))
bool({1,2,3})
not 0

# 조건제어문에서 False 표현 방법
bool(0)
bool(None)
bool([])
bool({})
bool(())
bool('')
bool("")

not 1
not -1