파이썬 강의 필기 3일차

간단 필기

"""
통계쪽 이용하는 것은 Ipython을 이용한다.
빅데이터를 하기 위해서는 Spark를 해야한다. 하둡도 한다는데..... 

스파크는 자바, 스칼라, 파이썬으로 쓸수 있다.
자바는 코드 길이가 길기 때문에 상대적으로 길이가 짧은 스칼라나 파이썬을 쓸수 있다.
스파크는 스칼라에 최적화 되어 있다............................

통계쪽으로 특화 되어 있는 것은 ipython인데 이것은 아나콘다를 쓴다.
빅데이터는 R을 베이스로 깔고 가야한다.
실무, 빅데이터, 스칼라는 아직 2.7을 쓰고 있다.

====================================================================================================
클래스는 새로운 타입을 만들수 있다.
파이썬은 패키지 안에 만들어져야 모듈로 인정된다.

OOP : 자원의 재활용. 이게 제일 큰 특징이다.

클래스 - 포함관계 has a (약결함) , 상속관계 is a (강결합) 상속에서 다형성 & 메소드 오버라이드로 개념 연결됨.
클래스 관계 - 강결합, 약결합

부품 클래스 가 있고 그것들을 조립하여 제품을 만들어 낸다. 완성 클래스.
car 라고 하는 완성차를 만들때 부품, 타이어, 엔진 등의 부품을 조립해서 만든다.
====================================================================================================
포함관계 연습문제 : http://cafe.daum.net/flowlife/RUrO/24
포함관계 무엇인지 알기!

상속관계
부모가 가지고 있는 자원
자식에 자원이 주어지는데 copy이다.
자원의 재활용.

====================================================================================================
추상메소드 : 바디(내용)이 없는 메소드. 추상메소드가 있는 클래스를 추상 클래스라고 한다.
추상클래스의 추상메소드를 반드시 가져오지 않으면 객체 만들어지지 않고 에러가 난다.
파이썬은 추상클래스를 기본적으로 제공하지 않는다. 따라서 반드시 Import 해야한다.
추상클래스가 있어야 메소드 상속?을 강제 할수 있다.

"""

class1.py

"""
oop : 객체 지향적인 프로그래밍
파이썬은 모듈단위로 처리한다.
"""
a = 1
# 모듈의 요소 : 전역 변수와 함수, 클래스
def aa():
    pass
 
class TestClass:
    aa =1                    # 클래스내의 멤버변수 : 클래스 내에서 전역변수이다. 클래스 생성시 기본적으로 가지고 있는 것.
                             # 클래스 내의 함수는 메소드라고 한다.
 
    def __init__(self):
        print('생성자')
 
    def __del__(self):
        print('소멸자')
 
    #  꼭 self를 써줘야 하나?
    #  self를 써주지 않으면 프린트 메소드 안에서 aa를 찾게 된다고 한다.
 
    #  다형성을 만들기 위해서 OOP를 하게 된다.
    #  이벤트 프로그램을 하기 위해서 OOP를 짠다.
 
    # 생성자 : 시작할때 처리해야 할 것들에 대해서 명시하고 처리하는 것 (생략가능하지만 없어야 하는건 아니다. 없으면 자동적으로 호출함)
    # 소멸자 : 끝마칠때 처리해야 할 것들에 대해서 명시하고 처리하는 것 (생략가능)
 
    def printMessage(self): # 멤버메소드 or 메소드
        name = '홍길동'
        print(name)
        print(self.aa)
 
# test = TestClass        # 주소를 불러온다.
test = TestClass()      # 생성자 호출         --> 테스트 클래스의 공간이 만들어지고 test는 그 주소를 저장하게 된다.
print(test.aa)
test.printMessage()         # Bound method call 방법
print('====='*50)
print('Class 이름으로 호출==>', TestClass.aa)     
# 파이썬은 static개념이 없어서 그냥 불러올수 있다. test = TestClass() 이런 방법으로 쓰인다.
 
TestClass.printMessage(test)
# Unbound method call 방법
# 클래스의 메소드는 반드시 인수 argument 가 따라붙는다. 클래스의 이름으로 멤버를 부를수는 있지만 메소드를 부를수는 없다.
 
