Python 08 面向对象

Python 面向对象

---

1、编程范式

2、面向对象特性

3、属性、方法

4、三大特性

5、高级方法

6、类的特殊成员方法

7、反射

8、异常处理

9、单例模式

---

一、编程范式 

编程：程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 ， 实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。 

面向过程编程(Procedural Programming)

面向过程编程依赖：procedures，一个procedure包含一组要被进行计算的步骤，面向过程又被称为top-down languages， 就是程序从上到下一步步执行。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改，所以我们一般认为， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。

面向对象编程(Object-Oriented Programming )

面向对象编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

二、面向对象的特性

类：class，一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

对象 ：object，一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性

封装：Encapsulation，在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

继承：Inheritance ，一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

多态：Polymorphism ，多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

三、属性、方法

 1、属性、方法、类变量、实例变量

class dog: #dog：类名
    n = 123    #类变量
    def __init__(self,name):
        #构造函数
        #在实例化时做一些类的初始化工作
        self.name = name  #实例变量（静态属性），作用域就是实例本身
    def bulk(self):  #类的方法（动态属性），功能
        print("%s:wang wang wang !"% self.name)

d1 = dog("狗") #d1 叫做dog类的实例
d1.bulk()

2、构造函数、析构函数、私有方法、私有属性

#析构函数：在实例释放、销毁的时候执行的，通常用于做一些收尾工作，如关闭一些数据库连接打开的临时文件
class dog: #dog：类名
    def __init__(self,name,age = 0):
        #构造函数
        #在实例化时做一些类的初始化工作
        self.name = name
        self.__age = age  #私有属性：只能在内部访问和修改(私有方法同理也是在函数前面加两个_)
    def show_age(self):
        print("name:%s age:%s"%(self.name,self.__age))
    def after_year(self):
        self.__age += 1
        print("一年过去了。。。")
    def __del__(self):  #析构函数
        print(self.name)
r1 = dog("哈士奇")
r1.after_year()
r1.show_age()

四、特性

1、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容

将内容封装到某处：

class foo: #类名
    def __init__(self,name,age):
        self.name = name
        self.age = age
pop1 = foo("zz",12)
pop2 = foo("aa",13)
# foo相当于一类事物的模板，当执行pop1 = foo("zz",12)时
# 相当于在foo中：self = poo1，pop1 = foo("zz",12) 即 pop1 = foo(por1,"zz",12)
# 将类中的内容封装到了对象 pop1中，而pop1有了自己的name 和 age 属性并在内存中保存了下来

从某处调用被封装的内容

class foo: #类名def __init__(self,name,age):self.name = nameself.age = age
pop1 = foo("zz",12)print(pop1.name,pop1.age)  #通过对象直接调用

class foo: #类名
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def detail(self):
        print(self.name,self.age)
pop1 = foo("zz",12)
pop1.detail() #通过self间接调用

2、继承

继承：面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

class People:def __init__(self,name,age):self.name = nameself.age = agedef eat(self):print("%s is eating..."%self.name)def talk(self):print("%s is talking..."%self.name)def sleep(self):print("%s is sleeping..."%self.name)
class man(People):def __init__(self,name,age,money):# People.__init__(self,name,age)  #重构父类构造函数super(man,self).__init__(name,age)self.money = moneydef drink(self):print("%s is drinking..."%self.name)def sleep(self):People.sleep(self)   #重构父类方法print("man is sleeping...")
class woman(People):def makeup(self):print("%s is makeuping..."%self.name)m1 = man("zz",12,1)
m1.drink()
m1 .sleep()
m2 = woman("aa",10)

多继承：

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

# 经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法
# 从写法上区分的话，如果当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类
#class People:  #经典类
class People(object):   #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s is eating..."%self.name)
    def talk(self):
        print("%s is talking..."%self.name)
    def sleep(self):
        print("%s is sleeping..."%self.name)
class relation(object):
    def make_friend(self,obj):
        print("%s is making friend with %s"%(self.name,obj.name))

class man(People,relation):
    def __init__(self,name,age,money):
        # People.__init__(self,name,age)  #重构父类构造函数
        super(man,self).__init__(name,age)
        self.money = money
    def drink(self):
        print("%s is drinking..."%self.name)
    def sleep(self):
        People.sleep(self)   #重构父类方法
        print("man is sleeping...")
class woman(People,relation):
    def makeup(self):
        print("%s is makeuping..."%self.name)

