파이썬 기본 문법

이태혁·2020년 9월 30일
python
0

🦊 함수 정의

def f(x,y):
	z = x + y
	return z
print(f(3, 5))

🦊 함수내에서 global 참조

a = 1
def aplus():
	global a
	a += 10
	return a
print(aplus())

🦊 리스트(javascript와 비교)

li = [1, 1, 2, 3, 4, 5]
print(li)
print(type(li))
print(dir(li))

li.append('a') # [1, 1, 2, 3, 4, 5, 'a']
# append = push
print(li)

print(li.count(1)) #2

li.extend([11, 22])
print(li) #[1, 1, 2, 3, 4, 5, 'a', 11, 22]
# extend = concat

print(li.index(1)) # 0
# index = indexOf

#pop() = pop
#argument 없으면 맨뒤에꺼 삭제, 값이 있으면 해당 번째 삭제

li.insert(1, 3000) #[1, 3000, 1, 2, 3, 4, 5, 'a', 11, 22]
#insert(몇번째, 값)
print(li)

li.remove(100)
# 처음 만나는 100을 지움

#reverse() = reverse

#sort() = sort()


#sorte(), reversed()도 있는데 이거는 원 리스트는 놔두고 새로운 리턴을 만들어

🦊 copy()

  • list나 dictionary 에서
a = [1, 2, 3]
b = a
b[0] = 111
#a = [111, 2, 3]으로 바뀜
  • 위처럼 참조를 할때 얕은 복사가 된다.
  • 깊은 복사를 하려면 b = a.copy()를 붙여주면 된다.

🦊 반복문

a = 10
while a < 15:
	print('hello world')
    a += 1
a = 1
while a < 5:
	print('hi')
    a += 1
else :
	print('bye')
"""
결과
hi
hi
hi
hi
bye
"""
  • while뒤에then을 쓸 수도 있음
  • while이 정상적으로 완료되면 실행됨
    • break로 끝나면 실행 안됨

🦊 반복문에서 언더바 '_'

  • i가 횟수정보만을 담고 있을 때 쓰임
for _ in range(5)
    print("Hello World")

🦊 for in

l = [1, 2, 3, 4]
s = {1, 2, 3, 4}
d = {'one':1, 'two':2}

for i in l:
	print(i)
"""
1
2
3
4
"""
for i in s:
	print(i)
"""
1
2
3
4
"""
for i in d:
	print(i)
"""
one
two
"""

🦊 range

#range(start, stop, step)
print(type(range(1)))
print(1, list(range(10)))
print(2, list(range(5, 10)))
print(3, list(range(2, 10, 2)))
print(4, list(range(10, 5, -1)))
print(5, list(range(-10)))
"""
<class 'range'>
1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2 [5, 6, 7, 8, 9]
3 [2, 4, 6, 8]
4 [10, 9, 8, 7, 6]
5 []
"""

🦊 문자열 for

for i in 'hello world'
    print(i)

🦊 리스트

  • 여러개 초기화하기
a = [0] * 10
print(a)
#결과
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

🦊 슬라이싱

  • start인덱스는 그대로 end 인덱스는 1더해서
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[1:4])
#결과
#[2,3,4]

🦊 지능형 리스트(list comprehension)

l = [i for i in range(10)]
print(l)

for i in range(2, 10):
	for  j in range(1, 10):
		print('{} X {} = {}'.format(i, j, i*j));

ll = ['{} X {} = {}'. format(i, j, i*j) for i in range(2, 10) for j in range(1, 10)]

  • 두번째와 세번째의 구구단 코드는 같은 결과임

  • 지능형 리스트에 조건문도 쓸 수 있음

array = [i for i in range(20) if i % 2 == 1]
print(array)
#[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
  • 이차원 리스트를 간단하게 초기화 할 수 있음
m = 2
n = 3
array = [[0] *m for _ in range(n)]
print(array)
#[[0, 0], [0, 0], [0, 0]]
  • 주의 
