수업자료 - 엑셀
Python
Visual Srudio Code
Python 설치
- Python 다운로드
- Add Python 3.xx to PATH 체크
- Install Now 선택
- Visual Studio Code 다운로드
- 확장(Expansion) 클릭
- kor 검색 후 설치
- Python 검색 후 설치
VS Code 자동저장설정
- 파일 -> 기본설정 -> 설정 -> files:Auto Save -> afterDelay
단축키
- alt + shift + 방향키 : 한줄복사 후 방향키에 따라 붙여넣기
- alt + 방향키 : 해당줄 이동
- ctrl + d : 같은 글자 찾아주기
- ctrl + s : 저장하기
■ 1월 28일 - 1일차
print() : 기본 출력(기초)
숫자는 그자체로 입력
문자열은 ' ' 또는 " " 사이에 입력
ptint('hello')
==========출력==========
hello
print('n','n'), print('n'+'n') 차이점 확인 필요 // +사용시 문자열만 가능
ex) print(1+'2') : 에러
print('hello','python')
print('hello'+'python')
print(1+2)
==========출력==========
hello pyton
hellopyton
3
변수 및 자료형 p30
a = 1의 의미 : a에 1을 넣어라.
type(n) : n의 자료형 타입
# int형 변수 a 선언 및 초기화
a = 1
# float형 변수
f = 1.1
# str형 변수
s = '안녕'
# bool형 변수
bt = True
bf = False
print(type(a))
print(type(f))
print(type(s))
print(type(bt))
==========출력==========
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
자료형 p33
기본 자료형
구분자료형의미변환함수
| int | 정수 | -2,-1,0,1,2,3 | int(n) |
| float | 실수 | -1.1, 3.14, 1.3 | float(n) |
| bool | 논리 | 참(True)과 거짓(False)을 나타내는 형태 | bool(n) |
| str | 문자열 | 일반적인 단어와 단어의 연결 | str(n) |
정수형 int()
논리형 True = 1, False =0을 의미
int(1) #1
int(3.14) #3
int(False) #0
int('100') #100 <- 숫자를 의미
print(int(1))
print(int(3.14))
print(int(False))
print(int('100'))
==========출력==========
1
3
0
100
실수형 float()
논리형 True = 1.0, False =0.0을 의미
float(1) #1.0
float(1.1) #1.1
float(True) #1.0
float('100') #100.0
print(float(1))
print(float(1.1))
print(float(True))
print(float('100'))
==========출력==========
1.0
1.1
1.0
100.0
논리형 bool()
값이 있으면 True로 인식
숫자 0, 빈 문자열, 빈리스트 는 False로 인식
print("----숫자----")
print(bool(0)) #False
print(bool(1)) #True
print(bool(2)) #True
print("----문자----")
print(bool('')) #False
print(bool('0')) #True
print(bool(' ')) #True
print("----리스트----")
print(bool([])) #False
print(bool([0])) #True
----숫자----
False
True
True
----문자----
False
True
True
----리스트----
False
True
문자열 str()
정수, 실수, 논리에 대해서 문자열로 표현
문자열 인덱싱(indexing)
인덱스 0이 첫번째 문자 // 1은 두번째 문자 // 10은 11번째 문자 // 인덱스 n은 n+1번째 문자
s = '안녕하세요 저는 김영원 입니다.'
print(s)
print(s[1])
print(s[5])
print(s[-1])
print(s[-2])
==========출력==========
안녕하세요 저는 김영원 입니다.
녕
.
다
문자열 슬라이싱(slicing) p37
[start:stop:step] star=처음 시작하는 인덱스번호, stop=끝나는 점의 다음 인덱스 번호, step=인덱스 증가차이
s = '0123456789'
print(s[0:2], s[5:10])
print(s[0:10:2]
==========출력==========
01 56789
02468
문자출력 p52
이스케이프 문자 p52
이스케이프 문자의미
| \' | 작은 따옴표(')출력 |
| \" | 큰 따옴표(")출력 |
| \n | 줄바꿈 |
| \r | 캐리지리턴 |
| \t | 탭(tab) |
| \\ | 역슬러시 |
| \a | 벨 |
| \b | 백스페이스 |
% 연산자 p56
형식기호의미자료형
| %d | decimal | 정수(10진수) |
| %o | octal | 정수(8진수) |
| %x | hexadecimal | 정수(16진수) |
| %f | floation point | 실수 |
| %s | string | 문자열 |
% 연산자 기본(정수출력)
a = 1
print('%s' %a) #정수 1을 문자열로 출력 '1'
print('%f' %a) #정수 1을 실수로 출력 1.0...
print('%d' %a) #정수 1을 정수로 출력 1
==========출력==========
1
1.000000
1
% 연산자 기본(실수출력)
a = 1.1
print('%s' %a) #실수 1.1을 문자열로 출력 '1.1'
print('%f' %a) #정수 1.1을 실수로 출력 1.1000
print('%d' %a) #정수 1.1을 정수로 출력 1
==========출력==========
1.1
1.100000
1
% 연산자 기본(문자열출력)
a = '1'
print('%s' %a) #문자열 '1'을 문자열로 출력 '1.1'
==========출력==========
1
```python
print('%f' %a) #문자열 '1'을 실수로 출력 1.1000
print('%d' %a) #문자열 '1'을 정수로 출력 1
##에러 TypeError: must be real number, not str
% 연산자 출력
name = 'kai'
print('내 이름은 %s입니다.' % name)
he = 120.5
print('내 키는 %.1f입니다.' % he)
y,m,d = 2014, 8, 25
print('내 생일은 %d년 0%d월 %d일 입니다.' %(y,m,d))
==========출력==========
내 이름은 kai입니다.
내 키는 120.5입니다.
내 생일은 2014년 08월 25일 입니다.
% 연산자 세부 p57
코드결과의미
| print('%5d' % 1) | 1 | 5자리로 오른쪽 맞춤 |
| print('%5.2f' % 1.12 | 1.12 | 전체 5자리 맞추고 소주점 2자리까지 |
%.2f의 의미 = 소수점 2자리수를 출력
a = 1.234
print('%f' %a)
print('%.2f' %a)
print('%.3f' %a)
==========출력==========
1.234000
1.23
1.234
%10f의 의미 = 공간을 10자리로 선정 오른쪽 맞춤
%-10f의 의미 = 공간을 10자리로 선정 왼쪽 맞춤
b = 131.461
print('%10f' %b)
print('%10.2f' %b)
print('%10.3f' %b)
print('=================')
print('%-8.3f기준%8.3f'%(b,b))
print('%-9.3f기준%9.3f'%(b,b))
print('%-10.3f기준%10.3f'%(b,b))
==========출력==========
131.461000
131.46
131.461
=================
131.461 기준 131.461
131.461 기준 131.461
131.461 기준 131.461
%5d의 의미 = 공간을 10자리로 선정 오른쪽 맞춤
-%5d의 의미 = 공간을 10자리로 선정 오른쪽 맞춤
기본입출력 p52
print함수 p54
print(value, ... sep=' ', end='\n')
sep = 중간에 대한 표시할 내용, end는 마지막에 붙여지는 내용
동일한 데이터 출력 (,) 와 (+)
a = '백두산'
b = '한라산'
print(a,b)
print('백두산','한라산')
print(a+b)
print('백두산'+'한라산')
==========출력==========
백두산 한라산
백두산 한라산
백두산한라산
백두산한라산
=변형=
a = '백두산'
b = '한라산'
print(a,b)
print('백두산','한라산')
print(a+b)
print('백두산'+'한라산'+a+'한라산')
==========출력==========
백두산 한라산
백두산 한라산
백두산한라산
백두산한라산백두산한라산
sep=' ' 확인하기
=변형=
a = '백두산'
b = '한라산'
c = '설악산'
d = '계룡산'
e = '지리산'
print(a,b,c,d,e)
print(a)
==========출력==========
백두산 한라산 설악산 계룡산 지리산
백두산
=변형=
print(1,2,3,4,5)
print(1.1,2.2,3.3,4.4,5.5)
print(-1.1,-2.2,-3.3,-4.4,-5.5)
#print는 함수이다. 정수, 실수, 문자열등의 데이터타입과 옵션(선택지)를 갖는다.
==========출력==========
1 2 3 4 5
1.1 2.2 3.3 4.4 5.5
-1.1 -2.2 -3.3 -4.4 -5.5
sep=' ' (separation : 분리 구분) 시작하기
print(1,2,3,4,5)
print(1,2,3,4,5,sep=' ')
==========출력==========
1 2 3 4 5
1 2 3 4 5
=변형=
print(1,2,3,4,5)
print(1,2,3,4,5,sep='')
1 2 3 4 5
12345
# 문제 1,2,3,4,5 출력하기
# 답 print(1,2,3,4,5,sep=',')
# 문제 1a2a3a4a5 출력하기
# 답 print(1,2,3,4,5,sep='a')
# 문제 print()와 sep 옵션(선택)를 사용하여
# kimyws@naver.com python@naver.com wiken@naver.com 출력하기
# 답1
print('kimyws','naver.com python','naver.com wiken' 'nave.com',sep='@')
print('kimyws','naver.com python',
'naver.com wiken' 'naver.com'
,sep='@')
# 답2
print('kimyws','python','wiken@naver.com',sep='@naver.com ')
# 답3
print('kimyws','python','wiken','',sep='@naver.com ')
end='\n' 확인하기
print(1,2)
print(2,3)
print(3,4) #한줄을 띄어도 상관없음
==========출력==========
1 2
3 4
5 6
==변형==
print(1,2)
print(2,3)
print()
print(3,4)
==========출력==========
1 2
2 3
3 4
#문제1
1
2
3
4
를 하나의 sep을 이용하여 작성하시오
#답
print(1,2,3,4,sep="\n")
end='\n' 시작하기
print('백두산', end='')
print('한라산')
print(end='\n\n')
print('우리나라만세')
==========출력==========
백두산한라산
우리나라만세
==변형==
print(end='\n\n','안녕')
==변형==
print('안녕',end='',sep='')
print('안녕',sep='',end='')
==========출력==========
안녕안녕
문제 예시
#문제 1,2,3,4,5 를 출력하시오
#답
print(1,2,3,4,5,sep=',')
#문제 1-2-3-4-5를 출력하시오
#답
print(1,2,3,4,5,sep='-')
#문제 1반2반3반4반5반 를 출력하시오 end= 옵션은 사용 금지
#답
print(1,2,3,4,'5반',sep='반')
#문제 -1-2-3-4-5- 를 출력하시오
#답
print('-1',2,3,4,5,sep='-',end='-')
print(value, ... sep=' ',end ='\n') // sep='',end=''는 서로 바뀌어도 되지만 값뒤에 넣음
%d 또는 %f의 사용
print('안녕 %d','안녕 %d' % (1,2)) = 에러
==변형==
print('안녕 %d''안녕 %d' % (1,2))
==========출력==========
안녕 1안녕 2
==변형==
a = 3.14
print('안녕 %d''안녕 %d' % (a,3.14))
print('안녕 %d안녕 %d' % (a,3.14))
==========출력==========
안녕 3안녕 3
안녕 3안녕 3
==변형==
a = 3.14
print('안녕 %f안녕 %f' % (a,3.14))
==========출력==========
안녕 3.140000안녕 3.140000
==변형==
a = 3.14
print('안녕 %f안녕 %.2f' % (a,3.1455))
print('안녕',a,end='')
print('안녕',3.14)
==========출력==========
안녕 3.140000안녕 3.15
안녕 3.14안녕 3.14
변수의 선언 및 초기화 위치
a = '백두산'
b = '한라산'
print(a)
print(b)
---또는---
a = '백두산'
print(a)
b = '한라산'
print(b)
==========출력==========
백두산
한라산
b에 변화에 따른 타입의 변화
a = '백두산'
b = '한라산'
print(type(b))
print(a)
b = 1
print(b)
print(type(b))
==========출력==========
<class 'str'>
백두산
1
<class 'int'>
타입의 변화 전체 확인
a = 1
print(a)
print(type(a))
a = 'c'
print(a)
print(type(a))
a = 1.2
print(a)
print(type(a))
==========출력==========
1
<class 'int'>
c
<class 'str'>
1.2
<class 'float'>
문자복사
#문제 print하나로 안녕하세요안녕하세요....안녕하세요 10개 작성
#답1
print('안녕하세요안녕하세요안녕하세요안녕하세요안녕하세요안녕하세요안녕하세요안녕하세요')
#답2
print('안녕하세요','안녕하세요','안녕하세요','안녕하세요',sep='')
#답3
print('','','','','','','','','','','',sep="안녕하세요")
#답4
print('안녕하세요'*10)
#문제 print하나로 안녕하세요1,안녕하세요2,안녕하세요3,...,안녕하세요10
#답
print('안녕하세요1','2','3','4','5','6','7','8','9','10',sep=",안녕하세요")
print라는 변수를 작성했을때 문제점
print = 1
print('안녕')
======사용불가=======
int = 1
print(int)
======int사용불가??=======
# int = 1
print(int(2))
format() 함수(메소드) p59
print('내 이름은 {}'.format('길동'))
print('내 이름은 {0}'.format('길동'))
print()
print('내 이름은 {name}'.format(name='길동'))
print()
print('내 이름은 {} 나이는{}'.format('길동',20))
print('내 이름은 {0} 나이는{1}'.format('길동',20))
print('내 이름은 {1} 나이는{0}'.format('길동',20))
print()
print('내 이름은 {a0} 나이는{a1}'.format(a0='길동',a1=20))
==========출력==========
내 이름은 길동
내 이름은 길동
내 이름은 길동
내 이름은 길동 나이는20
내 이름은 길동 나이는20
내 이름은 20 나이는길동
내 이름은 길동 나이는20
변수를 받는 format()함수
a='길동'
b=20
print('내 이름은 {a0} 나이는{a1}'.format(a0=a,a1=b))
print('내 이름은 {} 나이는{}'.format(a,b))
print('내 이름은 {a} 나이는{b}'.format(a=a,b=b))
f-strings 함수(메소드) 61
a = '홍길동'
b = '행복'
print(f'{a}은 {b} 합니다')
==========출력==========
홍길동은 행복 합니다
==변형==
a = 12
b = 1.2
print(f'{a}은 {b} 합니다')
12은 1.2 합니다
입력 input() 함수 62
name = input('이름을 입력하세요 >>> ')
age = input("나이를 입력하세요 >>> ")
print('format 이름은 {} 나이는 {}'.format(name,age))
print(f"f-string 이름은 {name} 나이는 {age}")
print("이름은 %s 나이는 %s" % (name,age))
==========출력==========
이름을 입력하세요 >>> 2
나이를 입력하세요 >>> 2
format 이름은 2 나이는 2
f-string 이름은 2 나이는 2
이름은 2 나이는 2
==변형==
name = input('이름을 입력하세요 >>> ')
age = int(input("나이를 입력하세요 >>> "))
print("이름은 %s 나이는 %d" % (name,age))
==변형2==
name = input('이름을 입력하세요 >>> ')
age = input("나이를 입력하세요 >>> ")
print("이름은 %s 나이는 %d" % (name,int(age)))
형변환 p64
n = input('정수입력 기본 >> \n')
print(type(n))
print(n)
n = int(input('정수입력 입력시 반환 >> \n'))
print(type(n))
print(n)
n = input('정수입력 int(n)으로 변수변경 >> \n')
n = int(n)
print(type(n))
print(n)
==========출력==========
<class 'str'>
<class 'int'>
<class 'int'>
==변형==
n = input('정수입력 기본 >> \n') 3.14입력
print(type(n))
print(n)
==========출력==========
3.14
<class 'str'>
3.14
연산자 p71
산술연산자 p72
연산자의미사용방법결과
| + | 덧셈 | 7+2 | 9 |
| - | 뺄셈 | 7-2 | 5 |
| * | 곱셈 | 7*2 | 14 |
| ** | 거듭제곱 | 7**2 | 49(7^2) |
| / | 나눗셈 | 7/2 | 3.5 |
| // | 몫 | 7//2 | 3 |
| % | 나머지 | 7%2 | 1 |
출력에 대한 3가지 이해
a = 7
b = 2
print('%d + %d = %d'%(a,b,a+b))
print('{} + {} = {}'.format(a,b,a+b))
print(f'{a} + {b} = {a+b}')
print('%d %s %d = %d'%(a,'%',b,a%b))
==========출력==========
7 + 2 = 9
7 + 2 = 9
7 + 2 = 9
7 % 2 = 1
산술연산자 사용 1개씩 해보기
a = 7
b = 2
print(f'{a} + {b} = {a+b}')
print(f'{a} - {b} = {a-b}')
print(f'{a} * {b} = {a*b}')
print(f'{a} ** {b} = {a**b}')
print(f'{a} / {b} = {a/b}')
print(f'{a} // {b} = {a//b}')
print(f'{a} % {b} = {a%b}')
==========출력==========
7 + 2 = 9
7 - 2 = 5
7 * 2 = 14
7 ** 2 = 49
7 / 2 = 3.5
7 // 2 = 3
7 % 2 = 1
대입연산자 p74
연산자사용방법의미
| = | a=1 | 변수 a에 1을 저장합니다. |
| = | a,b=1,2 | 변수 a에 1, 변수b에 2를 저장합니다. |
a, b = 10,12
print(a,b)
==========출력==========
10 12
문제 a = 10, b = 20, c = 30, d = 40 를 각각 변수로 저장해서 출력하시오
문제
답
a, b, c, d = 10, 20, 30, 40
print(a,b,c,d)
변수를 통합해서 선정했을때 주의점
a1,a2,a3,a4 = 1,2,3 #에러 변수 4개에 값은 3개 선정
print(a1,a2,a3,a4)
a1,a2,a3,a4 = 1,2,3,4,5 #에러 변수 4개에 값은 5개 선정
print(a1,a2,a3,a4)
a1,a2,a3,a4 = 1,2,3,4
print(a1,a2,a3,a4) #문제없음
변수 a,b 선언 이후 저장값 교환
a = 10
b = 20
print(a,b)
a,b = b,a
print(a,b)
==========출력==========
10 20
20 10
복합 대입 연산자 p76 a+=2 -> a=a+2
연산자사용방법의미
| += | a+=2 | 변수 a에 2를 더한 값을 저장합니다. |
| -= | a-=2 | 변수 a에 2를 뺀 값을 저장합니다. |
| *= | a*=2 | 변수 a에 2를 곱한 값을 저장합니다. |
| **= | a**=2 | 변수 a에 2를 거듭제곱한 값을 저장합니다. |
| /= | a/=2 | 변수 a에 2를 나눈 값을 저장합니다. |
| //= | a//=2 | 변수 a에 2를 나눈 몫을 저장합니다. |
| %= | a%=2 | 변수 a에 2를 나눈 나머지를 저장합니다. |
a+=2의 의미 a=a+2
a = 5
a = a+2
b = 5
b += 2
print(a)
print(b)
==========출력==========
7
7
a+=1 사용하는 이유
a = 0
a+=1
print(a)
a+=1
print(a)
a+=1
print(a)
a+=1
print(a)
==========출력==========
1
2
3
4
print()에 =에 대한 개념은 들어가지 않음
a = 0
print(a, a=1) #오류(화면상에서는 오류가 표시되지 않음)
print(a, a=a+1) #오류(화면상에서는 오류가 표시되지 않음)
print(a, a+=1) #오류(화면상에 오류 표시)
a = 0
b = 1
print(a, a+b, a+2)
==========출력==========
0 1 2
p76 기본예제
a = 100000
print(f'{a:,.2f}원')
print(f'{a:20,.2f}원')
print(f'{a:20,d}원')
==========출력==========
100,000.00원
100,000.00원
100,000원
bank = 0
mo = 10000
bank += mo
print('저금통에 용돈 {0:,}원을 넣었습니다.' .format(mo))
print('현재 저금통에 {0:,}원이 있습니다.' .format(bank))
print('=====')
bank += mo
print(f'저금통에 용돈 {mo:,}원을 넣었습니다.')
print(f'현재 저금통에 {bank:,}원이 있습니다.')
print('=====')
sn = 2000
bank -= sn
print('스넥을 구입하기 위해 %d 뺐습니다.' %sn)
print('현재 저금통에 %d원이 있습니다.' %bank)
==========출력==========
저금통에 용돈 10,000원을 넣었습니다.
현재 저금통에 10,000원이 있습니다.
=====
저금통에 용돈 10,000원을 넣었습니다.
현재 저금통에 20,000원이 있습니다.
=====
스넥을 구입하기 위해 2000 뺐습니다.
현재 저금통에 18000원이 있습니다.
format() 함수(메소드) p59
print('내 이름은 {}'.format('길동'))
print('내 이름은 {0}'.format('길동'))
print()
print('내 이름은 {name}'.format(name='길동'))
print()
print('내 이름은 {} 나이는{}'.format('길동',20))
print('내 이름은 {0} 나이는{1}'.format('길동',20))
print('내 이름은 {1} 나이는{0}'.format('길동',20))
print()
print('내 이름은 {a0} 나이는{a1}'.format(a0='길동',a1=20))
==========출력==========
내 이름은 길동
내 이름은 길동
내 이름은 길동
내 이름은 길동 나이는20
내 이름은 길동 나이는20
내 이름은 20 나이는길동
내 이름은 길동 나이는20
변수를 받는 format()함수
a='길동'
b=20
print('내 이름은 {a0} 나이는{a1}'.format(a0=a,a1=b))
print('내 이름은 {} 나이는{}'.format(a,b))
print('내 이름은 {a} 나이는{b}'.format(a=a,b=b))
f-strings 함수(메소드) 61
a = '홍길동'
b = '행복'
print(f'{a}은 {b} 합니다')
==========출력==========
홍길동은 행복 합니다
==변형==
a = 12
b = 1.2
print(f'{a}은 {b} 합니다')
12은 1.2 합니다
입력 input() 함수 62
name = input('이름을 입력하세요 >>> ')
age = input("나이를 입력하세요 >>> ")
print('format 이름은 {} 나이는 {}'.format(name,age))
print(f"f-string 이름은 {name} 나이는 {age}")
print("이름은 %s 나이는 %s" % (name,age))
==========출력==========
이름을 입력하세요 >>> 2
나이를 입력하세요 >>> 2
format 이름은 2 나이는 2
f-string 이름은 2 나이는 2
이름은 2 나이는 2
==변형==
name = input('이름을 입력하세요 >>> ')
age = int(input("나이를 입력하세요 >>> "))
print("이름은 %s 나이는 %d" % (name,age))
==변형2==
name = input('이름을 입력하세요 >>> ')
age = input("나이를 입력하세요 >>> ")
print("이름은 %s 나이는 %d" % (name,int(age)))
형변환 p64
n = input('정수입력 기본 >> \n')
print(type(n))
print(n)
n = int(input('정수입력 입력시 반환 >> \n'))
print(type(n))
print(n)
n = input('정수입력 int(n)으로 변수변경 >> \n')
n = int(n)
print(type(n))
print(n)
==========출력==========
<class 'str'>
<class 'int'>
<class 'int'>
==변형==
n = input('정수입력 기본 >> \n') 3.14입력
print(type(n))
print(n)
==========출력==========
3.14
<class 'str'>
3.14
연산자 p71
산술연산자 p72
연산자의미사용방법결과
| + | 덧셈 | 7+2 | 9 |
| - | 뺄셈 | 7-2 | 5 |
| * | 곱셈 | 7*2 | 14 |
| ** | 거듭제곱 | 7**2 | 49(7^2) |
| / | 나눗셈 | 7/2 | 3.5 |
| // | 몫 | 7//2 | 3 |
| % | 나머지 | 7%2 | 1 |
출력에 대한 3가지 이해
a = 7
b = 2
print('%d + %d = %d'%(a,b,a+b))
print('{} + {} = {}'.format(a,b,a+b))
print(f'{a} + {b} = {a+b}')
print('%d %s %d = %d'%(a,'%',b,a%b))
==========출력==========
7 + 2 = 9
7 + 2 = 9
7 + 2 = 9
7 % 2 = 1
산술연산자 사용 1개씩 해보기
a = 7
b = 2
print(f'{a} + {b} = {a+b}')
print(f'{a} - {b} = {a-b}')
print(f'{a} * {b} = {a*b}')
print(f'{a} ** {b} = {a**b}')
print(f'{a} / {b} = {a/b}')
print(f'{a} // {b} = {a//b}')
print(f'{a} % {b} = {a%b}')
==========출력==========
7 + 2 = 9
7 - 2 = 5
7 * 2 = 14
7 ** 2 = 49
7 / 2 = 3.5
7 // 2 = 3
7 % 2 = 1
대입연산자 p74
연산자사용방법의미
| = | a=1 | 변수 a에 1을 저장합니다. |
| = | a,b=1,2 | 변수 a에 1, 변수b에 2를 저장합니다. |
a, b = 10,12
print(a,b)
==========출력==========
10 12
문제 a = 10, b = 20, c = 30, d = 40 를 각각 변수로 저장해서 출력하시오
문제
답
a, b, c, d = 10, 20, 30, 40
print(a,b,c,d)
변수를 통합해서 선정했을때 주의점
a1,a2,a3,a4 = 1,2,3 #에러 변수 4개에 값은 3개 선정
print(a1,a2,a3,a4)
a1,a2,a3,a4 = 1,2,3,4,5 #에러 변수 4개에 값은 5개 선정
print(a1,a2,a3,a4)
a1,a2,a3,a4 = 1,2,3,4
print(a1,a2,a3,a4) #문제없음
변수 a,b 선언 이후 저장값 교환
a = 10
b = 20
print(a,b)
a,b = b,a
print(a,b)
==========출력==========
10 20
20 10
복합 대입 연산자 p76 a+=2 -> a=a+2
연산자사용방법의미
| += | a+=2 | 변수 a에 2를 더한 값을 저장합니다. |
| -= | a-=2 | 변수 a에 2를 뺀 값을 저장합니다. |
| *= | a*=2 | 변수 a에 2를 곱한 값을 저장합니다. |
| **= | a**=2 | 변수 a에 2를 거듭제곱한 값을 저장합니다. |
| /= | a/=2 | 변수 a에 2를 나눈 값을 저장합니다. |
| //= | a//=2 | 변수 a에 2를 나눈 몫을 저장합니다. |
| %= | a%=2 | 변수 a에 2를 나눈 나머지를 저장합니다. |
a+=2의 의미 a=a+2
a = 5
a = a+2
b = 5
b += 2
print(a)
print(b)
==========출력==========
7
7
a+=1 사용하는 이유
a = 0
a+=1
print(a)
a+=1
print(a)
a+=1
print(a)
a+=1
print(a)
==========출력==========
1
2
3
4
print()에 =에 대한 개념은 들어가지 않음
a = 0
print(a, a=1) #오류(화면상에서는 오류가 표시되지 않음)
print(a, a=a+1) #오류(화면상에서는 오류가 표시되지 않음)
print(a, a+=1) #오류(화면상에 오류 표시)
a = 0
b = 1
print(a, a+b, a+2)
==========출력==========
0 1 2
p76 기본예제
a = 100000
print(f'{a:,.2f}원')
print(f'{a:20,.2f}원')
print(f'{a:20,d}원')
==========출력==========
100,000.00원
100,000.00원
100,000원
bank = 0
mo = 10000
bank += mo
print('저금통에 용돈 {0:,}원을 넣었습니다.' .format(mo))
print('현재 저금통에 {0:,}원이 있습니다.' .format(bank))
print('=====')
bank += mo
print(f'저금통에 용돈 {mo:,}원을 넣었습니다.')
print(f'현재 저금통에 {bank:,}원이 있습니다.')
print('=====')
sn = 2000
bank -= sn
print('스넥을 구입하기 위해 %d 뺐습니다.' %sn)
print('현재 저금통에 %d원이 있습니다.' %bank)
==========출력==========
저금통에 용돈 10,000원을 넣었습니다.
현재 저금통에 10,000원이 있습니다.
=====
저금통에 용돈 10,000원을 넣었습니다.
현재 저금통에 20,000원이 있습니다.
=====
스넥을 구입하기 위해 2000 뺐습니다.
현재 저금통에 18000원이 있습니다.
관계연산자
연산자의미사용방법결과
| > | 왼쪽이 크다 | a>10 | a가 10보다 크면 True, 아니면 False |
| < | 왼쪽이 작다 | a<10 | a가 10보다 작으면 True, 아니면 False |
| >= | 왼쪽이 크거나 같다 | a>=10 | a가 10보다 크거나 같으면 True, 아니면 False |
| <= | 왼쪽이 작거나 같다 | a<=10 | a가 10보다 작거나 같으면 True, 아니면 False |
| == | 같다 | a==10 | a가 10이면 True, 아니면 False |
| != | 같지않다 | a!=10 | a가 10이 아니면 True, 아니면 False |
관계연산자 실행(하나씩 해보기)
a = 15
print(f'{a} > 10 : {a>10}')
print(f'{a} < 10 : {a<10}')
print(f'{a} >= 10 : {a>=10}')
print(f'{a} <= 10 : {a<=10}')
print(f'{a} == 10 : {a==10}')
print(f'{a} != 10 : {a!=10}')
==========출력==========
15 > 10 : True
15 < 10 : False
15 >= 10 : True
15 <= 10 : False
15 == 10 : False
15 != 10 : True
논리연산자 p77, p79
연산자사용방법의미
| and | a and b | a와 b가 모두 참(True)이면 True, 아니면 False |
| or | a or b | a와 b 둘중에 하나라도 참(True)이면 True, 아니면 False |
| not | nat a | a가 참(True)이면 False, a가 거짓(False)이면 True |
a = 10
b = 0
print(f'{a}>0 and {b}>0 : {a>0 and b>0}')
print(f'{a}>0 or {b}>0 : {a>0 or b>0}')
print(f'not {a}>0 : {not a>0}')
print(f'not {b}>0 : {not b>0}')
==========출력==========
10>0 and 0>0 : False
10>0 or 0>0 : True
not 10>0 : False
not 0>0 : True
비트연산자 p80, 82
연산자사용방법의미설명
| & | a & b | a와 b를 비트 AND처리 |
| ㅣ | a ㅣ b | a와 b를 비트 OR처리 |
| ^ | a ^ b | a와 b를 비트 NOR처리 |
| ~ | ~a | a를 비트 NOT처리 |
| << | a<<2 | a를 비트로 변환하여 왼쪽으로 2비트 이동 |
| >> | a>>2 | a를 비트로 변환하여 오른쪽으로 2비트 이동 |
비트연산자 & 확인
0001 = 1
0011 = 3
0001 = 1 & 비트연산자는 둘을 비교하여 1이 모두 있으면 1, 아니면 0
a = 1
b = 3
print(a & b)
==========출력==========
1
비트연산자 | 확인
0001 = 1
0011 = 3
0011 = 3 | 비트연산자는 둘을 비교하여 1이 하나라도 있으면 1, 아니면 0
a = 1
b = 3
print(a | b)
==========출력==========
3
비트연산자 ^ 확인
0001 = 1
0011 = 3
0010 = 2 ^ 둘이 서로 다르면 1, 같으면 0
a = 1
b = 3
print(a ^ b)
==========출력==========
2
비트연산자 &, | 와 비교연산자 and, or
a = 1
b = 3
print((a>b) & (a<b)) #and 비교연산자와 동일
print((a>b) | (a<b)) #or 비교연산자와 동일
==========출력==========
False
True
a = 1
b = 3
c = a>b
d = a<b
print(c&d) #and 비교연산자와 동일
print(c|d) #or 비교연산자와 동일
==========출력==========
False
True
비트연산자 ^의 관계
print(True ^ True) #False
print(True ^ False) #True
print(False ^ True) #True
print(False ^ False) #False
컴퓨터가 이해하는 숫자(보수, -표현 비트,~비트연산자)
1byte = 8bit // int()= 4byte = 32bit
0000 0000 에서 좌측 첫번째 0 은 양수(0), 음수(1)를 구분
0000 0001 = 1
0000 0010 = 21+1 = 2
0000 0001 +
0000 0001 =
0000 00101-1 | 1+(-1) = 0
0000 000 1 = 1
1 1 1 1 1 1 1 1 = -1
0000 0000 = 01의 보수
0000 0001
1111 1110
2의 보수
0000 0010
1111 1101
1의 보수에서 1을 더하면 -1이됨
2의 보수에서 1을 더하면 -2가됨1111 1111 = -1
1111 1110 = -2
1111 1101 = -3
1111 1100 = -4
1111 1101 =-5
1111 1010 =-6
a = -2 # 1110 (-2)
print('~-2 :',~a) # 0001 (1)
a = -1 # 1111 (-1)
print('~-1 :', ~a) # 0000 (0)
a = 0 # 0000 (0)
print('~0 :', ~a) # 1111 (-1)
a = 1 # 0001 (1)
print('~1 :', ~a) # 1110 (-2)
a = 2 # 0010 (2)
print('~2 :', ~a) # 1101 (-3)
==========출력==========
~-2 : 1
~-1 : 0
~0 : -1
~1 : -2
~2 : -3
>>,<<의 이해
0000 0001 = 1
0000 0010 = 1<<1 = 2
0000 0100 = 1<<2 = 4
print(1) # 0000 0001 (1)
print(1<<1) # 0000 0010 (2)
print(1<<2) # 0000 0100 (4)
print(1<<3) # 0000 1000 (8)
print(8>>1) # 0000 0100 (4)
print(8>>2) # 0000 0010 (2)
==========출력==========
1
2
4
8
4
2
===변형===
print(3) # 0000 0011 (3)
print(3<<1) # 0000 0110 (6) (3*2^1)
print(3<<2) # 0000 1100 (12) (3*2^2)
print(3<<3) # 0001 1000 (24) (3*2^3)
print(24>>1) # 0000 1100 (12) (24/2^1)
print(24>>2) # 0000 0110 (6) (24/2^2)
print(24>>4) # 24/2^4(16) = 1.xx
print(24>>5) # 24/2^5(32) = 0.xx
==========출력==========
3
6
12
24
12
6
1
0
컴퓨터가 이해하는 곱하기
1 * 3 = 3
1을 3번 더함
0000 0001 +
0000 0001
0000 0010 +
0000 0001
0000 00112 * 2 = 4
0000 0010(2) +
0000 0010(2)
0000 0100(4)3 * 3 = 9
0000 0011(3)+
0000 0011(3)
0000 0110(6)+
0000 0011(3)
0000 1001(9)
컴퓨터가 이해하는 나누기
9/3 =3
9-3 = 6-3 = 3-3=0 (3으로 뺀것이 3개)
5/2 =2.5
5-2 = 3-2 = 1-2 = ?? 나머지는 1
1-0.2 = 0.8-0.2 = 0.6-0.2 = 0.4-0.2 = 0.2 - 0.2 = 0 (0.2로 나눈것이 5개 0.5)
소수점의 비교의 문제
컴퓨터의 소수점 이해(고정 소수점 / 부동소수점)
고정 소수점(부호 : 1, 정수부 : 15, 소수부 : 16)
부동 소수점(부호 : 1, 지수부(10^-3) : 8, 가수부 : 23)
소수가 출력되는 방식
print('%.17f' % 0.1)
print('%.17f' % 0.2)
print('%.17f' % 0.3)
print('%.17f' % 0.4)
print('%.17f' % 0.5)
print('%.17f' % 0.6)
==========출력==========
0.10000000000000001
0.20000000000000001
0.29999999999999999
0.40000000000000002
0.50000000000000000
0.59999999999999998
소수점에 대한 비교
a = 0.1
b = 0.2
c = 0.3
print('%.30f' %(0.1+0.2))
print(a+b)
print(0.3==(0.1+0.2))
print(0.3==(a+b))
print(0.2==(0.1+0.1))
==========출력==========
0.300000000000000044408920985006
0.30000000000000004
False
False
True
===변환===
import math
print(math.isclose(a+b,c))
==========출력==========
True
소수점 비교 해결방안
a = 0.1111
b = 0.2222
c = 0.3333
print(c==(a+b))
print(int(c*10000)==int((a+b)*10000)) #int 타입으로 소수점 자리수 만큼 곱해준다
ai = int(a*10**4)
bi = int(b*10**4)
ci = int(c*10**4)
print(ci==(ai+bi))
==========출력==========
False
True
True
시퀸스 연산자 p81
print([1,2,3]+[4,5,6])
print('hello'+' '+'python')
==========출력==========
[1, 2, 3, 4, 5, 6]
hello python
print([1,2,3]*2)
print('hello'*5)
==========출력==========
[1, 2, 3, 1, 2, 3]
hellohellohellohellohello
시퀸스 연산자 활용
t = '#'
s = ' '
print(s*4+t*1)
print(s*3+t*3)
print(s*2+t*5)
print(s*1+t*7)
print(s*0+t*9)
==========출력==========
#
###
#####
#######
#########
멤버십 연산자 (in 포함시 True, not in 미포함시 true)
print(5 in [1,2,3,4,5]) #T
print(5 in [1,2,3]) #F
print('p' in 'hello') #F
print('l' in 'hello') #T
==========출력==========
True
False
False
True
print(5 not in [1,2,3,4,5]) #F
print(5 not in [1,2,3]) #T
print('p' not in 'hello') #T
print('l' not in 'hello') #F
==========출력==========
False
True
True
False
조건 연산자(삼항 연산자) p81
참 if 조건식 else 거짓
print('맞다' if 10==1 else '틀리다') #틀리다
print('맞다' if 10>1 else '틀리다') #맞다
print('맞다' if 10>=1 else '틀리다') #맞다
==========출력==========
틀리다
맞다
맞다
조건연산자 이용 p84
a = 10
b = 20
re = (a-b)if (a>=b) else(b-a)
print(f'{a}와 {b}의 차이는 {re} 입니다.')
==========출력==========
10와 20의 차이는 10 입니다.
조건연산자를 논리방법으로서 이용방법
a = 1 if 10>1 else 0
print(a) # 1
print(bool(a)) #True
a = True if 10>1 else False
print(a) #True
==========출력==========
1
True
True
조건연산자를 논리방법으로서 이용방법
a = 1 if 10==1 else 0
print(a) # 0
print(bool(a)) #False
a = 1 if 10==1 else 2
print(a) # 1
print(bool(a)) #True
==========출력==========
0
False
2
True
연산자 응용예제 p85
예제1
임의의 두자리 정수(10~99)를 입력받아서 십의 자리와 일의 자리로 분리하여 출력하는 프로그램을 구현하세요
실행 예시
10 ~ 99 사이의 정수를 입력하세요 >>> 45
십의 자리 : 4
일의 자리 : 5
a = input('10 ~ 99 사이의 정수를 입력하세요 >>> ')
a = int(a)
print(f'십의 자리: {a//10}')
print(f'일의 자리: {a%10}')
input을 문자열로 받았을때
a = input('10 ~ 99 사이의 정수를 입력하세요 >>> ')
print(f'십의 자리: {a[0]}')
print(f'일의 자리: {a[1]}')
예제2
1분은 60초이고, 1시간은 60분 입니다. 따라서 1시간은 3600초 입니다.
임의의 초를 입력 받아 해당 초를 시, 분, 초로 변환하여 출력하는 프로그램을 구현하세요.
실행 예시
초를 입력하세요 >>> 3690
변환 결과는 1시간 1분 30초입니다.
a = int(input('초를 입력하세요 >>> '))
print(f'변환 결과는: {a//3600}시간 {(a%3600)//60}분 {a%60}초')
예제3
네자리 정수로 구성된 사원번호를 기준으로 근무시간을 결정하고자 합니다.
사원번호의 끝자리 숫자가 5이상이면 '오전', 아니면 '오후'를 출력하는 프로그램을 구하세요.
실행 예시
4자리 사원번호를 입력하세요 >>> 1255
근무 시간은 오전입니다.
a = int(input('4자리 사원번호를 입력하세요 >>> '))
b = '오전' if (a%10)>=5 else '오후'
print(f'근무 시간은 {b} 입니다.')
예제4
1박스에 라면이 20개씩 들어갑니다. 라면이 21개 있다면 2박스가 있어야 모두 담을 수 있습니다.
라면의 개수를 입력받아 라면을 담기 위해서 필요한 박스의 개수를 구하여 출력하는 프로그램을 구하세요
실행 예시
한 박스에 20개의 라면을 담을 수 있습니다.
라면의 개수를 입력하시면 필요한 박스 수를 알려드립니다.
라면의 개수를 입력하세요 >>> 50
50개 라면을 담으려면 3박스가 필요합니다.
print("""한 박스에 20개의 라면을 담을 수 있습니다.
라면의 개수를 입력하시면 필요한 박스 수를 알려드립니다.""")
a = int(input('라면의 개수를 입력하세요 >>> '))
b = (a//20)+1 if a%20 >0 else (a//20)
print(f'{a}개 라면을 담으려면 {b}박스가 필요합니다.')
예제5
국어, 영어, 수학 점수를 각각 입력받아 평균을 구하고,
평균이 80점 이상이면 '합격', 아니면 '불합격'을 출력하는 프로그램을 구현
실행 예시
국어점수를 입력하세요 >>> 85
영어점수를 입력하세요 >>> 83
수학점수를 입력하세요 >>> 81
평균은 83.0점이고, 결과는 합격입니다.
a = int(input('국어점수를 입력하세요 >>> '))
b = int(input('영어점수를 입력하세요 >>> '))
c = int(input('수학점수를 입력하세요 >>> '))
avg1 = (a+b+c)/3
re = '합격' if avg1>=80 else '불합격'
print(f'평균은 {avg1:.1f}점이고, 결과는 {re}입니다.')
조건문
if문
if 조건식 :
(Tap) 조건식의 결과가 True일 때 실행문
if문의 동작 순서
a = 1
if a>0:
print(f'{a} : 양수')
print(a>0)
if True:
print(f'{a} : 양수')
==========출력==========
1 : 양수
True
1 : 양수
if문의 들여쓰기
a = 1
if a>0:
print(f'{a} : 양수') #들여쓰기 space 1번
if a>0:
print(f'{a} : 양수') #들여쓰기 space 2번
if a>0:
print(f'{a} : 양수') #들여쓰기 space 4번 tap1회와 동일
==========출력==========
1 : 양수
1 : 양수
1 : 양수
if문의 활용
a = 1
if a>0:
print(f'{a} : 양수')
a = -1
if a>0:
print(f'{a} : 양수')
print(a)
==========출력==========
1 : 양수
-1
실행문이 하나일때 사용해도 되는 것 (사용하지 않는 것을 추천)
a = 3
if a>0: print(f'{a} : 양수')
if문에서 두개 이상을 실행
a = 3
if a>0:
print(f'{a} : 양수')
print(f'{a} : 0보다 큰수')
==========출력==========
3 : 양수
3 : 0보다 큰수
if-else문 p94
if 조건식:
(Tap) 조건식의 결과가 True일때 실행
else:
(Tap) 조건식의 결과가 False일때 실행
a = 3
if a>=0:
print(f'{a} : 양수')
else:
print(f'{a} : 음수')
==========출력==========
3 : 양수
==변화==
a = 3
a = -1
if a>=0:
print(f'{a} : 양수')
else:
print(f'{a} : 음수')
==========출력==========
-1 : 음수
문제
if문 문제 1.
a = 11
a가 10보다 크거나 같은수이면 (11 : 10이상의 수 입니다.)를 출력
a = 11
if a>=10:
print(f'{a} : 10이상의 수 입니다.')
==========출력==========
11 : 10이상의 수 입니다.
if-else문 문제 1.
a = 6
a가 2의 배수이면 (6 : 2의 배수 입니다.)를 출력
아니면 (6 : 2의 배수가 아닙니다.)를 출력
a = 6
if a%2==0:
print(f'{a} : 2의 배수 입니다.')
else:
print(f'{a} : 2의 배수가 아닙니다.')
==========출력==========
6 : 2의 배수 입니다.
if-else문 문제 2.
a = 10
a가 5의 배수이면 (10 : 5의 배수 입니다.)를 출력
아니면 (10 : 5의 배수가 아닙니다.)를 출력
a = 10
if a%5==0:
print(f'{a} : 5의 배수 입니다.')
else:
print(f'{a} : 5의 배수가 아닙니다.')
==========출력==========
10 : 5의 배수 입니다.
if-else문 문제 3.
a=10, b =4
a와 b를 비교하여 a가 크면 (10 = 4보다 크다)
b가 크면 (4 = 10보다 크다)를 출력
a,b = 10,4
if a>b:
print(f'{a} = {b}보다 크다')
else:
print(f'{b} = {a}보다 크다')
==========출력==========
10 = 4보다 크다
==변형==
a,b = 10,10
if a>b:
print(f'{a} = {b}보다 크다(if)')
else:
print(f'{b} = {a}보다 크다(else)')
==========출력==========
10 = 10보다 크다(else)
==변형==
a,b = 10,10
if a>=b:
print(f'{a} = {b}보다 크거나 같다')
else:
print(f'{b} = {a}보다 크다')
==========출력==========
10 = 10보다 크거나 같다
기본예제 p95
나이를 입력받아 20살 이상이면 성인 20살 미민이면 미성년자를 출력
age = int(input('몇살 입니까 >>> ')) #int로 받아야 식이 정상적으로 시행
if age>=20: #아니면 에러
print("성인")
else:
print("미성년자")
if-elif
if 조건문:
(Tap) 조건이 참일경우 실행
elif 조건문:
(Tap) if조건이 거짓이고 elif조건이 참일경우 실행
else:
(Tap) if조건이 거짓이고 elif조건도 거짓일 경우 실행
a = 120 #100이상은 상, 99-50은 중, 50미만은 하
if a>=100:
print(f'{a} : 상')
elif a>=50:
print(f'{a} : 중')
else:
print(f'{a} : 하')
==========출력==========
120 : 상
기본예제 P98
나이를 입력받아 7이하 미취학 13이하 초등학생 16이하 중학생
19이하 고등학생 그외 성인
age = int(input('나이를 입력하세요 >>> '))
if age<=7:
print('미취학')
elif age<=13:
print('초등학생')
elif age<=16:
print('중학생')
elif age<=19:
print('고등학생')
else:
print('성인')
==========출력==========
나이를 입력하세요 >>> 5
미취학
나이를 입력하세요 >>> 12
초등학생
나이를 입력하세요 >>> 22
성인
if-elif문 예제2
학점이 4.0이상 A, 학점이 3.0이상 B, 2.0이상 C, 1.0이상 D 이하 F
a = 3.2
if a>=4.0:
print(f'{a} : A학점')
elif a>=3.0:
print(f'{a} : B학점')
elif a>=2.0:
print(f'{a} : C학점')
elif a>=1.0:
print(f'{a} : D학점')
else:
print(f'{a} : F학점')
==========출력==========
3.2 : B학점
문제
if-elif 문제1
m = 10 #10월을 뜻함
m = 3~5이면 m월은 봄입니다. 6~8이면 m월은 여름입니다
9~11이면 m월은 가을입니다. 12~2이면 m월은 겨울입니다.
12초과는 잘못 입력했습니다. 를 출력하는 if-elif문 만들기
m = int(input('월을 입력하세요 >>> '))
if m<=2:
print(f'{m}월은 겨울입니다.')
elif m<=5:
print(f'{m}월은 봄입니다.')
elif m<=8:
print(f'{m}월은 여름입니다.')
elif m<=11:
print(f'{m}월은 가을입니다.')
elif m<=12:
print(f'{m}월은 겨울입니다.')
else:
print('잘못 입력했습니다.')
==========출력==========
월을 입력하세요 >>> 10
10월은 가을입니다.
조건문 안에 or 작성
m = int(input('월을 입력하세요 >>> '))
if ((m<=2) or (m==12)): # or대신 | 넣어도 됨
print(f'{m}월은 겨울입니다.')
elif m<=5:
print(f'{m}월은 봄입니다.')
elif m<=8:
print(f'{m}월은 여름입니다.')
elif m<=11:
print(f'{m}월은 가을입니다.')
else:
print('잘못 입력했습니다.')
==========출력==========
월을 입력하세요 >>> 10
10월은 가을입니다.
오전 오후로 입력해주기
a = int(input("입력 > "))
b = "오류"
if 1<=a<=12:
b = f"오전 {a}시"
elif 13<=a<=24:
b = f"오후 {a-12}시"
print(b)
응용예제 p99
예제1
점수를 입력받아서 학점을 출력하는 프로그램을 구현하세요
학점은 점수가 100~90점이면 'A', 89~80점이면 'B',
79~70점이면 'C', 69~60점이면 'D', 59~0점이면 'F'입니다.
실행 예시
점수를 입력하세요 >> 95
점수는 95점이고, 학점은 A학점입니다.
HINT : 경우의 수가 3가지 이상이면 if-elif문을 활용하세요
a = int(input('점수를 입력하세요 >>> '))
# print(f'점수는 {a}점이고, 학점은 ', end='')로 빼서 사용 가능
if a>=90:
print(f'점수는 {a}점이고, 학점은 A입니다.')
elif a>=80:
print(f'점수는 {a}점이고, 학점은 B입니다.')
elif a>=70:
print(f'점수는 {a}점이고, 학점은 C입니다.')
elif a>=60:
print(f'점수는 {a}점이고, 학점은 D입니다.')
else:
print(f'점수는 {a}점이고, 학점은 F입니다.')
==========출력==========
점수를 입력하세요 >>> 95
점수는 95점이고, 학점은 A입니다.
100초과 0미만의 값을 갖을때 잘못입력되었음을 알리는 방법
a = int(input('점수를 입력하세요 >>> '))
c = ['A','B','C','D','F']
if (a>100) or (a<0):
print('100을 초과하거나 0미만의 점수는 없습니다.')
elif a>=90:
print(f'점수는 {a}점이고, 학점은 {c[0]}입니다.')
elif a>=80:
print(f'점수는 {a}점이고, 학점은 {c[1]}입니다.')
elif a>=70:
print(f'점수는 {a}점이고, 학점은 {c[2]}입니다.')
elif a>=60:
print(f'점수는 {a}점이고, 학점은 {c[3]}입니다.')
else:
print(f'점수는 {a}점이고, 학점은 {c[4]}입니다.')
==========출력==========
점수를 입력하세요 >>> 59
점수는 59점이고, 학점은 F입니다.
간략화
a = int(input('점수를 입력하세요 >>> '))
b = ""
if (a>100) or (a<0):
print('100을 초과하거나 0미만의 점수는 없습니다.')
elif a>=90:
b = "A"
elif a>=80:
b = "B"
elif a>=70:
b = "C"
elif a>=60:
b = "D"
else:
b = "F"
print(f'점수는 {a}점이고, 학점은 {b}입니다.')
점수가 넘을 경우 마지막 나오지 않게 하는 방법
a = int(input('점수를 입력하세요 >>> '))
b = ""
if (a>100) or (a<0):
print('100을 초과하거나 0미만의 점수는 없습니다.')
elif a>=90:
b = "A"
elif a>=80:
b = "B"
elif a>=70:
b = "C"
elif a>=60:
b = "D"
else:
b = "F"
if (a<=100) and (a>=0):
print(f'점수는 {a}점이고, 학점은 {b}입니다.')
예제2
임의의 정수를 입력받은 뒤 해당 값이 3의 배수인지 아닌지
판별하는 프로그램을 구현하세요.
실행 예시
정수를 입력하세요 >> 14
14는 3의 배수가 아닙니다.
정수를 입력하세요 >> 15
15는 3의 배수 입니다.
HINT : 3의 배수란 3으로 나눈 나머지가 0인 수를 의미
a = int(input('정수를 입력하세요 >>> '))
if a%3==0:
print(f'{a}는 3의 배수입니다.')
else:
print(f'{a}는 3의 배수가 아닙니다.')
==========출력==========
정수를 입력하세요 >>> 14
14는 3의 배수가 아닙니다.
정수를 입력하세요 >>> 15
15는 3의 배수입니다.
예제3
임의의 정수 3개를 입력받아 그 중에서 가장 큰 수를 출력하는 프로그램을 구현하세요
정수1 입력 >> 3
정수2 입력 >> 1
정수3 입력 >> 2
가장 큰 수는 3입니다.
HINT : 관계, 논리 연산자를 이용하면 좋아요
a1 = int(input('정수1 입력 >>> '))
a2 = int(input('정수2 입력 >>> '))
a3 = int(input('정수3 입력 >>> '))
if (a1>=a2) and (a1>=a3):
print(f'가장 큰 수는 {a1}입니다.')
elif (a2>=a1) and (a2>=a3):
print(f'가장 큰 수는 {a2}입니다.')
else:
print(f'가장 큰 수는 {a3}입니다.')
==========출력==========
정수1 입력 >>> 1
정수2 입력 >>> 2
정수3 입력 >>> 3
가장 큰 수는 3입니다.
다른방법
a1 = int(input('정수1 입력 >>> '))
a2 = int(input('정수2 입력 >>> '))
a3 = int(input('정수3 입력 >>> '))
max1 = a1
if max1<a2:
max1 = a2
if max1<a3:
max1 = a3
print(f'가장 큰 수는 {max1}입니다.')
■ 1월 29일 - 2일차
반복문 while p102
while 조건식:
(Tap) 반복실행문
while True:
print('hello python')
==========출력==========
hello python
hello python
hello python
hello python
hello python
hello python
hello python
무한대
반복문 원하는 만큼 반복
n = 1
while n<=10:
print(n)
n+=1
==========출력==========
1
2
3
4
5
6
7
8
9
10
기본예제 p105
1부터 10사이의 모든 정수를 역순으로 출력
n = 10
while n>=1:
print(f'{n}')
n-=1
==========출력==========
10
9
8
7
6
5
4
3
2
1
같이 해보기
while 반복출력
hello python을 3회 출력하시오 (while 함수사용)
n = 0
while n<3:
print(f'hello python')
n+=1
==========출력==========
hello python
hello python
hello python
== 변형 == #리스트에 들어 있는 인덱스는 0부터 시작하기 때문
n = 0
a = ['python', 'java', 'c']
while n<3:
print(f'hello {a[n]}')
n+=1
==========출력==========
hello python
hello java
hello c
==변형== # n에 1을 넣고 싶으면
n = 1
a = ['python', 'java', 'c']
while n<=3:
print(f'hello {a[n-1]}')
n+=1
n = 0 (리스트 인덱스 값이 0)
while n<3 (리스트 개수 보다 작다)(0,1,2) 3회 반복
기본예제 p107
리스트에 추가하기
0을 입력시 종료
l = []
a = int(input('정수 입력(0은종료) >> '))
while a != 0:
l.append(a)
a = int(input('정수 입력(0은종료) >> '))
print(l)
==========출력==========
정수 입력(0은종료) >> 1
정수 입력(0은종료) >> 2
정수 입력(0은종료) >> 3
정수 입력(0은종료) >> 5
정수 입력(0은종료) >> 0
[1, 2, 3, 5]
반복 입력값을 안에서
l = []
a = 1
while a != 0:
a = int(input('정수 입력(0은종료) >> '))
l.append(a)
l.pop()
print(l)
while문의 중첩 p109
d = 1
while d<=5:
h = 1
while h <=3:
print(f'{d}일차 {h}교시')
h+=1
d+=1
==========출력==========
1일차 1교시
1일차 2교시
1일차 3교시
2일차 1교시
2일차 2교시
2일차 3교시
3일차 1교시
3일차 2교시
3일차 3교시
4일차 1교시
4일차 2교시
4일차 3교시
5일차 1교시
5일차 2교시
5일차 3교시
d = 1
while d<=5:
h = 1
while h <=3:
print(f'{d}일차 {h}교시',end=' |')
h+=1
print()
d+=1
==========출력==========
1일차 1교시 |1일차 2교시 |1일차 3교시 |
2일차 1교시 |2일차 2교시 |2일차 3교시 |
3일차 1교시 |3일차 2교시 |3일차 3교시 |
4일차 1교시 |4일차 2교시 |4일차 3교시 |
5일차 1교시 |5일차 2교시 |5일차 3교시 |
기본예제 p110
구구단 2단부터 9단까지 출력
d = 2
while d<=9:
n = 1
while n <=9:
print(f'{d} x {n} = {d*n}')
n+=1
print()
d+=1
==========출력==========
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
3 x 1 = 3
...
9 x 9 = 81
응용예제 p111
예제1
정수를 입력 받아서 그 횟수 만큼 Hello를 출력하세요
0 이하의 값이 입력 되면 잘못된 입력 오류 메시지를 출력
n = int(input('정수를 입력하세요 >>> '))
if n<=0:
print('잘못된 입력입니다.')
else:
i = 1
while(i<=n):
print(f'{i}번째 Hello')
i += 1
==========출력==========
정수를 입력하세요 >>> 5
1번째 Hello
2번째 Hello
3번째 Hello
4번째 Hello
5번째 Hello
정수를 입력하세요 >>> 0
잘못된 입력입니다.
정수를 입력하세요 >>> -1
잘못된 입력입니다.
예제2
1부터 100 사이의 모든 정수 중에서 7의 배수만 출력하는
프로그램을 구현하세요
i = 1
while(i <= 100):
if (i%7 == 0):
print(f'{i}')
i += 1
#또는
i = 0
while(i <= 100):
i += 1
if (i%7 == 0):
print(f'{i}')
==========출력==========
7
14
21
28
35
42
49
56
63
70
77
84
91
98
예제3
커피 1잔을 300원에 판매하는 커피자판기
돈을 넣으면 자판기에서 뽑을 수 있는 커피가 몇잔에 잔돈은 얼마 출력
잔돈이 300원 이상이면 계속실행
실행 예시
자판기에 얼마를 넣을까요 >>> 1400
커피 1잔, 잔돈 1100원
커피 2잔, 잔돈 800원
커피 3잔, 잔돈 500원
커피 4잔, 잔돈 200원
mn = int(input('자판기에 얼마를 넣을까요 >>> '))
a = 1
while(mn>=300):
mn -= 300
print(f'커피 {a}잔, 잔돈 {mn}원')
a += 1
#한글로 변수명 지정
잔돈 = int(input('자판기에 얼마를 넣을까요 >>> '))
잔의수 = 1
while(잔돈>=300):
잔돈 -= 300
print(f'커피 {잔의수}잔, 잔돈 {잔돈}원')
잔의수 += 1
==========출력==========
자판기에 얼마를 넣을까요 >>> 1400
커피 1잔, 잔돈 1400원
커피 2잔, 잔돈 1100원
커피 3잔, 잔돈 800원
커피 4잔, 잔돈 500원
예제4
0~9 정수를 입력받고
정수가 5개 될때까지 입력
중복된 값은 무시
세트는 중복된 값을 저장할 수 없음
len()함수는 개수를 확인하는 함수임
b = set()
while(len(b)<5):
c = int(input('0 ~ 9 사이 정수를 입력하세요 >>> '))
b.add(c)
print(b)
==========출력==========
0 ~ 9 사이 정수를 입력하세요 >>> 0
0 ~ 9 사이 정수를 입력하세요 >>> 0
0 ~ 9 사이 정수를 입력하세요 >>> 0
0 ~ 9 사이 정수를 입력하세요 >>> 1
0 ~ 9 사이 정수를 입력하세요 >>> 2
0 ~ 9 사이 정수를 입력하세요 >>> 5
0 ~ 9 사이 정수를 입력하세요 >>> 3
{0, 1, 2, 3, 5}
예제5
1~100사이의 정수를 10개씩 출력
i = 1
while(i<=100):
n = 1
while(n<=10):
print(f'{i}',end='\t')
n+=1
i+=1
print()
==========출력==========
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
예제6
전체 구구단을 다음과 같은 모습으로 출력하는 프로그램을 구현
예시
2x1= 2 3x1= 3 ...
2x2= 4 3x2= 6
n = 1
while n<=9:
dan = 2
while dan <=9:
print(f'{n}x{dan}={n*dan}',end='\t')
# print('%dx%d=%-2d' %(dan,n,dan*n),end=' ')
dan+=1
print()
n+=1
==========출력==========
2x1=2 3x1=3 4x1=4 5x1=5 6x1=6 7x1=7 8x1=8 9x1=9
2x2=4 3x2=6 4x2=8 5x2=10 6x2=12 7x2=14 8x2=16 9x2=18
2x3=6 3x3=9 4x3=12 5x3=15 6x3=18 7x3=21 8x3=24 9x3=27
2x4=8 3x4=12 4x4=16 5x4=20 6x4=24 7x4=28 8x4=32 9x4=36
2x5=10 3x5=15 4x5=20 5x5=25 6x5=30 7x5=35 8x5=40 9x5=45
2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 7x6=42 8x6=48 9x6=54
2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 8x7=56 9x7=63
2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 9x8=72
2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
반복문 for p116
for n in [1,2,3]:
(Tap) 반복문 실행
형태 시퀀스(연관된), 비시퀀스(연관없는)
시퀀스 자료형비시퀀스 자료형
| 문자열 : 'hellow' | 세트 : {1,2,3,4} |
| 리스트 : [1,2,3] | 딕셔너리 : {'1':100,'2':200,'3':300} |
| 튜플 : (1,2,3) |
시퀀스와 for문
for a in 'hello':
print(a)
==========출력==========
h
e
l
l
o
기본예제 p120
pwd = input('비밀번호를 입력하세요 >>> ')
ch_c = 0
num_c = 0
for ch in pwd:
if ch.isalpha():
ch_c += 1
elif ch.isnumeric():
num_c += 1
if ch_c > 0 and num_c >0:
print('가능')
else:
print('불가능')
==========출력==========
비밀번호를 입력하세요 >>> abcde
불가능
비밀번호를 입력하세요 >>> 12356
불가능
비밀번호를 입력하세요 >>> 12a
가능
while문 작성
pwd = input('비밀번호를 입력하세요 >>> ')
i,a,b = 0,0,0
while(i<len(pwd)):
if pwd[i].isalpha():
a = 1
if pwd[i].isnumeric():
b = 1
i +=1
if a==1 and b==1:
print('가능')
else:
print('불가능')
for문과 리스트
for a in ['가위','바위','보']:
print(a)
==========출력==========
가위
바위
보
리스트 내포
리스트 = [표현식 for 변수 in 반복가능객체]
l = [n*2 for n in [2,1,3]]
print(l)
==========출력==========
[4, 2, 6]
조건을 만족하는 데이터만 추출
리스트 = [표현식 for 변수 in 반복가능객체 if 조건식]
l = [n*2 for n in [1,2,3,4,5]]
print(l)
==========출력==========
[2, 4, 6, 8, 10]
l = [n*2 for n in [1,2,3,4,5] if n%2==0]
print(l)
==========출력==========
[4, 8]
○ 글자를 입력해서 추가해주는 방법
a = "hello"
b = input("단어 >> ")
c = int(input("인덱스 입력 > "))
a = a[:c]+b+a[c+1:]
print(a)
===============
단어 >> z
인덱스 입력 > 0
zello
○ 두 리스트에 모두 들어있는 것만 출력하기
a = [1, 3, 5, 7, 9, 11]
b = [2, 3, 5, 7, 10, 13]
for n in a:
if n in b:
print(n)
===================================
3
5
7
○ 문자열 중 모음으로 시작하는 단어만 출력
words = ["apple", "dog", "orange", "elephant", "car", "umbrella", "banana"]
for w in words:
if w[0] in ['a', 'e', 'i', 'o', 'u']:
print(w)
========================================
apple
orange
elephant
umbrella
○ 1부터 50까지 수중 3이 포함된 수 리스트 저장
result = []
for n in range(1, 51):
if '3' in str(n):
result.append(n)
print(result)
================================
[3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43]
○ 앞으로 읽어도 뒤로 읽어도 동일한 문서만 출력
words = ["level", "python", "radar", "moon", "noon", "madam", "wow", "cat"]
for w in words:
if w == w[::-1]:
print(w)
==================
level
radar
noon
madam
wow
○ 두 리스트에서 위치는 달라도 같은 숫자만 리스트에 추가 / 동일한것은 1번만
a = [1, 2, 3, 4, 5, 6]
b = [6, 3, 9, 2, 0, 1]
common = []
for x in a:
if x in b and x not in common:
common.append(x)
print(common)
==============================
[1, 2, 3, 6]
○ 리스트에서 가장 많이 등장한 숫자 빈도 출력해보기
nums = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
max_count = 0
max_num = None
for n in nums:
count = 0
for x in nums:
if x == n:
count += 1
if count > max_count:
max_count = count
max_num = n
print("가장 많이 나온 숫자:", max_num)
=======================
가장 많이 나온 숫자: 4
리스트.count(x)
nums = [1, 2, 2, 3, 3, 3]
print(nums.count(2)) # 출력: 2
print(nums.count(3)) # 출력: 3
set() 과 count 혼합 간단 비교
nums = [1, 2, 2, 3, 3, 3]
for n in set(nums):
print(n, ":", nums.count(n))
set() 과 count 가장 많은 수 출력
a = [1, 1, 3, 3 ,3, 1, 2, 3, 3, 2, 1]
s = set(a)
mc = 0
mn = None
for i in s:
if mc < a.count(i):
mc = a.count(i)
mn = i
print(f"많은 수 {mn} : {mc}개")
■ 1월 30일 - 3일차
리스트 내포
리스트 = [표현식 for 변수 in 반복가능객체]
l = [n*2 for n in [2,1,3]]
print(l)
==========출력==========
[4, 2, 6]
조건을 만족하는 데이터만 추출
리스트 = [표현식 for 변수 in 반복가능객체 if 조건식]
l = [n*2 for n in [1,2,3,4,5]]
print(l)
==========출력==========
[2, 4, 6, 8, 10]
l = [n*2 for n in [1,2,3,4,5] if n%2==0]
print(l)
==========출력==========
[4, 8]
컬렉션
컬렉션생성함수특징예시
| 리스트 | list() | 추가, 수정, 삭제가 언제나 가능 | a=[1,2,3] |
| 튜플 | tuple() | 생성되고 나면 변경 불가능 | a=(1,2,3) |
| 세트 | set() | 중복된 값의 저장 불가능 | a={1,2,3} |
| 딕셔너리 | dict() | 키+값으로 관리 | a={'age':25} |
리스트
리스트의 생성
li = [값1,값2,값3]
li = list()
li = []
li1 = [1,2,3] # li = [1,2,3,] ,가 뒤에 들어가도 되지만 사용하지 않도록
li2 = [1,2,0.1,'안녕','hellow']
li3 = list()
li4 = []
print(li1)
print(li2)
print(li3)
print(li4)
==========출력==========
[1, 2, 3]
[1, 2, 0.1, '안녕', 'hellow']
[]
[]
리스트 list() 슬라이싱 / len() {length:길이}
len(li) = 리스트의 개수를 나타냄
li1 = [1,2,3,4,5,6]
print(li1)
print(li1[0])
print(li1[0:3])
li2 = li1[0:3]
print(li2)
print(f'li1 = {len(li1)} li2= {len(li2)}')
==========출력==========
[1, 2, 3, 4, 5, 6]
1
[1, 2, 3]
[1, 2, 3]
li1 = 6 li2= 3
리스트 내용 수정
li1 = [1,2,3,4]
li1[2] = 6
print(li1)
==========출력==========
[1, 2, 6, 4]
2단 리스트
li1 = [1,2,3,[4,5]]
print(li1)
print(li1[3])
print('='*30)
li1[3] = [5,6,2]
print(li1)
print('='*30)
li1[3] = '5'
print(li1)
==========출력==========
[1, 2, 3, [4, 5]]
[4, 5]
==============================
[1, 2, 3, [5, 6, 2]]
==============================
[1, 2, 3, '5']
리스트 활용
li1 = [[1,2,[31,32,33]],3,4,[5,6]]
print(li1)
print(li1[0][2])
print(li1[0][2][2])
#리스트 활용
li = [['홍길동',26],['백두산',31],['한라산',22]]
print(li)
print(f'이름 : {li[0][0]}, 나이 : {li[0][1]}')
print(f'이름 : {li[1][0]}, 나이 : {li[1][1]}')
print(f'이름 : {li[2][0]}, 나이 : {li[2][1]}')
==========출력==========
[[1, 2, [31, 32, 33]], 3, 4, [5, 6]]
[31, 32, 33]
33
[['홍길동', 26], ['백두산', 31], ['한라산', 22]]
이름 : 홍길동, 나이 : 26
이름 : 백두산, 나이 : 31
이름 : 한라산, 나이 : 22
리스트 메소드 p175
리스트 추가 append()
리스트 이름.append(내용)
li = [1]
li.append(2)
print(li)
li.append(input('추가 >> '))
print(li)
a=int(input('추가 >> '))
li.append(a)
print(li)
print('='*30)
li[2] = 3
print(li)
==========출력==========
[1, 2]
추가 >> 3
[1, 2, '3']
추가 >> 4
[1, 2, '3', 4]
==============================
[1, 2, 3, 4]
리스트 연장or확장 extend()
리스트 이름.extend([내용,내용])
li = [1,2,3,4]
li.append([5,6])
print(li)
# li.append(7,8) #에러 발생
# print(li)
li.extend([7,8])
print(li)
==========출력==========
[1, 2, 3, 4, [5, 6]]
[1, 2, 3, 4, [5, 6], 7, 8]
li1 = [1,2,3]
li2 = li1[0:]
li1.append(4)
li2.extend([4])
print(f'{li1}\n{li2}')
print('='*30)
li1.append([5,6])
li2.extend([[5,6]])
print(f'{li1}\n{li2}')
print('='*30)
a = [7,8]
li1.append(a)
li2.extend(a)
print(f'{li1}\n{li2}')
==========출력==========
[1, 2, 3, 4]
[1, 2, 3, 4]
==============================
[1, 2, 3, 4, [5, 6]]
[1, 2, 3, 4, [5, 6]]
==============================
[1, 2, 3, 4, [5, 6], [7, 8]]
[1, 2, 3, 4, [5, 6], 7, 8]
li = [1,2,3]
li.extend([int(input('연결 >> '))])
print(li)
==========출력==========
연결 >> 4
[1, 2, 3, 4]
리스트 안에 입력받은 리스트를 추가
li1 = [1,2,3]
li1.append(4)
print(li1)
li2 = []
li2.append(int(input('추가1 >> ')))
li2.append(int(input('추가2 >> ')))
li1.append(li2)
print(li1)
==========출력==========
[1, 2, 3, 4]
추가1 >> 5
추가2 >> 6
[1, 2, 3, 4, [5, 6]]
리스트 삽입 insert()
리스트 이름.insert(인덱스 번호,내용)
li = [1,2,3]
li.insert(2,20)
print(li)
print('='*30)
li.insert(0,[100,200])
print(li)
==========출력==========
[1, 2, 20, 3]
==============================
[[100, 200], 1, 2, 20, 3]
리스트 인덱스 값 확인 index()
리스트 이름.index(a) = 리스트중에 a의 값을 찾아서 인덱스 값을 알려줘라
li = [1,2,3,4,5]
print(li)
a=li.index(4)
print(a)
li[li.index(4)] = 800
print(li)
==========출력==========
[1, 2, 3, 4, 5]
3
[1, 2, 3, 800, 5]
리스트 인덱스 값 찾을때 두번째는 못찾음
li = [1,2,3,1,5]
print(li)
print(li.index(1))
a=li.index(1) #a라는 변수에 첫번째 인덱스값 저장
b=li[a] #b라는 변수에 li[a]의 내용 저장
li[li.index(1)] = '' #첫번째 인덱스 내용 변경
print(li)
print(li.index(1))
print('='*30)
li[li.index(1)] = 4 #두번째 인덱스에 값변경
print(li)
li[a] = b #''으로 변경했던 곳에 b저장
print(li)
==========출력==========
[1, 2, 3, 1, 5]
0
['', 2, 3, 1, 5]
3
==============================
['', 2, 3, 4, 5]
[1, 2, 3, 4, 5]
리스트 삭제 clear()
리스트 이름.clear()
li = [1,2,3,1,5]
print(li)
li.clear()
print(li)
==========출력==========
[1, 2, 3, 1, 5]
[]
리스트 터트리기 pop()
리스트 이름.pop() 마지막 뽑아내기
li = [1,2,3,1,5]
print(li)
print(li.pop())
print(li)
print('='*30)
li.pop()
print(li.pop())
print(li)
==========출력==========
[1, 2, 3, 1, 5]
5
[1, 2, 3, 1]
==============================
3
[1, 2]
리스트 이름.pop(인덱스값) = 인덱스에 있는 값 뽑아내기
li = [1,2,3,1,5]
print(li)
print(li.pop(2))
print(li)
==========출력==========
[1, 2, 3, 1, 5]
3
[1, 2, 1, 5]
리스트 제거 remove()
li = [1,2,3,1,5]
print(li)
print(li.remove(1)) #앞에 있는 1이 제거
print(li)
li.remove(3) #3이 제거
print(li)
==========출력==========
[1, 2, 3, 1, 5]
None
[2, 3, 1, 5]
[2, 1, 5]
리스트 역행 reverse()
리스트 이름.reverse() 리스트 순서 변경
li = [1,2,3,1,5]
print(li)
li.reverse()
print(li)
==========출력==========
[1, 2, 3, 1, 5]
[5, 1, 3, 2, 1]
튜플 p42
튜플 생성
tu = tuple()
tu = ()
tu = (1,2,3,4)
tu1 = tuple()
tu2 = ()
tu3 = (1,2,3,4)
print(tu1)
print(tu2)
print(tu3)
==========출력==========
()
()
(1, 2, 3, 4)
튜플은 추가, 삭제 수정불가능
tu = (1,2,3,4)
print(tu)
a = tu.index(3)
print(a)
tu[0] = 5 #에러
print(tu)
==========출력==========
(1, 2, 3, 4)
2
튜플 슬라이스
tu = (1,2,3,4)
print(tu)
a = tu[0:2]
print(a)
li = []
li.append(tu[0])
print(li)
li = []
li.extend([tu[0],tu[1],tu[2]])
print(li)
==========출력==========
(1, 2, 3, 4)
(1, 2)
[1]
[1, 2, 3]
세트 p43, p178
집합의 개념으로 저장된 값의 순서가 없다
인덱싱과 슬라이싱 사용할 수 없다
세트 생성
s = set()
s = {1,2,3,4}
s = {} // 딕셔너리가 생성됨 즉 안됨
s = set()
print(type(s))
s = {}
print(type(s))
s = {1,2,3}
print(type(s))
==========출력==========
<class 'set'>
<class 'dict'>
<class 'set'>
세트를 활용한 리스트중복 방지
li1 = [1,2,3,4,1,5]
print(li1)
li2 = list(set(li1))
print(li2)
a = set(li1)
print(a)
==========출력==========
[1, 2, 3, 4, 1, 5]
[1, 2, 3, 4, 5]
{1, 2, 3, 4, 5}
세트의 추가 add()
세트 이름.add(값) 값을 추가함 순서는 다름(정해져있지 않음)
s = {1,2,3,4,5}
print(s)
s.add(0)
print(s)
s.add(7)
print(s)
==========출력==========
{1, 2, 3, 4, 5}
{0, 1, 2, 3, 4, 5}
{0, 1, 2, 3, 4, 5, 7}
세트의 삭제 remove(), discard()
세트 이름.remove(값) // 값이 삭제됨
세트 이름.discard(값)
s = {1,2,3,4,5}
print(s)
s.remove(1)
print(s)
#s.remove(1) #에러
#print(s)
s.discard(1) #없어도 오류 미발생
print(s)
s.discard(5)
print(s)
==========출력==========
{1, 2, 3, 4, 5}
{2, 3, 4, 5}
{2, 3, 4, 5}
{2, 3, 4}
세트 메소드 p178
교집합(&) : 공통적인 요소만 추출
합집합(|) : 모든 요소를 합함 공통된 것은 1번만 // s1.union(s2)
차집합(-) : 한집합에서 다른 집합부분을 제외 // s1.difference(s2)
s1 = {1,2,3,4,5}
s2 = {2,3,9,4,10}
print(s1 & s2) # 교집합 두개중 동일한부분
print(s1|s2) # 합집합 둘의 합(동일한부분은 1번)
print(s1.union(s2)) #위와 동일 합집합
print(s1-s2) # 차집합 s1에서 s2에 해당부분 제거
print(s1.difference(s2)) # 위와 동일 차집합
==========출력==========
{2, 3, 4}
{1, 2, 3, 4, 5, 9, 10}
{1, 2, 3, 4, 5, 9, 10}
{1, 5}
{1, 5}
딕셔러니
키와 값을 가진 하나의 구성체
dict = {키1:값1,키2,값2}
생성
d = {'a':'apple', 'b':'banana'}
d = {}
d = dict(a='apple', b='banana')
d['a'] = apple
d1 = {'ㄱ':'고구마','ㄴ':'나무','ㄷ':'다시마'}
print(d1)
print(d1['ㄱ'])
d2 = {1:'금메달',2:'은메달',3:'동메달'}
print(d2[1])
d3 = {1:100,2:120,3:310}
print(d3[3])
d4 = dict(ㄱ='고구마',ㄴ='나무') # 숫자는 에러메시지
print(d4)
==========출력==========
{'ㄱ': '고구마', 'ㄴ': '나무', 'ㄷ': '다시마'}
고구마
금메달
310
{'ᄀ': '고구마', 'ᄂ': '나무'}
딕셔너리 요소 추가
딕셔너리 이름[키] = 값
딕셔너리 이름.setdefauly(키, 값)
d = {1:100,2:120,3:310}
print(d)
d[5] = 440
print(d)
d['a'] = 'apple'
print(d)
d[1] = 6 # 1의 키의 값이 6으로 변경
print(d)
print()
d.setdefault(8,1230)
print(d)
==========출력==========
{1: 100, 2: 120, 3: 310}
{1: 100, 2: 120, 3: 310, 5: 440}
{1: 100, 2: 120, 3: 310, 5: 440, 'a': 'apple'}
{1: 6, 2: 120, 3: 310, 5: 440, 'a': 'apple'}
{1: 6, 2: 120, 3: 310, 5: 440, 'a': 'apple', 8: 1230}
딕셔너리 요소 수정(추가)
딕셔너리.update(a=b) 'a'가 b로 변경
d = {1:100,2:120,3:310}
print(d)
d[1] = 2
print(d)
# d.update(1=50) #에러 1쪽에 문자열/ 문자열 1도 불가
d['a'] = 5
print(d)
d.update(a=50)
print(d)
d.update(b='안녕')
print(d)
==========출력==========
{1: 100, 2: 120, 3: 310}
{1: 2, 2: 120, 3: 310}
{1: 2, 2: 120, 3: 310, 'a': 5}
{1: 2, 2: 120, 3: 310, 'a': 50}
{1: 2, 2: 120, 3: 310, 'a': 50, 'b': '안녕'}
■ 2월 2일 - 4일차
enumerate()
리스트와 함께 사용
리스트에 저장된 요소와 해당 요소의 인덱스가 튜플 형태로 추출
for n in enumerate(['가','나','다']):
print(n)
for a, n in enumerate(['가','나','다']):
print(a, n)
==========출력==========
(0, '가')
(1, '나')
(2, '다')
0 가
1 나
2 다
zip() 전달된 여러개의 반복 객체의 요소를 튜플로 묶어서 반환
n = ['이순신','성춘향','이산']
s = [91,65,70]
for i in zip(n,s):
print(n)
==========출력==========
('이순신', 91)
('성춘향', 65)
('이산', 70)
n = ['이순신','성춘향','이산']
s = [91,65,70]
for n,s in zip(n,s):
print(f'{n}의 점수 : {s}')
==========출력==========
이순신의 점수 : 91
성춘향의 점수 : 65
이산의 점수 : 70
range() 리스트 튜플을 통해 사용
a = list(range(5))
b = list(range(1,5))
c = tuple(range(5))
d = list(range(5,0,-1))
e = list(range(0,-5,-1))
print(a,b,c,d,e)
==========출력==========
[0, 1, 2, 3, 4] [1, 2, 3, 4] (0, 1, 2, 3, 4) [5, 4, 3, 2, 1] [0, -1, -2, -3, -4]
len() 객체의 길이를 반환
a = len([1,2,3])
b = len(range(10))
c = len(range(1,5))
print(a,b,c)
s = ['봄','여름','가을','겨울']
for n in range(len(s)):
print(s[n])
==========출력==========
3 10 4
봄
여름
가을
겨울
sorted() 오름차순 정렬 reverse 역순
a = [1,7,4,2,3]
b = sorted(a)
c = sorted(a, reverse=1)
print(a,b,c)
print(list(reversed(b))) # 객체를 역순화 시킴
b.reverse() # 값을 반환하지 않는다.
print(b)
==========출력==========
[1, 7, 4, 2, 3] [1, 2, 3, 4, 7] [7, 4, 3, 2, 1]
[7, 4, 3, 2, 1]
[7, 4, 3, 2, 1]
기본예제 p159
m = [31,28,31,30,31,30,3,31,30,31,30,31]
for n,i in enumerate(m):
print(f'{n+1}월 = {i}일')
==========출력==========
1월 = 31일
2월 = 28일
3월 = 31일
4월 = 30일
5월 = 31일
6월 = 30일
7월 = 3일
8월 = 31일
9월 = 30일
10월 = 31일
11월 = 30일
12월 = 31일
응용예제 p160
예제1
무지게 일곱 색깔을 저장하는 rainbow 리스트 생성 다음과 같이 출력
Hint : enumerate() 함수사용실행 예제
무지개의 1번째 색은 red입니다.
무지개의 2번째 색은 orange입니다.
무지개의 3번째 색은 yellow입니다.
무지개의 4번째 색은 green입니다.
무지개의 5번째 색은 blue입니다.
무지개의 6번째 색은 navy입니다.
무지개의 7번째 색은 purple입니다.
r = ['red','orange','yellow','green','blue','navy','purple']
for n,i in enumerate(r):
print(f'무지개의 {n+1}번째 색은 : {i}입니다.')
예제2
점수를 입력받아 평균점수, 최고 점수 최저 점수 프로그램 작성
몇개를 입력받는지 모름
0보다 작은 점수 입력시 종료
입력받은 모든 점수 exam 리스트에 저장
마지막 0보다 작은 점수는 리스트에 저장 안함Hint : 평균은 합계 / 개수
실행 예제
점수 입력 >>> 80
점수 입력 >>> 50
점수 입력 >>> 60
점수 입력 >>> 30
점수 입력 >>> 90
점수 입력 >>> -1
평균 = 62.0, 최대 = 90, 최소 = 30
print('점수를 입력하세요. 더 이상 입력할 점수가 없으면 음수를 아무거나 입력하세요.')
exam = []
while(1):
a = int(input('점수 입력 >>> '))
if a < 0:
break
else:
exam.append(a)
print(f'평균 = {sum(exam)/len(exam)}, 최대 = {max(exam)}, 최소 = {min(exam)}')
사용자 함수 p184
사용자 함수 용어
함수의 정의 : 함수를 새로 만듦
인수 : 함수에 전달할 입력값
매개변수 : 인수를 받아서 저장하는 변수
반환값 : 함수의 출력
함수 호출 : 만들어진 것을 실제로 사용
함수의 정의
def 함수이름(매개변수)
(Tap) 본문
return 반환값
함수의 호출
호출인수반환값
| 함수 이름() | X | X |
| 함수 이름(인수) | O | X |
| 변수 = 함수이름() | X | O |
| 변수 = 함수이름(인수) | O | O |
가변 매개변수 (* : Asterisk) 인수의 개수가 정해져 있지 않음
def pr(*a):
for n in a:
print(n)
pr('이순신','백두산','한라산','지리산')
==========출력==========
이순신
백두산
한라산
지리산
디폴트 매개변수 작성하지 않으면 자동적으로 실행
def pr_f(a, b, c=1):
print(a,b,c)
pr_f(1,2)
pr_f(1,2,3)
print()
def fpr(a, b=0,c=1):
print(a,b,c)
fpr(7)
fpr(6,5)
fpr(6,5,4)
def fpr(a=1, b,c=1): # 뒤에서부터 디폴트 매개변수 사용
print(a,b,c)
==========출력==========
1 2 1
1 2 3
7 0 1
6 5 1
6 5 4
기본예제 p191
def fadd(*a):
print(f'{a}의 합은 {sum(a)}')
fadd(1,2)
fadd(2,4,5,6)
fadd(5,6,8,8)
==========출력==========
(1, 2)의 합은 3
(2, 4, 5, 6)의 합은 17
(5, 6, 8, 8)의 합은 27
반환값
반환값이 있는 함수
def fadd(a,b):
c = a+b
return c
print(fadd(5,3))
a = fadd(6,7)
print(a)
==========출력==========
8
13
다중반환
def fmath(*a):
return sum(a), sum(a)/len(a), max(a), min(a)
a = fmath(1,2,3,5,7)
print(a)
print(f'''합계 : {a[0]}, 평균 : {a[1]},
최대값 : {a[2]}, 최소값 : {a[3]}''')
==========출력==========
(18, 3.6, 7, 1)
합계 : 18, 평균 : 3.6,
최대값 : 7, 최소값 : 1
함수의 종료를 위한 return
def ft(a):
if a < 0:
print('0보다 작은 에너지는 충전할 수 없습니다.')
return
print('에너지가 충전되었습니다.')
ft(-1)
ft(1)
==========출력==========
0보다 작은 에너지는 충전할 수 없습니다.
에너지가 충전되었습니다.
def ft(a):
if a < 0:
print('0보다 작은 에너지는 충전할 수 없습니다.')
else :
print('에너지가 충전되었습니다.')
ft(-1)
ft(1)
print함수 만들기
def f(*a,e="\n",s=" "):
c = 0
for i in a:
c+=1
if c==len(a):
print(i,end=e)
continue
print(i,end=s)
기본예제 p195
커피자판기에 돈과 주문할 커피를 전달
주문할 수 있는 커피의 종류와 가격
아메리카노 1000원, 카페라떼 : 1500원, 카푸치노 : 2000원
없는 커피를 주문할 경우 입력한 돈을 그대로 반환
구매 금액이 부족하면 입력한 돈을 그대로 반환
정상 주문이면 주문한 커피와 잔돈을 반환
def fcm(m,p):
print(f'{m}원에 {p}를 선택')
mu = {
'아메리카노' : 1000,
'카페라떼' : 1500,
'카푸치노' : 2000
}
if p not in mu:
print(f'{p}는 판매 안함')
return m, '없는메뉴'
elif mu[p] > m:
print(f'{p}는 {mu[p]}원 입니다.')
return m, '금액 부족'
else:
return m - mu[p],p
order = input('커피를 선택하세요.(아메리카노, 카페라떼, 카푸치노 >>> ')
pay = int(input('얼마나 내시나요? >> '))
c1 = fcm(pay, order)
print(f'잔돈 {c1[0]}원, 커피 {c1[1]}')
==========출력==========
커피를 선택하세요.(아메리카노, 카페라떼, 카푸치노 >>> 마키아또
얼마나 내시나요? >> 10000
10000원에 마키아또를 선택
마키아또는 판매 안함
잔돈 10000원, 커피 없는메뉴
커피를 선택하세요.(아메리카노, 카페라떼, 카푸치노 >>> 아메리카노
얼마나 내시나요? >> 100
100원에 아메리카노를 선택
아메리카노는 1000원 입니다.
잔돈 100원, 커피 금액 부족
커피를 선택하세요.(아메리카노, 카페라떼, 카푸치노 >>> 아메리카노
얼마나 내시나요? >> 5000
5000원에 아메리카노를 선택
잔돈 4000원, 커피 아메리카노
○ 리스트에서 "예" 또는 "아니오" 응답 비율 반환
def survey_result(responses):
yes = 0
no = 0
for r in responses:
if r == "예":
yes += 1
elif r == "아니오":
no += 1
total = yes + no
return {
"예 비율": round(yes / total * 100, 1),
"아니오 비율": round(no / total * 100, 1)
}
print(survey_result(["예", "예", "아니오", "예", "아니오"]))
# 출력: {'예 비율': 60.0, '아니오 비율': 40.0}
○ 시작과 종료 문자 확인
print("홍길동".startswith("홍"))
print("홍길동".endswith("동"))
# True True
○ 이름 리스트에서 "김"씨이고 글자 수가 3자 이상인 사람만 추출
def filter_kim(names):
result = []
for name in names:
if name.startswith("김"):
if len(name) >= 3:
result.append(name)
return result
print(filter_kim(["김철수", "이영희", "김가", "김민준", "박하늘"]))
○ 점수 리스트에서 60점 이상은 "합격", 그 외는 "불합격" 표시 리스트 만들기
def check_pass(scores):
result = []
for score in scores:
if score >= 60:
result.append("합격")
else:
result.append("불합격")
return result
print(check_pass([85, 55, 60, 45]))
# 출력: ['합격', '불합격', '합격', '불합격']
○ 이메일 리스트 중에서 @naver.com 계정만 추출
def filter_naver_emails(emails):
result = []
for email in emails:
if email.endswith("@naver.com"):
result.append(email)
return result
print(filter_naver_emails(["kim@naver.com", "lee@gmail.com", "hong@naver.com"]))
# 출력: ['kim@naver.com', 'hong@naver.com']
○ 두 리스트를 비교하여 같은 값만 리스트로 반환
def find_common(a, b):
result = []
for x in a:
if x in b:
result.append(x)
return result
print(find_common([1, 2, 3, 4], [3, 4, 5, 6]))
# 출력: [3, 4]
○ 이름 리스트에서 성씨별로 몇 명씩 있는지 세기
def count_by_lastname(names):
result = {}
for name in names:
lastname = name[0]
if lastname not in result:
result[lastname] = 0
result[lastname] += 1
return result
○ 점수 구간별 인원 수 구하기
def score_distribution(scores):
result = {"0~59": 0, "60~79": 0, "80~100": 0}
for score in scores:
if score < 60:
result["0~59"] += 1
elif score < 80:
result["60~79"] += 1
else:
result["80~100"] += 1
return result
print(score_distribution([55, 67, 70, 85, 90, 58, 78]))
# 출력: {'0~59': 2, '60~79': 3, '80~100': 2}
○ 상품별 주문 수량 합계 구하기
def sum_by_product(orders):
result = {}
for product, qty in orders:
if product not in result:
result[product] = 0
result[product] += qty
return result
print(sum_by_product([
("사과", 3), ("바나나", 2), ("사과", 1), ("딸기", 5), ("바나나", 3)
]))
○ 책 대출 상태 안내 (도서명 → 대출 여부 → 메시지)
def is_borrowed(title, borrowed_list):
return title in borrowed_list
def get_book_status(title, borrowed_list):
if is_borrowed(title, borrowed_list):
return f"'{title}'은 대출 중입니다."
else:
return f"'{title}'은 이용 가능합니다."
print(get_book_status("데미안", ["1984", "데미안"]))
# 출력: '데미안'은 대출 중입니다.
○ 현재 시간(시) 입력 → 시간대 분류 → 인삿말 반환
def get_time_period(hour):
if 5 <= hour < 12:
return "아침"
elif 12 <= hour < 18:
return "오후"
else:
return "밤"
def say_hello_by_time(hour):
period = get_time_period(hour)
return f"{period}입니다. 좋은 하루 보내세요!"
print(say_hello_by_time(16))
# 출력: 오후입니다. 좋은 하루 보내세요!
○ 시간당 급여 계산기
def daily_pay(hour, rate):
return hour * rate
def show_earnings(name, hour, rate):
return f"{name}님의 일당은 {daily_pay(hour, rate)}원입니다."
print(show_earnings("영희", 6, 10500))
○ 여행 일정 예상 경비 계산
def calc_trip_cost(days, hotel_per_night, daily_food):
return (hotel_per_night * (days - 1)) + (daily_food * days)
def show_trip_budget(city, days):
total = calc_trip_cost(days, 80000, 30000)
return f"{city} 여행 {days}일 총 예상 경비: {total}원"
print(show_trip_budget("부산", 3))
# 출력: 부산 여행 3일 총 예상 경비: 250000원
○ 도서관 대출 통계 + 연체료 총합
설명: 대출된 책들(제목, 연체일 수)을 받아,
연체 여부 분류
연체 총합 계산
연체된 책 제목만 추출
def is_late(days):
return days > 0
def calc_fee(days):
return days * 500
def summarize_books(book_list):
fee_total = 0
late_books = []
for title, days in book_list:
if is_late(days):
fee = calc_fee(days)
fee_total += fee
late_books.append(title)
print(f"{title}: 연체 {days}일, {fee}원")
else:
print(f"{title}: 연체 없음")
print("총 연체료:", fee_total)
print("연체 도서 목록:", late_books)
# 실행 예시
books = [("1984", 0), ("데미안", 3), ("모비딕", 2)]
summarize_books(books)
○ 고객 등급 분류기 (주문 누적액 기반)
고객 이름과 누적 결제액이 담긴 리스트에서
30만 이상: VIP, 10만 이상: 우수, 그 외: 일반 고객으로 분류하세요.
def classify_customer(customers):
result = {"VIP": [], "우수": [], "일반": []}
for name, total in customers:
if total >= 300000:
result["VIP"].append(name)
elif total >= 100000:
result["우수"].append(name)
else:
result["일반"].append(name)
return result
# 예시 실행
custs = [("김지민", 340000), ("홍길동", 50000), ("이슬기", 120000), ("박보검", 90000)]
print(classify_customer(custs))
■ 2월 3일 - 5일차
모듈과 import
모듈
언제든지 사용할 수 있도록 변수나 함수 또는
클래스를 모아 놓은 파일을 모듈이라고 한다.
모든 파이썬 파일은 모듈이 될 수 있다.
import
사전적 의미는 수입으로 외부파일들을 불러오는 것을 말함.
모듈의 생성
파일 이름 converter_cm.py
1평 = 3.305785 m^2
1m^2 = 0.3025 평
smt = 3.305785
cmt = 0.3025
def ctm(comment):
a = comment * smt
print(f'{comment}평은 {a:.2f}제곱미터(m^2)')
def mtc(square_meter):
a = square_meter * cmt
print(f'{square_meter}제곱미터는 {a}평')
모듈의 사용
- import 모듈명
- from 모듈명 import 함수1명칭
- from 모듈명 import 함수1명칭, 함수2명칭
- from 모듈명 import *
import로 모듈을 불러왔을 때
함수를 사용하고 싶으면 어떤 모듈의 함수인지 작성
import converter_cm
converter_cm.ctm(30)
converter_cm.mtc(92)
==========출력==========
30평은 99.17제곱미터(m^2)
92제곱미터는 27.83평
함수를 import 시켜 놓으면 함수명만 작성하면 됨
# import converter_cm
from converter_cm import ctm, mtc
ctm(30)
mtc(92)
함수를 import * 로 선정하면 모든 항목을 사용가능
# import converter_cm
# from converter_cm import ctm, mtc
from converter_cm import *
ctm(30)
mtc(92)
별명 사용하기
import converter_cm as cvt
# from converter_cm import ctm, mtc
# from converter_cm import *
cvt.ctm(30)
cvt.mtc(92)
# import converter_cm as cvt
from converter_cm import ctm as cm
from converter_cm import mtc as mc
# from converter_cm import *
cm(30)
mc(92)
# ctm(30) # 오류
연습문제
연습문제 1.
모듈에 숫자를 입력받아 두 숫자를 비교하여
큰 수가 출력되는 함수를 만들고
메인 소스에서 함수를 import 받아
실행 시키도록 코드를 구현하시오.
실행예시
첫번째 숫자입력 >> 10
두번째 숫자입력 >> 5
입력된 숫자중 큰 수 는 10
converter_cm.py
a = int(input('첫번째 숫자입력 >> '))
b = int(input('두번째 숫자입력 >> '))
def max_print():
c = a
if a<=b:
c=b
print(f'입력된 숫자중 큰 수 는 {c}')
main.py
from converter_cm import max_print as mp
mp()
==========출력==========
첫번째 숫자입력 >> 10
두번째 숫자입력 >> 5
입력된 숫자중 큰 수 는 10
입력 해서 데이터 정리
a.py
from b import *
z = []
z.append(f())
z.append(f())
z.append(f())
pr(z)
b.py
def f():
a = ["국어","영어","수학"]
l = []
l.append(input("이름 >> "))
for i in a:
l.append(int(input(i + ">> ")))
return l
def pr(a):
s = ["국어","영어","수학"]
for i in a:
print(f"{i[0]}의 평균은 {sum(i[1:5])/len(i[1:5])}")
for j in range(3):
print(s[j],i[j+1],end = " ")
print()
클래스 개념
클래스는 객체를 정의해 놓은 객체의 설계도의 일종이다
객체는 실제 존재하는 사물 또는 개념
객체의 구성요소는 속성(변수)과 기능(메서드)
자동차에 비유
속성 : 크기, 길이, 높이, 색상, 엔진종류, 타입등
기능 : 시동켜기, 속도높이기, 연료충전, 기어변속등
객체와 인스턴스 (같은 말로도 할 수 있다)
객체 : 모든 인스턴스를 대표하는 일반적인 용어
인스턴스(사례) : 특정 클래스로부터 생성된 객체
인스턴스화 = 설계도를 가지고 제품을 만드는 행위
클래스를 인스턴스화 하면 인스턴스(객체)가 생성
클래스가 필요한 이유
객체(인스턴스)를 생성하기 위해서
객체가 필요한 이유
우리가 사용하기 위해
객체를 사용한다는 것은
객체가 가진 속성(변수)과 기능(메서드)을 사용하려고
클래스 변수와 인스턴스 변수
객체와 클래스의 주소 값
객체는 또다른 주소 값을 갖는다.
class c_a:
a = 10
o1 = c_a()
o2 = c_a()
print(f'객체 1번 주소 : {o1}')
print(f'객체 2번 주소 : {o2}')
print(f'클래스 : {c_a}')
==========출력==========
객체 1번 주소 : <__main__.c_a object at 0x0000018E22CC8BE0>
객체 2번 주소 : <__main__.c_a object at 0x0000018E22CC92D0>
클래스 : <class '__main__.c_a'>
클래스 변수의 변경
클래스 변수가 변경되면 그로 만들어진
모든 객체의 변수 값이 변한다
class c_a:
a = 10
o1 = c_a()
o2 = c_a()
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
c_a.a = 100
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
==========출력==========
o1의 a 값 = 10
o2의 a 값 = 10
o1의 a 값 = 100
o2의 a 값 = 100
객체 변수의 변경
객체의 변수를 변경하면
각각의 객체의 변수만 변경된다
class c_a:
a = 10
o1 = c_a()
o2 = c_a()
o1.a = 1
o2.a = 2
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
==========출력==========
o1의 a 값 = 1
o2의 a 값 = 2
클레스의 a 값 = 10
클래스 변수의 인스턴스 변수로의 변화
다시 클래스의 변수를 변경하면
객체의 변수는 이전의 변경 값을 그대로 받아들이고
클래스의 변수만 바뀐다.
class c_a:
a = 10
o1 = c_a()
o2 = c_a()
o1.a = 1 # 객체에서 변수의 값을 변화시키면서 자기자신의 변수를 생성
o2.a = 2 # 인스턴스 변수를 새로 지정함
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
print("클래스의 변수 변경 후\n")
c_a.a = 100
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
==========출력==========
o1의 a 값 = 1
o2의 a 값 = 2
클레스의 a 값 = 10
클래스의 변수 변경 후
o1의 a 값 = 1
o2의 a 값 = 2
클레스의 a 값 = 100
클래스 변수 와 인스턴스 변수
클래스 변수는 클래스 내에서 선언하여
만들어지는 모든 객체에 영향을 줌
인스턴스 변수는 각각의 객체에서 자기 스스로 사용
클래스 함수와 인스턴스 함수
클래스 함수 기초
클래스에서 사용할 수 있고
모든 객체에 영향을 준다
class c_a:
a = 10
def caa(): # 클래스 함수
c_a.a = 1
o1 = c_a()
o2 = c_a()
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
c_a.caa()
print()
print("함수 실행 후")
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
==========출력==========
o1의 a 값 = 10
o2의 a 값 = 10
클레스의 a 값 = 10
함수 실행 후
o1의 a 값 = 1
o2의 a 값 = 1
클레스의 a 값 = 1
인스턴스 함수
각각의 객체에서 객체 스스로 쓰는 함수임.
함수로 인스턴스 변수변경
객체의 변수 a를 변경시켜서 저장한다
클레스 변수에서 인스턴스 변수로 변화
class c_a:
a = 10
def caa(self):
self.a = 1
o1 = c_a()
o2 = c_a()
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
o1.caa()
print()
print("함수 선언 후")
print(f'o1의 a 값 = {o1.a}')
print(f'o2의 a 값 = {o2.a}')
print(f'클레스의 a 값 = {c_a.a}')
==========출력==========
o1의 a 값 = 10
o2의 a 값 = 10
클레스의 a 값 = 10
함수 선언 후
o1의 a 값 = 1
o2의 a 값 = 10
클레스의 a 값 = 10
일반적인 함수와 클래스 비교
변수를 단순 참조 하는 함수
a변수가 변하면 함수는 단순 참조로 같이 변한다
a = 1
def ap():
print(f'함수 a = {a}')
ap()
print(f'a = {a}')
print()
a = 2
ap()
print(f'a = {a}')
==========출력==========
함수 a = 1
a = 1
함수 a = 2
a = 2
함수의 기본 a라는 변수는
함수 안에서의 a라는 변수에 영향이 없다.
a = 1
def ap():
a = 10
print(f'함수 a = {a}')
ap()
print(f'a = {a}')
print()
a = 2
ap()
print(f'a = {a}')
==========출력==========
함수 a = 10
a = 1
함수 a = 10
a = 2
global 함수안에서
밖에 있는 변수를 통제한다.
a = 1
def ap():
global a
a = 3
print(f'함수 a = {a}')
ap()
print(f'a = {a}')
print()
a = 2
ap()
print(f'a = {a}')
==========출력==========
함수 a = 3
a = 3
함수 a = 3
a = 3
클래스내 클래스 변수는
클래스 외부변수에도 영향을 미치지 못하고
클래스 내부 함수에도 영향을 미치지 못한다
a = 1
class ca:
a = 2
def ap():
a = 3
print(f'a클래스내 함수 = {a}')
def cap():
print(f'a클래스내 변수 = {ca.a}')
print(f'a = {a}')
ca.ap()
ca.cap()
ca.ap()
print(f'a = {a}')
==========출력==========
a = 1
a클래스내 함수 = 3
a클래스내 변수 = 2
a클래스내 함수 = 3
a = 1
객체를 생성하여 함수를 사용하면
클래스 밖에 있는 변수를 채택한다
a = 1
class ca:
a = 2
def ap(self):
self.a = 3
print(f'a클래스내 인스턴스 함수 = {a}')
def cap():
print(f'a클래스내 변수 = {ca.a}')
print(f'a = {a}')
o1 = ca()
print()
o1.ap()
print(f'o1의 a = {o1.a}')
print()
a = 10
o1.ap()
print(f'a = {a}')
==========출력==========
a = 1
a클래스내 인스턴스 함수 = 1
o1의 a = 3
a클래스내 인스턴스 함수 = 10
a = 10
클래스 내 인스턴스 함수에 self.a로
바꿔주면 객체는 객체 내부에서
실행된 a를 채택
a = 1
class ca:
a = 2
def ap(self):
self.a = 3
print(f'a클래스내 인스턴스 함수 = {self.a}')
def cap():
print(f'a클래스내 변수 = {ca.a}')
print(f'a = {a}')
o1 = ca()
print()
o1.ap()
print(f'o1의 a = {o1.a}')
print()
a = 10
o1.ap()
print(f'a = {a}')
==========출력==========
a = 1
a클래스내 인스턴스 함수 = 3
o1의 a = 3
a클래스내 인스턴스 함수 = 3
a = 10
물론 클래스 내부에서 global로
클래스 외부 통제 가능
클래스 정리
class C1:
c1_list = []
c1_int = 0
def fintch(self,a):
self.c1_int = a
def fpr(a1):
print(a1.c1_list)
print(a1.c1_int)
def fla(self):
for i in range(self.c1_int):
self.c1_list.append(i)
def flich(self, a1, a2):
self.c1_list[a1] = a2
def fsum(self):
a = sum(self.c1_list)
print("합계는",a,"입니다.")
def favg(a):
b = sum(a.c1_list)/len(a.c1_list)
print("평균은",b,"입니다.")
oj1 = C1()
oj1.fintch(5)
oj1.fla()
oj1.flich(2,20)
oj1.fsum()
oj1.favg()
oj1.fpr()
클래스 생성자 와 소멸자
생성자
생성자란 클래스를 가지고 객체를 인스턴스할때
발생하는 것으로 쉽게 생각하면 되고
객체 생성시 초기화 해주는 내용을 넣을 수 있음
생성자 작성법
def _ _ init _ _(self):
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
oj = class_a()
==========출력==========
객체생성
- 메서드 사용해보기
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
oj = class_a()
oj.pr()
==========출력==========
객체생성
메서드 선언
- 다른 객체 생성해보기
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
oj = class_a()
oj.pr()
oj2 = class_a()
==========출력==========
객체생성
메서드 선언
객체생성
소멸자
생성자와 반대로 객체가 소멸할때 실행
def _ _ del _ _ (self)
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
def __del__(self):
print("객체소멸")
oj = class_a()
==========출력==========
객체생성
객체소멸
- 메서드 실행
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
def __del__(self):
print("객체소멸")
oj = class_a()
oj.pr()
==========출력==========
객체생성
메서드 선언
객체소멸
- 다른객체 생성
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
def __del__(self):
print("객체소멸")
oj = class_a()
oj.pr()
oj2 = class_a()
==========출력==========
객체생성 #oj 생성
메서드 선언
객체생성 #oj2 생성
객체소멸 #oj 소멸
객체소멸 #oj2 소멸
- 객체 소멸을 시행해보기
class class_a:
def __init__(self):
print("객체생성")
def pr(self):
print("메서드 선언")
def __del__(self):
print("객체소멸")
oj = class_a()
oj.pr()
oj.__del__()
oj2 = class_a()
==========출력==========
객체생성 #oj 생성
메서드 선언
객체소멸 #oj 소멸자를 실행
객체생성 #oj2 생성
객체소멸 #oj 소멸
객체소멸 #oj2 소멸
- 2개의 클래스로 확인해보기
class class_a:
def __init__(self):
print("객체생성 a")
def __del__(self):
print("객체소멸 a")
class class_b:
def __init__(self):
print("객체생성 b")
def __del__(self):
print("객체소멸 b")
oj = class_a()
oj.__del__()
oj2 = class_b()
==========출력==========
객체생성 a
객체소멸 a
객체생성 b
객체소멸 a
객체소멸 b
생성자와 활용 1
class class_a:
def __init__(self, a):
self.int_a = a
oj = class_a()
==========출력==========
Traceback (most recent call last):
File "e:\python\main.py", line 5, in <module>
oj = class_a()
TypeError: class_a.__init__() missing 1 required positional argument: 'a'
생성자를 보면
클레스를 객체로 인스턴스화 할때
a라는 인수에 값을 넣어서 인스턴스해야
한다는 의미를 지님
객체를 생성하면서 초기화 시킬때 사용
class class_a:
def __init__(self, a): #int_a라는 인스턴스 변수에 a로 초기화
self.int_a = a
oj = class_a(5)
print(oj.int_a)
==========출력==========
5
생성자 활용 2
class ca:
def __init__(self):
self.n = "홍길동"
self.a = 38
self.g = "남자"
o1 = ca()
print(o1.n)
#print(ca.n) #에러
==========출력==========
홍길동
생성자 활용 3
class ca:
def __init__(self,nf="홍길동",af=38,ng="남자"):
self.n = nf
self.a = af
self.g = ng
def pr(self):
print(f'이름 : {self.n}, 나이 : {self.a}, 성별 : {self.g}')
o1 = ca()
o1.pr()
o2 = ca("이순신", 27,"남자")
o2.pr()
==========출력==========
이름 : 홍길동, 나이 : 38, 성별 : 남자
이름 : 이순신, 나이 : 27, 성별 : 남자
클래스 로 만들기
class ca:
def __init__(self):
self.t = []
def pr(self): #출력
print(self.t)
def add(self, a): #뒤에 추가
self.t.append(a)
def add_loop(self, a, b): #값을 n번 반복
for i in range(b):
self.t.append(a)
def change(self, a, b): # 인덱스에 값 변경
if a < len(self.t):
self.t[a] = b
def find(self, a): #찾아서 인덱스 반환
b = 0
for i in self.t:
if i == a:
return b
b+=1
def find_change(self, a, b): #찾아서 변경
self.change(self.find(a),b)
def expand(self, a):
self.t+=a
def add_middle(self, a, b): #인덱스 리스트 추가
self.t = self.t[:a+1] + b + self.t[a+1:]
o1 = ca()
o1.add(5)
o1.add(20)
o1.add_loop(3,4)
o1.change(4,100)
o1.find_change(20,1)
o1.expand([20,40,50])
o1.add_middle(3,[10,20])
o1.pr()
■ 2월 4일 - 6일차
성적표
class ca:
def __init__(self):
self.name = []
self.kor = []
self.ma = []
self.avgs = []
def add(self, a,b,c):
self.name.append(a)
self.kor.append(b)
self.ma.append(c)
self.avgs.append((b+c)/2)
def total(self):
return sum(self.kor), sum(self.ma)
def avg(self):
return self.total()[0] / len(self.kor) , self.total()[1] / len(self.ma)
def pr(self):
for i in range(len(self.name)):
print(f"{self.name[i]} 국어 : {self.kor[i]} 수학 : {self.ma[i]} 평균 : {self.avgs[i]}")
o1 = ca()
o1.add("홍길동",85,90)
o1.add("이순신",87,92)
o1.add("백두산",95,91)
o1.pr()
점수 추가, 국어 수학 총계, 평균, 출력 함수 만들기
class ca:
def __init__(self):
self.name = []
self.kor = []
self.ma = []
self.avgs = []
def add(self, a,b,c):
self.name.append(a)
self.kor.append(b)
self.ma.append(c)
self.avgs.append((b+c)/2)
def total(self):
return sum(self.kor), sum(self.ma)
def avg(self):
return self.total()[0] / len(self.kor) , self.total()[1] / len(self.ma)
def pr(self):
for i in range(len(self.name)):
print(f"{self.name[i]} 국어 : {self.kor[i]} 수학 : {self.ma[i]} 평균 : {self.avgs[i]}")
o1 = ca()
o1.add("홍길동",85,90)
o1.add("이순신",87,92)
o1.add("백두산",95,91)
o1.pr()
계좌 만들기, 인덱스 번호 받아서 해당 인원의 뱅크 출력
class ca:
def __init__(self):
self.name = ["홍길동", "이순신", "백두산"]
self.bank = [57000,82000,29000]
def nin(self, a):
return self.name.index(a)
def pr(self):
for i in range(len(self.name)):
print(f"{self.name[i]} : {self.bank[i]:,}")
def depo(self, a,b):
self.bank[self.nin(a)] += b
o1 = ca()
o1.depo("백두산",10000)
o1.pr()
최대값 인덱스, 최소값 인덱스에 해당하는 성명 반환
import random
class ca:
def __init__(self, a):
self.ns = ["김","이","박","최","윤","서","강"]
self.n = []
self.t = []
for i in range(a):
self.t.append(random.randint(80,100))
self.n.append(self.ns[random.randint(0,len(self.ns)-1)])
def maxa(self):
m = max(self.t)
return self.t.index(m)
def mina(self):
return self.t.index(min(self.t))
def maxmin(self):
return self.n[self.mina()], self.n[self.maxa()]
o1 = ca(5)
print(o1.t, o1.n)
print(o1.maxmin())
■ 2월 5일 - 7일차
클래스 상속
상속의 의미
부모 클래스의 멤버를 자식클래스가 물려받는것
상속을 받으면 부모에서 사용하던 것을 쓸수 있다.
상속하는 방법
class 클래스 이름(상속받을 클래스명)
class 부모:
class 자식(부모):
상속한 상태에서 부모의 생성자넣는법
def __init__(self):
부모 클래스 이름.__init__(self)
상속한 상태에서 부모의 함수 넣는 법
def 함수이름(self):
부모클래스.부모함수이름(self)
class animal:
def __init__(self):
self.speak = "안녕"
self.color = "살색"
def pr(self):
print(f"울음소리 : {self.speak}, 색 : {self.color}")
class dog(animal):
def __init__(self):
animal.__init__(self)
self.food = "사료"
self.dress = "없음"
def pr(self):
animal.pr(self)
print(f"먹이는 : {self.food}, 옷 : {self.dress}")
def spch(self):
self.speak = "멍멍"
o1 = dog()
o1.pr()
print()
o1.speak = "멍멍"
o1.pr()
print()
o1.color = "갈색"
o1.pr()
print()
==========출력==========
울음소리 : 안녕, 색 : 살색
먹이는 : 사료, 옷 : 없음
울음소리 : 멍멍, 색 : 살색
먹이는 : 사료, 옷 : 없음
울음소리 : 멍멍, 색 : 갈색
먹이는 : 사료, 옷 : 없음
다중상속
두개 이상의 클래스를 상속받는것을 말함
클래스 정의
부모 1, 부모2 클래스를 받는다고 하면
class 자식 클래스명 (부모1 클래스명, 부모2 클래스명)
class m:
def __init__(self):
print("어머니 생성")
self.mn = "신사임당"
class d:
def __init__(self):
print("아버지 생성")
self.dn = "이원수"
class c(m,d):
def __init__(self):
print("자식 생성")
m.__init__(self)
d.__init__(self)
self.cn = "이이"
def pr(self):
print(f"어머니 : {self.mn}, 아버지 : {self.dn}, 본인 : {self.cn}")
def ch(self,mname,dname,cname):
self.mn = mname
self.dn = dname
self.cn = cname
o1 = c()
o1.pr()
o1.ch("백두산","한강","대한민국")
o1.pr()
==========출력==========
자식 생성
어머니 생성
아버지 생성
어머니 : 신사임당, 아버지 : 이원수, 본인 : 이이
어머니 : 백두산, 아버지 : 한강, 본인 : 대한민국
다이아 몬드 상속
a클래스를
b와 c가 상속받고
b와 c를 d가 상속받는 모양
class A:
def __init__(self):
print("A 클래스의 생성자 호출!")
class B(A):
def __init__(self):
print("B 클래스의 생성자 호출!")
A.__init__(self)
class C(A):
def __init__(self):
print("C 클래스의 생성자 호출!")
A.__init__(self)
class D(B, C):
def __init__(self):
print("D 클래스의 생성자 호출!")
B.__init__(self)
C.__init__(self)
o1 = D()
==========출력==========
D 클래스의 생성자 호출!
B 클래스의 생성자 호출!
A 클래스의 생성자 호출!
C 클래스의 생성자 호출!
A 클래스의 생성자 호출!
문제점 발생 A를 두번 생성하는 문제가 발생함
super() 함수를 작성하면 해결
super()는 부모 클래스의 객체를 반환
super()사용시 init(self) x init()으로 사용
class A:
def __init__(self):
print("A 클래스의 생성자 호출!")
class B(A):
def __init__(self):
print("B 클래스의 생성자 호출!")
super().__init__()
class C(A):
def __init__(self):
print("C 클래스의 생성자 호출!")
super().__init__()
class D(B, C):
def __init__(self):
print("D 클래스의 생성자 호출!")
super().__init__()
o1 = D()
==========출력==========
D 클래스의 생성자 호출!
B 클래스의 생성자 호출!
C 클래스의 생성자 호출!
A 클래스의 생성자 호출!
class ca:
def __init__(self, a):
self.t = []
for i in a:
self.t.append(int(i))
class cb(ca):
def __init__(self, a):
super().__init__(a)
self.s = sum(self.t)
def pr(self):
print(f"{self.t} 합계 : {self.s}")
class cc(cb):
def __init__(self, a, b):
super().__init__(a)
c = []
for i in self.t:
c.append(i+b)
self.t = c
self.s = sum(self.t)
o1 = cc("2897756",10)
o1.pr()
상속문제
class Order:
def __init__(self, a,b):
self.name = a
self.price = b
def priceout(self):
return self.price
def info(self):
print(self.name,self.price,self.priceout())
class OnlineOrder(Order):
def priceout(self):
if self.price >= 20000:
return self.price
else:
return self.price+3000
class StoreOrder(Order):
def priceout(self):
return int(self.price*1.1)
class MemberOreder(Order):
def priceout(self):
return int(self.price*0.8)
data = [[0,"가방",3000],[0,"쇼핑백",5000],[0,"커피",3000],
[1,"스웨터",20000],[2,"컴퓨터",50000],
[0,"마우스",12000],[1,"키보드",7000],[2,"휴대폰",30000],
[1,"자전거",20000]
]
orders = []
for i in data:
if i[0]==0:
orders.append(OnlineOrder(i[1],i[2]))
elif i[0]==1:
orders.append(StoreOrder(i[1],i[2]))
elif i[0]==2:
orders.append(MemberOreder(i[1],i[2]))
def pr():
for i in orders:
i.info()
def total():
s=0
for i in orders:
s+=i.priceout()
return s
summary = {"O":[0,0,[]],"S":[0,0,[]],"M":[0,0,[]]}
def sums():
for i in orders:
if isinstance(i,OnlineOrder):
summary["O"][0]+=1
summary["O"][1]+=i.priceout()
summary["O"][2].append(i.name)
if isinstance(i,StoreOrder):
summary["S"][0]+=1
summary["S"][1]+=i.priceout()
summary["S"][2].append(i.name)
if isinstance(i,MemberOreder):
summary["M"][0]+=1
summary["M"][1]+=i.priceout()
summary["M"][2].append(i.name)
print(summary)
def maxorder():
m = orders[0].priceout()
c = None
for i in orders:
if i.priceout() > m:
m = i.priceout()
c = i
return c
maxorder().info()
영화
class Movies:
def __init__(self, a,b):
self.title = a
self.score = b
class Action(Movies):
def __init__(self, a,b,c):
super().__init__(a,b)
self.num = c
def pr(self):
print(self.title,self.score,self.num)
class Drama(Movies):
def __init__(self, a,b,c):
super().__init__(a,b)
self.num = c
def pr(self):
print(self.title,self.score,self.num)
class Horror(Movies):
def __init__(self, a,b,c):
super().__init__(a,b)
self.num = c
def pr(self):
print(self.title,self.score,self.num)
class Cinema:
def __init__(self):
self.ms = [Action("ABC",8,30),
Action("ASD",9,40),
Drama("WFT",7,60),
Horror("YGT",6,20)]
self.ranks = []
def pr(self):
for i in self.ms:
i.pr()
def total(self):
s = 0
for i in self.ms:
s+=i.num
print(s)
def rank(self):
for i in self.ms:
self.ranks.append(i.score)
self.ranks.sort(reverse=True)
def ran(self, a):
print(self.ranks[a-1])
def ts(self):
for i in self.ms:
print(i.title, i.score*i.num)
kor = Cinema()
kor.ts()
■ 2월 6일 - 8일차
○ 컴포지션
컴포지션(Composition)은 클래스 안에 다른 클래스를 속성으로 포함하여 기능을 위임하거나 조합하는 방식
목적: 재사용성, 유연성, 결합도 최소화, 변경에 강한 구조
올바른 컴포지션 설계
클래스 분리 구조
Student: 이름, 번호 등 기본 정보
Grade: 과목별 점수 관리
GradeCalculator: 평균 및 통계 계산
타입힌트
변수의 예상타입이 무엇인지 눈으로 확인하면서 사용할때 착오를
일으키지 않으려고 작성해주는 것으로 권장됨
타입힌트가 특정 데이터 타입이라고 하더라도
다른 데이터를 저장하는 데는 문제 없음
class Grade:
def __init__(self, korean: int, math: int):
self.korean = korean
self.math = math
class Student:
def __init__(self, name: str, grade: Grade):
self.name = name
self.grade = grade
함수 타입힌트
def greet(name: str) -> str:
return f"Hello, {name}!"
주소 체계 연습
class Address:
def __init__(self, city: str, street: str):
self.city = city
self.street = street
def show(self):
return f"{self.city}시, {self.street}길"
class Person:
def __init__(self, name: str, address: Address):
self.name = name
self.address = address # 포함 (Composition)
def introduce(self):
print(f"저는 {self.name}입니다. 주소는 {self.address.show()} 입니다.")
# 실습
addr = Address("서울", "강남대로")
p = Person("홍길동", addr)
p.introduce()
컴포지션 예시
class Grade:
def __init__(self, korean, math):
self.korean = korean
self.math = math
def average(self):
return (self.korean + self.math) / 2
class Student:
def __init__(self, name, grade: Grade):
self.name = name
self.grade = grade
def show_info(self):
print(f"{self.name} 평균: {self.grade.average()}")
g = Grade(85, 90)
s = Student("홍길동", g)
s.show_info()
컴포지션의 장점
책임 분리 : 각 클래스가 자신의 역할만 수행
확장 가능성 : 새로운 과목이 생겨도 Grade만 수정
유닛 테스트 용이 : Grade만 따로 테스트 가능
구조적 유연성 : 다양한 객체를 재조합할 수 있음
다형성 활용 용이 : 포함된 클래스만 바꿔서 기능 변화 가능
○ 람다함수
*익명 함수(anonymous function)
lambda 매개변수: 반환값
f = lambda x: x + 1
print(f(3)) # ➜ 4
#동일
def f(x):
return x + 1
- map(function, iterable)
각 요소에 함수를 적용해 새로운 반복 가능한 객체를 반환
보통 lambda와 함께 많이 사용
map(함수, 리스트)
nums = [1, 2, 3, 4]
result = list(map(lambda x: x * 2, nums))
print(result) # ➜ [2, 4, 6, 8]
- filter(function, iterable)
조건에 맞는 요소만 걸러내는 함수
True를 반환하는 요소만 남긴다
filter(조건 함수, 리스트)nums = [1, 2, 3, 4, 5, 6]
result = list(filter(lambda x: x % 2 == 0, nums))
print(result) # ➜ [2, 4, 6]
실습
3이하 이름만 걸러내기
names = ["길동", "이순신", "강", "정몽주"]
short_names = list(filter(lambda x: len(x) <= 3, names))
print(short_names) # ➜ ['길동', '강']
점수 리스트에서 60점 이상이면 "pass", 미만이면 "fail" (map)
scores = [45, 67, 80, 59, 90]
result = list(map(lambda x: "pass" if x >= 60 else "fail", scores))
print(result) # ➜ ['fail', 'pass', 'pass', 'fail', 'pass']
map() + filter() 동시 사용 가능
nums = [1, 2, 3, 4, 5, 6]
# 짝수만 골라서 제곱
result = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, nums)))
print(result) # ➜ [4, 16, 36]
람다 연습
○ 주문
orders = [
{"id": 1, "price": 12000, "status": "PAID"},
{"id": 2, "price": 8000, "status": "CANCEL"},
{"id": 3, "price": 25000, "status": "PAID"},
{"id": 4, "price": 15000, "status": "PAID"},
{"id": 5, "price": 5000, "status": "CANCEL"},
]
filter — 취소 주문 제거
paid_orders = list(
filter(lambda o: o["status"] == "PAID", orders)
)
map — 배송비 계산해서 새 데이터 생성
20000원 이상: 배송비 0
그 외: 배송비 3000
with_shipping = list(
map(
lambda o: {
"id": o["id"],
"price": o["price"],
"shipping": 0 if o["price"] >= 20000 else 3000
},
paid_orders
)
)
filter — 무료배송 주문만 추출
free_shipping = list(
filter(lambda o: o["shipping"] == 0, with_shipping)
)
map — 주문 번호만 뽑기
free_ids = list(
map(lambda o: o["id"], free_shipping)
)
map + sum — 총 결제 금액 계산
total_price = sum(
map(lambda o: o["price"], paid_orders)
)
○ 지하철 이용기록
records = [
{"name": "kim", "line": "2호선", "hour": 8, "transfer": True},
{"name": "lee", "line": "9호선", "hour": 7, "transfer": False},
{"name": "park", "line": "1호선", "hour": 9, "transfer": True},
{"name": "choi", "line": "2호선", "hour": 10, "transfer": False},
{"name": "jung", "line": "7호선", "hour": 8, "transfer": False},
]
filter — 출근 시간대만 선택 (7~9시)
morning = list(
filter(lambda r: 7 <= r["hour"] <= 9, records)
)
filter — 환승 없는 이용만 선택
no_transfer = list(
filter(lambda r: not r["transfer"], morning)
)
map — 이용 노선만 추출
lines = list(
map(lambda r: r["line"], no_transfer)
)
filter — 특정 노선만 선택 (2호선)
line2 = list(
filter(lambda r: r["line"] == "2호선", records)
)
map + len — 이용 횟수 계산
count_2 = len(
list(filter(lambda r: r["line"] == "2호선", records))
)
○ 헬스장 회원
logs = [
["kim", "Mon", 7, 60],
["lee", "Mon", 19, 50],
["park", "Tue", 8, 40],
["kim", "Tue", 21, 30],
["choi", "Wed", 6, 70],
["jung", "Wed", 20, 20],
["lee", "Thu", 7, 55],
["park", "Fri", 18, 80],
]
“출근 시간대(6~9시) 방문 기록”만 뽑기
morning2 = list(filter(lambda r: 6 <= r[2] <= 9, logs))
print(morning2)
“이름만 뽑기”를 map으로
names = list(map(lambda r: r[0], logs))
print(names)
“체류시간만 뽑아서 총합”을 map + sum
total_stay = sum(map(lambda r: r[3], logs))
print(total_stay)
(사번, 부서, 출근시각, 퇴근시각, 월급 compiler(만원), 남은휴가일수, 재택여부)
data = [
("E01","DEV", 9, 18, 480, 12, False),
("E02","HR", 10, 19, 380, 5, False),
("E03","DEV", 8, 17, 520, 2, True),
("E04","SALES", 9, 20, 410, 8, False),
("E05","DEV", 11, 21, 600, 0, False),
("E06","HR", 9, 17, 360, 15, True),
]
재택(True) 직원만 추출
q1 = list(filter(lambda x: x[6] == True, data))
print(q1)
남은 휴가가 1일도 없는(0) 직원의 사번
q2 = list(map(lambda x: x[0], filter(lambda x: x[5] == 0, data)))
각 직원의 “근무시간(out-in)” 리스트
q3 = list(map(lambda x: x[3] - x[2], data))
월급이 500 이상(만원)인 직원의 (사번, 월급)만 추출하시오.
q4 = list(map(lambda x: (x[0], x[4]), filter(lambda x: x[4] >= 500, data)))
DEV 부서 직원들의 월급 총합
q5 = sum(map(lambda x: x[4], filter(lambda x: x[1] == "DEV", data)))
“9시 이전 출근” AND “휴가 3일 이하” 직원의 사번
q6 = list(map(lambda x: x[0], filter(lambda x: x[2] < 9 and x[5] <= 3, data)))
■ 2월 9일 - 9일차
재귀 함수
정의 단계에서 자신을 재 참조하는 함수
함수내부에서 자기 자신을 실행
예시 n! = 1 * 2 * 3 * (n-1) * n*
재귀형태 Factorial n! = n * (n-1)!
0! = 1
def factorial1(n):
a = 1
for i in range(1, n+1):
a*=i
return a
def factorial2(n):
if n==0:
return 1
else:
return n * factorial2(n-1)
print(factorial1(10))
print(factorial2(10))
==========출력==========
3628800
3628800
피보나치 수열 간단히
첫달에는 새로태어난 토끼한쌍이 존재
두달 이상 되야 토끼번식
그다음 토끼 한쌍은 새끼 한쌍 번식 총 두쌍
네번째 달은 3쌍
다섯번째 달은 5쌍
피보나치 수열은 1:1.6의 황금비를 갖추고 있다.
재귀함수 피보나치 수열
나뭇가지의 개수, 꽃잎의 개수
f(1) = 1
f(2) = 1
f(n) = f(n-1)+f(n-2)
예 f(3) = 2, f(4) = 3, f(5) = 5, 8, 13, 21
def f(n):
if n==1 or n==2:
return 1
else:
return f(n-1) + f(n-2)
for i in range(1,10):
print(f"f({i}) = {f(i)}")
print(f(35))
==========출력==========
f(1) = 1
f(2) = 1
f(3) = 2
f(4) = 3
f(5) = 5
f(6) = 8
f(7) = 13
f(8) = 21
f(9) = 34
9227465
느려짐 오래걸림
몇번을 계산하는지 확인
트리형태로 계산
c = 0
def f(n):
global c
c += 1
if n==1 or n==2:
return 1
else:
return f(n-1) + f(n-2)
# for i in range(1,10):
# print(f"f({i}) = {f(i)}")
print(f(33))
print(c)
print(f(34))
print(c)
print(f(35))
print(c)
==========출력==========
3524578
7049322
5702887
18455095
9227465
36910024
메모화 기술로 변경가능
한번계산했던 것을 다시 계산하지 않고
메모했던것을 확인
m = {1:1,2:1}
def f(n):
if n in m:
return m[n]
else :
op = f(n-1) + f(n-2)
m[n] = op
return op
print(f(100))
print(m)
==========출력==========
354224848179261915075
{1: 1, 2: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34, 10: 55, 11: 89, 12: 144, 13: 233, 14: 377, 15: 610
중첩 리스트 합계
def sum_nested(data):
total = 0
for x in data:
if isinstance(x, list):
total += sum_nested(x)
else:
total += x
return total
print(sum_nested([1, [2, 3], [4, [5, 6]]]))
상호 재귀(Mutual Recursion)
홀수/짝수 판별
def is_even(n):
if n == 0:
return True
return is_odd(n-1)
def is_odd(n):
if n == 0:
return False
return is_even(n-1)
print(is_even(10))
print(is_even(7))
print(is_odd(7))
재귀로 문자열 뒤집기
def reverse_str(s):
if s == "":
return ""
return reverse_str(s[1:]) + s[0]
print(reverse_str("recursion"))
# noisrucer
재귀로 숫자 그림 그리기
def draw(n):
if n == 0:
return
print("■" * n)
draw(n-1)
print("■" * n)
draw(4)
""" 출력
■■■■
■■■
■■
■
■
■■
■■■
■■■■
"""
재귀로 모든 경우의 수 만들기 (비밀번호/조합)
def make_pw(chars, length, cur=""):
if len(cur) == length:
print(cur,end=" ")
return
for c in chars:
make_pw(chars, length, cur + c)
make_pw(["A", "B", "C","D","E"], 3,"가")
"""
가AA 가AB 가AC 가AD 가AE 가BA 가BB 가BC 가BD 가BE 가CA 가CB 가CC 가CD 가CE 가DA 가DB 가DC 가DD 가DE 가EA 가EB 가EC 가ED 가EE
"""
계산기 만들기
def calc(expr):
if "+" not in expr:
return int(expr)
left, right = expr.split("+", 1) # 스필릿으로 1번만 나누기
return int(left) + calc(right)
print(calc("1+2+3+4+5"))
조기리턴
기본적으로 리턴을 뒤에다 쓰는 경우가 있는데
그러면 점점 Tap이 늘어서 식을 쓰는데 보여지는게 복잡하다.
그로인해 조기 리턴을 사용하는 식이 클린 식으로 여겨진다.
m = {1:1,2:1}
def f(n):
if n in m:
return m[n]
op = f(n-1) + f(n-2)
m[n] = op
return op
print(f(100))
print(m)
예제 리스트 평탄화
리스트를 가지고 함수를 사용하여
1차원으로 평탄화
힌트
type([]) == list
ㅣ = [[1,2,3],[4,[5,6]],7,[8,9,[10,11,12]]]
def f(a12):
op = []
for i in a12:
if type(i) == list:
# op += f(i) #리스트가 온다 자기자신
op.extend(f(i))
else:
op.append(i)
# op += [i]
return op
l = [[1,2,3],[4,[5,6]],7,[8,9,[10,11,12]]]
print("원본 : ", l)
print("변환 : ", f(l))
==========출력==========
원본 : [[1, 2, 3], [4, [5, 6]], 7, [8, 9, [10, 11, 12]]]
변환 : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
■ 제너레이터
파이썬에서 제너레이터는 여러 개의 데이터를
미리 만들어 놓지 않고 필요할 때마다 즉석해서 하나씩 만들어낼 수 있는 객체
이터레이터를 만드는 방법
Iterable(이터러블): for에 넣을 수 있는 것. iter(x)가 되는 것(예: list, tuple, dict, set, str, range)
Iterator(이터레이터): next()가 되는 것. __next__를 가진 객체
Generator(제너레이터): 파이썬이 yield로 만들어주는 특수한 iterator (가장 흔한 iterator 형태)
○ yield 키워드
함수가 값을 return으로 끝내는 대신,
값을 한 번 내보내고 멈췄다가(상태를 저장한 채) 다시 이어서 실행 하게 만드는 키워드
def return_value():
return list("ABCDE")
def yield_value():
for char in "ABCDE":
yield char
print(return_value())
print(list(yield_value()))
- 리스트와 제너레이터 차이
리스트: 생성 시점에 비용(시간/메모리) 확정
제너레이터: 소비 시점에 비용이 분산, 메모리 거의 안 씀
- 제너레이트 함수
def squares(n):
for i in range(n):
yield i*i
print(list(squares(5))) # Output: [0, 1, 4, 9, 16]
# 나오는 형식
# 먼저 0 출력 하고 다음 i=0 자기스스로 곱함
# 그 다음 1 출력 하고 i=1 자기스스로 곱함
# 이런식으로 n-1까지 반복
- 제너레이트 표현식
제너레이터는 한 번 소비되면 재사용할 수 없다
def squares(n):
for i in range(n):
yield i*i
a = (i for i in squares(5))
print(list(a))
print(list(a))
# 이것은 빈 리스트를 출력
- yield과 return의 관계
제너레이터 함수에서 return은 “값 반환”이 아니라 제너레이터 종료 신호
def gen():
yield 1
return
yield 2 # 도달 불가
for value in gen():
print(value) # 출력: 1
-yield from()
from은 제너레이터 안에서 다른 제너레이터를 호출할 때 사용된다.
이를 통해 코드가 더 간결해지고 가독성이 향상된다.
def a():
yield 1
yield 2
def b():
yield 10
yield from a()
yield 20
print(list(b())) # [10, 1, 2, 20]
def c():
yield 100
yield from b()
yield 30
print(list(c())) # [100, 10, 1, 2, 20, 30]
- next() 할 때 실행 시작/재개
def g():
print("A")
yield 1
print("B")
yield 2
print("C")
it = g()
print(it) # generator object
print(next(it)) # A 출력 후 1
print(next(it)) # B 출력 후 2
def f():
yield 10
yield 20
yield 30
g = f()
print(next(g)) # Outputs: 10
print(next(g)) # Outputs: 20
print(next(g)) # Outputs: 30
# next(g)는 f()의 yield 문에서 값을 하나씩 반환
# 더 이상 반환할 값이 없으면 StopIteration 예외가 발생
send()는 제너레이터를 값을 꺼내는 반복자에서
외부 입력을 받는 상태 머신으로 바꿉니다.
핵심은 yield가 내보내’이면서 동시에 받기 자리
x = yield out
# out : 바깥으로 나가는 값(외부가 받는 값)
# x : 다음에 외부가 send(값)로 넣어주는 값이 들어오는 자리def g():
x = yield 1
yield x
it = g()
print(next(it)) # 1 (첫 yield까지 진입)
print(it.send(10)) # x=10 → 다음 yield 값 10
#print(it.send(20)) # StopIteration 예외 발생 (제너레이터 종료)
작동원리는 무한히 반복되는 while 루프 안에서
yield 문을 통해 현재 누적 합계를 반환하고,
send() 메서드를 통해 외부로부터 값을 받아와서
누적 합계에 더하는 방식입니다.
None이 전달되면 루프가 종료됩니다.
def accu():
total = 0
while True:
x = yield total
if x is None:
break
total += x
it = accu()
print(next(it)) # 0
print(it.send(5)) # 5
print(it.send(3)) # 8
print(it.send(10)) # 18
it.send(None) # 종료
def string_accu():
result = ""
while True:
s = yield result
if s is None:
break
result += s
str_it = string_accu()
print(next(str_it)) # ""
print(str_it.send("Hello")) # "Hello"
print(str_it.send(", ")) # "Hello, "
print(str_it.send("World")) # "Hello, World"
print(str_it.send(None)) # 종료
def list_accu():
items = []
while True:
item = yield items
if item is None:
break
items.append(item)
return items
list_it = list_accu()
print(next(list_it)) # []
print(list_it.send(1)) # [1]
print(list_it.send(19)) # [1, 19]
print(list_it.send(29)) # [1, 19, 29]
print(list_it.send(22)) # [1, 19, 29, 22]
print(list_it.send(None)) # 종료
- clear() 제너레이터 강제 종료
def bat(n):
buf = []
while True:
item = yield None # 여기서는 밖으로 특별히 줄 값이 없으니 None
if item is None:
if buf:
yield buf[:] # 남은 것 flush
return
buf.append(item)
if len(buf) == n:
yield buf[:] # 한 배치 방출
buf.clear() #제너레이터 강제 종료 시
it = bat(3)
next(it) # 첫 yield(None) 대기 상태
print(it.send("a")) # None
print(it.send("b")) # None
print(it.send("c")) # ['a','b','c'] (배치 방출)
next(it) # 다시 입력 대기(yield None)로 맞춰줌(중요)
- 시뮬레이션 시간 흐름 외부 개입
def simulator():
time = 0
speed = 1
while True:
cmd = yield (time, speed)
if isinstance(cmd, int): # 속도 변경
speed = cmd
time += speed
it = simulator()
print(next(it)) # (0, 1)
print(next(it)) # (1, 1)
print(next(it)) # (2, 1)
print(it.send(5)) # 속도 개입 → (3, 5)
print(next(it)) # (8, 5)
print(next(it)) # (13, 5)
- 출력 모드가 바뀌는 제너레이터
def mode_printer():
mode = "normal"
n = 0
while True:
cmd = yield
if cmd in ("normal", "square", "cube"):
mode = cmd
else:
if mode == "normal":
print(n)
elif mode == "square":
print(n * n)
elif mode == "cube":
print(n ** 3)
n += 1
it = mode_printer()
next(it)
it.send(None) # 0
it.send(None) # 1
it.send("square")
it.send(None) # 4
it.send(None) # 9
it.send("cube")
it.send(None) # 27
- 대화 상대처럼 사용
def interviewer():
answer = yield "이름은?"
age = yield f"{answer}님, 나이는?"
height = yield f"{answer} ({age}) 키는?"
yield f"{answer} ({age}) 키는 {height} 등록 완료"
it = interviewer()
print(next(it)) # 이름은?
print(it.send("홍길동")) # 홍길동님, 나이는?
print(it.send(30)) # 홍길동 (30) 키는?
print(it.send(170)) # 홍길동 (30) 키는 170 등록 완료
- 이벤트만 개입
def counter():
n = 0
paused = False
while True:
cmd = yield n
if cmd == "pause":
paused = True
elif cmd == "resume":
paused = False
if not paused:
n += 1
it = counter()
print(next(it)) # 0
print(next(it)) # 1
print(it.send("pause")) # 2
print(next(it)) # 2
print(next(it)) # 2
print(it.send("resume")) # 2
print(next(it)) # 3
여러 변수를 가진 클래스
__iter__ 순회할 수 있게 만듬
class Data:
def __init__(self):
self.x = 10
self.y = 20
self.z = 30
def __iter__(self):
yield self.x
yield self.y
yield self.z
"""def __iter__(self): 또는
return iter((self.x, self.y, self.z))"""
data = Data()
print(list(data)) # Output: [10, 20, 30]
for v in data:
print(v)
# Output: 10, 20, 30
__getitem__
이 객체를 인덱스로 접근 가능하게 만드는 장치
class Data:
def __init__(self):
self.x = 10
self.y = 20
self.z = 30
def __iter__(self):
yield self.x
yield self.y
yield self.z
def __getitem__(self, index):
if index == 0:
return self.x
elif index == 1:
return self.y
elif index == 2:
return self.z
else:
raise IndexError
data = Data()
print(list(data)) # Output: [10, 20, 30]
print(data[1]) # Output: 20
__setitem__
인덱스로 값을 변경할 수 있게 만드는 장치
class Data:
def __init__(self):
self.x = 10
self.y = 20
self.z = 30
def __iter__(self):
yield self.x
yield self.y
yield self.z
def __getitem__(self, index):
if index == 0:
return self.x
elif index == 1:
return self.y
elif index == 2:
return self.z
else:
raise IndexError
def __setitem__(self, index, value):
if index == 0:
self.x = value
elif index == 1:
self.y = value
elif index == 2:
self.z = value
data = Data()
data[1] = 40
print(list(data)) # Output: [10, 40, 30]
__len__
len()으로 호출될 때 자동으로 실행되는 메서드입니다.
class Data:
def __init__(self):
self.x = 10
self.y = 20
self.z = 30
def __len__(self):
return 3
__contains__
in 연산자가 호출될 때 실행
class Data:
def __init__(self):
self.x = 10
self.y = 20
self.z = 30
def __contains__(self, value):
return value == self.x or value == self.y or value == self.z
d = Data()
print(20 in d) # True
print(99 in d) # False
- __getitem__에서 슬라이싱 처리
class Data:
def __init__(self):
self.x = 10
self.y = 20
self.z = 30
def __getitem__(self, key):
values = (self.x, self.y, self.z)
if isinstance(key, slice):
return values[key] # 튜플 슬라이싱 재사용
else:
return values[key]
d = Data()
print(d[0]) # 10
print(d[1:3]) # (20, 30)
필드개수가 가변인 컨테이너 클래스
class FieldSeq:
def __init__(self, **kwargs):
# 예: FieldSeq(x=10, y=20, z=30)
self._fields = []
for k, v in kwargs.items():
self._fields.append(k)
setattr(self, k, v)
# ---- 시퀀스처럼 보이게 만드는 핵심들 ----
def __len__(self):
return len(self._fields)
def __iter__(self):
for name in self._fields:
yield getattr(self, name)
def __getitem__(self, key):
if isinstance(key, slice):
# slice면 "값의 튜플"로 반환 (새 객체로도 가능)
names = self._fields[key]
return tuple(getattr(self, n) for n in names)
name = self._fields[key]
return getattr(self, name)
def __setitem__(self, index, value):
name = self._fields[index]
setattr(self, name, value)
def __contains__(self, value):
for name in self._fields:
if getattr(self, name) == value:
return True
return False
# ---- "동적 속성 연결" 기능 ----
def add_field(self, name, value=None):
# 새로운 변수를 동적으로 추가하고 시퀀스 연결에 포함
if name in self._fields:
raise ValueError("field already exists")
self._fields.append(name)
setattr(self, name, value)
def fields(self):
return tuple(self._fields)
d = FieldSeq(x=10, y=20)
print(d.fields()) # ('x', 'y')
print(len(d)) # 2
print(d[0]) # 10
print(list(d)) # [10, 20]
print(20 in d) # True
d.add_field("z", 30)
print(d.fields()) # ('x', 'y', 'z')
print(d[1:3]) # (20, 30)
d[0] = 99
print(d.x) # 99
-
class OrderBook:
def __init__(self, orders):
self.orders = list(orders)
def __iter__(self):
# 가격이 10000 이상인 것만, 이름 기준으로 정렬해서 순회
for name, price in sorted(self.orders, key=lambda x: x[0]):
if price >= 10000:
yield (name, price)
def add(self, value):
self.orders.append(value)
def delete(self, value):
self.orders.remove(next(filter(lambda x: x[0]==value, self.orders)))
def random_add(self):
import random
items = [("헤드셋", 30000), ("스피커", 50000), ("웹캠", 40000), ("USB허브", 15000)]
self.orders.append(random.choice(items)) #.choice는 리스트에서 랜덤으로 하나 뽑아줌
ob = OrderBook([("키보드", 7000), ("마우스", 12000), ("모니터", 200000)])
for o in ob:
print(o)
ob.add(("가방",2000)) #가격이 10000 미만이므로 출력 안됨
ob.add(("노트북",150000))
print(list(ob))
ob.delete("마우스")
print(list(ob))
ob.random_add()
ob.random_add()
print(list(ob))
#=== 출력 ====
#('마우스', 12000)
#('모니터', 200000)
#[('노트북', 150000), ('마우스', 12000), ('모니터', 200000)]
#[('노트북', 150000), ('모니터', 200000)]
#[('USB허브', 15000), ('노트북', 150000), ('모니터', 200000), ('웹캠', 40000)]
결석등
class Attendance:
def __init__(self, rows):
# rows: (name, absent, late, missing_hw, mid, final)
self.rows = [self._normalize(r) for r in rows]
def _normalize(self, r):
name, absent, late, missing_hw, mid, final = r
return {
"name": name,
"absent": int(absent),
"late": int(late),
"missing_hw": int(missing_hw),
"mid": float(mid),
"final": float(final),
}
# ---- 핵심: 리스크 스코어(설계 규칙) ----
def risk_score(self, rec):
# 결석 1회 = 3점, 지각 1회 = 1점, 과제 미제출 1회 = 2점
# 점수(중간/기말 평균)가 낮으면 추가 패널티
score = rec["absent"] * 3 + rec["late"] * 1 + rec["missing_hw"] * 2
avg = (rec["mid"] + rec["final"]) / 2
if avg < 60:
score += 6
elif avg < 70:
score += 3
return score
def grade_avg(self, rec):
return (rec["mid"] + rec["final"]) / 2
# ---- 1) 기본 iterable: 위험도 높은 순으로 순회 ----
def __iter__(self):
ranked = sorted(self.rows, key=lambda rec: self.risk_score(rec), reverse=True)
for rec in ranked:
yield (rec["name"], self.risk_score(rec), self.grade_avg(rec))
# ---- 2) 위험군 리스트: min_score 이상만, 위험도 낮은 순(요청에 맞춰 정렬 가능) ----
def risk_list(self, min_score, sort="score_asc"):
picked = []
for rec in self.rows:
s = self.risk_score(rec)
if s >= min_score:
picked.append((rec["name"], s, rec["absent"], rec["late"], rec["missing_hw"], self.grade_avg(rec)))
if sort == "score_asc":
return sorted(picked, key=lambda x: x[1]) # 리스크 낮은 순
if sort == "score_desc":
return sorted(picked, key=lambda x: x[1], reverse=True)
if sort == "avg_asc":
return sorted(picked, key=lambda x: x[5]) # 성적 낮은 순
if sort == "absent_desc":
return sorted(picked, key=lambda x: x[2], reverse=True)
return picked # 정렬 옵션이 이상하면 그대로 반환
# ---- 3) 경고 이벤트 스트림: 조건을 만족하는 순간만 방출 ----
def warnings(self):
for rec in self.rows:
s = self.risk_score(rec)
avg = self.grade_avg(rec)
# 경고 기준(예시): 결석 3↑ 또는 리스크 12↑ 또는 평균 60 미만
if rec["absent"] >= 4:
yield (rec["name"], "퇴학 위험", s, avg)
elif rec["absent"] >= 3 or s >= 12 or avg < 60:
yield (rec["name"], "경고", s, avg)
# ---- 4) 한 학생 상세 조회 ----
def detail(self, name):
for rec in self.rows:
if rec["name"] == name:
return {
**rec,
"avg": self.grade_avg(rec),
"risk": self.risk_score(rec),
}
return None
a = Attendance([
("민수", 2, 1, 0, 72, 68),
("지영", 3, 0, 2, 65, 58),
("철수", 4, 2, 1, 55, 50),
("영희", 0, 1, 0, 88, 92),
("준호", 1, 4, 3, 62, 60),
])
# 1) 기본 순회(위험도 높은 순): (이름, 리스크, 평균)
for x in a:
print(x)
print()
# 2) 위험군 리스트: (이름, 리스크, 결석, 지각, 미제출, 평균)
print(a.risk_list(min_score=10, sort="score_asc"))
print()
# 3) 경고 이벤트만 흘려보내기
for w in a.warnings():
print(w)
print()
# 4) 특정 학생 상세
print(a.detail("지영"))
======출력======
('철수', 21, 52.5)
('준호', 13, 61.0)
('지영', 18, 61.5)
('민수', 7, 70.0)
('영희', 0, 90.0)
[('준호', 13, 1, 4, 3, 61.0), ('지영', 18, 3, 0, 2, 61.5), ('철수', 21, 4, 2, 1, 52.5)]
('지영', '경고', 18, 61.5)
('철수', '퇴학 위험', 21, 52.5)
{'name': '지영', 'absent': 3, 'late': 0, 'missing_hw': 2, 'mid': 65.0, 'final': 58.0, 'avg': 61.5, 'risk': 18}
■ 2월 10일 - 10일차
■ 파이썬 엑셀 시작하기
○ 엑셀 편하게 사용는 라이브러리 설치
pip install openpyxl
py -m pip install openpyxl
python -m pip install openpyxl
○ import 하기
import openpyxl as op
○ 새로운 객체 만들기
import openpyxl as op #openpyxl 모듈 import
wb = op.Workbook() #새로운 Workbook 객체 생성
print(wb) #객체를 출력해보기
○ 저장하기
wb.save("openpyxl_test.xlsx")
# 동일폴더
wb.save(r"C:\Users\Desktop\VS CODE\openpyxl_test.xlsx")
# 특정위치
○ 작성하고 저장하기
import openpyxl as op
wb = op.Workbook()
ws = wb.active
ws["a1"].value = "음"
ws["a3"] = "파이썬"
print(wb)
wb.save("sample.xlsx")
○ 값보기
import openpyxl as op #openpyxl 모듈 import
wb = op.load_workbook(r"test.xlsx") #워크북 객체 생성(파일명 : test.xlsx)
ws = wb.active #활성화 되어있는 시트 설정(시트명 : "업")
#방법 1 : Sheet의 Cell 속성 사용하기
data1 = ws.cell(row=1, column=2).value
#방법 2 : 엑셀 인덱스(Range) 사용하기
data2 = ws["B1"].value
○ 불러와서 입력하기
import openpyxl as op
p = r"C:\Users\user\Desktop\web\web\오전\연습.xlsx"
# 파일위치
wb = op.load_workbook(p)
# 파일로드
ws = wb.sheetnames
#시트 이름 가져오기
print(ws)
works = wb[ws[1]]
#1번인덱스 시트를 wortks에 저장
data = works["a5:a10"] #또는 ["a5":"a10"]
#data에 시트안의 a5에서 a10 저장
works["a10"].value = "마지막"
#시트안에 a10에 값을 마지막으로 넣기
a = ["안녕","하세","요"]
for i in range(5,8):
works["a"+str(i)].value = a[i-5]
#a5~a7에 a배열에 있는 값들 한개씩 넣어주기
for i in data:
for j in i:
print(j.value)
■ 범위 가져오기
○ 엑셀 그대로 가져오기
2차원 튜플형식으로 가져옴
cell_range = ws["A1:C5"]
for row in cell_range:
for cell in row:
print(cell.value)
○ 행단위 범위 가져오기
a:5~a:10
for row in ws.iter_rows(min_row=5, max_row=10,
min_col=1, max_col=1):
for cell in row:
print(cell.value)for col in ws.iter_cols(min_col=1, max_col=1,
min_row=5, max_row=10):
for cell in col:
print(cell.value)
data1 = list(work.iter_rows(5,10,1,1))
print(data1[0][0])
for i in data1:
for j in i:
print(j.value)
■ 파이썬 엑셀 시작하기
○ 글자를 입력해서 추가해주는 방법
import openpyxl as op
wb = op.load_workbook("연습.xlsx")
wsn = wb.worksheets[0]
l = [
["사과", "배", "포도", "딸기", "바나나"],
[1000, 2000, 3000, 4000, 5000],
[10, 20, 30, 40, 50],
]
for ix, i in enumerate(l):
for jx, j in enumerate(i):
wsn[f"{chr(74+jx)}{ix+1}"] = j #74는 문자 j
wb.save("연습2.xlsx")○ 가져온것 확인해서 추가하는 방법
import openpyxl as op
wb = op.load_workbook(r"D:\Web\연습.xlsx")
wsn = wb.worksheets[0]
for i in range(3, 16):
a = wsn[f"f{i}"].value
b = wsn[f"g{i}"].value
c = wsn[f"i{i}"].value
if c>=500:
wsn[f"j{i}"] = a * b * 0.5
else:
wsn[f"j{i}"] = a * b
wb.save("연습2.xlsx")
■ 판다스
pip install pandas
py -m pip install pandas
import pandas as pd
df1 = pd.DataFrame( [[30,180,300], [28,162,200],[31,172,500]], index=["홍길동", "백두산", "이순신"], columns=["나이", "키", "월급"])
s1 = df1["나이"] # 시리즈
s2 = df1["키"]
s3 = df1["월급"]
print(df1)
print(s1)
print(s1[1])
==========출력==========
홍길동 30 180 300
백두산 28 162 200
이순신 31 172 500
홍길동 30
백두산 28
이순신 31
Name: 나이, dtype: int64
28
엑셀파일 불러오기
xlrd가 업데이트 되면서 xlsx 지원이 안됨
pip install openpyxl 다운
import pandas as pd
df1 = pd.read_excel(r"D:\Web\연습.xlsx", engine="openpyxl")
print(df1)
인덱스 값 변화
import pandas as pd
df1 = pd.read_excel('test1.xlsx', engine="openpyxl").set_index("이름")
print(df1)
==========출력==========
국어 영어 수학 과학
이름
강동원 63 93 67 71
송중기 89 83 71 80
기태영 83 76 92 98
김남길 94 88 73 93
류준열 71 83 80 88
박성균 67 87 92 90
import pandas as pd
df1 = pd.read_excel('test1.xlsx', engine="openpyxl").set_index("이름")
dfv = df1.values
dfi = df1.index
dfc = df1.columns
print(df1)
print(dfv)
print(dfv[0][0])
print(dfi)
print(dfi[1])
print(dfc)
print(dfc[0])
==========출력==========
국어 영어 수학 과학
이름
강동원 63 93 67 71
송중기 89 83 71 80
기태영 83 76 92 98
김남길 94 88 73 93
류준열 71 83 80 88
박성균 67 87 92 90
[[63 93 67 71]
[89 83 71 80]
[83 76 92 98]
[94 88 73 93]
[71 83 80 88]
[67 87 92 90]]
63
Index(['강동원', '송중기', '기태영', '김남길', '류준열', '박성균'], dtype='object', name='이름')
송중기
Index(['국어', '영어', '수학', '과학'], dtype='object')
국어
시트 확인
import pandas as pd
path = r"D:\Web\ai\webdesignuiux\연습.xlsx"
xls = pd.ExcelFile(path, engine="openpyxl")
print(xls.sheet_names)
해당시트 가져오기
import pandas as pd
path = r"D:\연습.xlsx"
df = pd.read_excel(
path,
sheet_name="매출",
engine="openpyxl"
)
딕셔너리로 가져오기
import pandas as pd
path = r"D:\연습.xlsx"
dfs = pd.read_excel(
path,
sheet_name=None,
engine="openpyxl"
)
print(dfs.keys()) # 시트 이름들
print(dfs["매출"]) # 특정 시트 DataFrame
열이름 지정해서 데이터 보기
import pandas as pd
df1 = pd.read_excel(r"D:\연습.xlsx", engine="openpyxl", sheet_name=None)
print(df1['1번'][0:1]) #1번 시트의 첫 번째 행 출력
print(df1['1번'].columns) #1번 시트의 열 이름 출력
print(df1['1번']['Unnamed: 3']) #1번 시트의 'Unnamed: 2' 열 출력
특정 셀값 수정
(이렇게 해야 안정적임)
df.loc[0, "가격"] = 9999 # 1행 가격 수정
df.loc[3, "상품명"] = "특가상품"
수정시 패턴
#허용 권장
df["가격"] = df["가격"] + 1
df["가격"] += 1
df.loc[:, "가격"] += 1
df.loc[조건, "가격"] += 1
#금지
df["가격"][i] += 1
df["가격"].iloc[i] += 1
df["가격"]["some_index"] += 1
조건 → 특정 컬럼 값 수정
df.loc[df["수량"] >= 10, "가격"] += 100
"""
수량이 10 이상인 행만 골라서
가격 컬럼에 +100
"""
df.loc[df["수량"] >= 10, "총액"] = df["가격"] * df["수량"]
"""
수량이 10이상인 총액에 가격*수량
"""
세로운 셀 만들어서 수정
import pandas as pd
df1 = pd.read_excel(r"D:\연습.xlsx", engine="openpyxl", sheet_name="4번")
df1["전체"] = df1["사용체중"] * df1["각도조절"]
# df1["이거다"] = [10,20] 불가 길이가 맞아야 함
df1["이거다"] = pd.Series([100, 200], index=[0, 2])
print(df1)
df1.to_excel(r"D:\연습2.xlsx", engine="openpyxl", index=False)
데이터 만들어서 저장
import pandas as pd
data = [
{"상품명": "사과", "가격": 1000, "수량": 10},
{"상품명": "배", "가격": 2000, "수량": 5},
{"상품명": "포도", "가격": 3000, "수량": 2},
]
df = pd.DataFrame(data)
# 계산 열 추가
df["총액"] = df["가격"] * df["수량"]
# 저장
out = r"D:\생성.xlsx"
df.to_excel(out, index=False)
import pandas as pd
rows = [
["사과", 1000, 10],
["배", 2000, 5],
["포도", 3000, 2],
]
df = pd.DataFrame(rows, columns=["상품명", "가격", "수량"])
df["총액"] = df["가격"] * df["수량"]
df.to_excel(r"D:\생성.xlsx", index=False)
import pandas as pd
df_item = pd.DataFrame(
[
{"상품명": "사과", "가격": 1000, "수량": 10},
{"상품명": "배", "가격": 2000, "수량": 5},
]
)
df_item["총액"] = df_item["가격"] * df_item["수량"]
df_log = pd.DataFrame(
[
{"시간": "2026-02-10 03:10", "메모": "생성 시작"},
{"시간": "2026-02-10 03:11", "메모": "저장 완료"},
]
)
out = r"D:\여러시트_생성.xlsx"
with pd.ExcelWriter(out, engine="openpyxl") as writer:
df_item.to_excel(writer, sheet_name="매출", index=False)
df_log.to_excel(writer, sheet_name="로그", index=False)
데이터 파일”로 쓸 거면 pandas → to_excel이 가장 빠르고 안정적
기존 서식/수식/병합셀 유지가 목적이면 그때는 openpyxl로
'언어 수업자료 > 파이썬' 카테고리의 다른 글
| Python 25-07 (0) | 2025.07.17 |
|---|---|
| Python 25-01 (0) | 2025.01.14 |
| Python 1 (1) | 2024.06.15 |
| 파이썬 2 (0) | 2024.03.31 |
| Python 2 (0) | 2023.12.23 |