Introduction to Python I (Python Basics I)

Introduction to Python I (Python Basics I)

2019, Jan 04    
02_1

Introduction to Python I (Python Basics)

by JunPyo Park

Part of the Alpha Square Lecture Series:


파이썬 κΈ°μ΄ˆμ™€ 자료ꡬ쑰, λ¬Έμžμ—΄, 쑰건문, 반볡문 그리고 ν•¨μˆ˜μ— λŒ€ν•΄μ„œ κ°„λ‹¨ν•˜κ²Œ 정리해 λ³΄μ•˜μŠ΅λ‹ˆλ‹€. μ£Όν”Όν„° λ…ΈνŠΈλΆ ν™˜κ²½μ—μ„œ μž‘μ„±ν•œ λ¬Έμ„œμ΄κΈ° λ•Œλ¬Έμ— μ£Όν”Όν„° λ…ΈνŠΈλΆμ„ 켜고 λ”°λΌμ„œ μ‹€μŠ΅ν•΄ λ³΄μ‹œλ©΄ μ‰½κ²Œ μ΄ν•΄ν•˜μ‹€μˆ˜ μžˆμŠ΅λ‹ˆλ‹€.

주석 코드(code comments)

주석 μ½”λ“œλŠ” ν”„λ‘œκ·Έλž˜λ¨Έκ°€ ν”„λ‘œκ·Έλž¨μ˜ μ†ŒμŠ€μ½”λ“œ 상에 λ‚¨κΈ°λŠ” λ©”λͺ¨ μž…λ‹ˆλ‹€. μ£Όμ„μ˜ λͺ©μ μ€ μ†ŒμŠ€ μ½”λ“œλ₯Ό λͺ…ν™•νžˆ ν•˜λŠ”κ²ƒκ³Ό λ”λΆˆμ–΄ λ‹€λ₯Έμ‚¬λžŒλ“€μ΄ μ½”λ“œλ₯Ό μ‰½κ²Œ λ”°λΌκ°ˆ 수 μžˆλ„λ‘ μ•ˆλ‚΄ν•΄μ£ΌλŠ” 역할을 ν•©λ‹ˆλ‹€. μ½”λ“œκ°€ 싀행될 λ•Œ μ£Όμ„μ²˜λ¦¬λœ λͺ¨λ“  λ‚΄μš©μ€ λ¬΄μ‹œλ©λ‹ˆλ‹€. νŒŒμ΄μ¬μ—μ„œ 주석은 # 을 톡해 μž‘μ„±ν•  수 μžˆμŠ΅λ‹ˆλ‹€(# 주석 λ‚΄μš©). #이 ν¬ν•¨λœ 쀄은 μ–΄λ–€ λ‚΄μš©μ„ μž…λ ₯해도 μ£Όμ„μ²˜λ¦¬ λ©λ‹ˆλ‹€.

In [ ]:
# 주석 처리 μ—°μŠ΅
# 이 쀄듀은 ν”„λ‘œκ·Έλž¨μƒμ— μ „ν˜€ 영ν–₯을 μ£Όμ§€ μ•ŠμŠ΅λ‹ˆλ‹€.
# # μ΄ν›„μ˜ μ–΄λ–€ λ‚΄μš©μ΄ 와도 μ½”λ“œλ‘œ μ‹€ν–‰λ˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€.

큰 λ”°μ˜΄ν‘œ μ„Έκ°œλ₯Ό μ‚¬μš©ν•œ 주석(""" 이곳에 μž…λ ΅λœ ν…μŠ€νŠΈ """)을 보신 뢄듀도 μžˆμ„κ²λ‹ˆλ‹€. μ—¬λŸ¬ μ€„μ˜ μ£Όμ„μ²˜λ¦¬λ₯Ό ν•  λ•Œ μ‚¬μš©λ˜κΈ°λ„ ν•˜μ§€λ§Œ μ •ν™•ν•˜κ²Œ λ§ν•˜μžλ©΄ μ΄λŠ” docstring 이라 λΆˆλ¦¬λŠ” λ¬Έμžμ—΄ νƒ€μž…(string)의 νŠΉμˆ˜ν•œ ν˜•νƒœμž…λ‹ˆλ‹€. docstring은 ν•¨μˆ˜μ˜ λͺ©μ κ³Ό κΈ°λŠ₯을 μ„€λͺ…ν•˜λŠ”λ° 주둜 μ‚¬μš©λ©λ‹ˆλ‹€.

In [ ]:
"""docstring : special string"""

주석 μ²˜λ¦¬κ°€ λ˜μ–΄μžˆλŠ” 뢀뢄이 μžˆλ‹€λ©΄ 항상 잘 μ‚΄νŽ΄λ³΄λŠ” μŠ΅κ΄€μ„ κ°€μ§€λŠ” 것이 μ€‘μš”ν•©λ‹ˆλ‹€.

변수(Variables)

λ³€μˆ˜λŠ” 값에 이름을 λΆ™μ—¬ μ‚¬μš©ν•  수 μžˆλ„λ‘ ν•΄μ€λ‹ˆλ‹€. μ–΄λ–€ 값을 μ €μž₯해놓고 λ‚˜μ€‘μ— 반볡적으둜 μ‚¬μš©ν•˜κ²Œ 될 경우, κ·Έ 값에 이름을 λΆ™μ—¬ λ³€μˆ˜μ— μ €μž₯ ν•  수 μžˆμŠ΅λ‹ˆλ‹€. ν”„λ‘œκ·Έλž˜λ°μ—μ„œμ˜ λ³€μˆ˜ μ‚¬μš©μ€ 기본적으둜 μˆ˜ν•™μ—μ„œμ˜ μ‚¬μš©κ³Ό μœ μ‚¬ν•˜λ‹€κ³  μƒκ°ν•˜μ‹œλ©΄ λ©λ‹ˆλ‹€. ν•˜μ§€λ§Œ νŒŒμ΄μ¬μ€ μΆ”κ°€μ μœΌλ‘œ λ³€μˆ˜λ§ˆλ‹€ λ‹€λ₯Έ 데이터 νƒ€μž…μ„ μ œκ³΅ν•©λ‹ˆλ‹€.

