Tmi
이번에 떨어지면 다시... 필기부터 다시 봐야 한다.. 절대 안돼 ㅠㅠㅠㅠㅠㅠㅠㅠ
와.. 접수부터 너무 힘들었다.
평일 10시라서 회사에서 접수해야 하는데 ㅎ... 심지어 서버 터져가지고 점심시간에도 붙잡고 있었던 거 ㄹㅈㄷ
트위터에 사람들 다 욕하고 ㅋㅋㅋㅋ 무슨 단계별로 끊겨서 열받았었다 진짜로
이번에 근처 접수 못해서 멀리 가는 사람들도 많던데..ㅋㅋㅋ 이번에가 더 터진 이유가
이라고.. ㅋㅋㅋ...
티켓팅 같은 정처기 실기를 다시 안보기 위해서 이번에 끝낸다
파이썬 정리
01. 데이터 타입
1) 변수
변수의 이름 규칙(Rule)
다음의 규칙을 가짐
2) 기본 데이터 타입
주요 데이터 타입
type()
type 함수를 활용하여 데이터의 타입을 알아 볼 수 있음
None 타입
말 그대로 아무 것도 아닌 흔히 null 값을 넣는다고 함
3) 타입 변환
a = 1
type(a)
float(a) # 정수 a를 float로 바꿈 1.0
float를 int로 변환한 경우 : 반올림이 아닌 값이 버림되어 진다.
02. 리스트(List), 튜플(Tuple)
| 분류 | 타입 | 특징 | 예시 |
|---|
| | | |
| | | |
| | | |
| | 순서가 없고, key/value 쌍으로 이루어짐 | {‘a’ : 1, ‘b’ : 2, ‘c’ : 3} |
출처 : https://wikidocs.net/137565
1) 리스트
리스트는 데이터의 요소를 순차적으로 파악하는데 용이한 자료형
리스트는 다양한 메서드 혹은 함수를 지원하며, 메서드를 활용하여 요소를 추가, 삭제, 변경 할 수 있다.
생성과 출력
mylist = []
mylist # []
규칙
list는 다양한 type의 데이터를 집합으로 가진다
관련 함수
함수는 어떤 작업을 수행하는 코드를 모아 이름을 붙인 것
1. append : 값 추가
mylist = []
mylist.append(1)
mylist # [1]
mylist.append(7)
mylist.append(7)
mylist.append(7)
mylist.append(3)
mylist.append(5)
mylist.append(2)
mylist
[출력]
[1, 7, 7, 6, 3, 5, 2]
2. sort() : 정렬
mylist = [1, 6, 3, 2, 7, 5, 4]
mylist.sort()
mylist
[출력]
[1, 2, 3, 4, 5, 6, 7]
mylist = [1, 6, 3, 2, 7, 5, 4]
mylist.sort(reverse=True)
mylist
[출력]
[7, 6, 5, 4, 3, 2, 1]
3. sorted() 정렬
mylist = [1, 6, 3, 2, 7, 5, 4]
sorted(mylist) # [1, 2, 3, 4, 5, 6, 7]
mylist # [1, 6, 3, 2, 7, 5, 4]
reverse=True를 지정하여 역정렬할 수 있음
mylist = [1, 6, 3, 2, 7, 5, 4]
sorted(mylist, reverse=True) # [7, 6, 5, 4, 3, 2, 1]
4. reverse() : 역정렬
mylist.reverse()
mylist # [4, 5, 7, 2, 3, 6, 1]
5. len() : 전체 항목의 개수 세기
mylist = [1, 6, 3, 2, 7, 5, 4]
len(mylist) # 7
6. insert() : 값 추가
mylist.insert(1, 100)
mylist # [1, 100, 6, 3, 2, 7, 5, 4]
7. remove() : 값 제거
mylist.remove(7)
mylist # [1, 100, 6, 3, 2, 5, 4]
8. pop() : 요소 꺼내기
mylist.pop(1) # 100
mylist # [1, 6, 3, 2, 5, 4]
9. count() : 갯수 세기
a = [1, 1, 1, 1, 1, 2, 2, 3]
a.count(1) # 5
10. extend() : 리스트 확장
a = [1, 2, 3]
a.extend([4, 5])
a # [1, 2, 3, 4, 5]
리스트 검색
list = [1, 2, 3, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4]
print(list.index(2)) # 1(첫 2의 인덱스 번호)
print(list.count(2)) # 3
2) 인덱싱, 슬라이싱
인덱싱 : 색인
mylist = ['P', 'Y', 'T', 'H', 'O', 'N']
인덱스는 0번 부터 시작
역순 인덱싱
인덱스로 접근하여 값 바꾸기
mylist = [10, 20, 30, 40, 50]
mylist[0] = 999
mylist # [999, 20, 30, 40, 50]
중첩된 리스트 인덱싱
중첩된 리스트에 대한 리스트는 중첩 인덱싱으로 접근하며, 값을 변경하는 것도 가능
mylist = [['가', '나', '다'], [4, 5, 6], 7, 8, 9]
mylist[1] # [4, 5, 6]
mylist[1][1] # 5
슬라이싱(Slicing): 범위 추출
슬라이싱의 활용: [start:stop:step] 을 명시하여 부분을 추출할 수 있습니다.
[start:]는 시작 index 부터 끝까지 추출합니다. end가 명시 안되어 있다면 끝
mylist = [100, 200, 300, 400, 500]
mylist[2:] # [300, 400, 500]
[:end]는 처음부터 end 전까지 추출합니다. end가 명시되어 있다면 end-1까지 출력
mylist[:3] # [100, 200, 300]
indexing 에 step 활용하기
mylist = [100, 200, 300, 400, 500]
mylist[::2] # [100, 300, 500]
mylist[::-2] # [500, 300, 100]
list 덧셈: list 확장
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
a + b # [1, 2, 3, 4, 5, 6, 7, 8]
list 곱셈: list 반복
a = ['a', 'b', 'c']
b = [1, 2, 3, 4]
a * 2 # ['a', 'b', 'c', 'a', 'b', 'c']
참고로 **print(fruit[7:])**를 해줘야 출력 되는거임
연습문제
sample = [1, 2, 3, 4, 5, 6, 7, 8]
sample[::-1] # [8, 7, 6, 5, 4, 3, 2, 1]
sample[-1:] #[8]
3) 튜플
리스트(list)는 가변(mutable)하는 객체(object)이지만, 튜플(tuple)은 불변(immutable)한 객체
가변 객체는 요소에 대한 수정, 삭제, 변경 등이 가능하지만, 불편 객체는 요소에 대한 수정, 삭제, 변경이 불가
생성
mytuple = (1, 2, 3)
mytuple # (1, 2, 3)
mytuple2 = 1, 2, 3
mytuple2 # (1, 2, 3)
단일 요소를 생성할 때는 반드시 ,를 붙여 줍니다.
(1,)과 (1)은 다른 자료구조임을 꼭 알고 있어야 합니다.
mytuple = 1,
print(type(mytuple))
mytuple # (1,)
class 'tuple'
mytuple = 1
print(type(mytuple))
mytuple # 1
class 'int'
튜플 자료형은 요소의 추가, 삭제, 변경등을 허용하지 않습니다.
그렇기 때문에 리스트로 바꾸고 요소 추가 삭제 변경 후 다시 튜플로 바꿔줘야 함
a = (1, 2, 3, 4)
a = list(a)
a.insert(1, 100)
tuple(a)
03. 세트(Set), 딕셔너리(Dictionary)
1) 세트(Set)
세트는 **{}**를 활용하여 생성할 수 있다.
생성
참고로 원래 myset만 하면 출력 nono print(myset)해줘야 함
myset = set([1, 1, 1, 2, 2, 2, 3, 3, 3])
myset # {1, 2, 3}
add() : 값 추가
myset = set()
myset.add(1)
myset.add(2)
myset.add(3)
myset.add(1)
myset.add(2)
myset.add(3)
myset.add(1)
myset.add(2)
myset.add(3)
myset # {1, 2, 3}
update() : 여러개 값 추가
myset = {1, 2, 3}
myset.update([4, 5, 6])
myset # {1, 2, 3, 4, 5, 6}
myset.update((7, 8, 9))
myset # {1, 2, 3, 4, 5, 6, 7, 8, 9}
myset.update({10, 11, 12})
myset # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
remove() : 값 제거
myset = {1, 2, 3, 4, 5}
myset.remove(2)
myset # {1, 3, 4, 5}
교집합 (intersection)
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
a & b
a.intersection(b)
[출력]
합집합 (union)
합집합은 집합 A와 B가 주어졌을 때 집합 A, B 요소 모두를 포함하는 것을 말한다.
|기호나 union() 메서드를 활용하여 합집합을 구할 수 있다.
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
a | b
a.union(b)
[출력]
{1, 2, 3, 4, 5, 6, 7}
차집합 (difference)
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
a - b
a.difference(b)
[출력]
discard : set에서 해당 값 제거 오류 발생 x
my_set = {3, 5, 7, 9}
my_set.add(5)
my_set.add(2)
my_set.add(8)
my_set.discard(7)
2) 딕셔너리(Dictionary)
키(key)와 값(value)의 쌍으로 이루어져 있다.
딕셔너리는 여러 타입의 key를 가질 수 있다.
mydict = {'a': 1, '가':2, 100: 3, 3.14: 4, True: 5}
mydict # {'a': 1, '가': 2, 100: 3, 3.14: 4, True: 5}
값 조회
mydict = {'a': 1, '가':2, 100: 3, 3.14: 4, True: 5}
mydict['a'] # 1
keys() : 모든 key 조회
[출력]
dict_keys(['a', 'b', 'c', 'd', 'e'])
[참고] dict_keys
객체(object)로 생성되는데, 이를 list로 변경하기 위해서는 list()로 타입 변환을 하면 된다.
[출력]
['a', 'b', 'c', 'd', 'e']
values() : 모든 value 조회
mydict.values() # dict_values([100, 200, 300, 400, 500])
items() : 모든 key, value 조회
[출력]
dict_items([('a', 100), ('b', 200), ('c', 300), ('d', 400), ('e', 500)])
key 값의 존재 유무 확인
값을 추가하기
mydict = dict()
mydict
mydict['apple'] = 123
mydict['apple'] #123
update() : 다중 업데이트
mydict = {'파인애플': 1500, '망고': 3500, '배': 1000}
fruit = {
'사과': 2000,
'딸기': 3000,
'수박': 5000,
}
mydict.update(fruit)
mydict # {'파인애플': 1500, '망고': 3500, '배': 1000, '사과': 2000, '딸기': 3000, '수박': 5000}
값 변경
key 값에 새로운 값(value)를 대입하여 값을 변경할 수 있다.
mydict = {'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 500}
mydict['a'] = 900
mydict # {'a': 900, 'b': 200, 'c': 300, 'd': 400, 'e': 500}
제거하기 / key 제거
pop() 에 key를 지정하여 값을 제거할 수 있다.
제거되는 값의 value를 반환
mydict = {'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 500}
mydict
mydict.pop('b') # 200
del mydict['a'] # a의 키 삭
len() : 요소의 개수 파악
4. 문자열(String)
1) 포맷팅, 길이, 인덱싱, 슬라이싱
%를 사용한 출력
%s -> 문자열
%d -> 정수
%f -> 실수
%c : 문자 1개
"안녕하세요? %s" % ('반갑습니다.') # '안녕하세요? 반갑습니다.'
'안녕하세요? %d' % (12345) # '안녕하세요? 12345'
'안녕하세요? %.4f' % (0.123456) # '안녕하세요? 0.1235'
'안녕하세요? %c' % ('a') # '안녕하세요? a'
{} 와 format를 사용한 출력
'웰컴투? {}'.format('파이썬.') # **'웰컴투? 파이썬.'
'원주율? {:.2f}'.format(3.141592) # '원주율? 3.14'**
문자열 길이
len('banana pen') # 10
2) 문자열(텍스트)를 다루는 다양한 기능
split() : 분리
split은 문장을 특정 규칙에 의해 쪼개 주는 기능
분리한 결과는 list 형식으로 값을 return 받는다.
기본 값으로 공백이 지정되어 있다. 즉, 공백을 기준으로 분리하여 리스트로 반환
a.split() #['This', 'is', 'a', 'pen']
기본 값인 공백에서 특정 문자로 지정할 수 있다.
a = 'This-is-a-pen'
a.split('-') # ['This', 'is', 'a', 'pen']
join() : 합치기
결합하고자 하는 문자에 .join() 안에 리스트를 지정하여 결합할 수 있다.
'-'.join(['010', '1234', '5678']) # '010-1234-5678'
lower(), upper() : 소문자 / 대문자로 만들기
내부가 변환이 되는 것은 아님 a =으로 넣어줘야함
a = 'My name is Teddy'
a.lower() # 'my name is teddy'
a.upper() # **'MY NAME IS TEDDY'**
startswith() : 시작하는
지정한 문자열로 시작하면 True, 그렇지 않다면 False를 반환
[출력]
endswith() : 끝나는
지정한 문자열로 끝나면 True, 그렇지 않다면 False를 반환
[출력]
4) Replace() : 문자열 바꾸기, 공백 제거
문자열에 replace(바꿀 대상, 바꾸려는 문자열) 지정하여 문자열을 변경
a = '01-sample.png'
a.replace('.png', '.jpg') # '01-sample.jpg'
strip() : 양쪽 공백 제거
a.strip() # '01-sample.png'
lstrip() : 왼쪽 공백 제거
rsreip : 오른쪽 공백 제거
find : 문자열의 첫 시작 위치를 구해줌
str ='hudndhj'
print(str.find('h')) # 0
5. 연산
**1) 기타 연산자 (%, //, )
//: floor division 연산자입니다. 나눗셈에 대한 몫을 정수형으로 구함
%: modulus 연산자입니다. 몫을 나눈 나머지를 구함
연산시 타입(type)이 다르면 Error가 발생합니다.
6. 비교, 논리, 삼항연산자
1) 삼항연산자
(문법) (참인 값) if 조건 else (거짓인경우 값)
age = 35
"30세 이상입니다." if age >= 30 else "30세 이하입니다." # '30세 이상입니다.'
7. 반복문
1) For와 In 구문
[기본 문법]
for 하나씩 꺼내올 때 변수 in [꺼내올 집합]:
(indent)
list, tuple, set, dictionary, 문자열 형태 모두 가능
리스트(list)
mylist = [1, 2, 3, 4, 5]
for i in mylist:
print(i)
[출력]
tuple + list
person = ('제이콥스', 10)
print(person)
print(person[0])
print(person[1])
[출력]
name, age = ('제이콥스', 10)
print(name)
print(age)
[출력]
mytuplelist = [('제이콥스', 10), ('피터', 20), ('타이거', 30)]
for mytuplein mytuplelist:
print(mytuple[0], mytuple[1])
[출력]
mytuplelist = [('제이콥스', 10), ('피터', 20), ('타이거', 30)]
for name, agein mytuplelist:
print(name, age)
[출력]
딕셔너리(dictionary)
mydict = {'헐크': 50, '아이언맨': 60, '펭수': 70}
for keyin mydict.keys():
print(key)
[출력]
for valuein mydict.values():
print(value)
[출력]
for name, agein mydict.items():
print(name, age)
[출력]
문자열(str)
for cin "Hello":
print(c)
[출력]
Range
range() 함수는 별도의 list, tuple 생성 없이 range() 에서 정의한 범위를 반복하는데 활용할 수 있다.
range(start, stop, step) 형식을 사용
for iin range(10):
print(i)
[출력]
start, stop: 두 개의 값을 지정한 경우
for iin range(2, 9):
print(i)
[출력]
start, stop, step: 세 개의 값을 지정한 경우
for iin range(1, 10, 2):
print(i)
[출력]
print('안녕', end=' ')
for i in range(5):
print(i, end=' ')
8. 함수
1) Lambda : 익명 함수(Annonymous Function)
**단일 문장(1줄)**의 코드로 작성되어야 합니다.
함수 내부에서는 return문이 포함하지 않지만 값을 반환합니다.
단일 인수를 가지는 lambda 함수
a =lambda x: x * 2
a(4) # 8
2개의 인수를 가지는 lambda 함수
a =lambda x, y: x * y
a(4, 8) # 32
기본 값이 지정된 인수를 가지는 lambda 함수
a =lambda x, y=10: x * y
a(3) # 30
키워드 인수를 지정하는 lambda 함수
[출력]
lambda 함수 내부에서 조건문 사용
a =lambda x, y: x * yif x > 0else y
a(4, 8) # 32
9. 내장함수(Built-in Function)
파이썬에는 이미 만들어진 내장함수(built-in function)가 존재
이미 사용하고 있는 print(), type()이 파이썬의 대표적인 내장함수
map
문법: map(function, iterable)
map은 함수(f)와 순회 가능한(iterable) 자료형을 입력으로 받다.
map은 입력받은 자료형의 각 요소를 함수(function)가 수행한 결과를 묶어서 돌려
sample_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
map만 실행시 요소의 내용이 바로 출력되지 않습니다.
map(str, sample_data)
[출력]
list()로 타입 변환하여 요소를 출력
list(map(str, sample_data))
[출력]
['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
map에 lambda 함수 적용
result = map(lambda x: x*2, sample_data)
list(result)
[출력]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
map에 다중 인수를 지정
sample_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sample_data_2 = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55]
list(map(lambda x, y: x+y, sample_data, sample_data_2))
[출력]
[1, 3, 5, 7, 10, 14, 20, 29, 43, 65]
list의 size가 다른 경우, 작은 size에 맞춰 생성
sample_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sample_data_2 = [1, 1, 1, 10, 100]
list(map(lambda x, y: x+y, sample_data, sample_data_2))
[출력]
zip
동일한 개수로 이루어진 자료형을 묶어 주는 역할을 합니다.
sample_data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sample_data2 = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55]
sample_data3 = [5, 6, 7]
sample_data1, sample_data2을 zip으로 묶어준 경우
result = zip(sample_data1, sample_data2)
list(result)
[출력]
[(1, 0),
(2, 1),
(3, 2),
(4, 3),
(5, 5),
(6, 8),
(7, 13),
(8, 21),
(9, 34),
(10, 55)]
sample_data1, sample_data2, sample_data3을 zip으로 묶어준 경우
작은 size를 가지는 리스트(list)에 맞춰 생성합니다.
list(zip(sample_data1, sample_data2, sample_data3))
[출력]
[(1, 0, 5), (2, 1, 6), (3, 2, 7)]
zip의 응용
number = [1, 2, 3, 4]
name = ['홍길동','김철수','John','Paul']
number_name = list(zip(number,name))
number_name
[출력]
[(1, '홍길동'), (2, '김철수'), (3, 'John'), (4, 'Paul')]
zip을 활용한 dict 만들기
number = [1, 2, 3, 4]
name = ['홍길동','김철수','John','Paul']
dic = {}
for number, namein zip(number,name):
dic[number] = name
[출력]
{1: '홍길동', 2: '김철수', 3: 'John', 4: 'Paul'}
enumerate
[문법]: enumerate(iterable, start=0)
순서가 있는 자료형을 입력 받아 index를 포함하는 객체로 return 합니다.
일반 range() 함수를 사용한 경우
for valuein range(1, 10, 2):
print(value)
[출력]
enumerate() 함수를 사용하여 index를 return 받은 경우
for idx, valuein enumerate(range(1, 10, 2)):
print(f'index: {idx}, value: {value}')
[출력]
index: 0, value: 1
index: 1, value: 3
index: 2, value: 5
index: 3, value: 7
index: 4, value: 9