m1 = man("zz",12,1)
w1 = woman("aa",10)
m1.make_friend(w1)

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

  

#经典类多继承：深度优先
class D:def bar(self):print ('D.bar')
class C(D):def bar(self):print ('C.bar')
class B(D):def bar(self):print ('B.bar')
class A(B, C):def bar(self):print ('A.bar')
a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()#新式类多继承：广度优先
class D(object):def bar(self):print ('D.bar')
class C(D):def bar(self):print ('C.bar')
class B(D):def bar(self):print ('B.bar')
class A(B, C):def bar(self):print ('A.bar')
a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()# 经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

从py3开始全部都是广度优先，没有深度优先

3、多态

 Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。

多态的作用是实现接口的重用

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)

class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' %self.name)
# c1 = Cat('猫')
# c1.talk()
# d1 = Dog('狗')
# d1.talk()
# 为采用多态
def anmiaml(obj): #一个接口，多种形态
    obj.talk()
c1 = Cat('猫')
d1 = Dog('狗')
anmiaml(c1)
anmiaml(d1)

 五、高级方法

1、静态方法

只是名义上归类管理，实际上在静态方法里访问不了类或实例中的任何属性

class dog(object):
    def __init__(self,name):
        self.name = name
    @staticmethod  #加上之后下面的方法和类就没有关系了
    def eat(self):
        print("%s is eating %s"%(self.name,"骨头"))
# 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法
# 可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量
# 但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了
# 它与类唯一的关联就是需要通过类名来调用这个方法
d = dog("狗")
# d.eat("骨头")  未加@staticmethod时的调用
d.eat(d)

2、类方法

只能访问类变量，不能访问实例变量

class dog(object):
    name = "gou"
    def __init__(self,name):
        self.name = name
    @classmethod
    def eat(self):
        print("%s is eating %s"%(self.name,"骨头"))
    def talk(self):
        print("%s is talking.."%self.name)
d = dog("狗")
d.eat()  #gou is eating 骨头  输出内容为类变量参数而非实例变量参数

3、属性方法

把一个方法变成一个静态属性

class dog(object):
    name = "gou"
    def __init__(self,name):
        self.name = name
        self.__food = "骨头"
    @property  #把一个方法变成静态属性
    def eat(self):
        print("%s is eating %s"%(self.name,self.__food))
    @eat.setter     #给静态属性传参数
    def eat(self,food):
        print("set to food:",food)
        self.__food = food
    @eat.deleter
    def eat(self):
        del self.__food
        print("删除私有food！")
    def talk(self):
        print("%s is talking.."%self.name)
d = dog("狗")
d.eat  #只能按照静态属性调用方式调用不能传参数，也不能d.eat()
d.eat = "狗粮"  #给静态属性传参数
d.eat   #狗 is eating 狗粮
del d.eat
d.eat  #报错

六、类的特殊成员方法

class dog(object):
    '''描述狗这个对象'''
    '''写类的时候一定写上这个类是作什么用的'''
    name = "gou"
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s is eating.."%self.name)
    def talk(self):
        print("%s is talking.."%self.name)
    def __call__(self, *args, **kwargs):
        print("run in call..",args,kwargs)
    def __str__(self):
        return "<obj:%s>"%self.name
# 1、 __doc__  输出：类的描述信息
print(dog.__doc__)    #输出：类的描述信息 (描述狗这个对象)
# 2、__module__ 表示当前操作的对象在那个模块
# 3、__class__  表示当前操作的对象的类是什么
print(dog.__module__)  #__main__  如果这个类是import的则会返回这个类所在模块的目录
print(dog.__class__)   #<class 'type'> 输出这个类本身
# 4、__init__ 构造方法，通过类创建对象时，自动触发执行
# 5、__del__　析构方法，当对象在内存中被释放时，自动触发执行
# 6、__call__ 对象后面加括号，触发执行
d = dog("狗")
d(1,2,3,name = 321)   #输出：run in call.. (1, 2, 3) {'name': 321}
# 7、__dict__ 查看类或对象中的所有成员
print(dog.__dict__)  #以一个字典的形式把类中的方法属性全部打印，不包括实例属性
print(d.__dict__)   #输出：{'name': '狗'} 打印所有实例属性，不包括类属性
# 8、__str__ 如果一个类中定义了__str__方法，那么在打印 对象时，默认输出该方法的返回值
print(d)  #输出：<obj:狗>
# 9、__getitem__、__setitem__、__delitem__ 用于索引操作，如字典。分别表示获取、设置、删除数
class Foo(object):
    def __getitem__(self, key):
        print('__getitem__',key)
    def __setitem__(self, key, value):
        print('__setitem__',key,value)
    def __delitem__(self, key):
        print('__delitem__',key)
