Python学习笔记（一）_表达式3>5anda

注：文中部分知识、截图和例子来源中国大学MOOC浙江大学Python程序设计以及北京理工大学Python语言程序设计，除此之外均进行了对应博文的引用，仅用于自学和记录。如有问题欢迎指出！

Python学习笔记（一）

1.标识符和变量

1.1 标识符

标识符由字母、下划线和数字组成，不能以数字开头，不能有"!"等特殊符号。标识符区分大小写，如Test 和 test 是不同的标识符。还有一些单词属于关键字，如class，False等，在自定义标识符时应当避免（否则程序会因为无法判断而无法运行）。

注：关键字可以理解为其在Python中预先定义好了相关含义，如True是用来判断是否为真。当所设置标识符与关键字冲突 程序执行过程中便无法判断如何执行。如下为常见的关键字。（关键字也是区分大小写的，比如true为一个普通的标识符，True为一个关键字）

1.2 变量和常量

1.2.1 常量

常量是指不能改变的量。
Python未如同C等使用const定义常量，如要设置常量可通过自定义类实现。
具体实践可见如下博文：
https://blog.csdn.net/cxj540947672/article/details/114633143

1.2.2 变量

变量是值可以改变的量，变量可以进行不同类型的变化，不需要事先的声明和定义（如c语言中定义一个整形变量r需要 int r；在python中不需要定义r。给r赋什么类型的值，变量即为什么类型）。变量名是为了方便引用内存中的值而取的名称。

注：
<1>变量名必须是正确的标识符（所以大小写是不一样的），但不可是关键字（程序执行的时候会显示无效定义）或Python的内置函数（如sum这类常用的求和函数 作为变量名赋值后便无法再利用sum进行相关求和操作，若要恢复则可用语句del(sum)恢复）。在Python3中还允许变量名是中文字符。

<2>Python的变量赋值本质上是将名字和对象相关联，赋值操作不会实际复制值，使用id(object)函数可以显示object对象在其生命周期上的内存地址。如 a = 1语句的执行过程是新申请一段内存来存储对象1，再让x指向对象1。

Python对象值的大小会影响内存分配。Python内部设置了一个小整数池，数值范围为-5到256，其内存已经分配完成，当对象值为小整数池范围内的数时，不再分配内存，高效率（故当变量名不同但对象为小整数池内的数时，其指向的id相同）；而对象为其余大整数或者其他对象时， python将重新分配内存空间（即便对象值相同，Python也会分别申请一段内存来存储该对象，故其指向的id不相同）。

>>> a=1
>>> b=1
>>> id(a)
140734245426848
>>> id(b)
140734245426848
>>> id(1)
140734245426848
1
2
3
4
5
6
7
8

结果发现其实Python设置的变量a与变量b的指向的地址指向就是数据对象1的地址（对比C语言 设置变量a和变量b系统会分配两个存储单元）

>>> a=1000
>>> b=1000
>>> id(a)
1850019900304
>>> id(b)
1850019900368
>>> id(1000)
1850020572240
1
2
3
4
5
6
7
8

超过小整数池范围，分别申请一段内存存储1000，故a b指向的内存地址不同。

具体内容详见如下：
https://blog.csdn.net/zhuzuwei/article/details/80554776

2.输入与输出函数

2.1输入函数input()

使用input()函数读入的是一个字符串。（所有形式的输入都会按照字符串进行处理）如果想要其他类型的输入，则需要通过强制类型的转换来实现，默认情况下没有提示字符串显示。
2.1.1正常基本输入

>>> a=input()
123
>>> a
'123'
>>> type(a)
<class 'str'>
1
2
3
4
5
6

随意输入一个数，类型仍然为字符串。

2.1.2 其他类型的输入

>>> a=int(input())
123
>>> a
123
>>> type(a)
<class 'int'>
1
2
3
4
5
6

通过强制转换可以将输入类型转换，但是假如强制转换类型为int但是输入字符串，系统会直接报错

2.1.3多变量的输入

>>> a,b=input().split()
12 34
>>> a
'12'
>>> b
'34'
1
2
3
4
5
6

通过split()函数可以进行多变量的依次输入（但是不能与强制转换一起使用，可以输入后再对其进行强制转化）

2.1.4 带提示字符串显示的输入

>>> a=input("请输入：")
请输入：12
>>> a
'12'
1
2
3
4

可以配合强制转换 多变量输入等一起使用

2.2输出函数print()

print可以输出变量或者常量值，print()函数默认会换行，同时进行多个变量输出时则默认不换行（如若不想换行，可以使用end函数改变默认的换行操作）
注意，end使用‘’和“”改变换行的效果相同

>>> a=1
>>> b=2
>>> print(a)#单变量输出
1
>>> print(a,b)#多变量输出
1 2
>>> for i in range(5):#利用for循环输出
	print(i)
0
1
2
3
4
>>> print(3,"",4,"   ",5,end="")#一行的多个输出 使用end函数
3  4     5
>>> for i in range(5):#不带换行的多个输出 使用end函数
	print(i,end='')	
01234
>>> print("hello")#常量输出
hello
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.数据类型

3.1 数字类型

3.1.1 整数（int）

整数与数学中整数概念一致，可正可负（数字前面加符号表示正负即可），默认情况下为十进制（其他进制表示可以在前面加前导符表示），Python不会由于超出整数范围而出现溢出的现象（达到界限后会自己转为long），直接可以处理超大数。

3.1.2 浮点数（float）

与数学中实数范围一致，取值范围与精度都有限制。可用小数表示（如1.23，-1.23），也可用科学计数法表示（1.23*10^9 可以写作1.23e9，0.001可以写作1e-3）。浮点数运算过程中可能会有误差（在小数点很多很多位以后存在不确定尾数，这是由于计算机在存储过程中使用二进制存储，使用十进制计算，两个进制的转化过程中的误差导致的）

如何消除不确定尾数？可以使用round函数实现！

>>>0.1+0.2== 0.3
>False
>>> 0.1+0.2
0.30000000000000004
>>>round(0.1+0.2,2)== 0.3  
#round(0.1+0.2,2)表示保留两位小数的相加
>True

1
2
3
4
5
6
7
8

3.1.3 复数（complex）

Python中的复数概念与数学中的复数概念一致，可以用complex（）函数创建。复数由实部和虚部组成，虚部用j表示。其中用real方法取实部，imag方法取虚部。complex（）函数可用于创建一个值为real +imag*j 的复数，也可以实现其他类型向复数类型的转化。
注：实部部分数据类型可以为 int,long,float或字符串；虚部部分数据类型可以为int,long,float。如果第一个参数为字符串，则不需要指定第二个参数，否则会出错。字符串里可以是具体的浮点数，整数，复数，不能写成它们的运算式。但若参数为具体的数值，就可以写成他们的运算式。

>>> a=complex(1,2)
>>> a
(1+2j)
>>> a.real
1.0
>>> a.imag
2.0
1
2
3
4
5
6
7

