Python

파이썬

---

파이썬의 문법, 함수, 라이브러리 사용법 등에 대해서 공부한 내용을 정리하고 있습니다. (작성중)

✅del 예약어 vs remove()

del은 함수가 아니라 예약어이다.

del 예약어

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

여러개의 요소를 삭제할수도 있다.

>>> str_list = ['가','나','다','라','마']
>>> del str_list[3:]
['가','나','다']

사전 자료형에서도 사용할 수 있다.

>>> d={'one':'하나', 'two':'둘'}
>>> del d['one']
>>> d
{'two':'둘'}

remove()

remove함수는 값으로 array의 요소를 삭제한다.

>>> l=[1,2,2,3,3,3]
>>> l.remove(3)
>>> l
[1,2,2,3,3] 

3을 모두 제거하려면 다음과 같이 할 수 있다.

>>> for _ in l:
        l.remove(3)

>>> l

[1,2,2]

✅round함수

round(number,[, ndigits])

첫 번째 인자 : 반올림 하고싶은 숫자
두 번째 인자 : 나타내고 싶은 자릿수 (소수점 2번째 까지 반올림 하는 것을 원하면 2를 넣는다)
만약, 생략하면 첫 번째 인자 number에 가장 가까운 정수를 반환한다
이때 반올림 하려는 수가 올림, 내림 했을 때 동일하게 차이나는 경우 짝수 값으로 반올림 한다.

print(round(1.5))
>>> 2
print(round(2.5))
>>> 2

음수의 경우도 마찬가지 이다.

print(round(-1.5))
>>> -2
print(round(-2.5))
>>> -2

부동소수점의 문제

float 자료형을 쓸 때 항상 주의해야 한다

>>> 0.1 * 3 == 0.3
False
>>> 1.2 - 0.1 == 1.1
False
>>> 0.1 * 0.1 == 0.01
False

컴퓨터에서 부동소수점 숫자들은 2진 분수로 표현되기 때문에 꽤 많은 값들은 정확히 표현될 수 없다.

10진수 0.1은 2진 분수로 정확하게 표현될 수 없고 0.0001100110011001100110...과 같이 무한 반복된다. 따라서 특정 비트에서 멈췬뒤 근사값을 얻는다

해결책

decimal.Decimal

>> import decimal
>> decimal.Decimal('0.1') * 3 == decimal.Decimal('0.3')
True
>>> decimal.Decimal('0.3') + 2
Decimal('2.3')

round

>>> round(0.1 + 0.1 + 0.1, 10)==round(0.3,10)
True
>>> 0.1 + 0.1 + 0.1 == 0.3
False
# 0.1 + 0.1 + 0.1 은 0.3과 다르다
>>> decimal.Decimal(0.1 + 0.1 + 0.1)
Decimal('0.3000000000000000444089209850062616169452667236328125')
>>> decimal.Decimal(0.3)
Decimal('0.299999999999999988897769753748434595763683319091796875')

사전에 round()를 수행하는 것은 도움이 되지 않는다.

>>> round(0.1,1) + round(0.1,1) + round(0.1,1) == round(0.3,1)
False

✅집합 자료형(set)

set()의 괄호안에 리스트를 입력하거나 문자열을 입력하여 만들 수 있다.

>>> s1=set([1,2,3])
>>> s1
{1,2,3}

>>> s2 = set("Hello")
>>> s2
{'e','H','l','o'}

비어 있는 집합 자료형은 s=set()으로 만들 수 있다.

>>> s1 = set([1, 2, 3, 4, 5, 6])
>>> s2 = set([4, 5, 6, 7, 8, 9])

교집합 ( & )

>>> s1&s2
{4,5,6}

합집합 ( | )

>>> s1 | s2
{1, 2, 3, 4, 5, 6, 7, 8, 9}

차집합 ( - )

>>> s1 - s2
{1, 2, 3}

값 추가하기 (add)

>>> s1=set([1,2,3])
>>> s1.add(4)
>>> s1
{1,2,3,4}

값 여러개 추가하기(update)

>>> s1=set([1,2,3])
>>> s1.update([4,5,6])
>>> s1
{1,2,3,4,5,6}

특정 값 제거하기(remove)

제거 하려는 값이 없을경우 KeyError가 발생

>>> s1=set([1,2,3])
>>> s1.remove(2)
>>> s1
{1, 3}

특정 값 제거하기 (discard)

제거 하려는 값이 없어도 정상종료

✅문자열

문자열 자료형은 immutable하다.
즉 요소값을 변경할 수 없다.

>>> a = "Pithon"
>>> a[1]
'i'
>>> a[1] = 'y'
Error발생!

replace로 특정문자열 제거하기

replace(A, B)는 문자열의 A를 모두 B로 변경한 문자열을 return한다.

st='012001202'

new_st=st.replace('0','')

print(new_st)

>>>12122

0이 모두 제거된 문자열을 리턴!

이때 st.replace('0','',1)와 같이 세 번째 인자에 replace할 횟수를 지정할 수 있다.

st='012001202'

