Python学习笔记（1）装饰器、异常检测、标准库概览、面向对象

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 = funcdef __call__(self, *args, **kwargs):print('Decorating', self.func.__name__)return self.func(*args, **kwargs)@DecoratorClass
def add(a, b):return a + bprint(add(1, 2))

运行结果：
在这里插入图片描述

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

def decorator1(func):def wrapper():print("1")func()print("2")return wrapperdef 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 = messagedef __str__(self):return f"MyError: {self.message}"def divide(a, b):if b == 0:raise MyError("Cannot divide by zero")return a / btry: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 = 12345def 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 = realpartself.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 = nself.age = aself.__weight = wdef 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 = nself.age = aself.__weight = wdef 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 = nself.age = aself.__weight = wdef 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 = nself.topic = tdef 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 += 1self.publicCount += 1print (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()      # 报错