1 装饰器

装饰器（decorators）是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。

装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。

语法使用 @decorator_name 来应用在函数或方法上。

Python 还提供了一些内置的装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。

装饰器的应用场景：

• 日志记录: 装饰器可用于记录函数的调用信息、参数和返回值。
• 性能分析: 可以使用装饰器来测量函数的执行时间。
• 权限控制: 装饰器可用于限制对某些函数的访问权限。
• 缓存: 装饰器可用于实现函数结果的缓存，以提高性能。

1.1 示例一：在函数前后添加输出

# 定义一个以函数为参数的函数
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()# 传入函数
        print("Something is happening after the function is called.")
    return wrapper

# 使用@+函数名，即可使用装饰器
@my_decorator
def say_hello():
    print("Hello!")

say_hello()

运行结果：

1.2 示例二：带参数的装饰器

def do_twice(func):
    def wrapper(*args, **kwargs):
        func(*args, **kwargs)
        func(*args, **kwargs)
    return wrapper

@do_twice
def greet(name):
    print(f"Hello {name}")

greet("World")

运行结果：

1.3 示例三：类装饰器

class DecoratorClass:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print('Decorating', self.func.__name__)
        return self.func(*args, **kwargs)

@DecoratorClass
def add(a, b):
    return a + b

print(add(1, 2))

运行结果：

1.4 注意：如果有有多个装饰器，则从近到远执行

def decorator1(func):
    def wrapper():
        print("1")
        func()
        print("2")
    return wrapper

def decorator2(func):
    def wrapper():
        print("3")
        func()
        print("4")
    return wrapper

@decorator1
@decorator2
def some_function():
    print("center")

some_function()

运行结果：

2 异常检测

2.1 异常处理

2.2 抛出异常

使用 raise 语句抛出一个指定的异常。

raise语法格式如下：

raise [Exception [, args [, traceback]]]

示例 1：

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

示例 2：
如果只想知道这是否抛出了一个异常，并不想去处理它，那么使用raise 语句就可以再次把它抛出。

try:
    raise NameError('HiThere')  # 模拟一个异常。
except NameError:
    print('An exception flew by!')
    raise

运行结果：

2.3 用户自定义异常

可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如，定义一个能将MyError 实例转换为字符串时应该返回的内容，返回的字符串格式为 MyError: ，这使得在打印异常时能够清晰地看到异常消息：

class MyError(Exception):
    def __init__(self, message):
        self.message = message

    def __str__(self):
        return f"MyError: {self.message}"

def divide(a, b):
    if b == 0:
        raise MyError("Cannot divide by zero")
    return a / b

try:
    result = divide(10, 0)
except MyError as e:
    print(e)
else:
    print(f"Result: {result}")

运行结果：

3 标准库概览

• os 模块： 提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
• sys 模块： 提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和stderr 相关的信息。
• time 模块： 提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等。
• datetime 模块： 提供了更高级的日期和时间处理函数，例如处理时区、计算时间差、计算日期差等。
• random 模块： 提供了生成随机数的函数，例如生成随机整数、浮点数、序列等。
• math 模块： 提供了数学函数，例如三角函数、对数函数、指数函数、常数等。
• re 模块： 提供了正则表达式处理函数，可以用于文本搜索、替换、分割等。
• json 模块： 提供了 JSON 编码和解码函数，可以将 Python 对象转换为 JSON 格式，并从 JSON格式中解析出 Python 对象。
• urllib 模块： 提供了访问网页和处理 URL 的功能，包括下载文件、发送 POST 请求、处理 cookies 等。

下面介绍几个常用的：

3.1 文件通配符

import glob
print("1:")
print(glob.glob('*.ipynb'))
print("2:")
print(glob.glob('d*.ipynb'))
print("3:")
print(glob.glob('e*o.ipynb'))
print("4:")
print(glob.glob('*o.ipynb'))

运行结果：

3.2 数学

常量

• math.pi: 圆周率 π (约等于 3.141592653589793)
• math.e: 自然对数的底 e (约等于 2.718281828459045)
• math.inf: 正无穷大
• math.nan: 非数字（Not a Number）

三角函数

• math.sin(x): 计算 x 的正弦值
• math.cos(x): 计算 x 的余弦值
• math.tan(x): 计算 x 的正切值
• math.asin(x): 计算 x 的反正弦值
• math.acos(x): 计算 x 的反余弦值
• math.atan(x): 计算 x 的反正切值
• math.atan2(y, x): 计算 y/x 的反正切值

双曲函数

