파이썬 기초 실습

파이썬 기초 실습 230511~230517

0. 표현식, 키워드, 식별자, 연산자

1. 자료형 type()

2. format() 함수

3. 기타 문자열 함수들

4. import datetime 현재 날짜 시간

5. if ~ elif ~ else 조건문

6. 리스트 list

7. 딕셔너리

8. 반복문 for, while문

9. 문자열, 리스트, 딕셔너리

10. 함수

11. 튜플

12. 람다

13. 텍스트 파일 처리

14. 예외 처리 try ~ except ~ else ~ finally

15. 모듈 import

16. 클래스 class

구글 코랩 깃허브 커밋

GitHub - yyeongeun/digitalhanaro: 디지털하나로 1기

 

프로그래밍 = 프로그램을 만드는 것

프로그램 = 미리 작성된 것 = 진행 계획

프로그래밍 언어 = 사람이 이해하기 쉬운 언어로 프로그램을 만들기 위해 만들어짐

 

0. 표현식, 키워드, 식별자

표현식 : 값으로 표현하는 코드, 숫자/수식/문자열/연산자 등

23, "hello"

표현식 -> 문장(실행될 수 있는 코드) -> 프로그램(문장들이 모인 것)

연산자 : 1+2, 사칙연산

 

키워드 : 특별한 의미가 부여된, 예약된 단어, 사용자가 변수나 함수 등의 이름을 정할 때 키워드 사용할 수 없음, 대소문자 구별

import keyword, print(keyword.kwlist)

 

식별자 : 변수명, 숫자로시작X, 언더바로 시작 O, 빈칸사용 X 키워드사용X

식별자를 잘 구별하기 위한 작성 방법

- 스네이크 케이스 - 뱀과 닮은 모양 - 모두 소문자이거나 대문자인 평평한 모양 my_name

- 캐멀 케이스 - 낙타와 닮은 모양 - 단어의 첫 글자는 대문자이고 나머지는 소문자인 울퉁불퉁한 모양 MyName

 

1. 자료형 type()

자료형 datatype = 자료의 형식 = 기능과 역햘에 따라 구분한 것

string 문자열

# 1. 문자열 안에서 따옴표 사용하는 경우, """" SyntaxError 구문오류
# 1.1 쌍따옴표, 작은따옴표 사용
print("'안녕'이라고 말해봐")
print('"안녕"이라고 말해봐"')

# 1.2 이스케이프 문자 사용 \" \"
print("\"안녕\"이라고 말해봐")
print('\'안녕\'이라고 말해봐')

## \t 탭
## \\ 역슬래시 한번 사용
## \\\\ 역슬래시 두번 사용
## \n 줄바꿈 = """ + 엔터사용
print(""" 
하나
둘
셋
""") # 비어있는 줄 앞 뒤로 한개씩 O, 비어있는 줄 삭제시 """\ 사용

# 2. 문자열 연산자 +, *

# 3. 인덱스, 인덱싱, 슬라이싱
## 0부터 시작, 거꾸로 -1부터 시작
print("안녕하세요"[:2])
print(len("안녕하세요"))

인덱스 : 자료의 위치

인덱싱 : 인덱스를 이용하여 자료를 추출하는 것

슬라이싱 : 인덱스의 범위를 이용하여 인덱싱하는 것

 

숫자형

int 정수형

float 실수형

