第五章---面向对象---1.组合/2.抽象类/3.多态与多态性/4.鸭子类型

1.组合：

选课系统 老师类 学生类
组合： 什么有什么    # 继承：什么是什么  代码重用
老师类的数据属性 = 课程类/[]     什么有什么 eg:老师有课程  学生有生日
student1.course1.tell_info()
student1.birth.tell_info()

class People:
    school = 'luffycity'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class Teacher(People):
    # school = 'luffycity'
    def __init__(self,name,age,sex,level,salary):
        # self.name = name
        # self.age = age
        # self.sex = sex
        super().__init__(name,age,sex)

        self.level =level
        self.salary = salary

    def teach(self):
        print('%s is teaching' % self.name)


class Student(People):
    # school = 'luffycity'

    def __init__(self, name, age, sex, class_time):
        # self.name = name
        # self.age = age
        # self.sex = sex
        super().__init__(name,age,sex)

        self.class_time = class_time

    def learn(self):
        print('%s is learning' % self.name)

class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period

    def tell_info(self):
        print('课程名<%s> 课程价格<%s> 课程周期<%s>' % (self.course_name,self.course_price,self.course_period))

class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day

    def tell_info(self):
        print('%s-%s-%s' % (self.year,self.mon,self.day))

teacher1 = Teacher('alex',18,'male',10,3000)
teacher2 = Teacher('egon',18,'female',30,3000)
python = Course('python',3000,'3mons')
linux = Course('Linux',2000,'4mons')

# 老师和课程不是什么是什么的关系，也就不能使用继承
# 但老师和课程是老师有课程的关系(相当于老师有名字，有性别)
# 可以把课程当做老师的一个属性,这就是组合
teacher1.course = python
teacher2.course = python

# print(python)
# print(teacher1.course)
# print(teacher2.course)
# # <__main__.Course object at 0x021A6230>
# # <__main__.Course object at 0x021A6230>
# # <__main__.Course object at 0x021A6230>

# print(teacher1.course.course_period)
# # 3mons

# teacher1.course.tell_info()
# # 课程名<python> 课程价格<3000> 课程周期<3mons>

# student1 = Student('王二',20,'female','08:30')
# student1.course1 = python
# student1.course2 = linux
#
# student1.course1.tell_info()
# student1.course2.tell_info()
# # 课程名<python> 课程价格<3000> 课程周期<3mons>
# # 课程名<Linux> 课程价格<2000> 课程周期<4mons>

# 多重玩法：变成列表
# student1.courses = []
# student1.courses.append(python)
# student1.courses.append(linux)
# student1.courses[0].tell_info()
# student1.courses[1].tell_info()
# # 课程名<python> 课程价格<3000> 课程周期<3mons>
# # 课程名<Linux> 课程价格<2000> 课程周期<4mons>

student1 = Student('王二',20,'female','08:30')
d = Date(1990,8,24)

student1.birth = d
student1.birth.tell_info()
# 1990-8-24

2.抽象类

人 猪 狗 都是动物 走的功能 名称不一样 找一种统一的方案
java 有interface 可以解决统一的方案！
在python中根本就没有一个叫做interface的关键字，如果非要去模仿接口的概念
可以借助第三方模块：http://pypi.python.org/pypi/zope.interface
但python 有自己的抽象类
抽象类: 只能被继承 不能被实例化 本质上还是一个类  功能就是规范子类
       基于继承演变而来的！ 好处降低使用者的使用复杂度  统一标准

# 需要一个方法，将一些类相同的方法统一抽象起来
# 此时就可以为他们抽象出一个父类出来，为了让子类调用方法适合强制使用父类的名称，需要引进一个第三方模块abc
import abc
class Animal(metaclass=abc.ABCMeta):  # 只能被继承，不能被实例化
    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def eat(self):
        pass

class People(Animal):
    def run(self):
        print('people is walking...')

    def eat(self):
        print('people is eating...')

class Pig(Animal):
    def run(self):
        print('pig is walking...')

    def eat(self):
        print('pig is eating...')

class Dog:
    def run(self):
        print('dog is walking...')

    def eat(self):
        print('dog is eating...')

peo1 = People()
# pig1 = Pig()
# dog1 = Dog()
#
# peo1.run()
# pig1.run()
# dog1.run()

# a = Animal()  # 会报错

3.多态与多态性

多态：指的就是同一类事物有多种形态，
      eg:动物有多种形态： 人  狗  猪
         文件有多种形态： 文本文件 可执行文件

多态的好处：
   多态性：指的是可以在不考虑对象的类型的情况下而直接使用对象
       动态多态性：# peo1.talk()
       静态多态性：# str int list  可相加+  str+str int+int

多态性的好处：
   1.增加了程序的灵活性  -- 建立在多态的前提下
　   　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
   2.增加了程序的扩展性
     　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 

# 多态：同一类事物的多种形态
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

class Cat(Animal):  # 扩展的
    def talk(self):
        print('say miaomiao')

# 多态性：指的是可以在不考虑对象的类型的情况下而直接使用对象
peo1=People()
dog1=Dog()
pig1=Pig()
cat1=Cat()
# peo1.talk()  # 动态多态性
# dog1.talk()
# pig1.talk()

# 不考虑对象的类型的情况下而直接使用对象
# eg.学开车 学的是怎么开车 不是怎么开具体哪款车 tesla 宝马等 多态性带来的好处
def fun(animal):
    animal.talk()

fun(peo1)
fun(pig1)
fun(dog1)
fun(cat1)  # 在使用的时 直接使用

4.鸭子类型

python 崇尚鸭子类型
鸭子类型： 类与类之间不用共同继承父类，只要做的像一种事物
不继承父类 有共同的方法 给使用者带来了直观性

# class File:
#     def read(self):
#         pass
#     def write(self):
#         pass

# class Disk:
#     def read(self):
#         print('disk read')
#     def write(self):
#         print('disk write')
#
# class Text:
#     def read(self):
#         print('text read')
#     def write(self):
#         print('text write')
#
# disk = Disk()
# text = Text()
#
# disk.read()
# disk.write()
#
# text.read()
# text.write()

# 序列类型：列表list，元组tuple，字符串str

l = list([1,2,3])
t = tuple(('a','b'))
s = str('hello')

# 列表，元组，字符串都像序列类型，所以都可以使用__len__()方法
print(l.__len__())
print(t.__len__())
print(s.__len__())

def  len(obj):
    return obj.__len__()

print(len(l))
print(len(t))
print(len(s))