였늘 μ‚΄νŽ΄λ³Ό κ°€μž₯ 기본적인 λ³€μˆ˜ νƒ€μž…λ“€μ€ integers(μ •μˆ˜ν˜•), floating point numbers(μ†Œμˆ˜μ ), booleans(μ°Έ/κ±°μ§“), 그리고 strings(λ¬Έμžμ—΄)이 μžˆμŠ΅λ‹ˆλ‹€.

integers(μ •μˆ˜ν˜•)은 μˆ˜ν•™μ—μ„œμ˜ μ •μˆ˜μ™€ κ°™μŠ΅λ‹ˆλ‹€. 파이썬 λ‚΄μž₯ ν•¨μˆ˜μΈ print ν•¨μˆ˜λ₯Ό 톡해 λ³€μˆ˜μ˜ κ°’κ³Ό νƒ€μž…μ„ 좜λ ₯ν•΄ λ³Ό 수 μžˆμŠ΅λ‹ˆλ‹€.

In [3]:
my_integer = 50
print(my_integer, type(my_integer))
50 <class 'int'>

νƒ€μž…μ— 관계없이 λ³€μˆ˜λŠ” λ“±ν˜Έ 기호(=)λ₯Ό 톡해 값을 ν• λ‹Ήν•  수 μžˆμŠ΅λ‹ˆλ‹€. λ³€μˆ˜ 이름은 λŒ€/μ†Œλ¬Έμžλ₯Ό κ΅¬λΆ„ν•˜κΈ°μ— λŒ€/μ†Œλ¬Έμžλ₯Ό λ³€κ²½ν•  경우 μ™„μ „νžˆ λ‹€λ₯Έ λ³€μˆ˜κ°€ λ©λ‹ˆλ‹€.

In [4]:
one = 1
print(One)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-4-6b74af782f90> in <module>()
      1 one = 1
----> 2 print(One)

NameError: name 'One' is not defined

첫 글씨가 λŒ€λ¬ΈμžμΈ One μ΄λΌλŠ” λ³€μˆ˜λŠ” 값이 ν• λ‹Ήλ˜μ§€ μ•Šμ•˜κΈ° λ•Œλ¬Έμ— 였λ₯˜κ°€ λ°œμƒν•©λ‹ˆλ‹€.

float 이라 λΆˆλ €μ§€λŠ” λ³€μˆ˜ νƒ€μž…μ€ μˆ˜ν•™μ—μ„œ μ‹€μˆ˜(real number)λ₯Ό λ‚˜νƒ€λ‚Έλ‹€κ³  μƒκ°ν•˜μ‹œλ©΄ λ©λ‹ˆλ‹€. float λ³€μˆ˜λ₯Ό μ„ μ–Έ ν•˜κΈ° μœ„ν•΄μ„œλŠ” μ†Œμˆ˜μ (.)을 μ°μ–΄μ£Όμ‹œκ±°λ‚˜ ν• λ‹Ήν•˜λ €λŠ” 값이 float μž„μ„ λ‚˜νƒ€λ‚΄ μ£Όμ–΄μ•Ό ν•©λ‹ˆλ‹€.

In [6]:
my_float = 1.0
print(my_float, type(my_float))
my_float = float(1)
print(my_float, type(my_float))
1.0 <class 'float'>
1.0 <class 'float'>

int ν˜•νƒœμ˜ λ³€μˆ˜λ“€μ€ μ†Œμˆ«μ μ„ μž˜λΌλ‚΄ λ²„λ¦¬λŠ” 반면 float ν˜•νƒœλŠ” νŠΉλ³„ν•œ μ§€μ‹œκ°€ μ—†λ‹€λ©΄ μ†Œμˆ«μ μ„ λ°˜μ˜¬λ¦Όν•˜κ±°λ‚˜ μž˜λΌλ‚΄μ§€ μ•ŠμŠ΅λ‹ˆλ‹€. λ”°λΌμ„œ 수치 계산에 μžˆμ–΄μ„œλŠ” float ν˜•νƒœμ˜ λ³€μˆ˜κ°€ 더 μ ν•©ν•˜λ‹€κ³  ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

μ°Έκ³ ) 이전에 데이터 값이 float ν˜•νƒœμž„μ„ λ‚˜νƒ€λ‚΄κΈ° μœ„ν•΄ float()μ΄λΌλŠ” ν•¨μˆ˜λ₯Ό μ‚¬μš©ν•˜μ˜€μŠ΅λ‹ˆλ‹€. 이와 λ§ˆμ°¬κ°€μ§€λ‘œ int() ν•¨μˆ˜λ₯Ό μ‚¬μš©ν•˜μ—¬ 데이터 값을 κ°•μ œλ‘œ int ν˜•νƒœλ‘œ μ²˜λ¦¬ν•˜λ„λ‘ ν•  수 μžˆμŠ΅λ‹ˆλ‹€. μ΄λ•Œ, μ†Œμˆ«μ μ€ 무쑰건 λ²„λ €μ§‘λ‹ˆλ‹€.

In [11]:
my_int = int(3.14159)
print(my_int, type(my_int))
3 <class 'int'>

이λ₯Ό μ‘μš©ν•˜μ—¬ λ‹€μŒκ³Ό 같이 반올림 ν•¨μˆ˜λ₯Ό λ§Œλ“€ 수 μžˆμŠ΅λ‹ˆλ‹€.

In [15]:
x = 3.49
int(x + 0.5)
Out[15]:
3
In [16]:
x = 3.5
int(x + 0.5)
Out[16]:
4

Strings(λ¬Έμžμ—΄) νƒ€μž…μ€ ν…μŠ€νŠΈκ°’μ„ μ €μž₯ν•  수 μžˆμŠ΅λ‹ˆλ‹€. μž‘μ€ λ”°μ˜΄ν‘œ('')λ‚˜ 큰 λ”°μ˜΄ν‘œ("")λ₯Ό μ‚¬μš©ν•˜μ—¬ λ¬Έμžμ—΄ λ³€μˆ˜λ₯Ό ν• λ‹Ήν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [18]:
my_string = 'This is a string with single quotes'
print(my_string)
my_string = "This is a string with double quotes"
print(my_string)
This is a string with single quotes
This is a string with double quotes