print(3/2) # 나누기 = 실수 1.5
print(3//2) # 나누기, 몫
print(3%3) # 나머지 = 정수
print(2**2) # 제곱
2+2*2 # 괄호, 곱하기, 더하기 우선순위 O
# 우선순위가 확실하더라도 소괄호 사용을 권장

# 숫자와 문자열 사칙연산 TypeError 발생
# 문자와 문자, 숫자와 숫자 사칙연산만 가능

bool 불/논리형 True or False

# 숫자비교
print(1 == 2)
print(1 != 2)
print(1 < 2)
print(1 > 2)
print(1 >= 2)
print(1 >= 2)

# 문자비교
print("가" == "나")
print("가" != "나")
print("가" < "나")
print("가" > "나")

print(True)
print(not True) # False

 

복합대입연산자 +=, *=

사용자 입력 input -> str로만 저장한다. 숫자형과 연산 불가능

함수 input()이 실행될 때는 사용자가 값을 입력하기 전까지 프로그램이 잠시 멈ㅁ추는데 이것을 블록이라고 함 => 이 상태는 값을 입력하는 부분에 있는 커서로 확인 가능함. 값을 입력하면 입력한 값이 출력 됨

캐스트 함수 = 자료형 변환 int(), float(), str()

# 변환 프로그램
# 예제1. 1m = 100cm
meter = input("키(m)를 입력하세요>")
meter = float(meter)
height = meter * 100
print(meter,"m는 cm로 변환하면 ", height,"cm 입니다.")

# 예제2. 1inch = 2.54cm
inch = input("인치(inch)를 입력하세요")
inch = float(inch)
cm = inch*2.54
print(inch,"inch는 cm로 변환하면 ", cm, "cm입니다.")

 

캐스트 함수 -> ValueError

# 1 숫자가 아닌 값을 숫자로 변환하는 경우
int("안녕")

# 2 실수를 정수로 변환하는 경우
int("2.3")

 

2. format() 함수

"{}".format(숫자) = 숫자를 문자열로 변환하는 함수

중괄호 개수 <= 숫자 개수

중괄호 개수 > 숫자 개수 인 경우, IndexError 발생

# 숫자(정수,실수) -> 문자열
"{}".format(23)
"{}".format(2.3)
"유퀴즈 상금 {} 만원".format(100)
"{} {} {}".format(1,2,3)
"{} {} {}".format(1,"안녕",True)

정수형 숫자 -> 문자열 변환 {:d}.format()

a = "{:d}".format(23) #정수
b = "{:5d}".format(23) #5자리, 왼쪽의 빈 자리는 빈칸으로 채움
c = "{:05d}".format(23) #5자리, 왼쪽의 빈 자리는 0으로 채움
d = "{:+d}".format(23) # 양수기호 +, 자리 1개 차지

#음수는 항상 마이너스 & 자리 1개 차지
a = "{:05d}".format(-23)
b = "{:+5d}".format(-23) # 음수기호 -
c = "{: d}".format(23) # 빈칸 = 양수기호 생략
d = "{: d}".format(-23)

#자리수와 기호의 순서
a = "{:+5d}".format(23) #5자리 + 기호
b = "{:+5d}".format(-23)
c = "{:=+5d}".format(23) #기호 + 5자리
d = "{:=+5d}".format(-23)
e = "{:=+05d}".format(23) #기호 + 5자리 + 남아있는 자리 0으로 채움
f = "{:=+05d}".format(-23)

실수형 숫자 -> 문자열 변환 {:f}.format()

a = "{:f}".format(23.45) #실수 = 디폴트로 소숫점 6자리까지 표현, 0으로 채움
b = "{:15f}".format(-23.45) #15자리
c = "{:+15f}".format(23.45) #15자리, 빈자리 빈칸, +
d = "{:+015f}".format(-23.45) #15자리, -(맨앞에), 빈자리 0으로 채움

# 소숫점 자리수 편집, 5보다 크면 반올림
a = "{:15.3f}".format(23.456) # 셋째자리까지
b = "{:15.2f}".format(23.456) # 둘째자리까지
c = "{:15.1f}".format(23.456) # 첫째자리까지
d = "{:15.1f}".format(23.45) # 5라서 반올림X
e = "{:15.1f}".format(23.46) # 6부터 반올림

"{:15.0f}".format(2.5) #2와 3 사이의 정가운데 값이라면, 더 가까운 값을 짝수로 생각 2
"{:15.0f}".format(3.5) #3과 4 사이의 정가운데 값이라면, 더 가까운 값을 짝수로 생각 4
"{:15.0f}".format(4.5) #4과 5 사이의 정가운데 값이라면, 더 가까운 값을 짝수로 생각 4

의미가 없는 소숫점 제거 {:g}.format(23.450)

 

f문자열 f"{23}"

"{}".format(23)
f"{23}"

# format() 함수 사용하는 것이 더 좋은 경우
# 1) 문자열이 많을 때
mc = "유재석"
reward = 100

"""\
유퀴즈 프로그램은 다양한 사람을 만나서 이야기하는 프로이다. \
엠씨는 {}이고, 퀴즈를 맞추면 상금 {} 만원을 준다.\
""".format(mc,reward)

f"""\
유퀴즈 프로그램은 다양한 사람을 만나서 이야기하는 프로이다. \
엠씨는 {mc}이고, 퀴즈를 맞추면 상금 {reward} 만원을 준다.\
"""

# 2) 여러 값을 리스트 형태로 사용할 경우
# format은 전개연산자 사용가능
data = ["강백호",17,"M","난 천재니까"]
"""\
이름 : {}, \
나이 : {}, \
성별 : {}, \
좌우명 : {} \
""".format(*data) #전개연산자 - 리스트 원소 자동으로 넣어줌

f"""\
이름 : {data[0]}, \
나이 : {data[1]}, \
성별 : {data[2]}, \
좌우명 : {data[3]} \
"""

 

 

3. 기타 문자열 함수들

문자열.upper() 대문자변경

문자열.lower() 소문자변경

문자열.strip() 앞뒤 공백 제거

문자열.rstrip() 뒤 공백 제거

문자열.lstrip() 앞 공백 제거

문자열.isalnum() 알파벳alpha 또는 숫자num 확인, True/False 반환

문자열.isdigit() 정수형digit 인지 확인, True/False 반환

문자열.find('a') 왼쪽부터 'a'의 첫번째 위치(인덱스) 반환, 인덱스 0부터 시작

문자열.rfind('a') 오른쪽부터 'a'의 첫번째 위치(인덱스) 반환

 

"안녕" in "안녕하세요" 안녕이 안녕하세요에 속해있는지 확인, True/False 반환

"안녕" not in "안녕하세요" 

문자열.split(" ") 빈칸을 기준으로 문자열 나누기, list 형태로 저장

 

4. import datetime 현재 날짜 시간

now = datetime.datetime.now()

import datetime
now = datetime.datetime.now()
print(now)
print(now.year)
print(now.month)
print(now.day)
print(now.hour)
print(now.minute)
print(now.second)
print(now.weekday())
# 0:월, 1:화, 2:수, 3:목, 4:금, 5:토, 6:일


"{}년 {}월 {}일 {}시 {}분 {}초입니다.".format(now.year, now.month, now.day, now.hour, now.minute, now.second)

 

5. if ~ elif ~ else 조건문

# 우리나라의 오전, 오후를 알려주는 프로그램
import datetime
now = datetime.datetime.now()
korea_hour = now.hour+9
if korea_hour < 12:
  print("현재 오전 {}시 입니다".format(korea_hour))
else:
  print("현재 오후 {}시 입니다.".format(korea_hour))
  
# 계절을 알려주는 프로그램
import datetime
now = datetime.datetime.now()
if 3 <= now.month <= 5:
  print("와 봄이야")
elif 6 <= now.month <= 8:
  print("와 여름이야")
elif 9 <= now.month <= 11:
  print("와 가을이야")
else:
  print("와 겨울이야")

조건문에 들어가면 False로 바뀌는 값 = None, 0, []

비어있지 않은 리스트는 항상 True = [1]

if None:
  print("None 값은 현재 True입니다.")
else:
  print("None 값은 현재 False입니다.")

pass 키워드

에러가 발생해도 지나가기

# 에러 발생해도 지나가기 pass
no = input("숫자(정수)를 입력하세요>")
last_no = int(no[-1])
if last_no % 2 == 0:
  pass
else:
  pass
  
# 아직 구현하지 않은, 코딩해야하는 부분임을 알려주기 위해 일부러 에러내기
no = input("숫자(정수)를 입력하세요>")
last_no = int(no[-1])
if last_no % 2 == 0:
  raise NotImplementedError
else:
  pass

 

6. 리스트 list

list_a = [[1,2,3,4], "안녕하세요", True]
list_a[0][:-2] # [1,2]

리스트 인덱싱 에러 -> IndexError

list_a[3] #인덱스 범위 초과
list_a[0][4] #인덱스 범위 초과

 

 

리스트 연결 => +, 원본 리스트 값 유지

리스트 추가 => 원본 리스트 값 유지 X, 파괴적 처리

리스트.append(4) 뒷자리에 4 추가

리스트.insert(3,4) 중간에 추가. 3번 위치에 4 요소 추가

리스트.extend(list_2) 연결&파괴적 처리

list_1 = [1,2,3]
list_2 = [4,5,6]
print(list_1 + list_2) # 연결 +
print(list_1*3) # 원본 리스트 값 유지
list_1.append(5) # 추가 +, 뒤에 추가, 원본 리스트 값 유지 X, 파괴적 처리
list_1.insert(3,4) # 인덱스 3번 위치에 4라는 값(요소) 추가

리스트 제거

# 인덱스 번호로 제거
del list_1[2] # del 키워드
list_1.pop(1) # pop 키워드
# 값으로 제거
list_1.remove(4) # remove 함수, 첫번째 4가 삭제
# 리스트 안의 모든 요소 제거 = 비우기 = 리스트 구조 살아있음
list_1.clear()

리스트 정렬

score = [75,55,40,90,100]
score.sort() # 오름차순
score.sort(reverse=True) # 내림차순

리스트 전개연산자 [*] = 비파괴적 처리!

# 1) 리스트 안에서 사용
a = [1,2,3]
b = [*a] # 비파괴적 처리 != append 함수와 다름
c = [*a, *a]

# 2) 함수에서 사용
print(*a)

범위 range(시작번호,끝번호,간격)

반복문 for i in range()

for i in range(1,10,2):
  print(i)
  
list_b = [[1,2,3],[4,5,6]] # 2차원
# 2개의 요소를 가지고 있어 2번 반복
# 여전히 리스트 형태로 출력
for i in list_b:
  print(i)

min(리스트) 최소값

max(리스트) 최대값

sum(리스트) 합계

reversed(리스트) 역순

리스트.enumerate() 튜플형태로 키와 값 전체 반환, 리스트 안에 들어있는 요소에 대한 (인덱스번호, 값)을 확인

 

7. 딕셔너리

dic = {"key":value}

dic["key"] 인덱싱

"이름" in sd_dic 딕셔너리 키 존재 여부

dic.items() 튜플형태로 키와 값 전체 반환,딕셔너리 안에 들어있는 (키, 값)을 확인

# 딕셔너리 생성
sd_dic = {
    "이름" : "정대만",
    "나이" : 19,
    "키" : 183,
    "몸무게" : 70
}

print(sd_dic["이름"])

딕셔너리 키와 값 제거

del sd_dic["이름"] #키와 값 동시 삭제

존재하지 않는 키 사용 -> KeyError

# 존재하지 않는 키를 사용할 때 발생
sd_dic["상대팀"]

del sd_dic["상대팀"] #키와 값 동시 삭제

키 이름 오류 -> NameError

# 문자열로 키 만들 때 따옴표 있어야함
a = {이름 : "강백호"}

dic.get("key") = 키가 존재하지 않아도, 에러 없이 None을 반환

# 여러 개의 값을 가지는 딕셔너리 생성
bs = {
    "선수" : ["채치수","정대만","송태섭","강백호","서태웅"],
    "감독" : ["안감독"],
    "매니저" : ["한나"]
}

# 존재하지 않는 키로 값 보기 = 에러 없이 결과가 없다는 내용
# 딕셔너리명.get("key명")
bs.get("감독")

value = bs.get("감독님")
print(value) # None

min(딕셔너리,key=) 최소값

max(딕셔너리,key=) 최대값

# 딕셔너리
players = [{"이름":"강백호","신장":189},
          {"이름":"서태웅","신장":188},
          {"이름":"채치수","신장":195},
           ]

def height(players):
  return players["신장"]

# 키 매개변수 필요
print(min(players, key = height)) # 최소값
print(max(players, key = height)) # 최대값
# 람다 사용
print(min(players, key = lambda x:x["신장"])) # 최소값
print(max(players, key = lambda x:x["신장"])) # 최대값

딕셔너리 정렬

# 오름차순
# key 매개변수에 함수 넣기
players = [{"이름":"강백호","신장":189},
          {"이름":"서태웅","신장":188},
          {"이름":"채치수","신장":195},
           ]
players.sort(key = lambda x:x["신장"])

# 내림차순
# key 매개변수에 함수 넣기
players = [{"이름":"강백호","신장":189},
          {"이름":"서태웅","신장":188},
          {"이름":"채치수","신장":195},
           ]
players.sort(key = lambda x:x["신장"], reverse=True)
print(players)

 

8. 반복문 for, while문

character = {
    "name" : "정대만",
    "number" : 14,
    "records" : {
        "three_point" : 24,
        "rebound" : 1
    },
    "schools" : ["무석중","북산고"]
}
print(character)

# 복잡한 딕셔너리 값 출력하기
for i in character:
  if type(character[i]) == list: #리스트 list
    for j in character[i]:
      print(j)
  elif type(character[i]) == dict: #딕셔너리 dict
    for k in character[i]:
      print(character[i][k])
  else: #나머지 값들
    print(character[i])

range(정수형) -> 실수형인 경우 TypeError 에러 발생

역반복문

# 역순으로 반복
for i in range(5,0,-1): # range(0,5)
  print(i)
  
for i in reversed(range(1,5+1)): # reversed(range())
  print(i)

무한반복 while문에 조건을 걸어서 조건 만족시에만 반복하기

# 무한반복
while True:
  print("언제 끝나",end = "")
  
i = 0
while i < 10:
  print(i) # 0부터 9까지 출력
  i += 1
 
# 값이 있는 동안에 반복
list_a = [1,2,3,2,4,2,5]
value = 2
while value in list_a:
  list_a.remove(value)

# 시간 기반으로 반복
import time
number = 0
target = time.time() + 3 
while time.time() < target: # 3초동안 반복
  number += 1
print(number)

break 반복 종료

continue 현재 반복 생략하고 다음 반복으로 이동, 다음 문장에서는 들여쓰기하지 않아도 됨

# break
# 반복 종료
i = 0
while True:
  print(i)
  i += 1
  yn = input("종료할까요? (종료를 원하시면 Y나 y를 입력하세요)>")
  if yn in ["Y","y"]:
    print("반복 종료")
    break
    
# continue
# 현재 반복 생략하고 다음 반복으로
list_a = [100,20,150,50,200]
for i in list_a:
  if i < 100:
    continue
  print(i)

 

9. 문자열, 리스트, 딕셔너리

인덱스와 값을 동시에 출력 및 저장하기

enumerate(list), dic.items()

-> 튜플값으로 저장되어 값 변경 불가능

# enumerate 함수 with 리스트
list_a = [21,34,11,5,67]
enumerate(list_a) #객체
list(enumerate(list_a)) #리스트와 유사하지만, 튜플값으로 저장되어 값 변경 불가능
for i,j in enumerate(list_a):
  print("인덱스",i,"값",j)

# items 함수 with 딕셔너리
sd_dic = {
    "이름" : "정대만",
    "나이" : 19,
    "키": 183,
    "몸무게" : 70
}
sd_dic.items() # # 키와 값을 동시에 출력, 튜플로 저장
for i, j in sd_dic.items():
  print("키",i,"값",j)

리스트 내포

# 리스트 내포로 재현
list_c = [i**2 for i in range(1,5+1)]

# 리스트 내포에 조건문 추가
# 과일만 리스트로 저장
list_a = ["사과","참외","수박","토마토"]
fruit = [i #표현식(값 표현)
         for i in list_a #반복문
         if i!= "토마토"] # 조건문
fruit

join 문자열 연결

print("-".join(["010","1234","5678"]))
print(" ".join(["010","1234","5678"]))
print("|".join(["010","1234","5678"])) # shit + \

# 소괄호로 문자 연결 => , 없이 사용해야 함!
a = (
    "나는 \n"
     "여름을 \n"
     "좋아합니다."
)
print(a)
print(type(a)) #여전히 문자열

# 쉼표 있는 버전
a = (
    "나는 ",
     "여름을 ",
     "좋아합니다."
)
print(a)
print(type(a)) #튜플, 자료구조

이터레이터 객체 next()

메모리 효율성을 위해 따로 저장하지 않을 경우, 자동으로 날아가게 되는 휘발성 있는 객체

이터러블 : 반복할 수 있는 것, 내부 요소를 순서대로 꺼내어 쓸 수 있는 객체

예) 리스트, 딕셔너리, 문자열, 튜플 등

