Python 멋대로 정리
1. List
[ ] 으로 나타냄, 갱신가능, mutable
x=[1,2,3,4]
xx = ["hello", "there"]
num_elements = len(x) # 4
y = sorted(x)
print(y)
z = sum(x)
print(z)
for n in x:
print(n) #list안에 있는 element를 차례대로 다 출력
print(x.index(3)) #3이란 숫자의 index를 알려준다. 2
print(xx.index("hello")) #hello란거의 index를 알려준다. 0
print("hello" in xx) #hello가 xx에 있는가? -> True
2. Tuple
( ) 으로 나타냄, 갱신 불가능, immutable
x = (1,2,3)
y = ('a', 'b', 'c')
z = (1, "hello", "there")
print(x+y)
print('a' in y)
print(z.index("hello"))
x[0] = 10 #이거는 안됨. 불가변하기때문에
3. Dictionary
{ } 으로 나타냄, x = { key1 : , key 2:, . . . } , 여기서 key에 list는 가변이라서 못씀, 갱신이 가능하여 바꾸거나 새로운거 집어넣을수 있음.
x.keys() 와 x.values() 요런식으로 가능
x = dict()
y = {}
# 이렇게 두가지 방식으로 만들 수 있음
x = {
0: "hello",
1: "Bye",
"name" : "근수",
"age" : 27, #마지막에 반점 꼭 찍어야함
}
print(x["name"]) # 근수출력
print(x[0]) # hello 출력됨
print("age" in x) # True 출력
print(x.keys()) # 모든 key 값 출력
print(x.values()) # 모든 values 값 출력
for key in x:
print(key) #dict인 x의 모든 key값 탐색하면서 출력
print(x[key]) #dict인 x의 모든 values값 탐색하면서 출력
x[0] = "Fuck you" #여기서 "hello"를 "Fuck you"로 변경 가능
x["school"] = "경북대" #여기서는 이러한 key값과 value를 추가로 생성 가능
반복문
while 중에 continue사용 가능, 바로 위로 올라감
if, elif, else
if ~~~ :
else ~ :
여러라인 출력하려면
z = """
안녕
이렇게
여러 줄로
하려면 큰따움표 세번
"""
Class
class Person:
def __init__(self, name):# 여기서 name은 받을 인자임 여기서 더받으려면 쭉쭊가능
self.name = name
def say_hello(self, to_name): # say_hello에 받을 인자를 self다음으로 쭉쭉
print("Hi " + to_name +" my name is " + self.name)
justin = Person("justin")
justin.say_hello("Tom")
class Police(Person): #Police란 class가 Person이라는 clamss를 상속함
def arrest(self, to_arrest):
print("under arrested, " + to_arrest)
justin = Person("justin")
jenny = Police("Jenny")#Jenny는 Person과 Police의 함수들을 다 공짜로 사용가능
jenny.arrest("justin")#요렇게 사용가능
Package
package안에 module들을 만들어보자
animal이라는 Package안에 3개의 파일이 있음
dog.py
class DogClass:
def hi(self):
print("bark!")
cat.py
class CatClass:
def hi(self):
print("meow")
_init__.py
from .cat import CatClass # .을 찍은거는 이 폴더에 있는 이라는 의미이고 cat이라는 파일에서 Cat이라는 클래스를 갖고와줘
from .dog import DogClass # 동일함
밖에 main.py
from animal.dog import DogClass # animal 패키지에서 dog라는 모듈을 갖고와줘
from animal.cat import CatClass # animal 패키지에서 cat라는 모듈을 갖고와줘
d = dog.DogClass()
d.hi()
c = cat.CatClass()
c.hi()
from animal import * # animal 패키지가 갖고 있는 모듈을 다 갖고와
d = DogClass()
c = CatClass()
d.hi()
c.hi()
이런식으로 다른 패키지를 가져올 수 있음
List에서의 append vs extend
list.append(x) : 리스트 끝에 x 한개를 넣음
list.extend(itrable) : 리스트 끝에 iterable의 모든 항목을 넣음
- append
x = ['A', 'B', 'C']
y = ['D', 'E']
x.append(y)
print ('x : ', x)
# x : ['A', 'B', 'C', ['D', 'E']]
- extend
x = ['A', 'B', 'C']
y = ['D', 'E']
x.extend(y)
print ('x : ', x)
# x : ['A', 'B', 'C', 'D', 'E']
List의 2차원 배열 만들고, 모든 원소 뽑기
2차원 배열 만들기
# 동적
array = [[0 for row in range(11)] for col in range(10)]
# row : 행 = 가로줄, col : 열 = 세로줄
# 정적
array = [[0] * 11] * 10
2차원 배열 원소 모두 뽑기
for element in array: #만약 array의 열이 3이면
i, j, k = element[0], element[1], element[2] #이것도 가능하고
i, j, k = element # 이것도 가능함
import numpy
import numpy
numpy.zeros((5,5))
#5*5배열의 0으로 된 2차원 배열 생성
Slice 함수
array = []
slice = array[i-1:j] #i번째부터 j번째까지 잘라옴
enumerate 함수
리스트가 있는 경우, 순서와 리스트의 값을 전달하는 기능을 가짐.
이 함수는 순서가 있는 자료형 (list, set, tuple, dictionary, string)을 입력으로 받아 인덱스 값을 포함하는 enumerate 객체를 리턴함.
for문과 함께 사용됨
for i, name in enumerate(['body', 'foo', 'bar']):
print(i, name)
# 0 body 1 foo 2 bar
abs 함수
abs(x)는 절댓값 x를 돌려주는 함수
>>>abs(3)
3
>>>abs(-3)
3
>>>abs(-1.2)
1.2
all
all(x)는 반복 가능한(iterable) 자료형 x를 입력 인수로 받으며 이 x의 요소가 모두 참이면 True, 거짓이 하나라도 있으면 False를 돌려준다.
※ 반복 가능한 자료형이란 for문으로 그 값을 출력할 수 있는 것을 의미한다. 리스트, 튜플, 문자열, 딕셔너리, 집합 등이 있다.
다음 예를 보자.
>>> all([1, 2, 3])
True
리스트 자료형 [1, 2, 3]은 모든 요소가 참이므로 True를 돌려준다.
>>> all([1, 2, 3, 0])
False
리스트 자료형 [1, 2, 3, 0] 중에서 요소 0은 거짓이므로 False를 돌려준다.
>>> all([])
True
만약 all의 입력 인수가 빈 값인 경우에는 True를 리턴한다. (주의)
any
any(x)는 반복 가능한(iterable) 자료형 x를 입력 인수로 받으며 이 x의 요소 중 하나라도 참이 있으면 True를 돌려주고, x가 모두 거짓일 때에만 False를 돌려준다. all(x)의 반대이다.
다음 예를 보자.
>>> any([1, 2, 3, 0])
True
리스트 자료형 [1, 2, 3, 0] 중에서 1, 2, 3이 참이므로 True를 돌려준다.
>>> any([0, ""])
False
리스트 자료형 [0, ""]의 요소 0과 ""은 모두 거짓이므로 False를 돌려준다.
>>> any([])
False
만약 any의 입력 인수가 빈 값인 경우에는 False를 리턴한다.
chr
chr(i)는 아스키(ASCII) 코드 값을 입력받아 그 코드에 해당하는 문자를 출력하는 함수이다.
>>> chr(97)
'a'
>>> chr(48)
'0'
divmod
divmod(a, b)는 2개의 숫자를 입력으로 받는다. 그리고 a를 b로 나눈 몫과 나머지를 Tuple 형태로 돌려주는 함수이다.
>>> divmod(7, 3)
(2, 1)
몫을 구하는 연산자 //
와 나머지를 구하는 연산자 %
를 각각 사용한 결과와 비교해 보자.
>>> 7 // 3
2
>>> 7 % 3
1
eval
eval(expression )은 실행 가능한 문자열(1+2, 'hi' + 'a' 같은 것)을 입력으로 받아 문자열을 실행한 결괏값을 돌려주는 함수이다.
>>> eval('1+2')
3
>>> eval("'hi' + 'a'")
'hia'
>>> eval('divmod(4, 3)')
(1, 1)
보통 eval은 입력받은 문자열로 파이썬 함수나 클래스를 동적으로 실행하고 싶을 때 사용한다.
find
find( 찾을 문자, 찾기 시작할 위치)
find함수는 문자열 중에 특정 문자를 찾고 위치를 반환해준다. 없을 경우 -1을 반환한다.
string = 'abcdefghijklmnop'
s.find(a) >> 0
s.find(b) >> 1
s.find(z) >> -1
startswith
startswith(시작하는 문자, 시작 지점)
startswith 함수는 문자열이 특정 문자로 시작하는지 여부를 알려준다
string = 'abcdefghijklmnop'
s.find(a) >> 0
s.find(b) >> 1
s.find(z) >> -1
filter
filter 함수는 첫 번째 인수로 함수 이름을, 두 번째 인수로 그 함수에 차례로 들어갈 반복 가능한 자료형을 받는다. 그리고 두 번째 인수인 반복 가능한 자료형 요소가 첫 번째 인수인 함수에 입력되었을 때 반환 값이 참인 것만 묶어서(걸러 내서) 돌려준다.
다음 예를 보자.
#positive.py
def positive(l):
result = []
for i in l:
if i > 0:
result.append(i)
return result
print(positive([1,-3,2,0,-5,6]))
결과값: [1, 2, 6]
즉 위에서 만든 positive 함수는 리스트를 입력값으로 받아 각각의 요소를 판별해서 양수 값만 돌려주는 함수이다.
filter 함수를 사용하면 위 내용을 다음과 같이 간단하게 작성할 수 있다.
#filter1.py
def positive(x):
return x > 0 #와 이렇게 함수 return값에 0보다 크다라고 지정해두면 filter 함수를 쓰면 두줄만에 정리가 되는구나!
print(list(filter(positive, [1, -3, 2, 0, -5, 6])))
결과값: [1, 2, 6]
여기에서는 두 번째 인수인 리스트의 요소들이 첫 번째 인수인 positive 함수에 입력되었을때 반환 값이 참인 것만 묶어서 돌려준다. 앞의 예에서는 1, 2, 6만 양수여서 x > 0 문장이 참이되므로 [1, 2, 6]이라는 결괏값을 돌려주게 된 것이다.
앞의 함수는 lambda를 사용하면 더욱 간편하게 코드를 작성할 수 있다.
>>> list(filter(lambda x: x > 0, [1, -3, 2, 0, -5, 6])) #labda 함수는 return값을 더욱 간단하게 바로 지정할 수 있구나!
[1, 2, 6]
hex
hex(x)는 정수 값을 입력받아 16진수(hexadecimal)로 변환하여 돌려주는 함수이다.
>>> hex(234)
'0xea'
>>> hex(3)
'0x3'
id
id(object)는 객체를 입력받아 객체의 고유 주소 값(레퍼런스)을 돌려주는 함수이다.
>>> a = 3
>>> id(3)
135072304
>>> id(a)
135072304
>>> b = a
>>> id(b)
135072304
위 예의 3, a, b는 고유 주소 값이 모두 135072304이다. 즉 3, a, b가 모두 같은 객체를 가리키고 있다.
만약 id(4)라고 입력하면 4는 3, a, b와 다른 객체이므로 당연히 다른 고유 주소 값이 출력된다.
>>> id(4)
135072292
isinstance
isinstance(object, class )는 첫 번째 인수로 인스턴스, 두 번째 인수로 클래스 이름을 받는다. 입력으로 받은 인스턴스가 그 클래스의 인스턴스인지를 판단하여 참이면 True, 거짓이면 False를 돌려준다.
>>> class Person: pass
...
>>> a = Person()
>>> isinstance(a, Person)
True
위 예는 a가 Person 클래스가 만든 인스턴스임을 확인시켜 준다.
>>> b = 3
>>> isinstance(b, Person)
False
b는 Person 클래스가 만든 인스턴스가 아니므로 False를 돌려준다.
len
len(s)은 입력값 s의 길이(요소의 전체 개수)를 돌려주는 함수이다.
>>> len("python")
6
>>> len([1,2,3])
3
>>> len((1, 'a'))
2
list
list(s)는 반복 가능한 자료형 s를 입력받아 리스트로 만들어 돌려주는 함수이다.
>>> list("python")
['p', 'y', 't', 'h', 'o', 'n'] #오 이렇게도 되는군
>>> list((1,2,3))
[1, 2, 3]
list 함수에 리스트를 입력으로 주면 똑같은 리스트를 복사하여 돌려준다.
>>> a = [1, 2, 3]
>>> b = list(a) # 오 이렇게 하면 리스트를 복사할수 도 있겠군
>>> b
[1, 2, 3]
map
map(f, iterable)은 함수(f)와 반복 가능한(iterable) 자료형을 입력으로 받는다. map은 입력받은 자료형의 각 요소를 함수 f가 수행한 결과를 묶어서 돌려주는 함수이다.
map함수쓸때 첫번째 인자 join으로 하면 문자열로 반환합니다!
다음 예를 보자.
# two_times.py
def two_times(numberList):
result = [ ]
for number in numberList:
result.append(number*2)
return result
result = two_times([1, 2, 3, 4])
print(result)
two_times 함수는 리스트 요소를 입력받아 각 요소에 2를 곱한 결괏값을 돌려준다. 실행 결과는 다음과 같다.
결과값: [2, 4, 6, 8]
위 예제는 map 함수를 사용하면 다음처럼 바꿀 수 있다.
>>> def two_times(x):
... return x*2
...
>>> list(map(two_times, [1, 2, 3, 4]))
[2, 4, 6, 8]
이제 앞 예제를 해석해 보자. 먼저 리스트의 첫 번째 요소인 1이 two_times 함수의 입력값으로 들어가고 1 * 2
의 과정을 거쳐서 2가 된다. 다음으로 리스트의 두 번째 요소인 2가 2 * 2
의 과정을 거쳐 4가 된다. 따라서 결괏값 리스트는 이제 [2, 4]가 된다. 총 4개의 요솟값이 모두 수행되면 마지막으로 [2, 4, 6, 8]을 돌려준다. 이것이 map 함수가 하는 일이다.
※ 위 예에서 map의 결과를 리스트로 보여 주기위해 list 함수를 사용하여 출력하였다.
앞의 예는 lambda를 사용하면 다음처럼 간략하게 만들 수 있다.
>>> list(map(lambda a: a*2, [1, 2, 3, 4]))
[2, 4, 6, 8]
max
max(iterable)는 인수로 반복 가능한 자료형을 입력받아 그 최댓값을 돌려주는 함수이다.
>>> max([1, 2, 3])
3
>>> max("python")
'y'
min
min(iterable)은 max 함수와 반대로, 인수로 반복 가능한 자료형을 입력받아 그 최솟값을 돌려주는 함수이다.
>>> min([1, 2, 3])
1
>>> min("python")
'h'
oct
oct(x)는 정수 형태의 숫자를 8진수 문자열로 바꾸어 돌려주는 함수이다.
>>> oct(34)
'0o42'
>>> oct(12345)
'0o30071'
open
open(filename, [mode])은 "파일 이름"과 "읽기 방법"을 입력받아 파일 객체를 돌려주는 함수이다. 읽기 방법(mode)을 생략하면 기본값인 읽기 전용 모드(r)로 파일 객체를 만들어 돌려준다.
mode | 설명 |
---|---|
w | 쓰기 모드로 파일 열기 |
r | 읽기 모드로 파일 열기 |
a | 추가 모드로 파일 열기 |
b | 바이너리 모드로 파일 열기 |
b는 w, r, a와 함께 사용한다.
>>> f = open("binary_file", "rb")
위 예의 rb는 "바이너리 읽기 모드"를 의미한다.
다음 예의 fread와 fread2는 동일한 방법이다.
>>> fread = open("read_mode.txt", 'r')
>>> fread2 = open("read_mode.txt")
즉 모드 부분을 생략하면 기본값으로 읽기 모드 r를 갖게 된다.
다음은 추가 모드(a)로 파일을 여는 예이다.
>>> fappend = open("append_mode.txt", 'a')
ord
ord(c)는 문자의 아스키 코드 값을 돌려주는 함수이다.
※ ord 함수는 chr 함수와 반대이다.
>>> ord('a')
97
>>> ord('0')
48
pow
pow(x, y)는 x의 y 제곱한 결괏값을 돌려주는 함수이다.
>>> pow(2, 4)
16
>>> pow(3, 3)
27
range
range([start,] stop [,step] )는 for문과 함께 자주 사용하는 함수이다. 이 함수는 입력받은 숫자에 해당하는 범위 값을 반복 가능한 객체로 만들어 돌려준다.
인수가 하나일 경우
시작 숫자를 지정해 주지 않으면 range 함수는 0부터 시작한다.
>>> list(range(5))
[0, 1, 2, 3, 4]
인수가 2개일 경우
입력으로 주어지는 2개의 인수는 시작 숫자와 끝 숫자를 나타낸다. 단 끝 숫자는 해당 범위에 포함되지 않는다는 것에 주의하자.
>>> list(range(5, 10))
[5, 6, 7, 8, 9]
인수가 3개일 경우
세 번째 인수는 숫자 사이의 거리를 말한다.
>>> list(range(1, 10, 2)) # 오 이렇게 1부터 10까지 2만큼의 간격의 list로도 출력할수 있구만
[1, 3, 5, 7, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
round
round(number[, ndigits]) 함수는 숫자를 입력받아 반올림해 주는 함수이다.
※ [, ndigits]는 ndigits가 있을 수도 있고 없을 수도 있다는 의미이다.
>>> round(4.6)
5
>>> round(4.2)
4
다음과 같이 실수 5.678을 소수점 2자리까지만 반올림하여 표시할 수 있다.
>>> round(5.678, 2)
5.68
round 함수의 두 번째 매개변수는 반올림하여 표시하고 싶은 소수점의 자릿수(ndigits)이다.
sorted
sorted(iterable) 함수는 입력값을 정렬한 후 그 결과를 리스트로 돌려주는 함수이다.
>>> sorted([3, 1, 2])
[1, 2, 3]
>>> sorted(['a', 'c', 'b'])
['a', 'b', 'c']
>>> sorted("zero")
['e', 'o', 'r', 'z']
>>> sorted((3, 2, 1))
[1, 2, 3]
리스트 자료형에도 sort 함수가 있다. 하지만 리스트 자료형의 sort 함수는 리스트 객체 그 자체를 정렬만 할 뿐 정렬된 결과를 돌려주지는 않는다.
주의 : 리스트 자료형에 있는 sort 함수 vs sorted 함수
str
str(object)은 문자열 형태로 객체를 변환하여 돌려주는 함수이다.
>>> str(3)
'3'
>>> str('hi')
'hi'
>>> str('hi'.upper())
'HI'
sum
sum(iterable) 은 입력받은 리스트나 튜플의 모든 요소의 합을 돌려주는 함수이다.
>>> sum([1,2,3])
6
>>> sum((4,5,6))
15
tuple
tuple(iterable)은 반복 가능한 자료형을 입력받아 튜플 형태로 바꾸어 돌려주는 함수이다. 만약 튜플이 입력으로 들어오면 그대로 돌려준다.
>>> tuple("abc")
('a', 'b', 'c')
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple((1, 2, 3))
(1, 2, 3)
type
type(object)은 입력값의 자료형이 무엇인지 알려 주는 함수이다.
>>> type("abc")
<class 'str'>
>>> type([ ])
<class 'list'>
>>> type(open("test", 'w'))
<class '_io.TextIOWrapper'>
zip - 시이발 이거 개애애애 유용함
zip(*iterable)
은 동일한 개수로 이루어진 자료형을 묶어 주는 역할을 하는 함수이다.
※ 여기서 사용한
*iterable
은 반복 가능(iterable)한 자료형 여러 개를 입력할 수 있다는 의미이다.
for p1, p2 in zip (phoneBook, phoneBook[1:]):
# 이말은 즉슨 phoneBook배열에서 이중 for문을 하는데 두번째 for문에 index가 1부터 들어간단 말임. 또한, 당연히 그 값에 p1, p2에 넣겠다는말임. 시발 개쩜 파이썬.
잘 이해되지 않는다면 다음 예제를 살펴보자.
>>> list(zip([1, 2, 3], [4, 5, 6]))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> list(zip("abc", "def"))
[('a', 'd'), ('b', 'e'), ('c', 'f')]
순열과 조합
permutations 와 combinations는 list로 반환해야함
list로 반환해서 print하면 [(1,2), (3,4), . . . ] 요런식으로 됨
그래서 map함수를 해서 print로 반환
- 순열
from itertools import permutations
items = ['A', 'B', 'C', 'D']
print(list(map(''.join, permutations(items)))) # items의 모든 원소를 가지고 순열을 만든다.
print(list(map(''.join, permutations(items, 2)))) # 2개의 원소를 가지고 순열을 만든다
>>['ABCD', 'ABDC', 'ACBD', 'ACDB', 'ADBC', 'ADCB', 'BACD', 'BADC', 'BCAD', 'BCDA', 'BDAC', 'BDCA', 'CABD', 'CADB', 'CBAD', 'CBDA', 'CDAB', 'CDBA', 'DABC', 'DACB', 'DBAC', 'DBCA', 'DCAB', 'DCBA']
>> ['AB', 'AC', 'AD', 'BA', 'BC', 'BD', 'CA', 'CB', 'CD', 'DA', 'DB', 'DC']
permutations(items, i)
i는 option
Idea : 순열은 12 랑 21이랑 같다고 생각함
- 조합
from itertools import combinations
items = ['A', 'B', 'C', 'D']
for i in range(1, len(items)):
print(list(map(''.join, combinations(items, i))))
# 조합을 만들려는 아이템과 조합의 수를 반드시 넘겨줘야한다.
>>['A', 'B', 'C', 'D']
['AB', 'AC', 'AD', 'BC', 'BD', 'CD']
['ABC', 'ABD', 'ACD', 'BCD']
combinations(items, i)
i는 필수 - 조합으로 구하는 갯수가 필수적임.
from itertools import combinations
items = ['A', 'B', 'C', 'D']
for i in range(1, len(items)):
print(list(map(''.join,combinations(items, i))))
>>['A', 'B', 'C', 'D']
['AB', 'AC', 'AD', 'BC', 'BD', 'CD']
['ABC', 'ABD', 'ACD', 'BCD']
Python's Comprehension
- List Comprehension (LC)
- Set Comprehension (SC)
- Dict Comprehension (DC)
- Generator Expression (GE) == generator는 특별히 expression이라고 부름
for문을 활용한 list comprehension
[ 식 for 원소 in 리스트 if 문 ]
>>> [i for i in range(5)]
[0, 1, 2, 3, 4]
위의 코드를 말로 풀면 다음과 같다.
range(5) 안(in)에서 | 각각의(for) 원소(i)를 고르고 | 그 i를 리스트 안에 나타내라 |
---|---|---|
in range(5) | for i | i |
예제
>>> [i+5 for i in range(5)]
[5, 6, 7, 8, 9]
>>> [i*2 for i in range(5)]
[0, 2, 4, 6, 8]
단일 if문을 포함한 list comprehension
if 문은 for 문 뒤에 나오면 된다. 만약 range(5)에서 짝수만 리스트로 작성하려면 아래와 같이 하면 된다.
>>> [i for i in range(5) if i % 2 == 0][0, 2, 4]>>> [i for i in range(5) if i % 2 == 1][1, 3]
if와 else문을 포함한 List Comprehension
if 문에 else를 추가하여 리스트를 생성할 수 있다. 만약에 [0,1,2,3,4] 중 짝수는 모두 리스트에 포함시키고 홀수일 경우에는 None을 리스트에 포함시키려고 한다면 아래와 같이 하면 된다.
>>> [i if i % 2 == 0 else None for i in range(5) ][0, None, 2, None, 4]
else가 추가되는 경우에는 if~else문이 i와 for 사이에 위치하여야 한다는 점에 유의하기 바란다.
중첩 for문을 포함한 List Comprehension
for 문을 중첩하여 List Comprehension을 만들 수 있다. 1~5 사이의 숫자에 각각 7~9 숫자를 곱한 결과를 리스트에 나타내고 싶다면 아래와 같이 하면 된다.
>>> [i*j for i in range(1,6) for j in range(7,10)][7, 8, 9, 14, 16, 18, 21, 24, 27, 28, 32, 36, 35, 40, 45]
for 문 뒤에 for 문을 계속 쓰는 경우 앞의 for 문의 원소에 대해서 그 다음 for 문의 원소를 순차적으로 적용한 결과가 리스트에 나타나게 된다. 상기 사례를 도식화해서 나타내면 아래와 같다.
set(집합)
set(집합) - 기본
- set은 수학에서 이야기하는 집합과 비슷합니다.
- 순서가 없고, 집합안에서는 unique한 값을 가집니다.
- 그리고 mutable 객체입니다.
- REPL으로 여러가지를 확인해봅니다.
- 중괄호를 사용하는 것은 dictionary와 비슷하지만, key가 없습니다. 값만 존재합니다.
>>> s = {3, 5, 7}
>>> s
{3, 5, 7}
>>> type(s)
<class 'set'>
- set(집합) 내부 원소는 다양한 값을 함께 가질 수 있지만, mutable한 값은 가질수 없습니다.
>>> s = {"1", 3, 5, (1,3)}
>>> s
{(1, 3), 5, 3, '1'}
>>> s = {"1", 3, 5, [1,3]}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> s = {"1", 3, 5, {1,3}}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> s = {"1", 3, 5, {1:1,3:3}}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> s = {"1", 3, 5, frozenset([1,3,4])}
>>> s
{5, 3, '1', frozenset({1, 3, 4})}
2. set(집합) 선언
- list나 dict의 경우 대괄호나 중괄호로 선언할 수 있었습니다만, set은 dict타입과 동일한 중괄호를 사용하므로, 중괄호만으로는 생성할 수 없습니다.
- set 생성자를 이용합니다.
>>> s = {}
>>> type(s)
<class 'dict'>
>>> s = set()
>>> type(s)
<class 'set'>
>>> s
set()
- set 생성자에 iterable한 객체를 넣으면 변환하여 set을 만들어 줍니다.
- 물론 set생성자 없이 바로 중괄호 안에 값을 넣어도 됩니다.
>>> s = set([1,3,5,7])
>>> s
{1, 3, 5, 7}
>>> p = {1, 3, 5, 7}
>>> p
{1, 3, 5, 7}
- 중복된 값은 자동으로 중복이 제거 됩니다.
>>> s = {1, 5, 1, 1, 1, 3, 7}
>>> s
{1, 3, 5, 7}
- set(집합)은 순서가 없습니다. 어떤 값이 먼저 나올지 알 수 없습니다.
>>> for i in {1, 2, 4, 8, 16,32}:
... print(i)
...
32
1
2
4
8
16
3. set(집합)의 in
- 다른 collection 타입과 동일하게 동작 합니다.
>>> 2 in r
True
>>> 3 in r
False
>>> 3 not in r
True
4. set(집합)의 원소 추가
- 원소 추가는
add
메소드를 이용합니다.
>>> k = {100, 105}
>>> k.add(50)
>>> k
{105, 50, 100}
>>> k.add(12)
>>> k
{105, 50, 100, 12}
5. set(집합)의 update
- dictionary의 update는 여러값을 수정 또는 추가할때 사용했습니다만, set은 중복은 자동으로 제거되고 수정이라는 개념보다, 여러데이터를 한번에 추가할 때 사용합니다.
>>> k = {1, 2, 3}
>>> k.update([3, 4, 5])
>>> k
{1, 2, 3, 4, 5}
6. set(집합)의 원소 제거
- remove(item) : item에 해당하는 원소를 제거하고, 없으면 KeyError 발생
>>> k = {1, 2, 3}
>>> k.remove(3)
>>> k
{1, 2}
>>> k.remove(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 3
- discard(item) : item에 해당하는 원소를 제거하고, 없어도 에러발생하지 않음
>>> k = {1, 2, 3}
>>> k.discard(3)
>>> k
{1, 2}
>>> k.discard(3)
>>> k
{1, 2}
7. set(집합)의 복사
- set 내부의 값은 불변의 값만 들어올 수 있기때문에.. 얕은 복사와 깊은 복사의 구분이 필요 없을것 같지만... 일단 set의 메소드인 copy는 얕은 복사에 해당합니다.
>>> s = {1, 3, 5}
>>> t = s.copy()
>>> s
{1, 3, 5}
>>> t
{1, 3, 5}
>>> id(s)
4334668264
>>> id(t)
4334666696
- dictionary 처럼 생성자로 복사할 수 있습니다.
>>> s = {1, 3, 5}
>>> t = set(s)
>>> s
{1, 3, 5}
>>> t
{1, 3, 5}
>>> id(s)
4334666248
>>> id(t)
4334667144
8. set(집합) 연산 - 연산자
|
- 합집합 연산자
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a | b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 3, 4, 5, 6, 7}
&
: 교집합 연산자
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a & b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{3, 4, 5}
-
: 차집합 연산자
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a - b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2}
^
: 대칭차집합 연산자(합집합 - 교집합)
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a ^ b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 6, 7}
|=, &=, -=, ^=
: =
과 조합함으로써 연산과 동시에 할당합니다.
- id 또한 변경되지 않습니다.
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> a |= b
>>> a
{1, 2, 3, 4, 5, 6, 7}
>>> b
{3, 4, 5, 6, 7}
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> id(a)
4334668040
>>> a &= b
>>> a
{3, 4, 5}
>>> id(a)
4334668040
>>>
9. set(집합) - 연산메소드
- union - 합집합
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.union(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 3, 4, 5, 6, 7}
- intersection - 교집합
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.intersection(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{3, 4, 5}
- difference - 차집합
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.difference(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2}
- symmetric_difference : 대칭차집합 연산자(합집합 - 교집합)
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.symmetric_difference(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 6, 7}
10. set(집합) - 기타 메소드
- issubset : 부분집합 여부 확인
>>> a = {1, 2, 3, 4, 5}
>>> b = {1, 2, 3}
>>> a.issubset(b)
False
>>> b.issubset(a)
True
- issuperset : issubset과 반대 superset인지 확인
>>> a = {1, 2, 3, 4, 5}
>>> b = {1, 2, 3}
>>> a.issuperset(b)
True
>>> b.issuperset(a)
False
- isdisjoint : 교집합이 없으면 True, 있으면 False
>>> a = {1, 2, 3}
>>> b = {4, 5, 6}
>>> a.isdisjoint(b)
True
>>> c = {1, 2, 3}
>>> d = {3, 4, 5}
>>> c.isdisjoint(d)
False
Author And Source
이 문제에 관하여(Python 멋대로 정리), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다
https://velog.io/@gs0351/Python-멋대로-정리
저자 귀속: 원작자 정보가 원작자 URL에 포함되어 있으며 저작권은 원작자 소유입니다.
우수한 개발자 콘텐츠 발견에 전념
(Collection and Share based on the CC Protocol.)
>>> s = {3, 5, 7}
>>> s
{3, 5, 7}
>>> type(s)
<class 'set'>
>>> s = {"1", 3, 5, (1,3)}
>>> s
{(1, 3), 5, 3, '1'}
>>> s = {"1", 3, 5, [1,3]}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> s = {"1", 3, 5, {1,3}}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> s = {"1", 3, 5, {1:1,3:3}}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> s = {"1", 3, 5, frozenset([1,3,4])}
>>> s
{5, 3, '1', frozenset({1, 3, 4})}
>>> s = {}
>>> type(s)
<class 'dict'>
>>> s = set()
>>> type(s)
<class 'set'>
>>> s
set()
>>> s = set([1,3,5,7])
>>> s
{1, 3, 5, 7}
>>> p = {1, 3, 5, 7}
>>> p
{1, 3, 5, 7}
>>> s = {1, 5, 1, 1, 1, 3, 7}
>>> s
{1, 3, 5, 7}
>>> for i in {1, 2, 4, 8, 16,32}:
... print(i)
...
32
1
2
4
8
16
>>> 2 in r
True
>>> 3 in r
False
>>> 3 not in r
True
add
메소드를 이용합니다.>>> k = {100, 105}
>>> k.add(50)
>>> k
{105, 50, 100}
>>> k.add(12)
>>> k
{105, 50, 100, 12}
>>> k = {1, 2, 3}
>>> k.update([3, 4, 5])
>>> k
{1, 2, 3, 4, 5}
>>> k = {1, 2, 3}
>>> k.remove(3)
>>> k
{1, 2}
>>> k.remove(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 3
>>> k = {1, 2, 3}
>>> k.discard(3)
>>> k
{1, 2}
>>> k.discard(3)
>>> k
{1, 2}
>>> s = {1, 3, 5}
>>> t = s.copy()
>>> s
{1, 3, 5}
>>> t
{1, 3, 5}
>>> id(s)
4334668264
>>> id(t)
4334666696
>>> s = {1, 3, 5}
>>> t = set(s)
>>> s
{1, 3, 5}
>>> t
{1, 3, 5}
>>> id(s)
4334666248
>>> id(t)
4334667144
|
- 합집합 연산자>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a | b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 3, 4, 5, 6, 7}
&
: 교집합 연산자>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a & b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{3, 4, 5}
-
: 차집합 연산자>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a - b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2}
^
: 대칭차집합 연산자(합집합 - 교집합)>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a ^ b
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 6, 7}
|=, &=, -=, ^=
: =
과 조합함으로써 연산과 동시에 할당합니다.>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> a |= b
>>> a
{1, 2, 3, 4, 5, 6, 7}
>>> b
{3, 4, 5, 6, 7}
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> id(a)
4334668040
>>> a &= b
>>> a
{3, 4, 5}
>>> id(a)
4334668040
>>>
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.union(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 3, 4, 5, 6, 7}
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.intersection(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{3, 4, 5}
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.difference(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2}
>>> a = {1, 2, 3, 4, 5}
>>> b = {3, 4, 5, 6, 7}
>>> c = a.symmetric_difference(b)
>>> a
{1, 2, 3, 4, 5}
>>> b
{3, 4, 5, 6, 7}
>>> c
{1, 2, 6, 7}
>>> a = {1, 2, 3, 4, 5}
>>> b = {1, 2, 3}
>>> a.issubset(b)
False
>>> b.issubset(a)
True
>>> a = {1, 2, 3, 4, 5}
>>> b = {1, 2, 3}
>>> a.issuperset(b)
True
>>> b.issuperset(a)
False
>>> a = {1, 2, 3}
>>> b = {4, 5, 6}
>>> a.isdisjoint(b)
True
>>> c = {1, 2, 3}
>>> d = {3, 4, 5}
>>> c.isdisjoint(d)
False
Author And Source
이 문제에 관하여(Python 멋대로 정리), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다 https://velog.io/@gs0351/Python-멋대로-정리저자 귀속: 원작자 정보가 원작자 URL에 포함되어 있으며 저작권은 원작자 소유입니다.
우수한 개발자 콘텐츠 발견에 전념 (Collection and Share based on the CC Protocol.)