12、面向对象介绍

1、什么是对象

对象就是内存中存储指定数据的一块区域，实际上对象就是一个容器，存储数据

2、对象结构

由标识、类型、值组成
标识(id)
	id用来标识对象的唯一性，每个对象都有唯一的id
	id是由解释器生成的，就是对象的内存地址
	用函数id()可查看对象的地址
类型(type)
	类型决定了对象哪些功能
	用函数type()来查看对象的类型
值(value)
	值指的是对象中存储的具体数据
	包含可变对象（list、dict、set）不可变对象（Number、字符串、Tuple、布尔)

3、面向对象

面向对象即只要面对对象即可，不必去关注对象的行为如何发生
举例：
比如大象装冰箱
不必去关心大象装冰箱的过程，只需要面对冰箱这个对象，通过冰箱的可装取的功能，实现大象装冰箱

4、类的介绍

比如汽车，可以是一个类。宝马、奔驰、本田即为汽车这个类的对象
类也是一个对象

定义一个类的格式

语法： class 类名([父类])
	代码块
--------------------------------------------------------
class MyClass()：
	pass

5、如何创建一个对象

什么是类

类是一个用来创建对象的对象
类是一个type类型的对象

class MyClass()：
  pass
print(type(MyClass))

显示结果为：<class 'type'>

类的定义

类中的事务有两部分组成：数据(属性)和行为(方法)
属性：类中的变量
语法：对象.属性=s 属性值
方法：类中的函数，且该函数默认传递一个参数，self
语法：对象.方法(实参)

类对象和实例对象
1、我们去调用一个属性和方法的时候，解释器先会去寻找实例对象中是否存在，如果有就返回，如果没有就去类的对象中查找，存在就返回，不存在就报错
2、如果这个属性(方法)是所有类共享，则应该保存到类对象中
3、如果这个属性(方法)是某个实例独有的，则应该保存在实例对象中

class Person:#Person为类对象
    def __init__(self,name):#特殊方法
        self.__name=name
    def Play(self):#Play类方法
        return f'显示{self.__name}'
p1=Person('葫芦娃')#类对象实例化，p1为实例对象，设定默认值
p2=Person('葫芦')
print(p1.Play())#方法调用
print(p2.Play())

6、特殊方法(魔术方法)

特殊方法格式  __方法名__
特点：会在特殊的时候自动调用。
init方法，类实例化时候就将执行

7、封装

封装是面向对象的三大特征之一
封装是指一些属性或方法不想被外界访问
使用封装的好处，确实增长了类定义复杂度，但是它确保了数据的安全性
1、增加了getter和setter方法,可以很好的控制属性是否是只读的
2、使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的
3、可以在读取属性和设置属性做一些其他的操作
4、隐藏了属性名，使调用者无法随意修改对象当中的属性

一般情况，使用_开头的属性都是私有属性，没有特殊情况下不要修改私有属性
一定要修改私有属性如下举例

class Person:   #类
    def __init__(self,name):    #魔术方法
        self.__name=name
        self.__age=0
    @property       #增加装饰器
    def Play(self): #自定义方法
        return f'姓名{self.__name},年龄{self.__age}'
    def setter(self,age):  #写入权限
        self.__age=age
    def getter(self):      #读取权限
        return self.__name
p1=Person('葫芦娃') #类实力化，p1为实例化对象，设置默认值
p2=Person('葫芦')
p1.setter(100)  #写入age
p2.setter(200)
print(p1.Play)  #调用方法，此处将play对象改变为属性，因为在定义play函数之前使用了property装饰器
print(p2.Play)
p1._Person__name='葫芦娃2'#改变私有属性值
print(p1.Play)

结果为：
姓名葫芦娃,年龄100
姓名葫芦,年龄200
姓名葫芦娃2,年龄100

8、@property和@xxx.setter

@property 其作用为将方法改成称属性，写出
@@xxx.setter 其作用为将方法改成称属性，可以当成属性赋值写入

9、继承

继承是指类继承父类的过程

class Animal:
    def __init__(self,name):
        self._name=name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name
    def run(self):
        return f'{self._name}在跑'
    def play(self):
        return f'{self._name}在玩'
class Dog(Animal):
    def __init__(self,age,name):
        self._age=age
        super().__init__(name)
    def go_shopping(self):
        print(f'带着{self._age}岁的{self._name}逛街')
d=Dog(16,'土狗')
d.go_shopping()
d.name='藏獒'
print(d.play())
print(d.run())

结论：
Animal为父类，Dog为子类,surper继承父类的INIT魔术方法，@property使得方法变为属性使用，返回当前值，@xxx.setter使得方法变属性，设置目标值。

isinstance(d,Animal) 判断d是不是Animal的实例对象，如果是，返回True，否则返回False
issubclass(Dog,Animal)判断 Dog是不是继承Animal类，如果是，返回True，否则返回False

10、方法重写

如果子类和父类中有相同的方法，则实例化子类后，首先调用子类的方法。

class Animal:
    def __init__(self,name):
        self._name=name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name
    def run(self):
        return f'{self._name}在跑'
    def play(self):
        return f'{self._name}在玩'
class Dog(Animal):
    def __init__(self,age,name):
        self._age=age
        super().__init__(name)
    def go_shopping(self):
        print(f'带着{self._age}岁的{self._name}逛街')
    def play(self):
        return print('在玩')
d=Dog(16,'土狗')
d.play()

结果显示：在玩

11、多态

面向对象三大特性之一
多个物质共同的属性，如一个类可以表示多个物质的共同属性

class Dog():
    def __init__(self,age,name):
        self._age=age
        self._name=name
    def go_shopping(self):
        print(f'带着{self._age}岁的{self._name}逛街')
d=Dog(10,'拉布拉多')
d1=Dog(11,'藏獒')
d2=Dog(12,'土狗')
d.go_shopping()
d1.go_shopping()
d2.go_shopping()

12、类中属性和方法

print('以下实例方法','-'*50)
class Person:
    age=10
    @property
    def man(self):
        man_age = 12
        return man_age
p=Person()	#实例化
print(p.age)	实例属性可调用
print(Person.age)	类属性可调用
print('-'*50)
print(p.man)	#实例方法可调用
print(Person.man)	#类方法无法调用
print('以下类方法','-'*50)
class Person2:
    age=10
    @classmethod
    def man(cls):
        man_age = 12
        return man_age
p=Person2()	#实例化
print(p.age)	#实例属性可调用
print(Person2.age)	#类属性可调用
print('-'*50)
print(p.man())		#实例方法可调用
print(Person2.man())	#类方法可调用
print('以下静态对象','-'*50)
class Person3:
    age=10
    @staticmethod
    def man():
        man_age = 12
        return man_age
p=Person3()	#实例化
print(p.age)		#实例属性可调用	
print(Person3.age)		#类属性可调用
print('-'*50)
print(p.man())		#实例方法可调用
print(Person3.man())	#类方法可调用

结论：
实例方法 
	定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
	调用：只能由实例对象调用。
类方法
	定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；
	调用：实例对象和类对象都可以调用。
静态方法
	定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；
	调用：实例对象和类对象都可以调用。

总结:

面向对象三大特点

封装确保对象中的数据更加安全

继承确保对象可扩展性

多态确保程序灵活性