๊ณ์ฐ๊ธฐ ๊ธฐ๋ฅ
๐ abs (x) — ์ซ์๋ฅผ ๋ฐ์ ์ ๋๊ฐ ๋ฆฌํด โญ
๐ max(iterable) — ๋ฐ๋ณต ๊ฐ๋ฅํ ์๋ฃํ์ ๋ฐ์ ์ต๋๊ฐ์ ๋ฆฌํด
(์ด๋ค ๊ฐ์ ๋น์จ๋ก ๋ง๋ค ์ ์์), ๋ฌธ์์ด๋ ๊ฐ๋ฅ!!!!! ์ํ๋ฒณ์!
๐ min(iterable) — ๋ฐ๋ณต ๊ฐ๋ฅํ ์๋ฃํ์ ๋ฐ์ ์ต์๊ฐ์ ๋ฆฌํด
๐ divmod(a,b) — ๋ ์ซ์๋ฅผ ๋ฐ์ ๋๋๊ณ ๋ชซ๊ณผ ๋๋จธ์ง ๊ฐ์ ํํ๋ก ๋ฐํ
๐ eval(expression) — ์คํ ๊ฐ๋ฅํ ๋ฌธ์์ด์ ์ ๋ ฅ ๋ฐ์ ์คํํ ๊ฒฐ๊ณผ ๊ฐ ๋ฆฌํด
eval('1+2') ํ๋ฉด 3 ๋์ค๊ณ , eval('divmod(4,3)') ํ๋ฉด (1,1)๋์ด
์ฐธ๊ณ ๋ก ๋ฌธ์์ด ํฉ์น๊ธฐ๋ ๊ฐ๋ฅ!
๐ pow (x,y)— x์ y ์ ๊ณฑํ ๊ฒฐ๊ณผ
์์ ์ค์!!!!
๐๐ filter โญ
— (์ฒซ ๋ฒ์งธ ์ธ์ ํจ์ ์ด๋ฆ, ๋ ๋ฒ์งธ ์ธ์ ๋ฐ๋ณต ๊ฐ๋ฅํ ์๋ฃํ ) ์ฐธ์ธ ๋ฆฌํด๊ฐ ๋ฆฌํด
#ํํฐ ์ฐ๊ธฐ ์
def positive(list_):
result = [] # ์์ ์ ์ฅํ ๋ฆฌ์คํธ ์ ์ธ
for item in list_:
if item > 0:
result.append(item)
return result
print (positive([1,-1,2,-2,3,-3])) --- [1,2,3]
#ํํฐ๋ฅผ ์ฐ๋ฉด!!! (๏ฝก๏ฝฅ∀๏ฝฅ)๏พ๏พ
def positive(item): #์ฌ๊ธฐ์ item์ ๋จ์ผ๊ฐ, ์ค์นผ๋ผ!
return item > 0 #๋น๊ต ์ฐ์ฐ์ boolean ๋ฆฌํด ํด์ผํจ!!!!!
list_ = [1,-1,2,-2,3,-3]
print(list(filter(positive, list_))) --- [1,2,3]
๐๐ lambda โญ —
ํจ์๋ฅผ ์์ฑํ ๋ ์ฌ์ฉํ๋ ์์ฝ์ด, def๋ฅผ ์ฌ์ฉํ ์ ์๊ฑฐ๋ , ๊ฐ๋จํ ํ ๋
๋๋ค๋ ํจ์์ด๋ฆ์ ์์ฃผ์ด๋ ๋จ!!!!!! (์ต๋ช ์ ํจ์ & ์ผํ์ฑ ์ฌ์ฉ)๐ฎ๐งโ๏ธ
def๋ ์ ์ํ๋ ๊ฒ์ด์ง(์คํx), ์ค๋ธ์ ํธ ์์ฑ์ด ์๋๋ผ์ ์ธ ์ ์๋ ๊ณณ์ด ์์!!!!!!!!
lambda๋ (์ค๋ธ์ ํธ ์์ฑ) ์คํํด์ ๊ทธ ์ฐจ์ด๊ฐ ํฌ๋ค!!!! —์ฃผ์๊ฐ์ด ์์
sum = lambda a,b : a+b
#ํจ์ ์ค๋ธ์ ํธ ์์ฑ, ํ๋ผ๋ฏธํฐ a,b : return๊ฐ ์ฝ๋
#sum์ด ์ค๋ธ์ ํธ๋ฅผ ๊ฐ๋ฆฌํด!
sum (3,4) ---7 ๋์ด
#์์ filter ์์ ์ฝ๋๋ฅผ ์ค์ผ ์ ์์!
#postive ํจ์ ์ ์ ํ ํ์ ์์ด lambda ๋ก!!
list_ = [1,-1,2,-2,3,-3]
print(list(filter(lambda item: item>0, list_))) --- [1,2,3] ๋์ด!
#rambda_test.py
myList = [lambda a,b :a+b, lambda a,b :a*b]
print(myList)
---[<function <lambda> at 0x000001A0A8197F70>, <function <lambda> at 0x000001A0A8329700>]
print(myList[0](3,4)) --- 7
print(myList[1](3,4)) --- 12
[0]๋ฒ์งธ๋ฅผ ๊ฐ์ ธ์์ ()๋ ํจ์ ์คํ!!!!!!
๐๐ map (f, iterable) โญ —
์ ๋ ฅ ๋ฐ์ ์๋ฃํ์ ๊ฐ ์์๊ฐ ํจ์ f์ ์ํด ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฌถ์ด์ ๋ฆฌํด
ํํฐ๋ ๊ฑธ๋ฌ๋ด๋ ๊ฒ์ด๊ณ , map์ ํ๋์ฉ ๊บผ๋ด์ ์ฐ์ฐ ํ ๋ฌถ์! (์ฐ์ฐ ํ ํต์ผ๋ก ์ ์ฅ)
์๋ฅผ ๋ค์ด, ๋น๋ง์จ๋, ์ ๋ถ ๋ก๊ทธํ ํ ๋๋ ํ๋ฒ์ ๊ณ์ฐํ ๋ฐ์ดํฐ ๊ฐ์ผ๋ก ์ ์ฅํ ์ ์์๐๐
def two_times(numberList):
result = [] #๋ฆฌ์คํธ ์ค๋ธ์ ํธ ์์ฑ
for number in numberList:
result.append(number*2)
return result
result = two_times([1,2,3,4])
print(result)
#map์ ์ฐ๋ฉด ๊ฐ๊ฒฐํด์ง!
def two_times_01(x):
return x*2
result = map(two_times_01, [1,2,3,4])
print(list(result))
#map์ return์ด object์์ผ๋ก list๋ก ๋ฐ๊ฟ์ค์ผ ํจ!
Q.(์ฅ iterableํ์ง ์๋๋ฐ...)???
A.__iter__ ๋งค์ง๋ฉ์๋๊ฐ ์คํ๋จ!
#๋๋ค๊น์ง ๊ฐ์ด ์ฐ๋ฉด 2์ค๋ก !!!
result_01 = map(lambda x: x*2 , [1,2,3,4])
print(result_01)
๐๐ zip (iterable) โญ —
๋์ผํ ๊ฐ์๋ก ์ด๋ฃจ์ด์ง ์๋ฃํ์ ๋ฌถ์ด ํํ๋ก ๋ฐํํ๋ ํจ์
ํ์ด์ฌ์SQL์ด๋ ๋ค๋ฅด๊ฒ row๊ฐ ์๋๋ผ ์ปฌ๋ผ ๋จ์๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ค!!!!!!
zip์ ํ๋ฉด ํ ์ปฌ๋ผ์ ๊ฐ์ ์ธ๋ฑ์ค ๊ฐ์ ๋ชจ์์ ์ ๋ฆฌ (๋ฐ๋์ length๊ฐ ๊ฐ์์ผ ํจ!)
list(zip([1,2,3],[4,5,6])
#--- (1,4),(2,5),(3.6)
iterable ์๋ฃํ(๋ฆฌ์คํธ, ํํ, ๋ฌธ์์ด)
๐ all (x) — iterable์ ๋ฐ์ boolean ๋ฆฌํด (๋ชจ๋ ์ฐธ์ด๋ฉด True) ๋ง์ฝ 0์ด ์์ F
๐ any (x) — ํ๋๋ผ๋ ์ฐธ์ด ์์ ๊ฒฝ์ฐ True, ๋ชจ๋ ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ์ False
๐ len(s) — s (iterable)์ ๊ธธ์ด(์์ ์ ์ฒด ๊ฐ์)๋ฅผ ๋ฆฌํด
len(1,2) : ๊ตฌ๋ถ์๋ก ์ธ์ํด์ ์๋ฌ , len ((1,2)): ์ด๋ ๊ฒ ์จ์ผ ํํ๋ก ์ธ์!!!
๊ทธ๋ฆฌ๊ณ ๊ผญ len(1) ์ด๋ ๊ฒ iterableํ์ง ์์ ๊ฑฐ ์ฐ๋ฉด ์๋ฌ!!! ์ฃผ์
๐ enumerate — iterable์ ๋ฐ์ ์ธ๋ฑ์ค ๊ฐ๊ณผ ํจ๊ป enumerate๊ฐ์ฒด๋ฅผ ํํ๋ก ๋ฆฌํด โญ
for i , name in enumerate(['a','b','c']) : ํ๋ฉด i์๋ ์ธ๋ฑ์ค, name์๋ ๊ฐ์ฒด๋ฅผ ๋ด๋๋ค.
index๊ฐ ํฌํจ๋์ด ์๋ฃํ์ ํ์ฌ ์์(์์น)์ ๊ฐ์ ์ฝ๊ฒ ์ ์ ์๋ค.
๐ list(s) — s (iterable)๋ฅผ ์ ๋ ฅ ๋ฐ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด ๋ฆฌํด
๋ฆฌ์คํธ๋ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ผ๋๊น! ํํ์ด๋ ๋ฌธ์์ด์ ๋ฆฌ์คํธ๋ก ๋ณ๊ฒฝํด์ ์์ !!!
๋ฆฌ์คํธ๋ฅผ ๋ฆฌ์คํธ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณต์ฌํ๋ ๊ฒ!
๐ tuple(i) — ๋ฐ๋ณต ๊ฐ๋ฅํ ์๋ฃํ์ ์ ๋ ฅ ๋ฐ์ ํํ ํํ๋ก ๋ฐ๊พธ์ด ๋ฆฌํด (๊ณ ์ ์ํค๊ธฐ, ๋ณต์ )
๐ sorted (i) — ์ ๋ ฅ ๊ฐ์ ์ ๋ ฌํ ํ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌ์คํธ๋ก ๋ฐํ
(๋ฆฌ์คํธ ์ ๋ฉ์๋๋ ๋ณธ๋ ๋ฆฌ์คํธ๋ฅผ ์ ๋ ฌํ ๋ฟ์ด๋ค. ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ์ง ์์!!- None)
์ ๋ณด
๐ dir— ๊ฐ์ฒด๊ฐ ์์ฒด์ ์ผ๋ก ๊ฐ์ง๊ณ ์๋ ๋ณ์๋ ํจ์๋ฅผ ๋ณด์ฌ์ค
๐ id(object) — ๊ฐ์ฒด๋ฅผ ์ ๋ ฅ๋ฐ์ ๊ฐ์ฒด์ ๊ณ ์ ์ฃผ์๊ฐ์ ๋ฆฌํด
๐ isinstance(object, class) — ์ ๋ ฅ ๋ฐ์ ๊ฐ์ฒด๊ฐ ๊ทธ ํด๋์ค์ ์ธ์คํด์ค์ธ์ง ๋ถ๋ฆฐํ ๋ฆฌํด
๐ type (object) — object(์์ ํด๋์ค) & ์ ๋ ฅ ๊ฐ์ ์๋ฃํ์ด ๋ฌด์์ธ์ง ์๋ ค์ฃผ๋ ํจ์
๋ณํ
๐ chr (i) — ์์คํค ์ฝ๋๊ฐ(์ ์)์ ์ ๋ ฅ ๋ฐ์ ๊ทธ ์ฝ๋์ ํด๋นํ๋ ๋ฌธ์๋ฅผ ์ถ๋ ฅ
๐ ord (c)— ๋ฌธ์๋ฅผ ๋ฐ์ ์์คํค ์ฝ๋๊ฐ์ ๋ฆฌํด ( ํค๋ณด๋ ์ ์ด ์ ์ฌ์ฉ)
๐ hex(x) — ์ ์๊ฐ์ ์ ๋ ฅ๋ฐ์ 16์ง์๋ก ๋ณํ
(16์ผ๋ก ๋๋ , 3→ 0x3, 234 → 0xea), 1. ํ๊ธฐ๊ฐ ํธํจ!๐
16์ง์์์ 2์ง์๋ก ๊ณ์ฐ์ด 2๋ฒ์ด๋ฉด ๋์ด์ 2. ๋น ๋ฆ!!(234 → ea → 14,10 → 1110,1010)๐
๐ int(x) — ๋ฌธ์์ด ํํ์ ์ซ์๋, ์์์ ์ด ์๋ ์ซ์๋ฅผ ์ ์๋ก ๋ฆฌํด
int ํจ์๋ ๋ฌธ์์ด ์์ ์๋ int ๋ฅผ ํธ์ถ ํด์ ๋ฐํํ ๋ฟ! (int ์์ฑ์๋ ๋ค๋ฆ!!!!)???
์์์ ์ด ์๋ ์ซ์๋ ๋ฐ์ฌ๋ฆผ ๋์ง ์๊ณ ์ ์ฌ ๋จ!
- int(x, radix) — radix๋ก ํํ๋ ์ง์ x๋ฅผ 10์ง์๋ก ๋ณํํ ํํ๋ก ๋ฆฌํด
๐ str (object) — ๊ฐ์ฒด๋ฅผ ๋ฌธ์์ด ํํ๋ก ๋ฐํ(์ซ์→ ๋ฌธ์๋ก ๋ง์ด ์ฌ์ฉ, ๋ณต์ ๋ก๋ ์ธ ์ ์์)
๐ range([start], stop, [step]) — ์ ๋ ฅ ๋ฐ์ ์ซ์ ํด๋น ๋ฒ์์ ๊ฐ์ ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๋ก ๋ฆฌํด
- list(range(5)) ์ฒ๋ผ ์ด๋ป๊ฒ ๋ฆฌํดํ ์ง ์ง์ ํด์ผ, & ๋ ๊ฐ์ ํฌํจ ์๋๋ ๊ฑฐ ์ฃผ์!!!
๊ธฐํ
๐ input([prompt]) — ์ฌ์ฉ์ ์ ๋ ฅ์ ๋ฐ๋ ํจ์ [prompt]๋ ์ต์ ! ์ฐ๋ฉด ํ๋กฌํํธ๊ฐ ๋จ
๐ open(filename, [mode]) — ํ์ผ ์ด๋ฆ๊ณผ ์ฝ๊ธฐ ๋ฐฉ๋ฒ์ ์ ๋ ฅ ๋ฐ์ ํ์ผ ๊ฐ์ฒด๋ฅผ ๋ฆฌํด
[mode] : < w ์ฐ๊ธฐ , r ์ฝ๊ธฐ, a ์ถ๊ฐ, b ๋ฐ์ด๋๋ฆฌ ๋ชจ๋ > ๋ํดํธ๋ r