[Python] 변수(Variable)와 자료형(Datatype)

변수

변수란 말 그대로 '변할 수 있는 값'을 의미하며, 파이썬에서의 변수는 객체의 메모리 주소를 가리킨다.

파이썬은 모든 것을 객체로 취급한다.

변수 만들기

변수를 만들거나, 값을 변경할 때 대입(=할당, assignment)을 사용한다.
변수 이름 규칙은 다음과 같다.
- 문자, 숫자, _를 이용하여 생성할 수 있으나, 숫자를 변수명 맨 앞에 둘 수 없다.
- _(밑줄)은 변수명 맨 앞에 둘 수 있다.
- 대소문자를 구분한다.
- 특수문자(!, &, * 등)와 예약어(for, while, and 등)는 변수명으로 사용할 수 없다.
- 공백 및 연산자(*, % 등)는 사용할 수 없다.

변수 생성

a = 10
a

파이썬은 따로 타입(int, float, string 등)을 적을 필요 없이 '변수명 = 값'으로 변수를 생성한다.
아래와 같이 변수에는 숫자 말고 문자도 넣을 수 있다.

b = 'string'
b

string

변수 값 변경

a = 10
a = 'string'
a

string

간단하게 대입 기호(=)를 이용하여 바꾸려는 값으로 변경하면 된다.

변수가 가리키는 객체의 주소 확인

a = 10
id(a)

2745997197840

변수 a가 가리키는 객체의 메모리 주소는 id 함수를 이용하여 확인할 수 있다.

변수 값 복사하기

a = 10
b = a
print(a)	# print는 값을 출력하는 함수
print(b)

10
10

간단하게 대입 기호를 사용하여 '새로운 변수 = 기존 변수명'으로 복사할 수 있다.

자료형

변수가 저장하는 데이터의 종류를 말한다.

숫자형

숫자형은 크게 정수형(integer)과 실수형(real number)으로 나누어진다.

정수형

a = 10	  # 양의 정수
a = -10	  # 음의 정수
a = 0	  # 0

실수형

a = 3.141592
a = 3141592e-6	# 지수 표현1
a = 3141592E-6	# 지수 표현2

숫자형 연산

사칙연산

a = 6
b = 3

print(a + b)    # 덧셈
print(a - b)    # 뺄셈
print(a * b)    # 곱셈
print(a / b)    # 나눗셈

9	# 덧셈
3	# 뺄셈
18	# 곱셈
2.0	# 나눗셈

거듭제곱

a = 6
b = 3

print(a ** b)   # 거듭제곱 연산자 **

216	# 6^3

나머지와 몫

a = 6
b = 4

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

2	# 나머지
1	# 몫

문자열 자료형

