一、面向对象

面向对象是一种符合人类思维的编程方法，现实世界就是由对象和对象构成的，所以我们可以用代码将现实世界映射到开发中。 每一个对象都有他自己的状态和行为，以汽车为例：

状态：油耗，颜色，轴距，速度，材质......

行为：启动，行使，加减速，刹车......

二、类

类是构建对象的状态和行为的模板，以汽车为例，类就是汽车的设计图或者骨架图，而实例则是根据设计图制造出来的实物，被称作为对象。

例如：宝马88系中 红色，蓝色，黑色等。

定义一个类：

def car (object):
pass
#所有的类都会继承object类，不知道填什么就填这个类

三、类的属性和方法

类中定义的函数叫类的方法，类方法与普通函数的区别在于，其第一个参数固定为self，表示实际使用时对应的实例本身,可以使用init方法将一些强制的属性绑定进去。

1：定义一个Student类

class Car(object):
 #由于类是模板，当创建实例时，可以使用__init__构造方法将强制的属性绑定进去,self参数指向实例本身
       def __init__(self,speed):
        #给car定义speed属性
        self.speed = speed
    #定义一个打印汽车速度的方法（函数）
    def run(self):
        print('现在速度为：',self.speed)
        return  self.speed

2：传入参数

#创建student的实例,并传入数据
baoma = Car(100)

3：访问对象的属性

class Car(object):
    # speed = 0       #共用的类属性
    def __init__(self,speed,):
        self.speed = speed
    def run(self):
        print('现在速度为：',self.speed)
        return  self.speed

#创建Car的实例,并传入数据      
baoma = Car(100)

#调用baoma对象的speed属性。
print(baoma.speed)

#调用baoma的打印速度方法：
baoma.run()

运行结果：

L:/python项目库/面向对象编程/面向对象.py

100
现在速度为： 100

进程已结束,退出代码0

4：类的封装

因为在Student类中已经含有对象的属性，所以没必要在外部重新定义新的函数访问，我们可以在Student类中定义函数，这样的就叫封装。封装的好处是可以在类中新增方法。

新增打印汽车型号的方法。

class Car(object):
    def __init__(self,name,speed,):
        self.speed = speed
        self.name = name
    def run(self):
        print('现在速度为：',self.speed)
        return  self.speed
    #新增根据速度打印汽车型号的方法。
    def car_xh(self):
        if self.speed > 300:
            print(self.name,':','超级跑车')
        elif self.speed > 200:
            print(self.name,':','豪华型轿车')
        else:
            print(self.name,':','经济型轿车')

#创建Car的实例,并传入数据 
baoma = Car('baoma_X1',100)

#调用查询汽车型号的方法
baoma.car_xh()

5：访问限制

现在定义的类，外部可以访问到类的属性，这样很不安全，而且外部可以直接更改Car类的速度属性。

class Car(object):
    def __init__(self,name,speed,):
        self.speed = speed
        self.name = name
    def run(self):
        print('现在速度为：',self.speed)
        return  self.speed

#创建Car的实例,并传入数据
baoma = Car('baoma_X1',100)

#外部访问baoma的型号和速度
print(baoma.name,baoma.speed)

#外部更改宝马X1的参数
baoma.name = 'new_baoma_X1'
baoma.speed = 120

#更改后，再访问baoma的型号和速度
print(baoma.name,baoma.speed)

运行结果：

baoma_X1 100

new_baoma_X1 120

进程已结束,退出代码0

如果要让类的属性不被外部访问，直接在类属性的名称前加“__”两个下划线，这样就变成了一个私有变量（private）

更改为私有变量之后

Traceback (most recent call last):
  File "L:/python项目库/面向对象编程/面向对象.py", line 26, in <module>
    print(baoma.name,baoma.speed)
AttributeError: 'Car' object has no attribute '__name'

这样就不能直接访问了，但是又想让外部访问和更改怎么办？而且还要对更改的参数做检查。

6：改进版访问限制

外部访问方法：get_name，get_speed

class Car(object):
    def __init__(self,name,speed,):
        self.__speed = speed
        self.__name = name
    def get_name(self):
        return self.__name
    def get_speed(self):
        return  self.__speed
    def run(self):
        print('现在速度为：',self.__speed)
        return  self.__speed

