Python基础09

目录

1.封装(Enclosure)

2.多态(Polymorphic)

[3.魔术方法(Magic Methods)](#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 = name
        self.gender = gender
        self.__age = age

    def __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

    @classmethod
    def action(cls):
        print("吃")


class Dog(Animal):

    def __init__(self, name):
        Animal.__init__(self, name)

    @classmethod
    def action(cls):
        print("跑")


class Bird(Animal):

    def __init__(self, name):
        Animal.__init__(self, name)

    @classmethod
    def action(cls):
        print("吃")


dog1=Dog("狗")
dog1.action()
bird1=Bird("鸟")
bird1.action()

3.魔术方法(Magic Methods)

在class内部，以双下划线开头和结尾的方法

允许自定义类的行为，以便与内置Python功能交互。

|--------------------------------------|------------------------------------------------------------------------|
| init(self, ...) | 初始化对象，通常用于设置对象的属性。 |
| __str__(self) | 定义对象的字符串表示形式，可通过str(object)或print(object)调用。例如，您可以返回一个字符串，描述对象的属性。 |
| __repr__(self) | 定义对象的"官方"字符串表示形式，通常用于调试。可通过repr(object)调用。 |
| __len__(self) | 定义对象的长度，可通过len(object)调用。通常在自定义容器类中使用。 |
| __getitem__(self, key): | 定义对象的索引操作，使对象可被像列表或字典一样索引。例如，object[key]。 |
| __setitem__(self, key, value): | 定义对象的赋值操作，使对象可像列表或字典一样赋值。例如，object[key] = value。 |
| __delitem__(self, key): | 定义对象的删除操作，使对象可像列表或字典一样删除元素。例如，del object[key]。 |
| __iter__(self): | 定义迭代器，使对象可迭代，可用于for循环。 |
| __next__(self) | 定义迭代器的下一个元素，通常与__iter__一起使用。 |
| __add__(self, other) | 定义对象相加的行为，使对象可以使用+运算符相加。例如，object1 + object2。 |
| __sub__(self, other) | 定义对象相减的行为，使对象可以使用-运算符相减。 |
| __eq__(self, other): | 定义对象相等性的行为，使对象可以使用==运算符比较。 |
| __lt__(self, other): | 定义对象小于其他对象的行为，使对象可以使用<运算符比较。 |
| __gt__(self, other): | 定义对象大于其他对象的行为，使对象可以使用>运算符比较。 |
| __call__(self, other) | 是一个特殊的方法（也称为"魔法方法"），它允许一个对象像函数一样被调用。 |

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 = 0
    while i < stop:
        yield i
        i += 1


for 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 money
        money -= price
        print(f"{action}花费：", price)
        print("剩余：", money)

    return pay


work=earn_monry(100)
work("吃饭",15)
work("买饮料",4)

• 闭包的三个条件：

①必有内嵌函数

②内嵌函数必引用外部函数的变量

③内嵌函数必作为外部函数的返回值

9.2.2装饰器

装饰器：包装另一个函数的函数或类

作用：在不修改被装饰函数的代码，不改变被装饰函数的调用方式的情况下，改变其功能。

def 装饰器函数名(fun):

语句(包含新的函数定义)

return 新的函数对象

@装饰器函数名

def 被装饰器函数名(参数列表)：

语句

• 基本装饰器

"""
装饰器：打印执行时间
被装饰器函数：统计值
"""
import time

def Decorator(func):
    def wrapper():
        start_time = time.time()
        result = func()
        end_time = time.time()
        print("执行时间：", end_time - start_time)
        return result

    return wrapper

@Decorator
def Decoratored():
    sum_value = 0
    for i in range(100000000):
        sum_value += 1
    print(sum_value)
    return sum_value

Decoratored()

• 带参数的装饰器

def repeat(num):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num):
                func(*args, **kwargs)
        return wrapper
    return 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 wrapper

def 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 = func

    def __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")  # 调用被装饰的函数