Python笔记整理

一，python的概念

Python由 荷兰国家数学与计算机科学研究中心 的 吉多·范罗苏姆 于1990年代初设计，作为一门叫做 ABC语言 的替代品。 Python提供了高效的高级 数据结构 ，还能简单有效地 面向对象 编程。y

 python与c ，java 编译与解释的区别

静态与动态的区别：

静态对于变量有明确的类型定义的 动态对变量没有明确类型定义的

在 C C++ Java 中，基本数据类型变量（将常量数据存储在变量空间当中）

例如：

int a = 3 ;

int b = 4 ;

在 C C++ 中，指针变量（存储的是变量的物理内存地址）

例如：

int a = 3 ;

int* b ;

b = & a ;

int** c ;

c = & b ;

printf ( "%d" , & c ); //0x789

printf ( "%d" , * c ); //0x123

printf ( "%d" , &**& c ); //0x456

在 Java 中，引用数据类型变量（将对象在堆内存中的地址给变量）

例如：

Object obj = new Object ();

Object obj2 = obj ;

动态语言（所有的数据都是对象！所有的变量都是引用数据类型变量）

例如：

var a = 1

var b = 1.1

b = new object ();

安装环境

Python 开发工具包

http://python.p2hp.com/downloads/windows/index.html

如何验证安装成功： win+R 输入 cmd 打开控制台 输入 python 命令

如果没有出现 3.12.1 的提示，去找到 Python 的安装目录：

C:\Users\Administrator\AppData\Local\Programs\Python\Python312

我的电脑图标，邮件，属性，高级系统设置，环境变量， Path ，双击，新建，粘贴路径，确定，确定，

确定，重新打开 CMD 窗口测试

脚本与交互

交互模式

打开 CMD 窗口，输入 python 指令，进入到了 python 交互模式

print() 输出函数，输出的内容写在一对小括号中 print(XXX)

弊端：代码不能持久保存，代码随着窗口关闭而消失

我们一般在做简单的代码演示、测试会使用到交互模式

为了永久保存代码，需要脚本模式

脚本模式

打开 VSCode ， File ， New Folder ，选择代码目录， New File 按钮创建文件，输入名称和后缀名 (.py)

注意：一定要养成随时按crtl+s 保存

如何运行 Python 脚本文件呢

打开 CMD 窗口，进入到代码目录路径

指令： python XXX.py 运行 XXX.py 文件

整数常量

注意：没有byte short long 之分 一律默认int

小数常量

注意：没有float与double之分 默认float

字符串常量

字符串表示一段文本信息，程序会将文本信息原封不动的处理

Python 没有字符的数据，一律当成字符串处理，双引号和单引号都可以表示字符串

布尔值常量

只有两个值 True ， False ， T 和 F 是大写的

复数常量

标识符

就是我们程序员自定义的一些名称（变量 函数 类）

规则：

由字母、数字、下划线、美元符组成

数字不能开头

是一个连续的词，中间不能有空格分开

规范：

小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写 myName

大驼峰：类 所有单词首字母大写 MyName

下划线分割：单词之间用下划线分割 不大写 my_name

起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音

关键字

就是一些单词，被 Python 赋予了特殊的含义，不能随便使用

内置函数名 / 类名

内置函数就是 Python 自带的一些具有特殊功能的函数

所以，我们在使用内置函数的时候，一定要注意名称不能够被更改

注释

变量

在 Python 当中 变量其实就是一个万能箱子 他可以存储任何数据

本质：变量它只存储数据在内存中的地址（引用类型变量）

数据类型转换

int() 将其他有效的数据转为整数

取整

从字符串中解析整数

float() ：将其他的数据转为小数

str() ：将其他数据转字符串

bool() ：将其他数据转布尔类型

进制转换

字符与ASCII码转换

a~z A~Z 0~9 他们在 ASCII 中的编号都是连续的

ord() ：获取字符对应的 ASCII 码编号

chr() ：根据给定的 ASCII 码编号获取对应的字符

常见的数学计算

输入与输出

input()

print()

算术运算符

比较运算符

赋值运算符

逻辑运算符

位运输符
 

成员运算符

身份运算符

条件判断

只有 if-else 语句， Python 不支持 switch 语句

循环语句

主要解决什么样的问题：具有重复性、规律性的问题

向前走 10 步：有明显的循环次数的 - for