# 메소드를 부르는 방법 Bound method call (인수값 필요 없음, 객체이름가 그 역할을 하게 된다., 이 방식이 일반적임) ,
#  Unbound method call  명시적인 방법 - 클래스.메소드 직접 호출
 
print('====='*50)
print(isinstance(test, TestClass))
# 클래스 타입 확인할때 isinstance라는 내장 메소드를 사용하면 된다.
print(type(1))
print(type(test))
print(id(test))
print(id(TestClass))

class2.py

class Car:
    handle = 0          # 멤버변수들...
    speed = 0
 
    # self는 중요하다. 객체의 주소를 받는 것
    # self는 메소드 안에서 전역 변수들을 참조할 수 있게 하는 역할을 한다.
 
    def __init__(self, name, speed):
        # speed = speed                             지역변수 speed에다가 입력된 speed를 주는 것이다.
        self.speed = speed                        # 전역변수 speed에 다가 주는 것이다.
        self.name = name                          # 생성자가 호출됨으로서 비로소 만들어지는 전역변수이다.
        print("handle",self.handle)
 
    def showData(self):
        km = '킬로미터'
        msg = '속도:'+ str(self.speed) + km
        return msg
 
#  클래스 내의 함수는 메소드이다.
 
print(Car.handle)
print(Car.speed)
# print(Car.name)
car1 = Car('tom',10)                               # 여기서만 name변수가 생성된다. 왜냐하면 init이 실행되면서 만들어지기 때문이다.
print(car1.handle, car1.name, car1.speed)
car1.color = '검정'                                # car1내의 공간에서만 해당 변수가 추가되는 것이다.
print(car1.color)
# print(Car.color)                                 # 여기선 color가 없다.
print('======='*30)
car2 = Car('james',20)
print(car2.handle, car2.name, car2.speed)
# print(car2.color)
 
# 클래스는 객체 생성에서 없는 것들에 대해서 참조하는 것으로 프로토타입으로 보면된다.
# 차로 보면 순정 + 튜닝일때 튜닝에 없는 것을 순정으로 차지하는 것처럼....
 
print('======'*30)
print(car1.showData())
print()
print(car2.showData())

class3.py (함수, 메소드 예제)

kor = 100                      # 전역변수
 
def abc():
    print('함수')
 
# 클래스의 이름만큼은 왠만하면 대문자로 시작하자.
 
class My:
    kor = 90                   # 멤버변수
 
    def abc(self):
        print('메소드')
 
    def show(self):
        kor = 80               # 지역변수
        print('self',self.kor)
        print('nomal',kor)
        self.abc()
        abc()                   # 함수 호출 function call
        # 지역변수 -> 인스턴스 변수 -> 모듈 변수
        # 지역변수에서 찾아보고 없으면 모듈로 나간다.
        # ????????????? 인스턴스 변수?
 
m = My()
m.kor = 10000
m.show()

class4.py (변수 - 클래스 예제)

class My:
    a = 1
 
print('default',My.a)
print()
 
my1 = My()
print('my1',my1.a)
 
# my1, my2에 대해서 각각의 메모리 공간에 부여된 변수값주소가 저장된다.
# 변수값주소가 없을 경우에는 처음의 참조하는 클래스의 변수값을 불러온다.
print()
my1.a = 2
print('my1',my1.a)
print()
my2 = My()
print('my2',my2.a)
my2.a = 3
my2.b = 300
print('my2a',my2.a)
print('my2b',my2.b)
print(My.a)
# print(My.b)

class5.py (singer 예제)

"""
Singer type
"""
class Singer:
    title_song = '화이팅 코리아'
 
    def sing(self):
        msg = '노래는'
        print(msg, self.title_song,'랄라라~~~~~~~~~')
 
psy = Singer()
psy.sing()
 
print()
 
girls = Singer()
girls.sing()
girls.title_song = '댄싱 퀸'
girls.sing()
girls.co = 'SM'
print('소속사:', girls.co)
print(type(girls))
print()
psy.sing()
# print('소속사:', psy.co)

class6_car.py (포함관계)

"""
완성차 : 조립식(클래스의 포함관계)
"""
from basic_class.class6_handle import PohamHandle
 
