[20210726] Python 기본 문법 1 - 연산, 변수, 자료형(숫자, 문자 , 리스트, 튜플, 집합, 딕셔너리)

파이썬은 기존 프로그래밍 언어들보다 간단한 문법 덕분에 많은 사람들이 사용하기 시작했다. 그에 따라 다양한 라이브러리들이 존재한다.  들여쓰기를 강제해 가독성을 높였으며 문자열을 쉽게 다룰 수 있다. 또한 객체 지향을 지원하고 람다와 리스트 컴프리헨션 등 비교적 최신 문법들을 지원한다.

 

주석

파이썬의 주석은 다른 언어와 다르다. 한 줄 주석은 '#'을 사용하며, 여러 줄 주석은 '''(작은따옴표 세 개) 또는 """(큰 따옴표 세계) 사이에 입력하면 된다.

# 한 줄 주석

"""
여러 줄 주석
"""

'''
여러 줄 주석
'''

 

변수 선언 및 print() 함수

파이썬은 변수 선언 시에 자료형(data type)을 명시하지 않아도 된다. 자바스크립트에서는 변수명 앞에 var을 붙여줬지만, 파이썬에서는 더 나아가서 변수명 앞에 아무것도 쓰지 않아도 된다. 참고로, 파이썬에서 콘솔에 문자열을 출력하기 위해서는 print() 함수를 사용하면 된다.

a = 123
b = -123

# print() 함수
a = 123
print(a)

a = "python"
print(a)

a = [1, 2, 3]
print(a)

 

자료형 - 숫자

앞서 말했듯이 파이썬에서는 자료형을 명시하지 않아도 된다. 정수형, 실수형, 지수형, 8진수, 16진수이든간에 바로 입력이 가능하다.

a = -234  # 정수형
b = 21.54  # 실수형
c = 4.24E10  # 지수형. E, e 둘 다 가능
d = 4.24e-10
print(c, d)

e = 0o177  # 8진수. O, o 둘 다 가능
f = 0O177
print(e, f)

g = 0x8ff  # 16진수
print(g)

 

연산

파이썬의 사칙연산은 일반적인 프로그래밍 언어와 같다. 나머지 연산에서 나머지를 구하는 연산자(%)는 동일하지만, 몫을 구하는 연산자 '//'가 존재한다. 제곱을 구하는 연산자는 '**'을 사용한다.

# 사칙연산: +, -, *, /
a = 3
b = 4
print(a + b)
print(a - b)
print(a * b)
print(a / b)

# 나머지 연산자: %
print(a % b)

# 몫을 구하는 연산자: //
print(7 // 4)

# a의 b 제곱을 나타내는 연산자: **
print(a ** b)

 

자료형 - 문자, 문자열

파이썬에서는 문자와 문자열을 구분하지 않는다. 따라서 작은따옴표(')와 큰따옴표(") 모두 사용이 가능하다.

"Hello World"  # 문자열 큰따옴표로 감싸기
'Python is fun'  # 문자열 작은따옴표로 감싸기
"""Life is too short, You need python"""  # 큰따옴표 3개를 연속으로 써서 감싸기
'''Life is too short, You need python'''  # 작은따옴표 3개를 연속으로 써서 감싸기

# 문자열에 작은따옴표 포함시키기 - 큰따옴표로 감싸기
food = "Python's favorite food is perl"
print(food)

# 문자열에 큰따옴표 포함시키기 - 작은따옴표로 감싸기
say = '"Python is very easy." he says.'
print(say)

# 다른 따옴표로 감싸는 방법 대신 이스케이프 시퀀스(\", \') 사용하기
food = 'Python\'s favorite food is perl'
say = "\"Python is very easy.\" he says."
print(food)
print(say)

# 여러 줄인 문자열을 변수에 대입하기 - 연속된 작은따옴표 3개, 또는 큰따옴표 3개 사용하기
multiline = '''
Life is too short
You need python
'''
print(multiline)

multiline = """
Life is too short
You need python
"""
print(multiline)

# 여러 줄인 문자열을 변수에 대입하기 - 이스케이프 시퀀스(\n) 사용하기
multiline = "Life is too short\nYou need python"
print(multiline)

 

파이썬에서는 자바처럼 문자열을 더하는 것뿐만 아니라, 곱할 수도 있다. 더하는 것은 문자열을 하나로 합치는 것이며, 곱하는 것은 숫자만큼 반복한 문자열을 만드는 것이다.

# 문자열 연산
head = "Python"
tail = " is fun!"
print(head + tail)  # 문자열 더하기 - 두 개의 문자열을 하나로 합친다.

a = "python"
print(a * 2)  # 문자열 곱하기 - n번 연속한 문자열을 출력한다.

 

파이썬에서 문자열 길이는 len() 함수를 사용하여 구한다.

# 문자열 길이 구하기 - 자바의 a.length: len(a)
a = "Life is too short, You need python"
print(len(a))

 

파이썬에서는 인덱스를 통해서 문자열 슬라이싱이 가능하다. 별도의 메서드나 함수를 사용하지 않더라도 '[]'만으로 문자열을 쉽게 다룰 수 있다.

# 문자열 인덱싱(인덱스는 0부터 시작.)
a = "Life is too short, you need python"
print(a[0])  # 인덱스 0번, 즉 첫 번째 글자 출력
print(a[0] + a[1] + a[2] + a[3])  # 인덱스 0, 1, 2, 3에 해당하는 글자 합치기
print(a[-1])  # 뒤에서 첫 번째 자리
print(a[-5])  # 뒤에서 다섯 번째 자리
print(a[-0])  # -0은 결국 0과 같음

# 문자열 슬라이싱
a = "Life is too short, you need python"
print(a[0:5])  # 처음부터 5번째 자리까지 출력("Life ")
print(a[5:7])  # 5번째 자리 뒤부터 7번째 자리까지 출력. 6, 7번째 자리 출력("is")
print(a[12:17])  # 12번째 자리 뒤부터 17번째까지 출력. 13 ~ 17 5개 문자 출력("short")
print(a[19:])  # 19번째 자리 뒤부터 마지막까지 출력("you need python")
print(a[:17])  # 처음부터 17번째 자리까지 출력("Life is too short")
print(a[:])  # 처음부터 끝까지 전부 출력("Life is too short, you need python")
print(a[19:-7])  # 앞에서 19번째 자리 뒤부터 뒤에서 7번째 자리까지 출력("you need")

# 자주 사용하는 형태의 슬라이싱 기법
a = "20210726Clear"
date = a[:8]
weather = a[8:]
print(date)
print(weather)

 

문자열 인덱스를 통해서는 문자열의 문자를 대체하는 것이 불가능하다. 굳이 문자열의 문자를 바꿔야 한다면 앞뒤 문자를 슬라이싱한 것을 새로운 문자의 앞뒤에 붙여야 한다.

# 문자열 대체
a = "Pithon"
print(a[:1] + 'y' + a[2:])  # 'P' + 'y' + 'thon' = "Python"으로 변경됨

 

문자열 포매팅(string formatting)은 문자열에 아직 정해지지 않은 값을 나중에 입력할 수 있게 해 준다.

# 문자열 포매팅 - 문자열 안에 어떤 값을 삽입하는 방법
# "현재 온도는 18도입니다."
# "현재 온도는 20도입니다."

# 서식 지정자(format specifier) 사용
print("I eat %d apples." % 2)  # 숫자 대입 - %d

print("I eat %s apples." % "five")  # 문자열 대입 - %s

number = 3
print("I eat %d apples." % number)  # 변수 대입 - %

number = 10
day = "three"
print("I ate %d apples, so I was sick for %s days." % (number, day))  # 2개 이상의 값 넣기

# 문자열 포맷 코드
# %s: 문자열. 어떤 형태의 값이든 변환해서 넣을 수 있다. %c: 문자, %d: 정수,
# %f: 부동소수점 실수(float형), %o: 8진수, %x: 16진수, %%: 문자 '%' 자체
"I have %s apples" % 3
"rate is %s" % 3.234

print("Error is %d%%." % 98)  # '%' 자체를 입력하려면 '%%'를 사용한다.

# 포맷 코드와 숫자 함께 사용하기
print("%10s" % "hi")  # 10자리 문자열 공간에 뒤 두 자리에 hi를 넣고 그 앞에 8개의 공백으로 채워라.
print("%-10sjane." % "hi")  # 10자리 문자열 공간에 앞 두 자리에 hi를 넣고 뒤에 8자리를 공백으로 채워라.

# 소수점 표현하기
print("%0.4f" % 3.42134234)  # 소수점 4자리까지만 나타낸다.
print("%10.4f" % 3.42134234)  # 소수점 4자리를 포함한 10자리 수를 출력

# format 함수 사용 - 넣을 자리에 {} 사용하고 각각의 자리는 0부터 시작하는 인덱스를 가짐
# {} 안에 인덱스를 넣어줘도 되고 안 넣어줘도 상관없다.
# 숫자 대입하기
a = "I eat {0} apples".format(3)
print(a)

# 문자열 대입하기
a = "I eat {0} apples".format("five")
print(a)

# 2개 이상의 값 넣기
number = 10
day = "three"
a = "I ate {0} apples. so I was sick for {1} days.".format(number, day)
print(a)

# 이름으로 넣기
a = "I ate {number} apples. so I was sick for {day} days.".format(number=10, day=3)
print(a)

# 혼용 가능
a = "I ate {0} apples. so I was sick for {day} days.".format(10, day="three")
print(a)

# 왼쪽 정렬 <
a = "{0:<10}".format("hi")
print(a)

# 오른쪽 정렬 >
a = "{0:>10}".format("hi")
print(a)

# 가운데 정렬 ^
a = "{0:^10}".format("hi")
print(a)

# 공백 채우기 - 정렬문자를 >, <, ^ 바로 앞에 넣어야 한다.
a = "{0:=^10}".format("hi")
print(a)

a = "{0:!<10}".format("hi")
print(a)

# f 문자열 포매팅: 파이썬 3.6 버전부터 지원한다. 이전 버전에서는 사용 불가
# 문자열 앞에 f 접두사를 붙여 사용한다.
name = "홍길동"
age = 30
a = f'나의 이름은 {name}입니다. 나이는 {age}입니다.'
print(a)

a = f'나는 내년이면 {age + 1}살이 된다.'
print(a)

f'{"hi":<10}'
f'{"hi":>10}'
f'{"hi":^10}'
f'{"hi":=^10}'
f'{"hi":!<10}'
y = 3.42134234
f'{y:0.4f}'
f'{y:10.4f}'
f'{{and}}'

 

문자열을 다루기 위한 파이썬의 내장 함수에는 count(), find(), index(), join(), upper(), lower(), lstrip(), rstrip(), strip(), replace(), strip() 등이 있다.

# 문자열 관련 내장 함수
# 문자 개수 세기: count()
a = 'hobby'
c = a.count('b')
print(c)

# 위치 알려주기1: find()
a = "Python is the best choice"
b = a.find('b')
print(b)  # 인덱스 값 리턴
b = a.find('k')
print(b)  # 값이 존재하지 않을 때는 -1 반환

# 위치 알려주기 2: index()
a = "Life is too short"
b = a.index('t')
print(b)
# c= a.index('k')
# print(c)  # 값이 존재하지 않으면 오류 반환

# 문자열 삽입: join()
a = ",".join('abcd')
print(a)

# 소문자를 대문자로 변환: upper()
a = "hi"
b = a.upper()
print(b)

# 대문자를 소문자로 변환: lower()
a = "HI"
b = a.lower()
print(b)

# 왼쪽 공백 지우기: lstrip()
a = " hi "
b = a.lstrip()
print(b)

# 오른쪽 공백 지우기: rstrip()
a = " hi "
b = a.rstrip()
print(b)

# 양쪽 공백 지우기: strip()
a = " hi "
b = a.strip()
print(b)

# 문자열 바꾸기: replace()
a = "Life is too short"
b = a.replace("Life", "Your leg")
print(b)

# 문자열 나누기: split()
# 값을 주지 않으면 공백(스페이스, 엔터, 탭 등) 기준으로 문자열을 나눈다.
# 만약 ':'처럼 괄호 안에 특정 값이 있을 경우 괄호 안의 값을 구분자로 문자열을 나누어 준다.
a = "Life is too short"
b = a.split()
print(b)
c = "a:b:c:d"
d = c.split(':')
print(d)

 

자료형 - 리스트(list)

리스트는 변수들을 저장할 수 있는 자료형이다. 변수의 자료형에 관계없이 저장이 가능하다. 리스트는 요소들을 [](대괄호)로 감싼다.

# 리스트 자료형
a = []  # 비어 있는 리스트
b = [1, 2, 3]  # 숫자
c = ["Life", "is", "too", "short"]  # 문자열
d = [1, 2, "Life", "is"]  # 숫자, 문자열을 동시에 요소로 가질 수 있다.
e = [1, 2, ["Life", "is"]]  # 리스트 자체를 요소로 가질 수 있다.

# 리스트의 인덱싱
# 배열처럼 인덱스를 사용해서 리스트에 접근 가능
a = [1, 2, 3]
print(a)
b = a[0]
print(b)
b = a[0] + a[2]
print(b)
b = a[-1]  # 리스트 뒤에서 첫 번째
print(b)

# 중첩 리스트 다루기
a = [1, 2, 3, ['a', 'b', 'c']]
b = a[-1] = a[3]
print(b)  # ['a', 'b', 'c']

# a[3]의 첫 번째 값인 'a' 출력
b = a[3][0]
print(b)

# 'c' 출력
b = a[-1][2]
print(b)

# 삼중 리스트에서 인덱싱하기 'Life' 출력
a = [1, 2, ['a', 'b', ["Life", "is"]]]
b = a[2][2][0]
print(b)
b = a[2][2][1]
print(b)

# 리스트 슬라이싱
a = [1, 2, 3, 4, 5]
b = a[0:2]
print(b)
b = a[:2]
print(b)
c = a[2:]
print(c)

# 중첩 리스트 슬라이싱
a = [1, 2, 3, ['a', 'b', 'c'], 4, 5]
b = a[2:5]
print(b)
b = a[3][:2]
print(b)  # 'a', 'b'

# 리스트 연산하기
# 더하기: 두 리스트를 이어서 출력
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)

# 곱하기: 리스트를 n번 반복하여 출력
c = a * 3
print(c)

# 리스트의 길이
a = [1, 2, 3]
b = len(a)
print(b)

# 문자열 연산은 데이터 타입이 같아야 가능. 문자열형이 아닐 경우 변환 후 사용.
a = [1, 2, 3]
# b = a[2] + "hi" // 데이터 타입이 달라서 오류 발생
b = str(a[2]) + "hi"  # str() 함수 사용
print(b)

# 리스트의 수정과 삭제
# 수정
a = [1, 2, 3]
a[2] = 4
print(a)

# del 예약어 사용해 리스트 요소 삭제
del a[1]
print(a)
a = [1, 2, 3, 4, 5]
del a[2:]
print(a)

 

리스트 관련 내장 함수에는 append(), sort(), reverse(), index(), insert(), remove(), pop(), count(), extend()가 있다.

# 리스트 관련 내장 함수
# 리스트에 요소 추가: append()
a= [1, 2, 3]
a.append(4)
print(a)
a.append([5, 6])
print(a)

# 리스트 정렬: sort()
a = [1, 4, 2, 3]
a.sort()
print(a)
a = ['d', 'a', 'b', 'c']
a.sort()
print(a)

# 리스트 뒤집기: reverse()
a = ['a', 'c', 'b']
a.reverse()
print(a)

# 리스트의 위치 반환: index()
a = [1, 2, 3]
print(a.index(3))
print(a.index(1))

# 리스트의 요소 삽입: insert()
a = [1, 2, 3]
a.insert(0, 4)
print(a)
a.insert(3, 5)
print(a)

# 리스트 요소 제거: remove(), 해당되는 첫 번째 값만 삭제
a = [1, 2, 3, 1, 2, 3]
a.remove(3)
print(a)
a.remove(3)
print(a)

# 리스트의 요소 끄집어내기: pop(), 마지막 요소를 돌려주고, 그 요소를 삭제한다.
a = [1, 2, 3]
print(a.pop())
print(a)

a = [1,2,3]
print(a.pop(1))
print(a)

# 리스트에 포함된 요소 x의 개수 세기: count()
a = [1, 2, 3, 1]
print(a.count(1))

# 리스트 확장: extend()
a = [1, 2, 3]
a.extend([4, 5])
print(a)
b = [6, 7]
a.extend(b)
print(a)

 

자료형 - 튜플(tuple)

리스트형과 비슷하지만, 튜플은 선언 후 값을 변경할 수 없다. 리스트는 요소를 [](대괄호)로 감쌌지만, 튜플은 ()(소괄호)로 둘러싼다. 리스트는 값의 생성, 삭제, 수정하는 것이 가능하지만, 튜플은 값을 바꿀 수 없다. 보통 튜플보다는 리스트를 더 많이 사용한다.

# 튜플 자료형
t1 = ()
t2 = (1,)
t3 = (1, 2, 3)
t4 = 1, 2, 3  # 소괄호 생략 가능
t5 = ('a', 'b', ('ab', 'cd'))

# t1 = (1, 2, 'a', 'b')
# del t1[0] 삭제 불가.
# t1[0] = 'c' 변경 불가

# 튜플 다루기
# 인덱싱
t1 = (1, 2, 'a', 'b')
b = t1[0]
print(b)
b = t1[3]
print(b)

# 슬라이싱
t1 = (1, 2, 'a', 'b')
b = t1[1:]
print(b)

# 튜플 더하기: 튜플을 이어서 출력
t1 = (1, 2, 'a', 'b')
t2 = (3, 4)
b = t1 + t2
print(b)

# 튜플 곱하기: 튜플을 n번 만큼 반복하여 출력
t2 = (3, 4)
b = t2 * 3
print(b)

# 튜플 길이 구하기
t1 = (1, 2, 'a', 'b')
b = len(t1)
print(b)

 

자료형 - 딕셔너리(Dictionary)

딕셔너리는 키(key)와 값(value)로 이루어진 자료형이다. 자바의 맵 자료형이나 JSON의 형식과 유사하다. {key1: value1, key2: value2, key3: value3,..., keyn: valuen}와 같은 형태로 사용한다. key와 value의 쌍 여러 개가 {}로 둘러싸여 있으며, 구분은 ','로 한다. key에는 변하지 않는 값을 사용하고, value에는 변하는 값과 변하지 않는 값 둘 다 사용 가능하다.

# 딕셔너리 자료형
dic = {'name': 'hong', 'phone': '01011112222', 'birth': '0727'}
"""
딕셔너리 dic의 정보
key     :  value
name    :  hong
phone   :  01011112222
birth   :  0727
"""
a = {1: 'hi'}  # key 1 , value 'hi'
b = {'a': [1, 2, 3]}  # value에 list도 넣을 수 있다.

# 딕셔너리 쌍 추가
a = {1: 'a'}
a[2] = 'b'  # 딕셔너리 a에 key: 2 , value: 'b' 쌍이 추가됨.
print(a)
a['name'] = 'hong'  # 딕셔너리 a에 key: 'name', value: 'hong' 쌍이 추가됨.
print(a)
a[3] = [1, 2, 3]
print(a)  # 딕셔너리 a에 key: 3, value: [1, 2, 3] 쌍이 추가됨.

# 딕셔너리 쌍 삭제
del a[1]  # key가 1인 값이 삭제됨.
print(a)
del a['name']  # key가 'name'인 값이 삭제됨.
print(a)

# 딕셔너리를 사용하는 이유는 예를 들어 4명의 사람이 있다고 할 때 각자의 특기를 표현해본다면,
# 리스트나 문자열로는 표현하기 어렵지만 딕셔너리를 사용하면 비교적 표현이 간단해지기 때문이다.
# {"김연아": "피겨스케이팅", "류현진": "야구", "손흥민": "축구", "김연경": "배구"}

# 딕셔너리에서 key를 사용해 value 값 얻기
grade = {'romeo': 50, 'julliet': 95}
b = grade['romeo']
print(b)
c = grade['julliet']
print(c)

a = {1: 'a', 2: 'b'}
print(a[1])
print(a[2])

dic = {'name': 'hong', 'phone': '01011112222', 'birth': '0727'}
print(dic['name'])
print(dic['phone'])
print(dic['birth'])

# 딕셔너리를 만들 때 주의 사항
# key는 고유값. 만약에 중복되는 key 값이 설정이 되어 있으면 하나를 제외한 나머지 값은
# 모두 무시된다.
# key 변경 불가. list, 딕셔너리는 key 값으로 사용 불가, 튜플은 key 값으로 사용 가능
a = {1: 'a', 1: 'b'}
print(a)
# a = {[1, 2]: 'hi'}
a = {(1, 2): 'hi'}
print(a)

 

딕셔너리 관련 내장 함수에는 keys(), values(), items(), clear(), get()이 있다.

# 딕셔너리 관련 내장 함수
# key 리스트 만들기: keys()
# a.keys()는 딕셔너리 a의 key만을 모아서 dict_keys 객체를 돌려준다.
# 파이썬 2.7 버전까지는 keys() 함수를 호출하면 리스트로 반환했다.
# 리스트로 반환 시 메모리 낭비가 발생하여 파이썬 3.0 버전 이후에는 dict_key 객체로 돌려준다.
a = {'name': 'hong', 'phone': '01011112222', 'birth': '0727'}
b = a.keys()
print(b)

c = list(a.keys())  # dict_keys 객체를 리스트로 반환받을 때 사용
print(c)

# value 리스트 만들기: values()
# dict_values 객체를 반환한다.
b = a.values()
print(b)

# (key, value) 쌍 얻기: items()
# (key, value) 쌍을 튜플로 묶은 값을 dict_items 객체로 반환한다.
b = a.items()
print(b)

# key: value 쌍 모두 지우기: clear()
# 빈 딕셔너리 값을 출력 시 {}로 표현
a.clear()
print(a)

# key로 value 얻기: get()
a = {'name': 'hong', 'phone': '01011112222', 'birth': '0727'}
b = a.get('name')
c = a['name']
print(b)
print(c)
# print(a.get('nokey')) key 값이 없을 때는 none(거짓)을 리턴
# print(a['nokey']) key 값이 없을때 에러를 리턴
# 딕셔너리 안에 Key 값이 없을 경우 미리 정해 둔 디폴트 값을 대신 가져오게 하고 싶을 때
# get(x, '기본값')을 사용하면 편리하다
b = a.get('foo', 'bar')
print(b)

# 해당 key가 딕셔너리 안에 있는지 조사하기 in: 있으면 True, 없으면 False를 반환한다.
b = 'name' in a
print(b)
c = 'email' in a
print(c)

 

자료형 - 집합

집합은 요소의 중복을 허용하지 않는 리스트 자료형이다. 파이썬 2.3부터 지원한다. 수학의 집합처럼 합집합, 교집합, 차집합 연산이 가능하다. set 키워드를 사용하여 만든다. set 자료형의 두 가지 특징은 중복을 허용하지 않는다는 것과 순서가 없다(Unordered)는 점이다. 순서가 없기 때문에 인덱싱할 수 없으며, 인덱싱을 사용하려면 리스트나 튜플로 변환해야 된다. 종종 중복 제거 필터로도 사용한다.

# 집합 자료형
s1 = set([1, 2, 3])
print(s1)
s2 = set("Hello")
print(s2)

s1 = set([1, 2, 3])
l1 = list(s1)  # list로 변환
print(l1)
print(l1[0])

t1 = tuple(s1)
print(t1)  # tuple로 변환
print(t1[0])

# 교집합, 합집합, 차집합
s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

# 교집합: &, intersection() 두 가지 방법으로 출력
b = s1 & s2
print(b)
c = s1.intersection(s2)
print(c)

# 합집합: |, union() 두 가지 방법으로 출력
# 중복값은 하나만 표현됨.
b = s1 | s2
print(b)
c = s1.union(s2)
print(c)

# 차집합: -, difference() 두 가지 방법으로 출력
b = s1 - s2
print(b)
c = s1.difference(s2)
print(c)

 

집합 관련 내장 함수에는 add(), update(), remove()가 있다.

# 집합 관련 내장 함수
# 값 1개 추가하기: add()
s1 = set([1, 2, 3])
s1.add(4)
print(s1)

# 값 여러 개 추가하기: update()
s1 = set([1, 2, 3])
s1.update([4, 5, 6])
print(s1)

# 특정 값 제거하기: remove()
s1 = set([1, 2, 3])
s1.remove(2)
print(s1)

 

자료형 - 불(bool)

불 자료형은 True 또는 False 값을 가지는 자료형이다. 파이썬에서는 true나 false 값이 대문자로 시작함에 유의하자.(True, False)

# 불 자료형
a = True
b = False
print(type(a))  # a는 불 자료형
print(type(b))  # b는 불 자료형

print(1 == 1)
print(2 > 1)
print(2 < 1)

"""
자료형의 참과 거짓: 참과 거짓이 존재한다. 중요한 특징이고, 실제로도 자주 쓰인다.
자료형의 참과 거짓을 구분하는 기준은 아래와 같다.
문자열, 리스트, 튜플, 딕셔너리 등의 값이 비어 있으면 거짓이 되고, 비어있지 않으면 참이 된다.
숫자는 값이 0일 때만 거짓, None은 무조건 거짓

값            :       참 또는 거짓
"python"      :       참
""            :       거짓
[1, 2, 3]     :       참
[]            :       거짓
()            :       거짓
{}            :       거짓
1             :       참
0             :       거짓
None          :       거짓
"""
b1 = bool('python')
b2 = bool([])
b3 = bool(0)
b4 = bool(3)
print(b1, b2, b3, b4)

 

그 외 변수와 관련된 사항

변수의 주솟값을 사용할 때는 id() 함수를 사용한다. 리스트의 복사에는 '='을 이용한 참조 복사, copy()를 이용한 값 복사가 있다. 튜플이나 리스트를 만들 때는 ()나 []를 사용하고, 두 변수의 값을 바꿀 때는 임시 변수 선언 없이 쉼표(,)만으로 쉽게 교환할 수 있다.

# 파이썬에서는 저장된 값을 스스로 판단하여 자료형을 지정한다.
# a = [1, 2, 3]와 같이 리스트를 선언할 때,
# 파이썬은 사용하는 변수를 객체를 가리키는 리스트 자료형(객체)이 메모리에 생성되고,
# 변수 a는 [1, 2, 3] 리스트가 저장된 메모리의 주소를 가리키게 된다.
a = 1
b = "python"
c = [1, 2, 3]

# id() 함수로 메모리의 주솟값을 확인할 수 있다.
address = id(c)
print(address)
# list[1, 2, 3]가 저장된 메모리 값은 1904295413248(예시)이고 c는 1904295413248 값을 가지고 있다.

# 리스트 복사
a = [1, 2, 3]
b = a
print(id(a))
print(id(b))
print(a is b)
a[1] = 4
print(a)
print(b)

# b 변수를 생성할 때, a 값을 가져오면서 a와 다른 주소를 가리키게 하는 방법
# [:] 이용
a = [1, 2, 3]
b = a[:]
a[1] = 4
print(a)
print(b)

# copy 모듈 이용
from copy import copy  # copy 모듈 임포트

a = [1, 2, 3]
b = copy(a)
print(b is a)

# list 자료형의 자체 함수 copy() 사용
a = [1, 2, 3]
b = a.copy()
print(a is b)

# 변수를 만드는 방법
# 튜플로 생성 가능
a, b = ('python', 'life')
(a, b) = 'python', 'life'

# 리스트로 생성
[a, b] = ['python', 'life']
a = b = 'python'

a = 3
b = 5
a, b = b, a  # 간단하게 값을 바꿀 수 있다.
print(a)
print(b)