new_st=st.replace('0','',1)

print(new_st)

>>>12001202

✅리스트

리스트 더하기(+)

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

위치 반환(index)

>>> a = [1,2,3]
>>> a.index(3)
2
>>> a.index(1)
0

이때 없는 값을 넣으면 값 오류(ValueError)가 발생한다.

요소 삽입(insert)

>>> a = [1,2,3]
>>> a.insert(0,4)
>>> a
[4,1,2,3]

array.insert(i,x) array의 원하는 위치 i앞에 x를 추가한다.

pop

pop(0)을 호출하면 첫 번째 데이터를 제거할 수 있다.

extend()

array.extend(iterable) iterable의 각 요소를 하나씩 array의 끝에 요소로 추가한다. append와 다르게 괄호안에 iterable자료형만 올 수 있다.

join을 활용한 문자열 리스트 출력

리스트 l=['a','b','c','d','e']가 있을때 한 줄에 하나씩 출력하려면 보통

for i in l:
    print(i)

이렇게 했다.

더 빠르게 출력할 수 있는 방법이 하나 있는데 바로

print('\n'.join(l))

이렇게 하면 반복문을 돌리지 않고 더 빠른 속도로 출력이 가능하다.
하지만 문자열 리스트 일때만 가능하다는 것을 주의해야 한다!

print(*list)

a=[1,2,3,4,5]

print(*a)
# 1 2 3 4 5 

print할 때 리스트 앞에 *를 붙여주면 공백을 기준으로 원소들만 나열된다

map과 lambda를 이용한 리스트 두 개 더하기

list1=[1,2,3,4,5]
list2=[6,7,8,9,10]

result=list(map(lambda a,b:a+b,list1,list2))

print(result)

>>> [7, 9, 11, 13, 15]

lambda를 이용해 원소 내부의 값끼리 더할 수 있다.

이때 result=[map(lambda a,b:a+b,list1,list2)]로 하면 안된다.

l=list(map(int,input().split())) 은 되고
l=[map(int,input().split())] 은 안되는 것 처럼..

zip함수를 이용한 전치행렬

l=[[1,2,3],[4,5,6]]

print(list(zip(*l)))

>>> [(1, 4), (2, 5), (3, 6)]

2차원 배열 최댓값 찾기

map함수를 활용하면 2차원 배열의 최댓값을 찾을 수 있다.

vertices = [
    [1, 7, 12],
    [4, 7, 13],
    [1, 5, 17],
    [3, 5, 20],
    [2, 4, 24],
    [1, 4, 28],
    [3, 6, 37],
    [5, 6, 45],
    [2, 5, 62],
    [1, 2, 67],
    [5, 7, 73],
]

max_value = max(map(max, vertices))

print(max_value)

>>>73

✅사전

Key는 immutable

Key에 리스트를 쓸 수 없다.리스트가 변하는(mutable)한 값이기 때문
Key에 튜플을 쓸 수 있다. 튜플은 변하지 않는(immutable)한 값이기 때문

Key가 있는지 조사하기(in)

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> 'name' in a
True
>>> 'email' in a
False

(key가 존재하지 않을 경우) a.get(key) vs a[key]

a.get(k) : None을 리턴
a[k] : 오류를 발생

이때 None대신 리턴할 디폴트 값을 설정 가능

a.get(k,'hello')

None대신 'hello'를 리턴

최소 value를 가지는 key값 찾기

dic={1:99,2:98,3:97}
min(dic)

>>> 1

딕셔너리에 min함수를 적용하면 key값 중 가장 작은 key를 리턴한다

dic={1:99,2:98,3:97}
min(dic,key=dic.get)

>>> 3

min함수에 key로 dic.get 즉 value를 설정하면

value가 가장작은 key를 리턴한다

사전 정렬하기

사전에 대해 sorted함수를 수행 할 때 items()함수를 꼭 써줘야 한다!!

dic = {'pop': 3100, 'classic': 1450, 'trot':620}

print(sorted(dic.items(),key=lambda x:x[1]))

print(dict(sorted(dic.items(),key=lambda x:x[1])))

>>> [('trot', 620), ('classic', 1450), ('pop', 3100)]
>>> {'trot': 620, 'classic': 1450, 'pop': 3100}

✅split 함수

문자열.split() : 문자열을 일정한 규칙으로 잘라서 리스트로 만들어 준다.

✅ reverse, reversed, [::-1]

• revesre: 리스트를 거꾸로 뒤집음 (l.reverse())
• reversed : 문자열, 리스트를 거꾸로 뒤집고 뒤집은 값을 리턴 (reversed_s=revesred(s))

  출력방법 : print(''.join(reversed(s)))

• [::-1] : 처음부터 끝까지 거꾸로
• [3::-1] : 3번 인덱스부터 0번 인덱스 까지 거꾸로

✅sort() 와 sorted()

sort() : 리스트형의 메소드, 리스트 원본값을 직접 수정
sorted() : 내장 메소드, 원본값은 그대로 두고 정렬한 값을 리턴

참고 : map객체를 sorted로 감싸면 리스트가 리턴된다.

