?系列
目录
表示整数值，例如：42, -10。
可以指定进制类型的。
print(int('100')) # 默认就是 10进制
print(int('100', 2)) # 按照2进制读取，就是4
print(int('100', 8)) # 按照8进制读取，就是64
print(int('100', 9)) # 按照9进制读取，就是81
print(int('100', 10)) # 按照10进制读取，就是100支持常见的进制转换。包括2、8、10、16进制。
举一个例子，
# 十进制转换为2进制、8进制、10进制、16进制
num = 255
# 转换为二进制
binary = format(num, 'b') # 输出: '11111111'
print(f"二进制: {binary}")
# 转换为八进制
octal = format(num, 'o') # 输出: '377'
print(f"八进制: {octal}")
# 转换为十进制（实际上是重复了，因为num已经是十进制的）
decimal = format(num, 'd') # 输出: '255'
print(f"十进制: {decimal}")
# 转换为十六进制
hexadecimal = format(num, 'x') # 输出: 'ff'
print(f"十六进制: {hexadecimal}")再举个例子，
num = 100
print("二进制", format(num, 'b'))
print("八进制", format(num, 'o'))
print("十进制", format(num, 'd'))
print("十六进制", format(num, 'x'))
# 二进制 1100100
# 八进制 144
# 十进制 100
# 十六进制 64表示带有小数部分的数值，例如：3.14, -0.5。
num = 100
print(type(num), num) # 原始数据
num_float = float(num) # int 转 float
print(type(num_float), num_float)表示字符或文本序列，用引号（单引号或双引号）括起来，例如：“Hello, World!”。
num = 100
print(type(num), num) # 原始数据
num_str = str(num) # int 转 str
print(type(num_str), num_str)
num_int = int(num) # str 转 int
print(type(num_int), num_int)表示真（True）或假（False）的值。
又称一维数组。表示有序、可变的集合，可以包含不同类型的元素。
创建一维数组
numbers = [1, 2, 3, 4, 5]?创建二维数组，赋值0
matrix = [[0 for col in range(cols)] for row in range(rows)]创建二维数组，空
matrix = [[] for row in range(rows)]?遍历一维数组
first_number = numbers[0] # 访问第一个元素
last_number = numbers[-1] # 访问最后一个元素?遍历二维数组
for row in range(rows):
for col in range(cols):
print(matrix[row][col])更新一维数组
numbers[1] = 10 # 将索引为1的元素更新为10更新二维数组
matrix[row][col] = value添加元素?
numbers.append(6) # 在数组末尾添加一个元素
numbers.insert(2, 7) # 在索引为2的位置插入元素7删除元素
del numbers[3] # 删除索引为3的元素
numbers.remove(4) # 删除值为4的第一个元素length = len(numbers) # 获取数组的长度一维数组切片
sliced_numbers = numbers[1:4] # 获取索引1到3的元素切片二维数组切片，取原矩阵的[2:5][2:5]
new_matrix = [row[2:5] for row in maxtrix[2:5]]index()是在序列中检索参数并返回第一次出现的索引位置，Python下标默认从0计数。
A = [123, 'xyz', 'zara', 'abc']
print(A.index('xyz')) # 输出1表示有序、不可变的集合，可以包含不同类型的元素。
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
t = (1, 2, 3)
t = t + (4, 5, 6)
print(t) # (1, 2, 3, 4, 5, 6)表示无序、键值对的集合，用大括号括起来。
使用字典的键来获取对应的值，可以使用方括号或get()方法。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
print(my_dict['name']) # 输出：Alice
print(my_dict.get('age')) # 输出：25使用字典的键来添加或修改对应的值，可以使用方括号或update()方法。?
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
my_dict['email'] = 'alice@example.com'
my_dict.update({'age': 26, 'gender': 'unknown'})
print(my_dict) # 输出：{'name': 'Alice', 'age': 26, 'gender': 'unknown', 'email': 'alice@example.com'}?删除。使用del语句或pop()方法来删除字典中的键值对。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
del my_dict['age']
my_dict.pop('gender')
print(my_dict) # 输出：{'name': 'Alice'}使用keys()方法获取所有键，使用values()方法获取所有值。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
print(my_dict.keys()) # 输出：dict_keys(['name', 'age', 'gender'])
print(my_dict.values()) # 输出：dict_values(['Alice', 25, 'female'])使用in判断键是否存在于字典中。?
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
print('name' in my_dict) # 输出：True表示无序、唯一的元素集合，用大括号括起来。
返回两个集合中都存在的元素。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
intersection = set1.intersection(set2)
print(intersection) # {4, 5}
intersection = set1 & set2
print(intersection) # {4, 5}返回两个集合中所有的元素，去重后组成的新集合。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
union = set1.union(set2)
print(union) # {1, 2, 3, 4, 5, 6, 7, 8}
union = set1 | set2
print(union) # {1, 2, 3, 4, 5, 6, 7, 8}返回属于第一个集合但不属于第二个集合的元素。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
difference = set1.difference(set2)
print(difference) # {1, 2, 3}
difference = set1 - set2
print(difference) # {1, 2, 3}返回只属于一个集合而不属于另一个集合的元素。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
symmetric_difference = set1.symmetric_difference(set2)
print(symmetric_difference) # {1, 2, 3, 6, 7, 8}
symmetric_difference = set1 ^ set2
print(symmetric_difference) # {1, 2, 3, 6, 7, 8}在函数式编程中，函数是第一类对象，这意味着函数可以作为参数传递给其他函数，也可以作为返回值从一个函数返回。
即，函数也可以像常见的bool、int、str一样，作为一个参数进行传递。
将一个列表映射成另一个列表。
def square(x):
return x ** 2
nums = [1, 2, 3, 4, 5]
squared_nums = map(square, nums)
print(list(squared_nums)) # 输出：[1, 4, 9, 16, 25]bool函数，将一个列表进行过滤，返回为True的值，生成新列表。
def is_even(x):
return x % 2 == 0
nums = [1, 2, 3, 4, 5]
even_nums = filter(is_even, nums)
print(list(even_nums)) # 输出：[2, 4]列表元素从左往右，逐个缩减，缩减方法为函数的操作方法。
from functools import reduce
def add(x, y):
return x + y
nums = [1, 2, 3, 4, 5]
sum_nums = reduce(add, nums)
print(sum_nums) # 输出：15嵌套函数是一种函数作为返回值的情况。
def my_sum(x):
def my_add(y, z):
return x + y * z
return my_add
f = my_sum(10) # my_add(y, z)
print(f(5, 2)) # 输出 20
但嵌套函数不会立马计算值，只是保存了一个引用。
注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。
def my_sum(x):
result_f = []
for x in range(3):
def my_add(y, z):
return x + y * z
result_f.append(my_add)
return result_f
f1, f2, f3 = my_sum(10) # my_add(y, z)
print(f1(5, 2), f2(5, 2), f3(5, 2)) # 输出 12
print(list(map(lambda x: x * x, [1, 2, 3])))
# 输出 [1, 4, 9]# 定义一个lambda函数，接受两个参数x和y，返回它们的和
add = lambda x, y: x + y
# 调用lambda函数，将3和5作为参数传递
result = add(3, 5)
print(result) # 输出：8Python装饰器是一种特殊类型的函数，它可以接受一个函数作为参数，并返回一个新的函数。装饰器可以在不修改原始函数代码的情况下，为函数添加额外的功能。
下面是一个简单的Python装饰器示例，不涉及一个参数：
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()下面实现一个在原始函数前后添加额外功能的装饰效果，用于计算函数的执行时间：
import time
def timer_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function {func.__name__} took {end_time - start_time} seconds to execute.")
return result
return wrapper
@timer_decorator
def compute_fibonacci(n):
if n <= 1:
return n
else:
return compute_fibonacci(n-1) + compute_fibonacci(n-2)
# 调用装饰后的函数并传入参数10，计算斐波那契数列的第10个数
result = compute_fibonacci(10)