πŸ“š μŠ€ν„°λ””/파이썬 μŠ€ν„°λ”” κ°•μ˜μžλ£Œ

[4νŒ€/μ΄μ œμ€] 2μ°¨μ‹œ 파이썬 μŠ€ν„°λ”” - μžλ£Œν˜•

μ•Œ 수 μ—†λŠ” μ‚¬μš©μž 2023. 3. 17. 12:39

 

2μ°¨μ‹œ_μžλ£Œν˜•_κ°•μ˜μ•ˆ.pdf
0.66MB
2μ°¨μ‹œ_μžλ£Œν˜•_과제.pdf
0.21MB

01 λ³€μˆ˜μ˜ 이해

λ³€μˆ˜λ₯Ό μ΄ν•΄ν•˜κΈ°μ— μ•žμ„œ

μžλ£Œν˜• - λͺ¨λ“  λ°μ΄ν„°μ—λŠ” μžλ£Œν˜•μ΄ μžˆλ‹€!

이름 λ‚˜μ΄ ν‚€
디솝이 20 160.4
μŠˆλ‹ˆ 21 178.4
string int float

디솝이, μŠˆλ‹ˆ πŸ‘‰ λ¬Έμžμ—΄

20, 21 πŸ‘‰ μ •μˆ˜

160.4, 178.4 πŸ‘‰ μ‹€μˆ˜

 

 

πŸ’‘μ‘°κΈˆ 더 μ•Œμ•„λ³΄λ„λ‘ ν•©μ‹œλ‹€!

 

# 데이터 νƒ€μž… 확인 name = '디솝이'
age = 20
height = 160.4
print(type(name))
print(type(age))
print(type(height))​

<class 'str'> <class 'int'> <class 'float'>

 

 

λ³€μˆ˜λž€?

# λ³€μˆ˜μ™€ κ°’
name = '디솝이'
age = 20
height = 160.4
print(type(name))
print(type(age))
print(type(height))​

값을 μ €μž₯ν•˜λŠ” name, age, height - λ³€μˆ˜

각 λ³€μˆ˜μ— λ“€μ–΄κ°€λŠ” '디솝이', 20, 160.4 - κ°’

 

 

λ³€μˆ˜μ˜ μ˜λ―Έμ™€ μ—­ν• 

λ³€μˆ˜ = 값이 λ“€μ–΄κ°ˆ 수 μžˆλŠ” μƒμž

name = 이름이 λ“€μ–΄κ°ˆ 수 μžˆλŠ” μƒμž (디솝이 μ΄μ™Έμ˜ μŠˆλ‹ˆ, λž‘μ΄, 우치 λ“± λ‹€λ₯Έ 값도 λͺ¨λ‘ λ“€μ–΄κ°ˆ 수 있음!

jelly = "Haribo"
print(jelly)

jelly = “Haribo”

 

  1. jelly의 이름은 Haribo이닀.
  2. jellyλŠ” Haribo이닀.
  3. jelly와 HariboλŠ” κ°™λ‹€.
  4. jelly에 Hariboλ₯Ό 넣어라.

∴ jelly = λ³€μˆ˜, Haribo = κ°’

 

 

 

λ³€μˆ˜ μ‚¬μš© κ·œμ •

- λ³€μˆ˜λͺ… μ„ μ–Έ

 

  πŸ‘‰ 일반적으둜 μ•ŒνŒŒλ²³, 숫자, 밑쀄(_)둜 μ„ μ–Έ (ν•œκΈ€ μ‚¬μš© X)

  πŸ‘‰ λ‹€λ₯Έ μ‚¬λžŒμ΄ 읽어도 이해할 수 μžˆλŠ” μ΄λ¦„μœΌλ‘œ μ„ μ–Έ 

        μ’‹μ•„μš”!πŸ™†‍♂️ : name, professor, age (값을 μ•Œμ•„λ³΄κΈ° 쉽도둝)

         μ§€μ–‘ν•΄μš”πŸ™… : a, b, c (λ³€μˆ˜λ₯Ό μ§€μ •ν•˜λŠ” μ˜λ―Έκ°€ μ—†μ–΄μ§‘λ‹ˆλ‹€…)

  πŸ‘‰ λ³€μˆ˜λͺ…은 λŒ€μ†Œλ¬Έμž ꡬ뢄됨 (Name ≠ name)

 

- λ³€μˆ˜ κ·œμΉ™

1) 영문자(λŒ€, μ†Œλ¬Έμž ꡬ뢄), 숫자, 언더바( _ , underscore), ν•œκΈ€ μ‚¬μš© κ°€λŠ₯ν•˜λ‹€.

