점프 투 파이썬 - 02

02장 파이썬 프로그래밍의 기초, 자료형

---

[ 숫자형 ]

a = 128		# int (정수형)
b = 1.28	# float (실수형)
c = 0o177	# 8진수 (127)
d = 0xABC	# 16진수 (2748)

 

연산자

+	덧셈
-	뺄셈
*	곱셈
/	나눗셈
**	a ** b → a의 b 제곱
%	나눗셈 후 나머지 리턴
//	나눗셈 후 몫 리턴

 

---

[  문자열 ]

# 문자열을 만드는 방법
string1 = "Hello World"
string2 = 'Python is fun'

string3 = """
Life is too short
You need python
"""					# 여러 줄인 문자열 사용

string4 = '''
First In
Last Out
'''					# 여러 줄인 문자열 사용

string5 = "I'm \n Iron Man"		# 여러 줄인 문자열 사용

 

문자열 연산 + 길이 구하기

head = "Python"
tail = " is fun!"
print(head + tail)

a = "python"
print(a * 2)

b = "Life is too short"
print(len(b))				# 길이 구하기 (파이썬 기본 내장 함수)

Python is fun!
pythonpython
17

 

문자열 인덱싱

a = "Python"
print(a[2])
print(a[0])
print(a[-1])

t
P
n

 

문자열 슬라이싱

a = "Life is too short"
print(a[0:4])
print(a[4:7])
print(a[:4])
print(a[8:])

Life
 is
Life
too short

 

문자열 포매팅

코드	설명
%s	문자열(String)
%c	문자 1개(character)
%d	정수(Integer)
%f	부동소수(floating-point)
%o	8진수
%x	16진수
%%	Literal % (문자 % 자체)

 

number = 3
day = "three"
print("I ate %d apples. so I was sick for %s days." % (number, day))
print("%10s" % "hi")        # 정렬과 공백
print("0.4%f" % 3.42134)     # 소수점 표현하기

print("I eat {0} apples".format(3)) # 숫자 바로 대입하기
print("I eat {0} apples".format("five")) # 문자열 바로 대입하기

print("I ate {0} apples, so Iwas sick for {day} days.".format(10, day=3))	# 인덱스와 이름 혼용

I ate 3 apples. so I was sick for three days.
        hi
0.43.421340
I eat 3 apples
I eat five apples
I ate 10 apples, so Iwas sick for 3 days.

 

문자열 정렬 + 공백 채우기

왼쪽 정렬	:<10 → 왼쪽 정렬 & 10자릿수
오른쪽 정렬	:>
가운데 정렬	:^
공백 채우기	0:■!<10 → 빈 공간 !로 채우기

 

f 문자열 포매팅

name = 'HanTul'
age = 30
print(f'나의 이름은 {name}입니다. 나이는 {age}입니다.')
print(f'나는 내년이면 {age+1}살이 된다.')

나의 이름은 HanTul입니다. 나이는 30입니다.
나는 내년이면 31살이 된다.

 

문자열 관련 함수들

a = 'First In, Last Out'
print(a.count('s'))		# 문자 개수 세기
print(a.find('s'))		# 위치 알려주기 1
print(a.index('i'))		# 위치 알려주기 2

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

print(a.upper())		# 소문자를 대문자로
print(a.lower())		# 대문자를 소문자로

b = ' hi '
print(b.lstrip())		# 왼쪽 공백 지우기
print(b.rstrip())		# 오른쪽 공백 지우기
print(b.strip())		# 양쪽 공백 지우기

c = "Life is too short"
print(c.replace("Life", "Your leg"))	# 문자열 바꾸기
print(c.split())		# 문자열 나누기

2
3
1
a,b,c,d
FIRST IN, LAST OUT
first in, last out
hi 
 hi
hi
Your leg is too short
['Life', 'is', 'too', 'short']

 

 

---

[ 리스트 ]

odd = [1, 3, 5, 7, 9]	# 리스트명 = [요소1, 요소2, 요소3, ...]
a = list()		# 비어있는 리스트

 

리스트 인덱싱 + 슬라이싱

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

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

c = [1, 2, 3, 4, 5]		# 슬라이싱 (문자열과 동일)
print(c[:2])
print(c[2:])

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

 

리스트 연산 + 수정과 삭제

a = [1, 2, 3]
b = [4, 5, 6]
print(a + b)	# 리스트 더하기
print(a * 3)	# 리스트 반복하기

