P3
查看内置函数
dir(__builtins__)P4
变量名命名规则：
1、变量名不能以数字打头；
2、变量名可以是中文
字符串可以是：
1、单引号：文本中存在双引号时使用单引号
2、双引号：文本中存在单引号时使用双引号
当文本中既有单引号又有双引号时使用转义字符。
P5
原始字符串：在字符串前加 r ，转义字符将不再有效
>>> print("D:\three\two\one\now")
D: hree wo\one
ow
>>> print(r"D:\three\two\one\now")
D:\three\two\one\now反斜杠不能放在字符串的末尾，若某行的末尾是反斜杠，则说明字符串还没有结束。反斜杠可以让字符串跨行。
三引号：分为三单引号或三双引号，前后要对应，可以实现字符串的跨行而不需要行末的反斜杠。
字符串的加法和乘法：
1、加法：拼接
2、乘法：复制
P6
字符串的输入input方法：输入的是字符串，如需要数字则需要强转一下。
>>> temp=input("你是谁？")
你是谁？我是你霸霸
>>> temp
'我是你霸霸'
>>> num=input("请输入一个数字")
请输入一个数字8
>>> num
'8'
>>> NUM=int(num)
>>> NUM
8P7
if...else...语句：
a = 1
if a < 3:
print("a is small")
else:
print('a is big')
a = 5
if a < 3:
print("a is small")
else:
print('a is big')a is small
a is bigwhile循环：
counts = 3
while counts > 0:
print("I love HZQ")
counts = counts - 1I love HZQ
I love HZQ
I love HZQ
break语句：
跳出一层循环体。
P8
random模块
1、random.randint(a,b)函数，返回一个a~b的伪随机数；
2、random.getstate()函数，返回随机数种子
3、random.setstate(x)函数，设置随机数种子，
随机数种子相同时，生成的伪随机数顺序相同。
P9
1、python可以随时随地进行大数的计算。
2、python存储浮点数存在误差，浮点数并不是百分之百精确的，
>>> 0.1+0.2
0.30000000000000004
>>> i=0
>>> while i<1:
... i=i+0.1
... print(i)
...
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.09999999999999993、python要想精确地计算浮点数，需要 decimal 模块。
>>> import decimal
>>> a=decimal.Decimal('0.1')
>>> b=decimal.Decimal('0.2')
>>> print(a+b)
0.3
>>> c=decimal.Decimal('0.3')
>>> c==a+b
True4、科学计数法
>>> 0.0000000000005
5e-13
>>> 0.00000000004003002050403
4.003002050403e-115、复数
复数的实部和虚部都是浮点数的形式存储的
>>> a=1-2j
>>> a
(1-2j)
>>> a.real
1.0
>>> a.imagP10
1，x//y，地板除，结果向下取整。
2，abs(x)，返回x的绝对值，x为复数时返回模值。
3，complex(a，b)函数，括号中可以是两个数字表示实部和虚部，也可以是复数对应的字符串。
>>> complex(1,3)
(1+3j)
>>> complex('3+8j')
(3+8j)P11
1，布尔值为False的情况：
2，
and和or都是短路逻辑，下方代码中几种情况需要记住。
>>> 3 and 4
4
>>> 3 or 4
3
>>> "HZQ" and "LOVE"
'LOVE'
>>> '''HZQ''' and """LOVE"""
'LOVE'
>>> '''HZQ''' or """LOVE"""
'HZQ'P12
1，运算符优先级
P13
流程图
P14
P15、P16
1，基本结构：if.... elif.... else....
2，条件表达式：
score = 76
level = ("D" if 0 <= score < 60 else
"C" if 60 <= score < 70 else
"B" if 70 <= score < 80 else
"A" if 80 <= score < 100 else
"S" if score == 100 else
print("请输入0~100之间的数字"))
print(level)
运行结果：BP17
P18
1，continue，结束本轮循环，开始下一轮循环
2，while...else...语句：while后的条件不成立时，执行一次else后的操作
P19
1，for循环：
for 变量 in 可迭代对象 :
statement(s)>>> for each in "FishC":
... print(each)
...
F
i
s
h
C
>>> each
'C'1000不是可迭代对象，故以下代码报错
>>> for each in 1000 :
... print(each)
...
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable2，range()函数，用于生成数字序列，将数字变为可迭代对象，形式如下：
range(stop)
range(start,stop)
range(start,stop,step)
生成的序列包括start，不包括stop
>>> for i in range(10):
... print(i)
...
0
1
2
3
4
5
6
7
8
9
>>> for i in range(8,17,2):
... print(i)
...
8
10
12
14
16P20
列表索引，列表切片
P21
1，append()方法：列表添加一个元素
>>> a=[1,2,3]
>>> a
[1, 2, 3]
>>> a.append('q')
>>> a
[1, 2, 3, 'q']2，extend()方法：列表添加一个可迭代对象
>>> a
[1, 2, 3, 'q']
>>> a.extend([5,56,'gf'])
>>> a
[1, 2, 3, 'q', 5, 56, 'gf']3，切片添加元素
>>> a=[1,2,3,4,5]
>>> a[len(a):]=[6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> a[len(a):]=['qq',2,"ed"]
>>> a
[1, 2, 3, 4, 5, 6, 'qq', 2, 'ed']4，insert()方法， 指定位置插入元素
>>> a=[1,3,4,5]
>>> a.insert(1,2)
>>> a
[1, 2, 3, 4, 5]
>>> a.insert(0,0)
>>> a
[0, 1, 2, 3, 4, 5]
>>> a.insert(len(a),6)
>>> a
[0, 1, 2, 3, 4, 5, 6]5，remove()方法，删除列表元素，若有多个待删除元素，未指定时删除下标最小的一个。
>>> a=[1,2,3,4,5]
>>> a.remove(3)
>>> a
[1, 2, 4, 5]
>>> a=[1,2,4,3,4,4,5,6,7]
>>> a.remove(4)
>>> a
[1, 2, 3, 4, 4, 5, 6, 7]6，pop()方法，通过下标删除元素，同时返回删除的元素
>>> a
[1, 2, 3, 4, 4, 5, 6, 7]
>>> a.pop(3)
4
>>> a
[1, 2, 3, 4, 5, 6, 7]
>>> a.pop(5)
6
>>> a
[1, 2, 3, 4, 5, 7]7，clear()，清空列表
>>> a
[1, 2, 3, 4, 5, 7]
>>> a.clear()
>>> a
[]P22
1，s.sort(key=None,reverse=False)方法，对列表中的元素进行原地排序(key 参数用于指定一个用于比较的函数;reverse 参数用于指定排序结果是否反转)
2，reverse()方法，纯数字列表从大到小排序
3，count(a)，返回元素出现的次数
4，index(a，start，end)，返回元素的索引
5，copy()，拷贝列表
6，切片和copy都是浅拷贝，
*P23
1，对于嵌套列表，用乘法进行拷贝时，内存中开辟的空间是同一个；
判断是否在内存中开辟空间是同一个用 is 关键词
列表元素用*复制，指向同一内存空间，用*复制后在分别赋值，则指向不同空间；
>>> A=[0]*3
>>> for i in range(3):
... A[i]=[0]*2
...
>>> A
[[0, 0], [0, 0], [0, 0]]
>>> B=[[0]*2]*3
>>> B
[[0, 0], [0, 0], [0, 0]]
>>> A[1][1]=1
>>> B[1][1]=1
>>> A
[[0, 0], [0, 1], [0, 0]]
>>> B
[[0, 1], [0, 1], [0, 1]]2，两个相同的字符串分别赋值，即使不是用*复制的，内存空间也是指向同一个，因为字符串和列表不同，字符串是不可变的。
>>> a=[1,2,3]
>>> b=[1,2,3]
>>> a is b
False
>>> c="WAHZQ"
>>> d='WAHZQ'
>>> c is d
TrueP24
1，等号赋值单个变量，只是让两个变量地址相同，改变一个变量时，这个变量的地址将会改变，两个变量地址将不相同。
>>> a=2
>>> b=a
>>> a is b
True
>>> a=3
>>> b
2
>>> a is b
False等号赋值列表，是让两个变量列表地址相同，当改变其中一个列表的某一元素时，另一个列表中对应元素也改变。当对整个列表赋值时，这个列表的地址将会改变。
>>> a=[1,2,3,'qwe']
>>> b=a
>>> b is a
True
>>> b
[1, 2, 3, 'qwe']
>>> a[1]=5
>>> b
[1, 5, 3, 'qwe']
>>> b=[1,5,3,'qwe']
>>> b is a
False2，copy()方法，切片
copy()方法和切片不仅拷贝列表的引用，拷贝的是整个列表，拷贝后的列表与被拷贝的列表的地址不同，改变一个元素，另一个列表中对应元素的值不变。
>>> a=[1,2,3]
>>> b=a.copy()
>>> b
[1, 2, 3]
>>> a[1]=5
>>> b
[1, 2, 3]
>>> a is b
False
>>> c=a[:]
>>> a[0]=8
>>> c
[1, 5, 3]
>>> a is c
False3，深拷贝
copy()方法和切片可以拷贝一维列表，当二维列表时，将不能完成内层的拷贝。
>>> a=[[1,2,3],[4,5,6],[7,8,9]]
>>> b=a.copy()
>>> b
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> a[1][1]=0
>>> a
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> b
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]这时候就需要用到深拷贝了，即copy模块中的deepcopy()函数，copy模块中的copy()函数也是浅拷贝，但是浅拷贝的效率更高，速度快。
>>> import copy
>>> a=[[1,2,3],[4,5,6],[7,8,9]]
>>> b=copy.copy(a)
>>> b
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> a[1][1]=0
>>> b
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> c=copy.deepcopy(a)
>>> a[1][0]=0
>>> a
[[1, 2, 3], [0, 0, 6], [7, 8, 9]]
>>> c
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]is()方法验证：
>>> import copy
>>> a=[[1,2,3],[4,5,6],[7,8,9]]
>>> b=copy.copy(a)
>>> c=copy.deepcopy(a)
>>> d=a
>>> a is b
False
>>> a is c
False
>>> a is d
True
>>> a[1] is b[1]
True
>>> a[1] is c[1]
False
>>> a[1][1] is b[1][1]
True
>>> a[1][1] is c[1][1]
True故拷贝能力强弱顺序为：
(=赋值) < (copy方法、切片操作、copy模块中的copy函数) < （copy模块中的deepcopy函数）
对于深层拷贝，再多一层还是可以完美拷贝：
>>> a=[[[11,13,14],2,3],[4,5,6],[7,8,9]]
>>> e=copy.deepcopy(a)
>>> e
[[[11, 13, 14], 2, 3], [4, 5, 6], [7, 8, 9]]
>>> a[0][0][0]=22
>>> a
[[[22, 13, 14], 2, 3], [4, 5, 6], [7, 8, 9]]
>>> e
[[[11, 13, 14], 2, 3], [4, 5, 6], [7, 8, 9]]P25
ord()函数：将字符转换为Unicode编码
列表推导式
>>> oho=[1,2,3,4,5]
>>> x=[i*2 for i in oho]
>>> x
[2, 4, 6, 8, 10]
>>> y=[i+1 for i in range(10)]
>>> y
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]P26
1，列表推导式创建二维列表
>>> a=[[0]*3 for i in range(3)]
>>> a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> a[1][1]=2
>>> a
[[0, 0, 0], [0, 2, 0], [0, 0, 0]]
>>> b=[[0]*3]*3
>>> b
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> b[1][1]=2
>>> b
[[0, 2, 0], [0, 2, 0], [0, 2, 0]]列表推导式后还可加 if 条件限制：
>>> y=[i+1 for i in range(10) if i%2==0]
>>> y
[1, 3, 5, 7, 9]这个列表推导式的运行顺序是：
（1）for i in range(10)
（2）if i%2==0
（3）i+1
2，嵌套的列表推导式
根据列表推导式的运行顺序可推出嵌套列表推导式
>>> a=[[1,2,3],[4,5,6],[7,8,9]]
>>> b=[i*2 for j in a for i in j]
>>> b
[2, 4, 6, 8, 10, 12, 14, 16, 18]P27
1，元组：元素不可变，元组用的是圆括号。元组也可以省略括号，用逗号隔开就可以。
2，元组支持切片，
3，列表中有增删改查，到元组就只有了查，即count()和index()方法
4，没有元组推导式
5，生成只有一个元素的元组：需要有逗号
>>> a=(520)
>>> type(a)
<class 'int'>
>>> b=(520,)
>>> type(b)
<class 'tuple'>6，元组的打包和解包，字符串、列表也可以打包和解包。
>>> x=1
>>> y=2
>>> z=3
>>> t=(x,y,z)
>>> t
(1, 2, 3)
>>> (a,b,c)=t
>>> a
1
>>> b
2
>>> c
3
>>> a,b,c,d='hjdk'
>>> a
'h'
>>> c
'd'解包时等号左侧的变量数个右侧元素数需相等，不相等时报错，可以在最后一个变量上加*来解决。
>>> a,b,c="ahjjdk"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)
>>> a,b,*c="ahjjdk"
>>> a
'a'
>>> b
'h'
>>> c
['j', 'j', 'd', 'k']7，元组元素不可变，当元组中的元素指向一个可以修改的列表时，这个元组元素列表中的元素可以改变
>>> s=[1,2,3]
>>> t=[5,6,7]
>>> w=(s,t)
>>> w
([1, 2, 3], [5, 6, 7])
>>> w[0][1]=10
>>> w
([1, 10, 3], [5, 6, 7])P28、P29、P30、P31
1，判断字符串是否是回文字符串：
>>> x='12321'
>>> "是回文数" if x==x[::-1] else "不是回文数"
'是回文数'
>>> x='12345'
>>> "是回文数" if x==x[::-1] else "不是回文数"
'不是回文数'2，字符串相关的众多方法：
（1）~（6）主要是大小写字母的变换。
（1）capitalize()：返回首字母大写，其他字母小写的字符串
>>> x="I love Hzq"
>>> x.capitalize()
'I love hzq'（2）casefold()：返回所有字符都是小写的字符串
>>> x="I love Hzq"
>>> x.casefold()
'i love hzq（3）title()：返回每个单词的首字母都变成大写，剩下的字母变成小写
>>> x="I love Hzq"
>>> x.title()
'I Love Hzq'（4）swapcase()：所有字母大小写反转
>>> x="I love Hzq"
>>> x.swapcase()
'i LOVE hZQ'（5）upper()：全部大写
（6）lower()：全部小写，只能处理英语，casefold()不仅英语，还可以其他语言
（7）~（10）左中右对齐
（7）center(width , fillchar = '')：width如果比原字符串小，则直接原字符串输出，如果比原字符串大，则宽度保持width，不足的部分用空格填充，字符串居中；不设置fillchar时默认空格填充，设置后以设置的fillchar填充。
（8）ljust(width , fillchar = '')：左对齐，其余同上
（9）rjust(width , fillchar = '')：右对齐，其余同上
（10）zfill(width)：字符串靠右，0填充左侧；也适合负数情况，负数时，负号会被移到最左侧。
>>> x="I love Hzq"
>>> x.center(15)
' I love Hzq '
>>> x.center(15,'_')
'___I love Hzq__'
>>> x.ljust(16)
'I love Hzq '
>>> x.rjust(16)
' I love Hzq'
>>> x.zfill(16)
'000000I love Hzq'（11）~（15）查找
（11）count(x,start,end)：包括索引为star的元素，不包括索引为end的元素
（12）find(x,start,end)：从左往右找，返回第一个找的的元素的索引，找不到的话返回-1
（13）rfind(x,start,end)：从右往左找，返回第一个找的的元素的索引，找不到的话返回-1
（14）index(x,start,end)：和find()类似，找不到不到字符串时，报错
（15）rindex(x,start,end)：和rfind()类似，找不到不到字符串时，报错
（16）~（18）替换
（16）expandtabs([tabsize=8])：将字符串中的tab替换为空格，返回字符串，参数代表一个tab代表多少个空格
（17）replace(old,new,count=-1)：将字符串中的old替换为new，count为替换的个数，默认为全部。
>>> a="yuuiijhgfb"
>>> a.replace('u','U')
'yUUiijhgfb'
>>> a.replace('u','U',5)
'yUUiijhgfb'（18）translate(table)：table代表的是一个映射关系，即将原字符串按照table进行映射，并返回映射后的字符串。
>>> a="I love Hzq"
>>> table=str.maketrans("abcdefg","1234567")
>>> a.translate(table)
'I lov5 Hzq'
// str.maketrans("abcdefg","1234567") 表示创建一个映射关系，
//该函数还支持第三个参数 str.maketrans("abcdefg","1234567","str")，表示将 str 忽略掉（删掉）。（19）~（33）表示对字符串的判断
（19）startswith(x,start,end)：判断指定字符串是否在待判断字符串的起始位置，x可以是一个元组，将多个待匹配的字符串写进去，若有一个匹配成功，即返回True
（20）endswith(x,start,end)：判断指定字符串是否在待判断字符串的结束位置，x可以是一个元组，将多个待匹配的字符串写进去，若有一个匹配成功，即返回True
>>> a="我爱python"
>>> a.startswith(('我','你','她'))
True（21）isupper()：全大写字母，返回True
（22）islower()：全小写字母，返回True
（23）istitle()：所有单词以大写字母开头，其余小写，返回True
（24）isalpha()：判断是否全以字母构成
（25）isascii()：
（26）isspace()：判断是否是空白字符串，空白包括：空格、Tab、\n、
>>> ' \n'.isspace()
True（27）isprintable()：判断字符串是否是可打印的，其中 转义字符、空格 不是可打印字符
>>> ' \n'.isprintable()
False
>>> ' '.isprintable()
False
>>> ' love '.isprintable()
False
>>> 'love'.isprintable()
True（28）isdecimal()：判断数字，能力最弱
（29）isdigit()： 判断数字，能力居中，可判断（）
（30）isnumeric()：判断数字，能力最强，可判断（ⅠⅡⅢ...和一二三...）
（31）isalnum()： 判断数字，能力第一，上述三个一个为True，这个就为True
（32）isidentifier()：判断字符串是否是python的合法标识符（空格不合法，下划线合法；数字开头的字符串不合法）
>>> 'I love'.isidentifier()
False
>>> 'I_love'.isidentifier()
True
>>> 'love520'.isidentifier()
True
>>> '520love'.isidentifier()
False（33）keyword模块中的iskeyword(str)函数：判断是否是关键字
>>> import keyword
>>> keyword.iskeyword('if')
True
>>> keyword.iskeyword('py')
False（34）~（38）字符串截取
（34）strip(char=None)：删掉字符串左边和右边的指定字符，默认为空格
（35）lstrip(char=None)：删掉字符串左边的指定字符，默认为空格
（36）rstrip(char=None)：删掉字符串右边的指定字符，默认为空格
>>> ' I love '.lstrip()
'I love '
>>> ' I love '.rstrip()
' I love'
>>> 'www.Iloveyou.com'.lstrip('w.I')
'loveyou.com'
>>> 'www.Iloveyou.com'.rstrip('.mo')
'www.Iloveyou.c'
>>> 'www.Iloveyou.com '.rstrip(' .mo')
'www.Iloveyou.c'
>>> 'www.Iloveyou.com '.rstrip('.mo')
'www.Iloveyou.com '（37）removeprefix(prefix)：删除前缀（整体）
（38）removesuffix(suffix)：删除后缀（整体）
>>> 'www.Iloveyou.com'.removeprefix('www.')
'Iloveyou.com'
>>> 'www.Iloveyou.com'.removesuffix('.com')
'www.Iloveyou'
>>> 'www.Iloveyou.com '.removesuffix('.com')//原字符串在.com后加了一个空格
'www.Iloveyou.com '（39）~（）字符串拆分、拼接
（39）partition(sep)：从左到右找一个sep字符串，以sep为界，返回元组（'左'、'sep'、'右'）
（40）rpartition(sep)：从右到左找一个sep字符串，以sep为界，返回元组（'左'、'sep'、'右'）
>>> 'www.Iloveyou.com '.partition('.')
('www', '.', 'Iloveyou.com ')
>>> 'www.Iloveyou.com '.rpartition('.')
('www.Iloveyou', '.', 'com ')（41）split(sep=None,maxsplit=-1)：从左到右找到maxsplit个sep，默认为全部，并以此分割成若干字符串元素的列表，分界处的sep删去
（42）rsplit(sep=None,maxsplit=-1)：从右到左找到maxsplit个sep，默认为全部，并以此分割成若干字符串元素的列表，分界处的sep删去
（43）splitlines()：以行进行分割，换行符可以是\n、\r、\r\n ，括号中写True时，换行符写进前一个元素中。
（44）join(iterable)：字符串拼接，join拼接比加号拼接快，大量需要拼接时，join节省大量时间。
>>> '.'.join(['www','Iloveyou','com'])
'www.Iloveyou.com'
>>> '.'.join(('www','Iloveyou','com'))
'www.Iloveyou.com'P32、P33
1，格式化字符串format()函数
>>> "love you {} years".format(num) //位置索引
'love you 10000 years'
>>> '{}看到{}很激动'.format('我','你') //位置索引
'我看到你很激动'
>>> '{1}看到{0}很激动'.format('我','你') //位置索引
'你看到我很激动'
>>> '{1}看到{1}很激动'.format('我','你') //位置索引
'你看到你很激动'
>>> '{a}看到{b}很激动'.format(a='我',b='你') //关键字索引
'我看到你很激动'
>>> '{0}看到{b}很激动'.format('我',b='你') //关键字索引和位置索引杂交
'我看到你很激动'2，在字符串中显示花括号
>>> '{},{},{}'.format(1,'{}',2)
'1,{},2'
>>> '{},{{}},{}'.format(1,2)
'1,{},2'3，格式化字符串
>>> '{:^}'.format(250)
'250'
>>> '{:^10}'.format(250)
' 250 '
>>> '{1:>10}{0:<10}'.format(520,250)
' 250520 '
>>> '{left:>10}{right:<10}'.format(left=520,right=250)
' 520250 '
>>> '{:010}'.format(520)
'0000000520'
>>> '{:010}'.format(-520)
'-000000520'
>>> '{1:%>10}{0:%<10}'.format(520,250)
'%%%%%%%250520%%%%%%%'
>>> '{:0=10}'.format(520)
'0000000520'
>>> '{:0=10}'.format(-520)
'-000000520'
>>> '{:=10}'.format(-520)
'- 520'
>>> '{:+}{:-}'.format(520,-250)
'+520-250'
>>> '{:,}'.format(12345)
'12,345'
>>> '{:.2f}'.format(3.14159)
'3.14'
>>> '{:.2g}'.format(3.14159)
'3.1'
>>> '{:.6}'.format('I love you')
'I love'
>>> '{:b}'.format(80)
'1010000'
>>> '{:c}'.format(80)
'P'
>>> '{:d}'.format(80)
'80'
>>> '{:o}'.format(80)
'120'
>>> '{:x}'.format(80)
'50'
>>> '{:#b}'.format(80)
'0b1010000'
>>> '{:#c}'.format(80)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Alternate form (#) not allowed with integer format specifier 'c'
>>> '{:#d}'.format(80)
'80'
>>> '{:#o}'.format(80)
'0o120'
>>> '{:#x}'.format(80)
'0x50'适用于浮点数、复数：
>>> '{:e}'.format(3.14159)
'3.141590e+00'
>>> '{:E}'.format(3.14159)
'3.141590E+00'
>>> '{:f}'.format(3.14159)
'3.141590'
>>> '{:g}'.format(123456789)
'1.23457e+08'
>>> '{:g}'.format(123.456789)
'123.457'
>>> '{:%}'.format(0.98)
'98.000000%'
>>> '{:.2%}'.format(0.98)
'98.00%'
>>> '{:.{prec}f}'.format(3.1415,prec=2)
'3.14'3，f-字符串：代替format()函数，python3.6以后的版本才能用
>>> F"I love you {num} year"
'I love you 10000 year'
>>> F"{-520:010}"
'-000000520'所有的格式化都可以用F-字符串代替format()函数
