■ 48. 파일 열고 닫기 (open, close)
예제: 이미지 파일을 파이썬에서 여는 방법
import PIL.Image as pilimg #PIL.Image 내장모듈
import numpy as np # numpy 내장모듈
import matplotlib.pyplot as plt # matplotlib.pyplot 내장모듈
im=pilimg.open('d:\\lena.png') #그냥 open 아니고 pilimg.open 으로 갖고옴
#↑
#image(**csv 할때는 file)
pix=np.array(im)
#↑
#변수이름
plt.imshow(pix) # plt 에서 imshow 함수 써서 pix 보이게함.
문제167. sun.jpg 를 파이썬에서 open 하시오
import PIL.Image as pilimg
import numpy as np
import matplotlib.pyplot as plt
im=pilimg.open('d:\\sun.jpg')
pix=np.array(im)
plt.imshow(pix)
■ 49. 클래스 이해하기(class)
클래스(자료형) ---------->객체
클래스는 자료형이고 아직 객체가 되지 않았다.
↓ ↓
붕어빵 틀 붕어빵
차 설계도 차
총 설계도 총
고릴라 설계도 고릴라
*클래스가 필요한 이유에 대한 실습
→ 계산기 함수 생성
result=0
def adder(num):
global result
result=result+num
return result
print(adder(3) )
print(adder(4) )
print 할 때마다 누적치처럼 더해짐
근데 다른자료를 하나 더 만들고 싶으면??
결국 계산기 하나 더 필요하다.
adder 함수 하나만으로는 결과값을 따로 유지할 수가 없다.
result1=0
result2=0
def adder1(num):
global result1
result1=result1+num
return result
def adder2(num):
global result2
result2=result2+num
return result
print(adder1(3) )
print(adder1(4) )
print(adder2(2) )
print(adder2(5) )
계산기1 과 계산기2 를 가지고 계산을 했는데
하지만 계산기가 3개, 5개, 10개로 점점 더 많이 필요해진다면
어떻게 해야 할 것인가?
그때마다 전역변수와 함수를 추가할 것인가?
이 문제를 클래스가 간단하게 해결해 준다.
class Calculator: #계산기 설계도(클래스)를 만든다. 클래스이름은 대문자로 시작한다.
def __init__(self): #계산기 초기화 하는 함수(띄어쓰기 잊지마시긔) class랑 꼭함께 온다.
self.result=0
def adder(self,num): #더하기 하는 함수
self.result+=num
return self.result
#설계도(클래스)를 가지고 계산기 2개를 생성
cal1=Calculator()
cal2=Calculator()
print(cal1.adder(3))
print(cal1.adder(4))
print(cal2.adder(2))
print(cal2.adder(5))
문제168. Calculator 클래스(계산기 설계도) 에 빼기(minus), 곱하기(multiply),
나누기(devide)
함수 3개를 추가하고 실행해보시오
class Calculator:
def __init__(self):
self.result=0
def adder(self,num):
self.result+=num
return self.result
def minus(self,num):
self.result-=num
return self.result
def multiply(self,num):
self.result*=num
return self.result
def devide(self,num):
self.result/=num
return self.result
cal1=Calculator()
cal2=Calculator()
print(cal1.adder(3))
print(cal1.adder(4))
print(cal2.multiply(2))
print(cal2.devide(2))
문제169. 총 클래스를 생성하고 객체화 시키시오
class Gun:
def __init__(self): #클래스가 실체화 될때 바로 작동~
self.bullet=0 #~하는 메소드
def charge(self,num): #충전하는 기능
self.bullet=num
def shoot(self, num): #총 쏘는 기능
for i in range(num):
if self.bullet > 0:
print('탕!!!!!')
self.bullet-=1
elif self.bullet==0:
print('총알이 없습니다..ㅜㅜ')
break
def print(self): #출력하는 기능
print('{}발 남았습니다.' .format(self.bullet))
#총을 실체화 시킨다
gun1=Gun()
#총알을 충전한다
gun1.charge(10)
#총알을 쏜다.
gun1.shoot(3)
#몇 발 남았는지 확인한다
gun1.print()
문제170. 총알 충전할 때
몇 발 충전되었습니다.
라는 메세지가 출력되게 하시오
gun1.charge(7)
7발 충전되었습니다.
class Gun():
def __init__(self): #클래스가 실체화 될때 바로 작동~
self.bullet=0 #~하는 메소드
def charge(self,num): #충전하는 기능
self.bullet=num
#bullet은 총갯수를 뜻함. +가 없어도
#계속 충전 총 갯수가 나온다.
print('{}발 충전되었습니다.' .format(self.bullet))
def shoot(self, num): #총 쏘는 기능
for i in range(num):
if self.bullet > 0:
print('탕!!!!!')
self.bullet-=1
elif self.bullet==0:
print('총알이 없습니다..ㅜㅜ')
break
def print(self): #출력하는 기능
print('{}발 남았습니다.' .format(self.bullet))
#총을 실체화 시킨다
gun1=Gun()
#총알을 충전한다
gun1.charge(10)
#총알을 쏜다.
gun1.shoot(3)
#몇 발 남았는지 확인한다
gun1.print()
#################################################
위에건 충전되었습니다가 토탈값으로 나온다.
아래걸로 다시 짜보면
class Gun():
def __init__(self): #클래스가 실체화 될때 바로 작동~
self.bullet=0 #~하는 메소드
def charge(self,num): #충전하는 기능
self.bullet+=num #이렇게 해야 충전 될때마다 누적이 된다.
print('{}발 충전되었습니다.' .format(num)) # format을 num으로 해줘야
#당장 입력되는 숫자값만 프린트 되서 나온다
#self.bullet으로 하면 전체숫자가 입력되기 때문에
#충전값이 total print랑 같은 값이 나온다.
def shoot(self, num): #총 쏘는 기능
for i in range(num):
if self.bullet > 0:
print('탕!!!!!')
self.bullet-=1
elif self.bullet==0:
print('총알이 없습니다..ㅜㅜ')
break
def print(self): #출력하는 기능
print('{}발 남았습니다.' .format(self.bullet))
#총을 실체화 시킨다
gun1=Gun()
#총알을 충전한다
gun1.charge(10)
#총알을 쏜다.
gun1.shoot(3)
#몇 발 남았는지 확인한다
gun1.print()
문제170. 고릴라 클래스를 구현해서 고릴라 객체를 만드시오
기능:
1. 소리지르는 기능: shout
우와~~~~~~
소리를 지를 수 없습니다 <-- 바나나가 없으면
2. 바나나 먹는 기능: eat
3. 바나나가 뱃속에 몇 개 남았는지 프린트 하는 기능
바나나를 10개 먹었으면 소리를 10번 지를 수 있다.
class Gorila:
def __init__(self): #클래스가 실체화 될때 바로 작동~
self.banana=0 #~하는 메소드
def eat(self,num): #충전하는 기능
self.banana+=num
print('{}개 먹었습니다.' .format(num))
def shout(self, num): #총 쏘는 기능
for i in range(num):
if self.banana > 0:
print('우와~~~~')
self.banana-=1
elif self.banana==0:
print('소리를 지를 수 없습니다')
break
def print(self): #출력하는 기능
print('{}개 남았습니다.' .format(self.banana))
#총을 실체화 시킨다
gorila1=Gorila()
#총알을 충전한다
gorila1.eat(10)
#총알을 쏜다.
gorila1.shout(3)
#몇 발 남았는지 확인한다
gorila1.print()
문제171. 위의 고릴라의 기능중에 걷는 기능을 추가하시오
(힌트: for 문 2개)
메소드 이름 walk
print(go.walk(3))
뚜벅 !
뚜벅 !
뚜벅 !
바나나가 없으면 "배가 고파 걸을 수 없습니다" 메세지 출력
바나나가 없으면 "배가 고파 소리를 지를 수 없습니다" 메세지 출력
바나나를 10개를 먹었으면 10번 소리를 지를 수 있다.
바나나를 10개를 먹었으면 10번 걸을 수 있다.
바나나를 10개를 먹었으면 5번 소리 지를 수 있고, 5번 걸을 수 있다.
class Gorilla:
def __init__(self):
self.banana = 0
def eat(self,num):
self.banana = num
print('바나나를 {}개 먹었습니다.' .format(self.banana))
def shout(self,num):
for i in range(num):
if self.banana > 0:
print('우와~~~~~~')
self.banana -= 1
elif self.banana == 0:
print('배가 고파 소리를 지를 수 없습니다.')
break
def walk(self,num):
for i in range(num):
if self.banana > 0:
print('뚜벅!')
self.banana -= 1
elif self.banana == 0:
print('배가 고파 걸을 수 없습니다.')
break
def print(self):
print('바나나가 뱃속에 {}개 남았습니다.' .format(self.banana))
gorilla1 = Gorilla()
gorilla1.eat(10)
gorilla1.shout(5)
gorilla1.walk(6)
gorilla1.print()
문제172.(오늘의 마지막 문제)
Card 클래스를 생성해서 카드를 발급하시오
Movie_Card 클래스
- 충전 기능 ( charge )
- 소비 기능 ( consume)
consume(3000, '마트')
consume(10000,'영화') # 20% 할인
- print 기능 (print)
card1.charge(20000)
card1.print()
잔액이 20000 원 입니다.
card1.consume(3000,'마트')
마트에서 3000 원 사용했습니다.
card1.consume(10000,'영화')
영화관에서 8000 원 사용했습니다.
card1.print()
잔액이 9000 원 입니다.
card1.consume(13000,'마트')
잔액이 부족합니다.
#####################################
class Movie_Card:
def __init__(self):
self.ch = 0
def charge(self,num):
self.ch = num
print('충전이 %d원 입니다'%num)
def consume(self,num,data):
if data=='영화관':
num=num*0.8
if self.ch>num:
self.ch = self.ch - num
print(data,'에서',num,'사용했습니다')
elif self.ch < num:
print('잔액이 부족합니다')
def print(self):
print('잔액이 {} 입니다'.format(self.ch))
card1 = Movie_Card()
card1.charge(20000)
card1.consume(3000,'마트')
card1.print()
card1.consume(10000,'영화관') #20% 할인 받으라오
card1.print()
card1.consume(10000,'영화관') #20% 할인 받으라오
card1.print()
*클래스를 사용해야 하는 이유?
클래스를 사용하지 않으면 동일한 코드의 함수를 반복 코딩해야하는
번거로움이 생긴다.
예제:
1.계산기 클래스
2. 총 클래스
3. 고릴라 클래스
4. 영화 카드 클래스
■ 50. 클래스 멤버와 인스턴스 멤버 이해하기
*용어 설명
gun1=Gun()
↑ ↑
객체 클래스(설계도)
(인스턴스)
gun2=Gun()
gun1 과 gun2 는 클래스(설계도)는 동일하지만 객체는 서로 다르다.
gun1=Gun()
인스턴스=클래스()
: 클래스를 가지고 인스턴스를 생성했다!
*클래스에서 사용하는 변수 2가지
1. 클래스 변수? 객체에 의해서 변경이 되면 안되는 변수.
반드시 고정값으로 사용되어야만 하는
데이터는 클래스로 선언해서 사용한다.
2. 인스턴스 변수? 객체에 의해서 변경이 되어야 하는 데이터의 변수
예: emp_hurim.raise_amount=1.2 <- 이작업 못하게 막고싶으면 클래스변수를 사용.
*밑에 다룬 내용 죽 나옴
클래스 변수의 예제:
"회사의 사원의 월급을 관리하는 클래스(설계도)를 생성"
class Employees(object):
raise_amount=1.1 #클래스 변수
def __init__(self, first, last, pay): #객체(인스턴스)가 만들어질 때
self.first=first # 바로 작동되는 함수
self.last=last
self.pay=pay
self.email=first.lower()+'.'+last.lower()+\
'@gmail.com' # yongsik.kim@gmail.com
def full_name(self): #사원의 전체이름을 출력하는 함수
return '{} {}'.format(self.first,self.last) #괄호순서대로 넣는다.
def apply_raise(self): #월급을 인상하는 함수
self.pay=int(self.pay*raise_amount) #8000*1.1
emp_yongsik=Employees('yonsik','kim',5000000)
print(emp_yongsik.first) # 이렇게 뽑아도 출력됨
문제173. 위의 Employees 설계도를 가지고 emp_yongsik 객체를
실체화 시켜서 기존 월급과 인상된 월급 2가지를 같이 프린트 하시오
class Employees(object):
#class Employees에 object값 담아서 emp_yongsik 에 담으라고 한다.\
그럼 이제부터\
emp_yongsik 은 self 로 인식되서\
def를 가져다가 쓸 수 있게 되는거다.
raise_amount=1.1 #클래스 변수
def __init__(self, first, last, pay): #객체(인스턴스)가 만들어질 때
self.first=first
self.last=last
self.pay=pay
self.email=first.lower()+'.'+last.lower()+\
'@gmail.com'
def full_name(self): #사원의 전체이름을 출력하는 함수
return '{} {}'.format(self.first,self.last)
def apply_raise(self): #월급을 인상하는 함수
self.pay=int(self.pay*Employees.raise_amount)
emp_yongsik=Employees('Yongsik','kim',5000000)
print(emp_yongsik.pay)
emp_yongsik.apply_raise()
print(emp_yongsik.pay)
※패키지에서 함수 끌어오듯이
클래스에서 self 로 지정시키고, def 함수 끌어와서 쓰는거다.
문제175.용식이와 후림이 사원 객체를 아래와 같이 생성하고
월급도 동일하게 해서 각각 프린트 해보시오
class Employees(object):
raise_amount=1.1 #클래스 변수
def __init__(self, first, last, pay): #객체(인스턴스)가 만들어질 때
self.first=first
self.last=last
self.pay=pay
self.email=first.lower()+'.'+last.lower()+\
'@gmail.com'
def full_name(self): #사원의 전체이름을 출력하는 함수
return '{} {}'.format(self.first,self.last)
def apply_raise(self): #월급을 인상하는 함수
self.pay=int(self.pay*Employees.raise_amount)
emp_yongsik=Employees('Yongsik','kim',5000000)
print(emp_yongsik.pay)
emp_yongsik.apply_raise()
print(emp_yongsik.pay)
emp_hurim=Employees('hoorim','lee',5000000)
print(emp_hurim.pay)
emp_hoorim.apply_raise()
print(emp_hurim.pay)
선생님 정정
class Employees(object): ----> class Employees 안 써도 됨!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
self.pay = int( Employees.pay * self.raise_amount) #클래스변수
----------->> self.pay = int( self.pay * self.raise_amount) #인스턴스 변수
# 인스턴스 변수를 써야 하는이유는
# 인스턴스 이름을 쓸거니까.
만약 hurim 만 월급인상을 20%로 해주고 싶다면??
class Employees:
:
:
def apply_raise(self): #월급을 인상하는 함수
self.pay=int(self.pay*self.raise_amount)
emp_yongsik=Employees('Yongsik','kim',5000000)
print(emp_yongsik.pay)
emp_yongsik.apply_raise()
print(emp_yongsik.pay)
emp_hurim=Employees('hoorim','lee',5000000)
emp_hurim.raise_amount=1.2
#def apply_raise(self): #월급을 인상하는 함수
self.pay=int(self.pay*self.raise_amount)
#emp_hurim.raise_amount = self.raise_amount
**만약 class 변수 가져다 쓰면 (raise_amount=1.1)
self 처럼 지정,변환이 안되니까
계속 1.1로 값이 곱해진다.**
print(emp_hurim.pay)
emp_hurim.apply_raise()
print(emp_hurim.pay)
*역으로, 변경을 원하지 않으면, self 안 붙게
class 변수로 위치시켜 주면 된다.
↓
class Employees:
raise_amount=1.1 #클래스 변수
def __init__(self, first, last, pay): #객체(인스턴스)가 만들어질 때
self.first=first
self.last=last
self.pay=pay
self.email=first.lower()+'.'+last.lower()+\
'@gmail.com'
*****
또는 def __init__ 안에다가
def __init__(self,first,last,pay)
:
:
Employees.raise_amount=1.1
이라고 써도 클래스함수로 인식한다.
■ 51. 클래스 메소드 이해하기
class MyClass: #낙타등 표기법(CamelCase)
def sayHello(self):
print('안녕하세요')
def sayBye(self,name):
print('%s! 다음에 보자!' %name)
obj=MyClass()
obj.sayHello() #객체(=클래스).함수
obj.sayBye('철수')
예제: gun=Gun()
↓ ↓
객체 클래스
gun.shoot(3) # (클래스의)객체화.함수(값)
[1,2,3,4,5]
↓
객체
[1,2,3,4,5].count(2) : 결과는 1 (리스트 안에서 숫자2를 카운트한거니까)
↓ ↓
객체 메소드
*리스트 변수(객체)의 유용한 메소드
1. count()
2. append()
3. insert()
4. remove()
5. pop()
6. index()
7. sort()
8. reverse
a=[1,2,3,4,5]
a.count(2)
변수 a는 리스트 객체의 메모리 주소를 가지고 있어서
a.count(2) 라고 하면 a를 통하여 [1,2,3,4,5] 객체의 count 메소드를
실행한 것이다.
문제176.(점심시간문제)
아래와 같이 고릴라 두 객체를 생성하는데 고릴라가 태어날 때부터
바나나를 뱃속에 넣고 태어날 수 있게 클래스를 생성하시오
anwooyong_gorilla=Gorilla(10) #바나나 10개 충전하면서 태어남
gehyuk_gorilla=Gorilla(10) #바나나 10개 충전하면서 태어남
anwooyong_gorilla.shout(3)
우와~
우와~
우와~
class Gorilla:
def __init__(self,num):
self.banana = num
print('바나나를 {}개 가지고 태어났습니다' .format(self.banana))
def shout(self,num):
for i in range(num):
if self.banana > 0:
print('우와~~~~~~')
self.banana -= 1
elif self.banana == 0:
print('배가 고파 소리를 지를 수 없습니다.')
break
def print(self):
print('바나나가 뱃속에 {}개 남았습니다.' .format(self.banana))
anwooyong_gorilla = Gorilla(10)
anwooyong_gorilla.shout(3)
anwooyong_gorilla.print()
class Gorilla:
def __init__(self,num=0):
self.banana = num
print('바나나를 {}개 가지고 태어났습니다' .format(self.banana))
:
:
anwooyong_gorilla = Gorilla(10)
#이렇게 해도 num 이 10을 인식함.
-------------------------------------------------------------------------------------------------------------------------------
■ 51. 클래스 메소드 이해하기 ②
"기초 통계에 필요한 함수들을 가지고 class 를 생성"
예:
stats=Stats()
a=[24,23,21,20,30,44,41]
stats.mean(a)
문제190. mean 함수를 생성해서 아래와 같이 수행하면 실행되게 하시오
def mean(data):
b=len(a)
c=sum(a)
d=c/b
return d
a=[24,23,21,20,30,44,41]
print(mean(a))
| |
def mean(args):
result=sum(args)/len(args)
return result
a=[24,23,21,20,30,44,41]
print(mean(a))
문제191. Stats 라는 클래스를 만들고
Stats 클래스 안에 mean 메소드를 추가하여
아래와 같이 실행되게 하시오
class Stats:
def mean(self,num):
self.num=num #생략해도 돌아감
return sum(num)/len(num)
stats1=Stats()
a=[24,23,21,20,30,44,41]
print(stats1.mean(a))
문제192. 분산 함수를 생성하시오 !
*분산: 평균에서 얼마나 퍼졌는가
*표준편차: 분산에 루트씌운거.
평균에서 떨어진 값이 분산이고 위아래가 + , - 로 나타날 것이다.
근데 이런값을 다 더하면 0이 되기 때문에
각각의 값을 제곱해서 갯수만큼 나눈다.
이렇게 분산을 구하고,
제곱값을 없애기 위해 루트를 씌우는데
그 값이 표준편차다.
1. 평균을 구하는 함수
2. (실제값 - 평균값의 차이) 제곱
예: (i-m)**2
3. 전체갯수 구하는 함수
예: len(a)
실행방법:
a=[24,23,21,20,30,44,41]
print(variance(a)) #분산 구하라
서영답:
def variance(data):
avg=sum(data)/len(data)
va=[]
for i in data:
va.append((i-avg)**2)
return sum(va)/len(data) #위치가 for문 안에있음 틀림
a=[24,23,31,20,30,44,41]
print(variance(a))
선생님답:
a=[24,23,31,20,30,44,41]
def mean(self,num):
return sum(num)/len(num)
def variance(args):
total=0
m=mean(args)
for i in args:
total=total+(i-m)**2
return total/len(args)
다른방식의 우용답:
a=[24,23,21,20,30,44,41]
def mean(args):
return sum(args)/ len(args)
def variance(args):
total = 0
a=0
for i in args:
total += i**2
a = total /len(args) # a= 수제곱의 합/갯수
return a-mean(args)**2 # a-평균제곱
print(variance(a))
※ 설명:
분산 구하는 공식이 선생님꺼, 우용이꺼 있는데
1. 선생님꺼는 요소와 요소의 평균의 차가 정수면
위의것을 쓴다
2. 우용이것을 쓰는 경우는 요소와
평균이 분수,소수와 같은 유리수 일때 사용한다.
■표준편차란? 평균과의 오차
(분산에 루트 씌운 것)
예:
import math
print(math.sqrt(4))
결과: 2.0
루트= 분산에 1/2제곱
문제193. 표준편차를 구하는 함수를 생성하시오
a=[24,23,21,20,30,44,41]
def mean(num):
return sum(num) / len(num)
def variance(args):
total = 0
m = mean(args)
for i in args:
total = total + (i-m)**2
return total / len(args)
def stddev(args):
v = variance(args)
v2 = v**(1/2)
return v2
문제194. 중앙값을 구하는 함수를 생성하시오
(어제배웠던 numpy 이용해서 구현)
(할 수 있으면 def 로 생성)
def median(args):
import numpy as np
return np.median(args)
a=[24,23,31,20,30,44,41]
print(median(a))
*sort.() : 오름차순으로 정렬
*네 풀었습니다
def median(num):
num.sort()
if len(num)%2==0:
return (num[int(len(num)/2)]+num[int((len(num)/2)-1)])/2
else:
return num[int((len(num)/2)-0.5)]
a=[19,21,25,30,21,33,40]
print(median(a))
준하답:
def median(lst):
lst.sort()
if len(lst)%2==0 :
return (lst[int(len(lst)/2)-1]+lst[int((len(lst)/2)+1)-1])/2
else:
return lst[int((len(lst)/2)-0.5)]
문제195. 최빈값을 구하는 함수를 생성하시오
age_9 = [ 2,2,2,2,2,2,2,2,2,2, 52,52,52,52,52,52,52,52,52,52,3,4]
print(mode(age_9) )
def mode(num):
from collections import Counter
cnt = Counter(num)
return cnt
def mode(args):
from collections import Counter as cnt
return cnt.most_common(args)
a=[24,23,31,20,30,44,41]
print(mode(a))
**숫자의 중복값 카운트=x , set 처리=y, x 값 for loop
문제196.(점심시간문제)
위에서 만든 기초통계 함수들을 가지고
통계 클래스(My_stats)를 생성하시오
stats1=My_stats()
통계 객체가 생성되었습니다 <---메세지 출력
print(stats1.mean(a))
print(stats1.median(a))
print(stats1.mode(a))
print(stats1.variance(a))
print(stats1.stddev(a))
클래스 생성되서 바로 뽑게끔 하려면
init 아래에 프린트메세지 넣으면 뽑힘.
class My_stats():
def __init__(self):
print("통계 객체가 생성되었습니다")
def mean(self,num):
return sum(num) / len(num)
def variance(self,args):
total = 0
m = self.mean(args)
for i in args:
total = total + (i-m)**2
return total / len(args)
def stddev(self,data):
v=self.variance(data)
v2=v**0.5
return v2
def median(self,args):
import numpy as np
return np.median(args)
def mode(self,num):
from collections import Counter
cnt = Counter(num)
return cnt
stats1=My_stats()
a=[24,23,31,20,30,44,41]
print(stats1.mean(a))
print(stats1.median(a))
print(stats1.mode(a))
print(stats1.variance(a))
print(stats1.stddev(a))
반장코드
class Stats:
def __init__(self):
print('통계 객체가 생성되었습니다.')
def mean(self, data):
return sum(data)/len(data)
def varience(self, data):
avg = self.mean(data)
num = 0
for i in data:
num += i**2
avg_2 = num/len(data)
return avg_2 - avg**2
def stddev(self, data):
var = self.varience(data)
std = var**0.5
return std
def median(self, args) :
import numpy as np
a = np.array(args)
b = np.median(a)
return b
def mode(self, data): #모르겠다 !!
dis_data = list(set(data))
cnt = 0
mod = []
mod_data = []
for i in dis_data:
for j in data:
if i == j:
cnt += 1
mod.append(cnt)
cnt = 0
mod_index = 0
data_mod_index = []
for i in mod:
if max(mod) == i:
data_mod_index.append(mod_index)
mod_index += 1
result =[]
for i in data_mod_index:
result.append(dis_data[i])
return result
a = [24, 23, 21, 20, 30, 44, 41]
stats1 = Stats()
print (stats1.mean(a))
print (stats1.median(a))
print (stats1.mode(a))
print (stats1.varience(a))
print (stats1.stddev(a))
문제197. 위에서 만든 기초 통계 클라스를 모듈화 해서
아래와 같이 다른장에서 실행되게 하시오
import my_stats #메모장 저장한 이름
a=[24,23,31,20,30,44,41]
m=my_stats.My_stats() #클래스를 선언해야 함
print(m.stddev(a))
※ import my_stats 에서 커서 갖다대고 왼쪽버튼 누르면 새창에 함수 열림.
문제198.
range 함수와 percent_range (사분위 범위) 함수를 각각 My_stats 클래스에
추가하시오!
def range(self,data):
return max(data)-min(data)
def percent_range(self,data):
import numpy as np
return np.percentile(data, 75)- np.percentile(data,25)
#quantile 이면 0.75로 바꿔서 써야 함
import my_stats
a=[24,23,21,20,30,44,41]
m=my_stats.My_stats()
print(m.percent_range(a))
1. 클래스 변수와 인스턴스 변수
클래스 변수와 인스턴스 변수의 차이? \
"고정데이터와 비고정데이터"
2. 기초 통계에 필요한 함수
데이터를 대표할 수 있는 값중에 중심성향을 나타내는 값
-평균값 : 평균
-중앙값 : 데이터의 가운데 값
-최빈값 : 데이터의 빈도수가 많은 값
-분산 : 데이터의 퍼짐의 정도
-표준편차: 분산에 루트씌운거. 평균과의 오차
-범위 : 최대값-최소값 (8기 24~40)
-사분위수 범위: 데이터의 25%~75% 사이 (25~28 (7기와 8기의 공통된 범위) )
3. 파이썬으로 그래프 그리는 방법
-라인 그래프
-막대 그래프
-원형 그래프
-plot 그래프
-히스토그램 그래프
-사분위수 그래프
특급 엔지니어
여러 회사들을 돌아다니면서 쌓은 노하우를 스크립트로 가지고 다님
1. 우리의 지식을 잘 정리한 블로그(홈페이지)
2. 스크립트
■52. 클래스 생성자 이해하기
"객체가 만들어질 때 호출되는 함수를 생성자(__init__)라고 한다."
생성자는 객체를 초기화 할 때 자주 사용한다.
예제:
class Stats:
def __init__(self):
print("통계 객체가 생성되었습니다")
■ 53. 클래스 소멸자 이해하기
"객체가 사라질 때 호출되는 함수를 소멸자 (__del__) 라고 한다."
예제:
class Myclass:
def __init__(self):
self.var='안녕하세요'
print('Myclass 인스턴스 객체가 생성되었습니다')
def __del__(self):
print('Myclass 인스턴스 객체가 메모리에서 제거되었습니다')
object1=Myclass()
del object1 #지웠는지 안지웠는지 확인어려워서 프린트 걸어둔거임.
■ 54. 클래스 상속 이해하기
상속이란? 클래스들끼리 유산(기능)을 물려주는 것
부모 클래스 ------------------------> 자식 클래스
기능
상속을 받게 되면 부모의 기능을
굳이
자식 클래스에 코딩을 하지 않아도 된다.
-----------------------------------------------------
이해를 위한 간단한 예제
예제:
class father:
def base_method(self):
print("hello~~~")
class child(father):
pass
father=father()
father.base_method()
child=child()
child.base_method() #father 의 base_method 를 갖고와서 쓴거다.
-----------------------------------------------
문제199.
아래의 카드사의 상속 코드 구현하기 위해 먼저
부모 클래스인 card 클래스를 구현하시오
예제:
Card 클래스
↙ ↘
영화할인 card 마트할인 card
구현내용:
card 의 기본 기능
1. __init__ 함수: 카드 발급시 카드가 발급되었습니다. 메세지 출력
2. 충전 기능(charge)
3. 소비 기능(consume)
"잔액부족 메시지 출력"
4. 잔액 프린트
↓
class Card:
def __init__(self):
self.ch = 0
print('카드 발급되었습니다')
def charge(self,num):
self.ch = num
print('충전이 %d원 입니다'%num)
def consume(self,num,data):
if self.ch>=num:
self.ch = self.ch - num
print(data,'에서',num,'사용했습니다')
elif self.ch < num:
print('잔액이 부족합니다')
def print(self):
print('잔액이 {} 입니다'.format(self.ch))
card1 = Card()
card1.charge(10000)
card1.consume(2000,'마트')
card1.print()
문제200.
부모 클래스인 card 클래스의 기능을 상속받아서
영화 할인 카드 클래스를 생성하시오
1) 그냥 그대로 상속 받은 버전의 코드
class Movie_Card(Card):
pass
movie_card1=Movie_card()
movie_card1.charge(20000)
movie_card1.consume(10000,'영화관')
2) 오버라이드한 버전의 코드
class Movie_card(Card):
def consume(self,num,place): #consume 만 직접 만들어 쓰겠다.(영화값 20%할인)
if place == '영화관':
num = 0.8 * num
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' %(place, num))
else:
print('잔액이 부족합니다.')
else:
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' %(place, num))
else:
print('잔액이 부족합니다.')
movie_card1 = Movie_card()
movie_card1.charge(20000)
movie_card1.consume(10000,'영화관')
문제201.
마트 할인 카드 클래스를 생성하시오(할인률 10%)
class mart_card(Card):
def consume(self,num,where):
if where =='마트':
num=0.9* num
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' %(where, num))
else:
print('잔액이 부족합니다.')
else:
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' %(where, num))
else:
print('잔액이 부족합니다.')
mart_card1 = Card()
mart_card1.charge(20000)
mart_card1.consume(10000,'마트')
문제202. 손자 card 를 생성하시오
(영화_마트_교통 card 를 생성하시오)
예제:
Card 클래스
↙ ↘
영화할인 card 마트할인 card
↘ ↙
영화_마트_교통
죽음의 다이아몬드 ㅎ
class Card:
def __init__(self):
self.card = 0
print(' 카드가 발급 되었습니다')
def charge(self, num):
self.card += num
print('%d 원이 충전되었습니다.' % num)
def consume(self, num, place):
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' % (place, num))
else:
print('잔액이 부족합니다.')
def print(self):
print('%d 원 남았습니다.' % self.card)
class Movie_card(Card):
def consume(self, num, place):
if place == '영화관':
num = 0.8 * num
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' % (place, num))
else:
print('잔액이 부족합니다.')
class Mart_card(Card):
def consume(self, num, place):
if place == '마트':
num = round(num * 0.9)
if self.card >= num:
print('{}에서 {}원 사용했습니다. '.format(place, num))
self.card -= num
else:
print('잔액이 부족합니다')
class movie_mart_trans_card(Movie_card, Mart_card):
def consume(self, num, place):
if place in ['영화관','마트']:
Movie_card.consume(self, num, place)
Mart_card.consume(self, num, place)
else:
if place == '교통':
num = round(num * 0.9)
if self.card >= num:
print('{}에서 {}원 사용했습니다. '.format(place, num))
self.card -= num
else:
print('잔액이 부족합니다')
else:
if self.card >= num:
print('{}에서 {}원 사용했습니다. '.format(place, num))
self.card -= num
else:
print('잔액이 부족합니다')
t_card1 = movie_mart_trans_card()
t_card1.charge(20000)
t_card1.consume(10000, '마트')
t_card1.consume(10000, '아무거나')
t_card1.print()
--------------------------------
↓
수정한 한솔 코드
class Card:
def __init__(self):
self.card = 0
print(' 카드가 발급 되었습니다')
def charge(self, num):
self.card += num
print('%d 원이 충전되었습니다.' % num)
def consume(self, num, place):
if self.card >= num:
self.card -= num
print('%s 에서 %d 를 사용했습니다.' % (place, num))
else:
print('잔액이 부족합니다.')
def print(self):
print('%d 원 남았습니다.' % self.card)
class Movie_card(Card):
def consume(self, num, place):
if place == '영화':
self.card -= num * 0.8
print('영화에서 {} 사용했습니다'.format(num * 0.8))
else:
Card.consume(self, num, place)
class Mart_card(Card):
def consume(self, num, place):
if place == '마트':
self.card -= num * 0.9
print('마트에서 {} 사용했습니다'.format(num * 0.9))
else:
Card.consume(self, num, place)
class movie_mart_trans_card(Movie_card, Mart_card):
def consume(self, num, place):
if place =='영화':
Movie_card.consume(self, num, place)
elif place =='마트':
Mart_card.consume(self, num, place)
else:
if place == '교통':
num = round(num * 0.9)
if self.card >= num:
print('{}에서 {}원 사용했습니다. '.format(place, num))
self.card -= num
else:
print('잔액이 부족합니다')
else:
if self.card >= num:
print('{}에서 {}원 사용했습니다. '.format(place, num))
self.card -= num
else:
print('잔액이 부족합니다')
■ 다중 상속
다중 상속이란 두 개 이상의 클래스를 상속 받는 것을 말한다.
이 경우에는 두 클래스의 모든 속성을 물려받게 된다.
이는 하나의 자식 클래스가 두개 이상의 부모 클래스를
가지는 것이라고 할 수 있다.
father1 father2
↘ ↙
child
예제:
class father1:
def func(self):
print('지식')
class father2:
def func(self):
print('지혜')
class child(father1,father2):
def childfunc(self):
father1.func(self)
father2.func(self)
child1=child()
child1.childfunc()
■ 다중 상속시 주의할 점 "죽음의 다이아몬드 상속"
grandfather
↙ ↘
father1 fahter2
↘ ↙
child
예제1:
class grandfather:
def __init__(self):
print('튼튼한 두팔')
class father1(grandfather):
def __init__(self):
grandfather.__init__(self)
print("지식")
class father2(grandfather):
def __init__(self):
grandfather.__init__(self)
print("지혜")
class grandchild(father1,father2):
def __init__(self):
father1.__init__(self)
father2.__init__(self)
print("자기 만족도가 높은 삶")
grandchild = grandchild()
결과:
튼튼한 두팔
지식
튼튼한 두팔
지혜
자기 만족도가 높은 삶
※설명: 팔이 4개가 되어버렸다. 이런 오류를 잡기위해
super().__init__() 쓴다
class grandfather:
def __init__(self):
print('튼튼한 두팔')
class father1(grandfather):
def __init__(self):
super().__init__()
print("지식")
class father2(grandfather):
def __init__(self):
super().__init__()
print("지혜")
class grandchild(father1,father2):
def __init__(self):
super().__init__()
print('자기 만족도가 높은 삶')
grandchild = grandchild()
'python' 카테고리의 다른 글
| 12. %, divmod, max/min (0) | 2019.03.25 |
|---|---|
| 11. try~except (0) | 2019.03.25 |
| 9. from/import (0) | 2019.03.25 |
| 8. 함수, 지역/번역 변수 (0) | 2019.03.25 |
| ★리스트/함수 (0) | 2019.03.25 |