print(len(a))	# 길이 구하기

a[2] = 5	# 리스트 값 수정
print(a)

del a[2]	# 리스트 값 삭제
print(a)

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

 

리스트 관련 함수

a = [1, 2, 3]
a.append(4)		# 리스트에 요소 추가하기
print(a)

b = [4, 3, 1, 2, 7]
b.sort()		# 리스트 정렬
print(b)

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

print(a.index(3))	# 리스트에 값이 존재할 경우 인덱스 리턴

a.insert(0, 4)		# insert(a, b) → 리스트 a번째 위치에 b 삽입
print(a)

a = [1, 2, 3, 1, 2, 3]
a.remove(2)		# remove(x) → 첫 번째로 나오는 x값 삭제
print(a)

print(a.pop())		# 리스트 마지막 요소 리턴 후 삭제
print(a)

print(a.count(1))	# 리스트 안에 값 개수 리턴

a = [1, 2, 3]
a.extend([4, 5])	# extend(x) → x는 리스트만 사용 가능
print(a)
b = [4, 5]
a.extend(b)
print(a)

[1, 2, 3, 4]
[1, 2, 3, 4, 7]
['b', 'c', 'a']
2
[4, 1, 2, 3, 4]
[1, 3, 1, 2, 3]
3
[1, 3, 1, 2]
2
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 4, 5]

 

---

[ 튜플 ]

t1 = ()
t2 = (1, )
t3 = (1, 2, 3)
t4 = 1, 2, 3
t5 = ('a', 'b', ('ab', 'cd'))

 

튜플은 리스트와 거의 비슷하지만, 2가지 차이점이 존재한다.

1개의 요소만을 가질 때는 요소 뒤에 쉼표(, )를 반드시 붙여주어야 하고, t4의 경우처럼 소괄호를 생략해도 된다.

 

또한, 튜플의 요솟값은 지우거나, 변경할 수 없다.

 

t1 = (1, 2, 'a', 'b')
t2 = (3, 4)
t3 = (t1 + t2)		# 튜플 더하기
print(t3)

t3 = t2 * 3		# 튜플 곱하기
print(t3)

print(len(t1))		# 튜플 길이 구하기

(1, 2, 'a', 'b', 3, 4)
(3, 4, 3, 4, 3, 4)
4

 

---

[ 딕셔너리 ]

딕셔너리는 단어 그대로 '사전'이라는 뜻이다. 때문에 딕셔너리는 Key와 Value를 한 쌍으로 가진다.

딕셔너리는 리스트나 튜플처럼 순차적으로 요솟값을 구하지 않고, Key를 통해 Value를 얻는다.

 

딕셔너리의 기본 모습

{Key1: Value1, Key2: Value2, Key3: Value3, ...}

 

딕셔너리의 예

dic = {'name': 'pey', 'phone': '010-0000-1234', 'birth': '1118'}

a = {1: 'hi'}			# Key → 정수값, Value → 문자열

a = {'a': [1, 2, 3]}		# Value에 리스트 삽입

 

딕셔너리 쌍 추가, 삭제

a = {1: 'a'}
a[2] = 'b'		# (딕셔너리)[Key] = (Value) 쌍 추가
print(a)

del a[1]		# del (딕셔너리)[Key] 쌍 삭제
print(a)

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

 

딕셔너리 사용법

딕셔너리에서 Key를 사용해 Value 얻기

age = {'Mike': 12, 'Lily': 17}
print(age['Mike'])		# (딕셔너리)[Key] → Value
print(age['Lily'])

12
17

 

딕셔너리를 만들 때 주의사항

→ Key는 고유한 값이므로 중복되는 Key 값을 설정했을 경우, 하나를 제외한 나머지는 모두 무시된다.

→ Key에 리스트는 사용할 수 없다. 다만, 튜플은 사용가능하다. (값 변경 가능 / 불가능의 차이)

 

딕셔너리 관련 함수

a = {'name': 'Mike', 'age': 12, 'birth': '1214'}
print(a.keys())		# 딕셔너리 a의 Key 모은 뒤 dict_keys 객체 리턴
print(list(a.keys()))	# dict_keys 객체 → 리스트로 변환

print(a.values())	# dict_values 객체 리턴

print(a.items())	# dict_items 객체 리턴 (Key, Value)(튜플)

a.clear()		# 딕셔너리의 모든 요소 삭제
print(a)	

