python 面向对象
目录：
面向对象
面向对象技术
类
对象
面向对象的三大特征
绑定和非绑定（静态方法）
反射
元类
面向对象
所有的程序都是由"数据"和"功能"组成，因而编写程序的本质就是定义出一系列的数据，然后定义出一系列的功能来对数据进行操作。
理解：把对象比作容器，容器里面放该容器可以存水（数据）和存水的功能（功能），所以说对象是数据和功能的组合体。
面向对象技术
类：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实列。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例化变量使用。
局部变量：定义在方法中的变量，只用作于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。
数据成员：类变量或者实列变量，是用于处理类及其实列对象的相关数据。
方法：类中定义的函数。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称方法的重写。
实列化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
类
定义：是一个抽象的概念, 是一系列具有相同特征和行为的对象的结合体。
创建类语法:
class ClassnName:
variable = "zsh"
def __init__(self):
pass
def print_info(self):
print("What is your name?")
说明：
class：定义类的关键字
ClassName: 类名
variable：类变量（数据）
print_info：类方法（功能）
self：self代表类的实例，而非类。self定义类方法是必须的，但是再调用时不必传入相应的参数。
__init__()：
该方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。该方法再创建类时可无。
特点：
1，当实例化对象时，会自动执行init方法
2，会自动将对象作为第一个参数传入
功能: 给对象赋初始值
语法：
class Person:
def __init__(self,name,age,hobby)
self.name = name
self.age = age
self.hobby = hobby
p = Person('jason',18,'read')
类的名称书写规范：
见名知意，大驼峰命名法(首字母大写)。
类属性的写法:
和python定义变量一样。写在类中的属性是所有对象共有的。
类的三个组成部分
类的名称（字符类型）
类的父类（列表或元组）
类的名称空间（字典类型）
类内置方法
__slots__
slots是类型属性，用于优化对象内存占用。
说明：将类中不固定的属性数量，变为固定；解释器不会为该对象创建名称空间，没有__dict__，减少内存消耗。
Example：
import sys
class Person:
__slots__ = ['name'] # 告诉它我只存'name'
def __init__(self,name):
self.name = name
p = Person('jack')
print(p.name) # jack
# 查看内存占用
print(sys.getsizeof(p))
p.age = 20 # AttributeError: 'Person' object has no attribute 'age'
print(p.__dict__) # AttributeError: 'Person' object has no attribute '__dict__'
__str__
在对象被转换成字符串时，转换的结果就是这个函数的返回值。
使用场景：来定义对象的打印格式
Example：
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return 'name: %s age: %s'%(self.name,self.age)
p = Person('jack',33)
print(str(p))
# input
# name: jack age: 33
__del__
对象被删除或者程序运行结束后执行。
使用场景：当对象在使用的过程中打开不属于解释器的资源，关闭资源。如：文件等
Example：
class Dog():
def __del__(self):
print("it dead")
dog = Dog()
del dog
__call__
在使用对象时执行（即函数加括号）。
class A:
def __call__(self, *args, **kwargs):
print('call run')
print(args)
print(kwargs)
a = A()
a(1, a=100)
对象
对象定义：具体存在的事物，具备自己的特征和行为，对象就是特征和技能的结合体。
创建实例对象：
obj = ClassnName() # obj是ClassnName的对象
属性访问：
访问类中的数据
obj.variable
调用类中的函数
obj.function()
属性的访问顺序:
先访问对象，在访问类。
属性的增删改查（没用过）：
增加属性: 对象变量名称.属性名称 = 属性值
删除属性: del 对象的变量名称.属性名称
修改属性: 对象变量名称.属性名称 = 属性新值
查看属性: 访问对象的所有属性
print(obj.__dict__)
访问对象的类信息：
print(obj.__class__)
面向对象的三大特征
封装：定义类。
继承：即一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
多态：
多态指的是一类事物有多种形态，比如动物有多种形态：猫、狗、猪。
案例：
"""
多态:
不同对象执行同一种方法,产生的结果不一样
"""
class Jj:
def say_hi(self):
print('够够够')
class Yy:
def say_hi(self):
print('丫丫')
class Ee:
def say_hi(self):
print('eee')
j = Jj()
y = Yy()
e = Ee()
def func(obj):
obj.say_hi()
func(y)
func(j)
func(e)
绑定和非绑定（静态方法）
绑定
绑定给对象，当函数逻辑需要访问对象中的数据时。
绑定给类，当函数逻辑需要访问类中的数据时。
对象的绑定方法:
class Student:
school = 'hn'
def __init__(self,name):
self.name = name
def say_hi(self):
print('hi my name is %s'%self.name)
s = Student('zsh')
s.say_hi()
类的绑定方法：
class Student:
school = 'he'
print('hello world')
def __init__(self,name):
self.name = name
@classmethod # 绑定给类
def say_hi(cla):
print(cla)
s = Student('zsh')
s.say_hi()
非绑定（静态方法）
为类中某个函数加上装饰器@staticmethod后，该函数就变成了非绑定方法，也称为静态方法。
该方法不与类或对象绑定，类与对象都可以来调用它，但它就是一个普通函数而已，因而没有自动传值那么一说。
class Student:
school = 'he'
print('hello world')
def __init__(self,name):
self.name = name
@staticmethod # 非绑定
def say_hi():
print()
s = Student('zsh')
s.say_hi()
反射
元类
定义：创建类的类叫做元类。
对象、类、元类的关系：
万物皆对象，对象时通过类实例化产生的，类也是对象，类也是由另一个类实例化产生，另一个类也就是元类。
type类：默认情况下所有的类的元类都是type类。
元类的用作：用于管理所有的类。
方法：
call
new
单例
创建元类：
# -*- coding: utf-8 -*-
"""
只要继承了type,那么这个类就变成了一个元类
"""
# 定义一个元类
class MyType(type):
def __init__(self, class_name, bases, dict):
super().__init__(class_name, bases, dict)
if not class_name.istitle():
raise Exception('类名命名规则')
# 为Pig类指定元类为MyType
class Pig(metaclass=MyType):
pass
# 为 Duck指定元类为MyType
class Duck(metaclass=MyType):
pass
