νŒŒμ΄μ¬μ„ 파이썬 λ‹΅κ²Œ

2020. 12. 30. 18:00γ†πŸ“š Algorithm/πŸ“• Python 문법

λ°˜μ‘ν˜•

μ˜€λŠ˜μ€ 파이썬 곡뢀할 λ•Œ 많이 μœ μš©ν–ˆλ˜ ν”„λ‘œκ·Έλž˜λ¨ΈμŠ€μ˜ 'νŒŒμ΄μ¬μ„ 파이썬 λ‹΅κ²Œ' κ°•μ˜μ— λŒ€ν•΄ μ†Œκ°œν•΄λ“œλ¦¬κ³ μž ν•΄μš”!

 

νŒŒμ΄μ¬μ„ νŒŒμ΄μ¬λ‹΅κ²Œ

λ³Έ κ°•μ˜λŠ” 파이썬 문법을 이미 μ•Œκ³  μžˆλŠ” 뢄듀을 λŒ€μƒμœΌλ‘œ λ§Œλ“€μ–΄μ‘ŒμŠ΅λ‹ˆλ‹€. ##### 이런 λΆ„λ“€κ»˜ μΆ”μ²œν•©λ‹ˆλ‹€ * 파이썬 문법을 μ•Œκ³  κ³„μ‹œλŠ” λΆ„ * μ•Œκ³ λ¦¬μ¦˜ 문제λ₯Ό 쑰금 더 μ‰½κ²Œ ν’€κ³  싢은 λΆ„ * Python μ½”

programmers.co.kr

 

파이썬 μ™ λ§Œν•œ 문법에 λŒ€ν•΄ λ‹€ 잘 μ•Œκ³  μžˆλ‹€κ³  μƒκ°ν–ˆλŠ”λ° 'νŒŒμ΄μ¬μ„ νŒŒμ΄μ¬λ‹΅κ²Œ' κ°•μ˜μ™€ 문제λ₯Ό ν’€μ–΄λ³΄λ©΄μ„œ 아직 많이 λΆ€μ‘±ν•˜κ³ , νŒŒμ΄μ¬μ€ 정말 λ¬΄κΆλ¬΄μ§„ν•œ μ–Έμ–΄λΌλŠ” 것을 μ•Œμ•˜μ–΄μš”! μ•Œκ³ λ¦¬μ¦˜ 문제 ν’€ λ•Œ 파이썬이 μ–Όλ§ˆλ‚˜ 쒋은 언어인지도 λ‹€μ‹œν•œλ²ˆ κΉ¨λ‹¬μ•˜μŠ΅λ‹ˆλ‹€ πŸ˜€

 

κ·Έλž˜μ„œ ! 'νŒŒμ΄μ¬μ„ 파이썬 λ‹΅κ²Œ' κ°•μ˜μ—μ„œ μƒˆλ‘­κ²Œ 배운 μœ μš©ν•œ 파이썬 문법/λͺ¨λ“ˆμ— λŒ€ν•΄ μ •λ¦¬ν•΄λ³Όκ²Œμš”!

'νŒŒμ΄μ¬μ„ 파이썬 λ‹΅κ²Œ' κ°•μ˜ μš”μ•½ 및 정리라고 μƒκ°ν•˜μ‹œλ©΄ 될 κ±° κ°™μŠ΅λ‹ˆλ‹€ : )

 

 

πŸ“Œ λͺ«κ³Ό λ‚˜λ¨Έμ§€λ₯Ό ꡬ할 λ•Œ?! - divmod

보톡을 λͺ«κ³Ό λ‚˜λ¨Έμ§€λ₯Ό ꡬ할 λ•Œ μ–΄λ–»κ²Œ κ΅¬ν•˜μ‹œλ‚˜μš”!? μ•„λž˜μ™€ 같이 μ—°μ‚°μžλ₯Ό μ΄μš©ν•˜μ—¬ λͺ«, λ‚˜λ¨Έμ§€ λ”°λ‘œ κ΅¬ν•˜μ‹€ κ±° κ°™μ€λ°μš”.