문자의 집합을 문자열이라고 한다.
문자열은 작은 따옴표(') 혹은 큰 따옴표(")로 둘러싸인다.
큰 따옴표(") 안에 작은 따옴표('), 작은 따옴표(') 안에 큰 따옴표("), 백슬래시(\)를 이용하여 내부에 다른 따옴표를 문자로 표기할 수 있다.
파이썬은 문자열에 대한 연산을 지원한다.

문자열을 생성하는 방식

"hello world"       # 큰 따옴표(") 이용하기
'hello world'       # 작은 따옴표(') 이용하기
"""hello world"""   # 큰 따옴표(") 3개 이용하기
'''hello world'''   # 작은 따옴표(') 3개 이용하기

문자열은 위와 같이 총 4가지 방법으로 생성할 수 있다.
따옴표를 3개 사용하는 방식은 여러 줄로 이루어진 긴 문자열을 생성할 때 사용한다.

따옴표 안에 다른 따옴표 포함하기

a = " python's world "     # 큰 따옴표(") 안에 작은 따옴표(')
b = ' python is "good" '   # 작은 따옴표(') 안에 큰 따옴표(")
c = " python\'s world "    # 백슬래시(\) 이용
print(a)
print(b)
print(c)

 python's world 
 python is "good" 
 python's world

여러 줄 작성하기

a = " python's world\n python is 'good' "    # \n 사용
b = """ python's world
 python is 'good' """                        # 따옴표 3개 사용
print(a)
print(b)

 python's world
 python is 'good' 
 python's world
 python is 'good'

문자열 연산

문자열 더하기

a = "python"
b = " is good"
print(a + b)

python is good

문자열 곱하기

a = "python"
print(a * 3)

pythonpythonpython

문자열 인덱싱/슬라이싱

a = "python"
print(a[0])     # 인덱싱   -> 0번 인덱스의 문자
print(a[0:3])   # 슬라이싱 -> 0번 인덱스에서 2번 인덱스까지의 문자열

p
pyt

문자열 자료형은 immutable 객체이므로, 인덱싱 및 슬라이싱을 통한 값의 변경이 불가능하다.
모든 인덱스는 0번부터 시작함에 유의하자. (첫 번째 원소 = 0번 인덱스 원소)

문자열 포매팅

문자열에서 문자는 같은데, 숫자를 다르게 하고 싶을 때 문자열 포매팅 기법을 이용한다.
이것은 꽤 알아야 하는 부분이 많으므로 다음 사이트 참고

Python String Formatting Best Practices – Real Python

Learn the four main approaches to string formatting in Python, as well as their strengths and weaknesses. You'll also get a simple rule of thumb for how to pick the best general purpose string formatting approach in your own programs.

realpython.com

문자열 자료형 관련 메서드

# 문자열 길이 반환 함수 len

a = "Python is Good"

# 문자열 길이 반환 함수 len
print(len(a))

# 문자열 내 특정 문자 개수 반환 함수 count

a = "Python is Good"

# 문자열 내 특정 문자 개수 반환 함수 count
print(a.count('o'))

# 문자열 내 특정 문자의 인덱스 반환 함수 find

a = "Python is Good"

# 문자열 내 특정 문자의 인덱스 반환 함수 find
print(a.find('y'))     # 없을 시 -1 반환

# 문자열 내 특정 문자의 인덱스 반환 함수 index

a = "Python is Good"

# 문자열 내 특정 문자의 인덱스 반환 함수 index
print(a.index('y'))    # 없을 시 오류 발생

# 대문자 변환 함수 upper

a = "Python is Good"

# 대문자 변환 함수 upper
print(a.upper())

PYTHON IS GOOD

# 소문자 변환 함수 lower

a = "Python is Good"

# 소문자 변환 함수 lower
print(a.lower())

python is good

# 문자열 삽입 함수 join

a = "Python is Good"

# 문자열 삽입 함수 join
print("/".join(a))

P/y/t/h/o/n/ /i/s/ /G/o/o/d

# 문자열 교체 함수 replace

a = "Python is Good"

# 문자열 교체 함수 replace
print(a.replace("Good", "Bad"))

Python is Bad

# 문자열 나누기 함수 split

a = "Python is Good"

# 문자열 나누기 함수 split
p, q, r = a.split()    # 공백을 기준으로 나누기
print(p, ",", q, ",", r)

Python , is , Good

# 시작 문자열 확인 함수 startswith()

a = "PythonisGood"

# 시작 문자열 확인 함수 startswith()
tf1 = a.startswith('Python')
tf2 = a.startswith('C++')
print(f'tf1 : {tf1}')
print(f'tf2 : {tf2}')

tf1 : True
tf2 : False

리스트 자료형 (List)

파이썬이 기본으로 제공하는 리스트는 연결리스트(Linked List) 자료구조이다.
연결리스트는 원소들이 실제 메모리 공간에 연속적으로 배열된다.

리스트 만들기

리스트는 대괄호([ ]) 혹은 list()를 이용하여 생성할 수 있다.

# 빈리스트 만들기
a = list()
b = []

# 리스트에 원소 초기화하기
c = list([1, 2, 3, 4])
d = [1, 2, 3, 4]

# 리스트에 리스트를 원소로 포함하기
e = [1, 2, [3, 4]]

# 다른 타입 원소 갖기
f = [1, 2, "hello", "world"]

리스트 원소 접근하기

리스트 원소는 메모리에 연속적으로 배열되어 있어 인덱스를 이용하여 접근할 수 있다.
리스트 원소에 접근하여 값을 변경하거나 제거할 수 있다.

리스트 인덱싱

a = [1, 2, 3, 4]
a[1]

리스트 슬라이싱

a = [1, 2, 3, 4]
a[1:3]

[2, 3]

리스트 원소 수정

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

[1, 10, 3, 4]

리스트 원소 삭제

a = [1, 2, 3, 4]
del a[2]	# 슬라이싱 사용 가능
print(a)

[1, 2, 4]

리스트 연산

a = [1, 2, 3, 4]
print(a + [5, 6, 7, 8])
print(a * 2)

[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 1, 2, 3, 4]

리스트는 더하기 연산과 곱하기 연산이 가능하다.

리스트 관련 메서드

# 원소 추가하기 append

a = [2, 1, 4, 3]

# 원소 추가하기 append
a.append(5)     # 리스트 또는 다른 타입도 추가 가능
print(a)

[2, 1, 4, 3, 5]

# 리스트 정렬하기(작은 숫자 순) sort

a = [2, 1, 4, 3]

# 리스트 정렬하기(작은 숫자 순) sort
a.sort()
print(a)

[1, 2, 3, 4]

# 리스트 정렬하기(큰 숫자 순) sort

a = [2, 1, 4, 3]

# 리스트 정렬하기(큰 숫자 순) sort
a.sort(reverse=True)
print(a)

[4, 3, 2, 1]

# 리스트 뒤집기 reverse

a = [2, 1, 4, 3]

# 리스트 뒤집기 reverse
a.reverse()
print(a)

[3, 4, 1, 2]

# 리스트의 특정 인덱스 위치에 원소 삽입 insert

a = [2, 1, 4, 3]

# 리스트의 특정 인덱스 위치에 원소 삽입 insert
a.insert(1, 10)     # 1번 인덱스에 원소 10 삽입
print(a)

[2, 10, 1, 4, 3]

# 리스트의 특정 원소 제거 (가장 먼저 나오는 원소를 1개 제거) remove

a = [2, 1, 4, 3]

# 리스트의 특정 원소 제거 (가장 먼저 나오는 원소를 1개 제거) remove
a.remove(1)
print(a)

[2, 4, 3]

# 리스트 원소 꺼내기 pop

a = [2, 1, 4, 3]

# 리스트 맨 위 원소 꺼내기
print(a.pop())
print(a)

a = [2, 1, 4, 3]
# 인덱싱을 통해 원소 꺼내기
print(a.pop(2))
print(a)

3
[2, 1, 4]
4
[2, 1, 3]

# 리스트 원소의 인덱스 반환하기 index

a = [2, 1, 4, 3]

# 리스트 원소의 인덱스 반환하기 index
print(a.index(2))     # 값이 없으면 오류 발생

# 리스트 내 특정 원소 개수 세기 count

a = [2, 1, 4, 3]

# 리스트 내 특정 원소 개수 세기 count
print(a.count(1))

# 리스트 확장하기 extent

a = [1, 2, 3, 4, 5]

# 리스트 확장하기 extent
a += [6, 7]    # a = a + [6, 7]
print(a)
a.extend([8, 9])     # 위와 동일
print(a)

[1, 2, 3, 4, 6, 7]
[1, 2, 3, 4, 6, 7, 8, 9]

# 문자열이 담긴 리스트 원소 연결하기 join

a = ["Python", "is", "good"]

# str을 기준으로 문자열 합치기 join
print(''.join(a))	# 공백 없이 합치기
print(','.join(a))	# 중간에 문자열 넣고 합치기

Pythonisgood
Python,is,good

리스트 컴프리헨션

간단하게 리스트를 초기화할 수 있는 방법이다.
2차원 리스트를 초기화할 때 매우 효과적으로 이용할 수 있다.
2차원 리스트를 초기화할 때는 반드시 컴프리헨션을 이용해야 각 행이 서로 다른 참조를 할 수 있다.

# 홀수만 포함하는 리스트
a = [i for i in range(10) if i % 2 == 1]
print(a)

# 2차원 리스트 초기화
b = [[0] * 3 for _ in range(2)]
print(b)

b[0][0] = 1     # 각 행의 서로 다른 참조 확인
print(b)

[1, 3, 5, 7, 9]
[[0, 0, 0], [0, 0, 0]]
[[1, 0, 0], [0, 0, 0]]

리스트 복사하기

a = [10, 20, 30, 40]
b = a
print(a)
print(b)

[10, 20, 30, 40]
[10, 20, 30, 40]

주의) 얕은 복사