array = [[0*m]*n

이렇게 쓰면 안됨
이때는 똑같은 행이 n개 생긱는거라서 행안에 데이터가 바뀌면 모든 행 데이터가 똑같이 바뀜

🦊 실수형 지수 표현 방식

a = 1e9 -> 1 10^9
b = 75.25e1 -> 75.2510^1 -> 752.5
c = 3954e-3 -> 3.954

  • 지수 표현 방식은 모두 실수형이므로 정수형이 필요한경우 int(a)로 정수형으로 변환하면 된다.

🦊 문자열 연산

a = "String"
print(a*3)
"""
StringStringString
"""

b = "ABCDEF"
print(a[2:4])
"""
CD
이때 글자를 바꿀수는 없음 (immutable)
"""

🦊 튜플 자료형

  • 튜플은 선언 후 변경 불가
  • 리스트에 비해 상대적으로 공간 효율적(적은양의 메모리 사용)

🦊 딕셔너리

  • dict = ('키':'값')
  • 키 값으로는 immutable한 것만 올 수 있음 (문자열, 튜플)
  • 데이터 조회 및 수정에 O(1)의 시간이 걸림

🦊 딕셔너리 키, 밸류로 찾기

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'

print(data)

if '사과' in data:
	print('사과 in data')

if '사과' in data.keys():
	print('keys()에 사과가 있습니다.')

if 'Apple' in data.values():
	print('values()에 Apple이 있습니다')
"""
{'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}
사과 in data
keys()에 사과가 있습니다.
values()에 Apple이 있습니다
"""

🦊 딕셔너리 반복문

a = {}
#키로 반복
for key in a:
  print(a)

#키, 밸류로 반복
for key, value in a.items():
  print(key, value)

🦊 set

  • 리스트나 문자열로 초기화 할 수 있음
  • 데이터의 조회 및 수정에 O(1)의 시간이 걸림

🦊 set 초기화

  • 방법 1: data = set([1,2,3])
  • 방법 2: data = {1, 2, 3}

🦊 set 연산

  • 합집합 : a|b
  • 교집합 : a&b
  • 차집합 : a-b

🦊 원소 추가, 삭제, 확장

data = {1, 2, 3}
data.add(11) # {1, 2, 3, 11}
data.update([4, 5]) # {1, 2, 3, 11, 4, 5}
data.remove(2) # {1, 3, 11, 4, 5}

🦊 함수

def functionName(parameter):
	#code
    return result

🦊 스트링 길이

str1 = "hello"
print(len(str1))

🦊 sort(), sorted()

li = [1, 9, 3, 2]
#방법1
print(sorted(li))

#방법2
li.sort()
print(li)

#문자열에서 정렬
string = 'adfasdf'
result = "".join(sorted(string))
print(result)

🦊 형변환

문자열로 : str()
숫자로 : int()

🦊 자료구조: stack

stack = []
stack.append(3) #O(1)
stack.append(2)
stack.append(5)
stack.append(1)
stack.append(1)
stack.pop()      #O(1)
stack.append(5)

print(stack[::-1]) #위부터 출력
print(stack) #밑부터 출력

🦊 자료구조: queue

  • 리스트로 구현할 수도 있지만 deque라이브러리를 이용하는게 시간복잡도가 더 작음.
  • popleft가 리스트에서는 O(n), deque에서는 O(1)의 복잡도를 갖음. 출처
from collections import deque

# 큐 구현을 위해 deque 라이브러리 이용
queue = dequeue()

queue.append(5)  #O(1)
queue.append(2)
queue.append(1)
queue.append(3)
queue.append(1)
queue.popleft() #O(1)

print(queue) #먼저 들어온 원소부터 출력
queue.reverse() #역순으로 바꿈
print(queue) #나중에 들어온 원소부터 출력
  • 아래 두개 메소드도 있음
queue.appendleft()
queue.pop()

🦊 deque 초기화

queue = deque() #빈 큐 생성
queue = deque([1,2]) #1,2가 들어가 있는 큐 생성 (왼쪽이 먼저 오른쪽이 나중 순서)

🦊 if not

#두개가 똑같음
if a == False:
if not a:

🦊 원소가 다 비워질때까지

#두개가 똑같음
while len(li) > 0:
while li:

🦊 표준입력(input)

  • 공백으로 나뉜 데이터 받기
data = list(map(int, input().split()))
  • 데이터가 많지 않으면 이것도 가능
a, b, c = map(int, input().split())

🦊 여러줄의 표준입력(input)

array = []
for i in range(n):
    array.append(int(input()))

🦊 표준입력(readline())

import sys
data = sys.stdin.readline().rstrip()
  • 뒤에 rstrip()이 엔터를 구분해주는듯

🦊 표준 출력

print(2, end=" ")
print(2, '곱하기', 2)
print(f"정답은 {2*2}입니다")

🦊 이차원 배열 입력받기

n, m = map(int, input().split())
graph = []
for i in range(n):
	graph.append(list(map(int, input())))
print(graph)
"""
입력형태
3 4
1234
1234
4321

🦊 리스트, 딕셔너리 반복문(인덱스 포함)

>>> D1 = {1:'a', 2:'b', 3:'c'} 
>>> for k in D1.keys():
   print (k, D1[k])
1 a
2 b
3 c
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave
statesAndCapitals = { 
                     'Gujarat' : 'Gandhinagar', 
                     'Maharashtra' : 'Mumbai', 
                     'Rajasthan' : 'Jaipur', 
                     'Bihar' : 'Patna'
                    } 
for capital in statesAndCapitals.values(): 
    print(capital) 
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

🦊 딕셔너리에 해당 키가 있는지 체크

if key in dictionary.keys():

🦊 깊은 복사 & 얕은복사

얕은복사: 한쪽의 수정이 다른쪽에 영향을 줌
깊은복사: 둘의 연결이 끊김

#얕은복사
new_list = list(original_list)
new_dict = dict(original_dict)
new_set = set(original_set)
#깊은복사
>>> import copy
>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> zs = copy.deepcopy(xs)

🦊 join

''.join(['h', 'e', 'l', 'l', 'o'])
>>>'hello'

🦊 map, lambda, join의 혼합 사용

a = [ 1, 2, 3, 4]
print(' '.join(map(lambda x: str(x + 1), a)))

리스트 a에 모든 원소를 1씩 더해서 string으로 변환후 공백으로 join해서 출력

🦊 defaultdict

from collections import defaultdict
d = defaultdict(lambda: defaultdict(lambda: -1))
new_d = defaultdict(lambda: [])

🦊 ascii(아스키) 변환

>>> ord('a')
97
>>> chr(97)
'a'
>>> chr(ord('a') + 3)
'd'
>>>

🦊 2차원 배열 정렬하기

costs.sort(key=lambda x: x[2] )
## 기준이 2개일 때
scoreArray.sort(key=lambda x:(-x[1], x[0]))

🦊 몫 나머지 한번에 구하기

n = 250
min, second = divmod(250, 60)
#min = 4, second = 10

🦊 글자수 카운팅(배열, 문자열 둘다 가능)

s = "aabbaccc"
#방법1
from collections import defaultdict
result1 = defaultdict(int)
for c in s:
    result1[c] += 1
print(result1)
print(dict(result1))
>>defaultdict(<class 'int'>, {'a': 3, 'b': 2, 'c': 3})
>>{'a': 3, 'b': 2, 'c': 3}

#방법 2
result2 = dict()
for c in set(s):
    result2[c] = s.count(c)
print(result2)
>>{'b': 2, 'c': 3, 'a': 3}


#방법3
from collections import Counter
result3 = Counter(s)
print(result3)
print(dict(result3))
>>Counter({'a': 3, 'c': 3, 'b': 2})
>>{'a': 3, 'b': 2, 'c': 3}

🦊 combinations(나열, 갯수)

from itertools import combinations

combi = combinations("abc", 2)
print(list(combi))
>>[('a', 'b'), ('a', 'c'), ('b', 'c')]
import math
n = 4
r = 2
print (math.comb(n, k))
>>6

🦊 배열 복사하기

# 1차원인 경우
li = [1, 2, 3]
a = li[:]
b = li.copy()
# 2차원인 경우
from copy import deepcopy
li2 = [[1,2],[3,4]]
c = deepcopy(li2)

🦊 딕셔너리 안전하게 참조하기

dic = {'a':1, 'b':3, 'c':2}
print(dic.get('a', [])) #1
print(dic.get('d', [])) #[], 존재하지 않는 키를 참조하면 두번째 인자를 돌려줌
print(dic.get('d'))     #None, 두번째 인자를 안주면 기본으로 None

🦊 딕셔너리에서 최대 value값 찾기

dic = {'a':1, 'b':3, 'c':2}

print(max(dic, key=dic.get)) # b

🦊 Counter를 이용해 제일 자주 등장하는 값찾기

from collections import Counter
li = ['a', 'b', 'b', 'b', 'c', 'c']
counter = Counter(li)
print(counter) #Counter({'b': 3, 'c': 2, 'a': 1})
a = counter.most_common(1)
print(a[0][0]) #b

🦊 파이썬에서 DFS 쓸때 콜스택 한계 늘려놓기

import sys
sys.setrecursionlimit(300000)
profile
이태혁
back-end, cloud, docker, web의 관심이 있는 예비개발자입니다.
이전 포스트

How to Remove Array Duplicates in ES6(link)

다음 포스트

계전기(relay), 진공관, 트랜지스터- 컴퓨터의 발전

0개의 댓글