a1=[6,3,9]

a2 = a1.sort()

print(a1)
print(a2)
# [3,6,9]
# None

a1=[6,3,9]
a2=sorted(a1)

print(a1)
print(a2)
# [6,3,9]
# [3,6,9]

sort()와 sorted()에서 내림차순으로 정렬하고자 한다면 reverse매개변수에 True를 주면 된다.
a1.sort(reverse=True), sorted(a1,reverse=True)

---

sort()와 sorted() 모두 이차원 리스트에 대해서도 정렬을 수행한다.

[(3, 4), (1, 1), (1, -1), (2, 2), (3, 3)]

위와 같은 2차원 리스트에 정렬을 수행할 수 있다.

[(1, -1), (1, 1), (2, 2), (3, 3), (3, 4)]

0번째 인덱스를 기준으로 정렬하고, 0번째 인덱스의 값이 같을경우 1번째 인덱스를 기준으로 정렬한다!

---

key 매개변수로 정렬 기준값을 지정할 수 있다

l.sort(key=lambda x: (x[1]))

lambda를 사용하여 정렬 기준을 정해줄 수 있다.
위 코드는 두 번째 값을 기준으로 정렬을 수행한다.

l.sort(key=lambda x: (x[1],x[0]))

두 번째 값을 기준으로 정렬하고, 같을경우 첫 번째 값을 기준으로 졍렬하는 것이다.

l.sort(key=lambda x: (x[0],-x[1]))

첫 번째 값을 기준으로 오름차순 정렬하고, 두 번째 값을 기준으로 내림차순 정렬하는 것이다.

l.sort(key=lambda x: len(x))

길이를 기준으로 정렬하는 것이다.

✅자료형의 참과 거짓

• 1 : 참
• [1,2,3] : 참
• "python" : 참
• [],(),{} : 거짓
• "" : 거짓
• 0 : 거짓
• None : 거짓

✅Counter 클래스

데이터의 개수를 셀 때 유용한 collections 모듈의 Counter 클래스이다.

from collections import Counter

print(Counter('hello world'))

# Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

딕셔너리 형태로 반환 되기때문에, 루프 형태로 돌릴 수 도 있다.

value='hello world'
countValue=Counter(value)
for key,value in countValue.items():
    print(key,':',value)

h : 1
e : 1
l : 3
o : 2
  : 1
w : 1
r : 1
d : 1

추가로 most_common() 메소드를 사용하여 상위요소를 반환 할 수도 있다.

from collections import Counter

print(Counter('hello world').most_common())
# [('l', 3), ('o', 2), ('h', 1), ('e', 1), (' ', 1), ('w', 1), ('r', 1), ('d', 1)]

이때 인자로 숫자 k를 넣어주면 상위 k개의 데이터를 얻을 수도 있다.

from collections import Counter

print(Counter('hello world').most_common(1))
# [('l', 3)]

✅find() vs index()

• find()
  문자열에서 사용 가능
  리스트, 튜플, 딕셔너리에서 사용 불가능
  찾는 문자가 없는 경우 -1을 출력

• index()
  문자열, 리스트, 튜플에서 사용 가능
  딕셔너리에서 사용 불가능
  찾는 문자가 없는 경우 ValueError 발생

✅Queue vs deque(덱)

deque는 Queue와 다르게 인덱싱이 가능하다. (메소드 사용법도 리스트와 매우 흡사)

Queue : put(), get()
deque : append(),pop()

deque(덱) 메서드(method)

• deque.append(item): item을 데크의 오른쪽 끝에 삽입한다.
• deque.appendleft(item): item을 데크의 왼쪽 끝에 삽입한다.
• deque.pop(): 데크의 오른쪽 끝 엘리먼트를 가져오는 동시에 데크에서 삭제한다.
• deque.popleft(): 데크의 왼쪽 끝 엘리먼트를 가져오는 동시에 데크에서 삭제한다.
• deque.extend(array): 주어진 배열(array)을 순환하면서 데크의 오른쪽에 추가한다.
• deque.extendleft(array): 주어진 배열(array)을 순환하면서 데크의 왼쪽에 추가한다.
• deque.remove(item): item을 데크에서 찾아 삭제한다.
• deque.rotate(num): 데크를 num만큼 회전한다(양수면 오른쪽, 음수면 왼쪽).
• len(deque): deque의 크기를 알려준다.

  ✅주요 연산자 시간복잡도

리스트

• append : O(1)
• pop()=pop(-1) : O(1)
• len(l) : O(1)
• clear() : O(1)
• l[a:b] : O(b-a)
• pop(0), pop(i) : O(N)
• insert, delete, remove : O(N)
• sort : O(N Log N)
• extend : O(len(…)) 확장 길이에 따라

✅데이터 크기에 따른 적합한 복잡도

N ; 데이터 크기
N < 500; 시간 복잡도 O(N*3)
N < 2,000; 시간 복잡도 O(N*2)
N < 10,000; 시간 복잡도 O(NlogN)
N < 10,000,000; 시간 복잡도 O(N)