• math.sinh(x): 计算 x 的双曲正弦值
• math.cosh(x): 计算 x 的双曲余弦值
• math.tanh(x): 计算 x 的双曲正切值
• math.asinh(x): 计算 x 的反双曲正弦值
• math.acosh(x): 计算 x 的反双曲余弦值
• math.atanh(x): 计算 x 的反双曲正切值

指数和对数函数

• math.exp(x): 计算 e 的 x 次方
• math.log(x[, base]): 计算 x 的自然对数（默认以 e 为底），也可以指定其他底
• math.log10(x): 计算 x 的以 10 为底的对数
• math.log2(x): 计算 x 的以 2 为底的对数
• math.log1p(x): 计算 1 + x 的自然对数，适用于 x 接近于 0 的情况

幂和根函数

• math.pow(x, y): 计算 x 的 y 次方
• math.sqrt(x): 计算 x 的平方根

取整函数

• math.ceil(x): 向上取整
• math.floor(x): 向下取整
• math.trunc(x): 去掉小数部分，只保留整数部分

其他函数

• math.fabs(x): 计算 x 的绝对值
• math.factorial(x): 计算 x 的阶乘
• math.gcd(x, y): 计算 x 和 y 的最大公约数
• math.lcm(x, y): 计算 x 和 y 的最小公倍数（Python 3.9+）
• math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0): 判断 a 和 b 是否接近
• math.isfinite(x): 判断 x 是否为有限数
• math.isinf(x): 判断 x 是否为无穷大
• math.isnan(x): 判断 x 是否为 NaN
• math.modf(x): 将 x 分解为小数部分和整数部分
• math.frexp(x): 将 x 分解为 (m, e)，使得 x == m * 2^e
• math.ldexp(x, i): 计算 x * 2^i

3.3 日期和时间

import datetime

#获取当前日期和时间
current_datetime = datetime.datetime.now()
print(current_datetime)

# 获取当前日期
current_date = datetime.date.today()
print(current_date)

# 格式化日期
formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_datetime)  # 输出：2023-07-17 15:30:45

运行结果：

3.4 数据压缩

以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

import zlib
s = b'witch which has which witches wrist watch'
print("s.len:",len(s))

# 压缩
t = zlib.compress(s)
print("st.len:",len(t))

# 解压缩
a=zlib.decompress(t)
print('a.len',len(a))

运行结果：

3.5 性能度量

Python 提供了一个度量工具，不过相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具，这里只介绍timeit

from timeit import Timer
t1=Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
print(t1)
t2=Timer('a,b = b,a', 'a=1; b=2').timeit()
print(t2)

运行结果：

以上我们看到的只是 Python3 标准库中的一部分模块，还有很多其他模块可以在官方文档中查看完整的标准库文档：https://docs.python.org/zh-cn/3/library/index.html

4 面向对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法： 类中定义的函数。
• 类变量： 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员： 类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写： 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量： 定义在方法中的变量，只作用于当前实例的类。
• 实例变量： 在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承： 即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化： 创建一个类的实例，类的具体对象。
• 对象： 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

4.1 类对象

类对象支持两种操作：属性引用、实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

运行结果：

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用， init() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。例如:

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

运行结果：

4.2 self 代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self，在 Python中，self 是一个惯用的名称，用于表示类的实例（对象）自身：

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

运行结果：

4.3 类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例：

class people:
    #定义基本属性
    name = ''
    age = 0
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

运行结果：

4.4 单继承

派生类语法如下：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

class people:
    #定义基本属性
    name = ''
    age = 0
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

运行结果：

4.5 多继承

# 第一个基类
class people:
    #定义基本属性
    name = ''
    age = 0
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 派生类
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
# 第二个基类
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法
print('people value:',test.age)
print('student value:',test.grade)

运行结果：

4.6 类属性与方法

4.6.1 类的私有属性

__private_attrs： 两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

运行结果：

4.6.2 类的私有方法

__private_method： 两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。在类内部的方法中使用时 self.__private_methods。

class Site:
    def __init__(self, name, url):
        self.name = name       # 公开
        self.__url = url   # 私有
 
    def who(self):# 公开
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

运行结果：

4.6.3 类的专有方法

• __init__ : 构造函数，在生成对象时调用

• __del__ : 析构函数，释放对象时使用

• __repr__ : 打印，转换

• __setitem__ : 按照索引赋值

• __getitem__: 按照索引获取值

• __len__: 获得长度

• __cmp__: 比较运算

• __call__: 函数调用

• __add__: 加运算

• __sub__: 减运算

• __mul__: 乘运算

• __truediv__: 除运算

• __mod__: 求余运算

• __pow__: 乘方