1.面向对象
面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性，所以可以先了解下什么是面向过程编程：
面向过程编程的核心是过程，就是分析出实现需求所需要的步骤，通过函数一步一步实现这些步骤，接着依次调用即可，再简单理解就是程序
从上到下一步步执行,从头到尾的解决问题；
而面向对象编程是把构成事物的整个需求按照特点、功能划分，将这些存在共性的部分封装成对象，创建对象的目的不是为了完成某一个步骤，
而是为了描述某个事物在整个解决问题的步骤中的行为。
eg： 小明用美的洗衣机洗脏衣服，流程是怎样的？
面向过程的解决方法：
1、执行加洗衣液方法；
2、执行开启洗衣机方法；
3、执行加水方法；
4、执行洗衣服方法；
5、执行甩干方法；
6、取出衣服；
以上就是将解决这个问题的过程拆成一个个方法，通过按顺序执行方法来解决问题。
面向对象的解决方法：
1、可以先归纳出两个对象：“美的洗衣机”对象和“小明”对象
2、针对对象“美的洗衣机”加入一些它的方法：“自动注水方法”“洗衣方法”、“烘干方法”
3、针对对象“小明”加入他的方法：“加洗衣液方法”、“开启洗衣机方法”、“取出衣服方法”
4、然后执行，使用对象.动作 的方式，执行各步骤
小明.加洗衣液
小明.开启洗衣机
美的洗衣机.自动注水
美的洗衣机.洗衣服
美的洗衣机.烘干
小明.取出衣服
解决同一个问题 ，面向对象编程就是先抽象出对象，然后用对象执行方法的方式解决问题。
2.类
如果想通过面向对象编程，首先需要创建一个类(class)，才能实例化（或叫具象化）对象；
（洗衣例子中要先有人这个类，才能有“小明”对象、先有洗衣机类，才能有“美的洗衣机”这个对象）
类可以理解成一个模板，通过它可以创建出无数个具体实例（对象）；
使用类的关键字class，来声明类，首字母大写，多个单词时每个单词首字母要大写（驼峰命名法）；
eg： class MyName(object):
(object)可以不写，object是python中的一个通用对象，添加它后可以使用更多的内置功能；
class Test(object):
name = 'test' # 定义一个类属性
def run(self):
print(f'{self.name}在跑步!')
xiaoming = Test() # 实例化一个对象xiaoming
print(xiaoming.name) # 对象xiaoming可以调用类属性
xiaoming.run() # 对象xiaoming可以调用类方法
'''
test
test在跑步!
'''类的参数self
可以看到类的方法中默认第一个参数是self，且是必填的；（python中的self关键字只用于类的方法中）；
self也是一个对象，它代表实例化变量(例子中的xiaoming)本身（xiaoming可以调用name属性和run方法，都是self帮助找到的）
class Person(object):
name = None # 类属性（也叫类实例化属性）
age = None
def run(self):
print('可以直接使用self调用类属性')
print('打印属性:'+str(self.name))
a = 'new' # 类方法中定义的变量无self时，属于方法中的局部变量
print('打印局部变量:'+a)
def work(self):
print('利用self可直接调用类中其它类函数')
self.run()
def jump():
print('不添加self参数，就不属于类函数，就不可以被实例化的对象调用')
# 实例化一个对象xiaoming
xiaoming = Person()
# 可以直接调用类属性（类实例化属性）
print(xiaoming.name) # None
# 也可为类属性（类实例化属性）重新赋值
xiaoming.name = 'xiaoming'
# 调用类方法, 调用时无需传递self参数值
xiaoming.work()
'''
利用self调用类中其它函数
可以直接使用self调用类属性
打印属性:xiaoming （此时类属性值已被实例化对象修改）
打印局部变量:new
'''
# print(xiaoming.a) # AttributeError: 'Person' object has no attribute 'a' 方法中的局部变量不可被实例化对象调用
# 实例化另一个对象xiaohong
xiaohong = Person()
print(xiaohong.name) # None # 对象xiaohong并不会使用到对象xiaoming修改的类属性（类实例化属性）值;对象修改的类属性（类实例化属性），只能作用于对象本身
xiaohong.jump() # 非类函数无法被对象调用，直接报错
'''
Traceback (most recent call last):
File "D:\python_exercise\test_calss.py", line 44, in <module>
xiaohong.jump()
TypeError: Person.jump() takes 0 positional arguments but 1 was given
'''
# 可以看到报错信息是函数无参数值，却被传递了一个，说明对象在调用方法时，自动传递了self参数，所以直接报错了
3.类的构造函数
类中的一种默认函数，用来将类实例化的同时，将参数传入类中；（类似于函数执行时，可以传一些参数）
def __init__(self, a, b):
self.a = a # 类实例化对象的属性
self.b = b
此时self.a和self.b就可以在类的各个类函数中使用了；
class Person(object):
def __init__(self, name):
self.name = name # self.声明的变量是类实例属性
def run(self):
print(f"{self.name}在跑")
test = Person('x')
test.run() # x在跑
'''
此时已经见过了类中可定义的多种变量
类下直接定义的变量，属于类属性、又属于类实例化对象属性 （可被实例化后的对象直接引用）
构造函数中self.开头定义的属性，属于类实例化对象属性，不属于类属性（可被实例化后的对象直接引用）（工作中多用，且多在构造函数中提前定义好）
类函数中a=''定义的变量，属于局部变量，既不属于类实例化对象属性，也不属于类属性（不可被实例化后的对象直接引用）
'''
4.对象的生命周期
一个对象从出生到消亡的过程；
实例化对象后，会调用内置函数__init__, 此时对象生命开始，该对象会被内存分配一个内存块；
对象不再使用类中的方法属性时、或整个脚本结束执行时，对象会自动调用内置函数__del__通知内存管家，从内存中释放占用的内存块，对象生命结束；
无论是数字、字符串、列表、元组等对象，生命周期皆是如此；
python中会让对象自动调用__del__的操作，无需在程序中书写；
__def__所有这种书写形式的方法，都是类的内置函数，定义类时书写object（class Name(object)），就可以调用这些内置函数了。
5.私有函数和私有变量
私有：独有的、不公开；
无法被实例化后的对象调用的类中的函数和变量，就是私有函数、私有变量；
类的内部可以在类函数中调用私有函数和私有变量；
使用场景：某一方法只希望内部业务调用使用，不希望被使用者调用；
定义方法：在类函数、类变量前添加__ (两个下划线)；
class Cat(object):
def __init__(self, name):
self.name = name
self.__sex = 'boy' # 私有类实例化属性
def run(self):
# 类函数可以调用私有函数
self.__run(self.__sex)
# 私有函数
def __run(self, sex):
# 私有函数可以使用类实例化属性
print(f'{self.name}，是个{sex}，它在跑!')
cat = Cat('ll')
cat.run() # ll，是个boy，它在跑!
# 对象不可调用私有函数,直接报错
# cat.__run() # AttributeError: 'Cat' object has no attribute '__run'
# 也有可调用的方法，但既然创建了私有函数、私有变量，建议遵守使用规则
print(dir(cat)) # 打印所有类的内置函数，就可以看到私有函数的调用名了
'''
['_Cat__run', '_Cat__sex', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__',
'__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'run']
'''
cat._Cat__run('girl') # ll，是个girl，它在跑!
print(cat._Cat__sex) # boy
6.python中封装
python中封装的概念：
我们在类中把某些属性和方法隐藏起来、定义为私有，只能在类的内部使用，外部无法访问，或者留下少量的接口（函数）供外部访问，就是封装的概念；
这样做的目的是为了保护隐私、明确区分内外。
7.类的装饰器
装饰器也是一种函数；
它可以接收函数作为参数；且可以返回一个函数；
接收一个函数，内部对其进行处理，然后返回一个新函数，动态的增强函数功能；
# 简单梳理下装饰器的大概由来
# 有一个业务函数print_test()
def print_test(info):
print('业务函数'+info)
'''
此时想在执行业务函数前后增加日志输出,
且有多个类似的业务函数需要完成同样的操作，
可以编写另一个公用函数，以业务函数为参数，业务函数前后完成相应日志输出
'''
def add_info(func, info):
print('开始的日志')
func(info)
print('结束的日志')
# 执行add_info
add_info(print_test, 'test')
'''
开始的日志
业务函数test
结束的日志
'''
# 但是这样改变了原有的print_test(info)完成业务操作的写法，可以借助装饰器写法优化下
def add_info_new(func):
def wrapper(*args, **kwargs):
print('打印开始的日志')
func(*args, **kwargs)
print('打印结束的日志')
return wrapper
print_test = add_info_new(print_test)
print_test('test')
'''
打印开始的日志
业务函数test
打印结束的日志
'''
# python中可以借助@语法糖，优化上面print_test = add_info_new(print_test)的写法
@add_info_new
def print_test_final(info):
print('借助语法糖的业务函数'+info)
print_test_final('test')
'''
打印开始的日志
借助语法糖的业务函数test
打印结束的日志
'''
# 装饰器调用时，也可以传递参数，对业务处理进行再次的判断
def add_print_args(handle):
def decorator(func):
def wrapper(*args, **kwargs):
print('依旧执行前打印日志')
func(*args, **kwargs)
print('依旧执行后打印日志')
if handle:
print('额外处理')
return wrapper
return decorator
@add_print_args(handle=True)
def print_test_args(info):
print('打印一下'+info)
print_test_args('test')
'''
依旧执行前打印日志
打印一下test
依旧执行后打印日志
额外处理
'''
'''
使用装饰器后，被装饰函数的元信息会被修改，例如__name__, doc等
'''
print(print_test_args.__name__)
# wrapper （这里也很好理解，已经被返回成新的装饰函数了）
'''
若想保存元信息不变，
可以使用wrap库，from functools import wraps
wraps也是一个装饰器，它是把原函数元信息拷贝到了装饰器函数中
'''
from functools import wraps
def add_print_wrap(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('执行前打印')
func(*args, **kwargs)
print('执行后打印')
return wrapper
@add_print_wrap
def print_test_wrap(info):
print('业务函数'+info)
print_test_wrap('test')
print(print_test_wrap.__name__)
'''
执行前打印
业务函数test
执行后打印
print_test_wrap
'''
'''
类装饰器
通过内置函数__call__处理额外操作
'''
class AddPrint(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print('开始的打印foo')
self.func(*args, **kwargs)
print('结束的打印foo')
@AddPrint
def print_test_foo(info):
print('业务函数'+info)
print_test_foo('test')
'''
开始的打印foo
业务函数test
结束的打印foo
'''
'''
类装饰器也可以通过传参做额外操作
'''
class Foo(object):
def __init__(self, handle):
self.handle = handle
def __call__(self, func):
def wrapper(*args, **kwargs):
print('执行前操作')
func(*args, **kwargs)
print('执行后操作')
if self.handle:
print('额外操作')
return wrapper
@Foo(handle=True)
def print_test5(info):
print('业务操作'+info)
print_test5('test')
'''
执行前操作
业务操作test
执行后操作
额外操作
'''
8.几种内置的常见装饰器
@classmethod
将类的函数定义为可以不经过实例化而直接被调用；此时可以不实例化，直接调用该方法；
class Foo(object):
def __init__(self, a):
self.a = a
def run(self):
print('run')
@classmethod
def jump(cls):
print('jump')
# 此时self被替换成cls，代表类本身
# Foo.run()
'''
Traceback (most recent call last):
File "D:\python_exercise\test5.py", line 21, in <module>
Foo.run()
TypeError: Foo.run() missing 1 required positional argument: 'self'
因为正常我们实例化的时候，python会自动帮我们将self参数传递进去
此时没有实例化，所以报错没有传self参数
'''
Foo.jump() # jump
# 类函数就可以不用实例化直接调用了cls函数不可引用self函数
class Foo(object):
def __init__(self, a):
self.a = a
def run(self):
print('run')
@classmethod
def jump(cls):
print('jump')
cls.run()
Foo.jump()
'''
TypeError: Foo.run() missing 1 required positional argument: 'self'
'''self函数可以引用cls函数
class Foo(object):
def __init__(self, a):
self.a = a
def run(self):
print('run')
self.jump()
@classmethod
def jump(cls):
print('jump')
foo = Foo('test')
foo.run()
foo.jump() # 实例化对象也可使用cls函数
'''
run
jump
jump
'''@staticmethod
将类函数定义为可以不经过实例化而直接被调用，且该函数不需要传递self或cls，且无法在该函数内调用其它类函数或类变量；
class Foo(object):
def __init__(self):
pass
def run(self):
print('run')
self.jump()
@staticmethod
def jump():
print('jump')
Foo.jump() # jump
foo = Foo()
foo.jump() # jump (也可以通过对象调用)
foo.run() # static函数也可以被其它类函数调用
'''
run
jump
'''@property
将类函数的调用免去括弧，类似于调用属性；
class Foo(object):
@property
def run(self):
print('run')
foo = Foo()
foo.run # run同样使用这种调用方法，需要传参时，有自己的写法；
class Foo(object):
@property
def run(self):
print('run')
@run.setter
def run(self, info):
print(info)
foo = Foo()
foo.run = 'test info' # test info
9.类的继承
通过继承，子类可以拥有父类所有的属性和方法；
父类不具备子类自有的属性和方法；
定义方法 class Child(Parent): Child类继承Parent类；
class Parent(object):
def __init__(self, name, age):
self.name = name
self.age = age
def walk(self):
print(f'{self.name}在行走')
class Child(Parent):
def run(self):
self.walk() # 子类可以调用父类的方法
print(f"{self.name}在跑步") # 子类可以直接调用父类的属性
child = Child('ll', 13) # 继承父类后，父类的初始化参数子类也要传递
child.walk() # ll在行走 (子类实例化对象可以调用父类的方法)
child.run()
'''
ll在行走
ll在跑步
'''
10.类的多态
子类继承父类后，对于父类中的同一功能可以表现出多状态变化（多种执行方式、结果等），且是通过子类对父类方法的重写实现的；
class Parent(object):
def __init__(self, name):
self.name = name
def walk(self):
print('父类在行走')
class Child(Parent):
def walk(self):
print('子类在行走')
child = Child('儿子')
child.walk() # 子类在行走
'''
为什么要继承
为了使用已经写好的类中的方法
为什么要多态
为了保留子类中和父类名称相同的函数的功能
'''
11.python中的super函数
在子类重新书写父类方法时，此时想既保留父类方法的逻辑、同时增加新逻辑，就可以借助super函数；
用法：super(当前类，self(类的实例)).父类的方法()；python3.0时代，super()中两个参数可以省略；
class Parent(object):
def __init__(self, name):
self.name = name
print('父类构造函数'+self.name)
class Child(Parent):
def __init__(self, name, age):
super(Child, self).__init__(name)
self.age = age
print('子类新的构造函数'+str(self.age))
child = Child('xiaoming', 23)
'''
父类构造函数xiaoming
子类新的构造函数23
'''
# 例子中子类对于父类中的构造函数参数进行了扩充，在工作中很常用
12.类的多重继承
子类可以继承多个父类；
class Child(Parent, Parent2, Parent3...):
class Father(object):
def run(self):
print('父亲跑')
def walk(self):
print('父亲走')
class Mother(object):
def run(self):
print('母亲跑')
def sing(self):
print('母亲唱')
class Child(Father, Mother):
pass
child = Child()
child.sing() # 母亲唱
child.run() # 父亲跑 (多个父类有重名方法时，优先继承写在第一位的类)
print(Child.__mro__) # (<class '__main__.Child'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)
'''
__mro__ 方法可以打印类的继承链
'''
13.类的几个高级函数
__str__ 返回类的描述信息；
class Test(object):
pass
test = Test()
print(test) # <__main__.Test object at 0x00000298AC9264D0>
class Test2(object):
def __str__(self):
return 'this is a test class'
test2 = Test2()
print(test2) # this is a test class__getattr__ 当调用的属性或方法不存在时，会返回该方法定义的信息；
class Test(object):
pass
test = Test()
print(test.a) # 调用类的属性不存在时，会直接报错
'''
Traceback (most recent call last):
File "D:\python_exercise\test7.py", line 14, in <module>
print(test.a)
AttributeError: 'Test' object has no attribute 'a'
'''
class Test2(object):
def __getattr__(self, item):
return f'{item}不存在'
test2 = Test2()
print(test2.a) # a不存在__setattr__ 拦截当前类中不存在的属性和值，并做处理；
class Test(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __setattr__(self, key, value):
print(key, value)
# 打印所有的属性字典
print(self.__dict__)
self.__dict__[key] = value
print(self.__dict__)
test = Test('xiao', 32)
test.sex = 'boy'
print(test.sex)
'''
name xiao
{}
{'name': 'xiao'}
age 32
{'name': 'xiao'}
{'name': 'xiao', 'age': 32}
sex boy
{'name': 'xiao', 'age': 32}
{'name': 'xiao', 'age': 32, 'sex': 'boy'}
boy
'''
# 可以看到每一次生成新的属性，都会调用__setattr__方法，无论是在构造函数，还是在实例对象test.sex = 'boy'
test.name = 'new_xiaoming'
# 也可修改原属性的值
'''
{'name': 'new_xiaoming', 'age': 32, 'sex': 'boy'}
'''__call__ 将实例化对象直接变成函数使用；
class Test(object):
def __call__(self, *args, **kwargs):
print(f'call 函数开始: {args[0]}')
test = Test()
test('test') # call 函数开始: test# eg: 编写一个可以通过 对象.a.b.c() 执行的类
class Test(object):
def __init__(self, args=''):
print('------')
self.args = args
def __getattr__(self, item):
print('开始的item:'+item)
print('self.args:'+self.args)
if self.args:
item = f'{self.args}.{item}'
print('后来的item:'+item)
return Test(item)
def __call__(self, *args, **kwargs):
print('ttttt')
test = Test()
test.a.b.c() # ttttt
'''
------
开始的item:a
self.args:
后来的item:a
------
开始的item:b
self.args:a
后来的item:a.b
------
开始的item:c
self.args:a.b
后来的item:a.b.c
------
ttttt
'''
总结