파이썬에서 mutable한 객체(list, set 등)를 복사하는 경우 '얕은 복사(Shallow Copy)'가 이루어진다.
얕은 복사란 같은 메모리 공간을 참조하도록 하는 복사 방식이다.
반면에 immutable한 객체(int, float 등)는 복사를 하면 참조가 변경되기 때문에 얕은 복사를 고려하지 않아도 무관하다.
얕은 복사는 동일한 참조를 하므로, a의 값이 변경되면 b의 값도 변경된다.

a = [10, 20, 30, 40]
b = a
print(a)
print(b)

a[0] = 100
print(a)
print(b)

[10, 20, 30, 40]
[10, 20, 30, 40]
[100, 20, 30, 40]
[100, 20, 30, 40]

원소의 값이 변경되더라도 b는 a와 동일한 메모리 공간을 참조하기 때문에 값이 같이 변하게 된다.
리스트를 복사할 때 아예 새로운 메모리 공간을 참조하도록 하려면 '깊은 복사(Deep Copy)'를 이용하여야 한다.

깊은 복사 (Deep Copy)

깊은 복사는 copy 모듈의 deepcopy 함수를 이용하여 구현할 수 있다.
copy 모듈은 내장 라이브러리가 아니기 때문에 맨 처음에 불러와야 함에 유의하자.

