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_exercisetest_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_exercisetest5.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_exercisetest7.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
'''
总结
本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:python基础-面向对象 - Python技术站