2) 첫 μžλ¦¬μ—λŠ” 숫자λ₯Ό μ‚¬μš©ν•  수 μ—†λ‹€. (3age, 5_age, ...)

3) λ³€μˆ˜λͺ…μ˜ λŒ€, μ†Œλ¬ΈμžλŠ” κ΅¬λΆ„λœλ‹€.

4) νŒŒμ΄μ¬μ—μ„œ 자체적으둜 μ‚¬μš©ν•˜κ³ μžˆλŠ” 단어(μ˜ˆμ•½μ–΄)λŠ” μ‚¬μš©ν•  수 μ—†λ‹€.

 

 

naming convention = κ°œλ°œμžλ“€μ˜ μ•½μ†πŸ€™

 

νŒŒμ΄μ¬μ—μ„œλŠ” μ΄λŸ¬ν•œ 약속듀 쀑 κ°€μž₯ 보편적인 것이 PEP-8 방식이고, κ·Έ 쀑 이름과 κ΄€λ ¨λœ μ»¨λ²€μ…˜(Convention)을 μ•Œμ•„λ΄…μ‹œλ‹€!

 

Convention

1) ν•œ λ‹¨μ–΄λ‘œ 된 λ³€μˆ˜λŠ” μ†Œλ¬Έμžλ‘œ μ λŠ”λ‹€ 

  • age, good, name, ...

2) 두 단어 μ΄μƒμ˜ λ³€μˆ˜λŠ” μ–Έλ”λ°”λ‘œ κ΅¬λΆ„ν•œλ‹€.

  • my_name, my_friend_name, ...

3) μ˜ˆμ•½μ–΄μ™€ μΆ©λŒν•  κ²½μš°μ—λŠ” 뒀에 언더바λ₯Ό 뢙인닀.

  • if_, time_, ...

4) μƒμˆ˜*의 경우 λŒ€λ¬Έμžμ™€ 언더바λ₯Ό ν˜Όμš©ν•˜μ—¬ μ“΄λ‹€ (Constant  Variable)λŠ” ν”„λ‘œκ·Έλž¨μ—μ„œ 값이 λ°”λ€Œμ§€ μ•ŠλŠ” λ³€μˆ˜)*

  • TOTAL, MAX_NUM, AVG, ...

 

 

πŸ”—PEP 8 -- https://www.python.org/dev/peps/pep-0008/

*μ΄λ²ˆμ—” κ°œλ°œμžλ“€μ΄ 기본적으둜 μ§€ν‚€λŠ” 관둀같은 κ·œμΉ™λ“€μ„ μ•Œμ•„λ΄…μ‹œλ‹€!

μ‹€μ œ μ½”λ“œλ₯Ό μž‘μ„±ν•˜κ²Œ 될 경우 λ‹€λ₯Έ μ‚¬λžŒμ˜ μ½”λ“œλ₯Ό μ°Έκ³ ν•˜κ±°λ‚˜ λ‹€λ₯Έ μ‚¬λžŒλ“€κ³Ό ν•¨κ»˜ μž‘μ„±ν•˜κ²Œ λ˜λŠ”λ°, μ΄λ•Œ μ„œλ‘œ νŠΉλ³„ν•œ μ„€λͺ… 없이도 이 λ³€μˆ˜, ν•¨μˆ˜λ“€μ΄ μ–΄λ–€ 역할을 ν•˜λŠ”μ§€ μ•Œμ•„λ³΄κΈ° μœ„ν•΄μ„œ κ°œλ°œμžλ“€μ€ 약속을 ν–ˆμŠ΅λ‹ˆλ‹€.

νŒŒμ΄μ¬μ—μ„œλŠ” μ΄λŸ¬ν•œ 약속듀 쀑 κ°€μž₯ 보편적인 것이 PEP-8 λ°©μ‹μž…λ‹ˆλ‹€.

 

PEP 8 – Style Guide for Python Code | peps.python.org

PEP 8 – Style Guide for Python Code Author: Guido van Rossum , Barry Warsaw , Nick Coghlan Status: Active Type: Process Created: 05-Jul-2001 Post-History: 05-Jul-2001, 01-Aug-2013 Table of Contents This document gives coding conventions for the Python co

peps.python.org

 

02 μžλ£Œν˜•κ³Ό κΈ°λ³Έ μ—°μ‚°

πŸ’‘ μ»΄ν“¨ν„°μ˜ 사칙연산을 μ΄ν•΄ν•˜κΈ° μœ„ν•΄ λ©”λͺ¨λ¦¬ 곡간, μžλ£Œν˜•, μ—°μ‚°μžμ™€ ν”Όμ—°μ‚°μžμ— λŒ€ν•΄ μ•Œμ•„λ΄…μ‹œλ‹€!

 