divmodλ₯Ό μ΄μš©ν•˜λ©΄ 보닀 μ‰½κ²Œ λͺ« κ³Ό λ‚˜λ¨Έμ§€λ₯Ό λ™μ‹œμ— κ΅¬ν•˜μ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€.

a = 7
b = 5
print( a//b , a%b ) # 1 2 좜λ ₯
a = 7
b = 5
print( *divmod(a, b) ) # 1 2 좜λ ₯

 

 

πŸ“Œ n 진법 ν‘œκΈ° 된 string을 10 진법 숫자둜 λ³€ν™˜ν•˜κΈ° - int

string으둜 ν‘œκΈ°λœ n 진법 숫자λ₯Ό 10 μ§„λ²•μœΌλ‘œ λ³€ν™˜ν•˜λŠ” λ¬Έμ œκ°€ μžˆμ—ˆμŠ΅λ‹ˆλ‹€.

μ œκ°€ μ•Œκ³  있던 intλŠ” Integer ν˜•μœΌλ‘œ λ³€ν™˜μ„ ν•΄μ£ΌλŠ” μ—­ν• λ§Œ ν•œλ‹€κ³  μƒκ°ν–ˆμ—ˆλŠ”λ° 이번 κΈ°νšŒμ— 10진법 λ³€ν™˜λ„ μžλ™μœΌλ‘œ ν•΄μ€€λ‹€λŠ” 사싀을 λ°°μ› μŠ΅λ‹ˆλ‹€!

νŒŒμ΄μ¬μ„ μ‚¬μš©ν•˜λ©΄ 진법 λ³€ν™˜λ„ 맀우 μ‰½κ²Œ ν•  수 μžˆλ‹€λŠ” κ±Έ 배우게 λ˜μ—ˆμ–΄μš”.

num = '3212'
base = 5

st = [int(i) for i in str(num)] # string 숫자λ₯Ό ν•œκΈ€μžμ”© μͺΌκ°œμ–΄ intν˜•μœΌλ‘œ list에 μ €μž₯ν•˜κΈ°
st.reverse() # 진법에 맞게 κ³±ν•΄μ£ΌκΈ° μœ„ν•˜μ—¬ list 거꾸둜 ν•˜κΈ°
answer = 0 # 10μ§„λ²•μœΌλ‘œ λ³€ν™˜λœ 숫자 더해주기

for i in range(len(st)):
  answer += st[i]*(base**i) 
num = '3212'
base = 5

answer = 0
for idx, i in enumerate(num[::-1]):
    answer += int(i) * ( base ** idx )

μ΄λ ‡κ²Œ κ½€ κΈ΄ μˆ˜μ‹μ„ intλ₯Ό 톡해 단 ν•œλ²ˆμ— 10μ§„λ²•μœΌλ‘œ 진법 λ³€ν™˜μ΄ κ°€λŠ₯ν•©λ‹ˆλ‹€.

 

num = '3212'
base = 5

answer = int(num, base)

 

 

πŸ“Œ λ¬Έμžμ—΄ μ •λ ¬ν•˜κΈ° - ljust, center, rjust

λ¬Έμžμ—΄μ— λŒ€ν•œ ν•¨μˆ˜λ“€μ„ 정리해논 적 μžˆμ—ˆλŠ”λ°, ljust,center,rjust의 μ‚¬μš©λ²•μ— λŒ€ν•΄μ„œλŠ” 잘 λͺ¨λ₯΄κ³  μžˆμ—ˆμŠ΅λ‹ˆλ‹€.

μ΄λ²ˆμ— λ¬Έμžμ—΄ μ •λ ¬ 문제λ₯Ό ν’€λ©΄μ„œ μ΄λ ‡κ²Œ μ‚¬μš©λ˜λŠ” κ΅¬λ‚˜ κΉ¨λ‹¬μ•˜μŠ΅λ‹ˆλ‹€.

 

πŸ“ λ¬Έμžμ—΄ sλ₯Ό 쒌츑 / κ°€μš΄λ° / 우츑 μ •λ ¬ν•œ 길이 n인 λ¬Έμžμ—΄μ„ ν•œ 쀄씩 ν”„λ¦°νŠΈν•΄λ³΄κΈ°

s = 'κ°€λ‚˜λ‹€λΌ'
n = 7

s.ljust(n) # 쒌츑 μ •λ ¬
s.center(n) # κ°€μš΄λ° μ •λ ¬
s.rjust(n) # 우츑 μ •λ ¬

 

 

πŸ“Œ μ•ŒνŒŒλ²³ 좜λ ₯ν•˜κΈ° - string λͺ¨λ“ˆ

보톡 'a' λΆ€ν„° 'z'κΉŒμ§€ 좜λ ₯ν•˜μ‹œμ˜€ ν•˜λ©΄ 'abcd....xyz' μ΄λ ‡κ²Œ ν•˜λ‚˜ν•˜λ‚˜ λ‚˜μ—΄ν•˜λŠ” κ²½μš°κ°€ λ§Žμ•˜μ„ κ±° κ°™μ€λ°μš”.

μ € λ˜ν•œ ν•˜λ‚˜ν•˜λ‚˜ λΆˆν•„μš”ν•˜κ²Œ λ‚˜μ—΄ν–ˆλ˜ μ‚¬λžŒ 쀑 ν•œλͺ…μ΄μ˜€μŠ΅λ‹ˆλ‹€.

string λͺ¨λ“ˆμ—λŠ” μ†Œλ¬Έμž, λŒ€λ¬Έμž, λŒ€μ†Œλ¬Έμž λͺ¨λ‘, 숫자λ₯Ό 좜λ ₯ν•΄μ£ΌλŠ” κΈ°λŠ₯이 μžˆμ—ˆμŠ΅λ‹ˆλ‹€. 

string λͺ¨λ“ˆμ— λŒ€ν•΄ 더 많이 곡뢀해야 κ² μ–΄μš”!

 

import string 

string.ascii_lowercase # μ†Œλ¬Έμž abcdefghijklmnopqrstuvwxyz
string.ascii_uppercase # λŒ€λ¬Έμž ABCDEFGHIJKLMNOPQRSTUVWXYZ
string.ascii_letters #λŒ€μ†Œλ¬Έμž λͺ¨λ‘ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
string.digits # 숫자 0123456789

 

 

πŸ“Œ 2차원 리슀트 뒀집기 - zip

' [ [1,2,3], [4,5,6], [7,8,9] ] λ¦¬μŠ€νŠΈκ°€ 주어진 경우, [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 둜 뒀집어라 ' λΌλŠ” 문제λ₯Ό 보고 μ–΄λ–»κ²Œ 뒀집을 수 μžˆμ„κΉŒ 생각해보닀 리슀트의 ν–‰κ³Ό μ—΄μ˜ 길이가 κ°™λ‹€λŠ” 쑰건을 보고, for문을 톡해 temp λ¦¬μŠ€νŠΈμ— 1ν–‰ 1μ—΄, 2ν–‰ 1μ—΄ .. 순차적으둜 μ €μž₯ν•˜μ—¬ μ •λ‹΅ λ¦¬μŠ€νŠΈμ— λ”ν•΄μ£ΌλŠ” ν˜•μ‹μœΌλ‘œ κ΅¬ν˜„ν•΄λ³΄μ•˜λŠ”λ°μš”.

 

zip을 μ΄μš©ν•˜λ©΄ 보닀 μˆ˜μ›”ν•˜κ²Œ 2차원 리슀트λ₯Ό 뒀집을 수 μžˆλ‹€λŠ” 것을 λ°°μ› μŠ΅λ‹ˆλ‹€.

def solution(mylist):
  answer = []
  for i in range(len(mylist[0])):
    tmp = []
    for j in range(len(mylist)):
      tmp.append(mylist[j][i])
    answer.append(tmp)  
    
  return answer
mylist = [ [1,2,3], [4,5,6], [7,8,9] ]
new_list = list(map(list, zip(*mylist)))

 

 

μΆ”κ°€λ‘œ zip의 μœ μš©ν•œ μ‚¬μš© μ˜ˆμ‹œλ„ μ •λ¦¬ν•΄λ³΄μ•˜μŠ΅λ‹ˆλ‹€.

 

βœ”οΈμ—¬λŸ¬ 개의 Iterable λ™μ‹œμ— μˆœνšŒν•  λ•Œ 

list1 = [1, 2, 3, 4]
list2 = [100, 120, 30, 300]
list3 = [392, 2, 33, 1]
answer = []
for i, j, k in zip(list1, list2, list3):
   print( i + j + k )

 

βœ”οΈKey λ¦¬μŠ€νŠΈμ™€ Value 리슀트둜 λ”•μ…”λ„ˆλ¦¬ 생성할 λ•Œ

animals = ['cat', 'dog', 'lion']
sounds = ['meow', 'woof', 'roar']
answer = dict(zip(animals, sounds)) # {'cat': 'meow', 'dog': 'woof', 'lion': 'roar'}

 

 

πŸ“Œ 리슀트의 λͺ¨λ“  μ›μ†Œμ˜ type λ³€ν™˜ν•˜κΈ° - map

map 은 input으둜 μ—¬λŸ¬κ°œμ˜ 숫자λ₯Ό ν•œ μ€„λ‘œ 받을 λ•Œ 많이 μ‚¬μš©ν•˜λŠ” ν•¨μˆ˜λΌ κ½€ μ΅μˆ™ ν•˜μ‹€κ±° κ°™μ€λ°μš”.

map을 μ‘μš©ν•œ 방법에 λŒ€ν•΄λ„ μ†Œκ°œ ν•΄λ“œλ¦¬κ³ μž ν•©λ‹ˆλ‹€.

list1 = ['1', '100', '33']
list2 = list(map(int, list1)) # [1, 100, 33]

 

βœ”οΈμ΄μ°¨μ› 리슀트의 μ›μ†Œμ˜ 길이λ₯Ό 담은 리슀트둜 λ§Œλ“€λ•Œ

[ [1,2] , [3,4,5], [1] ] πŸ‘‰πŸ» [ 2, 3, 1 ] 둜 λ§Œλ“€κΈ°

answer = list(map(len,mylist))

 

항상 map을 μ‚¬μš©ν•  λ•Œ int 만 λ„£μ–΄λ³Έ κ±° 같은데 λ‚΄κ°€ μ •μ˜ν•œ ν•¨μˆ˜λ‚˜, lenκ³Ό 같은 ν•¨μˆ˜λ“€μ„ 넣어도 μžλ™μœΌλ‘œ μΈμžλ“€μ„ ν•¨μˆ˜μ— λ„£μ–΄ λ³€ν™˜ν•΄μ£ΌλŠ” μ„±μ§ˆμ„ κ°™κ³  μžˆλ‹€λŠ” 것을 배울 수 μžˆμ—ˆμŠ΅λ‹ˆλ‹€.

 

 

πŸ“Œ sequence μ›μ†Œλ“€μ„ ν•˜λ‚˜λ‘œ 이어 뢙이기 - join

  • λ¬Έμžμ—΄ λ°°μ—΄ ['1', '100', '33']을 이어 λΆ™μ—¬ λ¬Έμžμ—΄ '110033' λ§Œλ“€κΈ°
  • μ •μˆ˜ν˜• νŠœν”Œ (3, 22, 91)을 이어뢙여 λ¬Έμžμ—΄ '32291' λ§Œλ“€κΈ°

μœ„μ™€ 같은 μƒν™©μ—μ„œ μ–΄λ–»κ²Œ 뢙일 수 μžˆμ„κΉŒ ?! λ§‰λ§‰ν•œ κ²½μš°κ°€ μžˆμœΌμ…¨μ„ 텐데 νŒŒμ΄μ¬μ—μ„œλŠ” join을 톡해 ν•œλ²ˆμ— string으둜 이어 뢙이싀 수 μžˆμŠ΅λ‹ˆλ‹€.

my_list = ['1', '100', '33']
answer = ''.join(my_list) # '110033'

 

βœ”οΈString을 List둜 λ³€ν™˜ν•˜λ €λ©΄ !?

str = '11 22 33'
list = str.split( ) # ['11', '22', '33']

 

 

πŸ“Œκ³±μ§‘ν•©(Cartesian product) κ΅¬ν•˜κΈ° - product

product에 λŒ€ν•΄μ„œλŠ” μ•Œκ³ λ¦¬μ¦˜ 문제 ν’€λ•Œ 자주 보진 λͺ»ν•œ 것 κ°™μ§€λ§Œ μ•Œμ•„λ‘λ©΄ 훨씬 λΉ λ₯΄κ³  μ‰½κ²Œ μ‚¬μš©ν•  수 μžˆλŠ” ν•¨μˆ˜ 쀑 ν•˜λ‚˜μΈ 것 κ°™μŠ΅λ‹ˆλ‹€!

 

두 슀트링 'ABCD', 'xy' 의 곱집합인 Ax Ay Bx By Cx Cy Dx Dy ꡬ할 λ•Œ / 2κ°œμ΄μƒμ˜ iterable 곱집합 ꡬ할 λ•Œ

import itertools

iterable1 = 'ABCD'
iterable2 = 'xy'
iterable3 = '1234'
itertools.product(iterable1, iterable2, iterable3) 

 

 

πŸ“Œ 2차원 리슀트λ₯Ό 1차원 리슀트둜 λ§Œλ“€κΈ° - from_iterable

itertoolsλ₯Ό μ΄μš©ν•˜λ©΄ μ‰½κ²Œ 2차원 리슀트λ₯Ό 1차원 리슀트둜 λ§Œλ“€ 수 μžˆμŠ΅λ‹ˆλ‹€!

2차원 리슀트λ₯Ό 1차원 리슀트둜 λ§Œλ“œλŠ” 방법 쀑 κ°„λ‹¨ν•œ 방법에 λŒ€ν•΄μ„œ μ†Œκ°œν•΄λ“œλ¦΄κ²Œμš”.

 

import itertools
my_list = [[1, 2], [3, 4], [5, 6]]

# 방법 1 - sum ν•¨μˆ˜
answer = sum(my_list, [])

# 방법 2 - itertools.chainimport itertools
list(itertools.chain.from_iterable(my_list))

# 방법 3 - itertools와 unpackingimport itertools
list(itertools.chain(*my_list))

# 방법4 - list comprehension 이용
[element for array in my_list for element in array]

 

 

πŸ“Œ μˆœμ—΄κ³Ό μ‘°ν•© - combinations, permutations

iterable의 μ›μ†Œλ₯Ό 가지고 μˆœμ—΄κ³Ό 쑰합을 κ΅¬ν•˜λŠ” 방법에 λŒ€ν•΄ μ•Œλ €λ“œλ¦¬κ³ μž ν•©λ‹ˆλ‹€.

μˆœμ—΄κ³Ό 쑰합을 κ΅¬ν•˜λŠ” 방식은 μ›μ†Œμ˜ κ°œμˆ˜κ°€ 적으면 μ‰½κ²Œ κ΅¬ν•˜μ‹€ 수 μžˆμ§€λ§Œ μ•Œκ³ λ¦¬μ¦˜μ„ κ΅¬ν•˜κΈ°μ—λŠ” μ–΄λ €μš΄ λ¬Έμ œμ΄μ§€ μ•Šμ„κΉŒ μ‹ΆμŠ΅λ‹ˆλ‹€.

itertools의 permutations을 μ΄μš©ν•˜λ©΄ 보닀 μ‰½κ²Œ κ΅¬ν•˜μ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€!

  • 1,2,3의 μˆ«μžκ°€ 적힌 μΉ΄λ“œκ°€ μžˆμ„ λ•Œ, 이 쀑 두 μž₯을 κΊΌλ‚΄λŠ” 경우의 수 -> 12, 13, 21, 23, 31, 32
  • 'A', 'B', 'C'둜 λ§Œλ“€ 수 μžˆλŠ” 경우의 수 -> 'ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA'
import itertools

pool = ['A', 'B', 'C']
print(list(map(''.join, itertools.permutations(pool)))) # 3개의 μ›μ†Œλ‘œ μˆ˜μ—΄ λ§Œλ“€κΈ°
print(list(map(''.join, itertools.permutations(pool, 2)))) # 2개의 μ›μ†Œλ‘œ μˆ˜μ—΄ λ§Œλ“€κΈ°

 

 

πŸ“Œ κ°€μž₯ 많이 λ“±μž₯ν•˜λŠ” μ•ŒνŒŒλ²³ μ°ΎκΈ° - Counter

collections λͺ¨λ“ˆμ— μ‘΄μž¬ν•˜λŠ” CounterλŠ” κ½€ 많이 μ‚¬μš©ν•΄λ³΄μ…¨μ„ 거라고 μƒκ°ν•©λ‹ˆλ‹€.

ν•˜μ§€λ§Œ ' mystrμ—μ„œ κ°€μž₯ 많이 λ“±μž₯ν•˜λŠ” μ•ŒνŒŒλ²³λ§Œμ„ 사전 순으둜 좜λ ₯ν•˜κΈ° ' 이런 문제λ₯Ό λ°›μ•˜μ„ λ•Œ μ–΄λ–»κ²Œ 문제λ₯Ό ν’€μ–΄μ•Ό 할지 λ°”λ‘œ μƒκ°λ‚˜μ§€ μ•Šμ•˜λŠ”λ°μš”. Counter을 μ΄μš©ν•˜λ©΄ μ‰½κ²Œ ν’€ 수 μžˆλ‹€λŠ” κ±Έ 배울 수 μžˆμ—ˆμŠ΅λ‹ˆλ‹€.

  • 'aab' -> 'a'
  • 'dfdefdgf' -> 'df'
  • 'bbaa' -> 'ab'
from collections import Counter
my_str = input().strip()

counter = Counter(my_str).most_common()
answer =""

for i in range(len(counter)):
if counter[i][1] == counter[0][1]:

answer+=counter[i][0]

print(''.join(sorted(list(answer))))

 

collections의 Counter ν΄λž˜μŠ€μ—λŠ” μ›μ†Œκ°€ λͺ‡λ²ˆ λ“±μž₯ν•˜λŠ”μ§€ κ΅¬ν•˜λŠ” 것 말고도 most_common() 처럼 λ°μ΄ν„°μ˜ κ°œμˆ˜κ°€ λ§Žμ€ 순으둜 μ •λ ¬λœ 리슀트λ₯Ό λ¦¬ν„΄ν•˜λŠ” λ©”μ„œλ“œλ„ μ‘΄μž¬ν•©λ‹ˆλ‹€.

from collections import Counter

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 7, 9, 1, 2, 3, 3, 5, 2, 6, 8, 9, 0, 1, 1, 4, 7, 0]
answer = Counter(my_list)

