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 : 저장하기
■ 7월 17일 - 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
■ 7월 18일 - 2일차
연산자 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}입니다.')
컬렉션 p39
컬렉션생성함수특징예시
| 리스트 | list() | 추가, 수정, 삭제가 언제나 가능 | a=[1,2,3] |
| 튜플 | tuple() | 생성되고 나면 변경 불가능 | a=(1,2,3) |
| 세트 | set() | 중복된 값의 저장 불가능 | a={1,2,3} |
| 딕셔너리 | dict() | 키+값으로 관리 | a={'age':25} |
조건문 p90
if문 p91
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}입니다.')
■ 7월 21일 - 3일차
반복문 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]
■ 7월 22일 - 4일차
○ 글자를 입력해서 추가해주는 방법
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}개")
컬렉션
컬렉션생성함수특징예시
| 리스트 | 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': '안녕'}
■ 7월 23일 - 5일차
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원, 커피 아메리카노
■ 7월 24일 - 6일차
○ 리스트에서 "예" 또는 "아니오" 응답 비율 반환
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}
○ 과일 정리
과일 출력
과일 구매
총가격
0개 삭제
t = [["사과",10,3000],["배",12,2500],["감",11,2000]]
def pr():
for i in t:
print(f"{i[0]} {i[1]}개 개당 {i[2]}원")
def add(a,b,c):
t.append([a,b,c])
def pur(a,b):
for i in t:
if a == i[0]:
if i[1] < b:
i[1] = 0
else:
i[1]-=b
def total():
a = 0
for i in t:
a += i[1]*i[2]
return a
def dels():
for i in t:
if i[1] == 0:
t.remove(i)
add("수박",6,4000)
pur("감",20)
dels()
pr()
■ 7월 25일 - 7일차
모듈과 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()
■ 7월 28일 - 8일차
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()
■ 7월 29일 - 9일차
최대값 인덱스, 최소값 인덱스에 해당하는 성명 반환
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())
클래스 상속
상속의 의미
부모 클래스의 멤버를 자식클래스가 물려받는것
상속을 받으면 부모에서 사용하던 것을 쓸수 있다.
상속하는 방법
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()
■ 7월 30일 - 10일차
학생관리 클래스
class Student:
def __init__(self,n,k,e,m):
self.name = n
self.grade = [k,e,m]
def get_avg(self):
return round(sum(self.grade) / len(self.grade),2)
def get_grade(self):
if self.get_avg() >= 90:
return "A"
elif self.get_avg() >=80:
return "B"
else:
return "C"
class School:
def __init__(self):
self.students = []
def add(self, a):
self.students.append(a)
def adds(self, *a):
for i in a:
self.students.append(i)
def pr(self):
for i in self.students:
print(i.name, i.grade)
def avgpr(self):
for i in self.students:
print(i.name,i.get_avg(),i.get_grade())
def total_avg(self):
s = 0
for i in self.students:
s+= i.get_avg()
print(f"평균 : {round(s/len(self.students),2)}")
abc = School()
abc.adds(
Student("홍길동",80,87,91),
Student("이순신",86,93,96),
Student("백두산",92,68,98),
Student("한라산",87,88,85),
)
abc.avgpr()
abc.total_avg()
○ 컴포지션
컴포지션(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 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만 따로 테스트 가능
구조적 유연성 : 다양한 객체를 재조합할 수 있음
다형성 활용 용이 : 포함된 클래스만 바꿔서 기능 변화 가능
주소 체계 연습
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 Account:
def __init__(self, balance: int):
self.balance = balance
def deposit(self, amount: int):
self.balance += amount
def withdraw(self, amount: int) -> bool:
if amount <= self.balance:
self.balance -= amount
return True
return False
def get_balance(self) -> int:
return self.balance
class Customer:
def __init__(self, name: str):
self.name = name
self.account = Account(0) # 포함
def show_info(self):
print(f"{self.name}님의 잔액: {self.account.get_balance()}원")
# 실습
c = Customer("이순신")
c.account.deposit(10000)
c.show_info()
○ 딕셔너리 사용법
- get(key, default)
해당 키가 있으면 값을 반환하고, 없으면 default값을 반환
menus = {
"김치찌개": 8000,
"된장찌개": 7500,
"비빔밥": 8500
}
print(menus.get("김치찌개")) # 8000
print(menus.get("순두부찌개")) # None
print(menus.get("순두부찌개", -1)) # -1
- in 연산자
해당 키가 딕셔너리에 존재하는지 확인
if "된장찌개" in menus:
print("메뉴에 있습니다.")
- keys(), values(), items()
설명: 반복문 처리 또는 전체 목록 탐색 시 유용합니다.
print(menus.keys()) # dict_keys(['김치찌개', '된장찌개', '비빔밥'])
print(menus.values()) # dict_values([8000, 7500, 8500])
print(menus.items()) # dict_items([('김치찌개', 8000), ...])
for name, price in menus.items():
print(f"{name}: {price}원")
- del, pop()
항목 삭제
del menus["된장찌개"] # 키가 없으면 오류 발생
menus.pop("비빔밥") # 비빔밥 제거
menus.pop("라면", None) # 라면이 없으면 오류 없이 None 반환
- .copy()
원본 딕셔너리를 보호하기 위한 복사
backup = menus.copy()
- update()
다른 딕셔너리 내용을 합쳐 넣거나, 값을 일괄 수정할 때 사용
menus.update({"김치찌개": 8200}) # 가격 수정
menus.update({"순두부찌개": 7000}) # 새 항목 추가
MenuRepository
class MenuRepository:
"""
이 클래스는 식당의 메뉴와 가격 정보를 저장하고 관리하는 역할을 수행합니다.
메뉴 이름을 key로 하고, 가격을 value로 가지는 딕셔너리를 내부에 보유합니다.
"""
def __init__(self):
# 내부 딕셔너리. 예: {'김치찌개': 8000, '된장찌개': 7000}
self._menus = {}
def add_menu(self, name: str, price: int) -> None:
"""
메뉴를 등록하거나, 이미 존재하는 메뉴가 있다면 가격을 갱신합니다.
:param name: 메뉴 이름 (문자열)
:param price: 메뉴 가격 (정수)
"""
self._menus[name] = price # 딕셔너리에 저장 또는 갱신
def add_menus_bulk(self, menu_dict: dict[str, int]) -> None:
self._menus.update(menu_dict)
"""
메뉴를 딕셔너리로 한번에 추가하기
"""
def get_price(self, name: str) -> int:
"""
특정 메뉴의 가격을 반환합니다.
메뉴가 존재하지 않을 경우 -1을 반환하여 예외 상황을 방지합니다.
dict.get(name, default) 메서드는 파이썬 딕셔너리 내장 함수입니다.
- name: 조회할 key
- default: key가 없을 경우 반환할 기본값
"""
return self._menus.get(name, -1) # 예: '비빔밥'이 없으면 -1 반환
def contains(self, name: str) -> bool:
"""
특정 메뉴가 현재 메뉴 저장소에 존재하는지 여부를 True/False로 반환합니다.
"""
return name in self._menus
def get_all(self) -> dict:
"""
전체 메뉴 정보를 딕셔너리 형태로 복사하여 반환합니다.
외부에서 직접 수정되지 않도록 `.copy()`를 사용합니다.
"""
return self._menus.copy()
OrderItem 클래스
class OrderItem:
def __init__(self, menu: str, count: int, unit_price: int):
# 주문한 메뉴 이름 (예: "김치찌개")
self._menu = menu
# 주문 개수 (예: 2개)
self._count = count
# 메뉴 단가 (예: 8000원)
self._unit_price = unit_price
def get_menu(self) -> str:
"""주문한 메뉴 이름을 반환"""
return self._menu
def get_count(self) -> int:
"""주문 개수를 반환"""
return self._count
def change_count(self, new_count: int):
"""주문 개수를 변경"""
self._count = new_count
def total_price(self) -> int:
"""해당 주문 항목의 총 가격을 계산하여 반환"""
return self._count * self._unit_price
Order 클래스 코드
from typing import Dict
class Order:
def __init__(self):
# 메뉴 이름을 key로 하여 OrderItem을 저장하는 딕셔너리
self._items: Dict[str, OrderItem] = {}
def add_item(self, menu: str, count: int, repository: MenuRepository):
"""메뉴 이름과 수량을 받아 주문 항목을 추가하거나 기존 항목 수량을 증가"""
if repository.contains(menu):
if menu in self._items:
# 이미 존재하는 메뉴면 수량만 증가
item = self._items[menu]
item.change_count(item.get_count() + count)
else:
unit_price = repository.get_price(menu)
self._items[menu] = OrderItem(menu, count, unit_price)
def total_price(self) -> int:
"""전체 주문 금액을 계산"""
return sum(item.total_price() for item in self._items.values())
def summary(self) -> dict:
"""주문 요약 정보를 딕셔너리 형태로 반환"""
return {
item.get_menu(): {
"count": item.get_count(),
"total": item.total_price()
}
for item in self._items.values()
}
def get_items(self) -> list:
"""OrderItem 객체들의 리스트를 반환 (직접 접근할 때 사용)"""
return list(self._items.values())
repo = MenuRepository()
repo.add("김치찌개", 8000)
repo.add("비빔밥", 8500)
order = Order()
order.add_item("김치찌개", 2, repo)
order.add_item("비빔밥", 1, repo)
order.add_item("김치찌개", 1, repo) # 기존 항목에 추가됨
print(order.total_price()) # ➜ 8000×3 + 8500×1 = 30500
print(order.summary())
# ➜ {'김치찌개': {'count': 3, 'total': 24000}, '비빔밥': {'count': 1, 'total': 8500}}
○ 람다함수
*익명 함수(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]
'언어 수업자료 > 파이썬' 카테고리의 다른 글
| Python 26-01(방특) (0) | 2026.01.28 |
|---|---|
| Python 25-01 (0) | 2025.01.14 |
| Python 1 (1) | 2024.06.15 |
| 파이썬 2 (0) | 2024.03.31 |
| Python 2 (0) | 2023.12.23 |