转化尝试：

>>> a = complex('22')
>>> a
(22+0j)

>>> a=complex(22.56,0.5)
>>> a
(22.56+0.5j)
1
2
3
4
5
6
7

3.2 运算符

3.2.1 常见的算术运算符

注：
<1>整数除法是数轴上向左取整，如-3//2=-2 3//2=1
<2>Python支持浮点数求余运算，A%B求得的余数是A - n*B的余数（这里的n被定义为不超过A/B的一个最大整数）注意！这里的余数仍具有浮点数的性质，即会有不确定的尾数

3.2.2 运算符优先级及结合性

在进行相应运算时，先根据优先级进行运算，优先级相同时，可根据结合性的方向（图中为右代表从右往左运算）进行运算。

（图表来源：http://c.biancheng.net/view/2190.html）

插眼！补充各类运算符，可参考图表来源blog

（1）逻辑运算符

and 运算（C中的&，与运算）：同真则真，有假则假
or 运算（C中的||，或运算）：有真则真，同假则假
not运算（非运算）：真变假，假变真。在not运算中，对于所有非0值都会被认为其逻辑值为真，0值认为其逻辑值为假。

example 1：
>>> 3>5 and a>3	#3<5的值为False 此时并没有定义变量a，计算得出结果
False
example 2：
>>> 3>5 or a>3	#3>5的值为False 所以需要计算后面
NameError: name'a'is not defined	#提示a未定义
example 3：
>>> 3<5 or a>3	#3<5的值为True，此时并没有定义变量a，计算得出结果
True
example 4：
>>> 3 and 5	#！！！注意：最后一个计算的表达式的值作为整个表达式的值
5
example 5：
>>> 3 and 5>2
>True
example 6：
>>>not 3
False
>>>not 0
True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注：example 1和 3 没有报错而example 2 报错是因为在计算过程中的短路原则，在and运算中若第一个逻辑量为假（如example 1中的3 < 5）则不进行第二个逻辑量的计算直接给出结果；在or运算中若第一个逻辑量为真（如example 3中的3 < 5）则不进行第二个逻辑量的计算直接给出结果。

（2）比较运算符（关系运算符）

比较运算符可以进行数值的比较，也可以进行字符串大小的比较，但是不可以进行数值与字符串的比较。
对于字符串的比较，是将两个字符串从头开始逐位进行ASCII码的比较。如判断“123”（字符串A）<=“23”（字符串B），则是先比较A[0]和B[0]的大小，即A串中的1和B串中的2。因为1<2所以“123”<="23"比较结果为True（若相同则继续比较后续位）。

>>> 1<2<3	#等价于1<2 and 2<3
True	#and运算符：同真则真，有假则假
>>> 1>2<3	#等价于1<2 and 2<3
False
>>> import math	#引入sqrt函数
>>> 1>6<math.sqrt(9)
False
>>> 'Hello'> 3	
TypeError: unorderable types: str()>int()	#字符串和数字不能比较，程序报错
1
2
3
4
5
6
7
8
9

3.3 数学函数库（math）

Python提供的常用数学函数如下：

注：
<1> 使用数学函数的时候首先要import math（导入数学函数库），使用数学函数时要math.函数名调用使用，如math.pow（2,3）
<2> round函数调用，可以不用math.函数名，其舍入规则不是四舍五入！当不写n时，则保留到整数值。
详见https://blog.csdn.net/qq_52007481/article/details/123776922

4.序列类型容器

（1）len函数

可以用来计算序列的长度

s=['a','b','c','d','e']	#列表
>>> len(s)	#计算长度
5
>>> s[len(s)-1]	#借助len函数找列表最后一位
'e'
>>> ss='abc' #字符串
>>> len(ss)
3
>>> ss[len(ss)-1]
'c'
1
2
3
4
5
6
7
8
9
10

（2）min/max函数

其中的数字是按照数字大小比较，对于字符是按照Unicode的顺序进行比较

4.1 字符串

4.1.1 字符串表达方式

Python没有单字符类型，即使是一个字符也会被认为是字符串。字符串是以引号括起来的任意文本，是一个有序序列。可以用单引号（‘hello’），双引号（“hello”），三引号（‘’‘hello’‘’）表示。其中三引号可以包含多行文本的形式。
注意！字符串是不可修改的

大段文字的输入：
example1：使用三引号进行多行文本的输出
>>> '''this
is
a
good  
boy'''
'this\nis\na\ngood  \nboy'#在输入good的时候后面输入了两个空格后换行
>>> s='''this
is
a
good  
boy'''
>>> s
'this\nis\na\ngood  \nboy'
>>> print(s)
this
is
a
good
boy
----------------------------------
example2：用\符号表达这一行的结尾时，其实是表达我这一行的内容还没有结束，下一行内容要紧紧跟在这一行的后面，故不会把\n作为一种输入
>>> s='this\
is\
a\
good  \
boy.\
   '
>>> s
'thisisagood  boy   '
>>> print(s)
thisisagood  boy   
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
32
33

Python中有许多转义字符：

注：<1>如在字符串中输入“ ’ ”其实是输入单引号“ ’ ”( \ 符号只是为了辅助输入)。若本身字符串中有“ \ ”字符，则可以输入\用以输入“ \ ”字符。如果字符串中包含单引号，则可以用双引号、三引号括起来（即可以不使用转义字符）；如包含双引号同理。

>>> "I'm a good boy"	#使用双引号规避单引号输入的问题
"I'm a good boy"
>>> 'I\'m a good boy'	#使用转义字符规避单引号输入的问题
"I'm a good boy"
1
2
3
4

<2>在字符串中的 \n使用print输出时，会换行

>>> 'this is a good\nand excellent boy'
'this is a good\nand excellent boy'
>>> s='this is a good\nand excellent boy'
>>> s
'this is a good\nand excellent boy'
>>> print(s)
this is a good
and excellent boy
1
2
3
4
5
6
7
8

<3>\t是制表位，会帮助下一个字符出现在某个特定的位置上，跟输出的终端有关。其不表示要输出几个空格，而是要将下一个字符推到某个空格位上去

>>> 'this is a good\tand excellent boy'
'this is a good\tand excellent boy'
>>> s='this is a good\tand excellent boy'
>>> s
'this is a good\tand excellent boy'
>>> print(s)
this is a good  and excellent boy
1
2
3
4
5
6
7

<4>如在字符串前面有一个r，其意为round，表达的意思是这个字符串是一个原始的字符串，里面所有的 \ 不被认为是转义字符的前缀。所以直接输出该字符串 \ 会被还原成 \ 的形态。

>>> s=r'this\nis\na\ngood\nboy/'
>>> s
'this\\nis\\na\\ngood\\nboy/'
>>> print(s)
this\nis\na\ngood\nboy/
1
2
3
4
5