이터레이터 : 함수 next()를 사용하여 꺼낼 수 있는 요소

a = [1,2,3]
b = reversed(a)
print(next(b)) # 3
print(next(b)) # 2
print(next(b)) # 1

 

10. 함수

함수 만들기 def 함수이름():

일반매개변수 / 가변매개변수 / 기본매개변수 / 키워드매개변수

 

가변매개변수는 원하는 만큼 매개변수를 받을 수 있는 함수

가변 매개변수 뒤에 일반 매개변수가 올 수 없음 & 가변 매개변수는 하나만 사용 가능

 

기본매개변수는 기본값이 지정되어 있는 매개변수

값 형태, 값은 매개변수를 입력하지 않으면 들어가는 기본값 예) sep

 

가변 매개변수와 기본 매개변수를 함께 사용하기 위한 방법

매개 변수 이름을 지정해서 입력하는 매개변수

위치가 아닌 키워드(매개변수 이름 직접 입력)로 전달하는 방식 사용

위치 매개 변수 먼저 입력 후 키워드 매개변수 입력

키워드로 모두 사용할 때는 상관없음

# 일반매개변수 = 값을 순서대로 입력
def printntimes(value,n):
  for i in range(n): # n은 반드시 정수
    print(value) # 무슨 값이든 상관 없음