a = {'name': 'Mike', 'age': 12, 'birth': '1214'}
print(a.get('name'))		# get(x) → x라는 Key에 대응하는 Value 리턴
print(a.get('phone', 'N/A'))	# Key가 존재하지 않을 경우, 'N/A' 리턴

print('name' in a)		# 해당 키가 존재 판별 후 True / False 리턴

dict_keys(['name', 'age', 'birth'])
['name', 'age', 'birth']
dict_values(['Mike', 12, '1214'])
dict_items([('name', 'Mike'), ('age', 12), ('birth', '1214')])
{}
Mike
N/A
True

 

---

 

[ 집합 ]

집합(set)은 집합에 관련된 것을 쉽게 처리하기 위한 자료형이다.

s1 = set([1, 2, 3])		# 기본형
print(s1)

s2 = set("Hello")		# set() / 괄호 안에 리스트 or 문자열 입력
print(s2)

s = set()			# 비어있는 집합

{1, 2, 3}
{'o', 'e', 'l', 'H'}

 

집합 자료형의 특징

• 중복을 허용하지 않는다.

     → 때문에 데이터의 중복을 제거하기 위한 필터로 종종 사용된다.

• 순서가 없다. (Unordered)

s1 = set([1, 2, 3])
l1 = list(s1)		# 인덱싱으로 접근 시 리스트 / 튜플 변환 필요
print(l1[0])

t1 = tuple(s1)		# 인덱싱으로 접근 시 리스트 / 튜플 변환 필요
print(t1[2])

 

교집합, 합집합, 차집합

s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

print(s1 & s2)			# 교집합

print(s1 | s2)			# 합집합
print(s1.union(s2))		# 합집합

print(s1 - s2)			# 차집합
print(s1.difference(s2))	# 차집합

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

 

집합 관련 함수

s1 = set([1, 2, 3])
s1.add(4)		# 1개 값 추가
print(s1)

s1.update([4, 5, 6])	# 값 여러 개 추가
print(s1)

s1.remove(2)		# 특정 값 제거
print(s2)

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

 

---

 

[ 불 ( bool ) ]

불(bool) 자료형이란 참(True) 또는 거짓(False)을 나타내는 자료형이다. 불 자료형은 2가지 값만 가질 수 있다.

• True : 참
• False : 거짓

a = True
b = False
print(type(a))		# type(x) → x의 자료형 확인 내장 함수
print(type(b))

<class 'bool'>
<class 'bool'>

 

자료형의 참과 거짓

값	참 or 거짓
"python"	참
""	거짓
[1, 2, 3]	참
[]	거짓
(1, 2, 3)	참
()	거짓
{'a': }	참
{}	거짓
None	거짓

 

불 연산

print(bool('python'))		# 참 / 거짓 식별
print(bool(''))
print(bool(0))

True
False
False

 

---

 

[ 자료형의 값을 저장하는 공간,  변수 ]

변수_이름 = 변수에_저장할_값	# =(assignment) 기호 사용

 

변수가 가리키는 메모리 주소 확인

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

2138928329856

 

리스트를 복사할 때

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

print(id(a))
print(id(b))

print(a is b)		# a와 b가 가리키는 객체가 같을까?

2059247826048
2059247826048
True

 

위의 코드에서 알 수 있듯이, b = a 와 같은 방식으로 b 변수에 a 변수를 대입할 시 동일한 주소를 가리키게 된다.

 

b 변수를 생성하면서 a 변수의 값을 가져옴과 동시에 a와는 다른 주소를 가리키게 하는 방법은 다음과 같다.

 

# 1. [:] 이용하기
a = [1, 2, 3]
b = a[:]

print(a is b)

a[1] = 8
print(a)
print(b)

False
[1, 8, 3]
[1, 2, 3]

 

# 2. copy 모듈 이용하기

from copy import copy
a = [1, 2, 3]
b = copy(a)		# → b = a[:] 와 동일

print(b is a)

False

 

변수를 만드는 여러 가지 방법

a, b = ('python', 'life')
# 위 / 아래 모두 동일한 방법 (튜플로 대입)
(a, b) = 'python', 'life'	# 튜플은 괄호 생략 가능

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

a = b = 'python'		# 여러 개의 변수에 같은 값 대입

a = 3
b = 5
print("변경 전 %d %d" % (a, b))
a, b = b, a			# 두 변수 값 변경
print("변경 후 %d %d" % (a, b))

변경 전 3 5
변경 후 5 3