python基础九：面向对象

1、面向对象的简介

1.1对象

分为可变与不可变可以参考（可变对象与不可变对象的区别）
定义：对象就是内存中专门用来储存数据的一块区域
对象的结构：①id(标识)②type(类型)③value(值)

1.2面向过程

①面向过程指将我们的程序分解为一个一个步骤，通过对每个步骤的抽象来完成程序
②这种编写方式往往只适用于一个功能，如果要实现别的功能，往往复用性比较低
③这种编程方式符号人类的思维，编写起来比较容易
例如：
1.妈妈穿衣服穿鞋出门
2.妈妈骑上电动车
3.妈妈到超市门口放好电动车
4.妈妈买西瓜
5.妈妈结账
6.妈妈骑电动车回家
7.到家孩子吃西瓜
这个可以用面向过程解决，一步一步实现符合人的思维逻辑，但是如果爸爸买瓜，奶奶吃瓜等需求改变时，面向过程的复用性就不足所以出现了面向对象

1.3面向对象

①面向对象的编程思维：将所有功能统一保存到对应的对象中，要使用某个功能，直接找到对应的对象即可
②优缺点：这种编码方式比较容易阅读，并且易于维护，容易复用。但是编写的过程中不太符合常规的思维，编写相对麻烦

2、类（class）

①我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以我们在开发中经常要自定义一些对象
②类简单理解它就是相当于一个图纸，在程序汇总我们需要根据类来创建对象。
③类就是对象的图纸我们也称对象是类的实例(instance)如果多个对象是通过一个类创建的，我们称这些对象是一类对象。类也是一个对象，类就是用来创建对象的对象可以像对象中添加变量，对象中的变量称之为属性
③ 语法：对象.属性名 = 属性值

# 语法
class 类名([父类]):
    pass

3、类的定义

类和对象都是对现实生活中事物的抽象
事物包含两部分：1. 数据(属性)2. 行为(方法)、
调用方法 对象.方法名()

3.1类属性

直接在类中定义的属性是类属性
类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象修改

3.2实例属性

通过实例对象添加的属性属于实例属性
实例属性只能通过实例对象来访问和修改，类对象无法访问修改

3.3方法

在类中定义，以self为第一个参数的方法都是实例方法
实例方法在调用时,Python会将调用对象以self传入
实例方法可以通过类实例和类去调用
当通过实例调用时，会自动将当前调用对象作为self传入
当通过类调用时，不会自动传递self，我们必须手动传递self

3.4类方法

在类的内容以@classmethod 来修饰的方法属性类方法
类方法第一个参数是cls 也会自动被传递。cls就是当前的类对象
类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
类方法可以通过类去调用，也可以通过实例调用

3.5静态方法

在类中用@staticmethod来修饰的方法属于静态方法
静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
静态方法一般都是些工具方法，和当前类无关

3.6方法调用和函数调用的区别

①如果是函数调用，调用时有几个形参，就会传递几个实参。如果是方法调用，默认传递一个实参，所以方法中至少得有一个形参(self)
②在类代码块中，我们可以定义变量和函数
变量会成为该类实例的公共属性，所有的该实例都可以通过 对象.属性名的形式访问
③函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名的形式访问

4、参数（self）

4.1属性和方法

①类中定义的属性和方法都是公共的，任何该类实例都可以访问，当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错

4.2 self参数

方法每次被调用的时候，解析器会自动传递一个实参
如果是p1调用，则第一个参数就是p1对象
如果是p2调用，则第一个参数就是p2对象
这样保证了谁实例化，类中的属性和方法就可以被谁调用

5、特殊方法

在类中可以定义一些特殊方法也称为魔术方法或者构造方法
特殊方法都是形如 __xxx __()这种形式（双下划线开头，双下划线结尾）
① __ init __ ()方法传参时直接在实例化中传入实参就好，他没有返回值返回值是None也就是不能自定义返回值，这就是self起的作用

class Person():
    name = '北妖'
    # 特殊方法的作用，①给对象初始化②不调用就自身调用
    def __init__(self,age,hometown):
        self.age = age
        self.hometown = hometown
    def action_speak(self):
        print('i am from {} and run action_speak'.format(self.hometown))
a = Person(18,'SHANXI')
a.action_speak()#运行结果：i am from SHANXI and run action_speak

② __ str __()方法：打印对象变量时，能够打印自定义的内容，自定义的内容通过return返回

class A():
    def __init__(self):
        self.name = 'beiyue'
        self.age = 22
    def __str__(self):
        return f"{self.name}, {str(self.age)}"
a = A()
print(a)  # 返回值是beiyue,22，注意只能返回字符串，
# 返回多个值默认以元组返回，也不行要格式化字符串才能
print(a.__str__())  # 这样可以返回就跟调用普通方法没区别，返回他的返回值

6、封装

什么是封装：
①封装是面向对象的三大特性之一
②封装是指隐藏对象中一些不希望被外部所访问到的属性或方法
③我们也可以提供给一个getter()和setter()方法是外部可以访问到属性
getter() 获取对象中指定的属性
setter() 用来设置对象指定的属性

6.1封装上

目前我们可以直接通过 对象.属性的方式来修改属性值，这种方式导致对象中的属性可以随意修改 非常不安全