#创建Car的实例,并传入数据
baoma = Car('baoma_X1',100)

#外部访问baoma的型号和速度
print(baoma.get_name(),baoma.get_speed())

运行结果：

baoma_X1 100

进程已结束,退出代码0

外部更改speed的方法：set_speed，并检查参数不能小于0

class Car(object):
    def __init__(self,name,speed):
        self.__speed = speed
        self.__name = name
    def get_name(self):
        return self.__name
    def get_speed(self):
        return  self.__speed
    def set_speed(self,speed):
        if speed > 0:
            self.__speed = speed
        else:
            raise ValueError('speed Erro')
    def run(self):
        print('现在速度为：',self.__speed)
        return  self.__speed

#创建Car的实例,并传入数据

baoma = Car('baoma_X1',100)
#调用set_speed方法，并传入错误参数
baoma.set_speed(0)

#外部访问baoma的型号和速度
print(baoma.get_name(),baoma.get_speed())

运行结果：

Traceback (most recent call last):
  File "L:/python项目库/面向对象编程/面向对象.py", line 34, in <module>
    baoma.set_speed(0)
  File "L:/python项目库/面向对象编程/面向对象.py", line 18, in set_speed
    raise ValueError('speed Erro')
ValueError: speed Erro

四、多态和继承

1：继承

##继承
class Animal(object):
    def speak(self):
        print('Animal is speaking:')

#定义Dog类，从父类继承
class  Dog(Animal):
    pass
class Cat(Animal):
    pass
#定义dog对象并调用继承来的Animal类的speak方法
dog = Dog()
dog.speak()

dog对象什么都没有做就能拿到Animal的方法，因为他即是Dog的子类也是Animal的子类。

2：多态

# -*- coding: utf-8 -*-

###多态
class Animal(object):
    def speak(self):
        print('Animal is speaking:')

#定义Dog类，从父类继承
class  Dog(Animal):
   def speak(self):
        print('汪汪')

class Cat(Animal):
    def speak(self):
        print('喵喵')

#定义一个外部函数speak_twice,传入的参数只要是带speak方法的对象就执行。
def speak_twice(animal):
    animal.speak()
    animal.speak()

speak_twice(Animal())
speak_twice(Dog()) 

1：在写一个函数speak_twice时，要调用Animal类，只需要保证函数中speak方法编写正确，不管你想调用子类Dog还是父类Animal还是新的子类，都可以拿到父类的speak方法。 2：在1中，如果子类的方法名和父类重复时，子类的优先执行，所以父类的方法即可继承有可以重写。

开闭原则：

对扩展开放：允许新增Animal子类；

对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

Python的鸭子理论

在Python中，只要你长得像鸭子那你就是鸭子 如： 在上面的多态例子中，函数speak_twice，只要你有speak方法那么就会执行，不管你的父类是谁

class yazi(object):
    def speak(self):
        print('嘎嘎')

speak_twice(yazi())

五、多重继承

继承和多态不仅可以继承父类的功能和行为，也可以继承多个父类，这样的叫多重继承。

# -*- coding: utf-8 -*-
"""
@author:leelian
@time:2018/9/2515:40
"""
class Bird(object):
    pass
class Mammal(object):
    pass
class Flyable(object):
    def say(self):
        print('我会飞!')
class Swimmable(object):
    def say(self):
        print('我会游泳')

#定义一种会飞的哺乳动物
class Bat(Flyable,Mammal):
    pass
#创建实例，并调用实例的方法
bat = Bat()
print(bat.say())

#如果多重继承中有多个父类，以第一个为主。
class Seagull(Mammal, Flyable, Swimmable):
    pass

#创建实例，并调用实例的方法)
seagull = Seagull()
seagull.say()

###类的定制__iter__
#构造一个迭代类
class FactorialIterator(object):
    def __init__(self):
        self.value = 1
        self.index = 1
    def __next__(self):
        self.value = self.value * self.index
        self.index = self.index + 1
        if self.index > 11:
                 raise  StopIteration()
        return self.value

class Factorial(object):
    def __init__(self):
        pass
    def __iter__(self):
        return FactorialIterator()

factorial = Factorial()
for n in factorial:
    print(n)