printntimes("안녕",3)

# 가변매개변수 = 입력할 수 있는 값의 개수 제한이 없음 = *values
# 일반매개변수 뒤에 와야함
def printntimes(n, *values):
  for i in range(n): # n은 반드시 정수
    for j in values:
      print(j)

printntimes(3,"안녕","파이썬","재밌니")

# 기본매개변수 = 기본값을 가지는 매개변수
# 가본매개변수 뒤에 기본매개변수
def printntimes(*values, n = 3):
  for i in range(n):
    for j in values:
      print(j)

printntimes("안녕","파이썬","재밌니")
# 순서 : 일반매개변수 - 가변매개변수 - 기본매개변수

# 키워드 매개변수
# 매개변수의 이름을 지정해서 입력
printntimes("안녕","파이썬","재밌니",n=5)

 

키워드 매개변수를 사용하면 좋은 점 -> 순서를 고려하지 않아도 됨, 일부만 사용할 수 있음

함수 return = 반환값, 함수 적용 결과 출력

 

재귀함수

문제점 : 상황에 다라 같은 내용을 기하급수적으로 반복함. 이 문제를 해결하기 위해 메모화 사용

1) 팩토리얼

# 팩토리얼
# 반복문으로 구현
def factorial(n):
  output = 1
  for i in range(1,n+1):
    output *= i
  return output
  
