Python 기본 문법
1. 주석 처리
# 한줄 주석
"""
여러줄 주석
"""
'''
여러줄 주석
'''2. 숫자 나열하여 print 시
a=10
b=10
print(a,b)
# 숫자를 나열하고 싶을 때 ,를 사용3. sep, end
a=10
b=20
print(a,b,sep=",")
# sep를 넣어서 두 값 사이에 콤마(,)출력
# sep 인수에 원하는 구분 (separator)를 지정함a=10
b=20
c=30
print(a,b,sep=",",end="====>")
print(c)
# sep는 내용 사이에 삽입합 문자열을
# end는 내용 마지막에 출력할 문자열을 지정
# 결과는 10,20 ====> 30
# print문 2개 작성
# c가 아래로 떨어져야 함, 하지만 end로 인해 밑에 print(c)까지는 가지 않음4. 이스케이프 문자
"""
이스케이프문자 종류
\n : 줄바꿈
\t : 탭 (탭한것 처럼 앞에 공백 갖고 노출)
\b : 백스페이스 # (뒤에서 하나씩 지워짐)
기호로만 쓰고 싶을 때
\\ : \
\' : '
\" : "
"""
# 이스케이프 시퀸스를 따르는 문자들로서 다음 문자가 특수 문자임을 알리는 \사용
print("hello world")
#hello world
print("hello\nworld") #\n 줄바꿈
#hello
#world
print("hello\tworld") #\t 탭
#hello world
print("h\bello world") #\b 백스페이스
#bello world
print("\\helloworld\\") # 기호로
#\helloworld\- 줄바꿈 사용 예시
a = "120"
b = int(a)
print(b,"\n") # 이전에는 "" 안에다가 다 적었지만 이번엔 ,로 끊었기에 ""안에/n 작성
print("테스트")
"""
120
테스트
"""5. 변수 할당
firstNum = 100
nextNum = 2
result = firstNum + nextNum
print("합계=",result)
# 결과변수를 만들어서 값을 출력
# 꼭 변수에 할당을 하고 덧셈뺄셈을 해야함
# 바로 해도 되지만 그건 하드코딩이라 나중에 수정공수가 듦- 지역변수 : 값 대입 시 안에서는 작용하나 그 함수를 벗어나는 순간 소멸
- 전역변수 : 함수 외부에서 선언된 변수로, 프로그램 전체에서 접근 할 수 있음
price = 1000 # 전역변수
def sale():
price=500 # 지역변수
sale()
print(price)- global 변수 사용 시, 전역변수
price = 1000 # 전역변수
def sale():
global price
price=500
sale()
print(price)
# global 변수 사용 시 전역변수로 바뀌면서 전체 적용
# 언어 상관없이 모두 존재
# 지역변수는 선언한 함수 그 안에서만 사용 가능하고 벗어나면 소멸된다
# 맨 처음에 선언된 함수 밖에서 선언되는 함수는 전역함수
# pyhon은 global로 사용- 변수 할당을 통한 계산
A=10
B=3
result = A+B
print(A," + ",B," = ",result)
# 10 + 3 = 13
result = A-B
print(A," - ",B," = ",result)
# 10 - 3 = 7
result = A*B
print(A," x ",B," = ",result)
# 10 X 3 = 30
result = A/B
print(A," / ",B," = ",result)
# 10 / 3 = 3.3333333335
result = A%B
print(A," % ",B," = ",result)
# 10 % 3 = 1
#result의 변수에 값이 덥어씌워지면서 값이 변화- 변수에 직접 논리값 할당 가능
a=True
b=False
print(a and b) # False / and는 둘다 모두 true 여야 참으로 나옴
print (a or b) # True / or는 둘중 하나만 참이여도 참으로 나옴
print(not a) # Flase / true 거짓 임- 변수 할당을 통한 합계, 평균 계산
a = 10
b = 23
c = 31
result = a + b + c
avg = round(result/3,1)
# 반올림 함수 round : 둘째 자리에서 반올림해서 첫째자리까지 노출
print("합계 = ",result)
print("평균 = ",avg)
# 합계 = 64
# 평균 = 21.3
6. 부등호
a=10
b=3
result= a > b # 10보다 3이 크다
print(result)
# True
result= a < b # 3보다 10이 크다
print(result)
# False
result= a >= b # 10은 3보다 크거나 같다
print(result)
# True
result= a <= b # 10은 3보다 작거나 같다
print(result)
# False
result= a == b # 10은 3과 같다
print(result)
# False
result= a != b # 10은 3과 같지 않다
print(result)
# True
"""
=== 는 완벽하게 성립하는 부등호로 알고있는데 python에서는 해당하지 않는다.
== 가 ===의 역할을 할 수 있는 듯 하다
예를들어 true나 false로 값을 반환해주는 듯 하다?
"""
7. 축약형 연산
# 중요한 연산, javascirpt에서도 자주 사용 "축약형 연산"
num1 = 10
num2 = 21
num1 += 5 # num1 = num1 + 의 축약형
print(num1)
# 15
num1 -= 5 # num1 = num1 - 5의 축약형
print(num1)
# 10
num1 *= 5 # num1 = num1 * 5의 축약형
print(num1)
# 50
num1 /= 5 # num1 = num1 / 5의 축약형
print(num1)
# 10
num2 %= 5 # num2 = num2 % 5의 축약형
# % : 나머지 부등호
print(num2)
# 18. 내장된 명령어 호출
# 내장된 명령어 호출 시 import 필요
import math
num3 = 2.4
num3 = math.ceil(num3) #math 안에 있는 함수를 num3안에 적용 시키겠다
print(num3)
"""
`ceil()` 함수는 숫자를 올림하여 가장 큰 정수를 반환. (반올림x)
예를 들어, ceil(2.4)는 3을 반환.
결과는 3
"""import math
num4 = 3.7
num4 = math.floor(num4) # math에 내장된 floor 를 사용하겠다
print(num4)
"""
`floor()` 함수는 숫자를 내림하여 가장 가까운 작은 정수를 반환
예를 들어, floor(3.7)은 3을 반환
해당 함수는 해당 화면에서 벗어나면 바로 짤라야하는
애니메이션 코드를 짜거나 동작하는 프로그램을 코딩 할 때 많이 사용됨
"""9. input 문
# intput 문은 입력 대기상태로 전환
# 하단 터미널에서 입력하면 print가 노출
# enter를 입력하지 않으면 아직까지 값을 받아들이지 않았다고 인식
# 로그인창 만들 때 input 문을 사용함
gender=input("당신의 성별은?")
print("당신의 성별은",gender)
age=input("당신의 나이는?")
print("당신의 나이는",age)
"""
당신의 성별은?여 ('여' 입력)
당신의 성별은 여
당신의 나이는?19 ('19' 입력)
당신의 나이는 19
"""- 입력된 input 값을 문자로 받아 정수로 바꿔서 받기
testNum = int(input("시험점수를 입력하세요?"))
# input값을 문자로 받아 인식을 못해서, 받을 때 정수로 바꿔서 받기
# 그러면 파이썬에서 숫자를 비교 할 수 있음
if testNum >=70:
print("합격")10. IF 문
"""
if 키워드 + 조건문(식) +:(콜론) 순서로 입력
실행할 블록은 띄어쓰기로 구분한다. (파이썬은 띄어쓰기로 블록을 구분한다.)
파이썬은 중괄호가 없음, 대신 띄어쓰기로 표기해서 중요함
"""
"""
# 다른프로그램 if문
if(a>=80){
a += 1}
javascirpt
"""
age = 25
if age>=20: #:는 다음에 무엇을 하겠다라는 뜻으로 자동으로 몇칸 뛰어짐
print("성인입니다")
# 단순 if, 조건식에 맞지않으면 그냥 빠져나감
# 에러날 때 컨트롤+z누르고 나서 다시 실행시키면됨- 입력받은 input 데이터를 통해 If/else 호출
testNum = int(input("시험점수를 입력하세요?"))
# input값을 문자로 받아 인식을 못해서, 받을 때 정수로 바꿔서 받기
# 그러면 파이썬에서 숫자를 비교 할 수 있음
if testNum >=70:
print("합격")
# 첫번째 if문에서 띄어쓰기를 이어받아 입력하면 if문에 이어져서 나오기 때문에 띄어스기 위치 변경 필요
else:
print("불합격")
# 참이 아니면 내용을 수행if : 조건이 참 일때 실행되는 코드 블록 정의
else if : 이전의 if나 else if의 조건이 거짓일 때 다른 조건을 추가로 검사
else : 이전의 if와 else if조건이 거짓일 때 실행되는 코드 블록 정의, 따라서 별도의 조건 없음
elif(python) : else if의 축약형으로 여러 조건을 연속적으로 검사 할 때 사용
- if / elif / else 의 사용
testNum = int(input("시험점수를 입력하세요?"))
if testNum >=90: # 90이상이 아니면 추가로 또 비교함 elif
print("최우수")
elif testNum >= 80: # 파이썬만 elif를 사용, 계속 사용하며 비교 가능
print("우수")
else: # 이도저도 아닐 때 빠져나올 경우 else 사용
print("보통")# 90점이상 A, 80이상 B, 70이상 C, 60이상 D, 나머지 F
testNum = int(input("시험점수를 입력하세요"))
if testNum >=90:
print("A")
elif testNum >=80:
print("B")
elif testNum >=70:
print("C")
elif testNum >=60:
print("D")
else:
print("F")
# 위와 같은 내용이 많을 경우 예외처리가 많이 된 부분이라고 할 수 있을 것11. while 문
- 1+(1+2)+(1+2+3)..(99+100)
# 반복하며 증감하는 문에 대해서 쉽게 코딩 가능
# while 비교조건: 증감누적수, 계산값 누적변수, 증감식
num = 1
sum = 0
tot = 0
while num <= 100:
sum += num
tot += sum
num += 1
print("TOTAL=",tot)
num1 = 1 # 증감하는 수
sum1 = 0 # 증감하며 누적되는 수
tot1 = 0 # 토탈 값
while num1 <= 100:
sum1 += num1 # 증감하며 누적되는 수 / a+(1+a)+(1+2+a)+(1+2+3+a).. = b
tot1 += sum1 # 토탈 값 계산 / 1+(a+1)+(a+3)+(a+4)..=171700
num1 += 1 # 증감식- 1~10 까지의 3의 배수의 합
"""
while문 사용
[결과]
"""
i = 0
tot = 0
while i <= 10:
i += 1
if i % 3 == 0:
tot += i
# print(tot) 일반적으로 사용
# 과거형 : print("3의 배수의 합은 %d"%(tot))
# %d (정수)
# %f (실수)
# %s (문자열)
# 형식은 ,가 아니라 %를 사용해야함. 이후 여러번 넣을경우 콤마로 구분
# 여러 결과 값이 있으면 여러번 넣으면 됨
# 최근에 버전업
print("3의 배수의 합={}".format(tot))
# tot 변수에 대해 {} 안에다가 포맷팅을 해주겠다.
# 형식은 .format(변수), 여러개면 콤마로 구분12. 자릿수 표기
i=10
j=2.66
y="test"
print("%d %0.1f %s"%(i,j,y))
# %0.1f : 소수점 이하 첫째자리 반올림되어 노출
"""
%d (정수)
%f (실수)
%s (문자열)
"""13. 인덱스 번호 부여
print("I like {},{},{}".format("red","blue","beige"))
print("I like {1},{0},{2}".format("red","blue","beige"))
# 인덱스 번호를 부여하여 순서를 지정 할 수 있음14. cotunue, breake
continue : 거치지 않고 건너뜀
break : 무한대, 계속 참일때, 빠져나와라
"
""
i = 0
eventot = 0
while i < 100:
i += 1
if i % 2 == 0:
eventot += i
print("방법1 : {}".format(eventot))
k = 0
eventot2 = 0
while k < 100:
k += 1
if k % 2 != 0:
continue
eventot2 += k
print("방법2 : {}".format(eventot2))
# 요즘은 {}.format() 방법을 많이 씀, 변수 위치라던가 소수점 자리 수 등을 지정 가능
j = 0
eventot3 = 0
while True:
if j>100:
break
j += 1
if j % 2 == 0:
eventot3 += j
print("방법3 : {}".format(eventot3))
15.range
"""
range(시작, 끝, 증가값)
range는 끝값 직전까지 값을 나열
시작값을 생략하면 0이 적용되고
증가값을 생략하면 1이 적용됨
while 반복문보다 for를 많이 씀
주의점은 ranget 뒷 값이 하나 +1된 값을 작성해야함
자바스크립트, 자바도 똑같이 들어가지만 쓰는 방법이 조금 다름
"""
for i in range(1,6):
print(i) # 1부터 5까지의 값을 호출해라16. for 문
- 1 ~ 100까지의 합계
"""
for(변수, 조건, 누적변수, 증감식
"""
sum = 0
for i in range(1,101):
sum += i
print(sum)- 1 ~ 10까지의 3의 배수의 합계
sum = 0
for i in range(1,11):
if i % 3 == 0:
sum += i
print(sum)- factorial 4! (4x3x2x1 =24)
sum = 1
for i in range(1,5):
sum *= i
print("fact= {} ".format(sum))- for 문을 통한 데이터 시각화 예시
# 10번째마다 +를 노출시킴
# 그 외에는 - 를 노출시킴
for i in range(1,51):
if i % 10 == 0:
print("+",end='') # 콤마를 찍으면 한칸 띠워져서 나오는데 end는 바로 붙어서 나오도록 함
else:
print("-",end='')
"""
---------+---------+---------+---------+---------+
"""17. 2중 for문
# 2중 for를 이용해서 확인
# 안쪽 for문이 다 돌아야 밖의 for문이 돌음
# 2차원적으로 행/렬 표를 찍으려면 for 2개가 필요하다는 것
for i in range(1,6): # 행 별 노출되는 별의 갯수 찍어줌
for k in range(i): # 1행1개, 2행의2개, 3행의3개.. 행을찍어주는 for문
print("*",end='')
print('') # 는 끊어주고 밑으로 내려주는 역할, 없으면 쭉 나열됨
"""
*
**
***
****
*****
"""- 2중 for문을 통한 데이터 시각화
for i in range(1,6):
for j in range(5-i): # 5에서 i값을 뺀 수 만큼 공백을 찍어라
print(' ',end="")
for k in range(i): # 그리고 i만큼 *을 이어서 작성해라
print('*',end="")
print('') # 두개의 for문을 나와서 밖에 print 작성, 한 줄이 아니라 나뉘어서 노출되도록 함
```python
"""
1
12
123
1234
12345
"""
for i in range(1,6): # 행 (가로)
for k in range(i): # 열 (세로)
print(k+1,end='') # 내부for 반복 후 외부 for 실행 1/12/123...
print('') - 2중 for문을 통한 구구단 작성
"""
2단부터 ~ 9단가지 구구단
2단 : 2 4 6 8 10 12 14 16 18
3단 : 3 6 9 12 15 18 21 24
4단 : 4 8 12 16 20 24 28 32 36
정수를 문자열로 바꾸는 함수 str(i)+"개"
숫자랑 문자랑 더하기로 연결을 못해서 str로 문자로 바뀌어서 나열 가능
"""
for i in range (2,10): #단수
print(str(i)+"단:",end='')
for k in range(1,10): #곱해지는 수
print(i*k,end=' ') # 2곱하기 1은 2 / 2곱하기 2는 4 / 옆에 나열되기 위해 end 사용
print('')
- 다중 for를 통해 피라미드 쌓기
"""
*
**
***
다중for를 많이 쓰진 않음
"""
for i in range(1,11):# 별을 찍을 열
for j in range(10-i): # 공백 지정 / 9칸의 공백을 가져라
print(' ',end="")
for k in range(i*2-1): # 찍을 별의 갯수 /1*2-1 : 1개의별
print("*",end='')
print('')18. 함수
# 함수를 정의하고 호출해서 사용 가능
def hello(): #함수정의
print("hello python!!") # 정의만해두고 호출을 안했기에 여기까지는 아무런 결과가 안뜸
hello() # 해석 시 해당 부분에서부터 읽음
hello() # 함수를 호출하기 전까지는 실행되지 않는다
hello() # print 또한 내장 함수임
hello() # 열고 닫고가 없으면 함수가 아님
- 함수 호출
"""
factorial를 호출 할 수 있는 함수
"""
def factorial(n):
fact = 1
for x in range(1,n+1):
fact *= x
return fact # 결과를 호출한 곳으로 값을 보내라, 안쓰면 출력이 나올 수 없음
print(factorial(4),end=' ')
print(factorial(5),end=' ')
# fact를 만드는 구문을 함수로 만들어둠
# 함수(인수), 인수가 없는 함수는 보낼 때 아무것도 없이 보냄
# 지금은 n이라는 인수를 1개 받고 있음
- 1 ~ 100까지의 합 구하는 함수
# 1-100까지 합 구하기 함수만들기
def sum ():
sum = 0
for i in range(1,101):
sum += i
# 증가치에 대한 수식이 없으면 디폴트로 1을 더해서 진행됨
return sum
print(sum())
# 전달하는 값에 따라서 다른걸 구하려면 인수를 삽입
# 궁금해서 임의의 인수를 부여하고 넣어봤는데 값이 변동없이 나옴
# 구성한 함수중에 부여된 인수의 값이 없으니 전혀 영향을 받지 않음- 인수가 두개 있는 함수
# 인수가 두개있는 함수
# 4행부터 읽음, 사용자가 불러서 작동할때만
def gaesan(a,b):
abc=a*b
return abc
print(gaesan(4,5))
print(gaesan(-1,5))- intput 함수
#range(100) : 0-99까지 숫자 발생
def enter_number():
num = int(input("Please enter number:"))
return num
def main():
num = enter_number()
for i in range(num): # num-1 까지 입력됨
print(i)
main() # 10행 호출 > 7행 호출 > 8행에서 3행 호출 - 함수를 활용한 간단 메뉴 코딩
"""
컨셉 : 제품명
빈 리스트 생성
print 메뉴 설정
1) Add name
2) Change name
3) Delete name
4) Print
5) Quit
Enter action to do : 1
Enter name to add to names list : aaa
"""
name = []
def add_name():
ask_name = str(input('Enter name to add to names list : '))
name.append(ask_name)
def change_name():
print_names()
row_ask = int(input('Enter row number to change name : '))
ask_name = str(input('Enter name : '))
name[row_ask] = ask_name # 입력받은 index의, 이름을 변경
print_name()
def delete_name():
print_names()
row_ask = int(input('Enter row number to delete name : '))
name.pop(row_ask)
def print_name():
count_row = 0
for row in name:
print('Row' + str(count_row) + ':' + str(row))
def print_names():
count_row =0
for row in name:
print('Row ' + str(count_row) + ' : ' + str(row))
count_row +=1
def main():
while True:
print('1) Add name')
print('2) Change name')
print('3) Delete name')
print('4) Print')
print('5) Quit')
ask = int(input('Enter action to do :'))
if ask == 1:
add_name()
elif ask ==2:
change_name()
elif ask ==3:
delete_name()
elif ask ==4:
print_names ()
elif ask ==5:
print('Good bye')
else:
print('Invalid input, please try again')
main()
19. 리스트
- 리스트는 각 방에 index가 부여되어 있음
- 파이썬 내 리스트는 덮어쓰기 기능이 있음
# 이전엔 변수 여러개 필요했지만, 리스트는 변수 1개로 가능
# 아파트와 비교해서 예시
# 변수 안에서 꺼내서 쓸 수 있어야 함
# 그래서 index라고 방 번호를 0부터시작해서 호출
# [] 사용해서 index 지정 가능
# 다른 프로그램에선 이걸 배열이라고 말함
list = [1,2,3,4,5]
print(list[0])
print(list[1])
print(list[2])
print(list[3])
print(list[4])
print("연산",end=' ')
print(list[1]+list[3],end=' ')
print(list[2]*list[4],end=' ')- 리스트와 인덱스를 활용한 데이터 출력
score= [88, 95, 70, 100, 99]
for s in range(5):
print("score[{}]===>{}".format(s,score[s]))
# S값을 뽑아오기위해서 대괄호를 사용해서 지정
#대괄호를 써서 사용
"""
score[0] ===> 88
score[1] ===> 95
score[2] ===> 70
score[3] ===> 100
score[4] ===> 99
"""- 리스트로 합계와 평균값 구하기
# 다섯개의 합계와 평균을 구하기
score= [88, 95, 70, 100,99]
sum = 0
for s in range (5):
sum += (score[s])
print ("총점=",sum)
print ("평균=",sum/5)
# 리스트에 있는 숫자가 "99"와 같이 문자열로 되어 있을 경우에는
# 아래처럼 형 변환을 시켜 계산 가능
score= ["88", "95", "70", "100", "99"]
sum = 0
for s in range (5):
sum += (int(score[s]))
print ("총점=",sum)
print ("평균=",sum/5)
- for 문으로 리스트 합계와 평균 구하기
score= [88, 95, 70, 100,99]
sum = 0
for s in score: # list 이름을 적어주면
sum += s # 아에 값을 0번째부터 뽑기에 s만 적어도됨
print ("총점=",sum)
print ("평균=",sum/len(score))
# len 길이를 뽑아내는 내장함수를 통해 나누기 가능
# 다른 언어에서는 lens로 사용 - list를 연결하고 반복하여 호출
list1 = [1,2,3,4,5]
list2 = [10,11]
listadd = list1 + list2 # +연산자 : 두 리스트 연결
print(listadd)
listmulit = list2 * 3 # 요소를 정수번 반복 3번 반복
print(listmulit)
"""
[1, 2, 3, 4, 5, 10, 11]
[10, 11, 10, 11, 10, 11]
"""- index를 통한 리스트 호출
# 문자열은 알아서 list로 잡힘
s="abcde"
print(s[0],end=" ")
print(s[1],end=" ")
print(s[2],end=" ")
print(s[3],end=" ")
print(s[4],end=" ")
print(" ")
print(s[-1],end=" ")
print(s[-2],end=" ")
print(s[-3],end=" ")
print(s[-4],end=" ")
print(s[-5])
"""
대괄호안의 첨자가 0부터 시작
a b c d e
e d c b a
"""- list 내 특정 위치에 데이터 추가(append, insert)
nums = [1,2,3,4]
nums.append(5) # 마지막에 추가
nums.insert(2,80) # 2번째에 80 추가
print(nums)
#[1,2,80,3,4,5]
'''
append : 맨 뒤에 추가
insert : 지정위치에 삽입 (지정위치가 오른쪽으로 밀리고)
'''- 입력받은 input 데이터를 list 내 추가
sport_list = ['football','crossfit']
print(sport_list)
sport_list.append(str(input('Enter your faviorate sport to add it : '))) # 뒤에 값 추가
print(sport_list)- 입력받은 input 데이터를 list 내 추가 및 입력받은 데이터를 통해 총점, 평균 계산
score = []
while True:
kor = int(input("국어 점수를 넣어주세요. : "))
eng = int(input("영어 점수를 넣어주세요. : "))
math = int(input("수학 점수를 넣어주세요. : "))
if kor == 0 and eng == 0 and math == 0:
break # 0 0 0 입력 시 break로 종료 시키기
my_sum = kor + eng + math
my_avg = my_sum / 3.0 # 나누는 타입을 따라감, 실수로 나누면 좀 더 정확하게 노출시킴, 형변환
score.append((kor, eng, math, my_sum, my_avg)) # 튜플로 표시, append는 전체를 닫아줘야지 리스트나 튜플이 들어감
# score.append([kor, eng, math, my_sum, my_avg]) # 리스트 표시
print()
print()
j = 1
for i in score: # %3d는 공백 3칸 마련하라는 뜻
print(j, "국어 : %3d, 영어: %3d, 수학 : %3d, 총점 : %3d, 평균 : %.2f" % (i[0], i[1], i[2], i[3], i[4]))
# i의 0번째, 1번째, 2번째, 3번째, 4번째로 나열하기
# 포멧이 맞지 않을 경우 오류 발생
# i의 index를 4개 부여했는데, 맞지 않아서 오류가 발생함-
j += 1
print("총 %d 명 처리하였습니다." % (j-1)) # j-1 : 안해주면 3명으로 나옴
# 원문이 길 때 그냥 줄바꿈하면 에러나지만 / 로 치고 내리면 인식해줌
# 경로인식이 안될 때는 아에 새 폴더를 만들어서 그 폴더로 만들기 - 파이썬) 문자열 자체에 인덱스 부여
s="python"
print(s[2])
print(s[-2])
# 리스트는 각 방에 index가 부여되어 있음
# 파이썬이라는 문자열 자체는 인덱스가 부여되어 있음
'''
t 앞
o 뒤
'''- 리스트 호출 시 대/소문자/교체하여 노출
s="Good morning. my love KIM."
print(s.lower()) # 모두 소문자
print(s.upper) # 모두 대문자
print(s) # 새로운 문자열 리턴, 자체 변경 없음
print(s.swapcase()) # 교체
print(s.capitalize) #시작되는 첫글자만 대문자
- 리스트 호출 시 공백 제거
s=" angel " # 앞2칸 뒤3칸 공백
print(s + "님") # 공백 제거없이 그대로
print(s.lstrip() + "님") # 왼쪽 공백 제거
print(s.rstrip()+"님") # 오른쪽 공백 제거
print(s.strip() + "님") # 양쪽 공백 제거
# 다른곳은 trin이라는 함수를 사용
# 이름같은 데이터를 받았을 때 사람별로 공백있게 작성하는 경우가 있음
# 데이터 활용을 위해 공백 제거 시 활용
- 리스트 호출 시 공백으로 구분
s = "노트북 키보드 마우스"
print(s.split()) # 공백으로 구분해서 리스트로 노출시켜라
# 아무것도 작성 안할 때 기본적으로 공백으로 적용
# ['노트북', '키보드', '마우스']
- 리스트 호출 시 특정 기준으로 문자열 분리
s2 = "A->B->C->D"
city = s2.split("->") # -> 기준으로 문자열 분리
print(city)
for c in city:
print(c, "+", end=' ') # 공백 기준 + 로 교체
"""
['A', 'B', 'C', 'D']
A + B + C + D +
"""- 문자열 합치기
s2 = "A->B->C->D"
city = s2.split("->")
print(" + ".join(city)) # 연결 / 문자열을 합칠 때 사용하는 메서드
# A + B + C + D - 리스트 내 여러개의 리스트를 감쌀 수 있음
# 여러개의 리스트를 감쌀 수 있음
lol = [[1,2,3], [4,5], [6,7,8,9]]
print(lol[0])
print(lol[2][1]) # 2번째의 1번째 index 값
"""
[1,2,3]
7
"""
# ----------------
for sub in lol :
for item in sub: # 0번째 일 때 그 안의 아이템 나열
print(item, end=' ')
print()
"""
1 2 3
4 5
"""- 리스트 내 각 학생 당 총점 및 평균을 구하고 전체 평균 구하기
# 각 학생 당 총점 및 평균을 구하고 전체 평균 구하기
score = [
[88, 76, 92, 98],
[68, 70, 58, 82],
[82, 80, 78, 88]
]
total = 0
totalsub = 0
for student in score: # 각 행당
sum=0 # 총점을 구하기 위한 초기치 sum 설정, 설정하지 않으면 각 행 기준이 아니라 모두 더해짐
for subject in student: # 열 (과목4개)
sum += subjects
subjects = len(student) # 과목 수 /4
print ("총점 %d, 평균 %.2f" % (sum, sum / subjects))
# print ("총점 {}, 평균 {:.2f}% (sum, sum / subject))
total += sum # 전체 점수
totalsub += subjects # 전체과목수로 나누기
print ("전체평균 %.2f" % (total / totalsub))
# print ("전체평균{:.2f}".format(total / totalsub))
"""
총점 354, 평균 88.50
총점 275, 평균 68.75
총점 328, 평균 82.00
"""- 리스트 내 학생들의 총점 및 평균 구하기 2
# 튜플 딕셔너리 리스트 리마인드
# 리스트 형태 []
# 리스트 내 데이터 변경 가능
# score 내 [[]]이 [()]로 바뀌어도 똑같은 결과 노출
score=[
["이진아",90,80,100,60], # 각각의 학생에 대한 데이터를 다시한번 리스트로 묶어서 2차원 리스트 형석
["박지수",60,75,80,90],
["송지연",100,60,100,77],
["이민수",95,77,92,65],
["장현아",88,90,80,70]
]
print("이름","국어","수학","영어","과학","총점","평균",sep="\t")
# sep="\t" : 탭(tap)문자, 열 구분시 사용
# index 지정 시에는 대괄호로 지정
# for 문으로 작성
for s in score: # 전체 데이터에서 s는 하나하나
sum = s[1]+s[2]+s[3]+s[4]
avg = sum/4
print(s[0],s[1],s[2],s[3],s[4],sum,avg,sep="\t")
# print(,"국어","수학","영어","과학","총점","평균")- 리스트 컴프리헨션
nums = [n * 2 for n in range(1,11)] # 각 요소에 2를 곱함
for i in nums :
print(i,end = ',')
# 1에서 10까지 도는데 곱해서
# 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20 ,
# 현재 예시에는 조건이 따로 없음
"""
리스트 컴프리헨션
[수식 for 변수 in 리스트 if 조건]
"""
# 1-10 사이의 3의 배수를 출력
nums1 = [n for n in range(1,11) if n%3 ==0] # 각 요소에 2를 곱함
for i in nums1 :
print(i,end = ' , ')
- 리스트 내 특정 index 데이터 삭제
score = [88, 95, 70, 100, 99, 80, 78, 50]
score.remove(100) # 100이라는 값을 찾아서 삭제
print(score)
del(score[2]) # 2번째 삭제
print(score)
score[1:4] = [] # 1-3번째 빈 리스트 -> 삭제
print(score)
"""
[88, 95, 70, 99, 80, 78, 50]
[88, 95, 99, 80, 78, 50]
[88, 78, 50]
"""- 리스트 내 싫어하는 과목 제거
# 과목을 작성하고 싫어하는 과목을 제거하기
subject_list = ['arabic', 'english','mathematics','chemistry','physics, biology']
print(subject_list)
subject_list.remove(str(input('Enter subject that you don\'t like : ')).lower())
print(subject_list)- pop / 맨 뒤에서 값을 뽑아서 제거
score = [88, 95, 70, 100, 99]
print(score.pop()) # 맨뒤에서 값을 뽑아서 제거
print(score.pop()) # pop() 뒤에서부터 제거
print(score.pop(1))
print(score)
"""
99
100
95
[88, 70]
"""- index / count 를 통해 인덱스 번호와 카운트 가능
score = [88, 95, 70, 100, 99, 80, 78, 50]
perfect = score.index(100)
print("만점 받은 학생은 " + str(perfect) + "번입니다.")
pernum = score.count(100)
print("만점자 수는 " + str(pernum) + "명입니다.")
"""
만점 받은 학생은 3번입니다.
만점자 수는 1명입니다.
"""- len / max / min 를 통해 수치 데이터 추출 가능
score = [88, 95, 70, 100, 99, 80, 78, 50]
print("학생 수는 %d 명입니다." % len(score)) # 배열의 자리수
print("최고 점수는 %d 명입니다." % max(score)) # 배열의 최대 수
print("최저 점수는 %d 명입니다." % min(score)) # 배열의 최소 수
# 이미 내장된 함수
"""
학생 수는 8 명입니다.
최고 점수는 100 명입니다.
최저 점수는 50 명입니다.
"""- 리스트 내 최대값을 코딩으로 추출
# 최대값을 함수가 아니라 코딩으로 뽑기
tst=[2,10,6,9,3,5,15]
# 최대값을 초기치로 줄 때 비교 할 값이 필요
# 임의로 너무 큰 값이 아닌 대상 지정
max=1
for i in range (len(tst)): # i변수에 tst 변수의 index 0~6번째
if tst[i] > max : # 만약에 tst 변수의 index 0~6번째 변수가 1보다 크다면
max = tst[i] # max는 tst 변수의 i(index 0~6번째)이다.
print(max)
# 15
miv=1
for n in range (len(tst)): # n변수의 tst 변수의 index 0~6번째
if tst[n] < miv: # 만약에 tst 변수의 index 0~6번째 변수가 1보다 작으면
miv = tst[n] # miv는 tst 변수의 i(index 0~6번째)이다.
print(miv)
# 1- 인덱스를 통한 리스트 데이터 추출
nums = [0,1,2,3,4,5,6,8,9]
print(nums[2:5]) # 2~5까지 끝은 포함하지 않음
print(nums[:4]) # 처음부터 4직전까지
print(nums[6:]) # 6에서 끝까지
print(nums[1:7:2])
# 1~7까지 하나씩 건너뛰며 setp을 2로 설정하면 하나씩 건너띄며 읽음
"""
[2, 3, 4]
[0, 1, 2, 3]
[6, 7, 8, 9]
[1, 3, 5]
"""
# 리스트, 튜블, 딕셔너리
# 리스트[] : 값을 바꿀수있고 추가 하거나 지울 수 있음
# 튜블 (): 값 수정 불가, 읽기만 가능
# 딕셔너리{} : 키:값 ==> key : value
==> 인덱싱할 때는 모두 [ ]
- input index를 통한 리스트 데이터 노출
colors_list = ['red','yellow','blur','orange','purple','black','brown','green','sky','gray']
print(colors_list)
start = int(input('Enter number between 0-4 : '))
end = int(input('Enter number beteen 5-9 : '))
print(colors_list[start:end])
- list : 값 변경 가능
socre = [88, 95, 70, 100, 99]
print(socre[2]) # 70
socre[2] = 55 # 값 변경
print(socre[2]) # 55
print(socre) # 변경된 list 값 호출하여 확인- list : 값 삽입 가능
nums = [0,1,2,3,4,5,6,8,9]
nums[2:5] = [20, 30, 40] # 5직전까지 적용
print(nums)
nums[6:8] = [90, 91, 92, 93,94] #6,7자리에 모두 삽입, 자리가 늘어남
print(nums)
"""
[0, 1, 20, 30, 40, 5, 6, 8, 9]
[0, 1, 20, 30, 40, 5, 90, 91, 92, 93, 94, 9]
"""- 리스트 내 위치 교환
a,b=12,34
print(a,b)
a, b=b,a # 교환
print(a,b)- 리스트 <-> 튜플, 튜플 <-> 리스트 변경
score = [88,95,70,100,99]
tu=tuple(score)
print(tu) # 리스트를 튜플로 변경
li=list(tu) # 튜플을 리스트로 변경
li[0]=100
print(li)
"""
서로 변경할 수는 있지만 엄청난 시간이 소요됨
부득이한 경우에 사용하길 권장
"""- 리스트 구조
list1=[1,2,3]
list2=list1
list2[1] = 100
print(list1)
print(list2)
"""
[1, 100, 3]
[1, 100, 3]
데이터가 같이 변하는 이유는 같은 메모리를 가르키고 있기 때문에
"""20. 리스트 정렬
- 순차정렬
# sequential sort
"""
[순차정렬]
처음부터 차례대로 비교하여 정렬
"""
tst=[2,10,6,9,3,5,15]
for i in range(len(tst)): # tst의 전체 자리인 index를 저장하는 변수 / 숫자 2와
for j in range(i+1, len(tst)): # i의 비교 대상인 index를 지정하는 변수 / 1번째인 10을 비교, 2번째인 6을 비교..
if tst[i] > tst[j]: # i와 j를 비교 시 i가 더 크다면
tst[i],tst[j] = tst[j],tst[i] # 위와같이 수식 지정 할 수 있으나 안된다면 임시변수 지정 필요
# tmp = tst[i] # 값을 교체하기 위해서 tmp에 임시적으로 변수를 저장하기 위해 지정
# tst[i] = tst[j] # i와 j의 위치를 스왑한다
# tst[j] = tmp # tmp에 스왑한 j변수의 값을 넣어준다
print(tst)
"""
[2, 3, 5, 6, 9, 10, 15]
부등호만 변경 시 동일하게 나옴
"""- 버블정렬
# #bubble sort
"""
[버블정렬]
처음부터 인접해있는것 까지 계속 비교하면서 고체 작업
한바퀴 돌았을 때 가장 큰 값을 맨 뒤로 배치
"""
tst=[2,10,6,9,3,5,15]
for i in range(len(tst)): # tst의 전체자리인 index를 저장하는 변수와
for j in range(len(tst)-i-1): # i를 넣은건 비교다하고 맨 마지막 수를 빼고, -1은 마지막은 끝에서 하나 적은수만큼만 비교하면 끝나기 때문임
if tst[j] > tst[j+1]:
tst[j],tst[j+1] = tst[j+1],tst[j]
# tmp = tst[i] # 값을 교체하기 위해서 tmp에 임시적으로 변수를 저장하기 위해 지정
# tst[i] = tst[j] # i와 j의 위치를 스왑한다
# tst[j] = tmp
print(tst)
'''
[1차수]
i : 조건문 지정 : 6번째 자리까지 반복되는
j : 조건문 지정 : 6(len)-0(i)-1, 최대 5번째 자리까지 반복
if : 만약에 0번째인 2가, 1번째인 10보다 크다면 / 두 자리 값을 스와이프
[총 5차수까지 진행] - 두번째 for문에서 반복
if : 만약에 1번째인 10이, 2번째인 6보다 크다면 / 두자리 값을 스와이프
if : 만약에 2번째인 6이, 3번째인 6보다 크다면 / 두자리 값을 스와이프
if : 만약에 3번째인 9이, 4번째인 3보다 크다면 / 두자리 값을 스와이프
.
.
전체 자리수 중 -1한 자리까지 비교하는 과정을 거치면
두번째 for문을 나오고, 첫번째 for문을 나와서 문장은 끝남
'''
"""
[2, 3, 5, 6, 9, 10, 15]
부등호만 변경 시 동일하게 나옴
"""- 선택정렬
"""
[선택정렬]
전체에서 최소값 찾아서 맨앞으로 배치하고 교체
맨처음 뺴고 두번째부터 전체에서 최소값 찾아 교체 식으로
"""
# 1회전에서 최소 값을 뽑아서 교체
# 2회전에서 0번째 자리부터 최소 값을 뽑아서 교체
# 3회전에서 1번째 자리부터 최소 값을 뽑아서 교체
tst=[2,10,6,9,3,5,15]
for i in range(len(tst)): # 0부터 6번째 자리 까지
k_index=i # i를 최소값으로 설정하고
for j in range(i,len(tst)): # i자리에서부터 6번째 자리 까지
if tst[j] < tst[k_index]:# 만약에, 현재 위치한 j자리와 최소값인 i와 비교했을 때 i가 더 크다면
k_index = j # 최소값을 j로 지정한다
tst[i],tst[k_index] = tst[k_index], tst[i] # 그리고 최소값이 먼저 앞으로 올 수 있도록 순서를 변경한다.
# tmp=tst[i]
# tst[i]=tst[k_index]
# tst[k_index]=tmp
print(tst)
'''
[2, 3, 5, 6, 9, 10, 15]
'''
# 이미 만들어져있는 shot 함수가 있으나
# 코딩을 위해 직접 설계- 오름차순 / 내림차순 정렬
# 만들어진 shot 함수
score = [88, 95, 70, 100, 99]
score.sort() #오름차순
print(score)
score.reverse() # 내림차순
print(score)
"""
[70, 88, 95, 99, 100]
[100, 99, 95, 88, 70]
"""- A B C D 문자 정렬
# A B C D 문자정렬
# sort() : 제자리 정렬
country = ["Korea", "japan", "CHINA", "america"]
country.sort() # sort(reverse=True) : 내림차순 정렬
print(country)
country.sort(key=str.lower) # lower 알파벳을 소문자로 변경하는 함수
print(country)
"""
ASCII 코드값
['CHINA', 'Korea', 'america', 'japan']
['america', 'CHINA', 'japan', 'Korea']
대문자를 더 작다고 간주
소문자(str.lower)로 바꾸어 정렬 (정렬 시에만 소문자로 하고 본래 데이터는 바뀌지 않음)
"""
"""
아스키 코드값 기준으로 나열
대문자가 더 작고 소문자가 큼
"""- sorted 정렬
score = [88, 95, 70, 100, 99]
score2 = sorted(score)
print(score)
print(score2)
"""
[88, 95, 70, 100, 99]
[70, 88, 95, 99, 100]
sort는 리스트를 직접 정렬하는데 비해
sorted는 리스트를 그대로 두고 새로운 리스트를 만들어 리턴함
"""21. 튜플
"""
리스트 [] / 값 추가 변경 가능, 메모리 용량 좀 더 들어감 (리스트는 변수)
튜블() / 수정 불가능, (튜블은 상수)
딕셔너리{} / 사전느낌
키:값 ===> key:value
===> 인덱싱(접근)할 때는 모두 []
"""
jumsu = (100,90,40,60,79)
sum=0
for i in jumsu:
sum += i
print("sum = ", sum)
print("ave = ", sum/len(jumsu))- 튜플 작성 방법
tu=2, # 튜플인것을 표시하기 위해 , 콤마 작성
value=2
print(tu)
print(value)
"""
(2,)
2
단, 요소가 하나밖에 없는 튜플은 일반 변수와 구분되지 않아
값 다음에 여분의 콤마(,)를 찍어 튜플임을 표시함.
소괄호는 생략해서 작성 가능
"""
- 튜플 : 요소 변경 삭제 불가능
# 튜플 소괄호 생략 가능, 값만 나열해도 상관 없음
# 인덕셔리 같은건 대괄호
tu=1,2,3,4,5
print(tu[3]) # 실행 가능, 수정은 안되지만 검색은 가능하다는 뜻
print(tu[1:4]) # 실행 가능
print(tu+(6,7)) # 실행 가능
print(tu*2) # 실행 가능, 2번 반복 / 리스트는 이를 활용해서 계산도 가능
# tu[1]=100 # 불가능, 1번 인덱스에 있는 값을 100으로 변경
# del tu[1] # 불가능, 지우기 불가
"""
튜플의 요소를 변경하거나 삭제하는 것은 불가능
리스트가 제공하는 append, insert 같은 메서드가 없어
요소를 추가, 삽입 할 수도 없고 삭제도 불가능함
제공하는 메서드가 idex, count 두 개 밖에 없어 요소를 찾거나 개수를 세는 것만 가능함
일체의 변경은 할 수 없고 오로지 읽기만 가능함
"""- 여러개의 변수에 값을 한꺼번에 대입 가능
tu="이민주","김지수","이유민"
lee, kim, kang = tu #차례차례 알아서 값이 들어감
print(lee)
print(kim)
print(kang)
"""
튜플은 여러개의 변수에 값을 한꺼번에 대입가능
"""
"""
이민주
김지수
이유민
"""- 튜플 내 학생들의 총점과 평균 더하기
# 튜플 딕셔너리 리스트 리마인드
# 튜플의 리스트
# 튜플 안에 있는 내용을 수정할 수 없음
# score 내 [()]이 [[]]로 바뀌어도 똑같은 결과 노출
score=[
("이진아",90,80,100,60), # 각각의 학생에 대한 데이터를 다시한번 리스트로 묶어서 2차원 리스트 형석
("박지수",60,75,80,90),
("송지연",100,60,100,77),
("이민수",95,77,92,65),
("장현아",88,90,80,70)
]
print("이름","국어","수학","영어","과학","총점","평균",sep="\t")
# index 지정 시에는 대괄호로 지정
# for 문으로 작성
for i in score: # 전체 데이터에서 s는 하나하나
sum = i[1]+i[2]+i[3]+i[4] # 합계를 구하기 위해 각 수치 변수 내 더하기
avg = sum/4 # 평균을 구하기 위해 4로 나누기
print(i[0],i[1],i[2],i[3],i[4],sum,avg,sep='\t')
# sep="\t"를 통해서 그대로 서식에 대입해주고
# 나열하기
22. 딕셔너리
- 키와 쌍의 값으로 구성(key,value)
dic= {'boy':'소년','school':'학교','book':'책'}
print(dic)- 사전 내 찾는 값이 없으면 None 값 반환
dic= {'boy':'소년','school':'학교','book':'책'}
print(dic['boy']) #boy를 키로하여 값을 찾음
print(dic['book'])
dic= {'boy':'소년','school':'학교','book':'책'}
print(dic.get('student'))
print(dic.get('student','사전에 없는 단어임'))
# for문 응용
dic= {'boy':'소년','school':'학교','book':'책'}
if 'student' in dic: # in : 특정키가 사전에 있는지 조사
print("사전에 있는 단어임")
else:
print("이 단어는 사전에 없음")- 딕셔너리 데이터 변경/추가/제거
dic= {'boy':'소년','school':'학교','book':'책'}
dic['doy'] = '남자애' # 데이터 변경
dic['girl'] = '소녀' # 데이터 추가
del dic['book'] # 데이터 제거
print(dic)
"""
{'boy': '소년', 'school': '학교', 'doy': '남자애', 'girl': '소녀'}
"""- 딕셔너리 내 학생들의 총점/평균 구하기
# 튜플 딕셔너리 리스트 리마인드
# 딕셔너리 형태 {}
# 사전 형식, 키 값 : 00, 00이 와야함
# 튜플 소괄호 [()]
# 리스트 대괄호 [[]]
# 딕셔너리 중괄호 {[]}
score={
"이진아":[90,80,100,60],
"박지수":[60,75,80,90],
"송지연":[100,60,100,77],
"이민수":[95,77,92,65],
"장현아":[88,90,80,70]
}
print("이름","국어","수학","영어","과학","총점","평균",sep="\t")
"""
list = [
[2,3,4],[5,6],[7,8,9,3]
]
"""
# index 지정 시에는 대괄호로 지정
# for 문으로 작성
for s in score:
sum = score[s][0]+score[s][1]+score[s][2]+score[s][3]
# 리스트, 튜플과 형태가 다르기 때문에 0번의 1번, 0번의 2번으로 지칭해줘야 함
avg = sum/4 # 평균을 구하기 위해 4로 나누기
print(s,score[s][0],score[s][1],score[s][2],score[s][3],sum,avg,sep="\t")
# for 문 밖에에다가 작성하면 가장 마지막 학생의 데이터만 나옴
# for 문 안에다가 작성해야지 각 학생의 정보가 반복적으로 노출
# ------------- 반복문인 for를 활용하여 작성 ------------
# index 지정 시에는 대괄호로 지정
# for 2개로 작성
# 분석 시 2차원, 다차원 등 리스트를 읽어줘야함
# for가 2개 들어가는 경우가 많음
# 행렬 계산이 많기 때문..
# 2차원적으로 누적시키는 형태를 인지하면 좋음
# 구구단처럼 1단 다 돌고나서 2단도는 느낌, 덧셈이 간략해짐
for s in score: # 각 이름의 순서를 결정 (세로)
sum = 0
for i in range(4): # 점수들 안에서 순서 설정 (가로)
sum += score[s][i] # 두번째 for문을 통해 1행0열,1행2열 이런식으로 계산 할 수 있도록 작성
avg = sum / 4
# i += 1 / 반복되는 제어문 작성할 필요가 없네..
# 연습할 때 2차원 읽는거 연습을 많이 하면 좋음..
# 헷갈리면 표 만들어서 데이터 넣으면서 연습하면 이해가 잘됨
#
print(s,score[s][0],score[s][1],score[s][2],score[s][3],sum,avg,sep="\t")
#sum = score[s][0]+score[s][1]+score[s][2]+score[s][3]
# 형태가 다르기 때문에 0번의 1번, 0번의 2번으로 지칭해줘야 함
#avg = sum/4 # 평균을 구하기 위해 4로 나누기
#print(s,score[s][0],score[s][1],score[s][2],score[s][3],sum,avg,sep="\t")
# for 문 밖에에다가 작성하면 가장 마지막 학생의 데이터만 나옴
# for 문 안에다가 작성해야지 각 학생의 정보가 반복적으로 노출
23. zip 함수
yoil = ["월","화","수","목","금","토","일"]
food = ["갈비탕","순대국","칼국수","삼겹살"]
meun=zip(yoil,food)
for y, f in meun:
print("%s요일 메뉴 : %s" %(y,f))
# 있는 것 까지만 함수를 맞추어서 노출
"""
zip 함수는 여러개의 컬렉션을 합쳐 하나로 만듦
두 리스트에 대응되는 요소끼리 짝을 지어 튜플의 리스트를 생성함.
두 개의 리스트를 병렬로 순회할 때 편리함.
두 리스트의 길이가 달라도 상관없음.
짧은 쪽에 맞추고 긴 쪽의 남는 요소는 사용안함.
"""24. filter 함수
def flunk(s):
return s < 60
score=[45,89,72,53,94]
for s in filter(flunk,score):
print(s)
"""
filter 함수는 함수 리스트의 각 값에 대해 flunk 함수를 호출하여
60미만 요소를 가려냄
첫번째 인수는 조건을 지정하는 함수이고,
두번째 인수는 대상리스트임.
"""25. map 함수
def half(s):
return s /2
score =[45,89,72,53,94]
for s in map(half, score):
print(s, end=', ')
"""
map 함수는 모든 요소에 대해 반환 함수를 호출하여
새 요소 값으로 구성된 리스트 생성.
map 함수는 score 리스트의 모든 값에 대해 half 함수를 호출하여 절반값을 구하고
이 값으로 구성된 새로운 리스트를 생성함.
원본인 score 리스트는 읽기만 할 뿐 변경되지는 않음.
22.5, 44.5, 36.0, 26.5, 47.0,
사용자 함수를 만들어 쉽게 대입 가능
"""
- 반복가능한 객체 (리스트, 튜플에 사용)
score=[45,89,72,53,94]
for s in map(lambda x:x/2, score):
print(s, end=", ")
"""
map 함수는 파이썬의 내장 함수 중 하나로,
주로 반복 가능한 객체 (리스트, 튜플 등)의
요소에 대해 어떤 함수를 일괄적으로 적용하고자 할 때 사용
"""26. 람다 함수
# 람다 함수, 축약형
score=[45,89,72,53,94]
for s in filter(lambda x:x<60, score): # score에서 골라서 60미만을 넣어라
print(s)
"""
람다 함수는 이름이 없고 이름과 출력만으로 함수를 정의하는 축약된 방법
키워드 lambda로 시작하고 인수는 콤바로 구분하여 여러 개 가질 수 있음.
return 문이 없지만 인수로부터 계산된 식을 리턴함.
lambda x:x+1
"""27. copy 메서드
list1=[1,2,3]
list2=list1.copy()
list2[1]=100
print(list1)
print(list2)
"""
copy 메서드는 원본 리스트와 똑같은 리스트를 새로 생성하기 때문에
메모리가 완전 분리되어 별도의 저장소를 가지므로 한쪽을 변경해도
영향을 받지 않음.
"""28. try / exept 예외처리 코드
- 예외처리 전
str="89점"
score=int(str)
print(score)
print("작업완료")
# error, 예외처리 필요 - 예외처리 후
# 예외사항 발생 시 예외서리
str="89점"
try :
score = int(str) # 정수형 str값이 아니라 except로 이동
print(score) # 예외가 아니면 except까지 넘어가지 않음
except: # 예외사항 발생 시 예외처리할 내용
print("예외가 발생했습니다.")
print("작업완료")- 반복 except 을 사용하여 여러 예외처리 가능
str="89"
try:
score=int(str)
print(score) # 해당 구문까지는 진행되나
a = str[5] # 5번째 index값이 없기에 에러 발생, 첨자에러
except ValueError:
print("점수의 형식이 잘못됨")
except IndexError: # 첨자 범위에 대한 예외처리
print("첨자 범위를 벗어남")
print("작업완료")- finally : 반드시 실행해야 할 명령어 지정 가능
try:
print("네트워크 접속")
a = 2 / 0
print("네트워크 통신 수행")
finally:
print("접속 해제")
print("작업 완료")
"""
finally : 예외발생 여부와 상관없이 반드시 실행해야할 명령어지정
"""28. islower 메서드
def solu(a):
b=''
for i in a:
if i.islower(): #소문자인지 여부 물어봄
b += i
return b
c =input("입력하시오.")
print(solu(c))
# 입력하시오.AcsFcvcv
# 결과 = > cscvcv
29. random
- 파이썬에서 무작위 난수를 생성하는데 사용하는 표준 라이브러리
# random 은 함수가 랜덤으로 뿌려줌
import random
def addition():
question_num_1 = random.randint(5,20) #5에서부터 20까지 랜덤
question_num_2 = random.randint(5,20) #5에서부터 20까지 랜덤
answer = question_num_1 + question_num_2 # 컴퓨터가 두 수를 랜덤하게 뽑고 값에 저장
ask_answer = int (input(str(question_num_1) + "+" + str(question_num_2) + "="))
# 문자열로 노출 시키고 그걸 다시 정수 함수로 감쌈
# input으로 받아서 마지막에 입력되어야지 계산되니까
data = (answer, ask_answer) # 두개의 값을 data 라는 인수에 넣음
return data
def subtraction ():
question_num_1 = random.randint(25,50) #5에서부터 20까지 랜덤
question_num_2 = random.randint(1,25) #5에서부터 20까지 랜덤
# 컴퓨터가 두 수를 랜덤하게 뽑음
answer = question_num_1 + question_num_2
ask_answer = int (input(str(question_num_1) + "-" + str(question_num_2) + "="))
# 문자열로 노출 시키고 그걸 다시 정수 함수로 감쌈
data = (answer, ask_answer) # 두개의 값을 data 라는 인수에 넣음
return data
def check (data):
rand_ans = data[0]
user_ans = data[1]
if rand_ans == user_ans: # 만약에 내가 맞춘 답과 동일하다면
print('Correct')
else:
print('Incorrect, the answer is {}'.format(rand_ans))
def main(): # def 함수는 불러주지 않아서 실행되지 않음
print('1) Addition')
print('2) Subtraction')
operation_ask = int(input('Enter 1 or 2 :'))
if operation_ask == 1:
check(addition()) # 1을 누르면 add 함수로감
else:
check(subtraction()) # 2를 누르면 sub 함수로 감
main()- 시간 관련 랜덤 게임
# 시간과 관련된 랜덤한 기능을 위해 random 사용
import random
import time
w= ["cat", "dog", "fox","monkey"]
n = 1
print("[타자게임] 준비되면 엔터!!!")
input( ) #사용자가 엔터 누를 때 까지 기다림
# 엔터 누르면 문제 제시 후 풀이
start = time.time() #시작시간 기록 / 걸린 시간을 뽑아야함
q = random.choice(w) # 단어 리스트에 서아무거나 뽑아서 제시, 임의의 함수에 저장
while n <=5: #다시 도전 5번까지
print("문제:",n)
print(q) # 문제를 보여줌
x = input() # 사용자 입력 받음
if q ==x :
print("통과!!!")
n = n+1
q = random.choice(w)
else:
print("오타! 다시도전!")
end = time.time() # 끝난 시간 기록
et = end - start # 실제로 걸린시간 계산
et = format(et, ".2f") # 소수점 둘째자리 까지 표시
print("타자 시간 : ", et, "초")
"""
컴퓨터에서 뽑은 값의 저장 w
내가 쓴 입력 값은 x
"""
- 숫자를 랜덤으로 뽑아낼 수 있는 게임
# 숫자를 랜덤으로 뽑아낼 수 있는 게임
import random
n = random.randint(1,30) # 1~ 30사이의 임의의 수를 주출
while True:
x = input("맞춰보세요.")
g = int(x) # 입력받은 값을 비교할 수 있도록 정수로 변경
if g == n : # 사용자가 추즉한 값과 임의의 수가 같으면 정답
print("정답") # 사용자가 입력한 값 g / 컴퓨터가 뽑은 값 n
break # 정답을 맞추면 break로 while 반복블록을 빠져나감
if g < 5:
print("너무 작아요.")
if g > n :
print("너무 커요.")
- 업과 다운을 통해 몇번만에 숫자를 맞췄는지 확인하는 모듈
import random
number = random.randint(1,100) # 1~100 중 랜덤의 수
count = 0 # 몇번째에 맞췄는지 저장할 변수값 초기화
while True:
answer = int(input('내가 고른 숫자를 맞혀 봐!'))
count += 1 # 반복적으로 실행 될 수 있도록 +1해주는 제어문
if answer == number:
print("OK! 정답이야!")
print(str(count)+ '번 만에 정답을 맞혔어!')
break
elif answer < number:
print('업 Up!')
else:
print('다운 Down!')30. capitalize 메서드
tuple_list = ('Iraq,','Fordon','Malatsia','Turkey', 'Japan')
# 확실하게 문자열로 작성하는게 좋음
print(tuple_list)
choose = str(input('Enter the name of country : ')).capitalize()
print(tuple_list.index(choose)) # 입력한 나라 이름의 index를 뽑아내시오
choose = int (input('Enter number to show country : '))
print(tuple_list[choose])
"""
capitalize : 문자열 메서드,
문자열의 첫 번째 문자를 대문자로 변환하고 나머지는 소문자로 변환하는 기능을 제공
"""31. 텍스트 파일 읽기
- 쓰기 모드 ("w")
- 추가 모드 ("a")
- 읽기 모드 ("r")
- 텍스트 모드 ("t")
- 이진 모드 ("b")
조합하여 사용 가능
f=open ("test.txt","wt")
# 텍스트 파일을 만들고, 텍스트로 기록하겠다.
f.write(''' 파일을 읽고(r) 기록하고 (w) 파일에 데이터를 추가 (a) t는 텍스트 파일, b는 이
진 파일
모드는 읽기, 쓰기, 추가''')
f. close
- 텍스트 파일 오픈 / 읽기 / 프린트 / 파일에러 시 예외처리
try:
f = open("test.txt","rt") # 텍스트 파일 오픈
text = f.read() # 텍스트 파일 읽기
print(text) # 텍스트 파일에 적혀있는 내용 프린트
except FileNotFoundError: # 파일이 없어 에러가 난다면
print("파일이 없습니다.")
finally:
f.close()- 읽은 텍스트 파일 호출
# 한줄씩 생기는데, 빈줄이 생기면(읽을게 없으면) 멈춤
# line 한줄 한줄 읽을 때 +1해주는 것
f = open("test.txt","rt")
text=""
line= 1 # 첫번째 줄 부터 시작
while True:
row = f.readline() # row 함수는 특정 셀의 행 값을 반환하는 함수
# readline 함수는 입력받은 문자열을 저장하고 그 메모리주소를 반환
if not row:break # 만약 읽을 내용이 없다면 while 문을 나간다
text += str(line) + ": " + row # 그게 아니라면 문자형으로(줄) : 해당 줄의 내용 반영
line += 1 # 반복하기 위한 제어문 / 줄 + 1
f.close()
print(text)
'''
"""
readline 함수는 한 줄씩 읽으며 파일 마지막에 도달하면 빈 문자열을 리턴한다.
무한 루프를 돌며 빈 줄을 읽을때까지 반복하면 모든 줄을 순서대로 다 읽음. 앞에 행번호도 같이 출력
readline 함수는 파일 전체를 읽어 한 줄씩 문자열로 만들어 리스트를 리턴함.
read ()
파일 전체를 한 번에 읽는다
readline ()
파일에서 한 라인을 읽는다. 여러 번 읽어야 전체를 읽을 수 있다.
readlines ()
파일 전체를 한 라인씩 읽어서 리스트로 만든다.
"""
32. class
[객체지향 프로그래밍 - 클래스]
- 클래스는 객체 지향 프로그래밍의 핵심 개념
- 현실 세계의 객체를 모델링하여 소프트웨어를 구성하는 방법으로 코드의 재사용성, 유지보수성, 확장성을 높일 수 있음
붕어빵 틀 = 반복되는 작업을 위한 틀
틀로 만들어진 붕어빵 = 객체
- 클래스는 객체를 생성하기 위한 틀이고, 객체는 클래스로부터 생성된 실체
클래스는 속성(데이터)와 메서드(함수)(기능)을 가지고 있으며 - 객체는 클래스에서 정의된 속성과 메서드를 가짐
클래스 안에 들어가는 변수를 멤버 변수라고 함
- 캡슐화 : 객체의 속성과 메서드를 하나로 묶고, 외부에서 직접적인 접근을 제어하는 것
- 상속 : 부모 클래스(상위클래스)의 속성과 메서드 자식 클래스(하위 클래스)가 상속 받는 것
코드의 재사용성을 높일 수 있으며 클래스 간의 계층 구조를 형성하여 코드를 구조화 할 수 있음 - 다형성 : 여러 객체가 동일한 인터페이스를 사용하거나 메시지를 전송할 수 있는 능력
[장점]
- 코드의 재사용이 쉽다. / 붕어빵 틀을 바꿔서 사용하기가 쉽다.
- 기존의 사용한 틀(클래스)를 이용하여 속성과 기능만 변경해서 빠르고 쉽게 프로그래밍
- 유지보수가 쉬우며 모듈화 가능
- 하드웨어 부품처럼 필요에 따라 다른프로그램에 쉽게 이식 가능
객체는 부품 하나만 갈면 됨
""" class 선언 시에는 앞에 class라고 선언해야 함
class(객체변수) 세면도구(객체): // 붕어빵 틀을 만듦 // 멤버 변수
치약 = 0 // 기능구현 할 수 있는 메서드(함수도 가능)
삼푸 = 0
비누 = 0
세01호 = 세면도구() // 객체를 인스턴스라고 표현
세01호.치약 = 1
세01호.샴푸 = 2
세01호.비누 = 3 // 붕어빵 틀로 만들어진 붕어빵 (세01호 인스턴스)
프린트("세면도구세트 세01호")
프린트("치약:",세01호.치약,"샴푸:",세01호.샴푸"비누 : ",세01호.비누)"""# 작성하는 형식이 있음
# 파이썬의 차이점, class에 뭔가를 덧 붙여줘서 써야함
# __init__과 self를 꼭 python에서 작성해줘야함, 초기화시키는 메서드
# self는 인스턴스를 받는 애, 팥 붕어빵을 만들면 self는 팥 붕어빵이 됨
# 다른 언어에서는 this.name 을 사용함 / 함수 안에 인수 받을 떄에는 생략함
# 파이썬은 self을 꼭 명시해줘야 함, 객체 자신
# 인수 아무것도 없는 것을 보낼 때 ()로만 보내지만 그럼에도 파이썬은 꼭 써야함
class Human : # 휴먼이라는 클래스를 내가 지정함 (개발자들 간의 보통 첫자를 대문자로 작성)
def __init__(self, age, name): # 초기화 시키는 작업 # __init__ 라는 함수가 따로 존재함
self.age = age # 초기화 시키는 작업 # 메서드, 피자빵을 어떻게 구울 것인지
self.name = name
def intro(self): # 기능, 메서드, self 아무것도 인수를 받지 않는 상태
print(str(self.age) + "살" + self.name + "입니다.") # + 사이에 넣을 때 str로 작성 필요
# 붕어빵 틀만 만들어둔 상태
# 독립적, 메모리 공간 따로 확보, self가 그 자신이 됨
# 접근은 다트 연산자 .으로 접근하면됨
# 인스턴스 객체를 2개 만듦
kim = Human(29, "김상형") # 휴먼 틀을 쓰려면 Human을 불러와줘야 함
kim.intro() # 그리고 다트 연산자로 메서드를 불러와서 접근
lee = Human(45, "이승우")
lee.intro()- 클래스를 활용한 데이터 호출
class Person:
def __init__ (self,name,age):
self.name = name
self.age = age
def f_print(self):
print("My name is {}".format(self.name))
print("My name is {}".format(self.age))
p1 = Person("홍길동",30)
p2 = Person("이순신",20) # 1~7행에서 만든 class를 불러서 p2 형식에 넣었기 때문에
p2.name = "장영실" # 여기에서는 person을 또 부르지 않고서 바로 변경 가능
p2.age = 40 # 변경된 인스턴스 값 삽입, 앞에 영향 없이 해당 데이터만 변경됨
print(p1.name,p1.age)
print(p2.name,p2.age)
# 다른 프로그래밍 하더라도 클래스 잘 하는게 이득
# 객체 지향은 대부분 class 로 되어 있음 - 클래스를 활용한 연산
class Calculate : # 클래스 (팀)
def __init__(self, first, second): # 붕어빵 틀 생성
self.frist = first
self.second = second
# 클래스로 함수들을 묶어놨지만, 불러올려면 27행~30행에서 각자 불러와야 함
def add(self) : # 클래스 내의 더하기 함수
result = self.frist + self.second
return '더하기 : %d ' % result
def sub(self):
result = self.frist - self.second
return '빼기 : %d' % result
def mul(self):
result = self.frist * self.second
return '곱하기 : %d ' % result
def div(self):
if self.second == 0 : # 나누기에서 인스턴스 넣을 때 0을 넣을 수 없으니까 5로 대체
self.second = 5
result = self.frist / self.second
return '나누기 : %.1f' % result
calc = Calculate(14,0) # 인스턴스 생성 (객체)(팀원) // 딸기맛 붕어빵 생성
# calc는 상단 class의 속성을 갖게 됨,
print(calc.add()) # 각 틀에 맞는 붕어빵 호출
print(calc.sub()) # calss 속성 중 필요한 함수를 뽑아 쓸 수 있게 됨
print(calc.mul())
print(calc.div())
# 너무 중요해서 반복해서 개념 익히기
- 클래스의 상속
# 자식 클래스가 부모 클래스에게 모두 상속받는 경우
class Human:
def __init__(self, age, name):
self.age = age
self.name = name
def intro(self):
print(str(self.age) + "살" + self.name + "입니다")
# 부모에게 상속을 받은 자식 클래스를 만들어야 함
# 위에 있는 부모에 모든 것을 상속 받기 위해서는 괄호 안에 작성
class Student(Human):
def __init__(self, age, name, stunum):
super(). __init__(age,name) # 자식클래스에서 받아와서 사용할라면 spuer 라는 함수 사용 필요 // 다른언어 동일
self.stunum = stunum
def intro(self):
super().intro()
print("학번 : " + str (self.stunum))
def study(self):
print("proram study")
# student 클래스는 위에 있는 클래스의 모든 것을 상속 받음
# 파이썬만 위와 같은 형식으로 상속 받음
kim = Human(29, "김상형")
kim.intro()
# 29살 김상형입니다.
# 자식 클래스 실행
lee = Student(34, "이승우", 930011)
lee.intro()
lee.study()- 부모에게 있는 메서드를 자식 클래스가 재 정의 (메서드 오버라이딩)
class Parent:
def show(self):
print("부모 메서드")
class child(Parent): #부모 메서드 상속 받음
def show(self):
print("자식에서 재정의한 메서드")
child = child()
child.show()
# 상위 부모 상수에 접근한다는 뜻 super, 자식에게 작성
# 부모에도 프린트 메서드, 자식에게도 있음
# 부모에게 있는 메서드를 다시 재 정의해서 사용 할 수 있음 = 메서드 오버라이딩
"""
위에서 알아 본 것 처럼 자식 클래스에서 부모 클래스의 메서드를 재 정의할 수 있고 이를 메서드 오버라이딩이라고 합니다.
이를 통해 하위 클래스는 상위 클래스의 메서드를 상속받아 동일한 메서드 이름을 사용하여 자신만의 동작을 재정의할 수 있습니다.
"""
# 자바스크립트는 클래스가 없었다가 나중에 생겨서 약한 편
# 많이 실습이 되고 오류가 많이 들어가야 발전이 됨연습문제
1) 연습 문제
# 연습 문제
# 5개의 점수를 입력받아 합계, 평균 구하기
score1 = int(input("첫번째 점수를 입력하시오 :"))
score2 = int(input("두번째 점수를 입력하시오 :"))
score3 = int(input("세번째 점수를 입력하시오 :"))
score4 = int(input("네번째 점수를 입력하시오 :"))
score5 = int(input("다섯번째 점수를 입력하시오 :"))
score = [score1, score2, score3, score4, score5]
sum = 0
for i in score:
sum += i
agv = sum/len(score)
print("합계는 %d 입니다."% (sum),"\n평균은 %.2f 입니다." %(agv))
# 선생님 답..
sum = 0 # sum이 밖에 있어야 하는이유, for 안에 있으면 계속 결과가 0으로 잡힘
for s in range(5):
s = int(input('정수를 입력하세요: '))
sum += s
ave = sum/5
print(sum,ave)2) 연습문제
"""
문제 풀이
여태까지 풀었던것을 활용하여 풀이
1) 합계 구하기
2) 금액 구하기
3) 1-100사이의 짝수합구하기
4) Quit
함수 안에서 그냥 계산하기
각 함수가 잘 계산되는지
금액 = 수량 * 단가
합계 구하기 : 1-100까지의 합께
리스트 굳이 필요 없음
"""
def main():
while True: # while 문을 통해
print("1) 1부터 100까지의 합계 구하기") # print 문 반복 호출
print("2) 금액 구하기")
print("3) 1-100 사이의 짝수 합 구하기")
print("4) Quit ")
aks=int(input("숫자를 입력하세요. : ")) # print 문 외 값을 정수로 입력 받아 변수에 저장하는 키 작성
if aks ==1:
asum()
elif aks ==2:
amount()
elif aks ==3:
even()
elif aks ==4:
print("프로그램을 종료합니다.")
break # 프로그램 종료 시 break 처리가 없다면 print 문이 반복적으로 노출
else:
print("다시 해주세요. ")
def asum():
sum = 0
for i in range(101):
sum += i
print("1부터 100까지의 합계는 %d 입니다." %(sum))
def amount():
count = int(input("수량을 입력해주세요. : "))
number = int(input("금액을 입력해주세요. : "))
total = count * number
print("금액은 {:,} 원 입니다.".format(number)) # {:,} 는 천단위 구분 기호 추가
print("수량은 %d 입니다." % (count))
print("총 금액은 {:,} 원 입니다.".format (total)) # format을 사용하여 변수 값을 삽입 할 수 있음
#print("금액은 %d 원 입니다." % (number)) # 원 단위 구분없이 출력
#print("수량은 %d 입니다." % (count))
#print("총 금액은 %d 원 입니다."% (total))
def even():
sumeven = 0
for even1 in range(101):
if even1 % 2 == 0:
sumeven += even1
print("1부터 100까지의 짝수의 합계는 %d 입니다."%(sumeven))
main()
# 프로그램이 간단함에도 불구하고 로직이 맞지 않으면
# 사소하게 틀리는 부분이 많음
# 큰 로직은 알 수 있으나 그 안에 작성하는 세부 서식을 자꾸 빠트림
비전공자 QA의 자기개발 공부노트