print(answer[1]) # = 4
print(answer[3])  # = 3
print(answer[100]) # = 0

 

 

πŸ“Œ for λ¬Έκ³Ό if문을 ν•œλ²ˆμ— - List comprehension의 if λ¬Έ

list μ›μ†Œλ“€ 쀑 2의 λ°°μˆ˜λ§Œμ„ 2λ°° ν•˜μ—¬ μ €μž₯ν•˜κ³  μ‹Άλ‹€λ©΄ ?! νŒŒμ΄μ¬μ—μ„œλŠ” forλ¬Έκ³Ό if문을 ν•œλ²ˆμ— μ“Έ 수 μžˆλŠ” List의 comprehension이 μ‘΄μž¬ν•©λ‹ˆλ‹€.

mylist = [3, 2, 6, 7]
answer = [ i**2 for i in mylist if i %2 == 0] # [4, 12]

 

 

πŸ“Œ flag OR for - else

for 문을 돌렀 쑰건에 ν•΄λ‹Ήν•˜λŠ” μ›μ†Œκ°€ μ‘΄μž¬ν•˜λŠ”μ§€ ν™•μΈν•œ λ‹€μŒμ— μ‘΄μž¬ν•˜λ©΄ Trueλ₯Ό , μ‘΄μž¬ν•˜μ§€ μ•ŠμœΌλ©΄ Fasle와 같이 좜λ ₯ν•΄μ•Όν•˜λŠ” κ²½μš°κ°€ μ‘΄μž¬ν•  수 μžˆμŠ΅λ‹ˆλ‹€. μ΄λ•Œ for - else 문을 μ‚¬μš©ν•˜λ©΄ κ°„νŽΈν•˜κ²Œ μ½”λ“œλ₯Ό μ§œμ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€.

 

