Appearance
进阶语法
推导式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
Python 支持四种主要类型的推导式：
- 列表推导式（List Comprehension）
- 字典推导式（Dictionary Comprehension）
- 集合推导式（Set Comprehension）
- 生成器推导式（Generator Expression）
列表推导式（List Comprehension）
列表推导式格式为：
JS
[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]比如我们要生成一个0-9的平方的列表，我们可以这样写：
JS
squares = [x**2 for x in range(10)]
print(squares)JS
# 生成一个包含偶数平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares) # 输出：[0, 4, 16, 36, 64]字典推导式（Dictionary Comprehension）
字典推导式允许你通过指定 key 和 value 来创建新的字典。其基本形式为
JS
{key_expression: value_expression for item in iterable if condition}
# 创建一个字典，键是数字，值是该数字的平方
square_dict = {x: x**2 for x in range(5)}
print(square_dict) # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# 创建一个字典，只包含偶数的键值对
even_square_dict = {x: x**2 for x in range(5) if x % 2 == 0}
print(even_square_dict) # 输出：{0: 0, 2: 4, 4: 16}集合推导式 (Set Comprehension)
集合推导式类似于列表推导式，但它返回一个集合
JS
{expression for item in iterable if condition}JS
even_set = {x for x in range(10) if x % 2 == 0}
print(even_set) # 输出：{0, 2, 4, 6, 8}生成器推导式 (Generator Comprehension)
用于生成惰性求值的生成器对象，适用于处理大量数据时提高内存效率
生成器推导式类似于列表推导式，但它返回一个生成器对象，而不是列表。生成器对象是一个可迭代对象，可以在需要时生成值，而不是一次性生成所有值。生成器推导式的基本形式为：
JS
(expression for item in iterable if condition)JS
# 创建一个生成器，生成 0 到 9 的平方
gen = (x**2 for x in range(10))
print(gen) # 输出：<generator object <genexpr> at 0x7f85d25c1c50>
print(list(gen)) # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]迭代器与生成器
迭代器
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
有两个基本的方法：iter() 和 next(),适用于（字符串，列表或元组对象）
我们常见的迭代器是这样子的
JS
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
print (next(it)) # 输出迭代器的下一个元素
print (next(it))
print (next(it))
print (next(it))迭代器也可以用于循环中，例如 for 循环
python
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")
// 输出：1 2 3 4使用next()函数时，如果迭代器耗尽，则会引发 StopIteration 异常。
也就是借助于这个StopIteration 异常我们可以实现while异常的时候进行捕捉这个异常，从而实现需求
python
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:
sys.exit()生成器
在 Python 中，使用了 yield 的函数被称为生成器（generator）
yield 是一个关键字，可以定义生成器函数，生成器函数在迭代过程中逐步产生值，而不是一次性返回所有结果。
这里我们就可以理解为其实类似我们上面的next() 一步一步把我们的值给返回出来
JS
def countdown(n):
while n > 0:
yield n
n -= 1
# 创建生成器对象
generator = countdown(5)
# 通过迭代生成器获取值
print(next(generator)) # 输出: 5
print(next(generator)) # 输出: 4
print(next(generator)) # 输出: 3
# 使用 for 循环迭代生成器
for value in generator:
print(value) # 输出: 2 1比如我们使用使用 yield 实现斐波那契数列：
斐波那契数列含义：
JS
**斐波那契数列**（Fibonacci sequence）是由意大利数学家 **莱昂纳多·斐波那契**（Leonardo Fibonacci）在他的著作《算术书》（Liber Abaci）中介绍的数列。
斐波那契数列的定义非常简单：从第3项开始，每一项都是前两项的和。
### 斐波那契数列定义
斐波那契数列的前两项通常定义为：
𝐹(0)=0,𝐹(1)=1_F_(0)=0,_F_(1)=1
之后的每一项都可以通过递推公式得到：
𝐹(𝑛)=𝐹(𝑛−1)+𝐹(𝑛−2)(对于所有 𝑛≥2)_F_(_n_)=_F_(_n_−1)+_F_(_n_−2)(对于所有 _n_≥2)
### 斐波那契数列前几项
根据定义，斐波那契数列的前几项如下：
0,1,1,2,3,5,8,13,21,34,55,89,144,…0,1,1,2,3,5,8,13,21,34,55,89,144,…
可以看到，从第三项开始，每一项都是前两项的和。例如：
+ 第 2 项：𝐹(2)=𝐹(1)+𝐹(0)=1+0=1_F_(2)=_F_(1)+_F_(0)=1+0=1
+ 第 3 项：𝐹(3)=𝐹(2)+𝐹(1)=1+1=2_F_(3)=_F_(2)+_F_(1)=1+1=2
+ 第 4 项：𝐹(4)=𝐹(3)+𝐹(2)=2+1=3_F_(4)=_F_(3)+_F_(2)=2+1=3
+ 第 5 项：𝐹(5)=𝐹(4)+𝐹(3)=3+2=5_F_(5)=_F_(4)+_F_(3)=3+2=5
+ 以此类推。实现斐波那契数列（fei bo na qi）：
JS
import sys
def fbnq(n):
a,b,counter=0,1,0
while True:
if (counter > n):
return
yield a
a,b=b,a+b
counter+=1
f=fbnq(10)
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()函数
函数定义
在Python中，函数定义的基本语法如下：
python
def function_name(parameters):
# 函数体
return result☞ 函数定义由以下几部分组成：
JS
`function_name`函数的名称
`parameters`是函数的参数
`# 函数体`是函数的具体实现
`return`语句用于返回结果常见的我们写一个函数
python
def handleInit(para):
print(para,'我是参数')
# 函数体
return para
# 调用函数
handleInit('传递参数')默认参数
PYTHON
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )lambda（匿名函数）
Python 使用 lambda 来创建匿名函数
个人觉得非常不友好，后面维护起来应该非常麻烦
语法格式
JS
lambda arguments: expression
lambda是 Python 的关键字，用于定义 lambda 函数。
arguments 是参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。
expression 是一个表达式，用于计算并返回函数的结果。使用
js
f = lambda: "Hello, world!"
print(f()) # 输出: Hello, world!计算乘法
python
x = lambda a, b : a * b
print(x(5, 6))装饰器（decorators）
Python 装饰允许在不修改原有函数代码的基础上，动态地增加或修改函数的功能
本质上是一个接收函数作为输入并返回一个新的包装过后的函数的对象
JS
# 定义一个简单的装饰器
def my_decorator(func):
def wrapper():
print("函数执行前的操作")
func()
print("函数执行后的操作")
return wrapper
# 使用装饰器
@my_decorator
def say_hello():
print("Hello, World!")
# 调用函数
say_hello()
// 最后我们输出结果
函数执行前的操作
Hello, World22!
函数执行后的操作带参数的装饰器
python
def repeat(n):
def decorator(func):
def wrapper(*args, **kwargs):
for _ in range(n):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(3)
def greet(name):
print(f"Hello, {name}!")
greet("Alice")
# 最后输出
Hello, Alice!
Hello, Alice!
Hello, Alice!实例