python基础

一、选择python的原因

1、python相较而言比较简单，容易上手，比较好学，同时又是多个企业指定多个语言中的一种

2、开发、网安、云原生、都会用到编程相关的技术

二、软件

1、定义

是指一些按照特定顺序组织的能够被计算机识别的数据与指令的集合

注：解决问题时，一定要先分析问题，一步一步的列出来，然后用代码实现

2、软件的分类

（1）操作系统软件：Windows Android IOS Harmony

主要负责管理和调控计算机硬件，给用户提供最基本的计算机功能（磁盘管理，上网管理，内存管理， 用户管理......）

（2）应用程序：微信 优酷 支付宝 网易云

提供专业领域服务的软件，是基于操作系统软件运行的

3、编程语言

（1）机器语言：所有的数据都是由0和1组成，人看不懂，机器能看懂

（2）汇编语言：1 2 add，必须要考虑计算机的执行过程，门槛比较高

（3）高级语言：C C++ Java Python JavaScript....，以人类的角度设计的，对学习者非常友好，但是计算机就 看不懂了

（4）静态编译型：C C++ Java （在完成一整个的代码编写后才开始编译）

        动态解释型：Python JavaScript （脚本语言，在编写的时候就可以编译）

4、静态和动态的区别

静态对于变量有明确的类型定义的 动态对变量没有明确类型定义的，动态语言中所有的数据都是对象！所有的变量都是引用数据类型变量

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

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

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

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

5、堆和栈

（1）栈：栈是一种后进先出（LIFO）的数据结构，用于存储局部变量和方法调用的上下文。

特点：

栈上的变量通常在函数调用时创建，在函数返回时销毁。

由编译器自动分配和释放。

栈的大小通常较小，且固定。

访问速度相对较快。

主要用于存储函数的局部变量、函数调用时的上下文等。

（2）堆：堆是一种动态内存分配方式，用于存储程序运行时创建的对象和数据。

特点：

堆上的数据生命周期由程序员控制，需要手动分配和释放。

由程序员通过 malloc、free（C/C++）或 new、delete（C++）等操作进行分配和释放。

堆的大小通常较大，且可以动态调整。

访问速度相对较慢。

主要用于存储动态创建的对象、大型数据等。

三、python的使用

1、安装环境

（1）python开发工具包：Python Windows版本下载| Python中文网 官网

（2）在控制台输入python命令，若没有出现版本的提示，去找到Python的安装目录， 我的电脑图标，邮件，属性，高级系统设置，环境变量，Path，双击，新建，粘贴路径，确定，确定， 确定，重新打开CMD窗口测试

2、脚本与交互

（1）交互模式

打开CMD窗口，输入python，进入到python的交互模式，由于代码会随着窗口的关闭而消失，交互模式一般是用于测试

（2）脚本模式

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

打开CMD窗口，进入到代码目录路径，python XXX.py 运行该文件

四、python的基础知识

1、基本数据

（1）常量

不能够改变的量：整数常量，小数常量，字符串常量，布尔值常量，复数常量

（2）标识符

程序员自己定义的一些名称，如变量，函数，类

规则：

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

数字不能开头

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

规范：

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

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

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

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

（3）关键字

一些已经被赋予价值的标识符，不能随便使用

可通过 keyword.kwlist 命令来查看目前有多少关键字

（4）内置函数名/类名

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

（5）注释

单行注释 # 后面就是注释的内容 直到换行为止

多行注释 """ 中间多行注释 """

（5）变量

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

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

2、数据转换

（1）数据类型转换

int()： 将其他有效的数据转为整数（取整 ，从字符串中解析整数）

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

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

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

（2）进制转换

bin()： 转二进制字符串

oct()： 转八进制字符串 

hex()： 转十六进制字符串

bin("123")：参数必须是整数

（3）字符与ASCII码转换

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

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

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

（4）常见的数学计算

abs()：取绝对值

pow()： 求a 的 b 次幂

max()：求最值问题

round()：四舍五入

（5）输入与输出

输入：input()，默认输入的是一个字符串(整行)

eval的使用：input（）前加个eval（），如num = eval（input（））

处理一行内多个数据的输入

eval处理的数据必须要有逗号分隔

 eval自动处理字符串解析

eval既可以处理单值 也可以处理多值

输出：print()，中间可代两个参数一个是 sep默认值是‘ ’，还有一个是 end默认值是”\n“换行 

（6）运算符

算数运算符：

加法：数值相加，序列拼接

减法：数值相减

乘法：数值相乘，序列增倍

除法：小数除 /，整数除 // （整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为0））

幂运算：**来进行标识

取余：10 / 3 = 3 ~ 1

布尔判断运算符（python当中比较的是具体的值）：

运算结果一律为布尔值： 大于 小于 大于等于 小于等于 不等于 等于（Python允许连续比较）

