ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ฝ๋ ๋ธ๋ก์ ๋ฐ๋ณตํ๋ ๋ก์ง. ๋ณดํต ๋ฐ๋ณต์๋ ์๋์ ๊ฐ์ ํํ๋ฅผ ๊ฐ์ง๊ณ ์๋๋ฐ, python์ ์ ํต์ ์ธ for loop๋ฅผ ๊ฐ๊ณ ์์ง ์๋ค. python์ javascript ์ฒ๋ผ initializer, condition ๋๋ iterator ๋ถ๋ถ์ด ์๋ค.
for (initializer; condition; iterator)
body
//javascript for loop
let numbers = [10, 12, 15, 18, 20];
for (let i = 0; i < numbers.length; i += 1) {
console.log(numbers[i])
}
# python for loop
numbers = [10, 12, 15, 18, 20]
for number in numbers:
print(number) # list์ ์๋ ์์ ํ๋์ฉ print ํด์ฃผ์ธ์
member๋ฅผ ํ ๋ฒ์ ํ๋์ฉ ๋ฐํํ ์ ์๋ object๋ฅผ ๋งํ๋ค. iterable์ด iter() method๋ฅผ passํ ๋ iterator๋ฅผ ๋ง๋ค๊ณ , __next__
method๋ฅผ ์ฌ์ฉํด iterable ๊ฐ์ฒด๋ฅผ ๋ฐ๋ณตํ๋ค. iterator๋ __next__
method๋ฅผ ๊ฐ๊ณ ์๊ณ , ๊ฐ์ฒด์ ๋ค์ ์์ดํ
์ ๋ฆฌํดํ๋ค.
sequence๊ฐ iterable type์ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์๋ค. built-in sequnece type์ list, string, tuple์ด๋ค. ๊ทธ๋ฐ์๋ ๋์ ๋๋ฆฌ, ํ์ผ ๊ฐ์ฒด, set, generator๊ฐ ๋ฐ๋ณต ๊ฐ๋ฅํ์ง๋ง sequence๋ ์๋๋ค.
Note that every iterator is also an iterable, but not every iterable is an iterator.
๋ชจ๋ ๋ฐ๋ณต์๋ ๋ฐ๋ณต ๊ฐ๋ฅํ์ง๋ง, ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๊ฐ ๋ชจ๋ ๋ฐ๋ณต์๋ ์๋๋ค. ์๋ฅผ๋ค์ด ๋ฆฌ์คํธ๋ ๋ฐ๋ณต ๊ฐ๋ฅํ์ง๋ง ๋ฐ๋ณต์๋ ์๋๋ค. iterator๋ iterable์ iter() ํจ์๋ฅผ ์จ์ ๋ง๋ค์ด์ง๋ค. ์ด๋ฅผ ๊ฐ๋ฅํ๊ฒ ๋ง๋ค๋ ค๋ฉด ๊ฐ์ฒด์ ํด๋์ค๊ฐ
__iter__
method(iterator๋ฅผ return)์ 0์ผ๋ก ์์ํ๊ณ ์ฐ์์ ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง__getitem
method๊ฐ ํ์ํ๋ค.
list, set, dic ๋ฑ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํด๋น ์์๋ฅผ ํ ๋ฒ์ ํ๋์ฉ ์ํ๋ ๋ก์ง์ ์คํํ ์ ์๊ฒ ํ๋ค.
์กฐ๊ฑด์ ๋ง์กฑํ๊ณ for๊ตฌ๋ฌธ์์ ์์ ํ ๋น ์ ธ๋์ค๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค.
my_list=[1,2,3,4,5]
for element in my_list:
if condition:
do something
break # ๋ฐ๋ณต๋ฌธ์ ๋ฉ์ถ๋ ๋ฐฉ๋ฒ
else:
do_something_with_element
break ์ฒ๋ผ ์์ ํ ๋น ์ ธ๋์ค์ง ์์ง๋ง, ๋ค์ iteration์ผ๋ก ๋์ด๊ฐ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค.
cats = ["๋ง๋ธ", "์น์ฆ", "์นด์ค์ค", "์บกํด", "ํฑ์๋"]
for cat in cats:
if cat !="์บกํด":
print("์ง๊ธ์ ์บกํด ๋ฐฅ์ค ์๊ฐ")
continue
else:
print("์บกํด ๋ฐฅ๋จน์!")
'''result:
์ง๊ธ์ ์บกํด ๋ฐฅ์ค ์๊ฐ
์ง๊ธ์ ์บกํด ๋ฐฅ์ค ์๊ฐ
์ง๊ธ์ ์บกํด ๋ฐฅ์ค ์๊ฐ
์บกํด ๋ฐฅ๋จน์!
์ง๊ธ์ ์บกํด ๋ฐฅ์ค ์๊ฐ
'''
python์ loop ์์์ ๋ ํ๋์ loop๋ฅผ ์ธ ์ ์๋๋ก ํ๋ค.
numbers1 = [1, 2, 3, 4, 5]
numbers2 = [10, 20, 30, 40, 50]
for num1 in numbers1:
for num2 in numbers2:
print(f"{num1} * {num2} == {num1 * num2}")
์๋ฃ ๊ตฌ์กฐ ๊ธฐ๋ฐ์ด ์๋๋๋ผ๋ ์ฝ๋ ๋ธ๋ก์ ๋ฐ๋ณตํด์ผ ํ ๋. ํน์ ์กฐ๊ฑด๋ฌธ์ด True์ผ ๋์ ์ฝ๋๋ธ๋ก์ ๋ฐ๋ณต ์คํํ๋ค.
False์ด๋ฉด ๋ฉ์ถ๋ค. for๋ฌธ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก break์ continue๊ฐ ์๋ค.
while <์กฐ๊ฑด๋ฌธ>:
<์ํํ ๋ฌธ์ฅ1>
<์ํํ ๋ฌธ์ฅ2>
...
<์ํํ ๋ฌธ์ฅN>
if๋ฌธ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก while์ ์กฐ๊ฑด๋ฌธ์ด false์ด๋ฉด ์คํ๋๋ค. ์ฆ, while๋ฌธ์ด ์ข ๋ฃ๋๋ฉด else๋ฌธ์ด ์คํ๋๋ค๋ ๋ป์ด๋ค.
while <์กฐ๊ฑด๋ฌธ>:
<์ํํ ๋ฌธ์ฅ1>
<์ํํ ๋ฌธ์ฅ2>
<์ํํ ๋ฌธ์ฅ3>
...
<์ํํ ๋ฌธ์ฅN>
else:
<while๋ฌธ์ด ์ข
๋ฃ๋ ํ ์ํํ ๋ฌธ์ฅ>
dictionary๋ฅผ ์ฌ์ฉํ for๋ฌธ์์๋ ๊ฐ ์์์ key๋ง ๋ฆฌํดํ๊ณ , key๊ฐ์ ํตํด value๋ฅผ ์ฝ์ด๋ค์ด๋ ๊ตฌ์กฐ๋ค.
cats = [ "์ฒซ์งธ":"์บกํด", "๋์งธ":"๋ง๋ธ"]
for cat in cats:
print(f'{cat} ๊ณ ์์ด๋ {cats[cat]}์
๋๋ค')
'''result:
์ฒซ์งธ ๊ณ ์์ด๋ ์บกํด์
๋๋ค
๋์งธ ๊ณ ์์ด๋ ๋ง๋ธ์
๋๋ค
'''
dict์ value๋ผ๋ ํจ์๋ฅผ ์์ฑ์ผ๋ก ๊ฐ์ง๊ณ ์๋ค. ์ธ๋ฑ์ค๋ฅผ ์ธ ํ์ ์์ด, ๋ฐ๋ณต๋๋ ๋์ ๋๋ฆฌ์ ํค๊ฐ์ ๋ฐ๋ก ๋ถ๋ฌ์ฌ ์ ์๋ค.
cats = [ "์ฒซ์งธ":"์บกํด", "๋์งธ":"๋ง๋ธ"]
for cat in cats.value():
print(f'๊ณ ์์ด ์ด๋ฆ์ {cat}์
๋๋ค')
'''result:
๊ณ ์์ด ์ด๋ฆ์ ์บกํด์
๋๋ค
๊ณ ์์ด ์ด๋ฆ์ ๋ง๋ธ์
๋๋ค
'''
key์ value ๊ฐ ๋ ๋ค ๊ฐ์ง๊ณ for ๋ฐ๋ณต๋ฌธ์ ์คํํ๋ ๋ฐฉ๋ฒ์ด๋ค. key์ value๋ฅผ ํํ๋ก ๋ฆฌํดํด์ค๋ค.
cats = [ "์ฒซ์งธ":"์บกํด", "๋์งธ":"๋ง๋ธ"]
for cats_key, cats_value in cats.items():
print(f'{cats_key} ๊ณ ์์ด๋ {cats_value}์
๋๋ค')
'''result:
์ฒซ์งธ ๊ณ ์์ด๋ ์บกํด์
๋๋ค
๋์งธ ๊ณ ์์ด๋ ๋ง๋ธ์
๋๋ค
'''
Scope์ ๋ฒ์๋ผ๋ ๋ป์ด๋ค. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ scope์ ์ด๋ ํ ๊ฐ์ฒด (๋ณ์, ํจ์ ๋ฑ)๊ฐ ์ ํจํ ๋ฒ์๋ฅผ ๋งํ๊ณ , ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ฉด ํด๋น ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
Python์์ scope์ ํญ์ ๊ฐ์ฒด๊ฐ ์ ์ธ๋ ์ง์ ์์ ์๋ก๋ ์์ ๊ฐ์ฒด ๊น์ง, ์๋๋ก๋ ๋ชจ๋ ํ์ ๊ฐ์ฒด๋ค๊ณผ ๊ทธ ์์๊น์ง๊ฐ ๋ฒ์์ด๋ค.
์์: Local => Enclosing => Global => Built-in
๋์ผํ ์ด๋ฆ์ ๋ณ์๊ฐ ๋ค๋ฅธ scope์์ ์ ์ธ๋๋ฉด, ๋ ์ข์ ๋ฒ์์ ๊ฐ์ฒด๊ฐ ๋์ ๋ฒ์์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌ๋ ํจ๊ณผ.
class๋ instance๋ฅผ ์ฐ์ด๋ด๋ ํ. ์ฟ ํค๋ฅผ ๋ง๋ ๋ค๊ณ ๊ฐ์ ํ ๋, class๋ผ๋ ํ์ ํตํด ๋ค์ํ ๋ง์ ์ฟ ํค์ธ instance๋ฅผ ๋ง๋ค ์ ์๋ค. ํ ํ์ ๋ฐ๋ผ ๋ง์ ๋ค๋ฅผ ์ ์์ง๋ง ๋ชจ๋ ์ฟ ํค๋ผ๋ ๊ณตํต์ ์ ๊ฐ๊ณ ์๋ค.
class ClassName:
...class ๋ด์ฉ ์ฝ๋๋ค
class1 = ClassName()
class2 = ClassName()
class Car:
def __init__(self, maker, model, horse_power): #attribute
self.maker = maker
self.model = model
self.horse_power = horse_power
def honk(self): # method
return "๋น ๋ผ๋ฐ๋ผ๋น ๋ผ๋ฐค"
def honk_with_name(self):
return f'{self.maker} ๋น ๋ผ๋ฐ๋ผ๋น ๋ผ๋ฐค' #๊ฐ์ฒด์ attribute์ธ self.maker ๋ถ๋ฌ์ค๊ธฐ
hyundai = Car("ํ๋", "์ ๋ค์์ค", 500) # instance ๊ฐ์ฒด ์์ฑ
hyundai.honk() # calling method
> "๋น ๋ผ๋ฐ๋ผ๋น ๋ผ๋ฐค"
hyundai.honk_with_name()
> "ํ๋ ๋น ๋ผ๋ฐ๋ผ๋น ๋ผ๋ฐค"
__init__
class๊ฐ ์ค์ฒดํ๋ ๋(instance๋ฅผ ๋ง๋ค ๋) ์ฌ์ฉ๋๋ ํจ์์ด๋ค. instance๋ฅผ ๋ง๋ค ๋ ์๋์ผ๋ก ํธ์ถ๋๋ค.
class Database:
def __init__(self, name, size):
self.name = name
self.size = size
self.dict = {}
์ ๋ค๋ก ๋ฐ์ค 2๊ฐ๊ฐ ์๋ ๋ฉ์๋๋ฅผ special methods๋ผ๊ณ ํ๋ค. ์ฌ์ฉ์๊ฐ ์ ์ํ ์ด๋ฆ๊ณผ ์ถฉ๋ํ์ง ์๊ธฐ ์ํด์ ์ฐ๋ convention์ด๋ค.
self๋ class์ ์ค์ฒด(instance)์ธ ๊ฐ์ฒด(object)๋ฅผ ๊ฐ๋ฅดํจ๋ค. Car class์์ "self" ๋ Car class์ ๊ฐ์ฒด์ธ hyundai๋ bmw๋ฅผ ๊ฐ๋ฅดํค๋ ๊ฒ์ด๋ค. ์๋ ์ธ ์ค์ ์ด๋ค์ ๋ค์ ์ฌ์ฉํ๊ธฐ ์ํด maker, model, horse_power๋ฅผ ๊ฐ์ฒด์ ์ ์ฅํ๋ ๊ฒ์ด๋ค.
class์ method๋ฅผ ๋ง๋ค ๋, ์ฒซ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ๋ ํญ์ self ๊ฐ ๋ค์ด๊ฐ์ผ ํ๋ค. ๊ทธ ๋ค์์ผ๋ก ์ถ๊ฐ๋๋ ๋ถ๋ถ์ ํ๋ผ๋ฏธํฐ์ด๊ณ (instance ์์ฑ ์ ์ธ์๊ฐ ๋ค์ด๊ฐ), __init__
์์ ์ ์ํ ์์ฑ์ ์ฌ์ฉํ๋ ค๋ฉด dot notation์ ์ฌ์ฉํ๋ค.
def insert(self, field, value):
if len(self.dict.keys()) < self.size:
self.dict[field] = value
else:
pass
def select(self, field):
if field in self.dict:
return self.dict[field]
else:
return None
Data type ์ค ํ๋. null or no
value๋ฅผ ์ ์ํ๊ธฐ ์ํด ์ฐ์ธ๋ค. 0์ด๋ False๋ฅผ ์๋ฏธํ์ง ์๋๋ค. ์์ ๋ง์ value๋ฅผ ๊ฐ์ง data type์ด๊ณ , Python์ ์ค์ง ํ๋์ None ๊ฐ์ฒด๋ฅผ ๊ฐ๊ณ ์๊ธฐ ๋๋ฌธ์, ๋ณ์์ None์ ํ ๋นํ๋ฉด ๋ชจ๋ ๋ณ์๊ฐ ๋์ผํ id๋ฅผ ๊ฐ๊ฒ ๋๋ค.
a=None
b=None
c=None
print(id(a)) # 4458713192
print(id(b)) # 4458713192
print(id(c)) # 4458713192
>>>
๋ค์ ๊ฐ๋ ์ ํ์ด์ฌ ์ฝ๋ฉ ๋์ฅ์์ ์ฐธ๊ณ ํ๋ค. ์ค๋ฒ๋ผ์ด๋ฉ(overriding)์ ๋ฌด์ํ๋ค, ์ฐ์ ํ๋ค๋ผ๋ ๋ป์ ๊ฐ์ง๊ณ ์๋๋ฐ ๋ง ๊ทธ๋๋ก ๊ธฐ๋ฐ ํด๋์ค์ method๋ฅผ ๋ฌด์ํ๊ณ ์๋ก์ด method๋ฅผ ๋ง๋ ๋ค๋ ๋ป์ด๋ค. ์๋์์ Person ํด๋์ค์ greeting method๋ฅผ ๋ฌด์ํ๊ณ Student ํด๋์ค์์ ์๋ก์ด greeting method๋ฅผ ๋ง๋ค์๋ค.
class Person:
def greeting(self):
print('์๋
ํ์ธ์.')
class Student(Person):
def greeting(self):
print('์๋
ํ์ธ์. ์ ๋ ํ์ด์ฌ ์ฝ๋ฉ ๋์ฅ ํ์์
๋๋ค.')
james = Student()
james.greeting() # result:์๋
ํ์ธ์. ์ ๋ ํ์ด์ฌ ์ฝ๋ฉ ๋์ฅ ํ์์
๋๋ค.
๊ทธ๋ผ method ์ค๋ฒ๋ผ์ด๋ฉ์ ์ ์ฌ์ฉํ ๊น? ๋ณดํต ํ๋ก๊ทธ๋จ์์ ์ด๋ค ๊ธฐ๋ฅ(์์ ์๋ฅผ ๋ค๋ฉด ์ธ์ฌ)์ด ๊ฐ์ ์ด๋ฆ์ผ๋ก ๊ณ์ ์ฌ์ฉ๋์ด์ผ ํ ๋ method ์ค๋ฒ๋ผ์ด๋ฉ์ ํ์ฉํ๋ค.
๋ง์ฝ method์ ๋ด์ฉ์ด ์ค๋ณต๋ ๊ฒฝ์ฐ, ๊ธฐ๋ฐ ํด๋์ค์ ๋ฉ์๋๋ฅผ ์ฌํ์ฉํ๋ฉด ์ค๋ณต์ ์ค์ผ ์ ์๋ค. ๋ค์๊ณผ ๊ฐ์ด ์ค๋ฒ๋ผ์ด๋ฉ๋ ๋ฉ์๋์์ super()๋ก ๊ธฐ๋ฐ ํด๋์ค์ ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๋ค.
class Student(Person):
def greeting(self):
super().greeting() # ๊ธฐ๋ฐ ํด๋์ค์ ๋ฉ์๋ ํธ์ถํ์ฌ ์ค๋ณต์ ์ค์
print('์ ๋ ํ์ด์ฌ ์ฝ๋ฉ ๋์ฅ ํ์์
๋๋ค.')
james = Student()
james.greeting()
#result:
#์๋
ํ์ธ์
#์ ๋ ํ์ด์ฌ ์ฝ๋ฉ ๋์ฅ ํ์์
๋๋ค.
์์ ๊ฐ์ด ๊ธฐ๋ฐ ํด๋์ค์ ์๋ ๊ธฐ๋ฅ์ ์ ์งํ๋ฉด์ ์๋ก์ด ๊ธฐ๋ฅ์ ๋ง๋ถ์ผ ๋ ์ฌ์ฉํ๊ธฐ๋ ํ๋ค.