문제 )

  1. 숫자λ₯Ό μ°¨λ‘€λ‘œ κ³±ν•΄ λ‚˜μ˜¨ μˆ˜κ°€ 제곱수1κ°€ 되면 foundλ₯Ό 좜λ ₯ν•˜κ³ 
  2. λͺ¨λ“  수λ₯Ό 곱해도 μ œκ³±μˆ˜κ°€ λ‚˜μ˜€μ§€ μ•Šμ•˜λ‹€λ©΄ not foundλ₯Ό 좜λ ₯ν•˜κΈ°
import math

numbers = [int(input()) for _ in range(5)]
multiplied = 1
for number in numbers:
    multiplied *= number
    if math.sqrt(multiplied) == int(math.sqrt(multiplied)):
        print('found')
        break
else:
    print('not found')

 

 

πŸ“Œ 두 λ³€μˆ˜μ˜ κ°’ λ°”κΎΈκΈ° - swap

swap을 ν•˜κΈ° μœ„ν•΄μ„œλŠ” 보톡 tempλ₯Ό μ΄μš©ν•˜μ—¬ λ³€ν™˜ν•˜λŠ” 방법에 λŒ€ν•΄ μ΅μˆ™ν•˜μ‹€ ν…λ°μš”.

νŒŒμ΄μ¬μ—μ„œλŠ” κ°„λ‹¨ν•˜κ²Œ swapλ₯Ό ν•˜μ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€!