μž‘μ€ λ”°μ˜΄ν‘œμ™€ 큰 λ”°μ˜΄ν‘œ λͺ¨λ‘ μ‚¬μš© ν•  수 μžˆκΈ°μ— λ‹€μŒκ³Ό 같이 μž‘μ€ λ”°μ˜΄ν‘œλ‚˜ 큰 λ”°μ˜΄ν‘œ 자체λ₯Ό λ¬Έμžμ—΄μ— μ €μž₯ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [19]:
my_string = '"Jabberwocky", by Lewis Carroll'
print(my_string)
my_string = "'Twas brillig, and the slithy toves / Did gyre and gimble in the wabe;"
print(my_string)
"Jabberwocky", by Lewis Carroll
'Twas brillig, and the slithy toves / Did gyre and gimble in the wabe;

Booleans, λ˜λŠ” bools νƒ€μž…μ€ 이진 λ³€μˆ˜μž…λ‹ˆλ‹€. bool νƒ€μž…μ€ True(μ°Έ)κ³Ό False(κ±°μ§“)쀑 ν•˜λ‚˜μ˜ κ°’λ§Œ κ°€μ§ˆ 수 μžˆμŠ΅λ‹ˆλ‹€. κ·Έλ ‡κΈ° λ•Œλ¬Έμ— 이진 λ³€μˆ˜λΌκ³  λΆˆλ¦¬λŠ”κ²ƒ μž…λ‹ˆλ‹€. 이런 bool νƒ€μž…μ€ ν”„λ‘œκ·Έλž˜λ°μ—μ„œ Logical Operators λΌλŠ” μ΄λ¦„μœΌλ‘œ ν™œμš©λ˜λŠ”λ° μžμ„Έν•œ λ‚΄μš©μ€ μΆ”ν›„ 닀루도둝 ν•˜κ² μŠ΅λ‹ˆλ‹€.

In [20]:
my_bool = True
print(my_bool, type(my_bool))
True <class 'bool'>

νŒŒμ΄μ¬μ—λŠ” μœ„μ—μ„œ μ‚΄νŽ΄λ³Έ 데이터 νƒ€μž… 이외에도 λ§Žμ€ νƒ€μž…λ“€μ΄ μžˆμ§€λ§Œ 이것듀이 κ°€μž₯ 기본적인 데이터 νƒ€μž…μ΄κΈ°μ— μ‚΄νŽ΄λ³΄μ•˜μŠ΅λ‹ˆλ‹€. 이번 νŠœν† λ¦¬μ–Όμ„ μ§„ν–‰ν•˜λ©΄μ„œ μΆ”κ°€μ μœΌλ‘œ λͺ‡κ°€μ§€μ˜ νƒ€μž…λ“€μ„ 더 μ‚΄νŽ΄λ³΄λ„λ‘ ν•˜κ² μŠ΅λ‹ˆλ‹€.

기초 수학연산(Basic Math)

νŒŒμ΄μ¬μ€ 기본적으둜 λ‚΄μž₯된 μˆ˜ν•™ ν•¨μˆ˜λ“€μ„ μ œκ³΅ν•©λ‹ˆλ‹€. math νŒ¨ν‚€μ§€λ₯Ό λΆˆλŸ¬μ™€μ„œ 좔가적인 μˆ˜ν•™ ν•¨μˆ˜λ“€μ„ μ‚¬μš©ν•  μˆ˜λ„ μžˆμŠ΅λ‹ˆλ‹€.

+, -, /, 그리고 * 와 같은 κΈ°λ³Έ 4칙연산이 μ§€μ›λ˜λ©° μ§€μˆ˜ 계산은 **, λ‚˜λ¨Έμ§€(modular)연산은 % 기호둜 계산이 κ°€λŠ₯ν•©λ‹ˆλ‹€.

In [23]:
print('Addition: ', 2 + 2)
print('Subtraction: ', 7 - 4)
print('Multiplication: ', 2 * 5)
print('Division: ', 10 / 2)
print('Exponentiation: ', 3**2)

# 15λ₯Ό 4둜 λ‚˜λˆˆ λ‚˜λ¨Έμ§€
print('Modulo:', 15 % 4)
Addition:  4
Subtraction:  3
Multiplication:  10
Division:  5.0
Exponentiation:  9
Modulo: 3

이런 연산은 λ¬Όλ‘  λ³€μˆ˜μ—κ²Œλ„ 적용이 κ°€λŠ₯ν•©λ‹ˆλ‹€.

In [25]:
first_integer = 4
second_integer = 5
print(first_integer * second_integer)
20
In [30]:
first_integer = 11
second_integer = 3
print(first_integer / second_integer)
3.6666666666666665

이외에 νŒŒμ΄μ¬μ—μ„œ 자주 μ“°μ΄λŠ” μˆ˜ν•™ ν•¨μˆ˜λ“€μ€ λ‹€μŒκ³Ό κ°™μŠ΅λ‹ˆλ‹€.

  • abs()
  • round()
  • max()
  • min()
  • sum()