<5>\ooo中的ooo是三位八进制数（可少于三位，如图中所示）；\xyy中的x是用以表示要输入十六进制数，yy可以是输入的十六进制对应字符。

4.1.2 字符串运算符

注意，字符串只能和字符串相加，不能和数值进行相加，否则会报错。

in 和not in可以用来判断某个字符是否在字符串内

>>> s = 'abcde'
>>> 'a' in s
True
>>> 'abc' in s
True
>>> 'f'in s
False
>>> 'f'not in s
True
1
2
3
4
5
6
7
8
9

4.1.3 字符串函数

因为字符串是不可修改的，所以所有的字符串函数都不会修改字符串本身，做的事情都是根据.左边的函数去做一定的计算产生一个新的字符串。

#1.lower函数：把字符串中所有的字母都变成小写
>>> s='JR Smith'
>>> s1=s.lower()
>>> s1
'jr smith'
>>> s
'JR Smith' #函数不修改原字符串
#2.find函数:在字符串中找子字符串的位置
>>> s='JR Smimthm'
>>> s.find('mi') #若能找到该子字符串，返回子字符串首字符位置编号
4
（PS：也可以写作'JR Smimthm'.find('mi'),其余函数同理）
>>> s.find('jo') #若不能找到该子字符串，返回-1
-1
>>> s.find('m') #如果有多个相同的要找的子字符串，返回第一个子字符串的首个字符位置
4
>>> s.find('m',5,7) #find函数提供第2、3个参数，用以表示寻找的起始编号位置以及结束编号位置
6 #找到的是编号范围（实际查找范围是编号5-6）内要找的子字符串的首个字符位置
#3.count函数:在字符串中找某个子字符串出现的次数
>>> s='hello world'
>>> s.count('l')
3
#3.strip/rstrip/lstrip函数:去掉字符串左右两边/右边/左边的空格
>>> s=' hello world '
>>> s.strip()
'hello world'
>>> s.rstrip()
' hello world'
>>> s.lstrip()
'hello world '
#4.replace函数:替换一段字符串为其他的内容
>>> s=' hello world '
>>> s.replace(' ','--')
'--hello--world--'
>>> s.replace(' ','')
'helloworld'
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
32
33
34
35
36

4.1.4 字符串索引及切片

#字符串中取单一元素方法1：借助系统编码实现
>>> s='abcdefgh'
>>> s[0]	#如上图所示，正向编码0所处位置为第一个数字
'a'
>>> s[-8]
'a'
>>> s[-1]	#如上图所示，负向编码-1所处位置为最后一个数字
'h'
#字符串中取单一元素方法2：借助[ ]+程序编码实现
>>> 'abcdefgh'[0] 
'a'
>>> 'abcdefgh'[-1] 
'h'
1
2
3
4
5
6
7
8
9
10
11
12
13

切片其实就是从一个序列中找到连续的一段元素

字符串的切片可以做如上理解，[2:6]就是从编号2的前面和编号6的前面切了一刀，中间为保留的部分，所以实际包含的为序列编号2~5的元素。
如果要从编号为0的位置开始切片，可以省略[ ]的第一个数字，如[:5]表示切下从编号0到编号4的元素；如果切到字符串的最后，可以省略[ ]的最后一个数字，如[5:]表示切下从编号5到最后的元素；如果后面要只切掉最后一个数字，则可以通过[x:-1]来实现（其中x表示前面切的位置，也可以是-2 -3 根据自己需要）

>>> s[1:5]	#切从编号1到编号4的字符
'bcde'
>>> '26C'[0:-1]	#省略最后一个数字的切片
'26'
>>> '26C'[1:-1]
'6'
>>> '26C'[:-1]	#省略切片第一个数字表示从编号0开始切片
'26'
>>> '26C'[1:]	#省略切片第二个数字表示切片到字符串最后
'6C'
1
2
3
4
5
6
7
8
9
10

4.1.5 字符串与数字的转化

（1）str函数

str函数是一个全局的自由函数，不是一个字符串的函数。给它一个任何类型只要它认识都可以转化为字符串表达，但是不能指定格式。

>>> str(123)
'123'
>>> str(123.45)
'123.45'
1
2
3
4

（2）%-字符串的格式化运算符

如在%的左边如果是一个字符串的话可以做一个字符串的%运算。要在%的前面字符串里面放一些格式限定符，这些格式限定符将来会被百分号右边的数据替换掉。

'l am %d year old.'% 18
'l am 18 year old.'
>>> 'I am %d years old and weight %d_kg.' %(18,50)
'I am 18 years old and weight 50_kg.'
>>> 'it is %.1fC.'%30.5
'it is 30.5C.'
>>> 'it is %.1fC.'%30.5123
'it is 30.5C.'
>>> 'it is %.1fC.'%30.574 #自动去计算四舍五入保留小数
'it is 30.6C.'
>>> 'I am %10d years old'%18 #%和d之间的数字10表达的是我们需要这个数字占据多宽的一个位置
'I am         18 years old'
>>> 'it is %10.1fC.'%30.5123 #%和.之间的数字10表达的是我们需要这个数字占据多宽的一个位置
'it is       30.5C.'
1
2
3
4
5
6
7
8
9
10
11
12
13
14

插眼：%e表示科学计数法 %s表达字符串 %o及%x表示八进制和十六进制 课件补充

4.2 列表

4.2.1 列表概念

列表由0个或多个元素组成，元素之间用逗号隔开，整个列表被方括号包裹。列表中的元素类型可以相同也可以不同（与C中数组必须是同种元素类型不同），通过序号可以引用列表中的元素。注意：列表的元素可以是列表！如[[1,2],3]这是一个合法的列表。

4.2.2 列表的特殊性

（1）列表创建

<1>使用基本语法创建
字面量(literal)是以变量或者常量给出的原始数据。同字符串一样，列表可以用字面量创建，但是列表的字面量不是常量（其他编程语言中都是常量），实际上是一个表达式。

>>> a=1
>>> b=2
>>> t=[a,b]
>>> t
[1, 2]
>>> t=[a+1,b+a]	
#列表在字面量上可做操作，受到a，b取值的影响，是一个动态的
>>> t
[2, 3]
1
2
3
4
5
6
7
8
9

<2>list函数创建
可使用list函数创建空列表 或将字符串转化为列表进而创建列表，详见4.2.5（1）部分；

<3>结合range函数创建整数列表
详见6.3.2 range函数介绍部分；

<4>列表推导式
详见6.4部分。

注：该部分内容参考自https://blog.csdn.net/linux_tcpdump/article/details/122914050

（2）广义表

当列表的元素本身也是列表的时候，其就形成了一种广义表。广义表是表的元素也是表，如果广义表是整齐的，就构成了一个多维链表，如同一个矩阵一样。

>>> t=[[1,2,3],[4,5,6],[7,8,9]]	#可以将其看成是一个3*3的矩阵
>>> t[0]
[1, 2, 3]
>>> t[0][0]
1
1
2
3
4
5