a = 3
b = 'abc'

a, b = b, a # a = 'abc', b = 3

 

 

πŸ“Œμ΄μ§„ 탐색 ν•˜κΈ° (binary search) - bisect

이진 νƒμƒ‰μ΄λž€ ?! μ˜€λ¦„μ°¨μˆœμœΌλ‘œ μ •λ ¬λœ λ¦¬μŠ€νŠΈμ—μ„œ νŠΉμ • κ°’ μœ„μΉ˜λ₯Ό μ°Ύμ•„λ‚΄λŠ” μ•Œκ³ λ¦¬μ¦˜μœΌλ‘œ 검색속도가 λΉ λ₯΄λ‹€λŠ” μž₯점이 μžˆμŠ΅λ‹ˆλ‹€.

μ•Œκ³ λ¦¬μ¦˜ 문제λ₯Ό ν‘Έμ‹€ λ•Œ 이진 탐색을 μ‚¬μš©ν•˜λŠ” λ¬Έμ œκ°€ 많이 λ“±μž₯ν•˜λŠ”λ°μš”. μ΄λ•Œ 이진 탐색 μ•Œκ³ λ¦¬μ¦˜μ„ μž‘μ„±ν•˜λŠ” 것이 μ•„λ‹Œ bisectλͺ¨λ“ˆμ˜ bisect λ₯Ό μ΄μš©ν•˜μ‹œλ©΄ κ°„λ‹¨ν•˜κ²Œ 이진 탐색을 μ΄μš©ν•˜μ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€.

 