ν•¨μˆ˜μ΄λ¦„μ—μ„œ μœ μΆ”ν•  수 μžˆλ“― 각각의 κΈ°λŠ₯을 μˆ˜ν–‰ν•©λ‹ˆλ‹€. abs() λŠ” absolute value ν•¨μˆ˜λ‘œμ¨ μ ˆλŒ“κ°’μ„ λ°˜ν™˜ν•©λ‹ˆλ‹€. round() λŠ” 반올림 ν•¨μˆ˜λ‘œ μ§€μ •λœ μ†Œμˆ˜μ  μžλ¦Ώμˆ˜μ— 맞게 반올림된 값을 λ°˜ν™˜ν•©λ‹ˆλ‹€. Default 값은 $0$ μž…λ‹ˆλ‹€. max() 와 min() ν•¨μˆ˜λŠ” μˆ«μžμ—΄(collection of numbers)에 λŒ€ν•΄ 각각 μ΅œλŒ“κ°’κ³Ό μ΅œμ†Ÿκ°’μ„ λ°˜ν™˜ν•©λ‹ˆλ‹€. sum() ν•¨μˆ˜λŠ” μˆ«μžμ—΄μ— λŒ€ν•œ 합을 λ°˜ν™˜ν•©λ‹ˆλ‹€. μˆ«μžμ—΄μ„ νŒŒμ΄μ¬μ—μ„œ μ–΄λ–»κ²Œ ν‘œν˜„ν•˜λŠ”μ§€λŠ” κ³§ μ‚΄νŽ΄λ³΄λ„λ‘ ν•˜κ² μŠ΅λ‹ˆλ‹€.

이외 좔가적인 μˆ˜ν•™ ν•¨μˆ˜λŠ” math νŒ¨ν‚€μ§€λ₯Ό 톡해 뢈러올수 μžˆμŠ΅λ‹ˆλ‹€.

In [1]:
import math

math λΌμ΄λΈŒλŸ¬λ¦¬μ—λŠ” λ‹€μ–‘ν•œ μˆ˜ν•™ν•¨μˆ˜λ“€μ΄ κ΅¬μΆ•λ˜μ–΄ μžˆμŠ΅λ‹ˆλ‹€. μžμ„Έν•œ λ‚΄μš©μ€ documentation을 톡해 확인 κ°€λŠ₯ν•©λ‹ˆλ‹€.

In [38]:
print('Pi: ',math.pi)
print("Euler's Constant: ", math.e)
Pi:  3.141592653589793
Euler's Constant:  2.718281828459045
In [2]:
print('Cosine of pi: ', math.cos(math.pi))
Cosine of pi:  -1.0

기초 자료구조

리스트(Lists)

νŒŒμ΄μ¬μ—μ„œ μ‚¬μš©λ˜λŠ” list(리슀트)λŠ” μˆœμ„œκ°€ μžˆλŠ” 객체의 λͺ¨μŒ(ordered collection of objects)으둜 μ–΄λ–€ 데이터 νƒ€μž…μ΄λΌλ„ 담을 수 μžˆμŠ΅λ‹ˆλ‹€. λ¦¬μŠ€νŠΈλŠ” λŒ€κ΄„ν˜Έ([])λ₯Ό 톡해 μ„ μ–Έ ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [3]:
my_list = [1, 2, 3]
print(my_list)
[1, 2, 3]

λŒ€κ΄„ν˜Έ μ•ˆμ— 인덱슀λ₯Ό μž…λ ₯ν•˜μ—¬ 리슀트 μ•ˆμ˜ λ‚΄μš©(element)에 μ ‘κ·Όν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [4]:
print(my_list[0])
print(my_list[2])
1
3

νŒŒμ΄μ¬μ—μ„œ 인덱싱은 숫자 0λΆ€ν„° μ‹œμž‘ν•©λ‹ˆλ‹€. 길이가 $n$인 λ¦¬μŠ€νŠΈκ°€ μžˆλ‹€λ©΄ 처음 λ‚΄μš©λ¬Όμ€ 인덱슀 번호 $0$λ²ˆμ— μ €μž₯되고 λ‹€μŒ λ‚΄μš©λ¬Όμ€ 인덱슀 번호 $1$λ²ˆμ— μ €μž₯λ©λ‹ˆλ‹€. λ”°λΌμ„œ λ§ˆμ§€λ§‰ λ‚΄μš©λ¬Όμ€ $n-1$번 인덱슀 상에 μ €μž₯되게 λ©λ‹ˆλ‹€. 쑴재 ν•˜μ§€ μ•ŠλŠ” μΈλ±μŠ€μ— μ ‘κ·Όν•  경우 μ—λŸ¬ λ©”μ‹œμ§€κ°€ 좜λ ₯되게 λ©λ‹ˆλ‹€.

In [5]:
print('The first, second, and third list elements: ',
      my_list[0], my_list[1], my_list[2])
print('Accessing outside the list bounds causes an error: ',
      my_list[3])
The first, second, and third list elements:  1 2 3
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-5-c1494c00da9b> in <module>()
      2       my_list[0], my_list[1], my_list[2])
      3 print('Accessing outside the list bounds causes an error: ',
----> 4       my_list[3])

IndexError: list index out of range

λ¦¬μŠ€νŠΈμ— λͺ‡κ°œμ˜ λ‚΄μš©λ¬Όμ΄ μžˆλŠ”μ§€λŠ” len() ν•¨μˆ˜λ₯Ό 톡해 확인할 수 μžˆμŠ΅λ‹ˆλ‹€.

In [6]:
print(len(my_list))
3

λ¦¬μŠ€νŠΈμ— λ‚΄μš©λ¬Όμ„ λ³€κ²½ν•˜κ³  μ‹Άλ‹€λ©΄ λ‹€μŒκ³Ό 같이 ν•΄λ‹Ή 인덱슀 값을 λ°”κΎΈμ–΄ μ£Όλ©΄ λ©λ‹ˆλ‹€.

In [7]:
print(my_list)
my_list[0] = 42
print(my_list)
[1, 2, 3]
[42, 2, 3]

μ΄λŠ” string(λ¬Έμžμ—΄)νƒ€μž…μ΄ μ²˜λ¦¬λ˜λŠ” 방식과 μ™„μ „νžˆ λ‹€λ₯Έ λ°©μ‹μž…λ‹ˆλ‹€. 리슀트 κ΅¬μ‘°λŠ” μœ„μ™€ 같이 λ‚΄μš©λ¬Όμ˜ 변경이 자유둭게 κ°€λŠ₯ν•˜μ§€λ§Œ string νƒ€μž…κ³Ό 같은 λͺ‡λͺ‡ 데이터 νƒ€μž…μ˜ 경우 λ‚΄μš©λ¬Όμ˜ 변경이 λΆˆκ°€λŠ₯ν•©λ‹ˆλ‹€. 이와 같은 λ³€κ²½λΆˆκ°€λŠ₯(immutable) 데이터 νƒ€μž…μ€ 일단 λ§Œλ“€μ–΄μ§€λ©΄ μƒˆλ‘œμš΄ 객체λ₯Ό λ§Œλ“€μ§€ μ•ŠλŠ” 이상 변경이 λΆˆκ°€λŠ₯ ν•©λ‹ˆλ‹€.

