标签：范围 pow any ace 英文 module dig floor 需要
Python 语言遵循 GPL(GNU General Public Licence) 协议。
GPL 指的是GNU通用公共许可协议，该协议通过提供给作者软件版权保护和许可证保障作者的权益
查看关键字。
help("keywords")
关键字如下:(注:复制代码只复制上一行代码即可，下面为输出结果)
False class from or
None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not
Python具有可扩展性，能够导入使用 C/C++ 语言编写的程序，从而提高程序运行速度。
Python具有可嵌入性，可以把Python程序嵌入到 C/C++ 程序中。
Python支持 GUI 编程，提供多个图形开发界面的库，如 Tkinter ，wxPython ，Jython 等。
学了这么久,tkinter 接触的要明显多余 Jython 和 wxPython ..
在 Windows 中设置环境变量时，打开命令提示框，输入：
path %path%;python的安装目录
Python 的重要环境变量：
PYTHONPATH：使用 import 语句后会从该环境变量进行寻找。
PYTHONSTARTUP：在 Python 启动后，会执行此文件中变量指定的执行代码。
PYTHONCASEOK：写在这里面的环境变量，在导入时模块不区分大小写。
PYTHONHOME：通常存在于 PYTHONSTARTUP 和 PYTHONPATH 目录中，便于切换模块库。
使用 Python 在命令提示符中运行 .py 程序
python 文件名.py 参数 参数
补充:
参数可以使用 sys.args 进行获取
但是是从第2个开始进行获取参数
python2 中使用
#-*-coding:UTF-8-*-
对中文进行编码
以单个下划线开头的变量或方法 _temp ，表示不能够直接访问的类属性，需要通过类提供的接口(函数)进行访问。
当使用 from xx import * 时，_temp不能够被导入。使用者不应该访问 _temp 的变量或方法。
以两个下划线开头的变量 __temp ，可以通过类提供的接口(函数)进行访问。
使用了__xxx 表示的变量或方法，实际上是实现了 名称转写 机制。
__temp 会被转写成 _classname__temp ，避免了使用者的错误访问。
使用 __temp 的类，在被子类继承时，能够避免子类中方法的命名冲突。
定义子类时，往往会使用到父类的 __init__构造方法，实际上为了避免冲突，调用的是_父类名 _initalize() 方法。
输出关键字的另一种方式
import keyword
print(keyword.kwlist)
[‘False‘, ‘None‘, ‘True‘, ‘and‘, ‘as‘, ‘assert‘, ‘async‘, ‘await‘, ‘break‘,
‘class‘, ‘continue‘, ‘def‘, ‘del‘, ‘elif‘, ‘else‘, ‘except‘, ‘finally‘,
‘for‘, ‘from‘, ‘global‘, ‘if‘, ‘import‘, ‘in‘, ‘is‘, ‘lambda‘, ‘nonlocal‘,
‘not‘, ‘or‘, ‘pass‘, ‘raise‘, ‘return‘, ‘try‘, ‘while‘, ‘with‘, ‘yield‘]
类方法和静态方法在使用装饰器方面(好久没有使用了,有点生疏了)
@classmethod
def eat(cls):
pass
@staticmethod
def eat():
pass
关于 finally 语句,最后一定会执行的问题,有一些遗忘
# 使用 try 语句
try :
pass
except Exception as e:
pass
finally:
pass
使用 ctime 获取当前时间
from time import ctime
print("{}".format(ctime()))
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
print("pi = %.*f" % (3,pi)) #用*从后面的元组中读取字段宽度或精度
# pi = 3.142
print(‘%010.3f‘ % pi) #用0填充空白
# 000003.142
print(‘%-10.3f‘ % pi) #使用 - 号左对齐
# 3.142
在 Python 中，变量不一定占用内存变量。变量就像是对某一处内存的引用，可以通过变量访问到其所指向的内存中的值，
并且可以让变量指向其他的内存。在 Python 中，变量不需要声明，但是使用变量之前，一定要先对变量进行赋值。
当创建了一个新对象时，Python 会向操作系统请求内存，Python 本身实现了内存分配系统。变量类型指的是变量所指向的内存中 对象 的类型。
Python 中变量赋值使用 = 等号，等号左面为创建的变量，等号右面为需要的值。
变量包含的内容主要包含四个方面：
1.变量的名称：在对变量赋值时也就是创建变量时所使用的名字。注：根据标识符规则。
2.变量保存的数据：通常为赋值时 = 等号 右面的对象。
对象主要包括：
①.数字：int 、float 、complex 、bool、表达式、函数调用返回值等。
数字: int 表示整数，包含正数，负数，0
float 表示浮点数，带有小数点的数
complex 表示复数，实部 + 虚部 J 或 j 均可
bool 布尔类型，True 为真，False 为假
②.字符串：字符串变量、带有" "的字符串、表达式、函数调用的返回值等。
注：Python3 以 Unicode 编码方式编码。
使用双引号 " " 或单引号 ‘ ‘ 创建字符串或者进行强制转换 str 。
③.列表：列表变量、带有 [ ] 的对象、表达式、函数调用的返回值等。
使用了 [ ] 的，[ ] 内可以是数字，字符串，字典，元组，列表，集合，表达式等。
④.元组：元组变量、带有逗号的或被( )包围的多个变量或值、表达式、函数调用的返回值等。
空元组 ( )
创建一个只包含数字 1 的元素的元组 (1,) 注：一定要带有 ， 号
创建包含多个元素的元组，可以直接用 (元素1，元素2，...，元素n) 赋值
或者元素1，元素2，...，元素n ，使用，逗号进行赋值
⑤.集合：空集合 set( )、使用了{ }的内部为单个变量或值、表达式、函数调用的返回值等。
空集合 set( )
创建多个元素的集合，{元素1，元素2，...，元素n}
注：集合中元素不重复，可利用此特性判断别的序列对象是否存在重复元素。
⑥.字典：字典变量、带有 {键:值} 的变量或值、表达式、函数调用的返回值等。
空字典 { }
创建多个元素的字典，变量名 = {键1:值1,键2:值2,...,键n:值n}
⑦.类：通常为类创建实例时，函数调用的返回值等。
class关键字声明。
⑧.函数：函数名、函数调用等。
def 关键字声明，在函数前可能会有装饰器。另外，函数可以嵌套函数，当内部函数使用了外部函数的某些对象时称为闭包函数。
注:表达式是指关于对象之间的运算。
变量的地址，也就是所指向的内存中的地址。使用 id(变量名) 函数获取。
# 查看 a 的内存地址
a = 123
print(id(a))
# 140734656708688
字典： {键 : 值} 对的元素的集合。字典内部的元素是无序的，通过键来获取键所对应的值。字典中的键是不能够改变的，并且是唯一的。
# 创建一个元素的集合，可以不使用 ，
set_2 = {1}
print(set_2)
# {1}
print(type(set_2))
# <class ‘set‘>
set_3 = {1,}
print(set_3)
# {1}
print(type(set_3))
# <class ‘set‘>
集合中不能包含列表和字典对象
# 负数
num_int_3 = -226
print(type(num_int_3))
# <class ‘int‘>
# 扩大100倍
num_float_3 = 2.5e2
print(num_float_3)
# 250.0
print(type(num_float_3))
# <class ‘float‘>
关于复数 0 进行隐藏问题
num_complex_3 = 3.j
print(num_complex_3)
# 3j
print(type(num_complex_3))
# <class ‘complex‘>
num_complex_4 = .6j
print(num_complex_4)
# 0.6j
print(type(num_complex_4))
# <class ‘complex‘>
有时判断条件是否成立使用 not True
比如说某一个元素不在列表中使用 not in
Unicode码：主要有三种，分别为 utf-8、utf-16、utf-32。utf-8 占用一到四个字节，utf-16 占用二到四个字节，utf-32 占用四个字节。
Python 在访问时，使用方括号 [ 索引位置 ] ,进行访问。字符串可以进行拼接操作，就是将两个字符串进行拼接，然后产生新的字符串。可以进行切片操作 [ : ] ,(注:左闭右开)。
列表可以进行增加元素、删除元素、查询是否存在该元素、修改某一位置上的元素、查看列表的长度、确定最大最小元素以及对列表排序等。有时候，还可以通过强制转换修改元组。
Python 的元组与列表类似。元组使用小括号 ( ) 包含数据。元组可以通过索引下标进行访问元组中的值。元组中的值不是允许修改的，但是可以对元组进行拼接。
# 创建只包含一个元素的元组
tuple_2 = (1,)
print(type(tuple_1))
# <class ‘tuple‘>
# 创建包含多个元素的元组
tuple_4 = 7,8,9
print(tuple_4)
# (7, 8, 9)
print(type(tuple_4))
# <class ‘tuple‘>
字典创建之后，可以使用 字典名[‘键名‘] 进行访问。
增加字典元素，可以直接使用 字典名[‘新的键‘] = 新的值
使用 del 可以将字典元素进行删除。
可以对字典求长度，强制转换，拷贝字典等操作。
注：当后来又添加了新的键，而原来有同名的键时，以后来的为准。
在字典中创建键值对,没有写明: 时,创建的是值
dic = {‘a‘:123,888:‘n‘,(4,5):[7,8]}
dic.keys()
# dict_keys([‘a‘, 888, (4, 5)])
dic.values()
# dict_values([123, ‘n‘, [7, 8]])
# 使用 dict 转化为字典
dic = dict(zip([‘a‘,‘b‘,‘c‘],[4,5,6]))
print(dic)
# {‘a‘: 4, ‘b‘: 5, ‘c‘: 6}
Python中的数据类型可以进行相互转换：
1.将 float 浮点型转化成 int 长整型。int( )
2. 将 2,3 转化为复数。complex(实部,虚部)
3.将数字、列表、元组、字典转化为字符串类型。str( ) , json.dumps(字典)
4.将字符串转化为数字类型。eval( )
5.将列表转化成元组。tuple( )
6.将元组转化成列表。list( )
7.将列表转化成集合，用来消除多余重复元素。set( )
8.将字符串转化为集合元素。set( )
9.将整数转化为字符。 chr( )
10.将字符转化为整数。ord( )
11.将十进制整数转化为十六进制数。hex( )
12.将十进制整数转化为八进制数。 oct( )
# 将整数转化为字符。
print(chr(65))
# A
print(chr(90))
# Z
print(chr(97))
# a
print(chr(122))
# z
# 将字符转化为整数。
print(ord(‘A‘))
# 65
# 将十进制整数转化为十六进制数。
print(hex(17))
# 0x11
# 将十进制整数转化为八进制数。
print(oct(9))
# 0o11
Python算术运算符。
算术运算符：
+ ：两个对象相加。
－：得到负数 或 前一个数减去后一个数。
* ： 两个数进行相乘 或 重复字符串元素、列表元素、元组元素。
/ ： 前一个数对后一个数进行除法操作，返回浮点数类型。
%： 取模，返回前一个数除去后一个数的余数。
** ： 返回前一个数的后面数次幂。
// ： 前一个数对后一个数整除，返回整数部分。
Python 比较运算符，多用于条件判断语句 if 中，返回值为 True (真)或 False (假)：
== ： 等于，比较两个对象的值是否相等。
！= ： 不等于，比较两个对象的值是否不相等。
> ： 大于，前面一个数是否大于后面的数。
< ： 小于，前面一个数是否小于后面的数。
>= ： 大于等于，前面的是是否大于等于后面的数。
<=： 小于等于，前面的数是否小于等于后面的数。
Python赋值运算符：
= ： 赋值运算符
+= ： 加法赋值运算符
-= ： 减法赋值运算符
*= ： 乘法赋值运算符
/= ： 除法赋值运算符
%= ： 取模赋值运算符 ，当前面的数小于后面的数时，返回前一个数本身(数大于 0)。
**= ： 幂赋值运算符
//= ： 取整赋值运算符
注：a 符号等于 b 等价于 a 等于 a 符号 (b)
# *= 乘法赋值运算符
a = 4
b = 5
a *= b #等价于 a = a * (b)
print("a = {0} , b = {1} ".format(a,b))
# a = 20 , b = 5
# /= 除法赋值运算符
a = 4
b = 5
a /= b #等价于 a = a / (b)
print("a = {0} , b = {1} ".format(a,b))
# a = 0.8 , b = 5
# %= 取模赋值运算符
a = 4
b = 5
a %= b #等价于 a = a % (b)
print("a = {0} , b = {1} ".format(a,b))
# a = 4 , b = 5
a = 6
b = 4
a %= b #等价于 a = a % (b)
print("a = {0} , b = {1} ".format(a,b))
# a = 2 , b = 4
# **= 幂赋值运算符
a = 4
b = 2
a **= b #等价于 a = a ** (b)
print("a = {0} , b = {1} ".format(a,b))
# a = 16 , b = 2
# //= 取整赋值运算符,返回整数
a = 4
b = 3
a //= b #等价于 a = a // (b)
print("a = {0} , b = {1} ".format(a,b))
# a = 1 , b = 3
Python位运算符：将 int 长整型数据看做二进制进行计算，主要是将前面的数和后面的数的对应位置上的数字 0，1 进行判断。
& 按位与：如果对应位置上的两个数都为 1，那么得到的该结果的该位置上也为 1 。其他情况都为 0。
| 按位或：如果对应位置上的两个数有一个为 1 或都为 1，则得到的该结果的该位置上也为 1 。其他情况都为 0。
^ 按位异或：如果对应位置上的两个数为 0 和 1 或 1 和 0，则得到的该结果的该位置上也为 1 。其他情况都为 0。
~ 按位取反：如果~后面为正数或 0，则结果为-(数+1)，
如果后面的数为负数，则结果为-(负数(带符号)+1)。
<< 左移运算符：将前面的数乘以 2 的(后面的数) 次幂。
>> 右移运算符：将前面的数除以 2 的(后面的数) 次幂。
# ~ 按位取反：如果后面的为正数，则结果为-(正数+1)
print(~2)
# -3
# 如果后面的数为负数，则结果为-(负数(带符号)+1)。
print(~(-5))
# 4
注意返回的是对象,不是True 和 False
Python逻辑运算符：
and 布尔‘与’： 当左面的对象为真时，返回右面的对象。
当左面的对象不为真时，返回左面的对象。
or 布尔‘或’： 当左面的对象为真时，返回左面的对象。
当左面的对象不为真时，返回右面的对象。
not 布尔‘非‘： 如果后面的对象为True，则返回False。否则返回True。
Python成员运算符：
in：如果左面的对象在右面的对象中，则返回 True，不在则返回 False。
not in：如果左面的对象不在右面的对象中，则返回 True，在则返回 False。
a = ‘a‘
d = ‘d‘
dic = {‘a‘:123,‘b‘:456,‘c‘:789}
# 判断 a 是否在 dic 中
# 字典主要是看,是否存在该键
print(a in dic)
# True
# 判断 d 是否在 s 中
print(d in dic)
# False
a = ‘a‘
d = ‘d‘
strs = ‘abc‘
# 判断 a 是否不在 strs 中
print(a not in strs)
# False
# 判断 d 是否不在 strs 中
print(d not in strs)
# True
Python身份运算符：
is ：判断左右两个对象内存地址是否相等。
is not ：判断左右两个对象内存地址是否不相等。
注：对于不可变类型数据，当引用自相同数据时，is 返回值为 True 。
数字、字符串、元组。
对于可变类型数据，当引用自相同数据时，is not 返回值为 True 。
列表、字典、集合。
# 对于不可变类型数据，引用自相同数据时，is 为真
# 数字
num = 123
num_two = 123
# 输出 num 和 num_two 的地址
print("num地址为:{0},num_two地址为:{1}".format(id(num),id(num_two)))
# num地址为:140729798131792,num_two地址为:140729798131792
print(num is num_two)
# True ,num 和 num_two 指向同一块内存地址
print(num is not num_two)
# False
# 对于可变类型，即使引用自相同数据，内存地址也不相同。is not 为 True
# 列表
lst = [1,2,3]
lst_two = [1,2,3]
# 输出 lst 和 lst_two 的地址
print("lst地址为:{0},lst_two地址为:{1}".format(id(lst),id(lst_two)))
# lst地址为:2781811921480,lst_two地址为:2781811921992
print(lst is lst_two)
# False
print(lst is not lst_two)
# True
Python运算符优先级（从高到低、有括号则最先算括号）：
** ：指数
~ 按位取反
* 乘法、/ 除法、% 取模、// 整除
+ 加法、- 减法
>> 右移运算、<< 左移运算
& 按位与
^ 按位异或、| 按位或
<= 小于等于、< 小于、> 大于、>= 大于等于
== 是否相等、!= 是否不相等
= 赋值、%= 取模赋值、/= 除法赋值、//= 整除赋值、-= 减法赋值、+= 加法赋值、*= 乘法赋值、**= 幂赋值
is 是、is not 不是 引用自同一地址空间
in 是否在、not in 是否不在
not 非、and 与、or 或
条件语句的几种情况
第一种：
‘‘‘
if 条件1:
条件1满足时，需要运行的内容
‘‘‘
第二种：
‘‘‘
if 条件1:
条件1满足时，需要运行的内容
else:
条件1不满足时，需要运行的内容
‘‘‘
第三种：
‘‘‘
if 条件1:
条件1满足时，需要运行的内容
elif 条件2:
条件1不满足时，条件2满足，需要运行的内容
‘‘‘
第四种：
‘‘‘
if 条件1：
当条件1满足时，需要运行的内容
elif 条件2：
当条件1不满足，满足条件2时，需要运行的内容
...
elif 条件n:
前面的 n-1 条条件都不满足，第n条条件满足，需要运行的内容
else:
前面的所有条件都不满足时，需要运行的内容
‘‘‘
在 if 中常用的操作运算符：
< 小于、<= 小于等于、> 大于、>= 大于等于、== 等于、!= 不等于
注：可以配合 and、or、not 进行混合搭配。
Python 中的循环包括 for 循环和 while 循环。
while 循环，当给定的判断条件为 True 时，会执行循环体，否则退出循环。(可能不知道具体执行多少次)
for 循环，重复执行某一块语句，执行 n 次。
在 Python 中可以进行嵌套使用循环。while 中包含 for ，或 for 包含 while。
Python循环控制语句：主要有三种，break、continue 和 pass 语句。
break 语句 ：在语句块执行过程中，终止循环、并跳出整个循环。
continue 语句 ：在语句执行过程中，跳出本次循环，进行下一次循环。
pass 语句 ：空语句，用来保持结构的完整性。
Python while循环语句（代码块中要有使判断条件不成立的时候、否则会陷入无限循环）：
第一种结构：
‘‘‘
while 判断条件:
一行语句 或 多行语句组
‘‘‘
第二种结构、else 表示只有程序正常运行才会进行使用的代码块：
‘‘‘
while 判断条件:
一行语句 或 多行语句组
else:
一行语句 或 多行语句组
‘‘‘
Python 无限循环：在 while 循环语句中，可以通过让判断条件一直达不到 False ，实现无限循环。
Python while 循环中使用 else 语句：
else：表示 while 中的语句正常执行完，然后执行 else 语句的部分。
示例：
while 判断条件:
一行语句 或 多行语句组
else:
一行语句 或 多行语句组
Python for 循环语句：遍历任何序列的项目，可以是字符串、列表、元组、字典、集合对象
for 中的 else 依旧为正常执行之后会进行输出的代码块
第一种：
‘‘‘
for 迭代对象 in 序列:
代码块(一行语句或多行代码)
‘‘‘
第二种：
‘‘‘
for 迭代对象 in 序列:
代码块(一行语句或多行代码)
else:
代码块(一行语句或多行代码)
‘‘‘
Python for 循环通过序列索引迭代：
注：集合 和 字典 不可以通过索引进行获取元素，因为集合和字典都是无序的。
使用 len (参数) 方法可以获取到遍历对象的长度。
使用 range 方法（左闭右开）：
range 函数参数如下，起始位置、终止位置(不包含)、步长。
注：起始位置默认为 0 。
步长可以为负，默认为 1。
lst = [i for i in range(5)]
print(lst) # 起始位置默认为 0
# [0, 1, 2, 3, 4]
lst = [i for i in range(1,5)]
print(lst) # 不包含终止位置
# [1, 2, 3, 4]
lst = [i for i in range(1,5,2)]
print(lst) #步长可以根据自己需要进行更改
# [1, 3]
lst = [i for i in range(-5,-1,1)]
print(lst) # 起始位置和终止位置可以为负
# [-5, -4, -3, -2]
通过序列索引进行迭代操作程序：
字符串：
strs = "Hello World."
for i in range(len(strs)):
print(strs[i],end = " ")
# H e l l o W o r l d .
Python循环嵌套：将 for 循环和 while 循环进行嵌套。
示例：
while 循环嵌套 for 循环：
while True:
for i in range(3):
print("while 和 for 进行嵌套")
break
# while 和 for 进行嵌套
# while 和 for 进行嵌套
# while 和 for 进行嵌套
for 循环嵌套 while 循环、不推荐进行使用：
a = 1
for i in range(3):
while a < 3:
print("while 和 for 进行嵌套")
a += 1
# while 和 for 进行嵌套
# while 和 for 进行嵌套
关于 break 的理解
Python break语句：当运行到 break 语句时，终止包含 break 的循环语句。
注：无论判断条件是否达到 False 或 序列是否遍历完都会停止执行循环语句和该 break 下的所有语句。
当使用循环嵌套时，break 语句将会终止最内层的 while 或 for 语句、然后执行外一层的 while 或 for 循环。
lst = [7,8,9,4,5,6]
for i in range(len(lst)):
if lst[i] == 4:
print("循环终止")
break #终止循环语句
print(lst[i],end = " ")
# 7 8 9 循环终止
关于 continue 的理解
当执行到 continue 语句时，将不再执行本次循环中 continue 语句接下来的部分，而是继续下一次循环
lst = [7,8,9,4,5,6]
for i in range(len(lst)):
if lst[i] == 9:
continue
#当运行到 continue 语句时，不执行本次循环中剩余的代码，而是继续下一层循环
print(lst[i],end = " ")
# 7 8 4 5 6
Python pass语句：空语句，主要用于保持程序结构的完整性 或者 函数想要添加某种功能，但是还没有想好具体应该怎么写。
Python数字类型转换：
int(x)：将 x 转换为一个整数
float(x)：将 x 转换为一个浮点数
complex(x,y)：将 x 和 y 转换为一个复数。x 为复数的实部，y 为复数的虚部。
eval(x)：将 x 转化为一个整数
chr(x)：x 为数字，将数字转化为对应的 ASCII 码。 65 -> A 、90 -> Z
ord(x)：x 为单个字符，将字符转换为对应的整数。 a -> 97、122 -> z
# 将 2,3 转化为复数
num_complex = complex(2,3)
print(num_complex)
# (2+3j)
print(type(num_complex))
# <class ‘complex‘>
Python数学函数
abs(x)
返回数字的绝对值，如abs(-10) 返回 10
math.ceil(x)
返回数字的上入整数，如math.ceil(4.1) 返回 5
math.exp(x)
返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)
返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)
返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)
如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)
返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)
返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)
返回给定参数的最小值，参数可以为序列。
modf(x)
返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)
x**y 运算后的值。
round(x [,n])
返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)
返回数字x的平方根。
# math.floor(x) 返回比 x 稍小的整数
print(math.floor(-5.9),math.floor(8.6))
# -6 8
# math.modf(x) 返回 x 的整数部分与小数部分，
# 两部分的数值符号与x相同，整数部分以浮点型表示。
print(math.modf(-5.9),math.modf(8.6))
# (-0.9000000000000004, -5.0) (0.5999999999999996, 8.0)
# math.round(x[,n]) # n 为保留的位数，将 x 进行四舍五入输出
print(round(-5.984,2),round(8.646,2))
# -5.98 8.65
# math.log(x) log 以 e 结尾，e 的 返回值 为 x
print(math.log(math.e),math.log(math.e ** 2))
# 1.0 2.0
Python随机数函数：
choice(seq)
从序列的元素中随机选出一个元素
randrange ([start,] stop [,step])
从指定范围内，在指定步长递增的集合中 获取一个随机数，步长默认为 1 。注：不包含 stop 值
random()
随机生成下一个实数，它在[0,1)范围内。
shuffle(lst)
将序列的所有元素随机排序，返回值为 None
uniform(x, y)
随机生成下一个实数，它在[x,y]范围内。
python 三角函数
math.sin(x)
返回的x弧度的正弦值。
math.asin(x)
返回x的反正弦弧度值。
math.cos(x)
返回x的弧度的余弦值。
math.acos(x)
返回x的反余弦弧度值。
math.tan(x)
返回x弧度的正切值。
math.atan(x)
返回x的反正切弧度值。
math.degrees(x)
将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
math.radians(x)
将角度转换为弧度
math.hypot(x, y)
返回 sqrt(x*x + y*y) 的值。
import math
# π/2 的正弦值
print(math.sin(math.pi/2))
# 1.0
# 1 的反正弦值
print(math.asin(1))
# 1.5707963267948966 π/2
# π 的余弦值
print(math.cos(math.pi))
# -1.0
# -1 的反余弦值
print(math.acos(-1))
# 3.141592653589793
# 四分之三 π 的正切值
print(math.tan(math.pi*3/4))
# -1.0000000000000002
# 使用 math.degrees(x) 函数查看 四分之一 π 的角度
print(math.degrees(math.pi/4))
# 45.0
# 使用 math.radians(x) 函数查看 135° 对应的弧度制
print(math.radians(135))
# 2.356194490192345
print(math.pi*3/4)
# 2.356194490192345
# math.hypot(x, y) 查看 sqrt(x*x + y*y) 的值
print(math.hypot(3,4))
# 5.0
print(math.hypot(6,8))
# 10.0
print(math.sqrt(6*6 + 8*8))
# 10.0
Python数学常量：
math.pi：π
math.e：自然常数 e
# lg 函数中求值
a = math.e
b = math.e ** 5
print("ln(a)的值为:",math.log(a))
# ln(a)的值为: 1.0
print("ln(b)的值为:",math.log(b))
# ln(b)的值为: 5.0
Python创建字符串：
一般情况下可以使用 ‘ 或 " 创建字符串 或 使用引用字符串变量 或 字符串表达式。
# 使用字符串表达式进行赋值
a = ‘ABCD‘
b = ‘EFG‘
c = a + b
print(c)
Python访问字符串中的值：
1.可以使用索引下标进行访问，索引下标从 0 开始：
# 使用索引下标进行访问，索引下标从 0 开始
strs = "ABCDEFG"
print(strs[0])
# A
2.使用切片操作获取字符串：
示例：[start:stop:step]
start ：需要获取的字符串的开始位置，默认为 0 。(通常可以不写)
stop ：需要获取的字符串的结束位置 的后一个位置。
step ：步长，默认为 1 、当 start 大于 stop 时，step 为负数。
# 使用[start:stop:step]切片操作获取字符串
strs = "ABCDEFG"
print(strs[:4])
# ABCD
print(strs[:4:2])
# AC
print(strs[2:6])
# CDEF
print(strs[2:6:2])
# CE
# 不包含结束位置
print(strs[6:2:-1])
# GFED
print(strs[6:2:-2])
# GE
3.通过 for 循环进行获取字符串：
strs = "ABCDEFG"
for i in strs:
# 其中 i 为字符串中的单个字母
# 注:此时的 i 不要用做索引下标
print(i,end =" ")
# A B C D E F G
Python字符串更新：截取字符串的某一部分 和 其他字符串进行拼接。
注：可以修改字符串的值，但修改的不是内存中的值，而是创建新的字符串。
1.使用字符串常量进行更新：
# 使用字符串常量
strs = "hello,hey"
print(strs[:6] + "world.")
# hello,world.
2.使用切片操作(不包含结尾 stop)进行更新：
strs = "hello,hey"
py = "Tom,Jerry"
s_2 = strs[:5] + py[3:]
print(strs[:5])
# hello
print(py[3:])
# ,Jerry
print("更新后的字符串:",s_2)
# 更新后的字符串: hello,Jerry
修改字符串：
# 修改字符串,将 world 修改为 python
strs = "hello，world"
strs = strs[:6] + "python"
print("更新后的字符串:{0}".format(strs))
# 更新后的字符串:hello，python
Python转义字符：当需要在字符串中使用特殊字符时，使用 \ 转义字符。
注：转义字符在字符串中，注释也是字符串类型。
\(在行尾时):续行符
\\ :反斜杠符号
\‘ :单引号
\" :双引号
\a :响铃
\b :退格(Backspace)
\000:空
\n :换行
\v :纵向制表符
\t :横向制表符
\r :回车
Python字符串运算符：
+ ：连接左右两端的字符串。
* ：重复输出字符串。
[ ] ：通过索引获取字符串中的值。
[start:stop:step]：开始，结束位置的后一个位置，步长。
in ：判断左端的字符是否在右面的序列中。
not in：判断左端的字符是否不在右面的序列中。
r/R ：在字符串开头使用，使转义字符失效。
Python字符串格式化：
字符串中符号：
%c ：单个字符
%s ：字符串
%d ：整数
%u ：无符号整数
%o ：无符号八进制数
%x ：无符号十六进制数
%X ：无符号十六进制数（大写）
%f ：浮点数，可指定小数点后的精度
%e ：对浮点数使用科学计数法，可指定小数点后的精度。%E 与 %e 作用相同
%g ：%f 和 %e 的简写，%G 与 %g 作用相同
注：%o 为八进制（oct）、%x 为十六进制（hex）。
# %o 八进制数
num = 11
print("%o"%(num))
# 13 1*8**1 + 3*8**0 = 11
print(oct(11))
# 0o13
# %x 十六进制数
num = 18
print("%x"%(num))
# 12 1*16**1 + 2*8**0 = 18
print(hex(num))
# 0o12
# %e 科学计数法
num = 120000
print("%e"%(num))
# 1.200000e+05
print("%.2e"%(num))
# 1.20e+05
print("%E"%(num))
# 1.200000E+05
print("%.2E"%(num))
# 1.20E+05
# %g : %f 和 %e 的简写
num = 31415926
print("%g"%(num))
# 3.14159e+07
print("%G"%(num))
# 3.14159E+07
格式化操作符的辅助指令：
* ：定义宽度 或 小数点精度
- ： 左对齐
+ ： 使正数显示符号
<sp>：在正数前显示空格
# ：在八进制前显示 0 ，在十六进制前显示 0x 或 0X
0 ：显示的数字前面填充 ‘0‘
% ：%%输出单个%
(var) ：字典参数映射变量
m.n. ：m是显示的宽度，n 是小数点后的位数
Python三引号：多用作注释、数据库语句、编写 HTML 文本
UTF-8 编码将英文字母编码成一个字节，汉字通常是三个字节。适用于存在大量英文字符时，节省空间
Python字符串内建函数：
注：汉字属于字符（既是大写又是小写）、数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
1.capitalize( )：
将字符串第一个字母大写
# 使用 字符串.capitalize() 方法将字符串首字母大写
strs = ‘abc‘
print(strs.capitalize())
# Abc
2.center(width[,fillchar]) ：
让字符串在 width 长度居中，两边填充 fillchar 字符(默认是空格)
# center(width,fillchar)
# 使用 字符串.center() 方法，将字符串在 width 长度居中，两边补充 fillchar
strs = ‘abcdefgh‘
print(strs.center(20,‘-‘))
#------abcdefgh------
3.count(str,start=0,end=len(string))：
返回 str 在字符串从 start 到 end 范围内出现的次数(不包含end)。
# 使用 字符串.count(str) 方法，返回 str 在 字符串中出现的次数
strs = ‘abcdefghabcd‘
print(strs.count(‘c‘))
#2
# 使用 字符串.count(str) 方法，返回 str 在 字符串中出现的次数
strs = ‘abcdefghabcd‘ # a 的索引位置为 0,8
print(len(strs)) # 12
print(strs.count(‘a‘,2,8))
# 0
print(strs.count(‘a‘,2,9))
# 1
4.bytes.decode(encoding="UTF-8")：
将字节码转换为字符串
strs_bytes = b‘\xe6\xac\xa2\xe8\xbf\x8e‘
print(strs_bytes.decode(encoding=‘UTF-8‘))
# 欢迎
5.encode(encoding=‘UTF-8‘)：
将字符串转换为字节码
strs = ‘欢迎‘
print(strs.encode(encoding=‘UTF-8‘))
# b‘\xe6\xac\xa2\xe8\xbf\x8e‘
6.endswith(str[,start[,end]])：
判断字符串在 start 到 end 是否以 str结尾
# 字符串.endswith(str[,start[,end]])
strs = ‘ABCDEFG‘
print(strs.endswith(‘G‘))
# True
print(strs.endswith(‘F‘,0,6))
# True
7.expandtabs(tabsize = 4)：
将字符串中的 tab 符号转换为空格，tabsize 为替换的空格数
# 字符串.expandtabs(tabsize = 4)
# 将字符串中的 tab 符号转换为空格，tabsize 为替换的空格数
strs = ‘ABCD EFG‘
print(strs.expandtabs(tabsize = 4))
# ABCD EFG
8.find(str,start = 0,end = len(string))：
在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，否则返回 -1。
# find(str,start = 0,end = len(string))：
# 在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，否则返回 -1
strs = ‘ABCDEFG‘ #索引位置，从 0 开始
print(strs.find(‘E‘))
# 4
print(strs.find(‘K‘))
# -1
9.index(str,start = 0,end = len(string))：
在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，找不到则会报错。
# index(str,start = 0,end = len(string))：
# 在 start 到 end 范围内寻找 str 元素，如果找到则返回 str 元素的索引位置，找不到则返回-1。
strs = ‘ABCDEFG‘
print(strs.index(‘F‘))
# 5
10.isalnum( )：
如果字符串所有字符都是 字母 或者 数字 则返回 True，否则返回 False。
# isalnum( )：
# 如果字符串所有字符都是 字母 或者 数字 则返回 True，否则返回 False。
strs = ‘abcd123‘
print(strs.isalnum())
# True
strs = ‘好的‘
print(strs.isalnum())
# True
strs = ‘abc_‘
print(strs.isalnum())
# False
11.isalpha( )：
如果字符串中所有字符都是字母则返回 True，否则返回 False。
# isalpha( )：
# 如果字符串中所有字符都是字母则返回 True，否则返回 False。
strs = ‘ABCD汉字‘
print(strs.isalpha())
# True
strs_two = ‘ABCD123‘
print(strs_two.isalpha())
# False
12.isdigit( )：
如果字符串中所有字符都是数字则返回True，否则返回 False。
# isdigit( )：
# 如果字符串中所有字符都是数字则返回True，否则返回 False。
# 注: ① 也是数字
strs = ‘①②12‘
print(strs.isdigit())
# True
strs_two = ‘ABCD123‘
print(strs_two.isdigit())
# False
13.islower( )：
如果字符串中所有能够区分大小写的字符都是小写的，则返回True。否则返回 False。
# islower( )：
# 如果字符串中所有字符都是小写的，则返回True。否则返回 False。
strs = ‘abcd‘
print(strs.islower())
# True
strs_two = ‘abc123‘
print(strs.islower())
# True
strs_three = ‘Abcd‘
print(strs_three.islower())
# False
14.isnumeric( )：
如果字符串只包含数字字符，则返回 True。否则返回 False。
# isnumeric( )：
# 如果字符串只包含数字字符，则返回 True。否则返回 False。
strs = ‘123456‘
print(strs.isnumeric())
#True
strs_two = ‘½?123①②ⅡⅣ??‘
print(strs_two.isnumeric())
# True
strs_three = ‘abc123A‘
print(strs_three.isnumeric())
# False
15.isspace( )：
如果字符串只包含空格，则返回True。否则返回False。
# isspace( )：
# 如果字符串只包含空格，则返回True。否则返回False。
strs = ‘ ‘
print(strs.isspace())
# True
strs = ‘ 1‘
print(strs.isspace())
# False
16.istitle( )：
如果所有被空格分割成的子字符串的首字母都大写，则返回 True。否则返回 False。
# istitle( )
# 如果所有被空格分割成的子字符串的首字母都大写，则返回 True。否则返回 False。
strs = ‘Hello World‘
print(strs.istitle())
# True
strs_two = ‘Welcome to Harbin‘
print(strs_two.istitle())
# False
strs_three = ‘World T12‘
print(strs_three.istitle())
# True
17.isupper( ) ：
如果字符串中所有能够区分大小写的字符都是大写的，则返回True。否则返回 False。
# isupper( ) ：
# 如果字符串中所有能够区分大小写的字符都是大写的，则返回True。否则返回 False。
strs = ‘ABCD123汉字‘
print(strs.isupper())
# True
strs_two = ‘ABCabc汉字‘
print(strs_two.isupper())
# False
Python字符串内建函数：
1.join(str) ：
使用调用的字符串对 str 进行分割，返回值为字符串类型
# join(str) ：
# 使用调用的字符串对 str 进行分割。
strs = "Hello"
strs_two = ‘ ‘.join(strs)
print(strs_two)
# H e l l o
print(‘,‘.join(strs))
# H,e,l,l,o
2.len(string)：
返回字符串的长度
# len(string)：
# 返回字符串的长度
strs = ‘happy‘
print(len(strs))
# 5
3.ljust(width[,fillchar])： 之前的是 center 函数，也可以进行填充。
字符串左对齐，使用 fillchar 填充 width 的剩余部分。
# ljust(width[,fillchar])：
# 字符串左对齐，使用 fillchar 填充 width 的剩余部分。
strs = ‘Hello‘
print(strs.ljust(20,‘-‘))
# Hello---------------
# fillchar 默认为空
print(strs.ljust(20))
# Hello
4.lower( )：注：使用了 lower 函数后，原来的字符串不变。
将字符串所有能够区分大小写的字符都转换为小写字符。
# lower( )：
# 将字符串所有能够区分大小写的字符都转换为小写字符。
strs = ‘Hello 123‘
print(strs.lower())
# hello 123
print(type(strs.lower()))
# <class ‘str‘>
# 原来的字符串没有发生改变
print(strs)
# Hello 123
# 使用字符串接收 lower 函数的返回值
strs = strs.lower()
print(strs)
# hello 123
5.lstrip(str)：
将字符串最左面的 str 部分去除，输出剩余的部分(str 默认为空格)。
#lstrip( )：
# 将字符串左面的空格部分去除，输出剩余的部分。
strs = ‘ hello‘
print(strs.lstrip())
# hello
print(strs)
# hello
# 使用 lstrip(‘过滤的参数‘) 函数，将最左面的 a 过滤掉
strs = ‘abcd‘
print(strs.lstrip(‘a‘))
# bcd
6.maketrans(参数1，参数2)：调用后，使用字符串.translate函数对字符串进行替换。
创建字符映射的转换表。
参数 1 是需要转换的字符
参数 2 是转换的目标
# maketrans(参数1，参数2)：
# 创建字符映射的转换表。
# 参数 1 是需要转换的字符
# 参数 2 是转换的目标
# 将 abcd 使用 1234 替换
keys = ‘abcd‘
values = ‘1234‘
tran = str.maketrans(keys,values)
print(type(tran)) #<class ‘dict‘>
# 使用 字符串.translate(接收了 maketrans 函数的对象)
strs = ‘abcdef‘
print(strs.translate(tran))
# 1234ef
7.max(str)：
返回 str 中最大的字母，小写字母的 Unicode 编码比大写字母的 Unicode 编码大。
# max(str)：
# 返回 str 中最大的字母
strs = ‘abcABC‘
print(max(strs))
# c
strs = ‘ABCDE‘
print(max(strs))
# E
8.min(str)：
返回 str 中最小的字母，大写字母的 Unicode 编码比小写字母的 Unicode 编码小。
# min(str)：
# 返回 str 中最小的字母
strs = ‘abcABC‘
print(min(strs))
# A
strs = ‘ABCDE‘
print(min(strs))
# A
9.replace(old,new[,num])：
将旧字符串替换为新的字符串，num 为最多替换的次数。(默认为全部替换)
# replace(old,new[,num])：
# 将旧字符串替换为新的字符串，num 为替换的次数。
strs = ‘abc abc abc abc‘
print(strs.replace(‘abc‘,‘ABC‘))
# ABC ABC ABC ABC
# 替换 3 次
print(strs.replace(‘abc‘,‘ABC‘,3))
# ABC ABC ABC abc
10.rfind(str,start = 0,end = len(string))：
从字符串的最右面查找 str
# rfind(str,start = 0,end = len(string))：
# 从字符串的最右面查找 str，不包含end
strs = ‘happy happy‘ # h 的索引位置分别为 0,6
print(strs.rfind(‘h‘))
# 6
# y 的索引位置分别为 4,10
# 在 索引位置 2 到 11 之间进行查找
print(strs.rfind(‘y‘,2,11))
# 10
11.rindex(str,start = 0,end = len(string))：
从字符串右面开始寻找 str ，返回索引值、找不到则报错。
# rindex(str,start = 0,end = len(string))：
# 从字符串右面开始寻找 str ，返回索引值
strs = ‘happy happy‘ # a 的索引位置为 1,7
print(strs.rindex(‘a‘))
# 7
12.rjust(width[,fillchar])：
返回一个以字符串右对齐，使用 fillchar 填充左面空余的部分的字符串
# rjust(width[,fillchar])：
# 返回一个以字符串右对齐，使用 fillchar 填充左面空余的部分的字符串
strs = ‘hello‘
print(strs.rjust(20))
# hello
print(strs.rjust(20,‘*‘))
# ***************hello
13.rstrip(str)：
删除字符串最右面的 str 字符，str默认为空格
注：遇到不是 str 字符才停止删除
# rstrip(str)：
# 删除字符串最右面的 str 字符，str默认为空格
strs = ‘hello ‘
print(strs.rstrip())
# hello
strs = ‘hello aaaaa‘
print(strs.rstrip(‘a‘))
# hello
14.split(str,num)：
对字符串使用 str 进行分割，如果 num有指定值，则分割 num次(默认为全部分割)
# split(str=" ",num=string.count(str))：
# 对字符串使用 str 进行分割，如果 num有指定值，则分割 num次(默认为全部分割)
strs = ‘hahahah‘
print(strs.split(‘a‘))
# [‘h‘, ‘h‘, ‘h‘, ‘h‘]
# 对字符串进行切割两次
print(strs.split(‘a‘,2))
# [‘h‘, ‘h‘, ‘hah‘]
15.splitlines(is_keep)：
按照 回车\r 、换行\n 对字符串进行分割。
is_keep ：当 is_keep 为 True 时，返回值保留换行符。
当 is_keep 为 False 时，返回值不包留换行符。
# splitlines(is_keep)：
#
# 按照 回车\r 、换行\n 对字符串进行分割。
# is_keep ：当 is_keep 为 True 时，返回值保留换行符。
# 当 is_keep 为 False 时，返回值不包留换行符。
strs = "a\r\nb\nc"
# True则保留换行符和回车，False则不保存
print(strs.splitlines(True))
# [‘a\r\n‘, ‘b\n‘, ‘c‘]
print(strs.splitlines())
# [‘a‘, ‘b‘, ‘c‘]
16.startswith(str,start = 0,end = len(string))：
查看在字符串的 start 到 end-1 的区间中，是否以 str 开头。
# startswith(str,start = 0,end = len(string))：
# 查看在字符串的 start 到 end-1 的区间中，是否以 str 开头。
strs = ‘hello , hey , world‘
print(strs.startswith(‘hello‘))
# True
print(strs.startswith(‘hey‘,8,13))
# True
print(strs[8:13])
# hey ,
17.strip(str)：
返回在最左端和最右端都删除 str 的字符串。
注：遇到其他字符则停止。
# strip(str)：
# 返回在最左端和最右端都删除 str 的字符串。
# 注：遇到其他字符则停止,只要是 str 进行删除、不限次数。
strs = ‘ABCDEABCD‘
print(strs.strip(‘A‘))
# BCDEABCD
# 右端字符因为遇到了D,所以停止了。
strs = ‘ABCDEABCDAAA‘
print(strs.strip(‘A‘))
# BCDEABCD
strs = ‘ABCDEABCD‘
# 如果最左和最右两端都没有 str ，则不进行删除
print(strs.strip(‘E‘))
# ABCDEABCD
18.swapcase( )：
将能够区分大小写的字符，大小写互换。
# swapcase( )：
# 将能够区分大小写的字符，大小写互换。
strs = ‘ABCDabcdefg‘
print(strs.swapcase())
# abcdABCDEFG
19.title( )：
将字符串变为每一个单词都是大写字母开头，其余字母为小写或数字。
# title( )：
# 将字符串变为每一个单词都是大写字母开头，其余字母为小写或数字。
strs = ‘hello world abc123‘
print(strs.title())
# Hello World Abc123
20.translate(字典 或 接收了字符串.maketrans(被替换元素,替换元素)的对象)：
将字符串按照参数进行转换
# translate(字典 或 接收了字符串.maketrans(被替换元素,替换元素)的对象)：
# 将字符串按照参数进行转换
keys = ‘abcd‘
values = ‘1234‘
tran = str.maketrans(keys,values)
print(type(tran)) #<class ‘dict‘>
# 使用 字符串.translate(接收了 maketrans 函数的对象)
strs = ‘abcdef‘
print(strs.translate(tran))
# 1234ef
21.upper( )：
将所有能够区分大小写的字符都转换为大写
# upper()：
# 将所有能够区分大小写的字符都转换为大写
strs = ‘hello World‘
print(strs.upper())
# HELLO WORLD
22.zfill(width)：
返回长度为 width 的字符串，在左端填充 0
# zfill(width)：
# 返回长度为 width 的字符串，在左端填充 0
strs = ‘hello‘
print(strs.zfill(10))
# 00000hello
23.isdecimal( )：
字符串是否只包含十进制数，其余进制都返回False。
# isdecimal( )：
# 字符串是否只包含十进制数
# 二进制
strs_bin = ‘0b11‘
print(strs_bin.isdecimal())
# False
# 八进制
strs_oct = ‘0o56‘
print(strs_oct.isdecimal())
# 十六进制
strs_hex = ‘0xa4‘
print(strs_hex.isdecimal())
# False
strs_int = ‘123‘
print(strs_int.isdecimal())
# True
Python列表：在 [ ] 中括号 中添加元素 或者 通过 list 转换其他类型。
列表(个人总结)：
1.列表是可变类型，即可以使用列表内置方法对列表进行增删查改排序操作
常用的增删查改排序方法：
增 ：append、extend、insert、+ 连接、
删 ：pop、remove、clear、del
查 ： in、not in、for循环迭代等
改 ： 列表变量[索引下标] = 元素、切片修改
排序： sort、sorted
2.列表是序列对象，即列表的索引下标从 0 开始，依次递增，最后一个元素为-1，从右向左依次递减
3.列表可以包含所有数据类型：数字、字符串、列表、元组、集合、字典
4.列表是可迭代对象，即可以进行 for 循环(推荐使用列表推导式)
5.列表可以进行切片操作 [start:end:step] (不包含end)
6.列表可以查看元素出现的次数 count 和 元素的位置(索引下标) index
7.获取列表的长度 len
注：列表还有很多其他的 用法 和 功能，以上只是常见的
访问列表元素：
通过索引下标：
# 通过索引下标获取列表元素
lst = [1,4,7,2,5,8]
print("lst 的第一个元素是",lst[0])
# lst 的第一个元素是 1
print("lst 的第四个元素是",lst[3])
# lst 的第四个元素是 2
通过切片进行获取：
# 切片 [start(默认为 0 ),end(一直到 end-1 位置),step(默认为 1 )]
# 默认的都可以省略不写
# 列表翻转
lst = [1,4,7,2,5,8] # 8 的索引位置是 5
print(lst[::-1])
# [8, 5, 2, 7, 4, 1]
print(lst[2:5]) #不包含 5
# [7, 2, 5]
print(lst[2:5:2]) #不包含 5
# [7, 5]
Python更新列表：
使用索引下标进行更新：
# 修改列表的第 6 个元素为 d
lst = [‘a‘,‘b‘,‘c‘,1,2,3]
lst[5] = ‘d‘
print(lst)
# [‘a‘, ‘b‘, ‘c‘, 1, 2, ‘d‘]
使用切片对列表进行更新：
# 修改列表的第2个元素到最后为 hey
lst = [‘a‘,‘b‘,‘c‘,1,2]
lst[2:] = ‘hey‘
print(lst)
# [‘a‘, ‘b‘, ‘h‘, ‘e‘, ‘y‘]
# 修改列表的第3个元素到第8个元素为 hello
lst = [1,2,3,‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,4,5,6]
lst[3:8] = ‘hello‘
print(lst)
# [1, 2, 3, ‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, 4, 5, 6]
使用 append 方法增加元素：
# 使用 append 方法对列表进行更新
lst = [‘a‘,‘b‘,‘c‘,1,2,3]
lst.append(‘d‘)
print(lst)
# [‘a‘, ‘b‘, ‘c‘, 1, 2, 3, ‘d‘]
Python删除列表元素：
pop( )：
删除最后一个元素，返回该元素的值
# 使用 pop 方法删除列表中的元素
lst = [‘a‘,‘b‘,‘c‘,1,2,3]
print(lst.pop())
# 3 ,pop方法删除最后一个元素并返回它的值
print(lst)
# [‘a‘, ‘b‘, ‘c‘, 1, 2]
remove(str)：
在列表中删除 str 元素，无返回值
注：当列表中不存在 str 元素时，则会报错
lst = [‘A‘,‘B‘,‘C‘,‘D‘]
print(lst.remove(‘C‘))
# None
print(lst)
# [‘A‘, ‘B‘, ‘D‘]
remove(str)：
# 将 str 从列表中删除一次
# 当列表中存在多个 str 元素时，只删除一次
lst = [‘a‘,‘b‘,‘c‘,‘d‘,‘a‘]
lst.remove(‘a‘)
print(lst)
# [‘b‘, ‘c‘, ‘d‘, ‘a‘]
del 元素：
删除列表中的元素 或 整个列表
# 使用 del 方法删除列表的第 3 个元素
lst = [‘A‘,‘B‘,‘C‘,‘D‘]
del lst[2]
print(lst)
# [‘A‘, ‘B‘, ‘D‘]
# 删除整个 lst 列表
del lst
Python列表脚本操作符：
len(列表名)：
查看列表长度
列表对象 1 + 列表对象 2 ：
将两个列表进行组合，有时可用于赋值
lst = [1,2,3,4]
lst_two = [7,8,9]
print(lst + lst_two)
# [1, 2, 3, 4, 7, 8, 9]
成员运算符 in 、not in：
判断左端元素是否在右端列表中
lst = [‘a‘,‘b‘,‘c‘]
print(‘a‘ in lst)
# True
将列表用作可迭代对象
lst = [1,2,3,‘a‘,‘b‘,‘c‘]
for i in lst:
print(i,end = " ")
# 1 2 3 a b c
# 注：此时的 i 不是数字，而是列表中的元素，不要用于索引下标
Python列表函数和方法：
函数：
len(列表名)：
返回列表长度
# len(列表名)：
# 返回列表长度
lst = [1,2,3,‘a‘,‘b‘,‘c‘]
print("lst 列表的长度为 %d"%(len(lst)))
# lst 列表的长度为 6
max(列表名)：
返回列表元素的最大值
注：列表内的元素一定要是同一类型，都是字母 或 数字
# max(列表名)：
# 返回列表元素的最大值
# 注：列表内的元素一定要是同一类型，都是字母 或 数字
lst = [8,4,5,6,9]
print(max(lst))
# 9
lst = [‘a‘,‘b‘,‘c‘,‘A‘,‘B‘,‘C‘]
print(max(lst))
# c
min(列表名)：
返回列表元素的最小值
注：列表内的元素一定要是同一类型，都是字母 或 数字
# min(列表名)：
# 返回列表元素的最小值
# 注：列表内的元素一定要是同一类型，都是字母 或 数字
lst = [8,4,5,6,9]
print(min(lst))
# 4
lst = [‘a‘,‘b‘,‘c‘,‘A‘,‘B‘,‘C‘]
print(min(lst))
# A
使用 list 将元组转换为列表对象（通常用来修改元组的值）：
# 使用 list 将元组转换为列表对象（通常用来修改元组的值）
tup = (1,2,3,‘a‘,‘b‘)
tuple_lst = list(tup)
print(tuple_lst)
# [1, 2, 3, ‘a‘, ‘b‘]
方法：
append(对象)：
在列表末尾添加该对象
# append(对象)：
# 在列表末尾添加该对象
lst = [‘A‘,‘B‘,‘C‘]
lst.append(‘D‘)
print(lst)
# [‘A‘, ‘B‘, ‘C‘, ‘D‘]
# 如果添加元素为列表，则将列表当做一个元素进行添加
lst = [‘A‘,‘B‘,‘C‘]
lst_two = [‘a‘,‘b‘,‘c‘]
lst.append(lst_two)
print(lst)
# [‘A‘, ‘B‘, ‘C‘, [‘a‘, ‘b‘, ‘c‘]]
count(str)：
返回列表中 str 出现的次数
# count(str)：
# 返回列表中 str 出现的次数
lst = [1,2,1,2,1,3]
print(lst.count(1))
# 3
# 如果不存在该元素，则返回 0
print(lst.count(4))
# 0
extend(序列对象)：
在列表末尾添加所有序列对象中的元素，返回值为空。多用来扩展原来的列表
# extend(序列对象)：
# 在列表末尾添加所有序列对象中的元素，多用来扩展原来的列表
lst = [1,2,3]
lst_two = [7,8,9]
lst.extend(lst_two)
print(lst)
# [1, 2, 3, 7, 8, 9]
index(str)：
返回 str 在列表中第一次出现的索引位置，str 不在列表中则报错
# index(str)：
# 返回 str 在列表中第一次出现的索引位置
lst = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘c‘]
print(lst.index(‘c‘))
# 2
insert(index,对象)：
在列表的 index 位置添加对象，原 index 位置及后面位置的所有元素都向后移
# insert(index,对象)：
# 在列表的 index 位置添加对象
lst = [‘a‘,‘b‘,‘c‘,‘d‘]
lst.insert(2,‘q‘)
print(lst)
# [‘a‘, ‘b‘, ‘q‘, ‘c‘, ‘d‘]
pop(index = -1)：
默认删除列表的最后一个元素，并返回值
当 index 为 2 时，删除第 3 个元素
# pop(index)：
# 默认删除列表的最后一个元素，并返回值
lst = [‘a‘,‘b‘,‘c‘,‘d‘]
lst.pop()
print(lst)
# [‘a‘, ‘b‘, ‘c‘]
lst = [‘a‘,‘b‘,‘c‘,‘d‘]
# 删除第二个元素
lst.pop(2)
print(lst)
# [‘a‘, ‘b‘, ‘d‘]
remove(str)：
将 str 从列表中删除，注：如果列表中有多个 str 元素，只删除一次 str
# remove(str)：
# 将 str 从列表中删除一次
lst = [‘a‘,‘b‘,‘c‘,‘d‘,‘a‘]
lst.remove(‘a‘)
print(lst)
# [‘b‘, ‘c‘, ‘d‘, ‘a‘]
lst = [‘a‘,‘b‘,‘c‘,‘d‘]
lst.remove(‘b‘)
print(lst)
# [‘a‘, ‘c‘, ‘d‘]
reverse( )：
翻转列表的元素
# reverse( )：
# 翻转列表的元素
lst = [1,7,3,2,5,6]
lst.reverse()
print(lst)
# [6, 5, 2, 3, 7, 1]
sort(key = None,reverse = False)：
对列表进行排序，无返回值
# sort(key = None,reverse = False)：
# key 用来接收函数，对排序的数据进行修改
# 对列表进行排序
lst = [1,4,5,2,7,6]
lst.sort()
print(lst)
# [1, 2, 4, 5, 6, 7]
lst = [1,4,5,2,7,6]
# 先排序后翻转
lst.sort(reverse = True)
print(lst)
# [7, 6, 5, 4, 2, 1]
lst = [5,4,1,2,7,6]
# 不满足 key 的放前面，满足 key 的放后面
lst.sort(key = lambda x : x % 2 == 0)
print(lst)
# [1, 5, 7, 4, 2, 6]
clear( )：
清空列表
# clear( )：
# 清空列表,无返回值
lst = [‘a‘,‘c‘,‘e‘]
lst.clear()
print(lst)
# []
copy( )：
复制一份列表元素
# copy( )：
# 复制列表
lst = [‘a‘,‘b‘,‘c‘]
print(lst.copy())
# [‘a‘, ‘b‘, ‘c‘]
print(lst)
# [‘a‘, ‘b‘, ‘c‘]
Python元组：元组与字典类似，不同之处在于元组的值不能够修改。
使用 ( ) 或 tuple 强制转换 可以得到元祖
创建空元组：
# 创建空元祖
tuple_1 = ()
print(type(tuple_1))
# <class ‘tuple‘>
print(tuple_1)
# ()
创建只包含一个元素的元组：
注：一定要使用，逗号，否则会被当做是一个常量值
# 创建只包含一个元素的元组
tuple_2 = (1,)
print(type(tuple_1))
# <class ‘tuple‘>
print(tuple_2)
# (1,)
创建包含有多个元素的元组：
# 创建包含多个元素的元组
tuple_3 = (4,5)
print(type(tuple_3))
# <class ‘tuple‘>
print(tuple_3)
# (4, 5)
# 使用 tuple 对列表进行强制转换
lst = [1,2,3,4,5]
tuple_4 = tuple(lst)
print(type(tuple_4))
# <class ‘tuple‘>
print(tuple_4)
# (1, 2, 3, 4, 5)
不使用括号，创建包含多个元素的元组：
# 创建包含多个元素的元组
tuple_4 = 7,8,9
print(tuple_4)
# (7, 8, 9)
print(type(tuple_4))
# <class ‘tuple‘>
Python访问元组：
使用索引下标进行访问元组：
# 通过索引下标进行访问
tuple_1 = (‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘)
# 输出元组中的第一个值
print(tuple_1[0])
# a
# 输出元组中的第六个值
print(tuple_1[5])
# f
# 输出元组的最后一个元素
print(tuple_1[-1])
# g
通过切片访问元组：
# 使用切片对元组进行输出 [start:end:step] 注：不包含 end 位置
tuple_1 = (‘a‘,‘b‘,‘c‘,4,5,6,7)
# 输出所有元组的元素
print(tuple_1[::])
# (‘a‘, ‘b‘, ‘c‘, 4, 5, 6, 7)
# 输出元组的第三个元素到第五个元素
print(tuple_1[2:5]) #不包含 end
# (‘c‘, 4, 5)
# 步长可以进行修改
print(tuple_1[2:5:2])
# (‘c‘, 5)
# 将元组倒序输出
print(tuple_1[::-1])
# (7, 6, 5, 4, ‘c‘, ‘b‘, ‘a‘)
Python访问元组：
使用索引下标进行访问元组：
# 通过索引下标进行访问
tuple_1 = (‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘)
# 输出元组中的第一个值
print(tuple_1[0])
# a
# 输出元组中的第六个值
print(tuple_1[5])
# f
# 输出元组的最后一个元素
print(tuple_1[-1])
# g
通过切片访问元组：
# 使用切片对元组进行输出 [start:end:step] 注：不包含 end 位置
tuple_1 = (‘a‘,‘b‘,‘c‘,4,5,6,7)
# 输出所有元组的元素
print(tuple_1[::])
# (‘a‘, ‘b‘, ‘c‘, 4, 5, 6, 7)
# 输出元组的第三个元素到第五个元素
print(tuple_1[2:5]) #不包含 end
# (‘c‘, 4, 5)
# 步长可以进行修改
print(tuple_1[2:5:2])
# (‘c‘, 5)
# 将元组倒序输出
print(tuple_1[::-1])
# (7, 6, 5, 4, ‘c‘, ‘b‘, ‘a‘)
注:
元组没有 reverse 方法
修改元组的元素
# 将元组中的 ‘c‘ 改为 ‘d‘
tuple_1 = (‘a‘,‘b‘,‘c‘,4,5,6,7)
# c 的索引位置是 2
# 修改元组的值，可先将元组转换为列表类型，然后再转变为元组类型
lst = list(tuple_1)
lst[2] = ‘d‘ #进行修改
tuple_1 = tuple(lst) #重新转换为元组类型
print(tuple_1)
# (‘a‘, ‘b‘, ‘d‘, 4, 5, 6, 7)
删除元组中的某一个元素,可以使用del 进行删除,也可以利用切片进行相加
# 方法1
# 将元组中的 ‘b‘ 删除
tuple_1 = (‘a‘,‘b‘,‘c‘,4,5,6,7)
# b 的索引位置是 1
lst = list(tuple_1)
del lst[1]
tuple_1 = tuple(lst) #重新转换为元组类型
print(tuple_1)
# (‘a‘, ‘c‘, 4, 5, 6, 7)
# 方法2
# 将元组中的 ‘b‘ 删除
tuple_1 = (‘a‘,‘b‘,‘c‘,4,5,6,7)
# b 的索引位置是 1
tuple_1 = tuple_1[:1] + tuple_1[2:]
print(tuple_1)
# (‘a‘, ‘c‘, 4, 5, 6, 7)
del 语句 删除元组：
# 删除元组
tuple_1 = (‘a‘,‘b‘,‘c‘)
del tuple_1
Python元组运算符：
len(元组名)：
返回元组对象的长度
tuple_1 = (1,4,5,2,3,6)
print(len(tuple_1))
# 6
+ 连接：
tuple_1 = (1,4,5)
tupel_2 = (3,5,4)
print(tuple_1 + tupel_2)
# (1, 4, 5, 3, 5, 4)
* 重复：
tuple_1 = (1,4,5)
num = 3
print(num * tuple_1)
# (1, 4, 5, 1, 4, 5, 1, 4, 5)
成员运算符 in ，not in：
tuple_1 = (1,4,5,2,3,6)
print(4 in tuple_1)
# True
print(8 in tuple_1)
# False
print(4 not in tuple_1)
# False
print(8 not in tuple_1)
# True
将元组作为可迭代对象：
# 将元组作为可迭代对象
tuple_1 = (‘a‘,‘b‘,‘c‘)
for i in tuple_1:
print(i , end = " ")
# a b c
Python元组索引、截取：
索引下标：
tuple_1 = (‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘,‘h‘)
print(tuple_1[0])
# a
print(tuple_1[3])
# d
print(tuple_1[7])
# h
# 当索引下标为负数时，-1表示最右端元素，从右向左依次递减
print(tuple_1[-1])
# h
print(tuple_1[-4])
# e
切片操作：
# 使用切片进行截取列表元素
tuple_1 = (1,2,3,4,5,6,7,8,9,10)
print(tuple_1[::])
# (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(tuple_1[2:8])
# (3, 4, 5, 6, 7, 8)
print(tuple_1[2:8:3])
# (3, 6) , 不包含end
print(tuple_1[2::-1])
# (3, 2, 1)
print(tuple_1[8:1:-1])
# (9, 8, 7, 6, 5, 4, 3)
print(tuple_1[8:1:-2])
# (9, 7, 5, 3)
print(tuple_1[-1:-5:-1])
# (10, 9, 8, 7)
Python元组内置函数：
len(元组名)：
返回元组长度
tuple_1 = (1,2,3,‘a‘,‘b‘,‘c‘)
print("tuple_1 元组的长度为 %d"%(len(tuple_1)))
# tuple_1 元组的长度为 6
max(元组名)：
返回元组元素的最大值
注：元组内的元素一定要是同一类型，都是字母 或 数字
tuple_1 = (8,4,5,6,9)
print(max(tuple_1))
# 9
tuple_1 = (‘a‘,‘b‘,‘c‘,‘A‘,‘B‘,‘C‘)
print(max(tuple_1))
# c
min(元组名)：
返回元组元素的最小值
注：元组内的元素一定要是同一类型，都是字母 或 数字
tuple_1 = (8,4,5,6,9)
print(min(tuple_1))
# 4
tuple_1 = (‘a‘,‘b‘,‘c‘,‘A‘,‘B‘,‘C‘)
print(min(tuple_1))
# A
使用 tuple 将列表转换为元组对象
# 使用 tuple 将列表转换为元组对象
tuple_1 = (1,2,3,‘a‘,‘b‘)
lst = list(tuple_1)
print(lst)
# [1, 2, 3, ‘a‘, ‘b‘]
Python字典：{键：值}，多个键值对使用 ， 进行分隔。
创建空字典：
dic = {}
print(type(dic))
# <class ‘dict‘>
print(dic)
# {}
创建只有一个元素的字典：
dic = {‘a‘:123}
print(dic)
# {‘a‘: 123}
创建包含多个元素的字典：
dic = {‘a‘:123,888:‘n‘,(4,5):[7,8]}
print(dic)
# {‘a‘: 123, 888: ‘n‘, (4, 5): [7, 8]}
# 键一定是不可变类型
使用 dict 转化为字典：
dic = dict(zip([‘a‘,‘b‘,‘c‘],[4,5,6]))
print(dic)
# {‘a‘: 4, ‘b‘: 5, ‘c‘: 6}
Python访问字典中的值：
# 使用字典 [‘键‘] 获取字典中的元素
dic = {‘a‘:123,‘b‘:456,‘c‘:789}
print(dic[‘a‘])
# 123
修改字典元素：
dic = {‘a‘: 123, ‘b‘: 456, ‘c‘: 789}
dic[‘b‘] = 14
print(dic)
# {‘a‘: 123, ‘b‘: 14, ‘c‘: 789}
增加字典元素：
dic = {‘a‘:123,‘b‘:456,‘c‘:789}
dic[‘d‘] = 555
print(dic)
# {‘a‘: 123, ‘b‘: 456, ‘c‘: 789, ‘d‘: 555}
删除操作：
dic = {‘a‘: 123, ‘b‘: 14, ‘c‘: 789}
# 删除字典元素
del dic[‘b‘]
print(dic)
# {‘a‘: 123, ‘c‘: 789}
# 清空字典
dic = {‘a‘: 123, ‘b‘: 14, ‘c‘: 789}
dic.clear()
print(dic)
# {}
# 删除字典
dic = {‘a‘: 123, ‘b‘: 14, ‘c‘: 789}
del dic
Python字典内置函数和方法：
注：使用了 items、values、keys 返回的是可迭代对象，可以使用 list 转化为列表。
len(字典名)：
返回键的个数，即字典的长度
dic = {‘a‘:123,‘b‘:456,‘c‘:789,‘d‘:567}
print(len(dic))
# 4
str(字典名)：
将字典转化成字符串
dic = {‘a‘:123,‘b‘:456,‘c‘:789,‘d‘:567}
print(str(dic))
# {‘a‘: 123, ‘b‘: 456, ‘c‘: 789, ‘d‘: 567}
type(字典名)：
查看字典的类型
dic = {‘a‘:123,‘b‘:456,‘c‘:789,‘d‘:567}
print(type(dic))
# <class ‘dict‘>
字典的内置方法
clear( )：
删除字典内所有的元素
dic = {‘a‘:123,‘b‘:456,‘c‘:789,‘d‘:567}
dic.clear()
print(dic)
# {}
copy( )：
浅拷贝一个字典
dic = {‘a‘:123,‘b‘:456,‘c‘:789,‘d‘:567}
dic_two = dic.copy()
print(dic)
# {‘a‘: 123, ‘b‘: 456, ‘c‘: 789, ‘d‘: 567}
print(dic_two)
# {‘a‘: 123, ‘b‘: 456, ‘c‘: 789, ‘d‘: 567}
fromkeys(seq[,value])：
创建一个新字典,seq作为键，value为字典所有键的初始值(默认为None)
# fromkeys(seq[,value])：
# 创建一个新字典,seq作为键，value为字典所有键的初始值(默认为None)
dic = dict.fromkeys(‘abcd‘)
# 默认为 None
print(dic)
# {‘a‘: None, ‘b‘: None, ‘c‘: None, ‘d‘: None}
dic = dict.fromkeys(‘abc‘,1)
print(dic)
# {‘a‘: 1, ‘b‘: 1, ‘c‘: 1}
get(key,default = None)：
返回指定的键的值，如果键不存在，则返会 default 的值
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(dic.get(‘b‘))
# 2
print(dic.get(‘e‘,5))
# 5
成员运算符 in、not in：
查看 键 是否在字典中:
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(‘a‘ in dic)
# True
print(‘a‘ not in dic)
# False
items( )：
返回键值对的可迭代对象，使用 list 可转换为 [(键,值)] 形式
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(dic.items())
# dict_items([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)])
print(list(dic.items()))
# [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
keys( )：
返回一个迭代器，可以使用 list() 来转换为列表
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(dic.keys())
# dict_keys([‘a‘, ‘b‘, ‘c‘, ‘d‘])
print(list(dic.keys()))
# [‘a‘, ‘b‘, ‘c‘, ‘d‘]
setdefault(key,default = None)：
如果键存在于字典中，则不修改键的值
如果键不存在于字典中，则设置为 default 值
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
dic.setdefault(‘a‘,8)
print(dic)
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4}
# 如果键不存在于字典中，则设置为 default 值
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
dic.setdefault(‘e‘,5)
print(dic)
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4, ‘e‘: 5}
update(字典对象)：
将字典对象更新到字典中
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
dic_two = {‘f‘:6}
dic.update(dic_two)
print(dic)
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4, ‘f‘: 6}
values( )：
返回一个可迭代对象，使用 list 转换为字典中 值 的列表
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(list(dic.values()))
pop(key[,default])：
删除字典中 key 的值，返回被删除的值。key 值如果不给出，则返回default的值
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(dic.pop(‘a‘,6))
# 1 , 返回删除的值
print(dic)
# {‘b‘: 2, ‘c‘: 3, ‘d‘: 4}
print(dic.pop(‘e‘,‘字典中没有该值‘))
# 字典中没有该值 ， 如果字典中不存在该键，则返回 default 的值
print(dic)
# {‘b‘: 2, ‘c‘: 3, ‘d‘: 4}
popitem( )：
随机返回一个键值对(通常为最后一个)，并删除最后一个键值对
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
print(dic.popitem())
# (‘d‘, 4)
print(dic)
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
print(dic.popitem())
# (‘c‘, 3)
print(dic)
# {‘a‘: 1, ‘b‘: 2}
time 模块
time.time()
# 1595600800.6158447
Python函数使用一个元组装起来的 9 组数字，专门用来处理时间使用
tm_year 年：使用 4 位数字 、2020
tm_mon 月：1~12 、6月
tm_mday 日：1~31 、25号
tm_hour 小时：0~23 、16时
tm_min 分钟：0~59 、33分
tm_sec 秒：0~60 或 0~61 、61 是闰秒
tm_wday 一周的第几日：0~6 、0 是周一
tm_yday 一年的第几日：1~365 或 1~366 、366是闰年
tm_isdst 夏令时：1 为夏令时、0 非夏令时、-1 未知
获取当前时间
#使用 time.localtime(time.time())
import time
times = time.time()
print(times) # 表示自 1970 年 1月 1 日 过去了多久
# 1595601014.0598545
localtime = time.localtime(times)
print(localtime)
# time.struct_time(tm_year=2020, tm_mon=7, tm_mday=24, tm_hour=22, tm_min=30,
# tm_sec=14, tm_wday=4, tm_yday=206, tm_isdst=0)
获取格式化时间：
time.time() 获取到1970年1月1日的秒数 -> time.localtime() 转变为当前时间 -> time.asctime() 将时间格式化
#获取格式化时间
import time
times = time.time()
print(times)
# 1595601087.3453288
local_times = time.localtime(times)
print(local_times)
# time.struct_time(tm_year=2020, tm_mon=7, tm_mday=24, tm_hour=22,
# tm_min=31, tm_sec=27, tm_wday=4, tm_yday=206, tm_isdst=0)
# 使用 asctime 将得到的 local_times 转化为有格式的时间
local_time_asctimes = time.asctime(local_times)
print(local_time_asctimes)
# Fri Jul 24 22:31:27 2020
格式化日期：
%y ：两位数的年份表示 (00~99)
%Y ：四位数的年份表示 (000~9999)
%m ：月份（01~12）
%d ：月份中的某一天（0~31）
%H ：某时，24小时制（0~23）
%I ：某时，12小时制（01~12）
%M ：某分（0~59）
%S ：某秒（00~59）
%a ：周几的英文简称
%A ：周几的完整英文名称
%b ：月份的英文简称
%B ：月份的完整英文名称
%c ：本地相应的日期表示和时间表示
%j ：年内的某一天（001~366）
%p ：本地 A.M. 或 P.M.的等价符
%U ：一年中的星期数（00~53）注：星期天为星期的开始
%w ：星期（0~6）注：星期天为星期的开始
%W ：一年中的星期数（00~53）注：星期一为星期的开始
%x ：本地相应的日期表示
%X ：本地相应的时间表示
%Z ： 当前时区的名称
%% ：输出一个%
time.strftime(format[,t]) 参数为日期格式
# 格式化日期
# time.strftime(format[,t]) 参数为日期格式
import time
times = time.time()
local_time = time.localtime(times)
# Y 年 - m 月 - d 日 H 时 - M 分 - S 秒
print(time.strftime("%Y-%m-%d %H:%M:%S",local_time))
# 2020-07-24 22:33:43
# Y 年 - b 月份英文简称 - d 日期 - H 时 - M 分 - S 秒 - a 周几的英文简称
print(time.strftime("%Y %b %d %H:%M:%S %a",local_time))
# 2020 Jul 24 22:33:43 Fri
获取某月的日历：
calendar.month(year,month)：
获取 year 年 month 月的日历
import calendar
cal = calendar.month(2020,2)
print("以下为2020年2月的日历")
print(cal)
# February 2020
# Mo Tu We Th Fr Sa Su
# 1 2
# 3 4 5 6 7 8 9
# 10 11 12 13 14 15 16
# 17 18 19 20 21 22 23
# 24 25 26 27 28 29
Python Time模块：
altzone：
注：我们在格林威治的东部，返回负值。对启动夏令时的地区才能使用
返回格林威治西部的夏令时地区的偏移秒数，如果是在东部（西欧），则返回负值
import time
print(time.altzone)
# -32400
time( )：
返回当前时间的时间戳
import time
times = time.time()
print(times)
# 1595601470.093444
asctime(时间元组)：时间元组：如使用了 gmtime 或 localtime 函数的对象
接受时间元组并返回可读形式，时间元组可以是使用了 time.localtime(time.time()) 的对象
import time
times = time.time()
print(times)
# 1595601496.8390365
local_time = time.localtime(times)
print(local_time)
# time.struct_time(tm_year=2020, tm_mon=7, tm_mday=24,
# tm_hour=22, tm_min=38, tm_sec=16, tm_wday=4, tm_yday=206, tm_isdst=0)
# 使用 asctime 转变为可读形式
print(time.asctime(local_time))
# Fri Jul 24 22:38:16 2020
perf_counter( )：
返回系统的运行时间
import time
# 使用 perf_counter()函数查看系统运行时间
print(time.perf_counter())
# 2.0289763
process_time( )：
查看进程运行时间
import time
# 使用 process_time() 查看进程运行时间
print(time.process_time())
# 0.0625
gmtime(secs)：secs 时间戳：从1970年1月1日到现在的秒数
查看格林威治的时间元组
# 使用 gmtime(时间戳) 查看格林威治的时间元组
import time
times = time.time()
# 查看格林威治的当前时间元组
print(time.gmtime(times))
# time.struct_time(tm_year=2020, tm_mon=2, tm_mday=10, tm_hour=5,
# tm_min=18, tm_sec=7, tm_wday=0, tm_yday=41, tm_isdst=0)
localtime(secs)：secs 时间戳：从1970年1月1日到现在的秒数
返回 secs 时间戳下的时间元组
import time
times = time.time()
print(times)
# 1581312227.3952267 , 时间戳
local_time = time.localtime()
print(local_time)
# time.struct_time(tm_year=2020, tm_mon=2, tm_mday=10, tm_hour=13,
# tm_min=23, tm_sec=47, tm_wday=0, tm_yday=41, tm_isdst=0)
mktime(使用了 gmtime 或 localtime 函数的对象)：
返回时间戳
import time
times = time.time()
print(times)
# 1581312492.6350465
local_time = time.localtime()
print(time.mktime(local_time))
# 1581312492.0
ctime( )：
返回可读形式的当前时间
# ctime()
# 返回可读形式的当前时间
import time
print(time.ctime())
# Mon Feb 10 13:32:22 2020
sleep(seconds)：
使程序延迟 seconds 秒运行
import time
print(time.ctime())
# Mon Feb 10 13:34:38 2020
time.sleep(5)
print(time.ctime())
# Mon Feb 10 13:34:43 2020
strftime(format,时间元组)：format表示时间显示格式，如 %Y-%m-%d %H-%M-%S
将时间元组转换为 format 形式
import time
times = time.time()
local_time = time.localtime()
time_strftime = time.strftime("%Y-%m-%d %H-%M-%S",local_time)
print(time_strftime)
# 2020-02-10 13-42-09
strptime(str,format)：
按照 format 格式将 str 解析为一个时间元组，如果 str 不是 format 格式，则会报错
import time
str = ‘2020-02-10 13-42-09‘
str_time = time.strptime(str,"%Y-%m-%d %H-%M-%S")
print(str_time)
# time.struct_time(tm_year=2020, tm_mon=2, tm_mday=10, tm_hour=13,
# tm_min=42, tm_sec=9, tm_wday=0, tm_yday=41, tm_isdst=-1)
属性：
timezone:
当前地区距离格林威治的偏移秒数
import time
print(time.timezone)
# -28800
tzname：
属性time.tzname包含一对字符串，分别是带夏令时的本地时区名称，和不带的。
# 使用 time.tzname 查看 带夏令时的本地时区名称 与 不带夏令时的本地时区名称
import time
print(time.tzname)
# (‘中国标准时间‘, ‘中国夏令时‘)
Python日历模块 calendar：
0：星期一是第一天
6：星期日是最后一天
注：形参 w，I，c 可以不写，正常使用，使用默认形参即可
calendar(year,w=2,I=1,c=6)：
返回一个多行字符格式的 year 年年历，3个月一行，间隔距离为 c。每日宽度间隔为 w 个字符
# calendar(year,w = 2,I = 1,c = 6)
import calendar
# calendar(年份，天与天之间的间隔，周与周之间的间隔，月与月之间的间隔)
print(calendar.calendar(2020,2,1,6))
# 2020
#
# January February March
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 1 2 1
# 6 7 8 9 10 11 12 3 4 5 6 7 8 9 2 3 4 5 6 7 8
# 13 14 15 16 17 18 19 10 11 12 13 14 15 16 9 10 11 12 13 14 15
# 20 21 22 23 24 25 26 17 18 19 20 21 22 23 16 17 18 19 20 21 22
# 27 28 29 30 31 24 25 26 27 28 29 23 24 25 26 27 28 29
# 30 31
#
# April May June
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 1 2 3 1 2 3 4 5 6 7
# 6 7 8 9 10 11 12 4 5 6 7 8 9 10 8 9 10 11 12 13 14
# 13 14 15 16 17 18 19 11 12 13 14 15 16 17 15 16 17 18 19 20 21
# 20 21 22 23 24 25 26 18 19 20 21 22 23 24 22 23 24 25 26 27 28
# 27 28 29 30 25 26 27 28 29 30 31 29 30
#
# July August September
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 1 2 1 2 3 4 5 6
# 6 7 8 9 10 11 12 3 4 5 6 7 8 9 7 8 9 10 11 12 13
# 13 14 15 16 17 18 19 10 11 12 13 14 15 16 14 15 16 17 18 19 20
# 20 21 22 23 24 25 26 17 18 19 20 21 22 23 21 22 23 24 25 26 27
# 27 28 29 30 31 24 25 26 27 28 29 30 28 29 30
# 31
#
# October November December
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 1 1 2 3 4 5 6
# 5 6 7 8 9 10 11 2 3 4 5 6 7 8 7 8 9 10 11 12 13
# 12 13 14 15 16 17 18 9 10 11 12 13 14 15 14 15 16 17 18 19 20
# 19 20 21 22 23 24 25 16 17 18 19 20 21 22 21 22 23 24 25 26 27
# 26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31
# 30
firstweekday( )：
返回当前每周起始日期的设置，默认返回 0 、周一为 0
import calendar
print(calendar.firstweekday())
# 0
isleap(year)：
如果是闰年则返回 True，否则返回 False
import calendar
print(calendar.isleap(2020))
# True
leapdays(year1,year2)：
返回 year1 到 year2 之间的闰年数量
import calendar
print(calendar.leapdays(2001,2100))
# 24
month(year,month,w = 2,I = 1)：
返回 year 年 month 月日历，两行标题，一周一行。
注：每天与每天的宽度间隔为 w 个字符，i 是每个星期与每个星期的间隔的空数
import calendar
print(calendar.month(2020,3,2,1))
# March 2020
# Mo Tu We Th Fr Sa Su
# 1
# 2 3 4 5 6 7 8
# 9 10 11 12 13 14 15
# 16 17 18 19 20 21 22
# 23 24 25 26 27 28 29
# 30 31
monthcalendar(year,month)：
以列表形式返回，每一周为内嵌列表，没有日子则为 0
import calendar
print(calendar.monthcalendar(2020,4))
# [[0, 0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11, 12],
# [13, 14, 15, 16, 17, 18, 19], [20, 21, 22, 23, 24, 25, 26],
# [27, 28, 29, 30, 0, 0, 0]]
monthrange(year,month)：
返回（这个月的第一天是星期几，这个月有多少天）
import calendar
print(calendar.monthrange(2020,2))
# (5, 29)
prcal(year,w = 2,I = 1,c = 6)：
输出 year 年的日历
import calendar
calendar.prcal(2020)
# print(calendar.prcal(2020,2,1,6))
# 2020
#
# January February March
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 1 2 1
# 6 7 8 9 10 11 12 3 4 5 6 7 8 9 2 3 4 5 6 7 8
# 13 14 15 16 17 18 19 10 11 12 13 14 15 16 9 10 11 12 13 14 15
# 20 21 22 23 24 25 26 17 18 19 20 21 22 23 16 17 18 19 20 21 22
# 27 28 29 30 31 24 25 26 27 28 29 23 24 25 26 27 28 29
# 30 31
#
# April May June
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 1 2 3 1 2 3 4 5 6 7
# 6 7 8 9 10 11 12 4 5 6 7 8 9 10 8 9 10 11 12 13 14
# 13 14 15 16 17 18 19 11 12 13 14 15 16 17 15 16 17 18 19 20 21
# 20 21 22 23 24 25 26 18 19 20 21 22 23 24 22 23 24 25 26 27 28
# 27 28 29 30 25 26 27 28 29 30 31 29 30
#
# July August September
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 1 2 1 2 3 4 5 6
# 6 7 8 9 10 11 12 3 4 5 6 7 8 9 7 8 9 10 11 12 13
# 13 14 15 16 17 18 19 10 11 12 13 14 15 16 14 15 16 17 18 19 20
# 20 21 22 23 24 25 26 17 18 19 20 21 22 23 21 22 23 24 25 26 27
# 27 28 29 30 31 24 25 26 27 28 29 30 28 29 30
# 31
#
# October November December
# Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
# 1 2 3 4 1 1 2 3 4 5 6
# 5 6 7 8 9 10 11 2 3 4 5 6 7 8 7 8 9 10 11 12 13
# 12 13 14 15 16 17 18 9 10 11 12 13 14 15 14 15 16 17 18 19 20
# 19 20 21 22 23 24 25 16 17 18 19 20 21 22 21 22 23 24 25 26 27
# 26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31
# 30
prmonth(year,month,w = 2,I = 1)：
输出 year 年 month 月的日历
import calendar
calendar.prmonth(2020,12)
# December 2020
# Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 6
# 7 8 9 10 11 12 13
# 14 15 16 17 18 19 20
# 21 22 23 24 25 26 27
# 28 29 30 31
setfirstweekday(weekday)：
设置每周的起始日期，0为周一，6为周日
import calendar
calendar.setfirstweekday(2)
timegm(时间元组)：
返回该时刻的时间戳
import time
import calendar
print(calendar.timegm(time.localtime(time.time())))
# 1581362983
weekday(year,month,day)：
查看 year 年 month 月 day 日 星期几
import calendar
print(calendar.weekday(2020,2,10))
# 0 周一
Python函数：实现某种功能的代码段
定义一个函数需要遵循的规则：
1.使用 def 关键字 函数名和( )，括号内可以有形参
匿名函数使用 lambda 关键字定义
2.任何传入参数和自变量必须放在括号中
3.函数的第一行语句可以使用字符串存放函数说明
4.函数内容以冒号开始，函数内的代码块缩进
5.使用了 return [表达式] 函数会返回一个值，如果不使用 return 没有返回值
def 函数名([参数，根据函数运行需要，如果函数不需要参数，可以不写]):
函数声明（可不写，如果怕忘记函数功能，最好是写）
函数语句 ...
return 需要返回的值（有些函数可以不使用 return，只进行某些操作，返回为None）
定义一个 say_hello 函数，使函数能够说出 hello
def say_hello():
print("hello")
定义一个求长方形面积的函数 area，要求具有返回值且参数为 height 和 width
def area(height,width):
return height * width
定义一个函数，输出 欢迎，接收到的参数 name
def huanying(name):
print("欢迎",name)
定义一个求 1~10 的总和的函数，函数名为 one_to_ten，要求具有返回值
def one_to_ten():
sum = 0
for i in range(1,11):
sum += i
return sum
函数名可以赋值给变量，使用变量进行调用（变量此时相当于函数名）
def add(num_1,num_2):
print(num_1 + num_2)
a = add
print(type(a))
# <class ‘function‘>
a(3,5)
# 8
函数内可以进行定义类：
def run():
class student(object):
pass
Python函数调用：
函数定义后，使用函数名(实参)进行调用，如果具有返回值，则使用变量接收。
示例：
无参数，无返回值
# 程序：定义一个 say_hello 函数，使函数能够说出 hello
def say_hello():
print("hello")
say_hello()
# hello
有参数，无返回值
# 定义一个函数，输出 欢迎，接收到的参数 name
def huanying(name):
print("欢迎",name)
huanying("小明")
# 欢迎 小明
无参数，有返回值
#定义一个求 1~10 的总和的函数，函数名为 one_to_ten，要求具有返回值
def one_to_ten():
sum = 0
for i in range(1,11):
sum += i
return sum
sum_1 = one_to_ten()
print(sum_1)
# 55
有参数，有返回值
# 定义一个求长方形面积的函数，要求具有返回值且参数为 height 和 width
def area(height,width):
return height * width
mianji = area(5,4)
print(mianji)
Python按值传递参数和按引用传递参数：
按值传递参数：
使用一个变量的值(数字，字符串)，放到实参的位置上
注：传递过去的是变量的副本，无论副本在函数中怎么变，变量的值都不变
传递常量：
# 定义一个函数，输出 欢迎，接收到的参数 name
def huanying(name):
print("欢迎",name)
huanying("小明")
# 欢迎 小明
# 定义一个求长方形面积的函数，要求具有返回值且参数为 height 和 width
def area(height,width):
return height * width
mianji = area(5,4)
print(mianji)
# 20
传递变量：
# 定义一个函数，输出 欢迎，接收到的参数 name
def huanying(name):
print("欢迎",name)
strs_name = "小明"
huanying(strs_name)
# 欢迎 小明
# 定义一个求长方形面积的函数，要求具有返回值且参数为 height 和 width
def area(height,width):
return height * width
height = 5
width = 4
mianji = area(height,width)
print(mianji)
# 20
按引用传递：
输出 列表、元组 和 集合所有元素的总和
lst = [1,2,3,4]
tuple_1 = (4,5,7)
se = {9,6,5,8}
def add(args):
‘‘‘将 args 中的元素总和输出‘‘‘
print(sum(args))
add(lst)
# 10
add(tuple_1)
# 16
add(se)
# 28
# 输出程序的注释
print(add.__doc__)
# 将 args 中的元素总和输出
使用函数，将参数引用传递输出参数中的奇数
lst = [1,2,3,4]
tuple_1 = (4,5,7)
def jishu(args):
‘‘‘将 args 中的奇数输出‘‘‘
for i in range(len(args)):
if args[i] % 2 == 1:
print(args[i], end = " ")
print()
jishu(lst)
# 1 3
jishu(tuple_1)
# 5 7
# 输出程序的注释
print(jishu.__doc__)
# 将 args 中的奇数输出
如果参数发生修改
1.原参数如果为可变类型(列表、集合、字典)则也跟着修改
2.原参数如果为不可变类型(数字、字符串、元组)则不发生改变
示例：
列表在函数中调用方法，列表本身发生改变
def add_elem(args,string):
‘‘‘将 lst_num 添加到 args 中‘‘‘
args.append(string)
# args += string
# args.extend(string)
# args.insert(len(args),string)
return args
lst = [1,2,3,4]
string = "ABC"
print(add_elem(lst,string))
# [1, 2, 3, 4, ‘ABC‘]
print(lst)
# [1, 2, 3, 4, ‘ABC‘]
在函数中，如果列表作为实参，形参发生修改时，列表值发生改变
def add_elem(args,string):
‘‘‘将 lst_num 添加到 args 中‘‘‘
args[len(args)-1] = string
return args
lst = [1,2,3,4]
string = "ABC"
print(add_elem(lst,string))
# [1, 2, 3, ‘ABC‘]
print(lst)
# [1, 2, 3, ‘ABC‘]
Python函数参数：
注：变量没有类型，有类型的是变量指向的内存空间中的值
可变类型：列表、集合、字典
不可变类型：数字、字符串、元组
可变类型在函数中发生改变时，原变量也会跟着发生变化
列表使用 赋值，+=，append，extend，insert 方法均会使列表的值发生改变
位置参数：
实参必须以正确的顺序传入函数，调用时的数量必须与声明时一致
# 必需参数
def hello(name):
‘‘‘输出欢迎信息‘‘‘
print("hello {0}".format(name))
name = "XiaoMing"
hello(name)
# hello XiaoMing
# hello() 会报错，因为没有传入参数
关键字参数：
函数在调用时使用关键字确定传入参数的值(可以不根据参数位置)
注：关键字即为函数定义时使用的形参名
对应关键字名进行传递：
def add(num_1,num_2):
‘‘‘将两个数字进行相加‘‘‘
print("num_1:",num_1)
print("num_2:",num_2)
print("num_1 + num_2",num_1 + num_2)
add(num_2 = 6,num_1 = 8)
# num_1: 8
# num_2: 6
# num_1 + num_2 14
默认参数：
当调用函数时，如果没有传递参数，则会使用默认参数
如果传递了参数，则默认参数不起作用
注：程序有时会设置好已经修改好的默认参数，调用只需要传入不是默认参数的参数即可
# 默认参数
def add(num_1,num_2 = 10):
‘‘‘将两个数字进行相加‘‘‘
print("num_1:",num_1)
print("num_2:",num_2)
print("num_1 + num_2",num_1 + num_2)
# add(15)
# # num_1: 15
# # num_2: 10
# # num_1 + num_2 25
# 不传入 num_2 的值，使用 num_2 的默认参数
add(num_1 = 15)
# num_1: 15
# num_2: 10
# num_1 + num_2 25
# 传入 num_2 的值，不使用 num_2 的默认参数
add(num_2 = 6,num_1 = 8)
# num_1: 8
# num_2: 6
# num_1 + num_2 14
不定长参数：
当需要的参数不确定，又还想使用参数进行函数内的运算时，可以考虑不定长参数
不定长参数：
* 变量
1.形参使用 *变量名： 实参通常为传入的多余变量(可以是字典变量)、 列表 或 元组 等
如果实参使用了 *列表，*元组，则函数中接收的是列表或元组中的所有的元素值
2.形参使用 **变量名：通常为 **字典变量 或 字典元素(键值对) 等
示例：
# 不定长参数
def print_info(*vartuple):
print(vartuple)
# 调用 printinfo 函数
print_info(70, 60, 50)
# (70, 60, 50)
当不定长参数前面存在位置参数时：
传入参数的值先传递给位置参数，剩余的传递给不定长参数
注：如果没有剩余的实参，则不定长参数没有值
不使用位置参数：
可以接收所有数据类型数据，除了 a = 2 这种键值对，**字典变量等
注：如果实参中使用了 *列表，*元组，则函数接收的为列表或元组的所有元素值
def print_info(*vartuple):
# print(type(vartuple))
print(vartuple)
# for i in vartuple:
# print(i,end =" ")
# print(type(vartuple[5]))
#
# print(vartuple[5])# 不定长参数
# 不使用位置参数
def print_info(*vartuple):
# print(type(vartuple))
print(vartuple)
# for i in vartuple:
# print(i,end =" ")
# print(type(vartuple[5]))
#
# print(vartuple[5])
# 调用 printinfo 函数
print_info(70,12.3,5+9j,True,"hello",[1,2,3],(7,8,9),{‘a‘:123})
# (70, 12.3, (5+9j), True, ‘hello‘, [1, 2, 3], (7, 8, 9), {‘a‘: 123})
print_info([1,2,3])
# # ([1, 2, 3],)
print_info(*[1,2,3],‘a‘)
# (1, 2, 3, ‘a‘)
print_info((1,2,3))
# # ((1, 2, 3),)
print_info(*(1,2,3),‘a‘)
# (1, 2, 3, ‘a‘)
使用位置参数：
def print_info(num,*vartuple):
print(num)
print(vartuple)
# 调用 printinfo 函数
print_info(70, 60, 50)
# 70
# (60, 50)
** 变量名：
形参使用 **变量名：实参可以使用 a = 2、**字典对象
# ** 变量名：
# 形参使用 **变量名：实参可以使用 a = 2、**字典元素
def print_info(**attrs):
print(attrs)
print(type(attrs))
# <class ‘dict‘>
dic = {‘a‘:123}
print_info(**dic,b = 4,c = 6)
# {‘a‘: 123, ‘b‘: 4, ‘c‘: 6}
在形参中使用 * 和 ** 参数接收：
def print_info(num,*vartuple,**attrs):
print(num)
print(vartuple)
print(attrs)
# 调用 printinfo 函数
print_info(70, 60, 50,{‘a‘:123},b = 456,c = 789)
# 70
# (60, 50, {‘a‘: 123})
# {‘b‘: 456, ‘c‘: 789}
Python匿名函数：
使用 lambda 关键字创建匿名函数：
lambda 定义的函数只是一个表达式，而不是代码块
lambda 函数拥有自己的命名空间，不能够访问参数列表之外的 或 全局命名空间的参数
# 使 lambda 实现输出 x 的 y 次方
# 使用变量接收函数
cifang = lambda x,y:x**y
# 匿名函数的调用：使用接收到的变量进行调用
print(cifang(3,2))
# 9
# 拓展：使用变量接收函数名，然后可以使用变量进行函数调用
def print_info():
print("hello")
pr = print_info
pr()
# hello
return语句：
在函数内当遇到 return 语句时，退出函数并返回 return 后面的对象，可以是表达式 或 值
不带 return 语句的函数返回值为None,也就是没有返回值
def add_num(num_1, num_2):
# 返回 num_1 和 num_2 的和"
total = num_1 + num_2
print(total)
return total
# 调用 add_num 函数
# 使用变量接收函数的返回值
total = add_num(10, 20)
print(total)
# 30
# 30
Python变量作用域
运行 Python 程序时，Python会在作用域中依次寻找该变量，直到找到为止，否则会报错(未定义)
Python定义的变量并不是任意一个位置都可以进行访问的，主要根据变量的作用域。
局部作用域：比如在一个函数内部
全局作用域：一个 .py 文件中只要不是在函数内部，都是全局变量
内建作用域：
import builtins
print(dir(builtins))
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域
Python全局变量和局部变量：
定义在函数内的为局部变量，在外部访问局部变量会出现未定义的错误
定义在函数外的变量称为全局变量，可以在整个函数范围内访问
当函数中存在与全局变量重名的变量，以函数中的局部变量为准
定义在函数中的局部变量的作用域只在函数中
# 定义全局变量 total
total = 0
def add(num1,num2):
# 定义局部变量 total
total = num1 + num2
# 输出局部变量
print(total)
add(4,6)
# 10
print(total)
# 0
在函数内部，如果想要修改外部变量时，可以使用 global 关键字
global 全局变量名
在函数中使用全局变量，可以对全局变量进行修改。
注：如果只是在函数中使用了和全局变量相同的名字，则只是局部变量
# 定义全局变量 total
total = 0
def add(num1,num2):
# 使用 global 关键字声明全局变量 total
global total
total = num1 + num2
# 输出全局变量
print(total)
add(4,6)
# 10
# 输出全局变量
print(total)
# 10
nonlocal 嵌套作用域中的变量(嵌套函数，外层函数与内层函数之间)：
修改嵌套函数之间的变量
def func_out():
num = 5
def func_inner():
# 使用嵌套函数中的 num 值
nonlocal num
num = 10
print("最内部函数中的 num 的值：",num)
func_inner()
print("嵌套函数中的 num 的值：",num)
func_out()
# 最内部函数中的 num 的值： 10
# 嵌套函数中的 num 的值： 10
Python模块：包含了所有定义的函数和变量的文件，后缀名为 .py
将某些方法存放在文件中，当某些脚本 或 交互式需要使用的时候，导入进去。
导入的文件，就称为模块。导入之后就可以使用导入的文件的函数等功能
import math
# 导入 math 库
print(math.exp(1) == math.e)
# 导入 exp() 和 e
# True
import 语句：
import 模块名 或 包：调用方法，使用 模块名.方法
当解释器遇到 import 语句时，如果模块在 搜索路径 中，则模块会被导入
注：搜索路径是解释器进行搜索的所有目录名的一个列表。
在一个 .py 文件中创建函数，在另一个 .py 文件中导入
func.py
# 在 func 模块中定义一个 print_info 函数
def print_info():
print("我是在 func 模块内部的")
test.py
# 导入 func 模块
import func
# 调用自定义的模块函数
func.print_info()
# 我是在 func 模块内部的
一个模块只会被导入一次，无论使用多少次 import 语句，都只导入一次
from 模块名 import 语句
from 模块名 import 子模块 或 函数 或 类 或 变量
导入的不是整个模块，而是 import 后面的对象
注：在调用导入的模块函数使，不使用模块名.函数名 而是 直接使用函数名进行调用
func.py
# 在 func 模块中定义一个 print_info 函数
def print_info():
print("我是在 func 模块内部的")
def get_info():
print("获取到了 func 模块的信息")
test.py
# 导入 func 模块
from func import get_info
# 调用自定义的模块函数
get_info()
# 获取到了 func 模块的信息
注：没有导入 print_info 方法，使用会报错
from 模块名 import *
使用 函数 或 变量 直接进行使用
将模块内的所有内容都导入到当前的模块中，但是不会将该模块的子模块的所有内容也导入
导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，
那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入
from func import *
# 调用自定义的模块函数
print_info()
# 我是在 func 模块内部的
get_info()
# 获取到了 func 模块的信息
注：不导入 _ 单个下划线开头的变量或方法
2020-07-24
标签：范围 pow any ace 英文 module dig floor 需要
原文地址：https://www.cnblogs.com/hany-postq473111315/p/13375048.html