이진 탐색 μ•Œκ³ λ¦¬μ¦˜
def bisect(a, x, lo=0, hi=None):
    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo + hi) // 2
        if a[mid] < x:
            lo = mid + 1
        else:
            hi = mid
    return lo

mylist = [1, 2, 3, 7, 9, 11, 33]
print(bisect(mylist, 3))

 

bisect λͺ¨λ“ˆμ„ μ΄μš©ν•œ 이진 탐색
import bisect
mylist = [1, 2, 3, 7, 9, 11, 33]
print(bisect.bisect(mylist, 3))

 

 

πŸ“Œν΄λž˜μŠ€μ˜ μΈμŠ€ν„΄μŠ€ 좜λ ₯ - class의 μžλ™ string casting

classλ₯Ό μƒμ„±ν•œ λ’€ print문을 μΆ”κ°€λ‘œ 좜λ ₯ν•˜κ³  싢을 λ•Œκ°€ μžˆμŠ΅λ‹ˆλ‹€.

μ΄λ•Œ νŒŒμ΄μ¬μ—μ„œλŠ” __str__ λ©”μ†Œλ“œλ₯Ό μ΄μš©ν•˜μ—¬ class λ‚΄λΆ€μ—μ„œ 좜λ ₯ format을 μ§€μ •ν•˜λŠ” 것이 κ°€λŠ₯ν•©λ‹ˆλ‹€!