（3）列表的管理者特性

Python中列表(t1,t2)实际是列表的管理者而非所有者。因此，列表的赋值操作，其实是共享了对某个元素的管理权，而不是列表本身的复制。
令t1=[1,2,3]，则t1管理这个[1,2,3]的列表

令t2 = t1 没有做列表本身的复制操作，而是t1将管理权分享给了t2，共同管理

让t2[0]=0，其实是通过t2的管理将t2管着的列表的第一个元素变成了0

所以print(t1[0])就等于0（因为t1和t2管着的是同一个列表）
因此，若想让t2获得t1中的所有元素和顺序，且不是共同管理，可以使用切片操作，即

>>>t2 = t1[:]
1

4.2.3 列表运算、索引及切片

（1）基本操作（同字符串）

列表支持加法、乘法、比较、索引、切片等操作。（基本上同字符串详细介绍见字符串部分）

#加法
>>> [1,2,3]+['a',5.0,'cd']	
[1, 2, 3, 'a', 5.0, 'cd']
#乘法
>>> [1,'a']*5	
[1, 'a', 1, 'a', 1, 'a', 1, 'a', 1, 'a']
>>> [0]*3 #列表的*运算可用于列表的初始化
[0, 0, 0]
>>> [[0]]*3
[[0], [0], [0]]
>>> [[0]*3]*3
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
#比较
>>> [1,2,3]<[2,3,4]	
True
#使用in和not in判断是否在序列内
>>> t=[1,2,3]	
>>> 1 in t
True
>>> [1,2]in t	#对于一个序列判断则必须是子序列在序列中
False
>>> t2=[[1,2],3]
>>> [1,2]in t2
True
>>> a=[1,2,3,4,5]	#索引方法1
>>> a[2]	#与字符串的索引相类似，从0开始索引
3
>>> a[-1]	#-1对应的是最后一个位置
5
>>> [1,2,3][0]	#索引方法2
1
>>> [1,2,3][-1]
3
>>> s=['a','b','c','d','e']	#切片操作
>>> s[2:3]
['c']
>>> s[2:6]
['c', 'd', 'e']
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
32
33
34
35
36
37
38

（2）列表特殊操作（不同于字符串）

#1.列表可以使用赋值语句修改序列中的值 ！！！字符串不可以
>>> t=[1,2,3]
>>>>t[0] = 4	
>>>t
>>>[4,2,3]
#2.列表可以使用切片方法进行元素的增加、删除、替换 ！！！字符串不可以
>>> s=['a','b','c','d','e']	
>>> s[2:4]=['f','g'] #使用切片方法批量修改列表中的值
>>> s
['a', 'b', 'f', 'g', 'e'] #将c,d修改为f,g
>>> s[2:3]=['x','y','z']
>>> s
['a', 'b', 'x', 'y', 'z', 'g', 'e'] #将位置2的元素f替换为了x y z，可以理解为插入
>>> s[2:4]=[]	#[]为一个空列表
>>> s
['a', 'b', 'z', 'g', 'e']	#将位置2-3的元素替换为了[]，可以理解为删除
#3.可以使用del命令，删除列表中的某个元素
>>> s=['a','b','c','d','e']	
>>>del(s[0])
>>>s
['b','c','d','e']		
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.2.4 列表函数

#1.append函数：在列表后面增加一个元素
>>> t1=[1,2,3]
>>> t1.append(5)
>>> t1
[1, 2, 3, 5]
>>> t1.append([7,8])
>>> t1
[1, 2, 3, 5,[7,8]] #其实只有5个元素，其中一个元素是列表
#2.extend函数：将一个新列表拼到列表后面去
>>> t1=[1,2,3]
>>> t1.extend([4,5,6])
>>> t1
[1, 2, 3, 4, 5, 6]
#3.insert函数：将一个元素插入到某个位置前面
>>> t1=[1,2,3]
>>> t1.insert(1,5) #表示在编号1的位置前面插入一个元素5
>>> t1
[1, 5, 2, 3]
>>> t1.insert(100,-1) #当insert的位置超过了列表的最大下标之后，其实就会做append的动作
>>> t1
[1, 5, 2, 3, -1]
#4.remove函数：删除列表中值为多少的元素
>>> t1=[1,2,3]
>>> t1.remove(2)
>>> t1
[1,3]
#5.pop函数：删除列表中的元素，其带返回值，可以输出
>>> t1=[1,2,3]
>>> t1.pop() #默认弹出列表中的最后一个元素
3（PS：无论在什么位置，每执行一次t1.pop()就会弹出一个值）
>>> print(t1.pop(1)) #pop函数可以带参数，如弹出位置为1的元素值
2
#6.reverse函数：颠倒列表中的元素顺序
>>> t1=[1,2,3]
>>> t1.reverse()
>>> t1
[3,2,1]
#6.index函数：可以用来查找某个元素在列表中的位置，需要print进行输出
>>> t1=[1,2,3,2]
>>> print(t1.index(2))
1 #如有多个满足，返回第一个的位置
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
32
33
34
35
36
37
38
39
40
41

4.2.5 列表和字符串之间的转化

常用split函数对字符串做分割，在进行相应处理后，再使用join函数连接起来

（1）list函数

可以使用list()将一个字符串转换为列表，字符串中的每一个字符（包括空格）都会被转化为列表中的一个元素，可以理解为通过list()函数操作以后，列表把字符串中的元素展开了。

>>> s='I\'m a good boy'
>>> ss=list(s)
>>> ss
['I', "'", 'm', ' ', 'a', ' ', 'g', 'o', 'o', 'd', ' ', 'b', 'o', 'y']
1
2
3
4

（2）split函数

split函数默认利用空格将字符串做分割转化为列表。若加参数，则以参数（某个特定的符号）作分割，将字符串分割成一系列的片段转化为列表，这个参数可以是多个字符。可以把参数看做是切割字符串的刀，只要有该参数在字符串里出现，就会发生切割。

>>> s='this is a test'
>>> s.split() #split函数默认可以利用空格做分割
['this', 'is', 'a', 'test']
>>> s 
'this is a test' #split函数没有修改原有字符串
>>> s='12.34'
>>> s.split(':')
['12.34'] #在字符串中没有找到切割点则不切割，直接转化为列表
>>> s.split('.')
['12', '34'] #以.作为分隔符进行分割
>>> s='12..34'
>>> s.split('.')
['12', '', '34']#两个切割位置中间没有元素，所以列表的第二个元素是空的
1
2
3
4
5
6
7
8
9
10
11
12
13

（3）join函数（列表转化为字符串）

将列表中的各个元素按照一定的方式连接成一个大的字符串

>>> s='this is a test'
>>> t=s.split()
>>> t
['this', 'is', 'a', 'test']
>>> ' '.join(t) #表达的意思是使用空格将列表t连接起来
'this is a test'
1
2
3
4
5
6

