빅오 (O, big-O)란 입력값이 무한대로 향할때 함수의 상한을 설명하는 수학적 표기 방법
시간 복잡도 Time Complexity(점근적 실행 시간)의 사전적 정의는 어떤 알고리즘을 수행하는 데 걸리는 시간을 설명하는 계산 복잡도 Computational Complexity를 의미. 계산 복잡도를 표기하는 대표적인 방법이 빅오이다.
빅오로 시간 복잡도를 표현할 때는 최고차항만을 쵸기하며, 계수는 무시한다.
- O(1)
입력값이 아무리 커도 실행 시간은 일정하다.
- O(log n):
실행 시간은 입력 값에 영향을 받는다. 그러나 로그는 매우 큰 입력값에도 크게 영향을 받지 않는 편으로 웬만한 n의 크기에 대해서도 매우 견고하다.
- O(n):
입력값만큼 실행 시간에 영향을 받으며, 알고리즘을 수행하는 데 걸리한 시간은 입력값에 비례한다. 이러한 알고리즘을 선형 시간 Linear-Time 알고리즘이라고 한다. 정렬되지 않은 리스트에서 최댓값 또는 최솟값을 찾는 경우가 이에 해당하며 이 값을 찾기 위해서는 모든 입력값을 적어도 한 번 이상은 살펴봐야 한다.
- O(n log n):
적어도 모든 수에 대해 한번 이상은 비교해야 하는 비교 기반 정렬 알고리즘은 아무리 좋은 알고리즘도 O(n log n)보다 빠를 수 없다. 물론 입력값이 최선인 경우, 비교를 건너뛰어 O(n)이 될 수 있으며 팀소트Timesort가 이런 로직을 갖고 있다.
- O(n^2):
버블 정렬과 같은 비효율적인 정렬 알고리즘이 해당된다.
- O(2^n):
피보나치 수를 재귀로 계산하는 알고리즘이 해당된다. n^2과 처음에는 비슷해 보이지만 2^n이 훨씬 더 크다.
- O(n!) :
가장 느린 알고리즘으로, 입력값이 조금만 커져도 웬만한 다항시간 내에는 계산이 어렵다.
빅오는 시간 복잡도 외에 공간 복잡도를 표현하는 데에도 널리 쓰인다. 또한 알고리즘은 흔히 '시간과 공간이 트레이드오프 Space-Time Tradeoff' 관계다. 이 말은 실행 시간이 빠른 알고리즘은 공간을 많이 사용하고, 공간을 적게 차지하는 알고리즘은 실행 시간이 느리다는 말이다.
| 상한과 최악
빅오(O)는 상한 Upper Bound 의미. 하한 Lower Bound을 나타내는 빅오메가(Ω), 평균을 의미하는 빅세타 (θ)
평균적인 시간보다는 상한 시간으로 단순화해서 주로 표현한다.
빅오 표기법은 정확하게 쓰기에는 너무 길고 복잡한 함수를 적당히 정확하게 표현하는 방법일 뿐, 최악의 경우/평균적인 경우의 시간 복잡도와는 아무런 관계가 없는 개념이라는 접에 유의해야 한다.
빅오 표기법은 주어진 (최선/최악/평균) 경우의 수행 시간의 상한을 나타낸다.
| 분할 상환 분석
시간 또는 메모리를 분석하는 알고리즘의 복잡도를 계산할 때, 알고리즘 전체를 보지 않고 최악의 경우만을 살펴보는 것은 지나치게 비관적이라는 이유로 분할 상환 분석 방법이 등장하는 계기가 됐다.
| 병렬화
일부 알고리즘들은 병렬화로 실행 속도를 높일 수 있다.
자료형
| 파이썬 자료형
...
| 숫자
파이썬에서는 숫자 정수형으로 int 만을 제공한다. int는 임의 정밀도를 지원하며, 더 이상 파이썬에서 고정 정밀도 정수형을 지원하지 않게 됐다.
bool은 엄밀히 따지면 논리 자료형인데 파이썬에서는 1(ture)과 0(false)로 처리되는 int의 서브 클래스
int는 object의 하위 클래스이기도 하다. object > int > bool
임의 정밀도 정수형이란 무제한 자릿수를 제공하는 정수형을 말한다.
| 매핑 Mapping
키와 자료형으로 구성된 복합 자료형. 딕셔너리
| 집합
파이썬의 집합 자료형인 set은 중복된 값을 갖지 않는 자료형.
| 시퀀스 Sequence
'수열' 같은 의미로, 어떤 특정 대상의 순서 있는 나열을 뜻함. 불변과 가변으로 구분하는데 말 그대로 불변은 값을 변경할 수 없다. srt,tuple,bytes가 불변으로 해당된다.
| 원시 타입 Primitive Type
원시 타입은 메모리에 정확하게 타입 크기만큼의 공간을 할당하고 그 공간을 오로지 값으로 채워넣는다.
언어
지원 타입 형태
C
원시 타입
자바
원시 타입, 객체
파이썬
객체
| 객체
파이썬은 모든 것이 객체다. 이 중에서 불변 객체와 가변 객체로 구분할 수 있다. ...
- is 와 ==
비교 연산자 중 is와 ==가 있다. 이 둘읜 파이썬의 객체 구조와 관련이 깊다.
is는 id()값을 비교하는 함수다. None은 널null로서 값 자체가 정의되어 있지 않으므로 ==로 비교가 불가능하다.
자바와 달리 각 단어를 _로 구분하여 표기하는 스네이크 케이스 Snake Case를 따름. 함수명도 마찬가지.
카멜 케이스 (단어별로 대소문자를 구별하여 표기) 뿐만 아니라 자바 스타일로 코딩하는 것을 지양함.
# 카멜 케이스
camelCase : int = 1
# 스네이크 케이스
snake_case : int = 1
| 타입 힌트 Type Hint
파이썬은 대표적 동적 타이핑 언어임에도, 타입 지정할 수 있는 타입 힌트가 있다. (파이썬 3.5 ver ~ 사용 가능)
# 함수 정의
def fn(a) :
...
#타입 힌트
def fn(a: int) => bool:
...
빠르게 정의하여 사용할 수 있다는 장점이 있지만 파라미터 a에는 숫자를 넘겨야 할지, 문자를 넘겨야 할지 전혀 알수없고 리턴값이 무엇인지 알 수 없다. 프로젝트 규모가 커지게 되면 가독성을 떨어뜨리며 버그 유발의 주범이 된다.
타입 힌트를 사용하게 되면 함수의 파라미터 a가 정수형임을 분명히 알수 있으며 리턴 값으로 True 또는 False 를 리턴할 것이라는 점도 확실히 알 수 있다.
+ 온라인 코딩 테스트 시 mypy를 사용하면 타입 힌트에 오류가 없는지 자동으로 확인 가능. pip으로 설치 가능.
타입 힌트가 잘못 지정됐을 때, Incompatible return value type 오류 발생하므로 확인후 수정
| 리스트 컴프리헨션 List Comprehension
파이썬은 map, filter와 같은 함수형 기능을 지원, 람다 표현식 Lambda Expression도 지원함.
List(map(lambda x:x+10, [1,2,3]))
#홀수인 경우 2를 곱해 출력하라는 리스트 컴프리헨션
[n*2 for n in range (1,10+1) if n%2 == 1]
#출력 : [2,6,10,14,18]
#리스트 컴프리헨션을 사용하지 않으면 길게 풀어서 작성해야 함
a = []
for n in range(1,10+1) :
if n%2 == 1 :
a.append(n*2)
#리스트 컴프리헨션이라고 반드시 리스트만 가능한 것은 아님.
#리스트 외 딕셔너리 등이 가능
a = {}
for key, value in original.items() :
a[key] = value
#딕셔너리 컴프리헨션
a = {key : value for key, value in original.items()}
| 제너레이터 Generator
루프의 반복 동작을 제어할 수 있는 루틴 형태.
예를 들어 임의의 조건으로 숫자 1억개를 만들어 내 계산하는 프로그램을 작성할때
제너레이터가 없다면 메모리 어딘가에 만들어낸 숫자 1억개를 보관하고 있어야 한다.
그러나 제너레이터를 이용하면, 단순 제너레이터만 생성해두고 필요할 떄 언제든 숫자를 만들어 낼 수 있다.
이때 yield 구문을 사용하면 제너레이터를 리턴할 수 있다. 기존의 함수는 return 구문을 맞닥뜨리면 값을 리턴하고 모든 함수의 동작을 종료한다. 그러나 yield는 제너레이터가 여기까지 실행 중이던 값을 보낸다는 ( 사전적 의미 '양보하다')의미로, 중간값을 리턴한 다음 함수는 종료되지 않고 계속해서 맨 끝에 도달할 때 까지 실행된다.
While True 구문은 종료 조건이 없으므로 계속해서 값을 내보낼 수 있다.
def get_natural_number():
n = 0
while True:
n += 1
yield n
g = get_natural_number()
for _ in range(0, 100):
print(next(g))
'''
1
2
3
. .
99
100
'''
#여러 타입의 값을 하나의 함수에서 생성하는 것도 가능
def generator():
yield 1
yield 'string'
yield True
g= generator()
next(g) #1
next(g) #'string'
next(g) #True
| range
제너레이터의 방식을 활용하는 대표적인 함수.
range(5) 는 range 클래스를 리턴. for문에서 사용할 경우 내부적으로 제너레이터 next()를 호출하듯 매번 다음 숫자를 생성해내게 됨.
값을 쉽게 출력하려면 콤마(,)로 구분한다. 이 경우 한 칸 공백이 디폴트로 설정되어 있다.
sep 파라미터로 구분자를 콤마로 구분해 줄수도 있다.
print()함수는 항상 줄바꿈을 하기 때문에 긴 루프의 값을 반복적으로 출력하면 디버깅하기 어려운데, 이경우 end 파라미터를 공백으로 처리하여 줄바꿈을 하지 않도록 제한할 수 있다.
리스트를 출력할 때는 join() 으로 묶어서 처리한다.
>>> print('A1','B2')
A1 B2
>>> print('A1','B2',sep=',')
A1,B2
>>> print('aa',end='')
aa
>>> print('A1','B2',end='')
A1 B2
>>> a=['A','B']
>>> print(''.join(a))
AB
>>> print(' '.join(a))
A B
>>> idx = 1
>>> fruit = "Apple"
>>> print('{0}:{1}'.format(idx+1, fruit))
2:Apple
>>> print(f'{idx+1}:{fruit}')
2:Apple
| pass
파이썬에서 pass는 널 연산 null Operation 으로 아무것도 하지 않는 기능.
pass는 먼저 목업 mockup 인터페이스 부터 구현한 다음 추후 구현을 진행할 수 있게한다.
class MyClass(object):
def method_a(self):
def method_b(self):
print("Method B")
c = MyClass()
#클래스 실행이 되지 않고, 인덴트 오류가 발생한다.
#method_a 가가 아무런 처리를 하지 않았기 때문에 method_b에서
#오류가 발생함.
class MyClass(object):
def method_a(self):
# 여기에 pass 추가
pass
def method_b(self):
print("Method B")
c = MyClass()
| locals
locals()는 로컬 심볼 테이블 딕셔너리를 가져오는 메소드. 업데이트 가능하다.
예를 들어 로컬 스코프에 제한해 정보를 저회할 수 있기 때문에 클래스의 특정 메소드 내부에서나 함수 내부의 로컬 정보를 조회해 잘못 선언한 부분이 없는지 확인하는 용도로 확인 가능하다.
변수명을 일일이 찾아낼 필요 없이 로컬 스코프에 정의된 모든 변수를 출력하기 때문에 편리하다.
대신 불변 객체 Immutable 를 사용한다. None을 명시적으로 할당하는 것도 좋은 방법이다.
No : def foo (a, b=[]) :
...
No : def foo (a, b : Mapping = {}) :
...
Yes : def foo (a, b=None) :
if b is None :
b=[]
Yes : def foo (a, b:Optional[Sequence] = None) :
if b is None :
b=[]
True,False를 판별할 때는 암시적 Implicit 인 방법을 사용하는 편이 간결하고 가독성이 높다.
굳이 False임을 if foo!=[] : 같은 형태로 판별할 필요가 없다. if foo : 로 충분하다.
Yes: if not users :
print('no users')
if foo = 0:
...
if i%10==0 :
...
No : if len(users)==0 :
print('no users')
if foo is not None and not foo :
...
if not i%10 :
...
# 09. 파이썬 함수
# 201 ~ 210
# ___________________________________
#"비트코인" 문자열을 화면에 출력하는 print_coin() 함수를 정의
def print_coin():
print("비트코인")
#함수호출
print_coin()
for i in range(100) :
print_coin()
def print_coins() :
for i in range(100) :
print("비트코인")
def message() :
print("A")
print("B")
message()
print("C")
message()
# 09. 파이썬 함수
# 211 ~ 220
# ___________________________________
def 함수(문자열) :
print(문자열)
함수("안녕")
함수("Hi")
'''출력:
안녕
Hi
'''
def 함수(a, b) :
print(a + b)
함수(3, 4)
함수(7, 8)
def print_with_smile(string) :
print(string , ":D")
print_with_smile("안녕하세요")
def print_upper_price(현재가격) :
print(현재가격*1.3)
def print_sum (a,b) :
print(a+b)
def print_arithmetic_operation(a,b) :
print(a,"+",b,"=",a+b)
print(a,"-",b,"=",a-b)
print(a,"*",b,"=",a*b)
print(a,"/",b,"=",a/b)
def print_max (a,b,c) :
max_val = 0
if a>max_val:
max_val = a
if b > max_val :
max_val = b
if c > max_val :
max_val = c
print(max_val)
# 09. 파이썬 함수
# 221 ~ 230
# ___________________________________
def print_reverse (string) :
print(string[::-1])
print_reverse("python") #출력:nohtyp
def print_score(score_list) :
print(sum(score_list)/len(score_list))
print_score ([1, 2, 3]) #출력:2.0
def print_even(list) :
for i in list :
if i%2 == 0 :
print(i)
print_even ([1, 3, 2, 10, 12, 11, 15])
'''출력 :
2
10
12
'''
def print_keys(dic) :
for k in dic.keys() :
print(k)
print_keys ({"이름":"김말똥", "나이":30, "성별":0})
'''출력:
이름
나이
성별
'''
my_dict = {"10/26" : [100, 130, 100, 100],
"10/27" : [10, 12, 10, 11]}
def print_value_by_key (my_dict,k) :
print ( my_dict[k] )
print_value_by_key (my_dict, "10/26") #출력 : [100, 130, 100, 100]
#입력 문자열을 한 줄에 다섯글자씩 출력
def print_5xn(string) :
ch = int(len(string)/5)
for i in range(ch+1) :
print(string[i*5:i*5+5])
print_5xn("아이엠어보이유알어걸")
#문자열과 한줄에 출력될 글자 수를 입력을 받아 한 줄에 입력된 글자 수만큼 출력
def printmxn(line , num) :
ch = int( len(line)/num )
for x in range(ch+1) :
print(line[x*num : x*num+num])
printmxn("아이엠어보이유알어걸", 3)
'''출력:
아이엠
어보이
유알어
걸
'''
#연봉을 입력받아 월급을 계산. 1원 미만은 버림
def calc_monthly_salary(sal) :
monsal = int(sal/12) #입력된 값을 12로 나누고 형변환을 해서 1원 미만을 절사함
return monsal
calc_monthly_salary(12000000)
def my_print (a, b) :
print("왼쪽:", a)
print("오른쪽:", b)
my_print(b=100, a=200)
'''출력:
왼쪽: 200
오른쪽: 100
'''
# 09. 파이썬 함수
# 231 ~ 240
# ___________________________________
def make_url(string) :
return "www." + string + ".com"
make_url("naver")
#문자열을 입력받아 각 문자들로 구성된 리스트로 반환
def make_list(string) :
list = []
for i in string :
list.append(i) #틀린 오답 : list.append(string[i])
return list
make_list("abcd") #출력 ['a', 'b', 'c', 'd']
#문자열을 list로 형변환하면 쉽게 문제를 해결
def make_list (string) :
return list(string)
#하나의 리스트를 입력받아, 짝수들을 추출하여 리스트로 반환
def pickup_even(list) :
result = []
for i in list :
if i%2 == 0 :
result.append(i)
return result
pickup_even([3, 4, 5, 6, 7, 8])
#콤마가 포함된 문자열 숫자를 입력받아 정수로 변환
def convert_int(string) :
return int(string.replace(",",""))
convert_int("1,234,567")
👉 모듈 (241 to 250)
# 10. 파이썬 모듈
# 241 ~ 250
# ___________________________________
#현재시간
#datetime 모듈을 사용해서 현재 시간을 화면에 출력
import datetime
now = datetime.datetime.now()
print(now) #출력 : 2021-03-21 06:23:37.722876
#현재시간의 타입
#datetime 모듈의 now 함수의 리턴 값의 타입을 화면에 출력
import datetime
now = datetime.datetime.now()
print(now, type(now)) #출력 : 2021-03-21 06:30:08.947733 <class 'datetime.datetime'>
#timedelta
#datetime 모듈의 timedelta를 사용해서 오늘로부터 5일, 4일, 3일, 2일, 1일 전의 날짜를 화면에 출력
import datetime
now = datetime.datetime.now()
for day in range(5,0,-1):
delta = datetime.timedelta(days=day)
date = now - delta
print(date)
'''출력 :
2021-03-16 06:32:43.259229
2021-03-17 06:32:43.259229
2021-03-18 06:32:43.259229
2021-03-19 06:32:43.259229
2021-03-20 06:32:43.259229
'''
#strftime
#trftime 메서드. 현재시간을 얻어온 후 다음과 같은 포맷으로 시간을 출력
import datetime
now = datetime.datetime.now()
print(now.strftime("%H:%M:%S")) #출력 : 06:48:45
#strptime
#datetime.datetime.strptime 메서드를 사용하면 문자열 형식의 시간을
#datetime.datetime 타입의 시간 값으로 만들어줌
#"2020-05-04"의 문자열을 시간 타입으로 변환
import datetime
day = "2020-05-04"
ret = datetime.datetime.strptime(day, "%Y-%m-%d")
print(ret, type(ret)) #출력 : 2020-05-04 00:00:00 <class 'datetime.datetime'>
#sleep 함수
#time 모듈, datetime 모듈을 사용해서 1초에 한 번 현재 시간을 출력하는 코드
import time
import datetime
'''
while True :
now = datetime.datetime.now()
print(now)
time.splee(1)
'''
#모듈 임포트
#모듈을 임포트하는 4가지 방식
'''
'''
#os 모듈
#os 모듈의 getcwd 함수를 호출하여 현재 디렉터리의 경로
import os
ret = os.getcwd()
print(ret,type(ret)) #출력 : C:\python_study <class 'str'>
#rename 함수
#바탕화면에 텍스트 파일을 하나 생성한 후 os 모듈의 rename 함수를 호출하여 해당 파일의 이름을 변경
'''
import os
os.rename("C:/Users/hyunh/Desktop/before.txt", "C:/Users/hyunh/Desktop/after.txt")
'''
#numpy
#numpy 모듈의 arange 함수를 사용해서 0.0 부터 5.0까지 0.1씩 증가하는 값을 화면에 출력
import numpy
for i in numpy.arange(0, 5, 0.1):
print(i)
👉 클래스 (251 to 290)
# 11. 파이썬 클래스
# 251 ~ 260
# ___________________________________
#클래스, 객체, 인스턴스 개념 알기
#클래스 정의
class Human :
pass
#참고 파이썬 pass와 continue
#https://zetawiki.com/wiki/%ED%8C%8C%EC%9D%B4%EC%8D%AC_pass%EC%99%80_continue_%EC%B0%A8%EC%9D%B4%EC%A0%90
#인스턴스 생성
# (Human) 클래스의 인스턴스를 "생성" 하고 이를 areum 변수로 바인딩
class Human :
pass
areum = Human()
#클래스 생성자-1
#(Human) 클래스에 "응애응애"를 출력하는 생성자를 추가
class Human :
def __init__(self) :
print("응애응애")
areum = Human()
# 클래스 생성자-2
# (Human) 클래스에 (이름, 나이, 성별)을 받는 생성자를 추가
class Human :
def __init__(self, name, age, sex) :
self.name = name
self.age = age
self.sex = sex
areum = Human("아름", 25, "여자")
print(areum.name)
#인스턴스 속성에 접근
#생성한 인스턴스의 이름, 나이, 성별을 출력
class Human:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
areum = Human("아름", 25, "여자")
print(areum.age)
#클래스 메소드 - 1
#(Human) 클래스에서 이름, 나이, 성별을 출력하는 who() 메소드를 추가
class Human :
def __init__(self,name,age,sex) :
self.name = name
self.age = age
self.sex = sex
def who(self) :
print("이름: {} 나이: {} 성별: {}" .format(self.name,self.age,self.sex))
areum = Human("아름",25,"여자")
areum.who()
#Human.who(areum)
#출력:이름: 조아름, 나이: 25, 성별: 여자
# 클래스 메소드 - 2
class Human:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def who(self):
print("이름: {} 나이: {} 성별: {}".format(self.name, self.age, self.sex))
def setInfo(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
areum = Human("불명", "미상", "모름")
areum.who() # Human.who(areum)
areum.setInfo("아름", 25, "여자")
areum.who() # Human.who(areum)
#클래스 소멸자
class Human:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def __del__(self):
print("나의 죽음을 알리지마라")
def who(self):
print("이름: {} 나이: {} 성별: {}".format(self.name, self.age, self.sex))
def setInfo(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
areum = Human("아름", 25, "여자")
del(areum) #출력 : 나의 죽음을 알리지 말라
# 11. 파이썬 클래스
# 261 ~ 270
# ___________________________________
class Stock:
def __init__(self, name, code):
self.name = name
self.code = code
삼성 = Stock("삼성전자", "005930")
print(삼성.name)
print(삼성.code)
class Stock:
def __init__(self, name, code):
self.name = name
self.code = code
def set_name(self, name):
self.name = name
a = Stock(None, None)
a.set_name("삼성전자") # Stock.set_name(a, "삼성전자")
print(a.name)
class Stock:
def __init__(self, name, code):
self.name = name
self.code = code
def set_name(self, name):
self.name = name
def set_code(self, code):
self.code = code
a = Stock(None, None)
a.set_code("005930")
print(a.code)
class Stock:
def __init__(self, name, code):
self.name = name
self.code = code
def set_name(self, name):
self.name = name
def set_code(self, code):
self.code = code
def get_name(self):
return self.name
def get_code(self):
return self.code
삼성 = Stock("삼성전자", "005930")
print(삼성.name)
print(삼성.code)
print(삼성.get_name())
print(삼성.get_code())
class Stock:
def __init__(self, name, code, per, pbr, dividend):
self.name = name
self.code = code
self.per = per
self.pbr = pbr
self.dividend = dividend
def set_name(self, name):
self.name = name
def set_code(self, code):
self.code = code
def get_name(self):
return self.name
def get_code(self):
return self.code
def set_per(self, per):
self.per = per
def set_pbr(self, pbr):
self.pbr = pbr
def set_dividend(self, dividend):
self.dividend = dividend
종목 = []
삼성 = Stock("삼성전자", "005930", 15.79, 1.33, 2.83)
현대차 = Stock("현대차", "005380", 8.70, 0.35, 4.27)
LG전자 = Stock("LG전자", "066570", 317.34, 0.69, 1.37)
종목.append(삼성)
종목.append(현대차)
종목.append(LG전자)
for i in 종목:
print(i.code, i.per) # i-> Stock 클래스의 객체를 바인딩하기 때문
# 11. 파이썬 클래스
# 281 ~ 290
# ___________________________________
class 차 :
def __init__(self,바퀴,가격) :
self.바퀴 = 바퀴
self.가격 = 가격
car = 차 (2,1000)
print(car.바퀴)
print(car.가격)
#클래스 상속
#차 클래스를 상속받은 자전차 클래스
class 차 :
def __init__(self,바퀴,가격) :
self.바퀴 = 바퀴
self.가격 = 가격
class 자전거(차):
pass
#부모 클래스 메서드 호출
class 차:
def __init__(self, 바퀴, 가격):
self.바퀴 = 바퀴
self.가격 = 가격
def 정보(self):
print("바퀴수 ", self.바퀴)
print("가격 ", self.가격)
class 자동차(차):
def __init__(self, 바퀴, 가격):
super().__init__(바퀴, 가격)
class 자전차(차):
def __init__(self, 바퀴, 가격, 구동계):
super().__init__(바퀴, 가격)
self.구동계 = 구동계
def 정보(self):
super().정보()
print("구동계 ", self.구동계)
bicycle = 자전차(2, 100, "시마노")
bicycle.정보()
#메서드 오버라이딩
class 부모:
def 호출(self):
print("부모호출")
class 자식(부모):
def 호출(self):
print("자식호출")
나 = 자식()
나.호출()
#생성자
class 부모:
def __init__(self):
print("부모생성")
class 자식(부모):
def __init__(self):
print("자식생성")
나 = 자식()
#부모클래스 생성자 호출
class 부모:
def __init__(self):
print("부모생성")
class 자식(부모):
def __init__(self):
print("자식생성")
super().__init__()
나 = 자식()
👉 파일 입출력과 예외처리(291 to 300)
# 12. 파일 입출력과 예외처리
# 291 ~ 300
# ___________________________________
#파일 쓰기
#바탕화면에 '매수종목1.txt' 파일을 생성한 후 다음과 같이 종목코드를 파일에 써보
'''
f = open("C:/Users/hyunh/Desktop/매수종목1.txt", mode="wt", encoding="utf-8")
f.write("005930\n")
f.write("005380\n")
f.write("035420")
f.close()
'''
#CSV 파일 쓰기
#바탕화면에 '매수종목.csv' 파일을 생성한 후
# 다음과 같이 종목코드와 종목명을 파일에 써보세요.
# 인코딩은 'cp949'를 사용해야함
'''
import csv
f = open("C:/Users/hyunh/Desktop/매수종목.csv", mode="wt", encoding="cp949", newline='')
writer = csv.writer(f)
writer.writerow(["종목명", "종목코드", "PER"])
writer.writerow(["삼성전자", "005930", 15.59])
writer.writerow(["NAVER", "035420", 55.82])
f.close()
'''
#파일 읽기
'''
f = open("C:/Users/hyunh/Desktop/매수종목1.txt", encoding="utf-8")
lines = f.readlines() # python list
codes = []
for line in lines:
code = line.strip() #'\n'
codes.append(code)
print(codes)
f.close()
'''
#예외처리
#문자열 PER (Price to Earning Ratio) 값을 실수로 변환할 때 에러가 발생함
#예외처리를 통해 에러가 발생하는 PER은 0으로 출력하라
per = ["10.31", "", "8.00"]
for i in per:
try:
print(float(i))
except:
print(0)
#예외처리 및 리스트에 저장
#문자열로 표현된 PER 값을 실수로 변환한 후 이를 새로운 리스트에 저장
per = ["10.31", "", "8.00"]
new_per = []
for i in per:
try:
v = float(i)
except:
v = 0
new_per.append(v)
print(new_per)
#특정 예외만 처리하기
#어떤 값을 0으로 나누면 ZeroDivisionError 에러가 발생함
#try ~ except로 모든 에러에 대해 예외처리하지 말고 ZeroDivisionError 에러만 예외처리
try:
b = 3 / 0
except ZeroDivisionError:
print("0으로 나누면 안되요")
#예외의 메시지 출력하기
'''
try:
실행코드
except 예외 as 변수:
예외처리코드
'''
data = [1, 2, 3]
for i in range(5) :
print(data[i])
#try, except, else, finally 구조 사용해보기
'''
try:
실행 코드
except:
예외가 발생했을 때 수행할 코드
else:
예외가 발생하지 않았을 때 수행할 코드
finally:
예외 발생 여부와 상관없이 항상 수행할 코드
'''
per = ["10.31", "", "8.00"]
for i in per:
try:
print(float(i))
except:
print(0)
else:
print("clean data")
finally:
print("변환 완료")
# 07. 파이썬 분기문
# 101 ~ 110
# ___________________________________
#파이썬에서 True 혹은 False를 갖는 데이터 타입 : bool타입
print(3==5) #출력 : False
print(3 < 5) #출력 : True
x=4
print(1<x<5) #출력 : True
print((3==3)and(4!=3)) #출력 : True
#print(3=>4) #error : 지원하지 않는 연산자
if 4 < 3:
print("Hello World.")
else:
print("Hi, there.")
if True :
print("1")
print("2")
else :
print("3")
print("4")
'''출력 :
1
2
4
'''
if True :
if False :
print("1")
print("2")
else :
print("3")
else :
print("4")
print("5")
'''출력 :
3
5
'''
# 07. 파이썬 분기문
# 111 ~ 120
# ___________________________________
#사용자로부터 입력받은 문자열을 두 번 출력
user = input("입력 : ")
print(user * 2)
'''출력:
입력 : 안녕하세요
안녕하세요안녕하세요
'''
user = input("숫자를 입력하세요 : ")
print(10+ int(user))
'''출력:
숫자를 입력하세요 : 10
20
'''
#사용자로부터 하나의 숫자를 입력 받고 짝수/홀수를 판별
user = input()
if int(user)%2==0 :
print("짝수")
else :
print("홀수")
#해당 값에 20을 더한 값을 출력
#사용자가 입력한 값과 20을 더한 계산 값이 255를 초과하는 경우 255를 출력
user = input("입력값: ")
num = 20 + int(user)
if num > 255:
print(255)
else:
print(num)
#해당 값에 20을 뺀 값을 출력
#출력 값의 범위는 0~255
#0보다 작은 값이되는 경우 0을 출력하고 255보다 큰 값이 되는 경우 255를 출력
user = input("입력값: ")
num = int(user) - 20
if num > 255:
print(255)
elif num < 0 :
print(0)
else:
print(num)
#입력 받은 시간이 정각인지 판별
time = input("현재시간: ")
if time[-2:] == "00":
print("정각 입니다.")
else:
print("정각이 아닙니다.")
''' 출력 :
현재시간:02:00
정각 입니다.
'''
#입력받은 단어가 아래 fruit 리스트에 포함되어 있는지를 확인
fruit=["사과","포도","홍시"]
user = input("좋아하는 과일은?")
if user in fruit :
print("정답입니다.")
else :
print("오답입니다.")
warn_investment_list = ["Microsoft", "Google", "Naver", "Kakao", "SAMSUNG", "LG"]
종목 = input("종목명: ")
if 종목 in warn_investment_list:
print("투자 경고 종목입니다.")
else:
print("투자 경고 종목이 아닙니다.")
#사용자가 입력한 값이 딕셔너리 키 (key) 값에 포함
fruit={"봄": "딸기", "여름" : "토마토", "가을":"사과"}
user = input("좋아하는게절은: ")
if user in fruit :
print("정답입니다.")
else :
print("오답입니다.")
#사용자가 입력한 값이 딕셔너리 키 (key) 값에 포함
fruit={"봄": "딸기", "여름" : "토마토", "가을":"사과"}
user = input("좋아하는게절은: ")
if user in fruit :
print("정답입니다.")
else :
print("오답입니다.")
#사용자가 입력한 값이 딕셔너리 값 (value)에 포함
user = input("좋아하는 과일은?")
if user in fruit.values():
print("정답입니다.")
else:
print("오답입니다.")
# 07. 파이썬 분기문
# 121 ~ 130
# ___________________________________
#문자 한 개를 입력 받고, 소문자일 경우 대문자로, 대문자 일 경우, 소문자로 변경해서 출력
# islower() 함수는 문자의 소문자 여부를 판별, 반환 True/False
# upper() 함수는 대문자로, lower() 함수는 소문자로 변경
user = input("")
if user.islower() :
print(user.upper())
else :
print(user.lower())
#사용자로부터 score를 입력받아 학점을 출력
user = input ("")
score = int(user)
if 81 <= score <= 100:
print("grade is A")
elif 61 <= score <= 80:
print("grade is B")
elif 41 <= score <= 60:
print("grade is C")
elif 21 <= score <= 40:
print("grade is D")
else:
print("grade is E")
#달러, 엔, 유로, 또는 위안 금액을 입력받은 후 이를 원으로 변환
#사용자는 100 달러, 1000 엔, 13 유로, 100 위안과 같이 금액과 통화명 사이에 공백을 넣어 입력한다
환율 = {"달러":1167, "엔":1.096, "유로":1268, "위안":171}
user=input("입력:")
num, currency = user.split()
print(float(num)*환율[currency],"원")
#세 개의 숫자를 입력 받은 후 가장 큰 숫자를 출력
num1 = input("input number1: ")
num2 = input("input number2: ")
num3 = input("input number3: ")
num1 = int(num1)
num2 = int(num2)
num3 = int(num3)
if num1 > num2 and num1 > num3 :
print(num1)
elif num2 > num3 and num2 > num1 :
print(num2)
else :
print(num3)
#사용자로부터 휴대전화 번호를 입력 받고, 통신사를 출력
number = input("휴대전화 번호 입력:")
num = number.split("-")[0]
if num == "011":
com = "SKT"
elif num == "016":
com = "KT"
elif num == "019":
com = "LGU"
else:
com = "알수없음"
print(f"당신은 {com} 사용자입니다.")
'''출력:
휴대전화 번호 입력: 011-345-1922
당신은 SKT 사용자입니다.
'''
'''
슬라이싱 참고
a = ['a', 'b', 'c', 'd', 'e']
a[ 2 : 4 ]
출력 : ['c', 'd']
end 는 포함되지 않음
'''
#5자리 우편번호를 입력받고 구를 판별
우편번호 = input("우편번호: ")
우편번호 = 우편번호[:3] #앞의 세자리만
if 우편번호 in ["010", "011", "012"]:
print("강북구")
elif 우편번호 in ["014", "015", "016"]:
print("도봉구")
else:
print("노원구")
'''출력 :
우편번호: 01400
도봉구
'''
주민번호 = input("주민등록번호: ")
주민번호 = 주민번호.split("-")[1]
if 주민번호[0] == "1" or 주민번호[0] == "3":
print("남자")
else:
print("여자")
주민번호 = input("주민등록번호: ")
뒷자리 = 주민번호.split("-")[1]
if 0 <= int(뒷자리[1:3]) <= 8:
print("서울입니다.")
else:
print("서울이 아닙니다.")
#유효한 주민번호
#참고 :
# 파이썬에서 역슬래쉬(\)는 구문이 길어질 때, 다음 줄까지 구문을 잇겠다는 것을 의미
num = input("주민등록번호:")
계산1 = int(num[0]) * 2 + int(num[1]) * 3 + int(num[2]) * 4 + int(num[3]) * 5 + int(num[4]) * 6 + \
int(num[5]) * 7 + int(num[7]) * 8 + int(num[8]) * 9 + int(num[9]) * 2 + int(num[10])* 3 + \
int(num[11])* 4 + int(num[12]) * 5
계산2 = 11 - (계산1 % 11)
계산3 = str(계산2)
if num[-1] == 계산3[-1]:
print("유효한 주민등록번호입니다.")
else:
print("유효하지 않은 주민등록번호입니다.")
'''출력:
주민등록번호: 821010-1635210
유효하지 않은 주민등록번호입니다.
'''
#비트코인의 가격 정보를 딕셔너리로 가져오는 코드
''' import 에러남. 파이썬 가상환경 만들어 줘야함
import requests
btc = requests.get("https://api.bithumb.com/public/ticker/").json()['data']
변동폭 = float(btc['max_price']) - float(btc['min_price'])
시가 = float(btc['opening_price'])
최고가 = float(btc['max_price'])
if (시가+변동폭) > 최고가:
print("상승장")
else:
print("하락장")
'''
👉 반복문 (131 to 200)
# 08. 파이썬 반복문
# 131 ~ 140
# ___________________________________
과일 = ["사과","귤","수박"]
for 변수 in 과일 :
print(변수)
'''출력:
사과
귤
수박
'''
#for문의 핵심은 "들여쓰기된 코드가 자료구조에 저장된 데이터 개수만큼 반복된다"
과일 = ["사과", "귤", "수박"]
for 변수 in 과일:
print("#####")
'''출력:
#####
#####
#####
'''
#for 문과 동일한 기능을 수행
for 변수 in ["A", "B", "C"]:
print("출력:", 변수)
변수 = "A"
print("출력:", 변수)
변수 = "B"
print("출력:", 변수)
변수 = "C"
print("출력:", 변수)
print("출력:", "A")
print("출력:", "B")
print("출력:", "C")
for 변수 in [10, 20, 30]:
print(변수)
리스트 = [10, 20, 30]
for 변수 in 리스트:
print(변수)
for 변수 in ["가", "나", "다", "라"]:
print("-------")
'''출력:
-------
-------
-------
-------
'''
# 08. 파이썬 반복문
# 141 ~ 150
# ___________________________________
리스트 = [100, 200, 300]
for 변수 in 리스트:
print(변수 + 10)
리스트 = ["김밥", "라면", "튀김"]
for 메뉴 in 리스트:
print("오늘의 메뉴: " + 메뉴)
리스트 = ["김밥", "라면", "튀김"]
for 메뉴 in 리스트:
print("오늘의 메뉴:", 메뉴)
#문자열길이 출력
리스트 = ["SK하이닉스", "삼성전자", "LG전자"]
for i in 리스트 :
print(len(i))
'''출력:
6
4
4
'''
리스트 = ['dog', 'cat', 'parrot']
for 이름 in 리스트:
print(이름, len(이름))
'''출력:
dog 3
cat 3
parrot 6
'''
#리스트 첫글자만 출력
리스트 = ['dog', 'cat', 'parrot']
for 이름 in 리스트:
print(이름[0])
'''출력:
d
c
p
'''
리스트 = [1, 2, 3]
for 변수 in 리스트:
print("3 x ", 변수, "=", 3 * 변수)
리스트 = ["가", "나", "다", "라"]
나다라 = 리스트[1:]
for 변수 in 나다라 :
print(변수)
'''출력:
나
다
라
'''
리스트 = ["가", "나", "다", "라"]
for 변수 in 리스트[1:]:
print(변수)
리스트 = ["가", "나", "다", "라"]
for 변수 in 리스트[: :2]:
print(변수)
리스트 = ["가", "나", "다", "라"]
for 변수 in 리스트[: :-1]:
print(변수)
# 08. 파이썬 반복문
# 151 ~ 160
# ___________________________________
#리스트 음수만 출력
리스트 = [3, -20, -3, 44]
for 변수 in 리스트 :
if 변수 < 0 :
print(변수)
#20 보다 작은 3의 배수를 출력
리스트 = [13, 21, 12, 14, 30, 18]
for 변수 in 리스트:
if (변수 < 20) and (변수 % 3 == 0):
print(변수)
#리스트에서 세 글자 이상의 문자 출력
리스트 = ["I", "study", "python", "language", "!"]
for i in 리스트 :
if len(i) >= 3 :
print(i)
'''출력:
study
python
language
'''
리스트 = ["A", "b", "c", "D"]
for 변수 in 리스트:
if 변수.isupper():
print(변수)
리스트 = ["A", "b", "c", "D"]
for 변수 in 리스트:
if 변수.isupper() != True:
print(변수)
리스트 = ["A", "b", "c", "D"]
for 변수 in 리스트:
if not 변수.isupper():
print(변수)
리스트 = ['dog', 'cat', 'parrot']
for i in 리스트 :
print( i[0].upper() + i[1:])
'''출력:
Dog
Cat
Parrot
'''
리스트 = ['hello.py', 'ex01.py', 'intro.hwp']
for 변수 in 리스트:
split = 변수.split(".")
print(split[0])
리스트 = ['intra.h', 'intra.c', 'define.h', 'run.py']
for 변수 in 리스트:
split = 변수.split(".")
if split[1] == "h":
print(변수)
리스트 = ['intra.h', 'intra.c', 'define.h', 'run.py']
for 변수 in 리스트:
split = 변수.split(".")
if (split[1] == "h") or (split[1] == "c"):
print(변수)
# 08. 파이썬 반복문
# 161 ~ 170
# ___________________________________
#0~99까지 한 라인에 하나씩 순차적으로 출력
for i in range(100) :
print(i)
for i in range(2002,2051,4):
print(i)
for num in range(3, 31, 3):
print (num)
#99부터 0까지 1씩 감소하는 숫자
for i in range(100) :
print(99 - i)
for num in range(10) :
print(num / 10)
'''출력:
0.0
0.1
0.2
0.3
0.4
0.5
...
0.9
'''
for i in range(1, 10) :
print (3, "x", i, " = ", 3 * i)
#구구단 3단을 출력하라. 단 홀수 번째만 출력
num = 3
for i in range(1, 10, 2) :
print (num, "x", i, " = ", num * i)
num = 3
for i in range(1, 10) :
if i % 2 == 1 :
print (num, "x", i, " = ", num * i)
sum=0
for i in range(1,11) :
sum +=i
print(sum)
hab = 0
for i in range(1, 11, 2):
hab += i
print ("합 :", hab)
result = 1
for i in range(1, 11) :
result *= i
print(result)
# 08. 파이썬 반복문
# 171 ~ 180
# ___________________________________
price_list = [32100, 32150, 32000, 32500]
for i in range(4):
print(price_list[i])
for i in range(len(price_list)):
print(price_list[i])
'''출력:
32100
32150
32000
32500
'''
#enumerate() 반복문 사용 시 몇 번째 반복문인지 확인 가능
#참고 https://wikidocs.net/16045
price_list = [32100, 32150, 32000, 32500]
for i, data in enumerate(price_list) :
print(i, data)
'''출력:
0 32100
1 32150
2 32000
3 32500
'''
for i in range(len(price_list)):
print((len(price_list) - 1) - i, price_list[i])
'''출력:
3 32100
2 32150
1 32000
0 32500
'''
for i in range(1, 4):
print(90 + 10 * i, price_list[i])
'''출력:
100 32150
110 32000
120 32500
'''
my_list = ["가", "나", "다", "라"]
for i in range (1,len(my_list)):
print(my_list[i-1], my_list[i])
'''출력:
가 나
나 다
다 라
'''
my_list = ["가", "나", "다", "라", "마"]
for i in range( len(my_list) - 2 ):
print(my_list[i], my_list[i+1], my_list[i+2])
for i in range(1,len(my_list)-1) :
print(my_list[i-1],my_list[i],my_list[i+1])
for i in range( 2, len(my_list) ):
print(my_list[i-2], my_list[i-1], my_list[i])
'''출력:
가 나 다
나 다 라
다 라 마
'''
my_list = ["가", "나", "다", "라"]
for i in range(len(my_list) - 1, 0, -1):
print(my_list[i], my_list[i-1])
'''출력:
라 다
다 나
나 가
'''
#각각의 데이터에 대해서 자신과 우측값과의 차분값을 화면에 출력
my_list = [100, 200, 400, 800]
for i in range(len(my_list)-1) :
print( my_list[i+1] - my_list[i])
'''출력:
100
200
400
'''
#종가 데이터의 3일 이동 평균
my_list = [100, 200, 400, 800, 1000, 1300]
for i in range(1,len(my_list)-1) :
print( (my_list[i-1]+my_list[i]+my_list[i+1])/3 )
'''출력:
233.33333333333334
466.6666666666667
733.3333333333334
1033.3333333333333
'''
#5일간의 변동폭을 volatility 리스트에 저장
low_prices = [100, 200, 400, 800, 1000]
high_prices = [150, 300, 430, 880, 1000]
volatility = []
for i in range(len(low_prices)) :
volatility.append(high_prices[i] - low_prices[i])
print(volatility) #출력:[50, 100, 30, 80, 0]
# 08. 파이썬 반복문
# 181 ~ 190
# ___________________________________
#총 3개의 리스트를 갖는 이차원 리스트 apart를 정의
apart = [ ["101호", "102호"], ["201호", "202호"], ["301호", "302호"] ]
stock = [ ["시가", 100, 200, 300], ["종가", 80, 210, 330] ]
#stock 이름의 딕셔너리로 표현
stock = {"시가": [100, 200, 300], "종가": [80, 210, 330] }
stock = {"10/10": [80, 110, 70, 90], "10/11": [210, 230, 190, 200] }
apart = [ [101, 102], [201, 202], [301, 302] ]
for row in apart :
for col in row :
print(col, "호")
'''출력:
101 호
102 호
201 호
202 호
301 호
302 호
'''
for row in apart [::-1] :
for col in row [::-1] :
print(col,"호")
'''출력:
302 호
301 호
202 호
201 호
102 호
101 호
'''
for row in apart :
for col in row :
print(col, "호")
print("------")
'''출력:
101 호
102 호
-----
201 호
202 호
-----
301 호
302 호
-----
'''
# 08. 파이썬 반복문
# 191 ~ 200
# ___________________________________
data = [
[ 2000, 3050, 2050, 1980],
[ 7500, 2050, 2050, 1980],
[15450, 15050, 15550, 14900]
]
for line in data :
for column in line :
print(column * 1.00014)
#result 이름의 리스트에 1차원 배열로 저장
result = []
for line in data:
for column in line:
result.append(column * 1.00014)
print(result)
#result 이름의 리스트에 2차원 배열로 저장
result2 = []
for line in data :
sub = []
for column in line :
sub.append(column * 1.00014)
result2.append(sub)
print(result2)
'''출력:
[
[2000.28, 3050.427, 2050.2870000000003, 1980.2772],
[7501.05, 2050.2870000000003, 2050.2870000000003, 1980.2772],
[15452.163, 15052.107, 15552.177, 14902.086000000001]
]
'''
#ohlc 리스트에는 시가(open), 고가 (high), 저가 (low) ,
#종가(close)가 날짜별로 저장돼 있다. 화면에 종가데이터를 출력
ohlc = [["open", "high", "low", "close"],
[100, 110, 70, 100],
[200, 210, 180, 190],
[300, 310, 300, 310]]
for line in ohlc[1:] :
print(line[3])
'''출력:
100
190
310
'''
#종가가 150원보다 큰경우에만 종가를 출력
for row in ohlc[1:]:
if (row[3] > 150) :
print(row[3])
'''출력:
190
310
'''
for row in ohlc[1:]:
if (row[3] > row[0]) :
print(row[3])
volatility = []
for i in ohlc[1:] :
volatility.append(i[1]-i[2])
print(volatility) #출력 : [40, 30, 10]
volatility = []
for i in range(1, len(ohlc)):
volatility.append(ohlc[i][1]-ohlc[i][2])
print(volatility) #출력 : [40, 30, 10]
for row in ohlc[1:]:
if row[3] > row[0]:
print(row[1]-row[2])
profit = 0
for row in ohlc[1:]:
profit += (row[3] - row[0])
# 01. 파이썬 시작하기
# 001 ~ 010
# _____________________________________________
# print 기초
# print는 정수, 실수, 문자열 등을 화면에 출력
# 문자열은 큰따옴표 또는 작은따옴표로 표현 가능
print("Hello World")
print('Hello World')
print("Mary's cosmetics")
print('신씨가 소리질렀다. "도둑이야". ')
print('"c:\Windows"')
print('"안녕하세요. \n만나서 \t\t반갑습니다."')
#여러 값을 출력하려면 print 함수에서 쉼표로 구분
print("오늘은","일요일")
# print 함수의 sep 인자로 ";"를 입력하면 출력되는 값들 사이에 한 칸의 공백대신 세미콜론이 출력
# sep = separator 분리기호
print("naver", "kakao", "samsung", sep=";") # 출력:naver;kakao;samsung
print("naver","kakao","sk","samsung",sep="/") # 출력:naver/kakao/sk/samsung
# end=""
# 세미콜론 (;)은 한줄에 여러 개의 명령을 작성하기 위해 사용
print("first");print("second")
#결과:
#first
#second
print("first", end="");print("second") # 결과:firstsecond
#연산 결과 출력
print(5/3)
👉 변수 (011 to 020)
# 02. 파이썬 변수
# 011 ~ 020
# _____________________________________________
#변수 사용하기
삼성전자 = 50000
총평가금액 = 삼성전자 * 10
print(총평가금액)
시가총액 = 298000000000
현재가 = 50000
PER = 15.79
print(시가총액, type(시가총액)) #출력: 298000000000 <class 'int'>
print(현재가, type(현재가)) #출력: 50000 <class 'int'>
print(PER, type(PER)) #출력: 15.79 <class 'float'>
#문자열 출력
s="hello"
t="python"
print(s+"!",t) #출력:hello! python
#값 계산
print(2+2*3)
#type함수
a=128
print(a, type(a))
#문자열 -> 정수 변환
num_str = "720"
print(int(num_str)+1, type(int(num_str)+1))
#정수 -> 문자열 100 변환
num = 100
print(str(num), type(str(num)))
#문자열 -> 실수 변환
strr="15.79"
print(float(strr), type(float(strr))) #출력: 15.79 <class 'float'>
#문자열 -> 정수 변환
year = "2020"
print(int(year), type(int(year)))
에어컨 = 48584
할부개월 = 36
총금액 = 에어컨*할부개월
print(총금액)
👉 문자열 (021 to 050)
# 03. 파이썬 문자열
# 021 ~ 030
# _____________________________________________
#문자열 인덱싱
letters = 'python'
print(letters[0],letters[2]) #출력: p t
#문자열 슬라이싱 : 문자열에서 여러 글자를 가져오는 것
#시작 인덱스를 생락하면 0으로 간주, 끝 인덱스를 생략하면 문자열의 끝을 의미
license_plate = "24가 2210"
print(license_plate[-4:]) #출력: 2210
#문자열 인덱싱
#시작인덱스:끝인덱스:오프셋
string = "홀짝홀짝홀짝"
print(string[::2]) #출력: 홀홀홀
#거꾸로 출력
string2="PYTHON"
print(string2[::-1]) #출력:NOHTYP
#문자열 치환
#파이썬 문자열에서 replace 메서드를 사용하면 문자열을 일부를 치환
#문자열은 수정할 수 없는 자료형이므로 기존 문자열은 그대로 두고 치환된 새로운 문자열이 리턴
#전화번호에서 -를 제거하고 출력
phone_number="010-1111-2222"
phone_number1 = phone_number.replace("-"," ")
print(phone_number1) #출력:010 1111 2222
#문자열 다루기
#웹페이지에서 도메인을 출력, 문자열로 표현된 url에서 .을 기준으로 분리
url="http://charebook.kr"
url_split = url.split('.')
print(url_split[-1]) #출력: kr
#문자열은 immutable
#... 문자열은 수정할 수 없다. 문자열이 할당(assignment) 메서드를 지원하지 않음
#lang3='python'
#lang3[0]='P'
#print(lang3)
#replace 메서드
string3 = 'abcdfe2a354a32a'
string3 = string3.replace('a','A')
print(string3) #출력: Abcdfe2A354A32A
#abcd가 그대로 출력된다.
#문자열은 변경할 수 없는 자료형이기 때문.
#replace 메서드를 사용하면 원본은 그대로 둔채로 변경된 새로운 문자열 객체를 리턴함.
string4 = 'abcd'
string4.replace('b', 'B')
print(string4) #출력 : abcd
#올바르게 고치면, string4 = string4.replace('b', 'B') 으로 한다.
# 03. 파이썬 문자열
# 031 ~ 040
# _____________________________________________
#문자열 합치기
a="3"
b="4"
print(a+b) #출력:34
#문자열 곱하기
print("Hi"*3) #출력:HiHiHi
print("-"*80)
t1='python'
t2='java'
t3 = t1 + ' ' + t2 + ' '
print(t3*4) #출력: python java python java python java python java
#문자열 출력
#문자열과 정수가 바인딩되어 있을 때 % formatting을 사용
name1 = "김민수"
age1 = 10
name2 = "이철희"
age2 = 13
print("이름 : %s 나이 : %d" % (name1,age1))
print("이름 : %s 나이 : %d" % (name2,age2))
#문자열의 format( ) 메서드를 사용
#문자열의 포맷 메서드는 타입과 상관없이 값이 출력될 위치에 { }
print("이름 : {} 나이 : {}" .format(name1,age1))
print("이름 : {} 나이 : {}" .format(name2,age2))
#파이썬 3.6부터 지원하는 f-string을 사용
print(f"이름: {name1} 나이: {age1}")
print(f"이름: {name2} 나이: {age2}")
#컴마 제거하기
상장주식수 = "5,969,782,550"
상장주식수 = 상장주식수.replace(',',"")
print(int(상장주식수), type(int(상장주식수)))
#문자열 슬라이싱
분기 = "2020/03(E) (IFRS연결)"
print(분기[:7])
#strip 메서드
#문자열의 좌우의 공백이 있을 때 이를 제거
data = " 삼성전자 "
print(data.strip())
# 03. 파이썬 문자열
# 041 ~ 050
# ___________________________________
#uppper 메서드
#문자열이 있을 때 이를 대문자 BTC_KRW로 변경
ticket="btc_krw"
print(ticket.upper())
#lower 메서드
#문자열이 있을 때 이를 소문자 btc_krw로 변경
ticket2 = "BTC_KRW"
print(ticket2.lower())
#capitalize 메서드 첫글자만 소 > 대문자로
#문자열 'hello'가 있을 때 이를 'Hello'로 변경
a = "hello"
a = a.capitalize() #출력:Hello
print(a)
#endswith 메서드
#파일 이름이 문자열로 저장되어 있을 때
#endswith 메서드를 사용해서 파일 이름이 'xlsx'로 끝나는지 확인
file_name="보고서.xlsx"
file_name.endswith("xlsx")
print(file_name.endswith("xlsx")) #결과:True
#endswith 메서드를 사용해서 파일 이름이 'xlsx' 또는 'xls'로 끝나는지 확인
print(file_name.endswith(("xlsx", "xls"))) #결과:True
#startswith 메서드
#파일 이름이 문자열로 저장되어 있을 때
# startswith 메서드를 사용해서 파일 이름이 '2020'로 시작하는지 확인
file_name2 ="2020_보고서.xlsx"
print(file_name2.startswith("2020")) #결과:True
#split 메서드
#문자열이 있을 때 공백을 기준으로 문자열을 나눈다.
#어떤 값을 넘겨주면 그 값을 기준으로 문자열을 분리해줌
b = "hello world"
b.split(" ")
print(b.split(" ")) #결과:['hello', 'world']
ticker3 = "btc_krw"
ticker3.split("_")
print(ticker3.split("_")) #결과:['btc', 'krw']
#날짜를 표현하는 문자열이 있을 때 연도, 월, 일로 나눔.
date = "2020-05-01"
date.split("-")
print(date.split("-")) #결과:['2020', '05', '01']
#restrip 메서드
#문자열의 오른쪽에 공백이 있을 때 이를 제거
data4 = "039490 "
data4.rstrip()
print(data4.rstrip())
# 참고 https://codechacha.com/ko/python-string-strip/
# strip([chars]) : 인자로 전달된 문자를 String의 왼쪽과 오른쪽에서 제거합니다.
# lstrip([chars]) : 인자로 전달된 문자를 String의 왼쪽에서 제거합니다.
# rstrip([chars]) : 인자로 전달된 문자를 String의 오른쪽에서 제거합니다.
👉 리스트 (051 to 070)
# 04. 파이썬 리스트
# 051 ~ 060
# ___________________________________
#리스트 생성
movie_rank =["닥터 스트레인지","스플릿","럭키"]
#리스트에 원소 추가
movie_rank.append("베트맨")
print(movie_rank)
#insert(인덱스, 원소) 메서드를 사용하면 특정 위치에 값을 끼어넣기
movie_rank.insert(1,"슈퍼맨")
print(movie_rank) #결과:['닥터 스트레인지', '슈퍼맨', '스플릿', '럭키', '베트맨']
#리스트 원소 삭제
#del을 이용하여 리스트에서 원소를 삭제
#리스트에서 어떤 값을 삭제하면 남은 값들은 새로 인덱싱
#여러 값을 삭제할 때는 어떤 값이 먼저 삭제된 후 남은 원소들에 대해서
#순서를 새로 고려한 후 삭제해야 함
del movie_rank[3]
print(movie_rank)
del movie_rank[2]
del movie_rank[2]
print(movie_rank) #결과:['닥터 스트레인지', '슈퍼맨']
#lang1과 lang2 리스트가 있을 때
#lang1과 lang2의 원소를 모두 갖고 있는 langs 리스트를 만들어라.
lang1 = ["C", "C++", "JAVA"]
lang2 = ["Python", "Go", "C#"]
print(lang1+lang2) #결과:['C', 'C++', 'JAVA', 'Python', 'Go', 'C#']
#리스트에서 최댓값과 최솟값을 출력하라. (힌트: min(), max() 함수 사용
nums = [1, 2, 3, 4, 5, 6, 7]
print("max: ", max(nums))
print("min: ", min(nums))
#리스트의 합
nums2 = [1,2,3,4,5]
print("sum : ", sum(nums2))
#리스트의 평균
print("평균 : ", sum(nums2)/len(nums2))
#리스트에 저장된 데이터의 개수
cook = ["피자", "김밥", "만두", "양념치킨", "족발", "피자", "김치만두", "쫄면", "쏘세지", "라면", "팥빙수", "김치전"]
print(len(cook))
# 05. 파이썬 튜플
# 071 ~ 080
# ___________________________________
#my_variable 이름의 비어있는 튜플 만들어라
#괄호는 튜플을 정의하는 기호
my_variable = ()
print(type(my_variable)) #출력:<class 'tuple'> 으로 튜플이 생성되었는지 확인함.
movie_rank = ("닥터 스트레인지", "스플릿", "럭키")
print(movie_rank) #출력:('닥터 스트레인지', '스플릿', '럭키')
#숫자 1 이 저장된 튜플을 생성
#아래와 같이 괄호와 함께 하나의 정숫값을 저장하면 튜플이 정의 될 것같지만 그렇지 않습니다.
#type()을 출력해보면 파이썬은 튜플이 아닌 정수로 인식
my_tuple0 = (1)
print(type (my_tuple0)) #출력:<class 'int'>
#하나의 데이터가 저장되는 경우, 아래와 같이 쉼표를 입력해만 함.
my_tuple = (1, )
print(type (my_tuple)) #출력:<class 'tuple'>
#아래 오류 발생함
#tuple은 원소(element)의 값을 변경할 수 없습니다.
'''t = (1, 2, 3)
t[0] = 'a' '''
#원칙적으로 튜플은 괄호와 함께 데이터를 정의해야 하지만,
#사용자 편의를 위해 괄호 없이도 동작합니다.
t=1,2,3,4
#변수 t가 ('A', 'b', 'c') 튜플을 가리키도록 수정하라.
t = ('a', 'b', 'c')
#튜플의 값은 변경할 수 없기 때문에,
# 리스트와 달리 아래 코드는 동작하지 않습니다. ==> t[0] = 'A'
#새로운 튜플을 만들고 t 라는 변수를 업데이트 해야 합니다.
# 기존의 튜플 ('a', 'b', 'c')은 자동으로 삭제
t = ('A', 'b', 'c')
#튜플을 리스트로 변환
interest = ('삼성전자', 'LG전자', 'SK Hynix')
datalist = list(interest)
#리스트를 튜플로 변경
interest = ['삼성전자', 'LG전자', 'SK Hynix']
datatuple = tuple(interest)
#튜플 언팩킹
temp = ('apple', 'banana', 'cake')
a, b, c = temp
print(a, b, c) #출력:apple banana cake
#range 함수
#1 부터 99까지의 정수 중 짝수만 저장된 튜플을 생성 (2, 4, 6, 8 ... 98)
result = tuple( range(2,100,2))
print(result)
👉 딕셔너리 (081 to 100)
# 06. 파이썬 딕셔너리
# 081 ~ 090
# ___________________________________
#별 표현식
#기본적으로 데이터 언패킹은 좌변의 변수와 우변 데이터 개수가 같아야 합니다.
#하지만 star expression을 사용하면 변수의 개수가 달라도
#데이터 언패킹을 할 수 있습니다. 튜플에 저장된 데이터 중에서
#앞에 있는 두 개의 데이터만 필요할 경우 나머지 데이터의 언패킹 코드를
#작성할 필요가 없음.
a,b,*c = (0,1,2,3,4,5)
print(a) #출력:0
print(b) #출력:1
print(c) #출력:[2,3,4,5]
#10개의 값이 저장된 scores 리스트가 있을 때,
#start expression을 사용하여 좌측 8개의 값을 valid_score 변수에 바인딩
scores = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]
*valid_score,_,_ = scores
print(valid_score) #출력:[8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5]
#우측 8개의 값을 valid_score 변수에 바인딩
scores2 = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]
a,b,*valid_score2 = scores2
print(valid_score2) #출력:[8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]
#가운데 있는 8개의 값을 valid_score 변수에 바인딩
scores3 = [8.8, 8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8, 9.4]
a,*valid_score3,b = scores3
print(valid_score3) #출력:[8.9, 8.7, 9.2, 9.3, 9.7, 9.9, 9.5, 7.8]
#비어있는 딕셔너리
temp = { }
ice={"메로나":1000,"폴라포":1200, "빵빠레":1800}
print(ice) #출력:{'메로나': 1000, '폴라포': 1200, '빵빠레': 1800}
#딕셔너리 추가
ice["죠스바"] = 1200
ice["월드콘"] = 1500
print(ice)
#딕셔너리 출력
print("메로나 가격 : ", ice["메로나"])
#딕셔너리 수정
ice["메로나"] = 1300
print("메로나 가격 : ", ice["메로나"])
#딕셔너리 삭제
del ice["메로나"]
print(ice)
#딕셔너리에 없는 키를 사용해서 인덱싱하면 에러가 발생합니다.