In [9]:
my_string = "Strings never change"
my_string[0]
Out[9]:
'S'
In [10]:
my_string[0] = 'Z'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-841c163bd3ef> in <module>()
----> 1 my_string[0] = 'Z'

TypeError: 'str' object does not support item assignment

μœ„μ—μ„œ μ„€λͺ…ν•˜μ˜€λ“― λ¦¬μŠ€νŠΈλŠ” μ–΄λ–€ 데이터 νƒ€μž…λ„ 담을 수 μžˆμŠ΅λ‹ˆλ‹€. λ‹€μŒκ³Ό 같이 리슀트 μ•ˆμ— λ¬Έμžμ—΄μ„ μ €μž₯ ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [11]:
my_list_2 = ['one', 'two', 'three']
print(my_list_2)
['one', 'two', 'three']

λ˜ν•œ λ¦¬μŠ€νŠΈλŠ” λ‹€μŒκ³Ό 같이 μ—¬λŸ¬κ°€μ§€ μ„œλ‘œ λ‹€λ₯Έ νƒ€μž…λ“€μ„ ν•œλ²ˆμ— 담을 수 μžˆμŠ΅λ‹ˆλ‹€.

In [12]:
my_list_3 = [True, 'False', 42]

두 κ°€μ§€ 리슀트λ₯Ό λΆ™μ—¬μ„œ ν•˜λ‚˜λ‘œ λ§Œλ“€κ³  μ‹Άλ‹€λ©΄ λ‹€μŒκ³Ό 같이 + 기호λ₯Ό 톡해 ν•˜λ‚˜μ˜ 리슀트둜 뢙일 수 μžˆμŠ΅λ‹ˆλ‹€.

In [13]:
my_list_4 = my_list + my_list_2 + my_list_3
print(my_list_4)
[42, 2, 3, 'one', 'two', 'three', True, 'False', 42]

Slicing

λ¦¬μŠ€νŠΈμ—μ„œ ν•˜λ‚˜μ˜ 데이터가 μ•„λ‹Œ νŠΉμ • 그룹의 데이터에 μ ‘κ·Όν•˜κ³ μž ν•  λ•Œ μŠ¬λΌμ΄μ‹±(slicing) 기법을 ν™œμš© ν•  수 μžˆμŠ΅λ‹ˆλ‹€. 콜둠(:) 기호λ₯Ό 톡해 리슀트λ₯Ό μŠ¬λΌμ΄μ‹± ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [14]:
my_list = ['friends', 'romans', 'countrymen', 'lend', 'me', 'your', 'ears']
In [15]:
print(my_list[2:4])
['countrymen', 'lend']

μœ„μ™€ 같이 :을 μ‚¬μš©ν•˜μ—¬ 리슀트 μƒμ—μ„œ νŠΉμ • 인덱슀 그룹에 λŒ€ν•œ 선택을 ν•  수 μžˆμŠ΅λ‹ˆλ‹€. 인덱슀 2번 μœ„μΉ˜μ— μžˆλŠ” 데이터 λΆ€ν„° 4번 보닀 μž‘μ€ μœ„μΉ˜μ— μžˆλŠ” 데이터(2이상 4미만)에 μ ‘κ·Όν•œ λͺ¨μŠ΅μž…λ‹ˆλ‹€.

λ‹€μŒκ³Ό 같이 콜둠 뒀에 숫자λ₯Ό λΉ„μš΄λ‹€λ©΄ νŠΉμ • 지점 이후 λͺ¨λ“  데이터에 μ ‘κ·Όν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [16]:
print(my_list[1:])
['romans', 'countrymen', 'lend', 'me', 'your', 'ears']

이와 λΉ„μŠ·ν•˜κ²Œ 콜둠 μ•žμ— 숫자λ₯Ό λΉ„μš΄λ‹€λ©΄ νŠΉμ • 지점 이전 κΉŒμ§€μ˜ 데이터에 μ ‘κ·Όν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [17]:
print(my_list[:4])
['friends', 'romans', 'countrymen', 'lend']

음수 인덱슀λ₯Ό μž…λ ₯ν•  경우 λ§ˆμ§€λ§‰ μΈλ±μŠ€λΆ€ν„° μΉ΄μš΄νŒ… ν•˜μ—¬ ν•΄λ‹Ή 데이터에 μ ‘κ·Ό ν•  수 μžˆμŠ΅λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄ λ‹€μŒκ³Ό 같이 -1μΈλ±μŠ€μ— μ ‘κ·Όν•œλ‹€λ©΄ ν•΄λ‹Ή 리슀트의 λ§ˆμ§€λ§‰ 데이터 값이 좜λ ₯λ©λ‹ˆλ‹€.

In [18]:
print(my_list[-1])
ears

0:7:2 와 같이 μ„Έλ²ˆμ§Έ 숫자λ₯Ό μž…λ ₯ν•˜μ—¬ μŠ¬λΌμ΄μ‹±μ„ ν•  수 μžˆμŠ΅λ‹ˆλ‹€. μ„Έλ²ˆμ§Έ 숫자의 μ˜λ―ΈλŠ” κ±΄λ„ˆλ›Έ κ°„κ²©μ˜ μ‚¬μ΄μ¦ˆ(step size) μž…λ‹ˆλ‹€.

In [19]:
print(my_list[0:7:2])
['friends', 'countrymen', 'me', 'ears']