4.3 元组（tuple）

元组和列表几乎一模一样，只有两点不同。一是字面量不同，即元组用()，列表用[]；二是元组是一种不可修改的数据，没有任何办法去修改它。
除了可能会对列表本身造成修改的函数，如append，其他函数列表能用的元组都可以用。
tuple函数可以将一个列表转化为元组。

>>> s=[1,2,3]
>>> t=tuple(s)
>>> t
(1, 2, 3)
1
2
3
4

在python中，如果有相邻的用逗号分割的值或者变量，且外面没有()，但是它天生就会被认为是元组。

>>> p=9,9
>>> p
(9, 9)
1
2
3

5.无序类型容器

5.1 集合

5.1.1 基本概念

Python中的集合跟数学中的集合概念一致，集合有两个特性：一是数据的唯一性，即集合中不存在重复的元素；二是数据的无序性，即集合中的元素是无序的（其内部存储可能是有序的，但集合中数的位置顺序不能由我们指定）。集合的字面量用{}表示。通常利用集合的唯一性进行相应操作。

>>> s = {1,2,3,3,4} #集合中元素不重复
>>> s
{1, 2, 3, 4}
>>> s = {1,3,2,5,4} #集合中最后的顺序跟我们输入顺序可能不一致
>>> s
{1, 2, 3, 4, 5}
1
2
3
4
5
6

集合是可变的，可以在集合中加入元素，但是集合中的数据要保证唯一性。

>>> s = {1, 2, 3, 4, 5}
>>> s.add(10) #在集合中加入不存在的元素
>>> s
{1, 2, 3, 4, 5, 10}
>>> s.add(3) #在集合中加入存在的元素，由于数据的唯一性，加入操作等于没做
>>> s
{1, 2, 3, 4, 5, 10}
1
2
3
4
5
6
7

5.1.2 集合的操作

（1）集合的创建

可以通过{}创建集合或者通过set函数将列表转换为集合。注意，若想创建一个空集合，不可以使用{}直接创建（因为字典和集合共用{}），可以使用set()的形式创建。

>>> t = [1,2,3,4,5]
>>> s1 = {1,2,3,4,5} #利用{}创建集合
>>> s1
{1, 2, 3, 4, 5}
>>> s2 = set(t) #利用set函数将列表转换为集合
>>> s2
{1, 2, 3, 4, 5}
>>> type({}) #{}创建的是一个空字典
<class 'dict'>
>>> type(set()) #set()创建的是一个空集合
<class 'set'>
1
2
3
4
5
6
7
8
9
10
11

（2）操作和访问集合的元素

可以用add()和remove()添加和删除集合元素，可以用min(),max(),len()和sum()对集合进行操作。但是由于集合内部的元素是无序的，所以集合的对象是取下标的，所以不能像列表那样通过下标来访问集合元素。所以对集合的操作就是数学上的相应操作。

#1.可以利用一些函数对集合做一些基本的操作
>>> s = {1,3,2,5,4}
>>> min(s)
1
>>> max(s)
5
>>> len(s)
5
>>> sum(s)
15
#2.不能通过下标访问集合
>>> s[0] 
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    s[0]
TypeError: 'set' object is not subscriptable
#3.可以使用in或者not in判断一个元素是否在集合内
>>> 3 in s
True
>>> 3 not in s
False
#4.可以使用for循环 获得集合内的所有元素
>>> for i in s:
	print(i)	
1
2
3
4
5
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

（3）集合间的操作

#1.可以用 == 和 != 来判断两个集合是否相等
>>> s1 = {1,2,3,4,5}
>>> s2 = {1,2,3,4,5}
>>> s1 == s2
True
>>> s1 != s2
False
#2.可以用 < 来判断是否为真子集 用 <= 判断是否为子集
>>> s1 = {1,2,3}
>>> {1,2,3} < s1 #左边为右边的子集 不是真子集
False
>>> {1,2,3} <= s1
True
#3.集合之间可以做并集、交集、对称差、差集操作
>>> s1 = {1,2,3,4,5}
>>> s2 = {2,4,6,8}
>>> s1|s2 #并集操作
{1, 2, 3, 4, 5, 6, 8}
>>> s1&s2 #交集操作
{2, 4}
>>> s1^s2 #对称差操作：两个集合做并集后去掉交集的成分
{1, 3, 5, 6, 8}
>>> s1-s2 #差集操作：在s1中去掉s1和s2的交集
{1, 3, 5}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.2 字典

字典通过d={‘one’:1,‘two’:2}形成它的字面量的，这个例子中有两个条目。其中’：'左边是键（key），右边是值（value）。通过键可以访问相应的值。

>>> d={'one':1,'two':2}
>>> d['one']
1
>>> d['two']
2
>>> d['three']
Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    d['three']
KeyError: 'three'
>>> d['three']=3
>>> d['three']
3
1
2
3
4
5
6
7
8
9
10
11
12
13

可以直接通过赋值操作增加条目或者修改字典中已有条目的值，使用del函数删除条目，使用for循环遍历条目中的key，使用get函数获取字典中某个key的对应值或判断是否在字典内。

>>> d['three'] = 3
>>> d['three']
3
>>> del d['two']
>>> d
{'one': 1, 'three': 3}
>>> for name in d: #这个name是遍历的字典条目中的key
	print(d[name])
1
3
>>> d.get('one') #'one'在字典中存在，则get函数等同于直接写d['one']
1
>>> d.get('four') #字典中没有该key，不返回值
>>> d.get('four',0) #加入第二个参数表示若字典中没有该key，返回0，否则返回该key对应的value
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

例：输入一些数据，统计整数中不同的数字出现的次数（利用字典），输入-1时候终止输入。

#1.基本实现方法
d={} #设置一个空字典
y = int(input())
for i in range(y)
    x = int(input())
    if x != -1:
        if x in d:
            d[x] += 1
        else:
            d[x] = 1
#2.利用get函数实现
d={} #设置一个空字典
y = int(input())
for i in range(y)
    x = int(input())
    if x != -1:
    	d[x]=d.get(x,0)+1 #如果x在字典中已经存在了我们把它的值取出来，没有则赋值为0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.语句

6.1 赋值语句

基本形式是“变量=值” 的形式，对于某个元素使用赋值语句，其实是对变量值做了一个复制，而非共同管理

6.1.1 常规赋值情况

>>> x=1
>>> y=1
>>> k=x+y
>>> k
2
1
2
3
4
5

6.1.2 多变量序列赋值情况

• 左侧的变量个数等于右侧的序列个数

>>> x,y=4,8 #数字
>>> x
4
>>> y
8
>>> x,y="ab" #字符串
>>> x
'a'
>>> y
'b'
>>> x=4
>>> y=8
>>> x,y=y,x #两变量交换
>>> x
8
>>> y
4
>>> i,j=[1,2] #序列
>>> i
1
>>> j
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 左侧的变量个数不等于右侧的序列个数