def factorial(n):
  output = 1
  for i in range(n,1-1,-1):
    output *= i
  return output
  
# 재귀함수로 구현
def factorial(n):
  if n == 0:
    return 1
  else:
    return n*factorial(n-1)

2) 피보나치 수열

UnboundLocalError : global 키워드 없이 외부 변수 참조하면 발생하는 에러

# 피보나치 수열 = 앞의 두 숫자를 합한게 다음 숫자
def fibonacci(n):
  if n==1:
    return 1
  elif n==2:
    return 1
  else:
    return fibonacci(n-1)+fibonacci(n-2)
    
# 키워드 global = 외부에 있는 변수 참조
count = 0
def fibonacci(n):
  global count
  count += 1
  if n==1:
    return 1
  elif n==2:
    return 1
  else:
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(25))
print(count)

메모화 = 같은 값을 반복해서 구하지 않고 저장(메모)

조기리턴 = 코드 중간에 키워드 return을 사용하는 것. 과거에는 변수는 앞쪽에 리턴은 뒤쪽에 작성하는 경향이 있었지만, 최근에는 필요할 때 쓰고 있음

# 같은 값을 반복해서 구하지 않고 저장(메모)
f_dict = {
    1:1,
    2:1
}

# 조기리턴
def fibonacci(n): # n은 딕셔너리 key
  if n in f_dict:
    return f_dict[n]
  output = fibonacci(n-1) + fibonacci(n-2)
  f_dict[n] = output
  return output