μœ„μ˜ μ½”λ“œλ₯Ό μžμ„Ένžˆ μ‚΄νŽ΄λ³΄λ©΄ λ¨Όμ € 0:7은 전체 리슀트λ₯Ό μ„ νƒν–ˆμŒμ„ μ˜λ―Έν•©λ‹ˆλ‹€(인덱슀 0μ—μ„œ 6κΉŒμ§€λ₯Ό μ˜λ―Έν•˜κΈ° λ•Œλ¬Έμž…λ‹ˆλ‹€). 그리고 λ§ˆμ§€λ§‰μ— step size '2'λ₯Ό μž…λ ₯ν•˜μ˜€μŠ΅λ‹ˆλ‹€. κ·Έ κ²°κ³Ό 0번, 2번, 4번, 6번 에 ν•΄λ‹Ήν•˜λŠ” 데이터 값듀이 좜λ ₯λ©λ‹ˆλ‹€.

μœ„μ™€ 같이 전체 λ¦¬μŠ€νŠΈμ— λŒ€ν•΄ step sizeλ₯Ό μ μš©ν•  경우 μ•„λž˜ μ½”λ“œμ™€ 같이 μ‹œμž‘κ³Ό 끝 λ²ˆν˜Έμ— ν•΄λ‹Ήν•˜λŠ” 값을 μƒλž΅ν•΄λ„ λ¬΄κ΄€ν•©λ‹ˆλ‹€.

In [20]:
print(my_list[::2])
['friends', 'countrymen', 'me', 'ears']

λͺ¨λ“  숫자λ₯Ό μƒλž΅ν•˜κ³  : 만 μž…λ ₯ν•  경우 μžλ™μ μœΌλ‘œ 전체 리슀트λ₯Ό μ„ νƒν•˜κ²Œ λ©λ‹ˆλ‹€.

In [22]:
print(my_list[:])
['friends', 'romans', 'countrymen', 'lend', 'me', 'your', 'ears']

λ‹€μŒκ³Ό 같이 step size μœ„μΉ˜μ— 음수인 -1을 λ„£μœΌλ©΄ κ°„λ‹¨ν•˜κ²Œ μ—­μˆœμœΌλ‘œ λ°°μ—΄λœ 리슀트λ₯Ό 얻을 수 μžˆμŠ΅λ‹ˆλ‹€.

In [24]:
print(my_list[::-1])
['ears', 'your', 'me', 'lend', 'countrymen', 'romans', 'friends']

numpy와 같은 νŒ¨ν‚€μ§€μ—λŠ” 행렬을 ν‘œν˜„ν•˜λŠ” μžλ£Œκ΅¬μ‘°κ°€ λ”°λ‘œ μžˆμ§€λ§Œ 파이썬 μžμ²΄μ—λŠ” 행렬을 κ΅¬ν˜„ν•˜λŠ” μžλ£Œκ΅¬μ‘°κ°€ λ”°λ‘œ μ—†μŠ΅λ‹ˆλ‹€. λ”°λΌμ„œ 파이썬 μžμ²΄μ—μ„œ 행렬을 κ΅¬ν˜„ν•˜κΈ° μœ„ν•΄μ„œλŠ” 리슀트 μ•ˆμ˜ 리슀트 ꡬ쑰λ₯Ό μ‚¬μš©ν•©λ‹ˆλ‹€.

파이썬의 range()λΌλŠ” λ‚΄μž₯ν•¨μˆ˜λ₯Ό 톡해 리슀트λ₯Ό 생성할 수 μžˆμŠ΅λ‹ˆλ‹€. range()ν•¨μˆ˜λŠ” λͺ‡κ°€μ§€ ν˜•νƒœμ˜ μž…λ ₯을 받을 수 있으며 list() λͺ…령어와 같이 μ‚¬μš©ν•˜μ—¬ μž…λ ₯ 값에 λŒ€ν•œ 리슀트λ₯Ό 얻을 수 μžˆμŠ΅λ‹ˆλ‹€.

(파이썬 2의 경우 range()λ₯Ό λ‹¨λ…μœΌλ‘œ μ‚¬μš©ν•˜λ©΄ 리슀트λ₯Ό 얻을 수 μžˆμ§€λ§Œ 파이썬 3 μ—μ„œλŠ” list(range()) 와 같이 μ‚¬μš©ν•˜μ—¬μ•Ό μ›ν•˜λŠ” 리슀트λ₯Ό 얻을 수 μžˆμŠ΅λ‹ˆλ‹€.)

In [29]:
b = 10
my_list = list(range(b))
print(my_list)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

리슀트 μŠ¬λΌμ΄μ‹± 기법듀을 λ™μΌν•˜κ²Œ μ μš©ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [31]:
a = 3
b = 10
my_list = list(range(a, b))
print(my_list)
[3, 4, 5, 6, 7, 8, 9]
In [33]:
a = 3
b = 10
step = 2
my_list = list(range(a, b, step))
print(my_list)
[3, 5, 7, 9]

튜플(Tuples)

νŠœν”Œ(Tuples) μžλ£Œκ΅¬μ‘°λŠ” λ¦¬μŠ€νŠΈμ™€ λΉ„μŠ·ν•œ 데이터 νƒ€μž…μœΌλ‘œ μ„œλ‘œ λ‹€λ₯Έ μ’…λ₯˜μ˜ 데이터 νƒ€μž…λ“€μ„ λ‚΄μš©λ¬Όλ‘œ κ°€μ§ˆ 수 μžˆμŠ΅λ‹ˆλ‹€. 핡심이 λ˜λŠ” 차이점은 νŠœν”Œμ€ λ³€κ²½λΆˆκ°€λŠ₯(immutable)ν•˜λ‹€λŠ” 것 μž…λ‹ˆλ‹€. λ‚΄μš©λ¬Όλ“€ 사이에 μ‰Όν‘œ(,)λ₯Ό μž…λ ₯ν•˜μ—¬ νŠœν”Œμ„ μ„ μ–Έ ν•  수 μžˆμŠ΅λ‹ˆλ‹€. 일반적으둜 νŠœν”Œμ„ μ„ μ–Έν•  λ•Œ κ΄„ν˜Έ(())λ₯Ό μ‚¬μš©ν•˜μ—¬ λ¬Άμ–΄μ£ΌλŠ” 것이 μ½”λ“œ 가독성에 μ’‹μŠ΅λ‹ˆλ‹€.