>>> i,*j=[1,2,3]
>>> i
1
>>> j
[2, 3]
1
2
3
4
5

• 变量也可以连等

>>> a=b=c=5
>>> a
5
>>> b
5
>>> c
5
1
2
3
4
5
6
7

6.2 条件语句（if 语句）

6.2.1 基本的条件语句

注意！代码的逻辑关系是通过缩进来实现的（不同于c使用{}）

x= int(input())
if x%2==0:
	print("这是一个偶数")
else:
	print("这是一个奇数")
1
2
3
4
5

6.2.2 连缀的if-elif-else语句

elif其实就是C中的else if，可以尽可能避免由于使用嵌套的条件语句（if里面套if这样）而出现过长的情况。注意：多重选择的语句中可以没有else子句。

6.2.3 条件表达式

类似if-else语句，用来直接得到值。条件表达式需要三个值：条件满足时的值，条件，条件不满足时的值。

注：如果在判断过程中要看是否有多个条件同时满足，则可以使用and or 等逻辑运算符连接起来。

6.3 循环语句

6.3.1 while 语句

基本形式如下：

s = 0
cnt = 0
while True:
	x = int(input())
	if x != -1:
 		s += x
 		cnt += 1
 	else:
 		break

1
2
3
4
5
6
7
8
9
10

6.3.2 for 语句

基本形式如下：

for i in [1,2,3,4]: #在一个列表中循环
	print(i)

1
2
3

如何产生列表？-> 可以使用range()函数产生一个数列

>>> list(range(10))	#产生0-9的递增序列
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1,10)) #产生1-9的递增序列
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1,10,2)) #产生1-9的步长为2的递增序列
[1, 3, 5, 7, 9]
>>> list(range(0,-10,-1)) #产生0-（-10）的步长为1的递减序列
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
1
2
3
4
5
6
7
8

例1：输入n，求解1+2+3+…+n 的和

n=int(input())
s=sum(list(range(n+1))) #利用内置的求和函数
print(s)
1
2
3

例2：输入n，求解 n!

n=int(input())
factor=1ist(range(1, n+1)) #利用for循环求阶乘
f=1
for i in factor:
	f=f*i
print(f)
#######或者可以如下写：
n=int(input())
factor=1ist(range(1, n+1)) #利用for循环求阶乘
f=1
for i in range(1, n+1):
	f=f*i
print(f)
1
2
3
4
5
6
7
8
9
10
11
12
13