import copy

a = [10, 20, 30, 40]
b = copy.deepcopy(a)
print(a)
print(b)

a[0] = 100
print(a)
print(b)

[10, 20, 30, 40]
[10, 20, 30, 40]
[100, 20, 30, 40]
[10, 20, 30, 40]

튜플 자료형 (tuple)

리스트와 비슷한 자료형이지만, 리스트와 달리 원소 값을 변경할 수 없다.
리스트에서 사용 가능한 메서드 중에서 삭제/수정 메서드를 제외하고는 거의 동일하게 튜플에서도 사용할 수 있다.

튜플 만들기

튜플을 만드는 방법은 3가지이다.
- 소괄호 ( ) 이용하기
- tuple() 메서드 이용하기
- 괄호 없이 원소 나열하기

# 소괄호 이용하기
a = (1, 2, 3)

# tuple() 메서드 이용하기
b = tuple([1, 2, 3])

# 원소만 나열하기
c = 1, 2, 3

print(a, type(a))
print(b, type(b))
print(c, type(c))

(1, 2, 3) <class 'tuple'>
(1, 2, 3) <class 'tuple'>
(1, 2, 3) <class 'tuple'>

딕셔너리 자료형 (Dictionrary)

키(key)와 값(value)의 쌍을 데이터로 갖는 자료형 ▶ 연관 배열(Associative Array) 또는 해시(Hash)
immutable한 데이터(숫자형, 문자열, 튜플 등)를 key로 사용할 수 있다.
데이터가 순차적으로 저장되어 있지 않기 때문에 리스트와 튜플과 달리 인덱싱/슬라이싱이 불가능하다.
- 대신 딕셔너리 자료형은 key를 이용하여 값을 조회한다.
- key에 해당하는 값을 바로 조회하기 때문에, 검색/수정하는 속도가 빠르다. ▶ 데이터 검색/수정: O(1)
- # O(n)란 빅-오 표기법(Big-O)으로 나타내는 알고리즘의 시간복잡도이다.

딕셔너리 만들기

중괄호 {} 또는 dict() 함수를 통해 생성할 수 있다.
왼쪽에 있는 값이 key, 오른쪽에 있는 값이 value이다.
key는 중복될 수 없기 때문에, 중복된 key가 존재하는 경우 1개를 제외한 나머지 요소는 무시된다.

dict_1 = {'a':1, 'b':2, 'c':3}	# 딕셔너리 선언1 -> 중괄호 {}
dict_2 = dict(a=1, b=2, c=3)	# 딕셔너리 선언2 -> dict() 함수
print(dict_1)
print(dict_2)

{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3}

딕셔너리 요소 조회하기

인덱싱을 할 때와 비슷하며, 인덱스 대신 key 값을 넣으면 된다.

dict_1 = {'a':1, 'b':2, 'c':3}
dict_1['a']