注：在Python当中 只有-5~256 Python会自动创建这些数据对象，这可能会导致地址相同

增强型赋值运算符：

+= -= *= /= //= **= %= （但是python中不存在++ -- 这种自增运算符）

逻辑运算符：

与 或 非 = and or not （&& || !）

与：全真则真 有假则假

或：有真则真 全假则假

非：取反

& 与 &&的区别：&无论左边是否为假 右边都要计算，&&如果左边是假 右边不计算

位运算符：

&按位与：把两个数值转换成二进制，再一位对应一位进行对比，相同则输出1，不同为0，这样出一个新的二进制的数，再转换回十进制

如：

>>> 13 & 7

5

1101

0111

0101 = 5

|按位或：把两个数值转换成二进制，再一位对应一位进行对比，有1则输出1，都为0则输出0，这样出一个新的二进制的数，再转换回十进制

右移：把需要移动的数值先转换成二进制，然后根据需要移动的位数把右侧的部分数移除，得到一个新的二进制，再转换成十进制

如：

>>> 16 >> 2

4

10000

100|00

100 = 4

16 / 2 ^ 2

左移：把需要移动的数值先转换成二进制，然后根据需要移动的位数把左侧的部分数移除，得到一个新的二进制，再转换成十进制

~取反：符号取反再减一

如：

>>> ~15

-16

01111 = 15

10000 = -16

^ 异或：相等为假 不同为真

如：

>>> 13 ^ 7

10 

1101

0111

1010 = 10

变量交换值的几种方法：

依靠一个中间值：

a = 1

b = 3

temp = a

a = b

b = temp

a, b = b, a # Python自带的交换特点

只针对整数 ：

a = 10

b = 100

a = a + b # 110

b = a - b # 10

a = a - b # 100

# 只针对整数：

a = a ^ b b = a ^ b a = a ^ b

成员运算符：判断一个元素是否在另一个序列中

in 和 not in

从属/身份运算符：判断两个变量指向的对象是否是同一个对象（比地址）

is 和 not is

注：之前说过python中有个预留的整数区间的地址是固定的 -5~256

（7）运算符优先级

由上到下对应的优先级从高到底

幂运算 **

取反、正号、负号 ~ + -

乘、除、取模、取整除 * / % //

加法、减法 + -

右移、左移 >> <<

与 &

异或、或 ^ |

比较运算符 <= < > >=

是否等于、是否不等于 == !=

赋值运算符 = %= /= //= -= += *= **=

身份运算符 is is not

成员运算符 in not in

五、列表与字符串

序列：存储一堆数据的集合或容器

列表、字符串、元组、集合、字典

1、序列的通用操作

（1）通过索引、下标来查找、删除、增加数据

 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 print(arr[0])
 arr[-1]  #倒数第一个
 arr[-100]
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 IndexError: list index out of range  #越界了，下标为-100的位置没有值
 >>> arr[100]
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 IndexError: list index out of range

（2）切片：获取序列中的某一个连续的子区间

序列名[ a : b : c]跟range（a，b ，c）类似

>>> 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]

（3）连接和重复 + 和 *

arr = [1, 2, 3, 4]
arrs = [5, 6, 7, 8, 9]
arr1 = arr + arrs  # 1, 2, 3, 4, 5, 6, 7, 8, 9
arr2 = arr * 3  # 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4

（4）成员资格

>>> 1 in arr
 True
 >>> 10 in arr
 False

（5）长度和最值

>>> len(arr) # 获取序列的长度
9
 >>> len(arr)
 9
 >>> max(arr)
 9
 >>> min(arr)
 1
 >>> s = "ABC"
 >>> len(s)
 3
 >>> max(s)
 'C'
 >>> min(s)
 'A'

（6）常见的一些问题

创建问题

"""
列表
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])
 # 通过for each遍历
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
 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) 

2、排序算法

（1）选择排序

arr = [6, 2, 1, 3, 5, 7, 4, 8, 9]
 for i in range(len(arr) - 1): # -1 少比较1轮
     for j in range(i + 1, len(arr)):
         if arr[i] > arr[j]:
             arr[i], arr[j] = arr[j], arr[i]
 print(arr)

（2）冒泡排序

 arr = [6, 2, 1, 3, 5, 7, 4, 8, 9]
 for i in range(len(arr) - 1):# -1 少比较1轮
     for j in range(len(arr) - i - 1):
         if arr[j] > arr[j + 1]:
             arr[j], arr[j + 1] = arr[j + 1], arr[j]
 print(arr)

（3）插入排序

 arr = [6, 2, 1, 3, 5, 7, 4, 8, 9]
 """
 for i in range(1, len(arr)):
 j = i
 while j > 0 and arr[j - 1] > arr[j]:
 arr[j], arr[j - 1] = arr[j - 1], arr[j]
 j -= 1
 """
 # 优化后的插入排序
 for i in range(1, len(arr)):
     e = arr[i]
     j = i
     while j > 0 and arr[j - 1] > e:
         arr[j] = arr[j - 1]
         j -= 1
     arr[j] = e
 print(arr)

（4）计数排序

 arr = [8,2,1,4,8,7,9,2,3,4]
 minValue = min(arr)
 maxValue = max(arr)
 temp = [0] * (maxValue - minValue + 1)
 for i in range(len(arr)):
     temp[arr[i] - minValue] += 1
 k = 0
 for index in range(len(temp)):
     while temp[index] > 0:
         arr[k] = index + minValue
         k += 1
         temp[index] -= 1
 print(arr)

（5）希尔排序

（6）快速排序

（7）堆排序

（8）归并排序

（9）基数排序

（10）桶排序

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)

（2）插值查找

"""
插值查找适用于数据分布比较均匀的情况
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)