for i in [1,2,3,4]:
print(i,end=’ ')
i=i+2
插眼！！！ ???输出为1 2 3 4？

6.4 列表推导式

其将循环和条件判断相结合，避免了语法冗长，基本格式如下：
[expression for item in iterable]

example1:基本的列表推导式
>>> n=[2*i for i in [1,2,3,4,5]]
>>> n
[2, 4, 6, 8, 10]
example2:带条件限制的列表推导式
>>> n=[2*i for i in range(1,8) if i % 2 == 1 ]
>>> n
[2, 6, 10, 14]
example3:求1-1/2+1/3-1/4+...之前n项和
n =int(input()) 
a = sum([i/i if i%2==1 else -1/i for i in range(1,n+1)]
print(a)
example4:求6+66+666+666...666之前n项和
n =int(input()) 
a = sum([int('6'*i) for i in range(1,n+1)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6.5 异常处理语句

注意：else 和 finally语句可以不写

try中程序执行如果有异常出现，后续代码不再继续执行，跳到except中执行对应异常下的语句，保护程序继续执行。如果没有异常出现 会在try执行完以后，执行else语句 再执行finally语句；如果有

6.6 字典推导式

6.7 集合推导式

7.格式化输出

7.1 利用Format函数

其基本语法是通过 {} 和 : 来代替C中的 %进行格式化输出 。format 函数可以接受无限个参数，位置可以不按顺序（默认为按顺序）。通过format函数输出的之前是什么类型就还是什么类型，与format函数无关。

>>>x=3.14159
>>>y=2*x*3
>>>print(“{0:.2f} {1:.2f}".format(x,y))
3.14 18.85
#0和1表示format函数中的第一和第二个参数，若交换0和1可以交换输出顺序
#.2f 表示小数部分保留两位，四舍五入
for i in range (lower, upper+1，2): #步长为2 范围为[lower, upper]的循环输出
	print(i，"{:.1f}".format(5*(i-32)/9))
1
2
3
4
5
6
7
8

Format函数还可以通过设置参数来实现相应输出（可以用{}括住设置的参数然后进行相应输出）

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) 

输出结果为：

网站名：菜鸟教程, 地址 www.runoob.com
1
2
3
4
5
6
7
8
9
10
11
12
13

（例子来源：https://www.runoob.com/python/att-string-format.html）

7.2 利用列表推导式和传统循环方式

例：输入正整数N，输出序列和，结果保留三位小数
1-2/3+3/5-4/7+5/9-6/11+…前N项

n =int(input()) #列表推导式
alist = [i/(2*i-1) if i%2==1 else -i/(2*i-1) for i in range(1,n+1)]
result=sum(alist)
print (("{ :.3f}".format (result))

n= int(input()) #传统的循环方式
result = 0
for i in range(1,n+1):
	if i%2==1:
		result = result +i/(2*i-1)
	else:
		result = result -i/(2*i-1)
print("{:.3f}".format(result))
1
2
3
4
5
6
7
8
9
10
11
12
13

8.函数

8.1 函数的定义与调用

函数是重用的程序段，其允许你给一段语句命名一个名字，这就是函数定义（可以使用def进行相应定义）。可以在程序的任何地方运行这个语句块，这就是函数调用。对于内置函数可以不用进行相应定义，直接调用。注意，对于自定义的函数是要先定义后执行的。


python 还可以使用 lambda表达式来创建匿名函数。lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
如g = lambda x,y,z:x+y+z，其就把lambda定义的匿名函数赋给函数g，使用g(1,4,5)就可以直接求1+4+5的值。
使用lambda可以省去定义函数的过程，对于一些抽象的，不会被别的地方再重复使用的函数，使用lambda不需要考虑命名的问题。
（部分内容引自https://blog.csdn.net/Liveor_Die/article/details/78667075，详细内容及实例可见）

8.2 函数参数

函数定义时的参数称为形参，这些参数像变量一样，参数在函数定义的圆括号内指定，用逗号分隔。当调用函数时，函数中的参数值称为实参，函数形参取得的值是你调用函数时候提供的实参。
注意！可变对象和不可变对象当参数时，效果是不同的！当实参是不可变对象时，形参值的改变不会影响实参！当实参是可变对象时，形参值的改变可能会影响实参！

8.2.1 位置参数

传入参数的值是按照实参输入顺序依次赋值给形参。因此位置参数有着严格的位置要求。

def Sum(a,b,c,d):
    print("a={},b={},c={},d={}".format(a,b,c,d))
    return a+b+c+d
print(Sum(1,2,3,4))
输出：
a=1,b=2,c=3,d=4 #按照输入顺序给形参赋值
10
1
2
3
4
5
6
7

8.2.2 关键字参数

关键字参数可以采用与函数定义形参时不同的顺序输入实参。

def Sum(a,b,c,d):
    print("a={},b={},c={},d={}".format(a,b,c,d))
    return a+b+c+d
print(Sum(c=3,b=2,a=1,d=4))
输出：
a=1,b=2,c=3,d=4 #按照实参对应给形参赋值，跟输入顺序无关
10
1
2
3
4
5
6
7

注意：位置参数可以和关键字参数混用，混用时应先写位置参数（先写的位置也要对应形参前面的位置），然后写关键字参数（位置参数后面的进行混用）。

#example 1：
def Sum(a,b,c,d):
    print("a={},b={},c={},d={}".format(a,b,c,d))
    return a+b+c+d
print(Sum(1,2,d=4,c=3))
输出：
a=1,b=2,c=3,d=4 
10
#example 2：
def Sum(a,b,c,d):
    print("a={},b={},c={},d={}".format(a,b,c,d))
    return a+b+c+d
print(Sum(1,2,b=4,c=3)) #出现了b重复赋值的情况
程序报错：
Traceback (most recent call last):
  File "C:/Users/lenovo/Desktop/test.py", line 4, in <module>
    print(Sum(1,2,b=4,c=3))
TypeError: Sum() got multiple values for argument 'b'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8.2.3 默认值参数

当调用时候没有提供对应形参的值时，可以指定一个默认形参值，若提供对应形参的值，在调用时会替代默认值。

#example 1：
def Sum(a,b,c,d = 5):
    print("a={},b={},c={},d={}".format(a,b,c,d))
    return a+b+c+d
print(Sum(1,2,3)) #未输入d的实参值，由d默认值代替实参值
输出：
a=1,b=2,c=3,d=5
11
#example 2：
def Sum(a,b,c,d = 5):
    print("a={},b={},c={},d={}".format(a,b,c,d))
    return a+b+c+d
print(Sum(1,2,3,4)) #输入d的实参值，由d的实参值代替默认值
输出：
a=1,b=2,c=3,d=4
10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

默认值参数在函数对象被创建时计算。（是否可以理解为当函数对象创建时，默认值参数已经对应创建了一个对象，使用默认值参数进行相应操作时，一直在该对象中进行相应操作，而当默认值参数改变时，要对应创建一个新对象进行新的对应操作）

def init(arg,result=[]):
    result.append(arg)
    print(result)
init('a')
输出：
['a']
init('b') #在上一个的基础上重复调用
输出：
['a','b']
init(1,[2]) #在上一个的基础上重复调用，因为此次调用不使用默认值参数，所以其另外创建一个对象
输出：
[2,1]
1
2
3
4
5
6
7
8
9
10
11
12

8.2.4 数量可变参数

*或**都是加在形参的前面，表示不定长参数，分别用来接收当函数实参数目不确定时，不带变量名的多余实参和带有变量名的多余实参，分别将它们以元组和字典的形式接收进函数。

#example1：*
def init(a,*b):
    print(b)
    print(len(b)+1)
init(5,'a',9)
输出：
('a', 9) #后面可变数量的位置参数被集合为一个元组
3
#example2：**
def init(a,**b):
    print(b)
    print(len(b)+1)
init(5,x1='a',x2=9)
输出：
{'x1': 'a', 'x2': 9}
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

当在实参前面加上‘*’，意味着实参拆包，将序列拆成一个个单独的实参。（print函数的详细解释图见2.2）

>>> s=[2,5,7]
>>> print(s)
[2, 5, 7]
>>> print(*s)
2 5 7
1
2
3
4
5

8.3 函数返回值

函数使用return语句返回值，如果函数没有用return语句返回或return后面没有表达式，函数返回值为None，None不表示任何数据。
例：求整数M和N区间内素数的个数

def isprime(i):
	for k in range(2,i):
	if i%k==O:
		return False
	return True
m,n=input().split()
m,n=int(m),int(n)
p=[i for i in range(m,n+1) ifisprime(i)]
print(len(p),sum(p))
1
2
3
4
5
6
7
8
9

函数返回值也可以是一个函数。

def test(par):
	return par
def test1():
	return 1000
def test2(par):
	return 2000
def f(x):
	return {'a': test,'b": test1,}.get(x, test2)
print(f('a')(100)) #在f(x)函数中返回对应函数为test，然后执行test(100)
print(f(4)(100))
输出：
100
2000
1
2
3
4
5
6
7
8
9
10
11
12
13

8.4 命名空间和作用域

变量可被访问的范围称为变量的作用域，也被称为变量的命名空间。命名空间可以用于区分不同空间的相同名字。

Python语言规定赋值即定义。“var=1”赋值语句定义了变量“var”并赋值为1。
全局变量:定义在函数外，作用域是整个程序。
局部变量:定义在函数内，作用域是函数内部。形参也是局部变量。

如果希望在函数中使用全局变量，而不是创建局部变量，需要使用global关键字声明

#example 1：
def scope():
    global var1 #使用了global进行声明
    var1=1 #将全局变量var1的值从10修改成1
    print("函数内部打印结果")
    print(var1,var2)
var1=10
var2=20
scope()
print("函数外部打印结果")
print(var1,var2)
输出：
函数内部打印结果
1 20
函数外部打印结果
1 20
#example 2：
def scope():
    var1=1 #未使用global进行声明 创建局部变量var并赋值为1 未修改全局变量var
    print("函数内部打印结果")
    print(var1,var2)
var1=10
var2=20
scope()
print("函数外部打印结果")
print(var1,var2)
输出：
函数内部打印结果
1 20
函数外部打印结果
10 20
#example 3：
x=100
def f():
    y=x	#在函数内部尚未定义x，y=x无法操作
    x=0
    print(x)
f()
程序报错
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
32
33
34
35
36
37
38
39

由此可见，当不使用global进行声明时，若创建一个函数内部的变量a与全局变量b变量名相同时，在函数内部则按照变量a进行相关操作和输出，若未定义a进行了b相关的操作，程序会报错。当函数内部未声明相关变量进行输出时，若有对应的全局变量，输出的是全局变量的值。

8.5 函数递归

同C，不赘述。不过可以考虑使用字典等容器保存值减少递归次数。

8.6 内置函数

8.6.1 杂七杂八的函数

（1）sorted函数

sorted函数可以对字符串、列表、元组、字典等对象进行排序操作。
sorted函数和sort函数的区别有如下：
（1）sort是应用在列表上的方法，sorted可以对更多的数据类型进行排序操作。
（2）列表的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted返回的是一个新的列表。

其基本语法如下：
sorted（iterable[,key[,reverse]]）
iterable——接受一个可迭代的对象（因为sorted实现了迭代协议，所以接受的参数不一定需要list，可以迭代的对象就可以），返回一个排序之后的列表。
key——一个函数，根据这个函数的返回值进行排序，通常可以用lambda
reverse——排序规则 reverse = True 降序，reverse=False 升序（默认）

>>> temp_list = [4, -5, 7, 1, -3, 2, -9]
>>> print(sorted(temp_list, key=lambda key: abs(key))) #按照绝对值排序
[1, 2, -3, 4, -5, 7, -9]
1
2
3

（2）map函数

（插眼，还需深入学习）

（3）zip函数

zip函数可将可迭代的对象作为参数，将对象中对应的元素打包成元组，然后返回由这些元组组成的列表或者迭代器。
若各个迭代器的元素个数不一致，返回列表长度与最短的对象相同（多余的丢掉）。

其语法形式如下：
zip([iterable,…])
iterable,…表示的是两个或多个序列
返回值为元组列表

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> c=[7,8,9,10,11]
>>> zip(a,b) #直接输出无法输出
<zip object at 0x000002ACFA15C700>
>>> print(list(zip(a,b)))
[(1, 4), (2, 5), (3, 6)]
>>> print(list(zip(a,c)))
[(1, 7), (2, 8), (3, 9)] #因为选取的与长度最短的列表对象相同，所以10,11被直接剔掉
1
2
3
4
5
6
7
8
9

例：字典键值互换

>>>d={blue":500, 'red:100, 'white':300}
>>>>d1=dict(zip(d.values(),d.keys())
>>>>print(d1)
{500: 'blue'， 100: 'red"',300: 'white”}
1
2
3
4

（4）eval和exec函数

（插眼 还需继续学习！）

>>>x,y=3,7
>>>eval('x+3*y-4') #执行eval函数相当于去掉''执行这个表达式
20
>>>exec('print("hello world")') #执行exec函数同理
hello world
1
2
3
4
5

（5）all()和any()函数

>>>n=47
>>> all([1 if n%k!=O else 0 for k in range(2,n)]) #列表中的值都是1 参数全为真
True #表示n是素数
>>>n=15
>>> all([1 if n%k!=0 else 0 for k in range(2,n))
False
>>>any([[],False,0])#空列表和O都表示False
False
1
2
3
4
5
6
7
8

8.6.2 内置转换函数

（1）类型转换函数

>>> bool('hello')
True
>>> float(1)
1.0
>>> str(3.5)
'3.5'
>>> list('abcd')	#list可以把一个字符串变成列表形式
['a', 'b', 'c', 'd']
1
2
3
4
5
6
7
8

int类型转换函数实例
其基本格式为int(x[,base=10])，base=10即默认为十进制，注意！int不能将字符串转换为数。

>>> int()	#不传入参数时，默认为0
0
>>> int('02')   #去掉0
2
>>> int("     12    ")	#去掉空格
12
>>> int("     1    2  ")	#两个数不能转换
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '     1    2  '
>>> int("ab",8)	#不能将字符串转换为八进制
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 8: 'ab'
>>> int("12",8)	#将数字12转换为八进制
10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

（2）编码类转换函数

>>> ord('a')	#ord函数参数类型只能是字符，用以求其ASCII码
97
>>> ord('中')	#汉字中的Unicode码
20013
>>> chr(97)	#chr函数参数类型必须为整数，用以求对应ASCII码的字符
'a'
>>> bin(1)
'0b1'
>>> oct(1)
'0o1'
>>> hex(1)
'0x1'
1
2
3
4
5
6
7
8
9
10
11
12

8.7 程序结构

代码也有类似的自底向上的组织层次:数据类型类似于单词,语句类似于句子，函数类似于段落，模块类似于章。一个Python程序可以在不同文件中，这些文件是一个个模块。用import语句引入。
“import 模块名”就是执行文件名为模块名的程序。模块名是另外一个Python文件的文件名,不包含扩展名,模块是可以运行的程序。

对于在同一目录下的两个文件，模块创建如下所示：（area.py和triangle.py两个文件在同一个目录下，通过Python运行主程序area.py,调用了triangle模块中的函数area进行执行）

而如果不在同一目录下，可以使用sys模块加入搜索路径后调用。模块的查找路径：sys.path

sys模块中的常用量：

使用命令行参数演示不用input()函数向程序输入值。
sys.argv[o] 表示程序的文件名
sys.argv[1] 表示第一个参数
sys.argv[2] 表示第二个参数
…
sys.argv[n] 表示第n个参数

import sys
print(sys.argv[0]) #打印程序的文件名
print(sys.argv[1]) #打印被乘数
print(sys.argv[2]) #打印乘数
print(int(sys.argv[1])*int(sys.argv[2])) #sys返回的是字符串，需要强制转化为int
程序执行:
c:\>python d:Imul.py 2 6 #输入的程序的路径和输入值
d:\mul.py 
2
6
12
1
2
3
4
5
6
7
8
9
10
11

9.文件

9.1 文件读写

计算机文件可以分为两种：一种是二进制文件（图形文件以及文字处理程序等计算机程序含有特殊的格式及计算机代码，都属于二进制文件），一种是文本文件。

在进行文件读写时候，一定要经历三个阶段：文件打开、做相应数据处理、文件关闭。

9.1.1 基本文件读写知识

open函数
fileobj = open(filename,mode)
fileobj是open()返回的文件对象filename是该文件的文件名
mode是指明文件类型和操作的字符串
mode的第一个字母表明对其的操作，也就是文件打开方式（图中的r w a x）。mode的第二个字母是文件类型:t（可省略）代表文本类型文件;b代表二进制类型文件。

例：将一个文件cj.txt的内容复制到cjback.txt中。

source=open("cj.txt","r")
back=open("cjback.txt","w")
s=source.read()
back.write(s)
source.close()
back.close()
1
2
3
4
5
6

9.1.2 多行文件读写

用readlines()读写多行文件

f=open("score.txt","r")
for line in f.readlines():
	print(line) #处理行，每行line为一个字符串，处理方式有很多
f.close()
1
2
3
4

可用嵌套列表存放多行内容，如
在for循环中l=line.split()将每行字符串转换为列表（出现嵌套列表）

9.1.3 输入输出重定向

把从文件中的输入改成从键盘中输入，改变输入源，有利于调试程序。

import sys #从文件读入变为从键盘输入，改变输入源
s=sys.stdin.readlines() #如不需要考虑行结构可以用read
#在Windows系统中输入ctrl+d结束输入
#然后做后续操作即可
1
2
3
4

9.2 用Pandas模块读写文件

https://blog.csdn.net/helloxiaozhe/article/details/80653308

9.3 数据可视化——plotly模块

https://blog.csdn.net/lsxxx2011/article/details/105803705?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultbaidujs_baidulandingword~default-0.pc_relevant_default&spm=1001.2101.3001.4242.1&utm_relevant_index=3