class Person():
    name = '北妖'
    def __init__(self,name):
        self.name = name
    def action_speak(self):
        print('hello everyone i am %s'%self.name)
p1 = Person('赤月') # hello everyone i am 赤月
p1.action_speak()
p1.name = '萧炎'
p1.action_speak() # hello everyone i am 萧炎

现在我们需要一种方式来增强数据的安全性，满足以下两点需求
1.属性不能随意修改
2.属性不能改为任意值
可以对对象的属性使用双_ _下划线开头
双下划线的属性是对象私有属性(隐藏属性)，私有属性只能在类的内部访问，无法通过对象访问

其实隐藏属性只不过是Python自动为属性修改了一个名字如果非要在外部访问也可以,以上述为例变print(a.__age)为print(a._A__age)就可以了 (_类名__私有属性)，没有严格意义的封装，但是也可以明确的告诉别人这是我的私有属性希望别改

6.2 封装下

使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
①隐藏属性名，使调用这无法随意的修改对象中的属性
②增加了getter()和setter()方法，很好控制属性是否是只读的
③使用setter()设置属性，可以在呢及数据的验证
④使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理

class Person():
    def __init__(self,name,age,hometown):
        self.__name = name
        self.age = age
        self.hometown = hometown
    def getter(self):
        return (self.__name,self.age)
    def setting(self,name,age):
        self. __name = name
        if age>0:
            self.age = age
p1 = Person('北月','18','shanxi')
print(p1.getter()) # ('北月', '18')
p1.setting('赤月',-5) # 赤月 18
# print(p1.__name,p1.age) # 报错无法访问
print(p1.getter()) # 赤月，18

6.3@property装饰器

封装的使用实例就是装饰器(还有别的，以property装饰器举例)
我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改
实例对象调用方法的时候就不能加括号了，比如text就是使用了装饰器一般
response = requests.get(url,…).text

class Stu():
    def __init__(self):
        self.__age = '22'
    def get_age(self):
        print(self.__age)
        return self.__age
    def set_age(self, age):
        self.__age = age
        print(self.__age)
    def del_age(self):
        print(self.__age)
        del self.__age
        print(self.__age)
    age = property(fget=get_age, fset=set_age, fdel=del_age)
a = Stu()
a.age
a.age = '25'
del a.age

setter只能是有property才能使用
setter和getter方法的装饰器是@属性名.setter(getter)属性名是property的名字

class A():
    def __init__(self):
        self.__name = '123'
    @property
    def test(self):
        print(self.__name)
    @test.setter
    def demo(self,name):
        self.__name = name
        print(self.__name)
a = A()
a.test
a.demo = 'hhh'    

8、继承的简介

8.1继承简介

特点：
① 让类与类之间产生关系，有了这层关系，就有了继承的特性
② 提高了代码的复用性

8.2继承的使用

继承是面向对象的三大特性之一
我们使用继承是可以获取到另一个类的属性和方法
在定义类的时候，我们可以在类名的括号中指定当前类的父类(超类，基类)
在创建类的时候，如果省略了父类，则默认父类是object
object是所有类的父类，所有类都继承与object
子类可以直接调用父类当中的方法，如果父类没有则从父类的父类找，如果又没有则报错

8.3方法重写

如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
当我们调用一个对象的方法时：
会优先去当前对象中寻找是否具有该方法，如果有则直接调用
如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了

8.4super（）

想要引用父类当中的方法，避免重复造轮子可以有两种形式
①父类.父类的方法(self)
②super()可以获取当前类的父类的所有方法，并且通过super()返回对象调用父类方法时，不需要传递self

class Person():
    def __init__(self,name,age,gender,addr):
        self._name = name
        self._age = age
        self._gender = gender
        self._addr = addr
    def speak(self):
        print('i can speak')
    @property
    def get_ter(self):
        return (self._name,self._age,self._gender,self._addr)
    @get_ter.setter
    def get_ter(self,z):
        (self._name,self._age,self._gender,self._addr) = z
class p1(Person):
    def __init__(self,name,age,gender,addr):
        super().__init__(name,age,gender,addr)
a = p1('a',18,'male','shanxi')
print(a.get_ter)
a.get_ter = ('b',5,'s','s')
print(a.get_ter)

8.5多重继承

在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
可以在类名的()后边添加多个类，来实现多重继承
多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的
__bases__ 可以获取当前类所有的父类（对象.__bases__）就可以调用
总结：
1、深度优先，先找自身，找不到往自己父类找
2、重写(防止自身有了却执行父类的方法)
3、self永远执行该方法的调用者
4、super(子类，self).父类当中的方法(*args)或者父类名.父类中的方法(self)

12、多态

①多态的概念是应用于java和c#这些强类型语言中，python崇尚’鸭子类型‘，企鹅不是鸭子但在python中只要像就把他认为是，所以企鹅也可以用鸭子的行为和方法
②动态语言调用实例方法的时候不检查类型，只要这个方法存在，参数正确，就可以调用，这就是动态语言的额’鸭子类型‘，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子，那么他就可以被当成鸭子”
③多态是面向对象的三大特性之一。从字面理解就是多种形态，定义时的类型和运行时的类型不一样，可以以不同形态去呈现，所以叫做多态
面向对象三大特性
封装：确保对象中数据的安全
继承：保证了对象的扩展性
多态：保证了程序的灵活性