（3）斐波那契查找

4、列表对象函数

对象函数是区别于内置函数的，内置函数直接调用即可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]
 33 / 38
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)
 """

5、字符串对象函数

可变对象与不可变对象

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

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

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

>>> 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())
 36 / 38
print("     
print("     
print("   
ABC       
ABC       
A   
B   
".rstrip())
 ".strip()) # 两边都去掉连续空格
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)

6、math模块

>>> import math
>>> dir(math)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

（1）math模块的常量

math.e  :返回欧拉数（2.7182...）

math.inf:返回正无穷大浮点数

math.nan:返回浮点值 NaN (not a number)

math.pi:π 一般指圆周率。 圆周率 PI (3.1415...)

math.tau:数学常数 τ = 6.283185...，精确到可用精度。Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。

（2）math模块的一些常用的方法

math.acos(x):  返回 x 的反余弦，结果范围在 0 到 pi 之间。

math.acosh(x): 返回 x 的反双曲余弦值。

math.asin(x): 返回 x 的反正弦值，结果范围在 -pi/2 到 pi/2 之间。

math.asinh(x): 返回 x 的反双曲正弦值。

math.atan(x):返回 x 的反正切值，结果范围在 -pi/2 到 pi/2 之间。 

math.atan2(y，x): 返回给定的 X 及 Y 坐标值的反正切值，结果是在 -pi 和 pi 之间。

math.tanh(x): 返回 x 的反双曲正切值。

math.ceil(x): 将 x 向上舍入到最接近的整数

math.comb(n，k): 返回不重复且无顺序地从 n 项中选择 k 项的方式总数。

math.copysign(x，y): 返回一个基于 x 的绝对值和 y 的符号的浮点数。

math.degrees(x): 将角度 x 从弧度转换为度数。

math.fabs(x): 返回 x 的绝对值。

math.floor(x): 将数字向下舍入到最接近的整数

math.pow(x，y): 将返回 x 的 y 次幂。

math.log(x，[base]): 使用一个参数，返回 x 的自然对数（底为 e ）。

7、random模块

（1）简介

Python标准库中的random函数，可以生成随机浮点数、整数、字符串，甚至帮助你随机选择列表序列中的一个元素，打乱一组数据等。

（2）random模块重要函数

random()： 返回0<=n<1之间的随机实数n

choice(seq)： 从序列seq中返回随机的元素

getrandbits(n)： 以长整型形式返回n个随机位

shuffle(seq[, random])： 原地指定seq序列

sample(seq, n)： 从序列seq中选择n个随机且独立的元素

（3）random模块方法

random.random()函数是这个模块中最常用的方法了，它会生成一个随机的浮点数，范围是在0.0~1.0之间。
random.uniform()正好弥补了上面函数的不足，它可以设定浮点数的范围，一个是上限，一个是下限。
random.randint()随机生一个整数int类型，可以指定这个整数的范围，同样有上限和下限值。
random.choice()可以从任何序列，比如list列表中，选取一个随机的元素返回，可以用于字符串、列表、元组等。
random.shuffle()如果你想将一个序列中的元素，随机打乱的话可以用这个函数方法。
random.sample()可以从指定的序列中，随机的截取指定长度的片断，不作原地修改。

 1 import random
 2  
 3 print(random.random()) #[0,1)----float    大于等于0且小于1之间的小数
 4  
 5 print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数
 6  
 7 print(random.randrange(1,3)) #[1,3）    大于等于1且小于3之间的整数（左开右闭）可指定步长
 8  
 9 print(random.choice([1,'23',[4,5]]))   #1或者23或者[4,5]
10  
11 print(random.sample([1,'23',[4,5]],2)) #列表元素任意2个组合
12  
13 print(random.uniform(1,3)) #大于等于1小于等于3的小数，如1.927109612082716 
14  
15  
16 item=[1,3,5,7,9]
17 random.shuffle(item) #打乱item的顺序,相当于"洗牌"
18 print(item)