λ©”λͺ¨λ¦¬ 곡간

- λ©”λͺ¨λ¦¬

λ³€μˆ˜ = μ–΄λ– ν•œ 값을 μ €μž₯ν•˜λŠ” μž₯μ†Œ

πŸ€” κ·Έλ ‡λ‹€λ©΄ 이 λ³€μˆ˜λ₯Ό μ €μž₯ν•˜λŠ” 물리적 곡간이 μ–΄λ”˜κ°€μ— μžˆμ–΄μ•Ό… = λ©”λͺ¨λ¦¬

πŸ€— μ •λ¦¬ν•˜μžλ©΄!

  • λ©”λͺ¨λ¦¬ : λ³€μˆ˜μ— 값이 μ €μž₯λ˜λŠ” 곡간
  • λ©”λͺ¨λ¦¬ μ£Όμ†Œ : λ³€μˆ˜μ˜ μ €μž₯ μœ„μΉ˜

- λ©”λͺ¨λ¦¬ 곡간

πŸ€” κ·Έλ ‡λ‹€λ©΄ ν•˜λ‚˜μ˜ λ³€μˆ˜λŠ” μ–΄λŠ μ •λ„μ˜ λ©”λͺ¨λ¦¬ 곡간을 μ‚¬μš©ν• κΉŒμš”?

 

πŸ€— ν•˜λ‚˜μ˜ λ³€μˆ˜λ₯Ό λ©”λͺ¨λ¦¬μ— μ €μž₯ν•  λ•Œ κ·Έ λ³€μˆ˜μ˜ 크기만큼 곡간을 ν• λ‹Ή! (2MB, 1KB…)

 

κ·ΈλŸ¬λ‚˜!

μ»΄ν“¨ν„°λŠ” 0κ³Ό 1 두 가지 μ •λ³΄λ§Œμ„ μ €μž₯ν•  수 있음 πŸ‘‰ μ΄μ§„μˆ˜ μ‚¬μš©!

  • μ΄μ§„μˆ˜ ν•œ 자리 = λΉ„νŠΈ(bit)
  • 8개의 λΉ„νŠΈ = 1λ°”μ΄νŠΈ(byte)
  • 1024λ°”μ΄νŠΈ = 1ν‚¬λ‘œλ°”μ΄νŠΈ(kilobyte, KB)
  • 1024ν‚¬λ‘œλ°”μ΄νŠΈ = 1λ©”κ°€λ°”μ΄νŠΈ(megabyte, MB)

μžλ£Œν˜•

πŸ€” ν• λ‹Ήλ°›λŠ” λ©”λͺ¨λ¦¬ κ³΅κ°„μ˜ 크킀, 즉 λ³€μˆ˜μ˜ ν¬κΈ°λŠ” μ–΄λ–»κ²Œ κ²°μ •λ κΉŒμš”?

πŸ‘‰ λ³€μˆ˜μ˜ μžλ£Œν˜•!

μ •μˆ˜ν˜• (integer type)

  • Cμ–Έμ–΄μ—μ„œ int에 ν•΄λ‹Ήν•˜λŠ” μžλ£Œν˜•. 개수, 번호 λ“± μ •μˆ˜ν˜• 자료λ₯Ό λ‚˜νƒ€λ‚Ό λ•Œ μ‚¬μš©ν•œλ‹€.
  • μžμ—°μˆ˜λ₯Ό 포함해 κ°’μ˜ μ˜μ—­μ΄ μ •μˆ˜λ‘œ ν•œμ •λœ κ°’ (0, 55, -2)

 

a = 154
print(type(a))
b = 0
print(type(b))
c = -25
print(type(c))

 

<class 'int'>

<class 'int'>

<class 'int'>

 

μ‹€μˆ˜ν˜• (floating-point type)

  • Cμ–Έμ–΄μ—μ„œ float, ν˜Ήμ€ double에 ν•΄λ‹Ήν•˜λŠ” μžλ£Œν˜•
  • μ†Œμˆ˜μ μ΄ ν¬ν•¨λœ κ°’ (1.0, 33.4, -0.22)
  • 값이 μ •μˆ˜ν˜•μ΄λΌλ„ 5.0으둜 μž…λ ₯ν•˜λ©΄ μ‹€μˆ˜ν˜•μœΌλ‘œ 해석
b = 181.34
print(type(b))

<class 'float'>

 

λ¬Έμžν˜• (string type)

  • 문자둜 좜λ ₯λ˜λŠ” μžλ£Œν˜•
  • λ”°μ˜΄ν‘œμ— λ“€μ–΄κ°„ 정보
