代码收藏家 Python-5级知识总结
1、Python 的 time 模块
获取当前时间戳
import time
# 获取当前时间戳
timestamp = time.time()
print("当前时间戳:", timestamp)将时间戳转换为本地时间
# 将时间戳转换为本地时间字符串
local_time = time.ctime(timestamp)
print("本地时间:", local_time)将时间戳转换为UTC时间
# 将时间戳转换为UTC时间字符串
utc_time = time.gmtime(timestamp)
print("UTC时间:", time.asctime(utc_time))暂停执行
# 暂停执行5秒
time.sleep(5)获取本地时间的 struct_time
# 获取本地时间的struct_time对象
local_time_struct = time.localtime()
print("本地时间struct_time:", local_time_struct)格式化时间
# 格式化时间
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time_struct)
print("格式化时间:", formatted_time)解析时间字符串
# 解析时间字符串
parsed_time = time.strptime("2024-06-12 12:00:00", "%Y-%m-%d %H:%M:%S")
print("解析后的时间:", parsed_time)将 struct_time 转换为时间戳
# 将struct_time对象转换为时间戳
time_stamp_from_struct = time.mktime(parsed_time)
print("从struct_time得到的时间戳:", time_stamp_from_struct)2、Python 的 random 模块
导入模块
import random生成随机浮点数
# 生成一个0到1之间的随机浮点数
random_float = random.random()
print("随机浮点数:", random_float)生成指定范围内的随机整数
# 生成一个1到10之间的随机整数（包括1和10）
random_int = random.randint(1, 10)
print("随机整数:", random_int)生成随机整数
# 生成一个0到指定数之间的随机整数（不包括指定数）
random_int = random.randrange(0, 100)
print("随机整数:", random_int)随机选择列表中的元素
# 从列表中随机选择一个元素
my_list = [1, 2, 3, 4, 5]
random_choice = random.choice(my_list)
print("随机选择的元素:", random_choice)随机排列列表元素
# 随机排列列表元素
random.shuffle(my_list)
print("随机排列后的列表:", my_list)生成随机样本
# 从列表中随机选择k个不重复的元素
sample = random.sample(my_list, k=3)
print("随机样本:", sample)设置随机数生成种子
# 设置随机数生成种子，确保随机数的可重复性
random.seed(1)
print("设置种子后的随机浮点数:", random.random())生成随机数序列
# 生成随机数序列
random_numbers = [random.random() for _ in range(5)]
print("随机数序列:", random_numbers)随机元素交换
# 随机交换列表中的两个元素
random.randint(0, len(my_list) - 1)
random.randint(0, len(my_list) - 1)
i, j = random.sample(range(len(my_list)), 2)
my_list[i], my_list[j] = my_list[j], my_list[i]
print("随机交换后的列表:", my_list)
3、Python 的 math 模块
Python 的 math 模块提供了许多数学函数，这些函数可以帮助你执行数学计算和操作。以下是 math 模块的一些常见用法：
导入模块
import math基本数学常量
# 数学常量
pi = math.pi # 圆周率π
e = math.e # 自然对数的底数e基础数学运算
# 绝对值
abs_value = math.fabs(-10)
print("绝对值:", abs_value)
# 幂运算
power = math.pow(2, 3) # 2的3次方
print("幂运算:", power)
# 平方根
sqrt = math.sqrt(16)
print("平方根:", sqrt)
# 计算两个数的最大公约数
num1 = 12
num2 = 18
gcd_value = math.gcd(num1, num2)
print(f"{num1} 和 {num2} 的最大公约数是 {gcd_value}")对数运算
# 自然对数
ln = math.log(math.e)
print("自然对数:", ln)
# 以10为底的对数
log10 = math.log10(100)
print("以10为底的对数:", log10)
# 常用对数（以e为底）
log = math.log(10)
print("常用对数:", log)三角函数
# 正弦
sin = math.sin(math.pi / 2)
print("正弦:", sin)
# 余弦
cos = math.cos(0)
print("余弦:", cos)
# 正切
tan = math.tan(math.pi / 4)
print("正切:", tan)双曲函数
# 双曲正弦
sinh = math.sinh(1)
print("双曲正弦:", sinh)
# 双曲余弦
cosh = math.cosh(1)
print("双曲余弦:", cosh)
# 双曲正切
tanh = math.tanh(1)
print("双曲正切:", tanh)角度和弧度转换
# 角度转弧度
radians = math.radians(180)
print("角度转弧度:", radians)
# 弧度转角度
degrees = math.degrees(math.pi)
print("弧度转角度:", degrees)特殊函数
# 阶乘
factorial = math.factorial(5)
print("阶乘:", factorial)
# 取整函数
floor = math.floor(3.7)
print("向下取整:", floor)
ceil = math.ceil(3.2)
print("向上取整:", ceil)
# 判断数字是否为无限大
is_inf = math.isinf(3.5)
print("是否为无限大:", is_inf)
# 判断数字是否为NaN（不是一个数字）
is_nan = math.isnan(0/0)
print("是否为NaN:", is_nan)三角函数的反函数
# 反正弦
asin = math.asin(1)
print("反正弦:", asin)
# 反余弦
acos = math.acos(0)
print("反余弦:", acos)
# 反正切
atan = math.atan(1)
print("反正切:", atan)
4、常见数据结构用法
字典（Dictionary）
字典是一种可变容器模型，它存储键值对。字典的键必须是唯一的。
创建字典
# 使用花括号创建字典
my_dict = {'name': 'Alice', 'age': 25}
# 使用dict()函数创建字典
my_dict = dict(name='Alice', age=25)访问字典元素
# 通过键访问
name = my_dict['name']
print("Name:", name)
# 使用get()方法，如果键不存在则返回None或指定的默认值
age = my_dict.get('age', 0)
print("Age:", age)修改字典
# 添加新的键值对
my_dict['gender'] = 'Female'
# 修改已有的键值对
my_dict['age'] = 26删除字典元素
# 删除指定键值对
del my_dict['gender']
# 使用pop()方法删除并返回指定键的值
removed_value = my_dict.pop('age', None)遍历字典
# 遍历字典的键
for key in my_dict:
print("Key:", key)
# 遍历字典的值
for value in my_dict.values():
print("Value:", value)
# 遍历字典的键值对
for key, value in my_dict.items():
print("Key:", key, "Value:", value)元组（Tuple）
元组是一种不可变的序列，一旦创建就不能修改。
创建元组
# 使用圆括号创建元组
my_tuple = (1, 2, 3)
# 单元素元组需要在元素后加逗号
single_element_tuple = (1,)
# 元组也可以包含不同类型的元素
mixed_tuple = (1, 'two', 3.0)访问元组元素
# 通过索引访问
first_element = my_tuple[0]
print("First Element:", first_element)
# 通过负索引访问
last_element = my_tuple[-1]
print("Last Element:", last_element)元组切片
# 获取元组的一部分
sub_tuple = my_tuple[1:3]
print("Sub Tuple:", sub_tuple)修改元组
# 元组是不可变的，所以不能修改其元素
# 但是可以创建一个新的元组
new_tuple = my_tuple + (4,)遍历元组
for element in my_tuple:
print("Element:", element)元组解包
# 将元组中的值赋给多个变量
a, b, c = my_tuple
print("A:", a, "B:", b, "C:", c)集合（Set）
集合是一种无序的不重复元素序列。
创建集合
# 使用花括号创建集合
my_set = {1, 2, 3}
# 使用set()函数创建集合
my_set = set([1, 2, 3])添加和删除元素
# 添加元素
my_set.add(4)
# 删除元素
my_set.discard(2) # 与remove()不同，如果元素不存在，不会抛出错误集合运算
# 两个集合的并集
union_set = my_set.union({3, 4, 5})
# 两个集合的交集
intersection_set = my_set.intersection({1, 2, 3})
# 两个集合的差集
difference_set = my_set.difference({2, 3})遍历集合
for element in my_set:
print("Element:", element)update 方法用于将一个字典的键值对更新到另一个字典中。如果键已存在，则值会被更新；如果键不存在，则会添加新的键值对。
# 创建两个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
# 使用update方法更新dict1
dict1.update(dict2)
print("更新后的字典:", dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}clear 方法
clear 方法用于清空字典中的所有内容。
my_dict = {'a': 1, 'b': 2}
# 清空字典
my_dict.clear()
print("清空后的字典:", my_dict) # 输出: {}keys、values、items 方法
这些方法用于返回字典中键、值和键值对的视图对象。
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 获取所有键
keys = my_dict.keys()
print("Keys:", list(keys))
# 获取所有值
values = my_dict.values()
print("Values:", list(values))
# 获取所有键值对
items = my_dict.items()
print("Items:", list(items))fromkeys 方法
fromkeys 方法用于创建一个新字典，其中的键来自一个给定的序列，每个键对应的值都是指定的值。
# 使用fromkeys创建字典
new_dict = dict.fromkeys(['a', 'b', 'c'], 0)
print("从keys创建的字典:", new_dict) # 输出: {'a': 0, 'b': 0, 'c': 0}集合（Set）
update 方法
集合也有 update 方法，用于将其他集合中的元素添加到当前集合中。
# 创建两个集合
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 使用update方法更新set1
set1.update(set2)
print("更新后的集合:", set1) # 输出: {1, 2, 3, 4, 5}add 和 remove 方法
add 方法用于向集合中添加元素，remove 方法用于移除指定元素。如果元素不存在，remove 方法会抛出 KeyError。
my_set = {1, 2, 3}
# 添加元素
my_set.add(4)
# 移除元素
my_set.remove(2)
print("操作后的集合:", my_set) # 输出: {1, 3, 4}discard 和 pop 方法
discard 方法用于移除指定元素，如果元素不存在，不会抛出错误。pop 方法用于移除并返回集合中的一个随机元素。
my_set = {1, 2, 3}
# 移除元素，如果不存在不会抛出错误
my_set.discard(2)
# 移除并返回一个随机元素
removed_element = my_set.pop()
print("操作后的集合:", my_set) # 输出可能是: {1, 3}
print("移除的元素:", removed_element) # 输出可能是: 1 或 3
在Python中，列表（list）和集合（set）是两种不同的数据结构，它们有不同的用途和特点：
列表（List）
列表是Python中最基本的数据结构之一，它是一个有序的集合，可以包含重复的元素。
创建列表
my_list = [1, 2, 3, 4]访问列表元素
# 通过索引访问
first_element = my_list[0]修改列表
# 修改元素
my_list[0] = 5添加元素
# 在列表末尾添加元素
my_list.append(6)
# 在列表开头添加元素
my_list.insert(0, 0)删除元素
# 删除末尾的元素
last_element = my_list.pop()
# 删除指定索引的元素
del my_list[0]列表切片
# 获取列表的一部分
sub_list = my_list[1:3]列表遍历
for element in my_list:
print(element)列表排序
# 原地排序
my_list.sort()
# 返回一个新的排序列表
sorted_list = sorted(my_list)列表推导式
# 使用列表推导式创建新列表
squared_list = [x**2 for x in my_list]集合（Set）
集合是一个无序的不重复元素集，它可以用来进行数学上的集合运算，如并集、交集、差集等。
创建集合
my_set = {1, 2, 3, 4}添加元素
# 添加单个元素
my_set.add(5)
# 一次性添加多个元素
my_set.update([6, 7])删除元素
# 删除元素，如果元素不存在，会抛出KeyError
my_set.remove(2)
# 删除元素，如果元素不存在，不会抛出错误
my_set.discard(8)
# 随机弹出一个元素
popped_element = my_set.pop()集合运算
# 并集
union_set = my_set.union({3, 4, 5})
# 交集
intersection_set = my_set.intersection({1, 2, 3})
# 差集
difference_set = my_set.difference({2, 3})集合遍历
for element in my_set:
print(element)集合推导式
# 使用集合推导式创建新集合
squared_set = {x**2 for x in my_set if x % 2 == 0}
5、排序算法
在Python中创建排序算法可以通过多种方式实现。以下是一些常见的排序算法的归纳和实现：
1. 冒泡排序（Bubble Sort）
冒泡排序的基本思想是重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复进行直到没有再需要交换，也就是说该数列已经排序完成。
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]2. 选择排序（Selection Sort）
选择排序的基本思想是首先在待排序的记录中选出最小（或最大）的元素，存放在序列的起始位置，然后，再从剩余的未排序元素中寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据排完。
def selection_sort(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i+1, len(arr)):
if arr[min_idx] > arr[j]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]3. 插入排序（Insertion Sort）
插入排序的基本思想是在已排序序列中插入一个元素，从而得到一个新的、数量加一的已排序序列。
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key4. 快速排序（Quick Sort）
快速排序的基本思想是选择一个基准值，将数组分为两部分，一部分比基准值大，一部分比基准值小，然后递归地对这两部分进行快速排序。
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)5. 归并排序（Merge Sort）
归并排序的基本思想是将两个或多个已排序的序列合并成一个已排序序列，然后将已排序的子序列合并成一个最终的已排序序列。
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
while left and right:
if left[0] < right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
result.extend(left or right)
return result
6、递归算法
- 基本情况（Base Case）：这是递归结束的条件，防止无限递归。
- 递归步骤（Recursive Step）：在这一步中，问题被分解成更小的子问题，这些子问题与原始问题相似，但规模更小。
以下是一些常见的递归算法示例：
1. 阶乘计算（Factorial）
阶乘函数是一个典型的递归问题，因为一个数的阶乘可以定义为该数乘以比它小1的数的阶乘。
def factorial(n):
# 基本情况：0的阶乘是1
if n == 0:
return 1
# 递归步骤：n的阶乘是n乘以(n-1)的阶乘
else:
return n * factorial(n - 1)2. 斐波那契数列（Fibonacci Sequence）
斐波那契数列中的每一项都是前两项的和，递归函数可以很好地表示这种关系。
def fibonacci(n):
# 基本情况：第0项和第1项分别是0和1
if n == 0:
return 0
if n == 1:
return 1
# 递归步骤：第n项是第(n-1)项和第(n-2)项的和
else:
return fibonacci(n - 1) + fibonacci(n - 2)3. 二分搜索（Binary Search）
二分搜索是一种在有序数组中查找元素的算法，通过每次将搜索范围缩小一半来提高效率。
def binary_search(arr, x, low, high):
# 基本情况：如果搜索范围无效，则元素不存在于数组中
if high >= low:
mid = (high + low) // 2
# 如果元素在中间位置
if arr[mid] == x:
return mid
# 如果元素小于中间位置，则在左半部分搜索
elif arr[mid] > x:
return binary_search(arr, x, low, mid - 1)
# 如果元素大于中间位置，则在右半部分搜索
else:
return binary_search(arr, x, mid + 1, high)
# 元素不存在于数组中
else:
return -14. 快速排序（Quick Sort）
快速排序是一种分而治之的算法，通过选择一个基准值将数组分为两部分，然后递归地对这两部分进行排序。
def quick_sort(arr):
# 基本情况：如果数组为空或只有一个元素，则不需要排序
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
# 递归步骤：递归地对左边和右边的子数组进行排序，然后合并
return quick_sort(left) + middle + quick_sort(right)5. 深度优先搜索（Depth-First Search, DFS）
深度优先搜索是一种用于遍历或搜索树或图的算法，它沿着一个分支深入到底，然后回溯。
def dfs(graph, visited, vertex):
visited[vertex] = True
print(vertex, end=' ')
for neighbor in graph[vertex]:
if not visited[neighbor]:
dfs(graph, visited, neighbor)递归算法在解决这些问题时非常直观和优雅，但需要注意防止栈溢出（特别是对于深度递归），并且在某些情况下，递归可能不是最高效的解决方案（比如可以使用迭代算法替代）。此外，递归算法的实现需要仔细考虑基本情况，以确保递归能够正确结束。
作者：xichu1024