In [34]:
my_tuple = 'I', 'have', 30, 'cats'
print(my_tuple)
('I', 'have', 30, 'cats')
In [35]:
my_tuple = ('I', 'have', 30, 'cats')
print(my_tuple)
('I', 'have', 30, 'cats')

μœ„μ—μ„œ μ–ΈκΈ‰ν•˜μ˜€λ“― νŠœν”Œμ€ λ³€κ²½λΆˆκ°€λŠ₯ν•©λ‹ˆλ‹€. μ–΄λ–€ 뢀뢄도 접근을 ν•˜μ—¬ μˆ˜μ •μ΄ λΆˆκ°€λŠ₯ν•©λ‹ˆλ‹€.

In [37]:
# 'cats' 값을 'dogs' 둜 λ°”κΎΈλ € ν•œλ‹€λ©΄ μ—λŸ¬κ°€ λ°œμƒν•©λ‹ˆλ‹€.
my_tuple[3] = 'dogs' 
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-37-aa37fbaae8eb> in <module>()
      1 # 'cats' 값을 'dogs' 둜 λ°”κΎΈλ € ν•œλ‹€λ©΄ μ—λŸ¬κ°€ λ°œμƒν•©λ‹ˆλ‹€.
----> 2 my_tuple[3] = 'dogs'

TypeError: 'tuple' object does not support item assignment

리슀트 μŠ¬λΌμ΄μ‹± 기법을 κ·ΈλŒ€λ‘œ μ‚¬μš©ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [38]:
print(my_tuple[1:3])
('have', 30)

λ¦¬μŠ€νŠΈμ™€ λ§ˆμ°¬κ°€μ§€λ‘œ + 기호λ₯Ό 톡해 ν•©μΉ  수 μžˆμŠ΅λ‹ˆλ‹€.

In [39]:
my_other_tuple = ('make', 'that', 50)
print(my_tuple + my_other_tuple)
('I', 'have', 30, 'cats', 'make', 'that', 50)

λ‹€μŒκ³Ό 같이 νŠœν”Œμ— μžˆλŠ” 값듀을 ν’€μ–΄μ„œ(unpacking) 각 λ³€μˆ˜μ— ν• λ‹Ή ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [40]:
str_1, str_2, int_1 = my_other_tuple
print(str_1, str_2, int_1)
make that 50

μ΄λ ‡κ²Œ 값듀을 풀어쀄 λ•ŒλŠ” νŠœν”Œμ— μžˆλŠ” 값듀이 μˆœμ„œλŒ€λ‘œ μ™Όμͺ½μ— μž…λ ₯ν•œ λ³€μˆ˜λ“€μ— ν• λ‹Ήλ˜μ–΄ μ§‘λ‹ˆλ‹€.

집합(Sets)

μ§‘ν•©(Sets)μžλ£Œκ΅¬μ‘°λŠ” μˆœμ„œκ°€ μ—†κ³ (unordered) μ€‘λ³΅λœ 값을 μ œκ±°ν•˜λŠ” 자료ꡬ쑰 μž…λ‹ˆλ‹€. ν•™μ°½μ‹œμ ˆ μˆ˜ν•™μ±… 맨 μ•žμ— λ‚˜μ™€ μ—΄μ‹¬νžˆ κ³΅λΆ€ν–ˆλ˜ μ§‘ν•©μ˜ κ°œλ…κ³Ό 거의 μœ μ‚¬ν•˜λ‹€κ³  μƒκ°ν•˜μ‹œλ©΄ λ©λ‹ˆλ‹€. Set은 μ€‘κ΄„ν˜Έ ({})λ₯Ό μ‚¬μš©ν•˜μ—¬ μ •μ˜ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [43]:
things_i_like = {'dogs', 7, 'the number 4', 4, 4, 4, 42, 'lizards',
                 'man I just LOVE the number 4'}
print(things_i_like, type(things_i_like))
{'lizards', 4, 'the number 4', 7, 'dogs', 42, 'man I just LOVE the number 4'} <class 'set'>

좜λ ₯ κ²°κ³Όλ₯Ό μ‚΄νŽ΄λ΄€μ„ λ•Œ μ€‘λ³΅λ˜μ–΄ ν¬ν•¨λœ 4λŠ” 쀑볡이 μ œκ±°λ˜μ–΄ ν•œλ²ˆλ§Œ 좜λ ₯된 것을 확인할 수 μžˆμŠ΅λ‹ˆλ‹€.

λ‹€μŒκ³Ό 같이 set() ν•¨μˆ˜λ₯Ό 톡해 리슀트둜 λΆ€ν„° set 자료ꡬ쑰 ν˜•νƒœλ₯Ό λ§Œλ“€μ–΄ λ‚Ό 수 μžˆμŠ΅λ‹ˆλ‹€.

In [45]:
animal_list = ['cats', 'dogs', 'dogs', 'dogs', 'lizards', 'sponges', 
               'cows', 'bats', 'sponges']
animal_set = set(animal_list)
print(animal_set) # λ¦¬μŠ€νŠΈμ—μ„œ μ€‘λ³΅λœ 값을 제거 ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
{'lizards', 'dogs', 'cows', 'sponges', 'cats', 'bats'}

len()ν•¨μˆ˜λ₯Ό ν™œμš©ν•˜μ—¬ λͺ‡ μ’…λ₯˜μ˜ 동물이 μžˆλŠ”μ§€ λ‹€μŒκ³Ό 같이 λ³Ό 수 μžˆμŠ΅λ‹ˆλ‹€.

In [46]:
print(len(animal_set))
6

Set νƒ€μž…μ€ μˆœμ„œκ°€ μ—†κΈ° λ•Œλ¬Έμ— set[0]와 같이 νŠΉμ • 인덱슀 값을 톡해 데이터에 μ ‘κ·Όν•  수 μ—†μŠ΅λ‹ˆλ‹€. ν•˜μ§€λ§Œ λ‹€μŒκ³Ό 같이 μ–΄λ–€ μ›μ†Œκ°€ λ“€μ–΄μžˆλŠ”μ§€ μ²΄ν¬λŠ” κ°€λŠ₯ν•©λ‹ˆλ‹€.