向前走，直到碰墙为止：没有明显的循环次数的，但是有结束条件 - while

循环四要素：

循环的开始（从第 1 步开始；从第 1 步开始 / 从起点开始）

循环的继续条件（还没走到第 10 步；没有碰到墙 / 就是看距离）

循环体（走的每一步；走的每一步）

循环的步长 / 间隔 / 周期 / 进度（步数的统计；距离的统计）

数组列表：

序列：序列是指一组有序的数据集合，其本质是一块存储多个值的连续内存空间。每个值在序列中都有对应的位置编号，即索引，这些值具有一定的顺序，可以通过索引访问对应的值。序列不是一种特定的数据类型，而是一种存储数据的方式。字符串，元组，集合，字典都可以是序列

序列通用操作

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> arr[0]
1
>>> arr[8]
9
>>> arr[-1] # 倒数第1个
9
>>> arr[-2] # 倒数第2个
8
>>> arr[-100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> arr[100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

切片：访问一定范围的序列元素

>>> arr[2:] # 从角标2开始向尾遍历 步长为1
[3, 4, 5, 6, 7, 8, 9]
>>> arr[2::2] # 从角标2开始向尾遍历 步长为2
[3, 5, 7, 9]
>>> arr[:6] # 从头开始到角标6(不取) 步长为1
[1, 2, 3, 4, 5, 6]
>>> arr[:6:3] # 从头开始到角标6(不取) 步长为3
[1, 4]
>>> arr[:] # 从头到尾
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[::]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[::2]
[1, 3, 5, 7, 9]
=======================================特殊的
>>> arr[-1:-7] # 从尾到头 步长必须负数
[]
>>> arr[-1:-7:-1]
[9, 8, 7, 6, 5, 4]
>>> arr[-9:7] # 从头到尾 步长为正数
[1, 2, 3, 4, 5, 6, 7]
>>> arr[0:7]
[1, 2, 3, 4, 5, 6, 7]
>>> arr[-9:-2] # 从头到尾 步长为正数
[1, 2, 3, 4, 5, 6, 7]

成员资格

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> 1 in arr
True
>>> 10 in arr
False

长度与最值

>>> arr = [1,2,3,4,5,6,7,8,9]
>>> len(arr) # 获取序列的长度
9
>>> len(arr)
9
>>> max(arr)
9
>>> min(arr)
1
>>> s = "ABC"
>>> len(s)
3
>>> max(s)
'C'
>>> min(s)
'A'

常见操作

创建问题

"""
列表
1.存储多个数据 数据不一定都是同一个类型 但是为了方便操作 建议存一样的类型
2.可以通过索引/角标来访问元素
3.可变长的数组 我们后续可以在列表中进行 增 删
4.用一对中括号[]
"""
# 创建一个空的列表
arr = []
print(arr)
# 创建一个具有若干元素的列表
arr = [1, 2, 3, 4]
print(arr)
# 创建一个具有长度但是没有值的列表
arr = [None] * 5
print(arr)
# 通过【列表推导式/解析式】来进行创建
# [目标值表达式 for 目标值 in 迭代对象 if ....]
# 创建1~100当中 能够被3整除 且 能够被5整除 的所有数字
"""
for x in range(1, 101):
if x % 3 == 0 and x % 5 == 0:
print(x)
"""
arr = [x for x in range(1, 101) if x % 3 == 0 and x % 5 == 0]
print(arr)
# 创建1~100当中 偶数
arr = [x for x in range(1, 101) if x % 2 == 0]
print(arr)
# 水仙花数
for num in range(100, 1000):
a = num % 10
b = num // 10 % 10
c = num // 100
if a ** 3 + b ** 3 + c ** 3 == num:
print(num)
arr = [num for num in range(100, 1000) if (num % 10) ** 3 + (num // 10 % 10) **
3 + (num // 100) ** 3 == num]
print(arr)
arr = [x * 3 + "哈哈" for x in "ABCDEFG"]
print(arr)
# 通过输入来获取元素
"""
5
"1" "2" "3" "4" "5"
"""
n = eval(input())
arr = input().split(" ") # 将输入的数据以空格分割 分割的结果就是列表
print(arr)
arr = [int(x) for x in arr]
print(arr)

遍历问题

arr = [1,2,3,4,5,6,7,8,9]
# 通过角标遍历
for i in range(len(arr)):
    print(arr[i])
# 通过foreach遍历
for num in arr:
    print(num)

最值问题

arr = [1,2,3,4,5,6,7,8,9]
# 最大值
maxNum = arr[0]
# 最小值
minNum = arr[0]
for i in range(1, len(arr)):
    if arr[i] > maxNum:
        maxNum = arr[i]
    if arr[i] < minNum:
        minNum = arr[i]
print(maxNum)
print(minNum)

存在性问题

arr = [1,2,3,4,5,4,6,4,7,8,9]
# 元素是否存在
key = 10
for num in arr:
    if num == key:
        print("存在")
        break
else:
    print("不存在")
# 元素在哪个位置 从左到右第1次出现的角标 不存在返回-1
key = -4
index = 0
for i in range(len(arr)):
    if arr[i] == key:
        index = i
        break
else:
    index = -1
print(index)

翻转问题

arr = [1,2,3,4,5,6,7,8,9,10]
#      0 1 2 3 4 5 6 7 8 9 角标
arr = arr[-1::-1]
print(arr)
 
for i in range(0, len(arr) // 2):
    j = len(arr) - 1 - i
    arr[i], arr[j] = arr[j], arr[i]
print(arr)
 
left = 0
right = len(arr) - 1
while left <= right:
    arr[left], arr[right] = arr[right], arr[left]
    left += 1
    right -= 1
print(arr)

排序算法

插入排序

插入排序（Insertion Sort）的基本思路是将一个未排序的数列，逐个插入到已排序的数列中，使得插入后的数列仍然有序。插入排序的优点是实现简单，适用于小规模的数据排序，时间复杂度为O(n^2)，空间复杂度为O(1)。但是，对于大规模数据的排序，插入排序的效率较低。

实现步骤
（1）设数组长度为n。

（2）将第1个元素看成已排序部分，第2个元素到第n个元素看成未排序部分。

（3）从未排序部分取出第1个元素,将其插入已排序部分的合适位置。此时已排序部分的长度为1。

（4）从未排序部分取出第2个元素将其插入已排序部分的合适位置。此时已排序部分的长度为2。

（5）重复步骤4，直到所有元素都被插入到已排序部分。

选择排序

选择排序的基本思路是每次从未排序的数列中选择最小（或最大）的元素（最小即升序，最大即降序），将其放到已排序数列的末尾。重复这个过程，直到所有元素都被排序为止。选择排序是一种简单但效率较低的排序算法，其时间复杂度为O(n^2)，不适用于大规模数据的排序。

实现步骤

（1）设数组长度为n。

（2）从数组中找到最小的元素，并记录其下标。

（3）将最小元素与第1个元素交换位置。

（4）在剩下的n-1个元素中，找到最小的元素，记录其下标。

（5）将最小元素与第2个元素交换位置。

（6）重复步骤4-5，直到排序完成。

冒泡排序

冒泡排序的基本思想是比较相邻两个元素的大小，如果顺序不对则交换它们的位置，一直重复这个过程直到整个序列有序。它的时间复杂度为O(n^2)，因此对于较大的数据集不太适用，但对于小型数据集和教学目的来说是一种不错的选择。

实现步骤
（1）设数组为长度为n。

（2）从第一个元素开始，比较数组相邻的元素。如果前一个元素比后一个元素大，则交换他们的位置。经过一轮循环后，最后一个元素一定是本轮中最大的元素，因此下一轮循环时只需要比较前n-1个元素即可。

（3）不计最后一个元素，在剩下的n-1个元素中，重复步骤2，直到第一个元素（即在n-1个元素数中，继续比较相邻的元素）。

（4）重复步骤3，直到第一个元素结束，此时数组升序。

堆排序

堆排序（Heap Sort）是一种基于完全二叉树的排序算法，它的基本思想是将待排序的序列看成一棵完全二叉树，并将其构建成一个大根堆（或小根堆），然后将堆顶元素与堆底元素交换（因为堆顶元素最大），并重新调整堆，使得剩余元素仍满足堆的性质，重复以上操作，直到所有元素有序为止。堆排序的时间复杂度为 O(nlogn)，空间复杂度为 O(1)。在实际应用中，堆排序是一种常用的排序算法，可以用于处理各种规模的数据。

实现步骤

（1）将待排序的序列构建成一个大根堆（或小根堆），这一步可以使用 Heapify 操作实现，即从最后一个非叶子节点开始，依次向下调整每个子树，使其满足堆的性质。

（2）将堆顶元素与堆底元素交换，并将堆的大小减一，（即将最大的元素放到最后）。

（3）对堆顶元素进行下沉操作，使其重新满足堆的性质（即在剩余的数中找最大的元素）。

（4）重复步骤 2 和 3，直到堆的大小为 1，此时整个序列有序。

查找算法

二分查找：要求数据必须有序

arr = [1,2,3,4,5,6,7,8,9]
minIndex = 0
maxIndex = len(arr) - 1
midIndex = (minIndex + maxIndex) // 2
key = 8
while arr[midIndex] != key:
    if arr[midIndex] < key:
        minIndex = midIndex + 1
else:
    maxIndex = midIndex - 1
    if minIndex > maxIndex:
        midIndex = -1
        break
    midIndex = (minIndex + maxIndex) // 2
print(midIndex)

归并排序

归并排序是一种基于分治策略的排序算法。它的基本思想是将待排序的序列不断地分成两个子序列，直到每个子序列只有一个元素，然后将这些子序列进行合并，直到最终得到一个有序序列。归并排序的时间复杂度为O(nlogn)，其中n为待排序序列的长度。归并排序是稳定的排序算法，即相等元素的相对位置不会改变。

实现步骤

（1）将序列中待排序数字分为若干组，每个数字分为一组。

（2）将若干组两两合并，保证合并的组都是有序的。

（3）重复第二步的操作，直到剩下最后一组即为有序数列。

插值查找：数据必须是有序的，除了要考虑位置还得考虑元素的分布情况

"""

插值查找适用于数据分布比较均匀的情况

low 区间最小值角标

high 区间最大值角标

mid 区间中间值角标

mid = (key- arr[low]) / (arr[high] - arr[low]) * (high - low) + low

"""

arr = [ 1 , 12 , 24 , 31 , 32 , 36 , 42 , 45 , 51 , 52 , 65 , 72 , 99 ]

low = 0

high = len ( arr ) - 1

mid = 0

key = 31

while True :

mid = int (( key - arr [ low ]) / ( arr [ high ] - arr [ low ]) * ( high - low )) + low

if mid > high or mid < low :

mid = - 1

break

if arr [ mid ] == key :

break

elif arr [ mid ] < key :

low = mid + 1

else :

high = mid - 1

print ( mid )

列表对象函数

对象函数是区别于内置函数的，内置函数直接调用即可 len() max()

对象函数 必须通过某一个具体的对象来调用 列表 . 函数名 ()

# append()

# 将某一个元素对象添加在列表的表尾

# 如果添加的是其他的序列，该序列也会被看成是一个数据对象

arr = [ 1 , 2 , 3 , 4 ]

arr . append ( 5 )

print ( arr )

arr2 = [ 6 , 7 , 8 ]

arr . append ( arr2 )

print ( arr )

# count()

# 统计列表当中 某一个元素出现的次数

arr = [ 1 , 2 , 3 , 4 , 1 , 2 , 3 , 1 , 1 , 2 , 0 , 0 , 1 ]

print ( arr . count ( 1 ))

# extend()

# 在当前列表中 将传入的其他序列的元素添加在表尾

arr1 = [ 1 , 2 , 3 ]

arr2 = [ 4 , 5 , 6 ]

arr1 . extend ( arr2 )

print ( arr1 )

"""

arr1.extend(7)

TypeError: 'int' object is not iterable( 可迭代的 = 序列 )

"""

arr1 . extend ( "ABC" )

print ( arr1 )

# index()

# 查找 ( 从左到右 ) 元素第一次出现的位置 ( 角标 )

arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 4 , 5 , 6 , 9 ]

print ( arr . index ( 4 ))

print ( arr . index ( 4 , 5 , 8 )) #[5, 8) 区间中找 4 的角标

"""

print(arr.index(10))

ValueError: 10 is not in list 找不到则报错

"""

# insert(index, obj)

# 在某一个角标出处插入一个元素

arr = [ 1 , 2 , 3 , 4 ]

arr . insert ( 2 , 5 )

print ( arr )

# pop()

# 弹栈：删除最后一个元素 并返回其值

# 也可以删除指定角标处的元素

arr = [ 1 , 2 , 3 , 4 ]

print ( arr . pop ())

print ( arr )

print ( arr . pop ( 1 ))

print ( arr )

# remove()

# 移除指定元素 从左到右第一次出现的

arr = [ 1 , 2 , 3 , 4 , 2 , 3 , 4 , 2 , 3 , 4 ]

arr . remove ( 4 )

print ( arr )

# reverse()

# 翻转列表

arr = [ 1 , 2 , 3 , 4 ]

arr . reverse ()

print ( arr )

# sort()

# 排序

arr = [ 4 , 2 , 5 , 2 , 6 , 2 , 7 , 9 , 4 , 7 , 2 , 7 ]

# arr.sort() # 默认升序

arr . sort ( reverse = True ) # 降序

arr = [ "ABC" , "123123123" , " 我爱你中国 " , "123123123" , "kasdkjas" ]

arr . sort ( key = len ) # 以序列的长度为基准进行排序

print ( arr )

# clear()

# 清空

arr = [ 1 , 2 , 3 , 4 ]

arr . clear ()

print ( arr )

# copy()

# 复制一个列表 ( 浅拷贝 )

arr1 = [ 1 , 2 , 3 , 4 ]

arr2 = arr1 . copy ()

print ( arr1 == arr2 ) # True 比较的是内容

print ( arr1 is arr2 ) # False 比较的是对象地址

print ( arr1 )

print ( arr2 )

arr1 [ 0 ] = 5

print ( arr2 [ 0 ])

# 上述代码在 arr1 中修改元素 并不影响 arr2

arr1 = [ 1 , 2 , 3 ,[ 4 , 5 , 6 ]]

arr2 = arr1 . copy ()

arr2 [ 0 ] = 7

print ( arr1 [ 0 ])

print ( arr2 [ 0 ])

arr2 [ 3 ][ 0 ] = 666

print ( arr1 [ 3 ])

# 上述代码在 arr2 中修改元素 影响 arr1

arr2 [ 3 ] = [ 9 , 9 , 9 ]

print ( arr1 [ 3 ])

print ( arr2 [ 3 ])

# 额外的知识

# del 关键字：删除

arr = [ 1 , 2 , 3 , 4 ]

del arr [ 0 ] # 删除序列中的元素

print ( arr )

del arr # 删除变量

"""

NameError: name 'arr' is not defined. Did you mean: 'arr2'?

print(arr)

"""

字符串对象函数

可变对象与不可变对象

列表是可变对象：可以修改列表中的元素 甚至长度

字符串是不可变对象：不可以修改字符串中的元素 包括 长度

注意：也就意味着对字符串的修改 一律不是在本身修改 而是创建一个新的字符串！

>>> arr = [1,2,3]

>>> arr[0] = 4

>>> arr

[4, 2, 3]

>>> s = "ABC"

>>> s[0]

'A'

>>> s[0] = "D"

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

字符串对象不支持元素修改

# center()

# 指定填充字符 将目标字符进行居中

s1 = "ABC"

s2 = s1 . center ( 10 , "#" )

print ( s1 )

print ( s2 )

# count()

# 和列表的 count 相似 统计字符串的个数

s = "abchjghjabcjkhjkhabchkjhabc"

print ( s . count ( "abc" ))

print ( s . count ( "a" ))

# count 是非贪心统计 贪心统计 6 个

s = "AAAAAAAA"

print ( s . count ( "AAA" ))

print ( s . count ( "AAA" , 2 , 6 ))

# endswith()

# 过滤字符串结尾 同样也可以指定区间

s = " 泷泽萝拉 .avi"

print ( s . endswith ( ".avi" ))

# find()

# 寻找字符串第一次出现的位置 同样也可以指定区间

s = " 八百标兵奔北坡 "

print ( s . find ( " 标兵 " )) # 2 指定是标的角标

# format()

# 格式化输出

name = " 小强 "

age = 18

print ( " 我的名字叫 %s, 年龄 %d 岁 " % ( name , age ))

print ( " 我的名字叫 {}, 年龄 {} 岁 " . format ( name , age ))

print ( f" 我的名字叫 {name}, 年龄 {age} 岁 " )

print ( f" 我的名字叫 {3 > 2}, 年龄 {2 ** 8} 岁 " )

# index()

# 寻找字符串第一次出现的位置 同样也可以指定区间

s = " 八百标兵奔北坡 "

print ( s . index ( " 标兵 " )) # 2 指定是标的角标

s = "ABC"

print ( s . find ( "D" )) # -1 如果找不到 则返回 -1

# print(s.index("D"))# 如果找不到 直接报错 ValueError: substring not found

# isalnum()

# 判断是否是字母或数字字符串 al-alpha 字母 num-number 数字

print ( "abc" . isalnum ())

print ( "123" . isalnum ())

print ( "abc123" . isalnum ())

print ( "abc123^&%&^&" . isalnum ())

# isalpha() 是否是纯字母字符串

# isdecimal() 是否是十进制纯数字字符串

# isdigit() 是否是纯数字字符串

# isspace() 是否是纯空格字符串

# islower() 出现的字母是否是小写字母

print ( "123abc" . islower ())

print ( "123Abc" . islower ())

# isupper() 出现的字母是否是大写字母

# join() 将字符串列表进行拼接的

arr = [ "banana" , "orange" , "apple" , "pich" ]

s = "-" . join ( arr )

print ( s )

# ljust() 左对齐 rjust() 右对齐

print ( "ABC" . ljust ( 10 , "#" ))

print ( "ABC" . rjust ( 10 , "#" ))

# lower() 出现的大写字母转小写 upper() 相反

print ( "Hello World123" . lower ())

# lstrip() 去除左边空格 rstrip() 去除右边空格

print ( " ABC " . lstrip ())

print ( " ABC " . rstrip ())

print ( " ABC " . strip ()) # 两边都去掉连续空格

print ( " A B C " . strip ())

# replace(a,b) 替换 a 旧 b 新

s = " 宇智波佐助、宇智波斑、宇智波鼬、宇智波泉奈、宇智波止水、宇智波卡卡西 "

s1 = s . replace ( " 宇智波 " , " 千手 " )

print ( s )

print ( s1 )

# split() 以某一个分割符来切割字符串 结果是一个字符串的列表

s = " 泰罗 - 杰克 - 赛文 - 迪迦 - 梦比优斯 "

arr = s . split ( "-" )

print ( arr )

arr = "1 2 34 4.12" . split ( " " )

print ( arr )

math和random的应用

# 导入math模块
import math
 
# Math模块提供了许多数学函数和常量，以下是一些常见的用法：
 
# 数学常数
pi_value = math.pi  # pi_value = 3.141592653589793
e_value = math.e    # e_value = 2.718281828459045
 
# 数学函数
# 平方根
sqrt_result = math.sqrt(16)  # sqrt_result = 4.0
 
# 对数函数
log_result = math.log(10)    # log_result = 2.302585092994046
log10_result = math.log10(100)  # log10_result = 2.0
 
# 三角函数
sin_result = math.sin(math.pi/2)  # sin_result = 1.0
cos_result = math.cos(math.pi)    # cos_result = -1.0
tan_result = math.tan(0)           # tan_result = 0.0
 
# 向上取整
ceil_result = math.ceil(4.3)  # ceil_result = 5
 
# 向下取整
floor_result = math.floor(4.7)  # floor_result = 4
 
# 绝对值
abs_result = math.fabs(-4.5)   # abs_result = 4.5
 
# 阶乘
factorial_result = math.factorial(5)  # factorial_result = 120
 
# 幂运算
power_result = math.pow(2, 3)   # power_result = 8.0
 
# 最大公约数
gcd_result = math.gcd(12, 8)   # gcd_result = 4
 
# 最小公倍数
lcm_result = math.lcm(12, 8)   # lcm_result = 24

# 导入random模块
import random
 
# Random模块提供了生成随机数的功能，以下是一些常见的用法：
 
# 生成随机整数
random_integer = random.randint(1, 10)  # 生成1到10之间的随机整数
 
# 生成随机浮点数
random_float = random.uniform(1.0, 5.0)  # 生成1.0到5.0之间的随机浮点数
 
# 从列表中随机选择一个元素
my_list = [1, 2, 3, 4, 5]
random_choice = random.choice(my_list)  # 从my_list中随机选择一个元素
 
# 打乱列表顺序
random.shuffle(my_list)  # 将my_list中的元素顺序打乱
 
# 生成随机种子
random_seed = random.seed(10)  # 生成随机种子，设置种子值为10
 
# 生成随机高斯分布数
random_gaussian = random.gauss(0, 1)  # 生成均值为0，标准差为1的随机高斯分布数