리스트 평탄화 flat(리스트)

중첩된 리스트를 모두 풀어서 1차원 리스트로 만드는 것

 

11. 튜플

튜플이 유용한 이유

튜플은 소괄호 없어도 튜플로 만들 수 있음

값의 교환을 편리하게 할 수 있음

함수 리턴에 많이 사용함. 리턴에 사용하면 여러 개의 값을 리턴하고 할당할 수 있음 - 인덱스와 값을 동시에 출력 enumerate, items, 몫과 나머지를 튜플 형태로 리턴 divmod

tuple_a = (1,2,3)
tuple_a = 1,2,3 # 소괄호 없이 튜플 생성
print(tuple_a)
print(type(tuple_a))

# 여러 변수를 한 번에 할당할 때 사용
[a,b] = [1,2]
(c,d) = (3,4) # int 타입

# 튜플 => 값의 교환 편리!
a,b = 1,2
a,b = b,a

# 튜플 형태로 리턴하는 사용자 정의 함수 만들기
def test():
  return (1,2)
a,b = test()
# a,b = (1,2)
print(a);print(b)

# 딕셔너리의 키와 값 반환 = items()
for i,j in {0:1,1:2,2:3}.items():
  print("인덱스",i,"값",j)

# 몫과 나머지 값을 튜플 형태로 반환하는 함수
c,d = divmod(a,b)
print(c);print(d)

 

12. 람다

람다함수로 지정한 함수는 언제든 호출하여 영구적으로 사용 불가능하다.

map함수는 리스트의 각각의 요소를 앞의 함수에 넣어 값을 출력해준다. map(함수, 리스트)

filter는 콜백 함수 적용 결과 중에서 True인 것만 출력해준다.

콜백함수는 함수의 매개 변수 역할을 해준다.

 

람다

함수라는 기능을 매개변수로 전달하는 코드

매개변수로 함수를 할당하기 위해 함수 구문을 작성하는 것이 번거로움

간단한 함수를 쉽게 선언하는 방법

함수를 따로 만들지 않고 바로 사용 가능

lambda 매개변수 : 리턴값

# 함수의 매개변수에 사용하는 함수 = 콜백 함수
def repeat_10(x):
  for i in range(10):
    x()
def print_hi():
  print("hi")
repeat_10(print_hi) #print_hi = 콜백 함수

# map 함수 = 콜백 함수 적용 결과 값
def sqr(x):
  return x**2

list_a = [1,2,3]
output_map = map(sqr,list_a)
print(output_map)
print(list(output_map))

# filter 함수 = 콜백 함수 적용 결과 중에서 True 인 것
def under_3(x):
  return x<3

list_a = [1,2,3]
output_filter = map(under_3,list_a)
print(output_filter)
print(list(output_filter))

# 람다로 변경
list_a = [1,2,3]
# 콜백 함수 자리에 람다
# 람다 사용법 : lambda 매개변수 : 리턴값(기능 결과)
output_map = map(lambda x:x**2, list_a)
print(output_map)
print(list(output_map))

list_a = [1,2,3]
output_filter = filter(lambda x:x<3, list_a)
print(output_filter)
print(list(output_filter))

 

13. 텍스트 파일 처리

파일 열기/닫기

open(문자열:파일경로, 문자열:읽기모드)

w : write 새로 쓰기

a : append 뒤에 이어쓰기

r : read 읽기

 

파일에 텍스트 쓰기 wirte()

파일 읽기 read()

키워드 with

텍스트 파일 한 줄씩 읽기

file = open('base.txt',"w") # 새로쓰기 write 모드
file.write("안녕 파이썬 재밌니") # 텍스트 쓰기
file.close() # 파일 닫기