obj = Foo()
result = obj['k1']   # 自动触发执行 __getitem__
obj['k2'] = 'zz'   # 自动触发执行 __setitem__
del obj['k1']      # 自动触发执行 __delitem__
# 10、__new__ \ __metaclass__
class Foo(object):
    def __init__(self,name):
        self.name = name
f = Foo("zz")
print(type(f))  #<class '__main__.Foo'>  表示，obj 对象由Foo类创建
print(type(Foo))  #<class 'type'>   表示，Foo类对象由 type 类创建
# 即：Foo是通过type类的构造方法创建
# 创建类就可以有两种方式
# 普通方式
class Foo(object):
    def func(self):
        print("in Foo!")
#特殊方式
def func(self):
    print("in func!")
foo = type('foo',(object,), {'func': func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员
# 类 是由 type 类实例化产生
# 类默认是由 type 类实例化产生，type类中如何实现的创建类:
# 类中有一个属性 __metaclass__，其用来表示该类由谁来实例化创建，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看类创建的过程。
# 类的生成调用顺序依次是 __new__ --> __init__ --> __call__

七、反射

通过字符串映射或修改程序运行时的状态、属性、方法

def bulk(self):
    print("%s is bulking..."%self.name)
class Dog(object):
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s is eating..."%self.name)

d = Dog("狗")
choice = input(">>:").strip()
#输入eat
print(hasattr(d,choice)) #True
#hasattr（obj,name_str） 判断一个对象obj里是否有对应的name_str字符串的方法映射
# print(getattr(d,choice)) #<bound method Dog.eat of <__main__.Dog object at 0x0000022F8A69C7F0>> 内存对象
#getattr（obj,name_str） 根据字符串去获取obj对象里的对应的方法的内存地址
if hasattr(d,choice):
    func = getattr(d,choice)
    func()
else:
    setattr(d,choice,bulk)
    d.bulk(d)
#setattr(obj,'y',z) 通过字符串设置新的方法
#delattr
delattr(d,choice)

 八、异常处理

1、介绍

在编程过程中为了增加友好性，在程序出现报错时一般不会将错误信息显示给用户，而是显示一个提示的页面。

name = []
dir = {}
try:
    dir["aa"]
    name[2]
except KeyError as e:
    print("没有这个key：",e)
except IndexError as e:
    print("列表操作错误:",e)

name = []
dir = {}
try:
    dir["aa"]
    name[2]
    open('zz.txt')
except KeyError as e:
    print("没有这个key：",e)
except IndexError as e:
    print("列表操作错误:",e)
# except (KeyError,IndexError) as e: #一般不这么写，这样不知道是哪个触发的
except Exception as e: #抓住所有错误
#对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行
    print(e)
else:
    print("一切正常！") #如果程序没有任何错误走这里
finally:
    print("不管有没有错都执行！")

2、异常种类

#常用异常：
'''
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
''''''其他异常：
ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError
'''

 3、自定义异常

class My_Exception(Exception):
    def __init__(self, msg):
        self.message = msg
try:
    raise My_Exception('我的异常')  #主动触发异常
except My_Exception as e:
    print(e)
    

 九、单例模式

#单例模式：永远用一个实例的模式

# class Foo(object):
#     instance = None
#
#     def __init__(self):
#         self.name = 'alex'
#     @classmethod
#     def get_instance(cls):
#         if Foo.instance:
#             return Foo.instance
#         else:
#             Foo.instance = Foo()
#             return Foo.instance
#
#     def process(self):
#         return '123'

# obj1 = Foo()
# obj2 = Foo()
# print(id(obj1),id(obj2))

#low的单例模式
# obj1 = Foo.get_instance()
# obj2 = Foo.get_instance()
# print(id(obj1),id(obj2))


#基于new方法实现单例模式
class Foo(object):
    instance = None

    def __init__(self):
        self.name = 'alex'

    def __new__(cls, *args, **kwargs):
        if Foo.instance:
            return Foo.instance
        else:
             Foo.instance = object.__new__(cls, *args, **kwargs)
             return Foo.instance

# obj1 = Foo()
# obj2 = Foo()
# print(id(obj1),id(obj2))