class PohamCar :
    turnShow = '정지'
 
    def __init__(self, ownerName):
        self.ownerName = ownerName
        # 포함 핸들을 쓰고 싶다. PohamHandle
        self.handle = PohamHandle()                 # 클래스의 포함관계
 
    def TurnHandle(self, q):
        if q > 0:
            self.turnShow = self.handle.RightTrun(q)
        elif q < 0:
            self.turnShow = self.handle.LeftTrun(q)
        elif q == 0:
            self.turnShow = self.handle.Straight(q)
 
tom = PohamCar('tom')
tom.TurnHandle(10)
print(tom.ownerName + '의 회전량은 '+tom.turnShow + str(tom.handle.quantity))
tom.TurnHandle(-10)
print(tom.ownerName + '의 회전량은 '+tom.turnShow + str(tom.handle.quantity))
 
james = PohamCar('james')
james.TurnHandle(0)
print(james.ownerName + '의 회전량은 '+james.turnShow + str(james.handle.quantity))
print(tom.ownerName + '의 회전량은 '+tom.turnShow + str(tom.handle.quantity))

class6_handle.py (피포함관계)

"""
완성제품의 부품 클래스 핸들
"""
 
class PohamHandle:            # 포함 예제
    quantity = 0                # 회전량    # 음수 왼쪽 0 직진 양수 오른쪽
 
    def LeftTrun(self, quantity):
        self.quantity = quantity
        return '좌회전'
 
    def RightTrun(self, quantity):
        self.quantity = quantity
        return '우회전'
 
    def Straight(self, quantity):
        self.quantity = quantity
        return '직진'

class7_animal.py (상속)

class Animal:
    leg = 4
 
    def move(self):
        print('움직이는 생물')
 
# 참조를 위한 클래스 animal
# argument 에 상속할 클래스를 적어넣으면 상속된다. 다중상속이 가능하다.
 
class Dog(Animal):
    def my(self):
        self.leg = 100
        print('멍멍멍')
 
dog1 = Dog()
print(dog1.leg)
dog1.move()
dog1.my()
print(dog1.leg)
 
print()
class Horse(Animal):
    pass
 
horse1 = Horse()
horse1.move()
# horse1.my()
 
print()
 
class Bird(Animal):
    leg = 2
 
bird1 = Bird()
bird1.move()
bird1.leg = 1
print(bird1.leg)
print()
print(horse1.leg)

class8.py  (상속)

"""
상속
"""
 
class Person:
    say = '난 사람이야'
    age = '20'
 
    def __init__(self,age):
        print('person 생성자')
        self.age = age
 
    def PrintInfo(self):
        print('나이{}, 소개:{}'.format(self.age, self.say))
 
    def Hello(self):
        print('안녕')
 
p = Person('22')
p.PrintInfo()
p.Hello()
 
print('==='*30)
 
class Employee(Person):
    say = '일하는 동물'
    subject = '근로자'
 
    def __init__(self):
        print('Employee 생성자')
    def PrintInfo(self):
        self.say = '피리부는 사나이'
        print('Employee의 PringInfo')
 
    def EprintInfo(self):
        self.PrintInfo()                    # self는 자신의 것
        super().PrintInfo()                 # 부모의 멤버를 쓸 때에는 수퍼를 쓴다.
        print(self.say, super().say)
        self.Hello()                        # 현 클래스에 없어서 부모 클래스의 Hello에서 가져온다.
 
e = Employee()
# e.say = '난 고용주야'
print('============test=======')
print(e.say, e.age, e.subject)
print('==='*30)
e.EprintInfo()
 
print('==='*30)
class Programmer(Employee):
    def __init__(self):
        print('Programmer 생성자')          # 없을땐 Employee생성자 출력
        # super().__init__()                # Bound method call
        Employee.__init__(self)             # Unbound method call
 
pr = Programmer()
print()
pr.EprintInfo()
print()
print(pr.say, pr.age)
print(type(pr))
print(Programmer.__bases__)                 # 부모클래스 보여준다.
print(Person.__bases__)                     # 모든 클래스의 최상위 클래스는 object이다.
 