a = "ABC"
b = "10101"
print(type(a), a)
print(type(b), b)

<class 'str'> ABC

<class 'str'> 10101

 

λΆˆλ¦°ν˜•/λ…Όλ¦¬ν˜• (boolean type)

  • μ°Έ λ˜λŠ” 거짓을 ν‘œν˜„ν•  λ•Œ μ‚¬μš©
  • True(μ°Έ)이면 1, False(거짓)이면 0
a = 1
b = 2
print(a > b)

False

 

 

μ—°μ‚°μž

- μ—°μ‚°μžμ™€ ν”Όμ—°μ‚°μž

βœ…ν”Όμ—°μ‚°μž : μ—°μ‚°μžμ— μ˜ν•΄ κ³„μ‚°λ˜λŠ” 숫자

βœ…μ—°μ‚°μž : +, -, *, / 기호

(ex. ‘3 + 2’μ—μ„œ +λŠ” μ—°μ‚°μž, 3κ³Ό 2λŠ” ν”Όμ—°μ‚°μž)

 

- κ°„λ‹¨ν•œ μ—°μ‚°

  • μ‚°μˆ μ—°μ‚°μž (+, -, *, /, **, %, //)

<사칙연산>

>>> a = 10
>>> b = 2.5
>>> a + b
12.5
>>> a - b
7.5
>>> a / b
4.0
>>> a * b
25.0

<제곱승>

>>> print(3*3*3*3*3) #3을 λ‹€μ„― 번 곱함
243
>>> print(3**5) #3의 5제곱
243

 

<λ‚˜λˆ—μ…ˆμ˜ λͺ«κ³Ό λ‚˜λ¨Έμ§€>

>>> print(7 // 2) #7 λ‚˜λˆ„κΈ° 2의 λͺ«
3
>>> print(7 % 2) #7 λ‚˜λˆ„κΈ° 2의 λ‚˜λ¨Έμ§€
1

 

  • λΉ„κ΅μ—°μ‚°μž (==, !=, <>, ≤≥)

 

 

>>> a=10
>>> b=10
>>> c=20
>>> a==b    # 10κ³Ό 10이 κ°™λ‹€.
True 
>>> a!=c    # 10κ³Ό 20이 λ‹€λ₯΄λ‹€.
True
>>> a>c     # 10이 20보닀 크닀.
False
>>> a<c     # 10이 20보닀 μž‘λ‹€.
True
  • *\ν• λ‹Ήμ—°μ‚°μž (+=, -=, =, /=)
>>> a = 1       # λ³€μˆ˜ a에 1을 ν• λ‹Ή
>>> a = a + 1   # a에 1λ₯Ό λ”ν•œ ν›„ κ·Έ 값을 λ‹€μ‹œ a 에 ν• λ‹Ή
>>> print(a)    # a 좜λ ₯
2
>>> a += 1      # a 증가 μ—°μ‚°
>>> print(a)    # a 좜λ ₯
3
>>> a = a -1    # aμ—μ„œ 1을 λΊ€ ν›„ κ·Έ 값을 λ‹€μ‹œ a에 ν• λ‹Ή
>>> a -= 1      # a κ°μ†Œ μ—°μ‚°
>>> print(a)    # a 좜λ ₯
1
>>> a = 5
>>> b = 3.14
>>> a += b      # a 증가 μ—°μ‚° (a = a + b)
>>> print(a)    # a 좜λ ₯
8.14
  • cλ‚˜ μžλ°”μ—μ„œ a++ λ˜λŠ” a--의 의미
  • += : 증가 μ—°μ‚° (a에 λ“€μ–΄κ°€ μžˆλŠ” 값을 1만큼 증가)
  • -= : κ°μ†Œμ—°μ‚° (a에 λ“€μ–΄κ°€ μžˆλŠ” 값을 1만큼 κ°μ†Œ)

 

03 μžλ£Œν˜• λ³€ν™˜

  • μ •μˆ˜ν˜•κ³Ό μ‹€μˆ˜ν˜• κ°„ λ³€ν™˜ πŸ‘‰ float( ) ν•¨μˆ˜λ‚˜ int( ) ν•¨μˆ˜λ₯Ό μ‚¬μš©
  • >>> a = 10
    >>> print(a)
    10
    >>> a = float(10)
    >>> print(a)
    10.0
    
    >>> a = 10
    >>> b = 3
    >>> print(a / b)
    3.3333333333333335
    
    >>> a = int(10.7)
    >>> b = int(10.3)
    >>> print(a + b)
    20
    >>> print(a)
    10
    >>> print(b)
    10
    

 

  • μˆ«μžν˜•κ³Ό λ¬Έμžν˜• κ°„ λ³€ν™˜ πŸ‘‰ μ •μˆ˜ν˜•μ΄λ‚˜ μ‹€μˆ˜ν˜• 값을 λ¬Έμžν˜•μœΌλ‘œ μ„ μ–Έν•˜κΈ° μœ„ν•΄μ„œλŠ” λ°˜λ“œμ‹œ λ”°μ˜΄ν‘œλ₯Ό λΆ™μ—¬ μ„ μ–Έ!
  • >>> a = '76.3'      # a에 λ¬Έμžν˜• 76.3을 ν• λ‹Ή - λ¬Έμžμ—΄μ„ 의미
    >>> b = float(a)    # aλ₯Ό μ‹€μˆ˜ν˜•μœΌλ‘œ λ³€ν™˜ ν›„ b에 ν• λ‹Ή
    >>> print(a)
    76.3
    >> print(b)
    76.3
    >>> print(a + b)    # a와 bλ₯Ό 더함 - λ¬Έμžμ—΄κ³Ό μˆ«μžμ—΄μ˜ λ§μ…ˆμ΄ λΆˆκ°€λŠ₯ν•˜μ—¬ μ—λŸ¬ λ°œμƒ
    Traceback (most recent call last):
    	File "<stdin>", line 1, in <modulo
    TypeError: can only concatenate str (nor "float") to str
    
    >>> a = '76.3'  
    >>> b = float(a)
    >>> a = str(a)
    >>> b = str(b)      # μ‹€μˆ˜ν˜• b값을 λ¬Έμžν˜•μœΌλ‘œ λ³€ν™˜ ν›„ b에 ν• λ‹Ή
    >>> print(a + b)    # 두 값을 λ”ν•œ ν›„ 좜λ ₯
    76.376.3            # λ¬Έμžν˜• κ°„ λ§μ…ˆμ€ λ¬Έμžμ—΄ κ°„ λ‹¨μˆœ μ—°κ²°
    

 

  • μžλ£Œν˜• ν™•μΈν•˜κΈ° πŸ‘‰ μžλ£Œν˜•μ΄ ν—·κ°ˆλ¦΄ λ•Œ type( ) ν•¨μˆ˜ μ‚¬μš©!

 

>>> a = int(10.3)
>>> b = float(10.3)
>>> c = str(10.3)
>>>
>>> type(a)
<class 'int'>
>>> type(b)
<class 'float'>
>>> type(c)
<class 'str'>

10

10.3

10.3

 

04 리슀트의 이해

리슀트λ₯Ό μ΄ν•΄ν•˜κΈ° μ•žμ„œ…

리슀트 μžλ£Œν˜• : ν”„λ‘œκ·Έλž˜λ° μ–Έμ–΄μ—μ„œ κ°€μž₯ 많이 μ‚¬μš©ν•˜λŠ” μžλ£Œν˜•μœΌλ‘œ λ°°μ—΄array이라고도 ν•œλ‹€.

πŸ‘‰ ν•œ 개의 λ³€μˆ˜μ— λ‹€μ–‘ν•œ 값을 μ €μž₯ν•  수 μžˆλ‹€!

 

λ¦¬μŠ€νŠΈλž€?

  • 리슀트의 κ°œλ…
    • λ‹€μ–‘ν•œ μžλ£Œν˜• μ €μž₯ κ°€λŠ₯
    • C ν˜Ήμ€ μžλ°”μ—μ„œ λ°°μ—΄μ΄λΌλŠ” κ°œλ…κ³Ό μœ μ‚¬λ¦¬μŠ€νŠΈ(list) : ν•˜λ‚˜μ˜ λ³€μˆ˜μ— μ—¬λŸ¬ 값을 μ €μž₯ν•˜λŠ” μžλ£Œν˜•(μ‹œν€€μŠ€ μžλ£Œν˜•)
    • μ‹œν€€μŠ€ μžλ£Œν˜• : μ—¬λŸ¬ 데이터λ₯Ό ν•˜λ‚˜μ˜ λ³€μˆ˜μ— μ €μž₯ν•˜λŠ” 기법. μ—¬λŸ¬ 자료λ₯Ό μˆœμ„œλŒ€λ‘œ λ„£λŠ”λ‹€λŠ” 뜻.
  • ν˜•νƒœ
  • 리슀트 이름 = [μš”μ†Œκ°’1, μš”μ†Œκ°’2, μš”μ†Œκ°’3, ···]
    리슀트 이름 = []  # 빈 리슀트
    food = ['짜μž₯λ©΄', '짬뽕', 'λ§ˆλΌνƒ•', ···]
    
  • νŠΉμ§• : μžλ£Œν˜•μ„ 톡일해주지 μ•Šμ•„λ„ λœλ‹€.
  • >>> mylist = [1, 2, 'μΉ΄λ¦¬λ‚˜', True, ['a', 'b', 'c']]
    >>> mylist
    [1, 2, 'μΉ΄λ¦¬λ‚˜', True, ['a', 'b', 'c']]
    
    μœ„μ™€ 같이 μ—¬λŸ¬ μ’…λ₯˜μ˜ μžλ£Œν˜•μ„ μ„žμ–΄μ„œ 넣어도 λͺ¨λ‘ μ €μž₯이 λœλ‹€.

 

인덱싱과 μŠ¬λΌμ΄μ‹±

πŸ’‘ λ¦¬μŠ€νŠΈλŠ” μΈλ±μ‹±μ„ ν™œμš©ν•΄μ„œ n번째의 값에 μ ‘κ·Όν•  수 있고, μŠ¬λΌμ΄μ‹±μ„ ν™œμš©ν•΄μ„œ ν•„μš”ν•œ 만큼 μž˜λΌμ„œ μ“Έ 수 μžˆλ‹€.

 

  • 인덱싱 & λ¦¬λ²„μŠ€ 인덱싱
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

aλΌλŠ” λ¦¬μŠ€νŠΈμ— 값이 1λΆ€ν„° 10κΉŒμ§€ μˆœμ„œλŒ€λ‘œ λ“€μ–΄κ°€ μžˆλŠ”λ°, μ—¬κΈ°μ„œ 5번째, ν˜Ήμ€ 8번째의 값에 μ ‘κ·Όν•˜κ³ μž ν•  λ•Œ λ‹€μŒκ³Ό 같이 μ‚¬μš©ν•˜λ©΄ λœλ‹€.

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[4]
5
>>> a[7]
8
>>> a[-1]
10
>>> a[-5]
6

πŸ’‘μΈλ±μŠ€λŠ” 0μ—μ„œλΆ€ν„° μ‹œμž‘ν•œλ‹€.

 

μ˜ˆμ‹œμ—μ„œ, a[4]라고 μ ν˜€μžˆλŠ”λ° 5번째 값인 5λ₯Ό 읽어왔닀.

πŸ‘‰μ΄λŠ”, μΈλ±μŠ€κ°€ 0μ—μ„œλΆ€ν„° μ‹œμž‘ν•˜κΈ° λ•Œλ¬Έμ΄λ‹€! λ”°λΌμ„œ μœ„μ˜ μ˜ˆμ‹œμ—μ„œ 1을 좜λ ₯ν•˜κ³  μ‹Άλ‹€λ©΄ a[0]을 좜λ ₯ν•˜λ©΄ λœλ‹€.

κ·ΈλŸ¬λ‚˜, 음수둜 μΈλ±μ‹±ν•œλ‹€λ©΄ λ’€μ—μ„œλΆ€ν„° μ½μ–΄λ“€μ–΄μ˜¨λ‹€.

πŸ‘‰μ΄ λ•ŒλŠ” 0λΆ€ν„° μ‹œμž‘ν•˜μ§€ μ•Šκ³  -1λΆ€ν„° μ‹œμž‘ν•œλ‹€! (λ¦¬λ²„μŠ€ 인덱싱)

 

 

- μŠ¬λΌμ΄μ‹±

 

μŠ¬λΌμ΄μ‹±μ„ μ‚¬μš©ν•˜λ©΄ λ¦¬μŠ€νŠΈμ—μ„œ μΌλΆ€λΆ„λ§Œ ν•„μš”ν•˜λ‹€λ©΄ μž˜λΌμ„œ μ“Έ 수 μžˆλ‹€.

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[0:3]
[1, 2, 3]
>>> a[1:3]
[2, 3]
>>> a[:3]
[1, 2, 3]
>>> a[7:]
[8, 9, 10]
>>> a[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a[-4:-2]
[7, 8]

 

a[ x : y ] 라고 μ“°λ©΄ a[ x ]λΆ€ν„° a[ y ]μ „κΉŒμ§€μ˜ 값이 좜λ ₯λœλ‹€λŠ” 것을 μ•Œ 수 μžˆλ‹€.

 

즉, μŠ¬λΌμ΄μ‹±μ—μ„œλŠ” μ²«λ²ˆμ§Έ 인덱슀 ~ λ§ˆμ§€λ§‰ 인덱슀 숫자의 -1λ²ˆμ§ΈκΉŒμ§€ 좜λ ₯ν•΄μ€€λ‹€.

 

ex) a[ 2 : 7 ] = a[2] ~ a[7-1] = a[2] ~ a[6]κΉŒμ§€ 좜λ ₯ = [3, 4, 5, 6, 7] 좜λ ₯

 

a[ 7: ]은 7λ²ˆλΆ€ν„° λκΉŒμ§€ 좜λ ₯ν•΄μ€€λ‹€!

a[ : ]은 μ²˜μŒλΆ€ν„° λκΉŒμ§€ 좜λ ₯ν•΄μ€€λ‹€!

 

 

- 증가값(step)

ν˜•νƒœ - λ³€μˆ˜λͺ…[ μ‹œμž‘ 인덱슀 : λ§ˆμ§€λ§‰ 인덱슀 : 증가값 ]

>>> cities = ['μ„œμšΈ', 'λΆ€μ‚°', '인천', 'λŒ€κ΅¬', 'λŒ€μ „', 'κ΄‘μ£Ό', 'μšΈμ‚°', 'μˆ˜μ›']
>>> cities[::2]  # 2μΉΈ λ‹¨μœ„λ‘œ
['μ„œμšΈ', '인천', 'λŒ€μ „', 'μšΈμ‚°']
>>> cities[::-1]  # μ—­μœΌλ‘œμŠ¬λΌμ΄μ‹±
['μˆ˜μ›', 'μšΈμ‚°', 'κ΄‘μ£Ό', 'λŒ€μ „', 'λŒ€κ΅¬', '인천', 'λΆ€μ‚°', 'μ„œμšΈ']

 

cities[ : : 2 ]λ₯Ό μž…λ ₯ν•˜λ©΄ μ²˜μŒλΆ€ν„° μ‹œμž‘ν•˜μ—¬ 2μΉΈ κ°„κ²©μœΌλ‘œ 좜λ ₯λœλ‹€.

cities[ : : -1 ]λ₯Ό μž…λ ₯ν•˜λ©΄ μ—­λ°©ν–₯으둜 1μΉΈ κ°„κ²©μœΌλ‘œ 좜λ ₯λœλ‹€.

 

 

리슀트 μ‚¬μš©λ²•

 

- 리슀트의 μ—°μ‚°

λ§μ…ˆ μ—°μ‚°

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]

κ³±μ…ˆ μ—°μ‚°

>>> a = [1, 2, 3]
>>> a * 2
>>> a = [1, 2, 3, 1, 2, 3]

in μ—°μ‚°

 

in 연산은 포함 μ—¬λΆ€λ₯Ό ν™•μΈν•˜λŠ” μ—°μ‚°μœΌλ‘œ ν•˜λ‚˜μ˜ 값이 ν•΄λ‹Ή λ¦¬μŠ€νŠΈμ— λ“€μ–΄μžˆλŠ”μ§€ 확인할 수 μžˆλ‹€.

>>> a = [1, 2, 3]  # a λ³€μˆ˜μ—μ„œ λ¬Έμžμ—΄ '3'κ³Ό 숫자 3의 쑴재 μ—¬λΆ€ λ°˜ν™˜
>>> '3' in a
False
>>> 3 in a
True

 

 

- 리슀트 μΆ”κ°€, μˆ˜μ • 및 μ‚­μ œ

  • append( ) ν•¨μˆ˜

append( ) ν•¨μˆ˜λ₯Ό μ‚¬μš©ν•˜λ©΄ 리슀트 맨 λ§ˆμ§€λ§‰ μΈλ±μŠ€μ— μƒˆλ‘œμš΄ 값을 μΆ”κ°€ν•  수 μžˆλ‹€.

>>> a = [1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
  • extend( ) ν•¨μˆ˜

extend( ) ν•¨μˆ˜λŠ” 리슀트의 λ§μ…ˆ μ—°μ‚°κ³Ό κ°™λ‹€. 즉, 값을 μΆ”κ°€ν•˜λŠ” 것이 μ•„λ‹Œ κΈ°μ‘΄ λ¦¬μŠ€νŠΈμ— κ·ΈλŒ€λ‘œ μƒˆλ‘œμš΄ 리슀트λ₯Ό ν•©μΉ˜λŠ” κΈ°λŠ₯을 ν•œλ‹€.a.extend([4, 5])λŠ” a += [4, 5]와 λ™μΌν•˜λ‹€.

>>> a = [1,2,3]
>>> a.extend([4,5])
>>> a
[1, 2, 3, 4, 5]
>>> b = [6, 7]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, 7]
  • insert( ) ν•¨μˆ˜

insert( ) ν•¨μˆ˜λŠ” append( ) ν•¨μˆ˜μ™€ 달리 리슀트의 νŠΉμ • μœ„μΉ˜μ— 값을 μΆ”κ°€ν•œλ‹€. insert(a, b)λŠ” 리슀트의 a번째 μœ„μΉ˜μ— bλ₯Ό μ‚½μž…ν•˜λŠ” ν•¨μˆ˜μ΄λ‹€. νŒŒμ΄μ¬μ€ 숫자λ₯Ό 0λΆ€ν„° μ„Όλ‹€λŠ” 것을 λ°˜λ“œμ‹œ κΈ°μ–΅ν•˜μž.

>>> a = [1, 2, 3]
>>> a.insert(0, 4)
>>> a
[4, 1, 2, 3]
  • remove( ) ν•¨μˆ˜

remove(x) ν•¨μˆ˜λŠ” λ¦¬μŠ€νŠΈμ—μ„œ 첫 번째둜 λ‚˜μ˜€λŠ” xλ₯Ό μ‚­μ œν•˜λŠ” ν•¨μˆ˜μ΄λ‹€. μ‚­μ œν•  값을 remove( ) ν•¨μˆ˜ μ•ˆμ— λ„£μœΌλ©΄ λ¦¬μŠ€νŠΈμ— μžˆλŠ” ν•΄λ‹Ή 값이 μ‚­μ œλœλ‹€.

>>> a = [1, 2, 3, 1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 3]
  • 인덱슀 μˆ˜μ •(μž¬ν• λ‹Ή)
>>> a = [1, 2, 3]
>>> a[2] = 4
>>> a
[1, 2, 4]

a[2]의 μš”μ†Ÿκ°’ 3이 4둜 λ°”λ€Œμ—ˆλ‹€.

  • del ν•¨μˆ˜
>>> a = [1, 2, 3, 4, 5]
>>> del a[2:]
>>> a
[1, 2]

a[2:]에 ν•΄λ‹Ήν•˜λŠ” 리슀트의 μš”μ†Œλ“€μ΄ μ‚­μ œλ˜μ—ˆλ‹€.

 

 

νŒ¨ν‚Ήκ³Ό μ–ΈνŒ¨ν‚Ή

- νŒ¨ν‚Ή(packing) : ν•œ λ³€μˆ˜μ— μ—¬λŸ¬ 개의 데이터λ₯Ό ν• λ‹Ήν•˜λŠ” κ·Έ 자체, 리슀트 자체

- μ–ΈνŒ¨ν‚Ή(unpacking) : ν•œ λ³€μˆ˜μ— μ—¬λŸ¬ 개의 데이터가 λ“€μ–΄μžˆμ„ λ•Œ 그것을 각각의 λ³€μˆ˜λ‘œ λ°˜ν™˜ν•˜λŠ” 방법

  • >>> t = [1, 2, 3]  # 1, 2, 3을 λ³€μˆ˜ t에 νŒ¨ν‚Ή
    >>> a, b, c = t  # t에 μžˆλŠ” κ°’ 1, 2, 3을 λ³€μˆ˜ a, b, c에 μ–ΈνŒ¨ν‚Ή
    >>> print(t, a, b, c)
    [1, 2, 3] 1 2 3
    
    μ–ΈνŒ¨ν‚Ή μ‹œ ν• λ‹Ήλ°›λŠ” λ³€μˆ˜μ˜ κ°œμˆ˜κ°€ μ κ±°λ‚˜ 많으면 λͺ¨λ‘ μ—λŸ¬κ°€ λ°œμƒ

 

이차원 리슀트 πŸ‘‰ ν–‰λ ¬κ³Ό 같은 κ°œλ…

학생 A B C
κ΅­μ–΄ 점수 49 [0][0] 79 [0][1] 20 [0][2]
μˆ˜ν•™ 점수 43 [1][0] 56 [1][1] 85 [1][2]

이차원 λ¦¬μŠ€νŠΈλŠ” ν‘œμ— 값을 채웠을 λ•Œ μƒκΈ°λŠ” κ°’λ“€μ˜ 집합!

κ΅­μ–΄μ μˆ˜, μˆ˜ν•™μ μˆ˜ : ν•˜λ‚˜μ˜ 리슀트

 

μ—¬λŸ¬ 개의 리슀트 값듀이 λͺ¨λ‘ ν•˜λ‚˜μ˜ 리슀트 λ³€μˆ˜μ— ν• λ‹Ήλ˜λ©΄ 그것이 이차원 리슀트

>>> kor_score = [49, 79, 20]
>>> math_score = [43, 59, 85]
>>> midterm_score = [kor_score, math_score]
>>> midterm_score
[[49, 79, 20], [43, 59, 85]]
>>> print(midterm_score[0][2])
20

print(midterm_score[0][2]) μ—μ„œ [0]은 ν–‰, [2]λŠ” 열을 λœ»ν•œλ‹€.