南昌seo锐创_高德街景地图全景在线_济南疫情最新情况_引流推广营销

目录

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, ...)	初始化对象，通常用于设置对象的属性。
__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 = 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")  # 调用被装饰的函数