目录
1.封装(Enclosure)
2.多态(Polymorphic)
3.魔术方法(Magic Methods)
4.重写
4.1函数重写
4.2运算符重载
5.super()函数
6.迭代器
7.生成器
8.处理异常
9.函数式编程
9.1函数作为参数
9.1.1lambda表达式
9.1.2内置高阶函数
9.2函数作为返回值
9.2.1闭包
9.2.2装饰器
1.封装(Enclosure)
在class外部不能访问,也不能在子类中访问
作用:
(1)指隐藏类的实现细节
(2)一定程度上,保证class内部数据安全
私有属性:__变量名
私有方法:__方法名()
运行结果:
class Girl():def __init__(self, name, gender, age):self.name = nameself.gender = genderself.__age = agedef __privateFun(self):print("私有方法")girl1 = Girl("柳如烟", "女", 18)
print(girl1.name)# girl1.privateFun()#不可访问
# print(girl1.age)#不可访问class Child(Girl):def __init__(self, name, gender, age):Girl.__init__(self, name, gender, age)child1 = Child("小绿","女",12)
# print(child1.age)#不可访问
# child1.privateFun()#不可访问
2.多态(Polymorphic)
在有继承/派生关系的类中,调用基类对象的方法,实际能调用子类的覆盖方法的现象叫多态。
class Animal():def __init__(self, name):self.name = name@classmethoddef action(cls):print("吃")class Dog(Animal):def __init__(self, name):Animal.__init__(self, name)@classmethoddef action(cls):print("跑")class Bird(Animal):def __init__(self, name):Animal.__init__(self, name)@classmethoddef action(cls):print("吃")dog1=Dog("狗")
dog1.action()
bird1=Bird("鸟")
bird1.action()
3.魔术方法(Magic Methods)
在class内部,以双下划线开头和结尾的方法
允许自定义类的行为,以便与内置Python功能交互。
__init__(self, ...) | 初始化对象,通常用于设置对象的属性。 |
| 定义对象的字符串表示形式,可通过 |
| 定义对象的“官方”字符串表示形式,通常用于调试。可通过 |
| 定义对象的长度,可通过 |
| 定义对象的索引操作,使对象可被像列表或字典一样索引。例如, |
| 定义对象的赋值操作,使对象可像列表或字典一样赋值。例如, |
| 定义对象的删除操作,使对象可像列表或字典一样删除元素。例如, |
| 定义迭代器,使对象可迭代,可用于 |
| 定义迭代器的下一个元素,通常与 |
| 定义对象相加的行为,使对象可以使用 |
| 定义对象相减的行为,使对象可以使用 |
| 定义对象相等性的行为,使对象可以使用 |
| 定义对象小于其他对象的行为,使对象可以使用 |
| 定义对象大于其他对象的行为,使对象可以使用 |
| 是一个特殊的方法(也称为“魔法方法”),它允许一个对象像函数一样被调用。 |
4.重写
可以在子类重写父类的方法以满足使用者需求
4.1函数重写
让自定义类创建的实例像内建对象一样进行内建函数操作
def __str__(self):return "x = %d , y = %d" % (self.x, self.y)
4.2运算符重载
让自定义的类生成的对象(实例)能够使用运算符进行操作
对自定义对象将运算符赋予新的运算规则
def __add__(self, another):return self.x + another.x, self.y + another.y
方法名 | 运算符和表达式 | 说明 |
---|---|---|
__add__(self, rhs) | self + rhs | 加法 |
__sub__(self, rhs) | self - rhs | 减法 |
__mul__(self, rhs) | self * rhs | 乘法 |
__truediv__(self, rhs) | self / rhs | 除法 |
__floordiv__(self, rhs) | self // rhs | 地板除 |
__mod__(self, rhs) | self % rhs | 取模(求余) |
__pow__(self, rhs) | self ** rhs | 幂 |
5.super()函数
用于调用父类(超类)的一个方法。
super()函数解决多继承问题,不用指定父类(在有多个父类的情况下,较简便)
直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
super().调用父类中已被覆盖的方法
super(Child, obj).用子类对象调用父类已被覆盖的方法
class A():def process(self):print("A process")class B(A):def process(self):print("B process")super().process()class C(A):def process(self):print("C process")super().process()class D(B, C):def process(self):print("D process")super().process()d1=D()
d1.process()
6.迭代器
用于访问可迭代对象的工具
- iter(iterable)
iterable必须是能提供迭代器的对象
lt = [1, 2, 3]
iter1 = iter(lt)while True:try:print(iter1)except:print("迭代结束")break
- next()
获取迭代对象的下一元素
7.生成器
生成器是在程序运行时生成数据,与容器不同,它通常不会在内存中保留大量的数据,而是生成一个用一个。
以关键字:yield修饰的变量
特性: 与return相似之处:获取一个元素作为返回值传给函数 与return相异之处:将返回值传给函数后不会终止函数运行而是暂停,继续获取下一个元素,直到不能获取元素。
def myRange(stop):i = 0while i < stop:yield ii += 1for x in myRange(10):print(x)
8.处理异常
尝试捕获异常,得到异常通知,将程序由异常状态变为正常状态
try:
语句
except Except as e:
语句
.....
except:
语句
else:
语句
finally:
语句
except 子句可以有 1个或多个
except: 不给错误类型,可以匹配全部的错误类型
else 子句里的语句会在 没有错误发生时执行,当处于异常时不执行
finally 子句里的语句,无论何时都执行
9.函数式编程
函数可以赋值给,变量存储的是函数的地址
函数可作为参数传入函数
9.1函数作为参数
9.1.1lambda表达式
一种匿名函数,参数传递时语法简洁
lambda [变量列表]:表达式
element=max(Beauties2.beauty_list,key=lambda x:x.age)
print(element.name,element.charm,element.age)
9.1.2内置高阶函数
- map(函数,可迭代对象)
对可迭代对象的每个元素执行函数,
- filter(函数,可迭代对象)
根据函数筛选可迭代元素,返回新的迭代对象
- sorted(可迭代对象,key=函数,reverse=True)
返回排序后的后果,reverse默认值是:False
- max(可迭代对象,key=函数)
返回不可迭代的元素,根据函数获取可迭代对象的最大值。
- min(可迭代对象,key=函数)
返回不可迭代的元素,根据函数获取可迭代对象的最小值。
9.2函数作为返回值
9.2.1闭包
闭包:调用外部函数的变量的内嵌函数
闭包的应用
逻辑连续
装饰器打基础
特点:外部函数执行过后,栈帧不释放,等待内部函数的使用
# 闭包
def earn_monry(money):print("赚到:", money)def pay(action, price):nonlocal moneymoney -= priceprint(f"{action}花费:", price)print("剩余:", money)return paywork=earn_monry(100)
work("吃饭",15)
work("买饮料",4)
- 闭包的三个条件:
①必有内嵌函数
②内嵌函数必引用外部函数的变量
③内嵌函数必作为外部函数的返回值
9.2.2装饰器
装饰器:包装另一个函数的函数或类
作用:在不修改被装饰函数的代码,不改变被装饰函数的调用方式的情况下,改变其功能。
def 装饰器函数名(fun):
语句(包含新的函数定义)
return 新的函数对象
@装饰器函数名
def 被装饰器函数名(参数列表):
语句
- 基本装饰器
"""
装饰器:打印执行时间
被装饰器函数:统计值
"""
import timedef Decorator(func):def wrapper():start_time = time.time()result = func()end_time = time.time()print("执行时间:", end_time - start_time)return resultreturn wrapper@Decorator
def Decoratored():sum_value = 0for i in range(100000000):sum_value += 1print(sum_value)return sum_valueDecoratored()
- 带参数的装饰器
def repeat(num):def decorator(func):def wrapper(*args, **kwargs):for _ in range(num):func(*args, **kwargs)return wrapperreturn decorator@repeat(3) # 应用装饰器,重复执行下面的函数3次
def greet(name):print(f"Hello, {name}!")greet("Alice") # 调用被装饰的函数
- 装饰器链
def uppercase(func):def wrapper(*args, **kwargs):result = func(*args, **kwargs)return result.upper()return wrapperdef exclamation(func):def wrapper(*args, **kwargs):result = func(*args, **kwargs)return result + "!"return wrapper@exclamation
@uppercase
def say_hello(name):return f"Hello, {name}"greeting = say_hello("Bob")
print(greeting) # 输出 "HELLO, BOB!"
注意: 当多个装饰器装饰一个函数时,离被装饰的函数越近者越先执行。
- 类装饰器
class MyDecorator:def __init__(self, func):self.func = funcdef __call__(self, *args, **kwargs):print("Something is happening before the function is called.")result = self.func(*args, **kwargs)print("Something is happening after the function is called.")return result@MyDecorator # 应用类装饰器
def say_hello(name):print(f"Hello, {name}!")say_hello("Charlie") # 调用被装饰的函数