# 파일을 열고 닫는 과정에 코드가 많이 생기면 파일 닫지 않는 실수를 함
# 이를 방지하기 위해서 with 문
with open('base.txt',"w") as file:
  file.write("안녕 파이썬 재밌니")
  # with 문이 끝나면 자동으로 파일이 닫힘
  
# 이름,키,몸무게 => csv 파일로 저장
import random
hangul = list("가나다라마바사아자차타파하")
with open("info.txt","w") as file: # as 별칭
  for i in range(1000):
    name = random.choice(hangul) + random.choice(hangul) + random.choice(hangul) # hangul 리스트에서 랜덤 선택
    height = random.randrange(140,200) #140에서 200 사이 range에서 랜덤
    weight = random.randrange(40,150)
    file.write("{}.{}.{}\n".format(name,height,weight))
    
# 텍스트 파일 한줄씩 읽기 & 새로운 변수 생성 및 출력
with open("info.txt","r") as file: # 읽기모드 "r"
  for line in file:
    name,height,weight = line.strip().split(".") # 앞뒤 공백 제거 & 자르기
    if (not name) or (not height) or (not weight): # 데이터 하나도 없으면 (결측치)
      continue # 해당 반복 생략하고 다음 줄로 넘어가기
    
    bmi = int(weight)/(int(height)/100)**2 # 체중(kg)/키(m)제곱

    result = ""
    # 25 보다 크거나 같으면 과체중
    # 18.5 보다 크거나 같으면 정상
    # 나머지 저체중
    if bmi >= 25:
      result = "과체중"
    elif bmi >= 18.5:
      result = "정상"
    else:
      result = "저체중"
    
    # print("이름:{}, 키:{}, 몸무게:{}, bmi:{}, 결과:{}".format(name,height,weight,bmi, result))
    print("\n".join(["이름:{}", 
                     "키:{}", 
                     "몸무게:{}", 
                     "bmi:{}", 
                     "결과:{}"]).format(name,height,weight,bmi,result))

 

 

14. 예외 처리 try ~ except ~ else ~ finally

오타에러 SyntaxError

프로그램 실행 전에 발생하는 오류구문 오류가 발생하는 코드