in 연산자

파이썬에서는 iterable 자료형에 대해 in 연산자를 지원하여, 이를 통해 특정 원소를 찾을 수 있다.
값이 존재하면 True, 없다면 False를 반환한다.
혹은 in 연산자를 이용하여 iterable 자료형의 요소를 나열할 수 있다.

dict_1 = {'a':1, 'b':2, 'c':3}

# 사전 내의 key 값으로 'b'가 있는지 찾음
if 'b' in dict_1:
    print('true')   # key값으로 'b'가 있으면 true
else:
    print('false')  # 없으면 false

true

딕셔너리 요소 추가하기

대괄호 [] 안에 key 값을 넣고, value 값을 매핑하면 된다.

dict_1 = {'a':1, 'b':2, 'c':3}
dict_1['d'] = 4    # 요소 추가하기
print(dict_1)

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

딕셔너리 요소 삭제하기

del 함수를 이용한다.

dict_1 = {'a':1, 'b':2, 'c':3}
del dict_1['c']    # 요소 삭제
print(dict_1)

{'a': 1, 'b': 2}

딕셔너리 관련 메서드

# key 데이터 뽑기 함수 keys

dict_1 = {'a':1, 'b':2, 'c':3}

# key 데이터 뽑기 함수 keys
print(dict_1.keys())

dict_keys(['a', 'b', 'c'])

# value 데이터 뽑기 함수 values

dict_1 = {'a':1, 'b':2, 'c':3}

# value 데이터 뽑기 함수 values
print(dict_1.values())

dict_values([1, 2, 3])

# key, value 쌍 추출 함수 items

dict_1 = {'a':1, 'b':2, 'c':3}

# key, value 쌍 추출 함수 items
print(dict_1.items())

dict_items([('a', 1), ('b', 2), ('c', 3)])

# key 값으로 value 값을 얻는 함수 get

dict_1 = {'a':1, 'b':2, 'c':3}

# key 값으로 value 값을 얻는 함수 get
print(dict_1.get('b'))
print(dict_1.get('d'))  # 값이 없으면 None 반환
print(dict_1.get('d', 'False'))    # 값이 없을 때의 출력을 미리 정할 수 있음

# 간단히 대괄호[] 를 이용하여 추출 가능 (대신 매칭되는 값이 없으면 오류 발생)
print(dict_1['a'])

2
None
False
1

# key, value 쌍 모두 지우기 함수 clear

dict_1 = {'a':1, 'b':2, 'c':3}

# key, value 쌍 모두 지우기 함수 clear
dict_1.clear()
print(dict_1)

{}

셋 자료형 (Set)

집합 자료형이라고도 한다.
중복을 허용하지 않으며, 순서가 없는 자료형이다. ▶ 중복되는 자료를 찾거나, 필터링 하는 데 유용
데이터의 순서가 없어 인덱싱 및 슬라이싱이 불가능하다.
데이터를 검색하는 시간이 빠르다. ▶ 데이터 검색 시간 복잡도: O(1)

셋 만들기

중괄호{} 또는 set() 함수를 이용하여 생성할 수 있다.

# set() 함수 이용
data1 = set([1, 1, 2, 2, 3, 4, 5, 5, 5])

# 중괄호 {} 이용
data2 = {1, 1, 2, 2, 3, 4, 5, 5, 5}

print(data1)
print(data2)

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}

셋 자료형 연산

셋에 대한 기본적인 연산으로 합집합, 교집합, 차집합 연산이 있다.

data1 = {1, 2, 3, 4, 5}
data2 = {1, 3, 5, 7, 9}

print(data1 | data2) # 합집합 / data1.intersection(data2)와 동일
print(data1 & data2) # 교집합 / data1.union(data2)와 동일
print(data1 - data2) # 차집합 / data1.difference(data2)와 동일

{1, 2, 3, 4, 5, 7, 9}
{1, 3, 5}
{2, 4}

셋 관련 메서드

data1 = {1, 2, 3}

# 요소 추가하기 (1개)
data1.add(4)
print(data1)

# 요소 추가하기 (여러개)
data1.update([5, 6, 7])
print(data1)

# 특정 값 제거하기
data1.remove(4)
print(data1)

{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 5, 6, 7}

변수