class Coord(object):
    def __init__ (self, x, y):
        self.x, self.y = x, y

point = Coord(1, 2)
print( '({}, {})'.format(point.x, point.y) ) 

# λ˜λŠ”
def print_coord(coord):
    print( '({}, {})'.format(coord.x, coord.y) )
print_coord(point)
class Coord(object):
    def __init__ (self, x, y):
        self.x, self.y = x, y
    def __str__ (self):
        return '({}, {})'.format(self.x, self.y)

point = Coord(1, 2)

 

 

πŸ“Œ κ°€μž₯ 큰수 - inf

infλ₯Ό μ΄μš©ν•˜λ©΄ 아무리 큰 μ–΄λ–€ μˆ«μžμ™€ λΉ„κ΅ν•˜λ”λΌλ„ 무쑰건 크닀고 νŒμ •ν•˜μ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€. 

infμ—λŠ” 음수 기호λ₯Ό 뢙일 수 μžˆλ‹€λŠ” 점도 κΈ°μ–΅ν•΄μ£Όμ‹œλ©΄ 쒋을거 κ°™μ•„μš”.

min_val = float('inf')
min_val > 10000000000

max_val = float('-inf')

 

 

πŸ“Œ 파일 μž…μΆœλ ₯ κ°„λ‹¨ν•˜κ²Œ ν•˜κΈ°

