$$config title: 파이썬 keywords: - IT - ... $$ # 4/11 ``` # 파이썬의 변수 - 데이터 타입을 지정하지 않음 : 모두가 주소다 - 파이썬의 변수는 주소값을 가지고 있음 - 데이터를 확인하는 함수가 필요(type) - 파이썬에서 변수의 대입은 주소(포인터(c), 래퍼런스(java)) - 데이터타입 - list(수정가능), tuple(수정 불가능:함수의 매개변수와 리턴값) - dict(키:data형식), set(키이) - []:리스트,{}:dict,set,():튜플 - 파이썬에서 블록은 indent(들여쓰기) - 변수(함수): stack, heap - stack: 함수의 복귀주소, 함수가 실행될 때 필요한 데이터 - heap은 동적 메모리 할당으로 데이터를 저장할 때 사용 a=10 # 10은 heap에 저장되고 그 주소를 a가 가리키는 메모리 위치에 저장 b=a # 주소값이 대입입 print(a) print(b) print("주소값 대입", id(a)),print(id(b)) # 주소값 확인 a=20 # 대입 print(a) print(b) print("주소값 대입", id(a)),print(id(b)) #c # NameError: name 'c' is not defined -> 변수는 반드시 초기화 되어야 한다. a type(a) print(type(a)) # 데이터 타입도 클래스, None도 클래스 => 모두가 클래스 => 객체지향 프로그래밍언어 # 파이썬은 대소문자를 구분 a = 10 A = 20 print(a) print(A) # 파이썬에서의 casting(형변환) problem = input('수식을 입력하시오') # 데이터 입출력은 문자열 print(problem) # 문자열 print(eval(problem)) # int() int도 클래스 , eval은 수식도 입력 가능 # casting print(int('23')) print(float('23')) print(eval('23')) print(eval('23.5')) x = 5 print(eval('23+(2*x)')) # 메모리: 2진수 -> 8, 16진수(메모리의 내용을 사람이 이해하기 좋게) a3 = 4.24e-3 # 지수(exponent) a4 = 0o177 # octal a5 = 0x8f # hexa print(a3) print(a4) print(a5) # C(%:string, integer, float), C#, f문자열 print('My name is %s and I am from %s , %i .'%('AI','4차산업혁명',10)) print('My name is {1} and I am from {0} and i like {thing}'.format('딥러닝','AI',thing='cats')) name='기믕걍' age=20 print(f'이름은 {name}, 나이는 {age}') # f문자열 # 문자열 - '', "", """ """: 입력하는 형태대로 문자열을 생성 - 문자열에서 +(결합연산자), *(반복연산자) - 인덱스 -는 뒤에서부터(R에서는 제외하고) - 입력순서를 보장 # 문자열은 기본으로 1차원 배열 fullName=input('이름을 입력하세요:') print(type(fullName)) # str 데이터타입 n=fullName.rfind(" ") # reverse find : 뒤에서부터 찾아라, 인덱스는 0번부터 print(fullName[0]) print(fullName[1]) print(fullName[2]) print(n) print('이름:', fullName[n+1:]) # n+1부터 끝까지 slicing - 부분 문자열 print('성(s):', fullName[:n]) # 처음부터 n번째까지 s='korea' # str class print(s+s) # 문자열 결합연산자 print(s*3) # 문자열 반복연산자 print(s[0:]) print(s[4]) print(s[-1]) print(s[1:3]) print(s[-2:]) print(s[-2:5]) print(s[3:-1]) print(len(s)) s.split('r') t = 'Seoul, Incheon, won'.split(',') print(t) t=','.join(t) print(t.upper()) print(t.lower()) # 숫자를 문자열로 변환 f = 1.23 g = str(f) h = repr(f) # 정밀도가 더 높다 print(g," ",h) a=3 b=4 print(a+b, a-b, a/b) print(a%b) # 나머지 연산자 print(1%2) print(7//4) # 정수 나눗셈 sum([1,2,3,4]) min([1,2,3]) abs(-11) # absolute pow(2,10) # 2**10 round(3.141592,2) # 소수점 셋째자리에서 반올림 round(3.141592) # 소수점 첫째자리에서 반올림하고 정수로 표현 # 리스트 자료구조 +,* : 문자열하고 동일 li=[4,7,8] # 리스트 lj=[5,6,7] print(type(li)) # print(li+lj) print(sum(li)) li*3 num1 = input('정수를 입력하시오:') num2 = input('정수를 입력하시오:') hab = int(num1)+int(num2) quotient = hab // 2 remainder = hab % 2 print('입력된 수를 2로 나눈 결과 몫=', quotient, '나머지=',remainder) if remainder == 0: print('짝수입니다.') else: print('홀수입니다.') print(hash(object)) # 파이썬의 부모는 object 모든 클래스가 상속받음 print(object) x=300 # 전역변수: 함수 밖에서 선언된 변수 def myfunc(): #x=200 # 내부선언된 변수: 지역변수가 우선 #x+=200 # 전역변수를 함수 안에서 수정하려고 하면 안됨됨 print(x) # 전역변수는 매개변수로 전달하지 않아도 사용이 가능 myfunc() print(x) # 전역변수를 함수 안에서 사용하려면 함수의 매개변수로 전달하는 것이 좋다 x=300 def myfunc(x): x+=200 print(x) myfunc(x) print(x) # 문제 # 어떤 정수를 입력받아서 0이면 가위, 1이면 바위, 2이면 보로 출력하시오 x = int(input('정수를 입력하시오(0,1,2):')) if x == 0: print('가위') elif x==1: print('바위') elif x==2: print('보') name=input('이름을 입력하시오:') kor=input('국어점수를 입력하시오:') mat=input('수학점수를 입력하시오:') eng=input('영어점수를 입력하시오:') tot=int(kor)+int(mat)+int(eng) avr=round(tot/3,2) print('이름'.center(10),'국어'.center(10),'수학'.center(10),'영어'.center(10),'합계'.center(10),'평균'.center(10),sep=" ") print(name.center(10),kor.rjust(10), eng.rjust(10), mat.rjust(1), str(tot).rjust(12), str(avr).rjust(12),sep=" ", end=" ") # 리스트: 문자열(배열)인덱스하고 동일일 t = [5,7,6,2] t = list([5,6,7,2]) # 캐스팅 print(t) print(len(t),max(t),sum(t)) # 리스트를 매개변수로 받음 print(t[0],t[-1],t[:2],t[1:3]) t=[5,7,6,2] print(t) a=20 b=10 print(a>b) c=1>10 and b<50 print(c) c=10 독립적인 데이터타입 유지 -> 출력이 안됨 b = range(1,6,1) print(b) print([b]) # 출력이 안됨 print(list(b)) # 리스트로 바꿔주어야 출력이 된다.(캐스팅) streaming = ['netflix','hulu','disney+','appletv+'] index=streaming.index('disney+') # 검색 print(index) streaming[index] if 'disney+' in streaming: streaming.remove('disney+') # 데이터가 입력 print(streaming) if streaming: del(streaming[0]) # 인덱스를 이용해서 삭제 print(streaming) streaming[0]='netflix'; # 수정 print(streaming) streaming.append('다람쥐') # 추가 streaming.pop(0) # 앞뒤에서만 가능 print(streaming) # 함수의 멀티 리턴 # 파이썬에서는 함수의 매개변수 개수가 반드시 일치해야 됨 def calc(a,b): # 일반화 프로그래밍 return a+b,a*b # tuple로 리턴 x,y=calc(3,4) print(x,y) print(x) x,y args=(4,5) # 튜플: 수정이 불가능 calc(*args) # 변동매개변수 # enumerate seasons = ['Spring','Summer','Fall','Winter'] print(enumerate(seasons)) # 자체 타입 print(list(enumerate(seasons))) # 순서를 지정 print(list(enumerate(seasons,start=1))) # 번호의 시작점을 달리 할 수 있음 # list 정렬 - 포인터이기 때문에 monarchs = [('대한',1),('민국',3),('만세',6),('야호',1)] # reverse=False 디폴트 매개변수 -> 디폴트 매개변수는 생략이 가능하다. monarchs.sort() # 오름차순 print(monarchs) # lambda함수: 무명함수(함수 이름이 없음) monarchs.sort(key=lambda row: row[1], reverse=True) # 내림차순 print(monarchs) # 문제 # 이름, 국어점수를 입력받아 school이라고 하는 리스트에 입력하고 점수로 정렬해서 출력하시오 school=[] name=input('이름:') kor = eval(input('국어점수:')) school.append([name,kor]) name=input('이름:') kor = eval(input('국어점수:')) school.append([name,kor]) name=input('이름:') kor = eval(input('국어점수:')) school.append([name,kor]) school.sort(key=lambda row:row[1], reverse=True) print(school) school=[] for i in range(3): name=input('이름:') kor=eval(input('국어점수:')) pair=[] pair.append(name) pair.append(kor) school.append(pair) school.sort(key=lambda row:row[1], reverse=True) print(school) # 튜플: 삽입, 삭제, 수정이 안됨(검색은 가능) tupl={'K','o','r','e','a'} tupl=tuple('Korea') tupl tupl[0] tupl[-1] tupl[-2:] len(tupl) cities=('seoul','incheon','suwon','seoul') cities.index('suwon') 'incheon'in cities cities.count('seoul') sorted(cities) sorted(cities, reverse=True) sungjuk=[['하하',100,100,100],['유재석',99,99,98],['추신수',90,98,91]] sungjuk.sort() print(sungjuk) # 세번째에 있는 점수를 중심으로 정렬해보시오 sungjuk.sort(key=lambda row:row[3]) def getKey(row): return row[3] sungjuk.sort(key=getKey) # 각 리스트의 점수 합계를 내고 리스트에 추가하고 합계를 기준으로 정렬하시오 total=sungjuk[0][1] + sungjuk[0][2] + sungjuk[0][3] sungjuk[0].append(total) total=sungjuk[1][1]+sungjuk[1][2]+sungjuk[1][3] sungjuk[1].append(total) total=sungjuk[2][1]+sungjuk[2][2]+sungjuk[2][3] sungjuk[2].append(total) sungjuk.sort(key=lambda row:row[4], reverse=True) print(sungjuk) for sung in sungjuk: total=sung[1]+sung[2]+sung[3] sung.append(total) sungjuk.sort(key=lambda row:row[4], reverse=True) sungjuk for sung in sungjuk: total=0 for i in range(1,4): total+=sung[i] sung.append(total) # 등수를 입력하시오(6번째 데이터로 등수를 입력하시오) print(sungjuk) i=0 for sung in sungjuk: i+=1 sung.append(i) print(sungjuk) # list를 이용해서 stack # LIFO(last in first out): 밑이 막힘 myStack=[] # list -> if myStack: false myStack.append('a') myStack.append('b') myStack.append('c') print(myStack) print(myStack.pop()) print(myStack.pop()) print(myStack.pop()) # 리스트를 이용한 Queue (First In, First Out 대기열) printer = [] if not printer: # 비어 있으면(데이터 없으면) 실행 print("리스트가 비어 있습니다.") printer.append(60) printer.append(50) if not printer: printer.pop() printer.append(40) print(printer.pop(0)) # 선두에서 데이터 삭제 printer # 관계 연산자 a = 13 b = 33 print(a > b) # F print(a < b) # T print(a == b) # F print(a != b) # T print(a >= b) # F print(a <= b) # T # 논리 연산자 a = True b = False print(a and b) # F print(a or b) # T print(not a) # F # 비트 연산자 a = 10 b = 4 print(bin(a)) # 00001010 print(bin(b)) # 00000100 print(a & b) # AND, False, 0 print(a | b) # OR, 00001110 (14) print(~a) # NOT, 11110101 (-11) print(a ^ b) # XOR, 00001110 (두개가 다르면 참) print(a >> 2) # 오른쪽 shift, 00000010 (2) => shift 한번의 의미는, 2로 나눔 print(a << 2) # 왼 쪽 shift, 00101000 (40) # 67을 2진수로 표현 : 01000011 # 108을 2진수로 표현 : 01101100 import statistics as s print("mean([1, 2, 3, 4, 4]) :", s.mean([1, 2, 3, 4, 4])) # 평균 print("median([1, 3, 5, 7]) :", s.median([1, 3, 5, 7])) # 중위수 data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5] print("variance(data) : ", s.variance(data)) # 분산 print("stdev(data) : ", s.stdev(data)) # 표준편차 # random 함수 # 의사난수 (이미 정해져 있는 데이터(난수)가 출력 => seed값 (시작지점을 달리하여 진짜 random인 것 처럼 설정) import random random.seed(1000) print(random.randint(1, 5)) elements = ["earth", "air", "fire", "water"] elements[0] = "earths" # choice와 sample의 차이? # choice = 복원 (항상 4개를 선택) # sample = 비복원 (R에서는, 7:3으로 데이터 분할 시 사용) print(random.choice(elements)) print(random.sample(elements, 2)) # 랜덤하게 요소 중 2개 추출 random.shuffle(elements) # 랜덤하게 요소 섞기 print(elements) for i in range(100): print(random.randint(1,5)) random.random() # time import time; ticks = time.time() print("Number of ticks since 12:00am, January 1, 1970:", ticks) # 초당 1000번씩 print(time.localtime()); time.localtime(ticks) import calendar cal=calendar.month(2023,4) print(type(cal)) print(cal) # 태어난 년도를 입력하면 나이를 계산하고 미성년자 여부를 판단하시오(미성년자 기준은 20) year = int(input("태어난 년도를 입력하세요: ")) age = 2023 - year if age > 20: print(age,'세',"당신은 성년 입니다") else: print(age,'세','당신은 미성년자') import datetime dt=datetime.datetime.now() print(dt.year) print(dt.month) # print(dt) print(dt.day) dt # 생년월일을 20010203형식으로 입력을 받아서 출생년도 월 일 변수에 대입하고 # 현재의 날짜를 기준으로 나이를 계산하고 18살 미만이면 미성년자로 출력하시오 import datetime dt = datetime.datetime.now() print(dt) age=input('생년월일을 입력:') year=int(age[:4]) month=int(age[4:6]) day=int(age[6:]) year_diff=dt.year-year month_diff=dt.month-month day_diff=dt.day-day if day_diff < 0: month_diff -= 1 if month_diff <0: year_diff -= 1 print('당신의 나이는 ',year_diff+1) if year_diff < 18 : print("당신은 미성년자입니다.") else: print("당신은 성년") ``` 정리할 내용 ``` 정리할 내용 1. 문자열 함수 중에 ls함수들을 확인하고 정리하시오 - ls함수: 디렉토리의 내용을 출력하는 함수 2. 문자열 함수의 종류를 대분류하여 5개의 카테고리로 나누어 보고 소속함수들을 모아보시오 (ls계열함수, crud함수, 카운트함수, 변환함수, format함수) ls 계열 함수 ls: 현재 디렉토리의 파일 목록을 출력하는 함수 ls -l: 현재 디렉토리의 파일 목록을 상세하게 출력하는 함수 ls -a: 현재 디렉토리의 숨김 파일을 포함한 파일 목록을 출력하는 함수 ls -t: 파일 목록을 최근 수정된 순서대로 출력하는 함수 CRUD 함수 Extend, append, index, rfind, find Count 함수 Len, count 변환 함수 Strip, upper, lower, split, ,join Format 함수 %, format., f문자열 3. list의 append와 extend의 차이를 확인하시오 - append()는 리스트에 하나의 요소만 그대로 추가하고 extend()는 리스트에 풀어져서 추가 4. 연산자의 종류를 확인하시오 대입연산자, 산술연산자, 관계연산자, 논리연산자, 비트연산자, 포함연산자(in) 5. escape 문자에 대해 확인하고 기호를 파악하시오 \t, \n, \r ``` # 4/12 ``` # if문 # false인 것들 - '',"",0,[],{},(),None 등 - if문을 사용하는 방법 - 단일if, - if else - if elif else - 중첩된(nested) if - for in - in 뒤에 올 수 있는 것들 - Collections(list,dict,set,tuple,bytes,str) - iterator - range - generator - enumerate(단일 입력 -> 2개 출력) - zip(2개 입력 -> 2개 출력) score = 70 if score >= 80: print("80이상") else: print("80이하") city = '' # False if not city: print("빈문자열") # 삼항항연산자 x=5 ans = '양수' if x>=0 else '음수' print(ans) # 문제 # 수입(income)과 지출(costs)을 입력받아서 순수입을 출력하는 프로그램을 작성하시오 # 경우의 수: 순수입(profit), 손익분기점(break_even_point), 순손실(loss) (3가지) income = eval(input("수입:")) costs = eval(input("지출:")) if costs == income: result="손익분기점" elif costs < income: profit=income-costs result="순수익={0:,.2f}".format(round(profit,2)) # 자리수 표현 else: loss=costs-income result="순손실={0:,.2f}".format(round(loss,2)) print(result) # 위 코드를 내포된 if문으로 수정 (중첩 if문) costs = eval(input("지출을 입력하세요 ")) revenue = eval(input("수익을 입력하세요 ")) if costs == revenue: result = "손익분기점" else: if costs < revenue: profit = revenue - costs result = "순수익 = {0:,.2f}".format(round(profit, 2)) else: loss = costs - revenue result = "순손실 = {0:,.2f}".format(round(loss, 2)) print(result) # 문제 # color와 mode를 입력받아서 처리하는 프로그램을 if문을 이용해서 처리하시오(4가지 경우) color=input("color:") mode=input("mode:") color=color.upper() mode=mode.upper() result="" if color=='BLUE' and mode=="STEADY": result="화창" elif color=='BLUE' and mode=="FLASHING": result="구름" elif color=="RED" and mode=="STEADY": result="비오는날" else : result="눈오는날" print("예측된 날씨는",result) # 위 코드를 내포된 if문으로 수정 (중첩 if문) color=input("color:") mode=input("mode:") color=color.upper() mode=mode.upper() result="" if color=='BLUE': if mode=="STEADY": result="화창" elif mode=="FLASHING": result="구름" elif color=="RED": if mode=="STEADY": result="비오는날" elif mode=="FLASHING": result="눈오는날" print("예측된 날씨는",result) # 문제 # 점수(jumsu)를 입력받아서 A,B,C,D,F 학점으로 출력하시오(경우의 수 5가지) jumsu = eval(input("점수입력:")) if jumsu>=90: result="A" elif jumsu>=80: result="B" elif jumsu>=70: result="C" elif jumsu>=60: result="D" else: result="F" print("학점:",result) # 문제 # 과일을 100.50원에 세금 12.5%를 붙여서 팔았다. 매출액은 얼마인가 # 세금과 매출액이 얼마인지 출력하시오 # 소수점 2째자리까지 표현하시오 tax_rate=12.5/100 price=100.50 tax_per_one=price*tax_rate sales_price=price*(1+tax_rate) print("세금=",round(tax_per_one,2),", 1개 판매 가격 =",round(sales_price,2)) # 위의 결과에 개수를 입력받아 1개를 팔았을 때의 세금, 판매개수에 대한 총 세금액, 판매개수에 대한 총매출액을 출력해보시오 amount = eval(input("판매한 과일 개수를 입력하시오:")) total_tax=tax_per_one *amount total_amount=sales_price * amount print(amount,"개를 팔았을 때, 1개의 세금=",round(tax_per_one,2),", 총 세금액=",round(total_tax,2),", 총 매출액=",round(total_amount,2)) # 문제 # 제곱미터(평수=제곱미터/3.305)로 입력되는 아파트 면적을 평형으로 계산하여 종류를 판정하시오 # 소형(17이하), 중형(17-30), 대형(30이상) square_area = int(input("제곱미터를 입력하시오:")) size=square_area/3.305 result="" if size > 30: result="대형" elif 17=500: continue print(item, end=" ") print(list(range(10))) # range(종료값) print(list(range(10,2))) # 미출력: 종료값이 더 작아서 print(list(range(1,10))) # range(시작값, 종료값) 이때 증감값=1 print(list(range(1,10,2))) # range(시작값, 종료값, 증감값) print(list(range(10,1,-1))) print(list(range(1,11,-1))) # 미출력 print(list(reversed(range(10)))) # 역순 출력력 # iterator ra=range(10) ra=iter(ra) next(ra) next(ra) next(ra) print(sorted([7,1,2,6,0,3,2])) seq1=['a','b','c'] seq2=['d','e'] zipped=zip(seq1,seq2) list(zipped) seq1=['foo','bar','bax'] seq2=['one','two','three'] seq3=[False,True] print(list(zip(seq1,seq2,seq3))) for i, (a,b) in enumerate(zip(seq1,seq2)): print('%d,%s %s' %(i,a,b)) list(reversed(range(10))) # 문제 # 1부터 10까지 더해보시오(range) sum=0 for i in range(1,11): sum+=i print(sum) my_list=['bobby','hadz','com'] while my_list: my_list.pop(0) # append pop(0) => FIFO(Queue) break; print(my_list) # 중첩된 for, 이중 for문 for x in range(1,10): for y in range(2,10): print(y,'*', x,'=', x*y, end='\t') print() # 문제 # 두 수를 입력해서 숫자이면 합계를 내서 출력하고 아니면 처음수가 아닌 것이 있는지 # ls함수: isdigit() # 아니면 뒤에 입력한 것이 숫자가 아닌 것이 있는지 확인해서 출력하시오 num1 = input("숫자입력:") num2 = input("숫자입력:") if num1.isdigit() and num2.isdigit(): print("합계는",str(eval(num1)+eval(num2))) elif not num1.isdigit(): if not num2.isdigit(): print('둘 다 숫자가 아님') else: print('처음수가 숫자가 아님') elif not num2.isdigit(): print('두번째 수가 숫자가 아님') # 문제 # while문을 이용해서 1부터 10까지 더한 결과를 출력하시오 i = 0 # 증가변수 sum = 0 # 누적변수 while i < 10: i += 1 # 1,2,3,4,5,6,7,8,9,10 sum+=i # 1,3,6,10... print(sum) # 3,4,5,6,7,8,9만 더해보시오 i=0 sum=0 while i<10: i+=1 # 1,2,3,4,5,6,7,8,9 if i<3:continue if i>9:break else: sum+=i # 1,3,6,10.. print(sum) # 문제 # 입력형식 10K or 10M, 10G와 같은 형식으로 입력하고 어떤 경우이던지 바이트로 변환해서 출력하시오 # 10*1024 -> 10K # 10*1024*1024 -> 10M # 10*1024*1024*1024 -> 10G # 입력을 무한대로 하고 Q가 입력이 되면 중지하게 하시오 UNIT=1024 criterion=['K','M','G'] while 1: volumein=input("용량을 입력하시오") if volumein.upper() == 'Q': break volumein = volumein.strip() num = volumein[:-1].strip() scale = volumein[-1] calcunit = scale.upper() # 대문자로 변환 if not num.isdigit() or not calcunit in criterion: print('잘못 입력하였습니다.') continue volume = int(num) if calcunit == 'K': volume_res = volume * UNIT elif calcunit == 'M': volume_res = volume * UNIT * UNIT elif calcunit == 'G': volume_res = volume * UNIT * UNIT * UNIT else: print("계산가능한 용량단위가 아니므로 다시 입력하시오") print("입력한 용량"+volumein +"은"+str(volume_res)+"바이트입니다.") # 문제 # 컴퓨터가 랜덤으로 숫자 하나를 결정(1-100사이) # 입력된 숫자와 컴퓨터가 결정한 숫자를 비교해서 입력된 수가 큰지 작은지 알려준다. # 무한루프로 작동하고 Q하면 중지하도록 한다. 맞춰도 중지 import random com = random.randint(1,100) while(1): person=input("숫자 입력:") if person.upper()=='Q': break person=int(person) if com > person: print('up') elif com < person: print('down') else: print("정답!") break # 6번 지나가면 진 것으로 처리 import random import sys tot_game=0 win=0 while True: com = random.randint(1,100) tot_game += 1 game=0 while(1): person=input("숫자 입력:") game += 1 if person.upper()=='Q': print("총 게임수",tot_game-1,"이긴게임수 ",win," 진 게임수",tot_game-win-1) sys.exit(0) # 정상종료 person=int(person) if com > person: print('up') elif com < person: print('down') else: win+=1 print("정답!") break if game >= 6: print("패배") break # 서비스 차원에서 매 게임마다 평균 몇 번 시도했는지를 출력하는 회로를 추가하시오 import random import sys tot_game=0 win=0 tot_attempt=[] while True: com = random.randint(1,100) tot_game += 1 game=0 while(1): person=input("숫자 입력:") game += 1 if person.upper()=='Q': print("총 게임수",tot_game-1,"이긴게임수 ",win," 진 게임수",tot_game-win-1) game_tot = sum(tot_attempt)/(tot_game-1) print("평균시도횟수",game_tot) sys.exit(0) person=int(person) if com > person: print('up') elif com < person: print('down') else: win+=1 tot_attempt.append(game) print("정답!") break if game >= 6: tot_attempt.append(game) print("패배") break [i for i in range(10)] # 패턴, 규칙이 있는 수를 발생 [i**2 for i in range(10)] {i : i**3 for i in range(10)} [i**2 for i in range(10) if i%2==0] # 짝수의 제곱 rows=range(1,5) # 4가지 cols=range(10,15) # 5가지 vectors=[(r,c) for r in rows for c in cols] vectors # 문제 # rows에 있는 수와 cols에 있는 수 중에 홀수만 선택해서 조합해보시오 vectors=[(r,c) for r in rows if r%2 for c in cols if c%2] vectors # 문제 # 1부터 20 사이의 수 중에 3의 배수, 5의 배수인 경우는 숫자 다음에 '3의 배수','5의 배수'와 같이 출력해보시오 ["3의 배수"*(i%3==0)+'5의 배수' * (i%5==0) or i for i in range(1,21)] # 관계연산자는 true,false를 리턴(true=1,false=0) # or은 앞이 참이면 뒤는 계산하지 않음 numberOfRows = int(input('숫자를 입력하시오:')) for i in range(numberOfRows): for j in range(i+1): print("*",end='') print() numberOfRows = int(input('숫자를 입력하시오:')) for i in range(numberOfRows): for k in range(numberOfRows-i): print(" ",end='') for j in range(i+1): print("*",end='') print() for i in range(1,11): print(" "*(10-i),"*"*i) # 과제 for i in range(1,11): print(" "*(10-i),"*"*(2*i-1)," "*(10-i)) for i in range(1,21): if i <= 10: print("*"*i) else: print("*"*(20-i)) for i in range(1,11): print("*"*i+" "*(10-i)+" "*(10-i)+"*"*i) for i in range(1,21): if i <= 10: print("*"*i+" "*(10-i)+" "*(10-i)+"*"*i) else: print("*"*(20-i)+" "*(i-10)+" "*(i-10)+"*"*(20-i)) for i in range(1,11): print("*"*(11-i)+" "*(i-1)+" "*(i-1)+"*"*(11-i)) ``` # 4/13 ``` # 함수 - 입력 -> 처리 -> 출력 - 매개변수 -> block -> 리턴 - def함수명(매개변수):처리 return sum=0 # 전역변수 def add(a,b): # 파이썬의 함수는 전역변수 참조가 가능 sum=a+b # 지역변수 print(sum) add(54,65) print('합계:',sum) # 문제 import random # if문으로 게임작성 sel=['가위','바위','보'] judge=['이김','짐','비김'] com=random.randint(0,2)%3 person=int(input('입력하시오(0:가위,1:바위,2:보):')) result=0 if person==0: if com==0: result=2 elif com==1: result=1 elif com==2: result=0 elif person==1: if com==0: result=0 elif com==1: result=2 elif com==2: result=1 elif person==2: if com==0: result=1 elif com==1: result=0 elif com==2: result=2 print('당신은 '+sel[person]+'을 내고 컴퓨터는 '+sel[com]+'을 냄 \n당신은 '+judge[result]) # 더 간단하게 sel=['가위','바위','보'] judge=['이김','짐','비김'] com=random.randint(0,2)%3 person=int(input('입력하시오(0:가위,1:바위,2:보):')) result=0 if person==com: result=2 elif (person+1)%3==com: result=1 else: result=0 print('당신은 '+sel[person]+'을 내고 컴퓨터는 '+sel[com]+'을 냄 \n당신은 '+judge[result]) # if문 없이 게임 작성 judge=[['비김','짐','이김'],['이김','비김','짐'],['짐','이김','비김']] # 메모리 낭비 com=random.randint(0,2)%3 person=int(input('입력하시오(0:가위,1:바위,2:보):')) print(judge[person][com]) # 무한반복하게 만들고 알파벳이 들어오면 게임을 종료시키고 게임이 끝나면 몇전 몇승 몇패인지 출력해보시오 judge=[['비김','짐','이김'],['이김','비김','짐'],['짐','이김','비김']] tot=0 win=0 lose=0 draw=0 while(1): com=random.randint(0,2)%3 person=input('입력하시오(0:가위,1:바위,2:보):') if person.isalpha(): # 알파벳을 입력하면 멈춤 print('게임을 종료합니다.') print('총 게임수:',tot,' 이긴 게임수:',win,' 진 게임수:',lose,' 비긴 게임수:',draw) if (win>0 and tot>0): print('승률:',(win/tot)*100) break person=int(person)%3 tot+=1 if person==com: draw+=1 elif (person+1)%3==com: lose+=1 else: win+=1 print(judge[person][com]) # 문제 # 이름, 국어, 수학, 영어점수 3인분을 2차원 리스트에 저장하시오 final=[] for i in range(3): sungjuk=[] name=input('이름 입력:') kor = int(input('국어점수 입력:')) mat = int(input('수학점수 입력:')) eng = int(input('영어점수 입력:')) sungjuk.append(name) # 형태유지, extend는 풀어져서 입력됨 sungjuk.append(kor) sungjuk.append(mat) sungjuk.append(eng) final.append(sungjuk) print(final) # 합계, 평균, 학점을 계산하여 추가하고 입력된 데이터에 대하여 등수를 추가하기 final = [] for i in range(3): sungjuk = [] name = input("이름:") kor = int(input("국어점수:")) mat = int(input("수학점수:")) eng = int(input("영어점수:")) sungjuk.append(name) sungjuk.append(kor) sungjuk.append(mat) sungjuk.append(eng) tot = kor + mat + eng avg = round(tot/3, 2) if avg >= 90: grade = "A" elif avg >= 80: grade = "B" elif avg >= 70: grade = "C" elif avg >= 60: grade = "D" else: grade = "F" sungjuk.append(tot) sungjuk.append(avg) sungjuk.append(grade) final.append(sungjuk) print(final) final.sort(key = lambda row:row[4], reverse=True) # 합계를 기준으로 정렬 rank = 0 for i in range(len(final)): rank = rank + 1 final[i].append(rank) # 2중 for문으로 데이터를 순서적으로 출력해보시오 tot_list=['이름','국어','수학','영어','총점','평균','등급','석차'] for j in range(len(tot_list)): print(tot_list[j],end="\t") for i in range(len(final)): # 행수 print('\n') for j in range(len(final[0])): # 열수 print(final[i][j], end="\t") a=10 b=20 result=a+b print(result) a=30 b=40 result=a+b print(result) def addvalue(a,b): return a+b result=addvalue(10,20) # 복귀주소 print(result) result=addvalue(30,40) print(result) # 어떤 데이터든 전달이 가능(데이터타입을 지정하지 않음) print(addvalue([10,20,30],[30,40,50])) print(addvalue('abc','def')) # 함수는 일반화시켜야 함 def sqr_list(list): # 목적은 리스트 처리 emp_list=[] for i in list: # Collections, iter, range, generator, enumerate, zip emp_list.append(i**2) print(emp_list) lista=[1,2,3,4] sqr_list(lista) lista=[1,2,3,4,5,6,7,8,9,10] sqr_list(lista) # default 매개변수 # 오버로딩은 매개변수의 타입이 다르거나 매개변수의 개수가 다르면 다른 함수로 인식한다. # 매개변수가 다르면 default 매개변수가 해결 # default 매개변수는 뒤에 있어야 함 # 함수 오버로딩하면 안됨 def student(name,age=21,weight=40): print('이름:',name) print('나이:',age) print('몸무게:',weight) def student(name, age=20): # 같은 이름으로 선언은 되나 뒤의 것만 작동 print('이름:',name) print('나이:',age) student('김일') student('김이',25) a=10 b=20 def swap(x,y): # temp를 사용하지 않고 멀티리턴을 이용해서 처리 return y,x a,b=swap(b,a) x=swap(a,b) print(x) def add(a,b): return a+b def substract(a,b): return a-b def multiply(a,b): return a*b def divide(a,b): return a/b print('add의 결과:',add(10,20)) addition=add # 함수를 변수에 대입 print('addition의 결과:',addition(10,20)) def changefun(g,a,b): return g(a,b) print('결과:',changefun(add,10,20)) # 함수를 함수의 매개변수로 전달 print('결과:',changefun(multiply,10,20)) def func_test4(): # 협업 pass result=func_test4() result is None # 객체 비교 # 파이썬: object 부모가 있음 : __class__ 속성 result.__class__ # call by reference : 원본이 변경되고 있음 # 파이썬의 변수는 전부 pointer이다.(변수가 주소를 저장하고 있음-데이터를 저장하지 않음) # mylist2 스택에서의 위치: 들어있는 데이터는 mylist의 주소값값 def changeme(mylist2): # list는 되고, tuple은 안됨 mylist2.append([1,2,3,4]) # 변화 print('함수 내부에서 출력:',mylist2) return mylist=[10,20,30] # heap -> 주소가 저장됨 changeme(mylist) changeme(mylist) changeme(mylist) changeme(mylist) print('함수 외부에서 출력:',mylist) # call by value와 같이 작동하려면 def changeme(mylist): mylist=[1,2,3,4] # 대입 mylist.append([1,2]) print('함수 내부에서 출력:',mylist) return mylist=[10,20,30] changeme(mylist) changeme(mylist) print('함수 외부에서 출력:',mylist) # 변동 매개변수 def func1(*args): # list for i in args: print(i,end=',') print() print('시작') func1(1,2,3) func1(1,2,3,4,5) func1(1,2,3,4,5,6,7) def var_parameter(*args,**kwargs): print('list 매개변수는 ',args) print('key 매개변수는 ',kwargs) return var_parameter(1,2,3,z=5,y=3) def say_hello_then_call(f,*args,**kwargs): # 받을 때는 묶고 print('list 매개변수는 ',args) print('key 매개변수는 ',kwargs) print('함수를 호출 %s'%f) return f(*args, **kwargs) # 사용시에는 풀고 def g(x,y,z=1): # x=1, y=2, z=5 print(x) print(y) print(z) return (x+y)/z say_hello_then_call(g,1,2,z=5) # 멀티 리턴 def func_test3(a,b): return a+b, a-b, a*b # -> tuple로 리턴 a=func_test3(10,5) print(a) a,b,c=func_test3(10,5) print(a,b,c) # 재귀함수 def power(r,n): value=1 # 지역변수 for i in range(1,n+1): value=r*value return value print(power(2,3)) def power(r,n): if n==1: # 반드시 종료조건 => 무한루프 => stack overflow => 프로그램 중단 return r else: return r* power(r,n-1) print(power(2,3)) # factorial(5) = 5*4*3*2*1 # 문제 # factorial을 함수의 재귀호출 방법을 이용해서 해결하시오 def factorial(n): if n<=1: # 종료조건 return 1 return n*factorial(n-1) factorial(5) # 내부함수 def outer(): def inner(): print('inner') inner() outer() # generator: 메모리 낭비가 심한 경우, 너무 데이터가 많아서 직접 입력하기 어려운 경우에 사용 import random def gaus_dist(n): while n>0: yield random.random() # 0-1사이의 난수: 중지(대기상태) n-=1 gd=gaus_dist(5) for i in gd: print(i) # clouser def make_closer(a): b=10 def closure(): print('나는 호출한 함수의 매개변수와 지역변수를 알고있다.: %d %d'%(a,b)) return closure # 내부함수 리턴 closure=make_closer(5) # 내부함수를 참조하고 있어서 외부함수를 메모리에서 삭제할 수 없다. closure() closure() closure() def format_and_pad(template, space): # 출력형태, 출력자리수 def formatter(x): return (template % x).rjust(space) return formatter fmt = format_and_pad('%.4f',15) print(fmt(1.756)) print(fmt(2.222)) fmt2=format_and_pad('%d',15) print(fmt2(1.756)) # 문제 # 총 근무시간(hours)과 시간당 급여(wage)를 입력받아 주급을 계산하는 프로그램을 작성하시오 # 조건: 40시간이 넘으면 2배로 지급 # 함수의 매개변수는 시간당 급여와 주작업시간 basictime = 40 multiple = 2 def pay(wage, hours): if hours <= basictime: amount = wage * hours else: amount = (wage * basictime) + (wage * multiple * (hours - basictime)) return amount hourlywage = eval(input("시간당 급여는 ")) hoursworked = eval(input("주간 총 근무시간 ")) earnings = pay(hourlywage, hoursworked) print('주간 수입은 : {0:,}원'.format(earnings)) # 문제 # 이자율이 주어졌을 때 기간 거치후의 총액과 이자수익율 출력(복리계산) # 원금*((1+이자율)**거치기간) # 자연대수 2.718 # 이자율은 2.25/100 INTEREST_RATE = 2.25/100 # principal 원금 # balance 잔액 def balanceAndInterest(principal,numYear): balance=principal*((1+INTEREST_RATE)**numYear) interestEarned = balance-principal return balance, interestEarned def main(): origin=eval(input('예금액')) numberOfYears = eval(input('기간:')) (bal, intEarned) = balanceAndInterest(origin, numberOfYears) print('총금액:{0:,.2f}원 이자수익:{1:,.2f}원'.format(bal,intEarned)) averagevalueofChage=(bal-origin)/numberOfYears print('평균변화액은',averagevalueofChage) print('평균이자율은',round(averagevalueofChage/origin ,3)) main() # 위 내용을 입력, 처리, 출력함수로 분할해서 처리 def getInput(): origin = eval(input('예금액:')) numberOfYears = eval(input('기간:')) return(origin, numberOfYears) def balanceAndInterest(origin, numYears): INTEREST_RATE=.04 balance = origin*((1+INTEREST_RATE)** numYears) interestEarned=balance-origin return(balance, interestEarned) def displayOutput(bal,intEarned): print('예금총액: {0:,.2f}원 이자총액:{1:,.2f}원'.format(bal,intEarned)) def main(): origin, numberOfYears=getInput() bal, intEarned = balanceAndInterest(origin, numberOfYears) displayOutput(bal, intEarned) main() # 3줄을 한줄로 간략하게 displayOutput(*balanceAndInterest(*getInput())) # tuple로 리턴 # 문제 # 2차원 좌표 2점 사이의 거리를 구하는 함수를 작성하시오 import math def distance_between_points(x1,y1,x2,y2): dx=x1-x2 dy=y1-y2 dist=math.sqrt(dx**2+dy**2) dist=math.sqrt(math.pow(dx,2)+math.pow(dy,2)) return dist print(distance_between_points(1,1,2,2)) a=(1,1) b=(2,2) print(distance_between_points(*a,*b)) # 문제 # 가위,바위,보 게임을 입력, 게임, 출력으로 함수화하시오 dicision=['이김','비김','짐'] def input_game(): player=input('입력하시오(0:가위,1:바위,2:보):') com=random.randint(0,2) if player.isdigit(): player=int(player)%3 else: player=9 return player, com return player, com def judge(playe,com,play,win,lose,draw): if player==com: result=1 draw+=1 elif player==(com+1)%3: win+=1 result=0 else: lose+=1 result=2 play+=1 return result,player,com,play,win,lose,draw def printgame(result): print('당신이',dicision[result]) def lastprint(play,win,lose,draw): print('게임종료') print('게임전적은',play,'전',win,'승',lose,'패',draw,'무') if (win>0 and play>0): print('승률:',round(win/play,4)*100) play=0 win=0 lose=0 draw=0 while 1: player, com=input_game() if player==9: lastprint(play, win, lose, draw) break playerwin,player,com, play,win,lose,draw=judge(player,com,play,win,lose,draw) printgame(playerwin) ``` ``` # 과제 # 성적프로그램을 함수화 # 입력함수, 계산함수, 학점함수, 출력함수, 등수함수, 메뉴화함수(메뉴:입력,계산,학점계산,출력,등수,종료) # 입력함수 def input_scores(): num_students = int(input("학생 수를 입력하세요 : ")) students = [] for i in range(num_students): name = input(f"{i+1}번째 학생의 이름을 입력하세요 : ") korean_score = int(input(f"{name}의 국어 점수를 입력하세요 : ")) english_score = int(input(f"{name}의 영어 점수를 입력하세요 : ")) math_score = int(input(f"{name}의 수학 점수를 입력하세요 : ")) students.append((name, korean_score, english_score, math_score)) return students # 계산함수 def calculate_scores(students): total_score = 0 for i, student in enumerate(students): name = student[0] score = sum(student[1:]) # 국어, 영어, 수학 점수를 합산 total_score += score print(f"{name}의 총점 : {score}") average_score = total_score / (len(students) * 3) # 과목수 3으로 나누어 평균 계산 return total_score, average_score # 학점함수 def grade(score): if score >= 90: return 'A' elif score >= 80: return 'B' elif score >= 70: return 'C' elif score >= 60: return 'D' else: return 'F' def print_scores(students): print("성적표") for student in students: name = student[0] score = student[1] grade_score = grade(score) print(f"{name}: {score}, {grade_score}") # 등수함수 def calculate_ranks(students): sorted_students = sorted(students, key=lambda x: sum(x[1:]), reverse=True) # 국어, 영어, 수학 점수 합산하여 정렬 ranks = [] for i, student in enumerate(sorted_students): name = student[0] total_score = sum(student[1:]) # 국어, 영어, 수학 점수를 합산 rank = i + 1 ranks.append((name, total_score, rank)) return ranks # 메뉴화 함수 # 메뉴 : 입력, 계산, 학점계산, 출력, 등수, 종료 def menu(): students = [] while True: print("1. 성적 입력") print("2. 성적 계산") print("3. 학점 계산 및 출력") print("4. 등수") print("5. 종료") choice = input("선택 : ") if choice == "1": students = input_scores() elif choice == "2": total_score, average_score = calculate_scores(students) print(f"총점 : {total_score}") print(f"평균 : {average_score}") elif choice == "3": print_scores(students) elif choice == "4": ranks = calculate_ranks(students) print("등수표") for rank in ranks: name = rank[0] score = rank[1] rank = rank[2] print(f"{rank}등: {name}({score}점)") elif choice == "5": print("프로그램을 종료합니다.") break else: print("잘못된 입력입니다. 다시 입력하세요.") menu() ``` # 4/14 ``` # 파이썬 class의 특징 - 객체 지향정신의 기준 - 캡슐화: 데이터 보호 => public으로 풀림 - 추상화: 메시지에 의한 데이터 송수신(멤버변수는 고려할 필요없이), 실세계->class - 다형성 - overloading: 파이썬 문법구조속에서 자연해결, default 매개변수로 해결 - overriding: 더욱 발전 - object(__call__, __init__, __repr__) - 구조적인 면 - 생성자는 __init__가 대신 - 멤버변수는 함수 안에서만 작성 - 클래스의 멤버변수는 공유변수 - 멤버변수나 멤버함수는 self를 붙여서 사용 - 함수에서 정의되는 변수: 지역변수라고 함 - 자료구조적인 면 - 기본적으로 이질적 데이터를 담은 배열 - 클래스는 기본적으로 1차원 배열과 같은 역할 - 클래스를 리스트에 담으면 2차원 배열과 같은 효과가 있음 width=10 height=20 area=width*height/2 print('삼각형의 넓이는',area) def calctri(width, height): area = width*height/2 return area print('삼각형의 넓이는',calctri(width,height)) # 클래스내 함수의 첫번째 매개변수는 반드시 self이어야 함 # 멤버변수는 초기화할 때나 사용할 때 항상 self를 붙임 class Triangle: def setData(self, width, height): # 초기화 함수 self.width=width # 멤버변수 self.height=height def area(self): return self.width*self.height/2 tri1=Triangle() tri1.setData(10,20) print(tri1.width, tri1.height, tri1.area()) # 클래스가 메모리에서 사라지는 경우는 참조가 없어지면 메모리는 자동청소(gabage collection) # 참조를 없애는 방법: 변수 -> 주소 -> 데이터가 있는 메모리 del(변수) class Triangle: def __init__(self, width, height): # 생성자: 인스턴스될 때 자동으로 호출 self.width=width # public 기본이 self.height=height def area(self): return self.width*self.height/2 tri1=Triangle(10,20) print(tri1.width, tri1.height, tri1.area()) class C: def __init__(self): self.__x=None # __ 두개가 붙으면 private변수: 직접 접근이 불가 def getx(self): return self.__x def setx(self, value): self.__x = value def delx(self): del self.__x test=C() test.setx(100) #test.getx() #test.__x # 없어도 되지만 명시적으로 object를 상속 # 인스턴스 여부: 자바에서는 new class MyClass(object): # template """클래스의 예""" i=12345 # 클래스변수 - 한번만 메모리 생성(static 만들어진다는 의미) def __init__(self): self.i=54321 num=100 def f(self): return self.i print(MyClass.__doc__) print(MyClass.i) myclass=MyClass() # 자바적 의미의 인스턴스 => heap에 데이터 저장 print(myclass.i) myclass.f() # time 1970.1.1 이후로의 tick(m초) from time import time, ctime, sleep # class는 멤버변수+멤버함수(method) # 멤버함수는 정의시 한 번 생성되고 멤버변수만 인스턴스할 때 heap영역에 메모리를 형성 class Life: def __init__(self): # 생성자 self.birth=ctime() # 시간을 문자열로 print('생성',self.birth) def __del__(self): # 소멸자: garbage collection print('사망',ctime()) def test(self): # mylife=Life() print('3초 동안 sleeping') sleep(3) li=Life() # 인스턴스 하는 순간 => heap영역의 주소 li.test() del li # 주소값만 지운 것: 참조주소가 없어짐 print(time()) # class # 함수: 데이터가 밖에 있고 함수로 전달해서 처리한 다음 return # 데이터도 내부에 있고 처리도 내부(자료구조+알고리즘) # template: 꼴, 형태 class Employee: empCount=0 # 클래스변수: 공유변수(해당 클래스를 인스턴스하는 것들끼리 공유) def __init__(self, name, salary): self.name=name # 멤버변수 self.salary=salary Employee.empCount+=1 # 인스턴스하지 않고 사용가능 => 인스턴스할 때마다 숫자가 늘어남 def displayCount(self): print('직원수=%d'%Employee.empCount) def displayEmployee(self): print('이름:',self.name,'급여:',self.salary) def __call__(self,*pargs, **kargs): # class를 함수처럼 사용하게 하기위하여 오버라이딩 print('Called:',pargs,kargs) # 함수는 일급객체(함수가 클래스다) # 클래스도 함수처럼 사용할 수 있다. emp=Employee('김은경',500) # empCount==1 emp.displayCount() emp1=Employee('은걍',500) # empCount==2 emp1.displayCount() emp.displayCount() emp("뭉걍",500,100,c=100) # 클래스를 함수처럼 실행시키면 __call__ 작동 emp1.age=7 # 멤버변수 추가 emp1.age=8 # 수정 hasattr(emp1,'name') hasattr(emp1,'age') getattr(emp1,'age') setattr(emp1,'age',8) delattr(emp1,'age') # 파이썬 자체가 변수들을 저장할 때 dict(검색속도가 빠름)형식으로 저장 print(emp.__dict__) print(Employee.empCount) print(emp1.__dict__) print('Employee.__doc__:',Employee.__doc__) print('Employee.__name__:',Employee.__name__) print('Employee.__bases__:',Employee.__bases__) print('Employee.__dict__:',Employee.__dict__) # 문제 # 이름과 나이를 저장하는 Student class를 생성하시오 # 이름과 나이를 출력하는 print함수를 작성하시오 class Student: """학생관리""" def __init__(self,name,age): self.name=name self.age=age def print(self): print("이름:",self.name," 나이:",self.age) def __repr__(self): return '이름: '+self.name+" 나이: "+str(self.age) stu=Student('뭉걍',20) stu.print() print(stu) stu.__doc__ print(stu.__class__) stu.__class__('테스트',30) class FourCal: def __init__(self, first, second): self.first=first self.second=second def mul(self): result=self.first*self.second return result def sub(self): result=self.first-self.second return result def div(self): result=self.first/self.second return result def all_cal(self): result2=self.mul() result3=self.sub() result4=self.div() return result2+result3+result4 fourcal=FourCal(100,200) fourcal.all_cal() def addnum(a,b): # 함수도 실시간으로 추가가 가능 return a+b # 파이썬의 함수는 일급객체: 변수대입도 가능, 매개변수로 전달 가능, 멤버변수에도 대입이 가능 fourcal.sum=addnum print(fourcal.sum(fourcal.first.fourcal.second)) # 파이썬에서는 모든 변수가 포인터 -> 복사가 필요할 때가 있음 import copy a=[1,2,3] b=[4,5,a] x=[a,b,100] # 주소로 연결 # y = x y=copy.copy(x) # 데이터를 복사 a.append(2000) print("a=",a) print(x) print(y) y2=copy.deepcopy(x) # 데이터만 가지고 별도의 공간을 만듬 a[0]=100 print(y) print(y2) # chaining # 일반함수나 멤버함수나 동일 구조에서 실행 class Person: def name(self,value): self.name=value return self # this 같은 역할 -> 메모리에서 클래스가 있는 주소 대입 def age(self,value): self.age=value return self def introduce(self): print('이름:',self.name,", 나이:",self.age) person=Person() person.name("뭉걍").age(21).introduce() # 클래스 구성: 클래스변수(공유변수,인스턴스하지 않고 사용가능)+멤버변수+멤버함수 # staticmethod: 인스턴스하지 않고 사용할 수 있는 함수 # 데코레이터를 이용해서 표현 class StaticTest(): def spam(x,y): print('정적함수',x,y) spam=staticmethod(spam) @staticmethod def spam1(x,y): print('일반함수',x,y) StaticTest.spam(1,2) StaticTest.spam1(1,2) # classmethod from datetime import date class Person: def __init__(self,name,age): # 파이썬에는 오버로딩이 없음 self.name=name self.age=age @classmethod # class: 아직 초기화되지 않은 상태에서 초기화되기 때문에 def fromBirthYear(cls,name,birthYear): return cls(name, date.today().year-birthYear) def display(self): print(self.name+'의 나이는:'+str(self.age)) person=Person('강감찬',19) person.display() person1=Person.fromBirthYear('을지문덕',1985) person1.display() class Guard: def three_point(self): print('가드는 3점슛 장착') def apass(self): print('가드의 핵심은 에이패스지') class Jordan: def three_point(self): print('조단은 3점슛 장착') def apass(self): print('조단은 에이패스 가능') def inhecourt(duck): duck.three_point() duck.apass() gu=Guard() jo=Jordan() inhecourt(gu) inhecourt(jo) ``` ``` # 문제 # Point 클래스를 작성 # x,y좌표가 멤버변수이고, 두 point간의 거리를 구하는 함수 작성 # 두 개의 거리값이 3보다 작으면 충돌을 확인하는 함수 작성 # 충돌확인함수를 이용해서 충돌 여부를 출력하는 함수를 작성 # 좌표값을 출력하는 함수 작성 import math class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def distance(self, other): dx = self.x - other.x dy = self.y - other.y return math.sqrt(dx*dx + dy*dy) def is_collision(self, other): distance = self.distance(other) if distance<3: return distance else: return "거리값이 3 이상" def print_coordinates(self): print("({}, {})".format(self.x, self.y)) def print_collision_status(self, other): if self.is_collision(other): print("두 점이 충돌했습니다.") else: print("두 점이 충돌하지 않았습니다.") point1 = Point(0, 0) point2 = Point(0, 1) point1.print_coordinates() # (0, 0) point2.print_coordinates() # (3, 4) distance = point1.distance(point2) print(distance) # 5.0 collision = point1.is_collision(point2) print(collision) # False point1.print_collision_status(point2) # 두 점이 충돌하지 않았습니다. class Rectangle: # 좌표 2개(Point class 사용) # 면적, 둘레, 대각선 길이 # 두 사각형의 충돌여부 # 충돌결과를 출력하는 함수 def __init__(self,x,y,width,height): self.width = width self.height = height self.center = Point(x,y) def area(self): return self.width * self.height def perimeter(self): return 2*(self.width + self.height) def diagonal(self): return math.sqrt(self.width**2 + self.height**2) def intersect(self, other): return not(self.center.x + self.width < other .center.x or other.center.x + other.width < self.center.x or self.center.y + self.height < other.center.y or other.center.y + other.height < self.center.y) def print_col(self, other): if self.intersect(other): print("두 사격형이 충돌합니다.") else: print("두 사각형이 충돌하지 않습니다.") rect = Rectangle(1,1,1,1) rect2 = Rectangle(2,2,2,2) print('넓이:', rect.area()) print('둘레:', rect.perimeter()) print('대각선 길이', rect.diagonal()) print('넓이:', rect2.area()) print('둘레:', rect2.perimeter()) print('대각선 길이', rect2.diagonal()) rect.print_col(rect2) ``` # 4/17 ``` import math class Point: # 클래스변수, 멤버변수, 함수의 지역변수 def __init__(self,x,y): self.x=x self.y=y def __repr__(self): return '좌표는 (%d %d) '%(self.x, self.y) def origindist(self): return math.sqrt(self.x**2 + self.y**2) # 점 하나의 원점으로부터의 거리 def dist(self,other): # 두 점 사이의 거리값을 구하는 함수 distance = math.sqrt((self.x-other.x)**2 + (self.y-other.y)**2) return distance def collision(self,other): return self.dist(other)<3 # True/False 를 리턴 def collisionUI(self,other): # 함수는 최소단위 작업을 해결하는 것 if self.dist(other): print('충돌했습니다') else: print('충돌하지 않았습니다') first = Point(7,3) second = Point(4,7) print(first) print(second) print('두 점 사이의 거리는',first.dist(second)) first.collisionUI(second) if first.collision(second): print('충돌했습니다') else: print('충돌하지 않았습니다') class Circle: def __init__(self,center,radius): self.center=center # Point: 관계 Association self.radius=radius def area_calc(self): return math.pi * float(self.radius**2) def perimeter(self): return 2 * math.pi * self.radius def collision(self,other): if self.center.dist(other.center) < self.radius + other.radius: result = '충돌한다' else: result = '충돌하지 않는다' return result def __repr__(self): return '원의 중심은 '+str(self.center)+'반지름은 '+str(self.radius) first = Point(7,3) second = Point(4,7) cir = Circle(first,1) # 센터점에 대한 데이터가 밖에 있음 cir2 = Circle(second,5) print(cir) print(cir2) cir.collision(cir2) # vector # 거리값 ,+,-,*,/ # vec = [1,2,3], vec2 = [2,3,4] # 위 두 벡터를 더하면 [3,5,7] # +,-,*,/ 인 경우는 요소끼리 연산: 연산자 오버로딩이 필요함 # 10+20 => 30 , 'str' + 'Str' => strStr # Vector(10,20) + Vector(20,30) class Vector: # 거리값, 방향값 def __init__(self,x,y): self.x=x self.y=y def __add__(self,other): return Vector(self.x+other.x,self.y+other.y) def __mul__(self,other): return Vector(self.x*other.x, self.y*other.y) def __sub__(self,other): return Vector(self.x-other.x, self.y-other.y) def __truediv__(self,other): return Vector(self.x/other.x, self.y/other.y) def __repr__(self): return '(좌표는 %d,%d) '%(self.x,self.y) f = Vector(100,23) g = Vector(20,27) print(f) print(f+g) print(f-g) print(f*g) print(f/g) # vector 연산 - 단일 vector인 경우: 크기와 방향(normalize) - 두 개의 vector인 경우: - 요소끼리 연산하는 경우(+,-,*,/) - 두 벡터의 크기값(거리값 dist) - 두 벡터의 내적 및 사이각(dot, theta) class Vector: def __init__(self,x,y,z): self.x=x self.y=y self.z=z def __add__(self,other): return Vector(self.x+other.x, self.y+other.y,self.z+other.z) def __mul__(self,other): return Vector(self.x*other.x, self.y*other.y, self.z*other.z) def __sub__(self,other): return Vector(self.x-other.x, self.y-other.y, self.z-other.z) def __truediv__(self,other): return Vector(self.x/other.x, self.y/other.y, self.z/other.z) def norm(self): # 크기값만 구할 때 return math.sqrt(self.x**2 + self.y**2 + self.z**2) def normalize(self): # 방향값만 구할 때 norm=self.norm() return(self.x/norm, self.y/norm, self.z/norm) # 크기값은 1인 값으로 변환 def dist(self, other): return math.sqrt((self.x - other.x)**2 + (self.y-other.y)**2 + (self.z-other.z)**2 ) def dot(self,other): # 내적 return (self.x*other.x + self.y*other.y + self.z*other.z) def costheta(self,other): dot = self.dot(other) norm1 = self.norm() # A의 norm norm2 = other.norm() # B의 norm return dot/(norm1*norm2) def theta(self,other): costheta = self.costheta(other) return math.acos(costheta)*(180/math.pi) # 라디안을 degree로 변환 def __repr__(self): return 'x:'+str(self.x)+'\ty:'+str(self.y)+'\tz:'+str(self.z) f = Vector(10,0,0) g = Vector(0,27,0) # 내적 == 0, 각도로는 90도 print(f) print(g) print(f+g) print('f벡터의 크기', f.norm()) print('g벡터의 크기', g.norm()) print('f의 normalize:',f.normalize()) # 방향값 print('g의 normalize:',g.normalize()) print('두 벡터의 내적 =',f.dot(g)) #0 print('두 벡터의 사이각은', f.theta(g)) #90 print('두 벡터의 코사인 사이각은', f.costheta(g)) # 리스트, dict d = {'one':1, 'two':2} print(d.items()) print(d.keys()) print(d.values()) # 데이터 리스트가 됨 d['one'] d = {'a':10, 'b':20, 'c':30} print(d['a']) print(d.get('z',-1)) # 값이 없을 때 에러 발생 print(d.__class__) # object를 상속 name={} # 중괄호로 초기화하면 dict, set add={} add={'서울'} # 키 - set name['kim'] = '충북' # 입력 name['대한'] = '대전' name['대한'] = add # 수정 print(name['kim']) name del(name['kim']) name adbook = {'고효경':['번호 : 010 4895 7885', '주소: 서대문구'], '양다혜':['번호 : 010 1234 5678', '주소 : 양천구']} def create(adbook): name=input('이름을 입력하시오:') callnum=input('전화번호를 입력하시오:') add=input('사는 지역을 입력하시오:') tot=[] tot.append('번호: %s'%callnum) tot.append('주소: %s'%add) newperson={name:tot} adbook.update(newperson) print(adbook) return def read(adbook): name=input('이름을 입력하시오:') if name in adbook: print(name, adbook.get(name)) else: print('찾는 이름이 없습니다.') return def update(adbook): name=input('이름을 입력하시오:') if name in adbook: a=adbook.get(name) keys=input('번호수정:0, 주소수정:1 을 입력하시오') if keys=='0': b=input('수정할 번호 입력') a[0]= '번호: %s'%b elif keys=='1': c=input('수정할 주소 입력') a[1]='주소: %s'%c else: print('찾는 이름이 없습니다.') print(name, adbook.get(name)) return def delete(adbook): name=input('이름을 입력하시오:') if name in adbook: del(adbook[name]) print('삭제완료',adbook) else: print('없는 이름입니다.') return menu=['새로운 사람 입력(1), 검색(2), 수정(3), 삭제(4), 종료(9)'] while 1: sel = input(menu) if sel == '1': create(adbook); continue elif sel == '2': read(adbook); continue elif sel == '3': update(adbook); continue elif sel == '4': delete(adbook); continue elif sel == '9': break else: print('잘못된 입력입니다. 다시입력하세요.'); continue # 상속 base = dir(object) print(base) class Parent(object): # 공통부분을 정의하고 공유 def myMethod(self): print('부모메쏘드') class Child(Parent): def myMethod(self): # 재정의 print('자식메쏘드') ch=Child() ch.myMethod() print(dir(ch)) class Parent: parentAttr=100 def __init__(self,name): # 부모의 생성자 self.name=name print('부모 생성자') def parentMethod(self): print('부모메쏘드',self.name) def setAttr(self,attr): Parent.parentAttr=attr def getAttr(self): print('부모속성:',Parent.parentAttr) class Child(Parent): # 자식의 생성자가 없으면 상속받은 부모의 생성자를 호출 def __init__(self): # 자식의 생성자 : 우선해서 호출 Parent.__init__(self,'선문') # 원칙은 부모의 생성자를 명시적으로 호출하는 것이 불가 print('자식 생성자') def childMethod(self): print('자식메쏘드') def print_attribute(self): self.setAttr(500) print('자식 호출된 부모 속성:',Parent.parentAttr) c=Child() c.parentMethod() class Point3D(Point): def __init__(self,x,y,z): Point.__init__(self,x,y) self.z=z def translate(self,dx,dy,dz): Point.translate(self,dx,dy) self.z += dz # 문제 import math class Point: # association해서 구현 def __init__(self,x,y): self.x=x self.y=y class Shape: # 상속: 실수하지 않고 단일이름으로 사용하기 위해서서 def area_calc(self): print('면적') def perimeter(self): print('둘레') # 상속을 받아 Triangle, Rectangle, Circle의 둘레와 면적을 출력하는 함수들을 오버라이딩해서 구현하시오 class Triangle(Shape): def __init__(self,top,left,right): # Point(3점) self.top=top self.left=left self.right=right def perimeter(self): # 피타고라스 정리 top_left=math.sqrt((self.top.x - self.left.x)**2 + (self.top.y-self.left.y)**2) left_right = math.sqrt((self.left.x-self.right.x)**2 + (self.left.y-self.right.y)**2) right_top=math.sqrt((self.right.x-self.top.x)**2 + (self.right.y-self.top.y)**2) return '삼각형의 둘레는 '+str(top_left + left_right + right_top) # 내적은 사이각을 계산하기 위해서 사용 # 외적은 광원(빛)을 얼마나 받는지: 외적의 크기는 두 벡터가 이루는 마름모꼴의 넓이이다. # 외적은 3차원이 되어야 가능: z=0으로 놓고 구함 def area_calc(self): # 외적을 이용해서 삼각형의 면적(외적의 정의: 구 벡터의 수직하는 벡터) area = 0.5*(abs(self.top.y-self.left.y)*abs(self.right.x-self.left.y) - abs(self.top.x - self.left.x)*abs(self.right.y-self.left.y)) return '삼각형의 면적은 '+str(area) class Rectangle(Shape): def __init__(self,lefttop,rightdown): self.lefttop=lefttop self.rightdown=rightdown def area_calc(self): area=abs((self.lefttop.x-self.rightdown.x)+(self.lefttop.y-self.rightdown.y)) return '사각형의 면적은'+str(area) def perimeter(self): peri=abs(self.lefttop.x - self.rightdown.x)*2 + abs(self.lefttop.y-self.rightdown.y)*2 return '사각형의 둘레는'+str(peri) class Circle(Shape): def __init__(self,center,radius): self.center=center self.radius=radius def area_calc(self): area=math.pi * float(self.radius^2) return '원의 면적은'+str(area) def perimeter(self): peri=2*math.pi+float(self.radius) return '원의 둘레는'+str(peri) import random # 파이썬에서는 상속개념을 가지지 않더라도 가능 # 반드시 오버라이딩하게 생성 # 코드의 통일성을 가하기 위해 상속을 써서 해결(반드시 사용하지 않아도 됨) shape_list=[] # 이질적인 데이터(데이터 타입도 지정하지 않음) for i in range(100): rand=random.randint(0,10) if rand%3==0: tri=Triangle(Point(10,20), Point(0,0), Point(20,0)) shape_list.append(tri) elif rand%3==1: rect=Rectangle(Point(10,20),Point(20,30)) shape_list.append(rect) else: circle=Circle(Point(10,20),5) shape_list.append(circle) for i in range(5): print(shape_list[i].area_calc()) print(shape_list[i].perimeter()) # 대표 타입(부모-delegate) class Evaluation: def printcalcGrade(self,average): pass class Hakjum(Evaluation): def printcalcGrade(self, average): if average >= 90: return 'A' elif average >= 80: return 'B' elif average >= 70: return 'C' elif average >= 60: return 'D' else: return 'F' class Evaluation_print: # 운용 def print_evaluation(self,evaluation): jumsu=eval(input('점수를 입력하시오')) print(evaluation.printcalcGrade(jumsu)) # 문제 # 합격/불합격으로 평가하는 클래스 # 수우미양가로 평가하는 클래스를 만들어서 선택적으로 사용하도록 클래스를 작성해보시오 class Pass_Fail(Evaluation): def printcalcGrade(self, average): if average >= 60: return "합격" else: return "불합격" class Element_Evaluation(Evaluation): def printcalcGrade(self, average): if average >= 90: return "수" elif average >= 80: return "우" elif average >= 70: return "미" elif average >= 60: return "양" else: return "가" class Evaluation_print: # 운용 def print_evaluation(self,evaluation): jumsu=eval(input('점수를 입력하시오')) print(evaluation.printcalcGrade(jumsu)) ha = Hakjum() pf= Pass_Fail() ee= Element_Evaluation() ev= Evaluation_print() ev.print_evaluation(ee) evaluation_method=[] evaluation_method.append(ha) evaluation_method.append(pf) evaluation_method.append(ee) for evalu in evaluation_method: ev.print_evaluation(evalu) class A: def m(self): print('A.m()호출') class B(A): def m(self): print('B.m()호출') class C(A): def m(self): print('C.m()호출') class D(B,C): # 다이아몬드형 다중상속 # B만 호출, C는 에러발생, 자바는 아예불가능-단독상속만 가능 pass d=D() d.m() class Person: def __init__(self): # object self.__name='1person' # private멤버변수 print('1사람') def printname(self): print(self.__name) class Student(Person): def __init__(self): self.name='2student' Person.__init__(self) print('2학생') class Worker(Person): def __init__(self): self.name='3worker' Person.__init__(self) print('3기술자') # 파이썬은 오버로딩이 없으니까 나중에 선언된 함수나 클래스가 우선 class PartTimer(Student,Worker): # 뒤에 있는 것이 찍힘: 뒤에 있는 것이 앞의 것을 지운다(오버로딩) def __init__(self): Student.__init__(self) Worker.__init__(self) print('Student.name') def print(self): print('이건 결합') pt = PartTimer() print(pt.print()) # 자식함수 print('테스트') print(pt.name) print(pt.printname()) # 문제 class Person(object): my_class_vaf="대전융합교육원" def __init__(self,year,month,day,sex): self.year=year self.month=month self.day=day self.sex=sex def __str__(self): return '{}년 {}월 {}일생 {}입니다.'.format(self.year, self.month, self.day, self.sex) # 주민번호를 입력받아 초기화할 수 있도록 프로그램하시오 # 파이썬을 오버로딩이 안되기 때문에 classmethod 이용, ssn_constructor # 생년월일: sex - 1,2 2000년도 이후에 태어난 사람은 3,4 @classmethod def ssn_constructor(cls,ssn): # 첫번째 매개변수가 class이다.(self가 아님) front, back=ssn.split('-') sex=back[0] if sex=='1' or sex=='2': year = '19'+front[:2] else: year='20'+front[:2] if(int(sex)%2)==0: sex='여성' else: sex='남성' month=front[2:4] day=front[4:6] return cls(year,month,day,sex) # __init__호출 # 문제 # 날짜가 주말인지 여부를 출력하는 정적함수를 작성해보시오 # weekday()함수 사용시 0~6까지 수를 리턴 @staticmethod def is_work_day(day): # self가 없음, 인스턴스 없이 바로 사용가능 if day.weekday() == 5 or day.weekday() == 6: return False return True ssn_1='990120-103456' ssn_2='101224-4061569' person_1=Person.ssn_constructor(ssn_1) print(person_1) person_2=Person.ssn_constructor(ssn_2) print(person_2) import datetime my_date=datetime.date(int(person_1.year), int(person_1.month),int(person_1.day)) print(Person.is_work_day(my_date)) my_date=datetime.date(2023,4,16) print(Person.is_work_day(my_date)) # Clock class Clock: def __init__(self,hours=0,minutes=0,seconds=0): self.__hours=hours self.__minutes=minutes self.__seconds=seconds def set(self, hours, minutes, seconds=0): self.__hours=hours self.__minutes=minutes self.__seconds=seconds def tick(self): if self.__seconds==59: self.__seconds=0 if self.__minutes==59: self.__minutes=0 if self.__hours==23: self.__hours=0 else: self.__hours+=1 else: self.__minutes+=1 else: self.__seconds+=1 def display(self): print('%d:%d:%d'%(self.__hours,self.__minutes,self.__seconds)) def __repr__(self): return'%2d:%2d:%2d'%(self.__hours,self.__minutes,self.__seconds) def check(self): if self.__hours==0 and self.__minutes==0 and self.__seconds==0: return True else: return False x=Clock() print(x) for i in range(20000): x.tick() print(x) # Calendar class Calendar: month=(31,28,31,30,31,30,31,31,30,31,30,31) # 클래스 변수 def __init__(self,year=1900,month=1,day=1): self.__year=year self.__month=month self.__day=day def leapyear(self,y): # 윤년 if y%4: return 0 else: if y%100: return 1 else: if y%400: return 0 else: return 1 def set(self,year,month,day): self.__year=year self.__month=month self.__day=day def get(self,year,month,day): return (self.__year, self.__month, self.__day) def advance(self): month=Calendar.month max_day=month[self.__month-1] if self.__month == 2: max_day += self.leapyear(self.__year) if self.__day==max_day: self.__day=1 if (self.__month==12): self.__month=1; self.__year+=1; else: self.__month+=1 else: self.__day+=1 def __repr__(self): return str(self.__year) + '/' + str(self.__month)+'/'+str(self.__day) x=Calendar() for i in range(365*123): x.advance() print(x) # 문제 # 두 개의 클래스를 다중상속 받은 CalendarClock 클래스를 선언하고 # 두 개의 클래스 잘 작동해서 시간이 지나면 날짜도 연계해서 작동하도록 프로그램을 구현하시오 class CalendarClock(Clock, Calendar): def __init__(self,year=1900,month=1,day=1,hours=0,minutes=0,seconds=0): Calendar.__init__(self,year,month,day) Clock.__init__(self,hours,minutes,seconds) def __repr__(self): return Calendar.__repr__(self)+'.'+Clock.__repr__(self) def tick_advance(self): self.tick() if self.check(): # 0:0:0 self.advance() x=CalendarClock(2020,1,1) print(x) for i in range(60*60*24): x.tick_advance() print(x) ``` # 4/18 ``` !uname -a # 학습결과 -> 구글 드라이브에 저장 -> 다시 로딩해서 학습(딥러닝:가중치를 학습) # shell명령 앞에는 ! 붙여야 함 !pip install pymysql import pymysql con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) # DDL : data definition language # creat(db, table), drop(삭제), alter(수정) # DML : data management language # select, insert into, update set, delete from : transaction 대상, trigger의 대상, commit의 대상 # 데이터베이스에 영향을 미치는 명령 # commit 해야됨 # DCL : data control language # grant, # TCL : transaction control language # 예외처리 # connection객체(연결객체) # cursor객체(Query문을 실행하는 객체) # cur = con.cursor() try: with con.cursor() as cur: # with문 안에서 객체를 생성하면 with문 종료와 더불어 객체도 닫힌다. cur.execute("select * from student") # resultset으로 도착 (형식이 DB와 같음) rows=cur.fetchall() # fetchone(),fetchmany(),fetchall() # 파이썬에서 다량의 데이터를 사용하는 방법: list, dict => default가 list다. desc=cur.description for row in rows: print(f'{row[0]},{row[1]},{row[2]},{row[3]}') finally: con.close() # os 차원에서 관리됨, 자원이 한정되어있음 print(desc) print([i[0] for i in cur.description]) # 열 이름만 선택 # 문제 # 이름을 출력하고 데이터를 출력해보시오 import pymysql con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) try: with con.cursor() as cur: cur.execute("select * from student") rows=cur.fetchall() desc=cur.description print(f'{desc[0][0]:<4} {desc[1][0]:>10} {desc[2][0]:>12} {desc[3][0]:>11}') for row in rows: print(f'{row[0]:<4} {row[1]:>10} {row[2]:>10} {row[3]:>10}') finally: con.close() # 번호가 5번 이하인 데이터만 query해 출력해보시오(번호,이름,국어,수학,영어) import pymysql con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) try: with con.cursor() as cur: cur.execute("select * from student where bunho <= 20") rows=cur.fetchall() desc=cur.description print(f'{desc[0][0]:<4} {desc[1][0]:>10} {desc[2][0]:>13} {desc[3][0]:>10} {desc[4][0]:>10}') for row in rows: print(f'{row[0]:<4} {row[1]:>10} {row[2]:>10} {row[3]:>10} {row[4]:>10}') finally: con.close() ``` # 4/19 ``` !pip install pymysql import pymysql con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) try: with con.cursor() as cur: cur.execute('SELECT * FROM student WHERE bunho IN (20,21,22)') rows = cur.fetchall() for row in rows: print(f'{row[0]:<4} {row[1]:>10} {row[2]:>10} {row[3]:>10} {row[4]:>10}') print(f'쿼리가 영향을 미친 것은 {cur.rowcount} 개의 행') finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) person=('typoon',100,100,100,'CH00000001') try: with con.cursor() as cur: cur.execute("""INSERT INTO student(name, kor, mat, eng, schoolcode) VALUES (%s, %s, %s, %s, %s)""", # 송수신은 문자열 (person[0],person[1],person[2],person[3],person[4])) con.commit() if(cur.rowcount): # 영향을 미친 행이 있으면 print('새로운 학생이 등록되었습니다.') finally: con.close() # 환각(할루시네이션): 사실 아닌 문자나 이미지를 마치 맞는 답처럼 내놓은 현상 # 문제 # 첫번째 나오는 이름을 '오환각'으로 update하시오 con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) person=('전공인','오환각') person_1=('typoon') try: with con.cursor() as cur: cur.execute("""update student set name= %s where name= %s""",(person[1],person[0])) cur.execute("""delete from student where name = %s""",person_1) con.commit() if(cur.rowcount): print('학생 이름이 수정되었습니다.') finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) try: with con.cursor() as cur: cur.execute("select * from student") rows=cur.fetchall() desc=cur.description print(f'{desc[0][0]:<4} {desc[1][0]:>10} {desc[2][0]:>12} {desc[3][0]:>11}') for row in rows: print(f'{row[0]:<4} {row[1]:>10} {row[2]:>10} {row[3]:>10}') finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) try: with con.cursor() as cur: cur.callproc('student_select') if(cur.rowcount): print(cur.fetchall()) cur.callproc('student_select') if(cur.rowcount): # 데이터가 있으면 data=cur.fetchall() for row in data: #print(row[0],row[1]) print(row['bunho'],row['name'],row['kor']) finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) data=('미래',90,80,100,'CH00000001',0) try: with con.cursor() as cur: cur.callproc('student_insert',data) cur.execute('SELECT @_student_insert_5') con.commit() result=cur.fetchone() print(result['@_student_insert_5']) finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) data = (15,'왕만덕', 100,90,80,0) try: with con.cursor() as cur: cur.callproc('student_update',data) cur.execute('select @_student_update_5') con.commit() result=cur.fetchone() print(result['@_student_update_5']) if result['@_student_update_5'] ==2: print('수정할 이름이 없습니다.') elif result['@_student_update_5']==-1: print('에러가 발생하였습니다.') elif result['@_student_update_5']==0: print('수정 성공하였습니다.') else: print('알 수 없음') finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',autocommit=True) try: with con.cursor() as cur: cur.execute("select * from student") rows=cur.fetchall() desc=cur.description print(f'{desc[0][0]:<4} {desc[1][0]:>10} {desc[2][0]:>12} {desc[3][0]:>11}') for row in rows: print(f'{row[0]:<4} {row[1]:>10} {row[2]:>10} {row[3]:>10}') finally: con.close() # 문제 # '미래'를 stored procedure call을 통해 삭제해보시오 con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='sungjuk',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) data=('미래',0) try: with con.cursor() as cur: cur.callproc('student_delete',data) cur.execute('SELECT @_student_delete_1') con.commit() result=cur.fetchone() print(result['@_student_delete_1']) if result['@_student_delete_1'] ==2: print('삭제할 이름이 없습니다.') elif result['@_student_delete_1']==-1: print('에러가 발생하였습니다.') elif result['@_student_delete_1']==0: print('삭제 성공하였습니다.') else: print('알 수 없음') finally: con.close() con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) cur = con.cursor() cur.execute("""CREATE TABLE `pet` `id` INT(11) NOT NULL AUTO_INCREMENT, `name` VARCHAR(20) NULL DEFAULT NULL, `owner` VARCHAR(20) NULL DEFAULT NULL, `species` VARCHAR(20) NULL DEFAULT NULL, `sex` CHAR(1) NULL DEFAULT NULL, `birth` DATE NULL DEFAULT NULL, `death` DATE NULL DEFAULT NULL, PRIMARY KEY (`id`) ) COLLATE='utf8mb4_general_ci' ENGINE=InnoDB ;""") con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) cur = con.cursor() sql="""INSERT INTO pet (name,owner,species,sex,birth,death) VALUES(%s,%s,%s,%s,%s,%s)""" #cur.execute(sql, ('인천시','민주','cat','f','2001-02-04',None)) #cur.execute(sql, ('대구시','자유','cat','f','2010-03-17',None)) #cur.execute(sql, ('대전시','민주','dog','f','2010-05-13',None)) #cur.execute(sql, ('광주시','민주','dog','m','2015-08-27',None)) #cur.execute(sql, ('부산시','자유','dog','m','2017-08-31','2018-04-29')) #con.commit() petlist=[('인천시','민주','cat','f','2001-02-04',None), ('대구시','자유','cat','f','2010-03-17',None), ('대전시','민주','dog','f','2010-05-13',None), ('광주시','민주','dog','m','2015-08-27',None), ('부산시','자유','dog','m','2017-08-31','2018-04-29')] cur.executemany(sql,petlist) con.commit() print(cur.description) print(cur.rowcount) con.close con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) cursor=con.cursor() cursor.execute('select * from pet') print(cursor.rowcount) cursor.fetchone() cursor.fetchone() cursor.fetchone() recs=cursor.fetchmany(2) for rec in recs: print(rec) recs=cursor.fetchall() # 커서가 마지막을 가리키고 있기 때문에 결과가 없음 for rec in recs: print('데이터가 있으면 찍힘') print(rec) cursor.close() con.close() # 문제 # 모든 pet을 가져오는 프로시저를 만들고 callproc로 데이터를 출력하시오 con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) try: cursor=con.cursor() cursor.callproc('pet_all') cur = cursor.fetchall() # stored procedure에서 select하는 것은 모두 결합되어 리턴 for row in cur: print('ID=%s, Name=%s'%(row['id'],row['name'])) cursor.nextset() for row in cur: print('ID=%s, Name=%s'%(row['id'],row['name'])) finally: cursor.close() con.close() # 생일이 2015-01-01 이후인 pet을 출력하시오 con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) try: cursor=con.cursor() cursor.execute('select * from pet where birth < "2015-01-01"') rows = cursor.fetchall() print(type(rows)) for pets in list(rows): pet = list(pets.values()) print('ID=%d, Name=%s, 주인=%s'%(pet[0],pet[1],pet[2])) finally: cursor.close() con.close() # species='cat'이고 여성만 출력하시오 # 이름과 생일을 생일로 정렬해서 출력하시오 # 사망일이 null인 것만 출력하시오 con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) try: cursor=con.cursor() cursor.execute('select name, birth from pet order by birth') cursor.execute('select name, birth from pet where death is NULL') rows = cursor.fetchall() print(type(rows)) for pets in list(rows): pet = list(pets.values()) print('ID=%d, Name=%s, 주인=%s'%(pet[0],pet[1],pet[2])) finally: cursor.close() con.close() # 이름이 대구시인 것을 부산시로 변경하시오 con = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',cursorclass=pymysql.cursors.DictCursor,autocommit=True) try: cursor=con.cursor() sql='update pet set name=%s where name=%s' cursor.execute(sql,('대구시','부산시')) con.commit print('실행완료') print(cursor.rowcount) cursor.description finally: cursor.close() con.close() # class에 데이터를 입력 # triger를 이용한 합계, 평균, 학점을 자동으로 입력하도록 stored prodcedure를 작성 import pymysql class Student: def __init__(self): self.bunho=0; self.name='' self.kor=0; self.mat=0; self.eng=0; self.total=0; self.average=0; self.grade='' def inputData(self): print('학생 데이터를 입력하시오') self.name=input('이름을 입력하시오') self.kor=eval(input('국어점수')) self.mat=eval(input('수학점수')) self.eng=eval(input('영어점수')) self.calc_total_average() def calc_total_average(self): self.total = self.kor+self.mat+self.eng self.average=round(self.total/3, 2) self.grade = self.calcSemGrade() def calcSemGrade(self): if self.average >= 90: return 'A' elif self.average >= 80: return 'B' elif self.average >= 70: return 'C' elif self.average >= 60: return 'D' else: return 'F' def __repr__(self): return '%5s %5s %6s %6s %6s %7s %7s %3s'%(self.bunho, self.name, self.kor, self.mat, self.eng, self.total, self.average, self.grade) class maria: schoolname='대전융합교육원' def __init__(self): self.conn = pymysql.connect(host='34.64.47.254',port=3306, user='root',passwd='acorn1234',db='zoo',charset='utf8',autocommit=True) cor = self.conn.cursor() cor.execute('show tables') tables=cor.fetchall() c=[] for i in tables: if i == ('sungjuk'): c.append(i) # if len(c)!=0: # sungjuk_table='select * from sungjuk' # cor.execute(sungjuk_table) # print('테이블이 있습니다.') # else: # cor.execute("""CREATE TABLE `sungjuk` ( # `bunho` INT(11) NOT NULL, # `name` VARCHAR(20) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci', # `kor` INT(11) NULL DEFAULT NULL, # `mat` INT(11) NULL DEFAULT NULL, # `eng` INT(11) NULL DEFAULT NULL, # `total` INT(11) NULL DEFAULT NULL, # `average` FLOAT NULL DEFAULT NULL, # `grade` CHAR(1) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci', # PRIMARY KEY (`bunho`) USING BTREE # ) # COLLATE='utf8mb4_general_ci' # ENGINE=InnoDB; """) def __del__(self): self.conn.close() def selectdb(self): cur=self.conn.cursor() cur.callproc('sungjuk_select') if cur.rowcount : std = list(cur.fetchall()) else: std = 0 cur.close() return std def insertdb(self,name,kor,mat,eng,result): cur = self.conn.cursor() arg= (name,kor,mat,eng,result) cur.callproc('sungjuk_insert',arg) cur.close() def updatedb(self,in_name,up_name,result): cur = self.conn.cursor() arg=(in_name, up_name,result) cur.callproc('sungjuk_update',arg) cur.close() def deletedb(self,in_name,result): cur=self.conn.cursor() arg=(in_name,result) cur.callproc('sungjuk_delete',arg) cur.close() from math import * class Management: def __init__(self): self.maria = maria() def M_select(self): data = self.maria.selectdb() st = [] if(data) : for student in data: stp = Student() stp.bunho = student[0] stp.name = student[1] # 문자, 숫자가 입력 stp.kor = student[2] stp.mat = student[3] stp.eng = student[4] stp.calc_total_average() stp.grade=student[7] st.append(stp) print(self.maria.schoolname + " 성적계산표 ") print('%5s %4s %5s %3s %3s %5s %5s %3s'%('번호', '이름', '국어', '수학','영어','합계','평균','학점')) for stud in st: print(stud) else: print("데이터가 없습니다.") def M_insert(self): stu = Student() stu.inputData() self.maria.insertdb(stu.name, stu.kor, stu.mat, stu.eng, 0) def M_update(self): name = input("검색할 이름을 입력하시요") replace_name = input("수정할 이름을 입력하시요") result = self.maria.updatedb(name, replace_name, 0) def M_delete(self): name = input("삭제할 이름을 입력하시요") self.maria.deletedb(name, 0) import sys class Menu: def __init__(self): self.manage = Management() def work(self): menu=['전체검색(1),입력(2),수정(3),삭제(4),종료(9)'] while(1): sel = input(menu) if sel == '1': self.manage.M_select() continue elif sel =='2': self.manage.M_insert() elif sel =='3': self.manage.M_update() elif sel =='4': self.manage.M_delete() elif sel =='9': sys.exit() else: print('잘못된 입력입니다. 다시 입력하시오') continue menu=Menu() menu.work() ```