In [47]:
# 'in' ν‚€μ›Œλ“œλ₯Ό μ‚¬μš©ν•˜μ—¬ 'cats' κ°€ animal_set 에 λ“€μ–΄μžˆλŠ”μ§€ 확인가λŠ₯ν•©λ‹ˆλ‹€.
'cats' in animal_set
Out[47]:
True

String 'cats' κ°€ animal_set에 λ“€μ–΄κ°€ 있기 λ•Œλ¬Έμ— True 값이 λ°˜ν™˜λ©λ‹ˆλ‹€.

ν•™μ°½μ‹œμ ˆ 배운 ꡐ집합과 합집합연산을 & 와 | μ—°μ‚°μžλ₯Ό 톡해 κ΅¬ν˜„ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [49]:
# ꡐ집합 연산을 μˆ˜ν–‰ν•˜μ—¬ 좜λ ₯ν•©λ‹ˆλ‹€.
print(animal_set & things_i_like)
{'lizards', 'dogs'}
In [51]:
# ν•©μ§‘ν•© 연산을 μˆ˜ν–‰ν•˜μ—¬ 좜λ ₯ν•©λ‹ˆλ‹€.
print(animal_set | things_i_like)
{'lizards', 4, 'the number 4', 7, 'dogs', 42, 'cows', 'sponges', 'cats', 'man I just LOVE the number 4', 'bats'}

이 외에도 setκ³Ό κ΄€λ ¨λœ λ‹€μ–‘ν•œ 파이썬 λ‚΄μž₯ν•¨μˆ˜λ“€μ„ μ‚΄νŽ΄λ³΄μ‹œλ €λ©΄ 곡식 Documentation 을 확인해 μ£Όμ„Έμš”.

딕셔너리(Dictionaries)

λ”•μ…”λ„ˆλ¦¬λŠ” 또 ν•˜λ‚˜μ˜ κ°€μž₯ μ€‘μš”ν•œ 자료ꡬ쑰 ν˜•νƒœλ‘œ μ€‘κ΄„ν˜Έ({})와 콜둠(:)을 μ‚¬μš©ν•˜μ—¬ μ •μ˜ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

μ€‘κ΄„ν˜ΈλŠ” λ”•μ…”λ„ˆλ¦¬μ˜ 처음과 끝 뢀뢄을 λ‚˜νƒ€λ‚΄κ³  콜둠 κΈ°ν˜ΈλŠ” ν‚€(key) 와 κ°’(value)의 μŒμ„ λ‚˜νƒ€λƒ…λ‹ˆλ‹€. λ”•μ…”λ„ˆλ¦¬λŠ” 본질적으둜 key-value의 쌍으둜 이루어진 μ§‘ν•©(set) 자료ꡬ쑰 μž…λ‹ˆλ‹€. λ”•μ…”λ„ˆλ¦¬μ˜ ν‚€(key)λŠ” λ³€κ²½λΆˆκ°€λŠ₯ν•œ μžλ£Œν˜• 이어야 ν•©λ‹ˆλ‹€. λ”°λΌμ„œ λ¬Έμžμ—΄(string)κ³Ό νŠœν”Œ(tuple)은 ν‚€(key)둜 쓰일 수 μžˆμŠ΅λ‹ˆλ‹€. Key 값듀은 μΆ”κ°€λ˜κ±°λ‚˜ μ‚­μ œκ°€ κ°€λŠ₯ν•©λ‹ˆλ‹€.

μ•„λž˜μ˜ μ˜ˆμ œλŠ” λ”•μ…”λ„ˆλ¦¬λ₯Ό μƒμ„±ν•˜λŠ” μ˜ˆμ œμž…λ‹ˆλ‹€. μ—¬κΈ°μ„œ KeyλŠ” μ±…μ˜ μž₯λ₯΄λ₯Ό λ‚˜νƒ€λ‚΄λŠ” string νƒ€μž…μ˜ 데이터이고 valueλŠ” list νƒ€μž…μœΌλ‘œ ν•΄λ‹Ή Key에 μ†ν•˜λŠ” 책듀을 λ‹΄κ³ μžˆμŠ΅λ‹ˆλ‹€.

In [52]:
my_dict = {"High Fantasy": ["Wheel of Time", "Lord of the Rings"], 
           "Sci-fi": ["Book of the New Sun", "Neuromancer", "Snow Crash"],
           "Weird Fiction": ["At the Mountains of Madness", "The House on the Borderland"]}

λ‹€μŒκ³Ό 같이 접근을 μ›ν•˜λŠ” Keyλ₯Ό μž…λ ₯ν•˜μ—¬ ν•΄λ‹Ήν•˜λŠ” Valueλ₯Ό 확인할 수 μžˆμŠ΅λ‹ˆλ‹€.

In [53]:
print(my_dict["Sci-fi"])
['Book of the New Sun', 'Neuromancer', 'Snow Crash']

μ–΄λ–€ Key값에 μ—°κ²°λœ Valueλ₯Ό 자유둭게 μˆ˜μ •ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

In [54]:
my_dict["Sci-fi"] = "I can't read"
print(my_dict["Sci-fi"])
I can't read

μƒˆλ‘œμš΄ key-value μŒμ„ μΆ”κ°€ ν•˜κ³ μž ν•œλ‹€λ©΄ λ‹€μŒκ³Ό 같이 μ„ μ–Έν•΄ μ£Όλ©΄ λ©λ‹ˆλ‹€.

In [55]:
my_dict["Historical Fiction"] = ["Pillars of the Earth"]
print(my_dict["Historical Fiction"])
['Pillars of the Earth']
In [56]:
print(my_dict)
{'High Fantasy': ['Wheel of Time', 'Lord of the Rings'], 'Sci-fi': "I can't read", 'Weird Fiction': ['At the Mountains of Madness', 'The House on the Borderland'], 'Historical Fiction': ['Pillars of the Earth']}