# 오타가 일반적 = SyntaxError
# 프로그램 실행 전에 발생하는 오류
print("안녕 점심시간 기다려지니)

프로그램 실행 중에 발생하는 오류

런타임 오류 RuntimeError

예외 exception

 

조건문으로 예외 처리하기

# 조건문으로 예외 처리 => 프로그램이 정상적으로 종료되었음
number = input("원의 반지름을 입력하세요(단, 정수)>")
pi = 3.14
if number.isdigit(): # 숫자로 변환 할 수 있는 경우
  number = int(number)
  print("원의 반지름",number)
  print("원의 둘레",2*pi*number)
  print("원의 넓이",pi*number*number)
else:
  print("정수를 입력해주시겠어요?")

pass 에러가 어디서 발생했는지 알지 못한다.

rasie NotImplementedError 내가 아직 구현하지 않았다는 에러 강제로 발생시키기

# 예외 강제 발생
# NotImplementedError 내가 아직 구현하지 않았다는 에러
try:
  number = input("원의 반지름을 입력하세요(단, 정수)>")
  pi = 3.14
  number = int(number)
  print("원의 반지름",number)
  print("원의 둘레",2*pi*number)
  print("원의 넓이",pi*number*number)
except:
  raise NotImplementedError

try ~ except ~ else ~ finally 구문

try 예외 발생할 수 있는 구문

except 예외 발생시

else 예외 발생하지 않았을 때 실행

finally 예외 발생 여부와 관계없이 무조건 실행. try 구문내에 return 있어도 실행. try 구문 내에 break있어도 실행.

 

try ~ except

try ~ except ~ else

try ~ except ~ finally

try ~ except ~ else ~ finally

try ~ finally

try: # 예외 발생할 수 있는 코드 입력
  number = input("원의 반지름을 입력하세요(단, 정수)>")
  pi = 3.14
  number = int(number)
except: # 예외 발생시
  print("정수를 입력해주시겠어요?")
else: # 예외 발생 X
  print("원의 반지름",number)
  print("원의 둘레",2*pi*number)
  print("원의 넓이",pi*number*number)
finally: # 예외 여부 상관없이 정상 작동시
  print("하여튼 프로그램이 정상적으로 종료되었어요")

except Exception as exception:

예외 종류 type(exception)

예외 객체 exception 클래스

# 예상할 수도 없는 예외도 대처
a = [1,2,3,4,5] # 0 1 2 3 4
try:
  # 1 번째 예외 상황 : 정수가 아닌 문자열 입력 (4번째 라고 입력)
  number = int(input("정수를 입력하세요>"))
  # 2 번째 예외 상황 : 인덱스에 없는 정수 번호를 입력 (10 입력)
  print("{} 번째 요소는 {}입니다.".format(number,a[number]))
except ValueError as exception:
  print("정수를 입력해주시겠어요?")
  print("예외 객체:",exception)
except IndexError as exception:
  print("정수를 잘 입력하셨겠지만 인덱스 범위에 있는 정수를 입력해주세요]")
  print("예외 객체:",exception)
except Exception as exception: # 예외객체
  print("예외 종류:",type(exception))
  print("예외 객체:",exception)

 

 

15. 모듈 import

모듈 = 여러 변수와 함수를 가지고 있는 집합체

표준모듈 = 내장모듈 = 파이썬 기본 내장 모듈

외부모듈 = 다른 사람이 만들어서 공개한 모듈

모듈 설치하기 pip install 모듈명

pip : 파이썬 패키지 관리 시스템, 특정 버전의 모듈 설치 및 제거.

beautiful Soup : 웹 페이지 분석 모듈, 웹크롤링 도구

모듈 bs4의 함수 BeautifulSoup() 매개변수로 HTML 문자열과 html.parser 문자열을 입력하면 BeautifulSoup 라는 특수한 객체를 반환

함수 select() 태그 여러개 선택

함수 select_one() 태그 하나만 선택6                                

 

import math

수학과 관련된 기능을 제공

import math
math.sin(1)
math.cos(1)
math.tan(1)
math.floor(3.14) #낮은 값의 정수
math.ceil(3.14) #높은 값의 정수

from math import sin,cos,tan
sin(1)

 

import random

랜덤한 값을 생성할 때 사용

import random
random.random() # 실수
random.uniform(10,20) # 범위에 있는 실수
random.randrange(130,210) # 범위에 있는 정수
random.randrange(10) # 범위 시작번호 생략 O
random.choice([1,2,3,4,5]) # 랜덤 선택

a = [1,2,3,4,5]
random.shuffle(a) # 랜덤 셔플

random.sample(a,k=2) # 2개 랜덤 뽑기

 

import sys

시스템과 관련된 정보를 가지고 있음

명령 매개변수를 받을 때 많이 사용

import sys
sys.argv
sys.copyright
sys.version
sys.stdin.readline() # 파이썬 입력받기

 

import os

운영체제와 관련된 기능을 가지고 있음

새로운 폴더 생성, 폴더 내부의 파일 목록 살펴보기 등

import os
os.name
os.getcwd()
os.listdir()
os.mkdir('hello') # 폴더 생성
os.rmdir('hello') # 폴더 삭제

with open("test.txt","w") as file:
  file.write("이제 파이썬 끝나간다")
  os.rename("test.txt","new.txt") # 이름변경
os.remove("new.txt") # 파일삭제

 

import datetime - 앞에서 해서 생략

날짜, 시간과 관련된 모듈

날짜 형식을 만들 때 자주 사용

 

import time

시간과 관련된 기능을 다룰 때 사용 예) 유닉스 타임

import time
print("지금부터 3초동안 꼼짝마")
time.sleep(3) # 3초 동안 쉬기
print("얼음 땡")

 

from urllib import request

url을 다루는 라이브러리, 인터넷 주소를 활용할 때 사용

URL (Uniform Resource Locator) : 네트워크의 자원이 어디에 위치하는지 확인할 때 사용하는 것, 웹 브라우저의 주소창에 입력하는 주소

from urllib import request
url_target = request.urlopen("https://www.google.com/")
output = url_target.read()
print(output)

 

16. 클래스 class

C를 제외한 모든 프로그래밍 언어는 객체 지향 프로그래밍 언어

객체 = 프로그래밍 언어에서 속성을 가질 수 있는 모든 것

클래스 = 객체를 조금 더 효율적으로 생성하기 위해 만들어진 구문

클래스 - 붕어빵 틀 / 인스턴스 - 붕어빵

 

생성자 __init__

객체 생성할 때 처리할 내용을 작성할 수 있음

첫번째 매개변수로 반드시 self 입력해야 함. 다만 self가 가지고 있는 속성과 기능에 접근할 때는 self.<식별자> 형태로 사용

 

메소드, 메서드

클래스가 가지고 있는 함수

class Player:
  def __init__(self, name, point3, point2, rebound):
    self.name = name # 문장 끝에 쉼표 X
    self.point3 = point3 
    self.point2 = point2
    self.rebound = rebound

  def score_sum(self):
    return self.point3 + self.point2 # self를 이용해 값 가져오기

players = [
    Player("정대만",24,.6,1),
    Player("강백호",0,4,10),
    Player("서태웅",12,16,5)
    ]

for player in players:
  print(player.name, player.score_sum())