class9_methodOverride.py

 
"""
method override
부모의 메소드와 이름을 동일하게 만들고 다시 재정의를 해주는 것이다.
"""
 
class Parent:
    def printData(self):
        print('tttttttttttest')
    def test123(self):
        print('11111111sssss')
 
# ???????만약 오버라이딩 하는데 다른 메소드일 경우에는 어떻게 되는건가?
 
class Child1(Parent):
    def printData(self):
        print('Child1 의 printData 재정의')
 
class Child2(Parent):
    def printData(self):
        print('Child2 의 printData 재정의')
        print('부모메소드와 이름은 같으나 수행되는 내용은 다르다.')
    def Abc(self):
        print('일반메소드')
 
c1 = Child1()
c1.printData()
c1.test123()
print()
c2 = Child2()
c2.printData()
print()
print('\n다형성----------------------------statement는 같으나 다른 출력------------------------------------------------------')
# par = Parent()        # 파이썬은 따로 부모 클래스 부를 것없이 해당 주소를 넘겨주면 되는 것이다.
par = c1                # 주소를 넘긴다.
par.printData()
par = c2
par.printData()
print()
plist = [c1, c2]
for item in plist:
    item.printData()

class10.py (다중 상속)

"""
다중 상속: 순서가 중요하다!!

"""
# Cry만 잘 보자.
class Tiger:
    data = '호랑이 세계'
    def Cry(self):
        print('호랑이 어흥!!')
    def Eat(self):
        print('맹수는 고기를 먹음')
 
class Lion:
    def Cry(self):
        print('사자 으르렁!!')
    def hobby(self):
        print('백수의 왕은 낮잠을 즐긴다.')
        print('백수의 왕의 2번째 취미')
 
class Liger1(Tiger,Lion):           # 다중상속, 중복데이터가 있을시에는 먼저 적힌 클래스의 멤버가 우선시 된다.
    pass
 
a1 = Liger1()
a1.Cry()
a1.hobby()
a1.Eat()
 
print('====='*30)
 
class Liger2(Lion,Tiger):
    data = '라이거가 나타났다'
    def play(self):
        print("라이거 고유 메소드")
        print('------------------')
        self.hobby()
        super().hobby()
        self.Cry()                      #이건 현 클래스에서 한번 찾고 상위 클래스로 간다.
        super().Cry()
    def hobby(self):
        print('라이거는 초원걷기가 취미')
 
a2 = Liger2()
a2.Cry()
print('-____------___')
a2.hobby()
a2.Eat()
a2.play()
print(a2.data)
 
 
 

class11_abstractClass.py

"""
추상 클래스 : 추상메소드를 1개이상 가지고 잇을경우에 된다.
추상 메소드는 일반메소드와 달리 반드시 가져와서 오버라이드 해야한다.
"""
from abc import *
 
 
class AbstractClass(metaclass=ABCMeta):             # 추상 클래스
 
    @abstractmethod                                    # 데코레이터
    def abcMethod(self):
        pass
 
    def normalMethod(self):
        print('추상클래스 내의 일반 메소드')
 
# TypeError: Can't instantiate abstract class AbstractClass with abstract methods abcMethod
# 추상클래스는 부모클래스로 의미있다. 위의 에러는 추상 메소드를 상속받아서 다시 오버라이드 하지 않아서 생긴거다
# TypeError: Can't instantiate abstract class Child1 with abstract methods abcMethod
# Child1 이 추상 메소드를 상속받아 오버라이드 하지 않아서 그렇다. 메소드를 강요하기 위해서 하는 것이다.
 
 
class Child1(AbstractClass):
    def abcMethod(self):
        print('추상 메소드를 오버라이드 했다.')
 
t1 = Child1()
t1.abcMethod()
t1.normalMethod()
 
 
class Child2(AbstractClass):
    def abcMethod(self):
        print('추상 메소드를 오버라이드 2222222222222.')
 
    def normalMethod(self):
        print('선택적으로 오버라이드')
 
t2 = Child2()
t2.abcMethod()
t2.normalMethod()
 
print("\n 다형성")
# 같은이름이나 다른 출력 등을 확인할수 있다.
aa = t1
aa.abcMethod()
aa = t2
aa.abcMethod()