파이썬의 with - as ꡬ문을 μ΄μš©ν•˜κ²Œ 되면 νŒŒμΌμ„ closeν•˜μ§€ μ•Šκ³  μžλ™ closeν•˜μ‹€ 수 있고, 

readlinesμ‹œ 파일의 EOF κΉŒμ§€λ§Œ 읽어, while문을 톡해 EOFλ₯Ό 체크할 ν•„μš”κ°€ μ—†μŠ΅λ‹ˆλ‹€.

with - as ꡬ문은 파일 λΏλ§Œμ•„λ‹ˆλΌ socket, httpμ—μ„œλ„ μ‚¬μš©ν•˜μ‹€ 수 μžˆμŠ΅λ‹ˆλ‹€!

 

with open('myfile.txt') as file:
  for line in file.readlines():
    print(line.strip().split('\t'))

 

 

 

이번 ν¬μŠ€νŒ…μ—μ„œλŠ” python의 μœ μš©ν•œ 문법과 λͺ¨λ“ˆμ— λŒ€ν•΄ μ•Œμ•„λ³΄μ•˜λŠ”λ°μš”. 

μ €λŠ” 'νŒŒμ΄μ¬μ„ 파이썬 λ‹΅κ²Œ' κ°•μ˜λ₯Ό λ“€μœΌλ©΄μ„œ μ•„μ£Ό μœ μ΅ν•œ 파이썬 μ½”λ“œ μž‘μ„±ν•˜λŠ” 법에 λŒ€ν•΄ 배울 수 μžˆμ—ˆλ˜ 것 κ°™μŠ΅λ‹ˆλ‹€. 

파이썬으둜 μ•Œκ³ λ¦¬μ¦˜ 문제λ₯Ό ν‘Έμ‹œλŠ” 뢄듀이라면 맀우 μΆ”μ²œν•˜λŠ” κ°•μ˜ μž…λ‹ˆλ‹€! : )

λ°˜μ‘ν˜•