1 面向对象
什么是面向对象？
譬如生产一个橱柜，需要三个属性
1）橱柜外形
2）橱柜尺寸
3）橱柜油漆
4）橱柜的功能--储物
这就是一个橱柜的图纸，在面向对象中，我们就叫类，
根据这个图纸生产出的橱柜，就是它的一个对象，或者实例。
这就是面向对象。
在程序中：
- 类class
类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合。
- 对象instance、object
对象是类的具体，是一个实体
*属性，它是对象状态的抽象
*操作，它是对象行为的抽象
Python的类的定义
class ClassName:
语句块
# 1.必须使用class关键字
# 2.类名必须是用大驼峰命名
# 3.类定义完成后，就产生了一个类对象，绑定到了ClassName上示例1
class MyClass:
"""A example class"""
x = 'abc' #类属性
def foo(self): #类属性，也是方法
print(self.x)
return 'My Class'
# 类本身也是对象，就叫类对象吧，所以它也有自己的属性和方法
print(MyClass.x)
print(MyClass.foo)
print(MyClass.__doc__)
print(MyClass.__name__)
print(MyClass.__dict__) # 通过__dict__() 可以查看类拥有的属性和方法，这个对象也有，作用与类的类似
''''
输出结果
abc
A example class
MyClass
{'__module__': '__main__', '__doc__': 'A example class', 'x': 'abc', 'foo': , '__dict__': , '__weakref__': }
''' 示例2
class Person:
COUNTRY="中国"
def __init__(self, name, age, address):
# 使用双下划线命名代表私有化，不能直接在外部访问
# 当然Python中的私有化也只是假私有,这个下边将 self.__name = name
self.__age = age
self.address = address
def getName(self):
return self.__name
def setName(self,name):
self.__name = name
def getAge(self):
return self.__age
def setAge(self, age):
self.__age = age
def getAddress(self):
return self.address
def setAddress(self,address):
self.address = address
if __name__ == '__main__':
p = Person("张三", 22, "北京") # 实例化一个变量,先隐藏调用__new__()创建实例，然后调用__init()__初始化
name = p.getName() # 因为是私有变量，所以不能直接通过p.__name获取，需要调用提供的获取方法
age = p.getAge()
address = p.address # p.address没有私有化，所以可以直接使用
print(f"姓名:{name},年龄:{age},地址:{address}")
# 前面说python中的私有是假私有，怎么回事呢？我们通过p.__dict__ 看下
print(p.__dict__)
# 输出结果 {'_Person__name': '张三', '_Person__age': 22, 'address': '北京'}
# 原来python的私有化，就是改了名,那么我们调用下 print(p._Person__name) # 虽然可以这样调用，但在正式环境，还是慎用
# 类有__dict__,对象也有，而且我们通过对象同样可以访问类中的属性， print(p.COUNTRY)
# 那么对象的属性查找顺序是怎样的呢？
#实例使用.访问属性，会先找自己的dict，找不到会找上层类的dict #如果直接使用__dict__[变量名] 访问变量，将不会按照上面顺序查找了,如下 print(p.__dict__['address'])2 封装
组装：将数据和操作组装到一起。
隐藏数据：对外只暴露一些接口，通过接口访问对象。
如上面的示例，就是封装的体现
3 装饰一个类
示例
def setnameproperty(name):
def _setnameproperty(cls):
cls.NAME = name
return cls #必须返回类
return _setnameproperty
@setnameproperty('My Class')
class MyClass:
pass
print(MyClass.NAME)
print(MyClass.__dict__)类方法和静态方法
def setnameproperty(name):
def _setnameproperty(cls):
cls.NAME = name
return cls #返回类
return _setnameproperty
@setnameproperty('My Class')
class MyClass:
x = 123
def __init__(self):
print('init')
def foo(self):
return 'foo'
@staticmethod # 使用这个装饰器修饰的方法就是静态方法
def bar():
print('bar')
@classmethod # 使用这个装饰器修饰的方法就是类方法
def clsmtd(cls):
print('{}的x=={}'.format(cls.__name__, cls.x))
# print(MyClass.NAME)
# print(MyClass.__dict__)
MyClass.bar()
print(MyClass.__dict__)
MyClass.clsmtd()
a = MyClass()
a.clsmtd() #隐式为a.__class__.clsmtd() 类方法等价于java中的静态方法在java中静态方法就是类方法，Python则不同，python中的静态方法指的的则是一般函数，为该类管辖，但从实质意义上无法归于该类，Python中有单独的类方法。
可以理解为挂名在该类的的方法，较少使用。
类方法，不需要实例化，只要类定义存在，即可调用
ClassName.clsmtd()
ClassName().clsmtd()
访问控制
- 公有属性(public)
- 私有属性(Private)：
两个下划线代表私有，但并非真的私有，实质是Python解释器将其改变为_类名__变量名
- 保护的(Protect)
一个下划线是一种约定，称为保护变量。
5 对象的销毁
类中可以定义__del__方法，称为析构函数(方法)
作用：销毁类的实例的时候调用，以释放占用的资源
由于Python实现了垃圾回收机制，这个方法不能确定合适执行，必要时使用del语句删除实例，来手动调用这个方法。
6 方法的重载
在其他面向对象的高级语言中，都有重载的概念
所谓重载，就是同一个方法名，但是参数数量、类型不一样，就是同一个方法的重载。
但Python只有重写，没有重载！
Python中，方法(函数)定义中，形参非常灵活，不需要指定类型，就算指定了类型也只是一个说明而非约束。
参数个数也不固定(可变参数)。一个函数的定义可以实现很多种不同形式的实参调用。
所以Python不需要方法的重载。
7 类的继承
Python3所有的类父类都是Object
查看继承的特殊属性和方法：
| 属性 | 描述 |
|---|---|
| \_base_ | 类的基类 |
| \_bases_ | 类的基类元组 |
| \_mro_ | 显示方法查找顺序，基类的元组 |
| \__subclasses__() | 类的子类列表 |
Python支持多继承
Python使用MRO(methon resoultion order)解决基类搜索顺序
MRO有三个搜索算法
1）经典算法，从左到右，深度优先策略
2）新式类算法，经典算法的升级，重复的只保留最后一个
3）C3算法，在类被创建出来的时候，就计算出一个MRO有序列表。2.3版本后支持，
Python3唯一支持的算法。
示例
# 父类或者超类
# 在Python3中object是所有类的父类，默认定义的类都继承这个object类
# 但在定义类时，还是直接写明
class Person(object):
def __init__(self, name, age):
self.__name = name
self.__age = age
def eat(self):
print("吃饭")
def sleep(self):
print("睡觉")
# 子类继承父亲类
class Student(Person):
def __init__(self, name, age, school):
super().__init__(name,age) # 使用super关键字调用父类的init方法
self.__school = school
def eat(self): # 重写父类方法
print("在学校食堂吃饭")
def learn(self):
print("上课学习")
stu = Student("张三",18,"北京大学")
stu.eat()
stu.sleep() # 虽然子类中没有实现sleep()方法，但继承了父类，所以可以直接调用
stu.learn()
"""
在学校食堂吃饭
睡觉
上课学习
"""8 多态
多态：不同的子类对调用相同的父类方法，产生不同的执行结果
多态 可以 增加代码的灵活度
以 继承和重写父类方法为前提示例1
class Person(object):
def __init__(self, name):
self.name = name
def working(self,):
pass
class Teacher(Person):
def __init__(self, name):
super().__init__(name)
def wrking(self):
print("I am a teacher")
class Student(Person):
def __init__(self, name):
super().__init__(name)
def wrking(self):
print("I am a Student")
# 1. 创建一一个Teacher对象和一个Student对象
teacher = Teacher()
student = Student()
teacher.working()
student.working()示例2：
class Animal(object):
def food(self):
pass
class Dog(Animal):
def food(self):
return "骨头"
class Cat(Animal):
def food(self):
return "鱼"
class Person(object):
def feedAnimal(self,animalObject):
food = animalObject.food()
print(f"喂{food}")
if __name__ == '__main__':
# 多态的体现
p = Person()
dog = Dog()
cat = Cat()
p.feedAnimal(dog)
p.feedAnimal(cat)封装、继承、多态是面向对象的三要素