其实是最近变懒了，该考虑一下更自律一点了
参考自以下
Python系列_礁之的博客-CSDN博客
主要为对之前所学内容的总结以及拓展学习，包含python·基础内容，函数，及面向对象编程
文章目录
一、 Python变量与数据类型
1.变量概述
2.创建变量
3.Python3常用的数据类型
3.1.数字（Numbers）
3.2.字符串（String）
3.3.列表（list）
3.4.元组（Tuple）
3.5.集合（Set）
3.6.字典（Dictionary）
3.7.Python数据类型转换
4.Python3基础语法
4.1.编码
4.2.标识符
4.3.Python保留字
4.3.注释
4.4.行与缩进
4.5.多行语句
4.6.空行
4.7.等待用户输入
4.8.同一行显示多条语句
4.9.多个语句构成代码组
4.10.print输出
4.11.import和from...import
4.12.命令行参数
二、拓展小脚本
-选车牌小程序
-99乘法表
- 年会抽奖小程序
一、 Python变量与数据类型
Python是一种动态解释型的编程语言
要想使用python，可以使用python自带的IDLE编辑器，也可以下载PyCharm、VScode等
1.变量概述
变量是存储在内存中的值，而这就意味着在创建变量时会在内存中开辟一个空间基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中，因此，变量可以指定不同的数据类型，如字符串、数字、列表、字典甚至函数
变量名是由字母、数字、下划线组成的，第一个字符必须是字母或者下划线_
使用变量可以提高代码的可读性，便于修改
Python中的变量赋值不需要类似声明，每个变量都在内存中创建，包括变量的的标识、名称、数据等信息，每个变量在使用前都必须赋值，变量赋值以后这个变量才会被创建
在Python中“=”用来给变量赋值，变量名=变量值，例如：
a = "hello world"
print(a)
hello world
1
2
3
2.创建变量
创建合法的变量名称
a =1
print(a) #print()是打印，即shell中的echo
1
_a =2
print(_a)
2
a1 = 3
print(a1)
3
可以同时指定多个变量名进行赋值
a,b,c = 1,2,3
print(a)
1
print(b,c)
2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
3.Python3常用的数据类型
类型 作用
数字（Numbers） 数字类型数据用于存储数值，他们是不可改变的数据类型，这意味着改变数字类型会分配一个新的对象，当你指定一个值时，Numbers类型的对象就会被创建，数字类型在输入时，直接输入数字即可，如55，无需加引号等
字符串（String） 字符串或串是由数字、字母、下划线组成的一串字符，在给变量赋值时加双引号" "或单引号' '就是字符串类型
列表（List） Python中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构，支持字符、数字、字符串，也可以嵌套，在列表中包含列表，使用`[ ]创建列表
元组（Tuple） 元组是另一个数据类型，类似于列表，但是不能二次赋值，相当于只读列表，使用（）创建元组
字典（Dictionary） 字典是除了列表以外，Python中最灵活的内置数据结构类型，使用{ }创建字典
列表是有序的对象集合，而字典是无序的对象集合
两者的区别在于：
（1）字典中的元素是通过键来存取的，也就是键值对的方式Key-Value，而不是通过偏移存取
（2）列表只是简单的存放多个变量值，字典相当于是"在字典中又创建了变量"
还有一种类型是集合（set），集合是无序的对象集合，集合中没有重复的元素，通常用来去重等，使用{ }来创建，不过和字典不同的是不需要使用：来定义key和value，与列表一样的去定义元素即可
3.1.数字（Numbers）
3.1.1.数字的数据类型也分成了很多种类型：
整型(int)： 也就是整数
浮点型(float)： 带小数点的数字
布尔型(bool)： 用于逻辑运算，只有true和false，即真和假
复数(complex)： 复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，,如1+2j、1.1+2.2J
3.1.2.Python运算符：
算法 运算符
加法 +
减法 -
乘法 *
除法 /
求模，取余 %
求幂，即求次方，2**2即2的2次方 **
先乘除后加减，有小括号就先算小括号，注意：Python是不支持自增运算符++和自减运算符–的
3.1.3.整型、浮点型、布尔型
x = 123 #整型
print(x)
123
y = 1.12 #浮点型
print(y)
1.12
a = True #布尔型true
print(a)
print(a)
hello world
1
2
3
2.创建变量
#创建合法的变量名称
>>> a =1
>>>print(a) #print()是打印，即shell中的echo
1
>>> _a =2
>>> print(_a)
2
>>> a1 = 3
>>> print(a1)
3
#可以同时指定多个变量名进行赋值
>>> a,b,c = 1,2,3
>>> print(a)
1
>>> print(b,c)
2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
3.Python3常用的数据类型
类型 作用
数字（Numbers） 数字类型数据用于存储数值，他们是不可改变的数据类型，这意味着改变数字类型会分配一个新的对象，当你指定一个值时，Numbers类型的对象就会被创建，数字类型在输入时，直接输入数字即可，如55，无需加引号等
字符串（String） 字符串或串是由数字、字母、下划线组成的一串字符，在给变量赋值时加双引号" "或单引号' '就是字符串类型
列表（List） Python中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构，支持字符、数字、字符串，也可以嵌套，在列表中包含列表，使用[ ]创建列表 元组（Tuple） 元组是另一个数据类型，类似于列表，但是不能二次赋值，相当于只读列表，使用（）创建元组 字典（Dictionary） 字典是除了列表以外，Python中最灵活的内置数据结构类型，使用{ }创建字典 列表是有序的对象集合，而字典是无序的对象集合 两者的区别在于： （1）字典中的元素是通过键来存取的，也就是键值对的方式Key-Value，而不是通过偏移存取 （2）列表只是简单的存放多个变量值，字典相当于是"在字典中又创建了变量" 还有一种类型是集合（set），集合是无序的对象集合，集合中没有重复的元素，通常用来去重等，使用{ }来创建，不过和字典不同的是不需要使用：来定义key和value，与列表一样的去定义元素即可 3.1.数字（Numbers） 3.1.1.数字的数据类型也分成了很多种类型： 整型(int)： 也就是整数 浮点型(float)： 带小数点的数字 布尔型(bool)： 用于逻辑运算，只有true和false，即真和假 复数(complex)： 复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，,如1+2j、1.1+2.2J 3.1.2.Python运算符： 算法 运算符 加法 + 减法 - 乘法 * 除法 / 求模，取余 % 求幂，即求次方，2**2即2的2次方 ** 先乘除后加减，有小括号就先算小括号，注意：Python是不支持自增运算符++和自减运算符–的 3.1.3.整型、浮点型、布尔型 >>> x = 123 #整型 >>> print(x) 123 >>> y = 1.12 #浮点型 >>> print(y) 1.12 >>> a = True #布尔型true >>> print(a) True if(a): #使用if语句反段，符合if语句的条件，就输出下面的语句，因为a为布尔型true，所以始终为真，也就是始终符合条件 ... print("为真") ... _a =2 >>> print(_a) 2 >>> a1 = 3 >>> print(a1) 3 #可以同时指定多个变量名进行赋值 >>> a,b,c = 1,2,3 >>> print(a) 1 >>> print(b,c) 2 3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 3.Python3常用的数据类型 类型 作用 数字（Numbers） 数字类型数据用于存储数值，他们是不可改变的数据类型，这意味着改变数字类型会分配一个新的对象，当你指定一个值时，Numbers类型的对象就会被创建，数字类型在输入时，直接输入数字即可，如55，无需加引号等 字符串（String） 字符串或串是由数字、字母、下划线组成的一串字符，在给变量赋值时加双引号" "或单引号' '就是字符串类型 列表（List） Python中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构，支持字符、数字、字符串，也可以嵌套，在列表中包含列表，使用[ ]创建列表
元组（Tuple） 元组是另一个数据类型，类似于列表，但是不能二次赋值，相当于只读列表，使用（）创建元组
字典（Dictionary） 字典是除了列表以外，Python中最灵活的内置数据结构类型，使用{ }创建字典
列表是有序的对象集合，而字典是无序的对象集合
两者的区别在于：
（1）字典中的元素是通过键来存取的，也就是键值对的方式Key-Value，而不是通过偏移存取
（2）列表只是简单的存放多个变量值，字典相当于是"在字典中又创建了变量"
还有一种类型是集合（set），集合是无序的对象集合，集合中没有重复的元素，通常用来去重等，使用{ }来创建，不过和字典不同的是不需要使用：来定义key和value，与列表一样的去定义元素即可
3.1.数字（Numbers）
3.1.1.数字的数据类型也分成了很多种类型：
整型(int)： 也就是整数
浮点型(float)： 带小数点的数字
布尔型(bool)： 用于逻辑运算，只有true和false，即真和假
复数(complex)： 复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，,如1+2j、1.1+2.2J
3.1.2.Python运算符：
算法 运算符
加法 +
减法 -
乘法 *
除法 /
求模，取余 %
求幂，即求次方，2**2即2的2次方 **
先乘除后加减，有小括号就先算小括号，注意：Python是不支持自增运算符++和自减运算符–的
3.1.3.整型、浮点型、布尔型
>>> x = 123 #整型
>>> print(x)
123
>>> y = 1.12 #浮点型
>>> print(y)
1.12
>>> a = True #布尔型true
>>> print(a)
True
>>>if(a): #使用if语句反段，符合if语句的条件，就输出下面的语句，因为a为布尔型true，所以始终为真，也就是始终符合条件
... print("为真")
...
为真
b = False #布尔型false
if(b): #如果b符合条件，则输出为真，否则输出为假，因为b是布尔型false，所以始终为假，也就是始终为假
... print("为真")
... else:
... print("为假")
...
为假
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
3.1.4.变量标识符
变量标识符就像是变量的“身份证”，具有唯一性
print(id(x)) #查看x变量的标识符
2774440106160
print(id(y)) #查看y变量的标识符
2774486777776
1
2
3
4
5
3.1.5.Python运算符
x,y = 2,4 #赋值变量x和y的值分别是2和4
print(x+y,y-x,x*y) #加、减、乘算法
6 2 8
print(4/2,2**4) #除、求幂算法
2.0 16
print(8%5) #取余算法，8除5余3
3
1
2
3
4
5
6
7
8
9
3.2.字符串（String）
python中单引号和双引号使用完全相同
使用三引号''' 或 """)可以指定一个多行字符串
转义符
反斜杠可以用来转义，使用r可以让反斜杠不发生转义,如 r"this is a line with \n" 则\n会作为普通字符显示，而不是作为换行符
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
字符串可以用 + 运算符连接在一起，用 * 运算符重复
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始，与列表相同
Python中的字符串不能改变
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串
3.2.1.单引号、双引号、三引号
name = '亚索' #单引号
print(name)
亚索
age = "34岁" #双引号
print(age)
34岁
aihao = """ #三引号
耍剑
喝酒
"""
print(aihao)
耍剑
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.转义符
aaa = "aa'gao'"
print(aaa)
aa'gao'
bbb = ' aaa"ccc"'
print(bbb)
aaa"ccc"
ccc = 'abc'ccc' #转义'为普通字符
print(ccc)
abc'ccc
1
2
3print(a)
True
>>>if(a): #使用if语句反段，符合if语句的条件，就输出下面的语句，因为a为布尔型true，所以始终为真，也就是始终符合条件
... print("为真")
...
为真
>>> b = False #布尔型false
>>> if(b): #如果b符合条件，则输出为真，否则输出为假，因为b是布尔型false，所以始终为假，也就是始终为假
... print("为真")
... else:
... print("为假")
...
为假
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
3.1.4.变量标识符
变量标识符就像是变量的“身份证”，具有唯一性
>>> print(id(x)) #查看x变量的标识符
2774440106160
>>> print(id(y)) #查看y变量的标识符
2774486777776
1
2
3
4
5
3.1.5.Python运算符
>>> x,y = 2,4 #赋值变量x和y的值分别是2和4
>>> print(x+y,y-x,xy) #加、减、乘算法
6 2 8
>>> print(4/2,24) #除、求幂算法
2.0 16
>>> print(8%5) #取余算法，8除5余3
3
1
2
3
4
5
6
7
8
9
3.2.字符串（String）
python中单引号和双引号使用完全相同
使用三引号''' 或 """)可以指定一个多行字符串
转义符
反斜杠可以用来转义，使用r可以让反斜杠不发生转义,如 r"this is a line with \n" 则\n会作为普通字符显示，而不是作为换行符
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
字符串可以用 + 运算符连接在一起，用 * 运算符重复
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始，与列表相同
Python中的字符串不能改变
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串
3.2.1.单引号、双引号、三引号
>>> name = '亚索' #单引号
>>> print(name)
亚索
>>> age = "34岁" #双引号
>>> print(age)
34岁
>>> aihao = """ #三引号
耍剑
喝酒
"""
>>> print(aihao)
耍剑
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.转义符
>>> aaa = "aa'gao'"
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
aaa"ccc"
>>> ccc = 'abc'ccc' #转义'为普通字符
>>> print(ccc)
abc'ccc
1
2
3
4
print(a)
True
>>>if(a): #使用if语句反段，符合if语句的条件，就输出下面的语句，因为a为布尔型true，所以始终为真，也就是始终符合条件
... print("为真")
...
为真
>>> b = False #布尔型false
>>> if(b): #如果b符合条件，则输出为真，否则输出为假，因为b是布尔型false，所以始终为假，也就是始终为假
... print("为真")
... else:
... print("为假")
...
为假
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
3.1.4.变量标识符
变量标识符就像是变量的“身份证”，具有唯一性
>>> print(id(x)) #查看x变量的标识符
2774440106160
>>> print(id(y)) #查看y变量的标识符
2774486777776
1
2
3
4
5
3.1.5.Python运算符
>>> x,y = 2,4 #赋值变量x和y的值分别是2和4
>>> print(x+y,y-x,xy) #加、减、乘算法
6 2 8
>>> print(4/2,2**4) #除、求幂算法
2.0 16
>>> print(8%5) #取余算法，8除5余3
3
1
2
3
4
5
6
7
8
9
3.2.字符串（String）
python中单引号和双引号使用完全相同
使用三引号''' 或 """)可以指定一个多行字符串
转义符
反斜杠可以用来转义，使用r可以让反斜杠不发生转义,如 r"this is a line with \n" 则\n会作为普通字符显示，而不是作为换行符
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
字符串可以用 + 运算符连接在一起，用 * 运算符重复
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始，与列表相同
Python中的字符串不能改变
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串
3.2.1.单引号、双引号、三引号
>>> name = '亚索' #单引号
>>> print(name)
亚索
>>> age = "34岁" #双引号
>>> print(age)
34岁
>>> aihao = """ #三引号
耍剑
喝酒
"""
>>> print(aihao)
耍剑
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.转义符
>>> aaa = "aa'gao'"
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
aaa"ccc"
>>> ccc = 'abc'ccc' #转义'为普通字符
>>> print(ccc)
abc'ccc
1
2
3
4
5
6
7
8
9
3.2.3.常用转义符
转义符 作用
\ 在行尾时使用，为续航符，也就是换行符
\ 这个含义是指把\转义成普通字符
\’ 把’转义成普通字符
" 把“转义成普通字符
\n 换行符，把光标移动到下一行继续
\v 纵向制表符，将光标向下移动一个制表符单位
\t 水平制表符，将光标向右移动一个制表符单位
\r 代表一个回车
3.2.4.字符串的其他用法
+号可以当作字符串的连接字符，而*号可以是重复操作
print("aaa" + "bbb")
aaabbb
print(3*"aaa")
aaaaaaaaa
新建一个新的.py文件，写入：
a = ' '
print("欢迎来到，英雄联盟")
print(a2+"欢迎来到，英雄联盟")
print(a4+"欢迎来到，英雄联盟")
欢迎来到，英雄联盟
欢迎来到，英雄联盟
欢迎来到，英雄联盟
a为一个空，利用*号可以使空重复操作变成多个，然后就可以实现上面的效果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.3.列表（list）
3.3.1.列表的定义
列表其实就是一个变量有多个变量值，但是这个变量值叫做元素，所以也叫做，一个列表中有多个元素，使用[]来表示列表
a = ["1","2","3"]
print(a)
['1', '2', '3']
1
2
3
4
3.3.2列表的取值
列表有两种取值顺序：
1.从左到右索引默认从0开始，最大范围是字符串长度-1，这个0和shell的位置变量有点像
2.从右到左的索引默认从-1开始，最大范围是字符串开头
a = ["1","2","3"]
print(a)
['1', '2', '3']
print(a[0])
1
print(a[1])
2
print(a[2])
3
print(a[-1])
3
print(a[-2])
2
print(a[-3])
1
print(a[0:2]) #从0开始到2位置结束
['1', '2']
print(a[0:3])
['1', '2', '3']
print(a[0:1])
['1']
a[0]=4 #修改a列表中0位置为4
print(a)
[4, '2', '3']
a.append(5) #在a列表末尾添加5
print(a)
[4, '2', '3', 5]
a.insert(1,6) #在a列表的1位置后添加6
print(a)
[4, 6, '2', '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
25
26
27
28
29
30
31
32
33
3.3.3.删除列表元素
print(a)
[4, 6, '2', '3', 5]
del a[0] #删除a列表中的0位置的元素
print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
print(a)
[6, '2', '3', 5]
6 in a #查看a列表中是否有6，有就返回True没有就返回False
True
8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
a = ["nihao","shijie"]
b = ["hello","world"]
c = a + b #利用+号，来合并列表，变量也可以这样使用
print(c)
['nihao', 'shijie', 'hello', 'world']
d = b + a
print(d)
['hello', 'world', 'nihao', 'shijie']
print(a3) #利用号，来重复列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常见问题
print(a)
[1, 2, 3]
print(a[6]) #不能直接查看超过列表元素总数的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
print(a[1:6]) #但是可以指定范围查看
[2, 3]
print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2]) #从0开始到2位置结束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4 #修改a列表中0位置为4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '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
25
26
27
28
29
30
31
32
33
3.3.3.删除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #删除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True没有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+号，来合并列表，变量也可以这样使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用号，来重复列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常见问题
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超过列表元素总数的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范围查看
[2, 3]
>>> print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2]) #从0开始到2位置结束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4 #修改a列表中0位置为4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '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
25
26
27
28
29
30
31
32
33
3.3.3.删除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #删除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True没有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+号，来合并列表，变量也可以这样使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用号，来重复列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常见问题
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超过列表元素总数的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范围查看
[2, 3]
>>> print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
列表中也可以是列表，是可以无限嵌套的
a = [[1,2,3],"aaa",[4,5,6]]
print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
print(a[0]) #查看a列表中的第0个位置的元素
[1, 2, 3]
print(a[0][0]) #查看a列表中第0个位置元素的第0个位置的元素
1
1
2a[0]=4 #修改a列表中0位置为4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '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
25
26
27
28
29
30
31
32
33
3.3.3.删除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #删除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True没有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+号，来合并列表，变量也可以这样使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用号，来重复列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常见问题
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超过列表元素总数的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范围查看
[2, 3]
>>> print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以无限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0个位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0个位置元素的第0个位置的元素
1
1
2
3name = '亚索' #单引号
>>> print(name)
亚索
>>> age = "34岁" #双引号
>>> print(age)
34岁
>>> aihao = """ #三引号
耍剑
喝酒
"""
>>> print(aihao)
耍剑
喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.2.2.转义符
>>> aaa = "aa'gao'"
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
aaa"ccc"
>>> ccc = 'abc'ccc' #转义'为普通字符
>>> print(ccc)
abc'ccc
1
2
3
4
5
6
7
8
9
3.2.3.常用转义符
转义符 作用
\ 在行尾时使用，为续航符，也就是换行符
\ 这个含义是指把\转义成普通字符
\’ 把’转义成普通字符
" 把“转义成普通字符
\n 换行符，把光标移动到下一行继续
\v 纵向制表符，将光标向下移动一个制表符单位
\t 水平制表符，将光标向右移动一个制表符单位
\r 代表一个回车
3.2.4.字符串的其他用法
#+号可以当作字符串的连接字符，而号可以是重复操作
>>> print("aaa" + "bbb")
aaabbb
>>> print(3"aaa")
aaaaaaaaa
#新建一个新的.py文件，写入：
a = ' '
print("欢迎来到，英雄联盟")
print(a2+"欢迎来到，英雄联盟")
print(a4+"欢迎来到，英雄联盟")
欢迎来到，英雄联盟
欢迎来到，英雄联盟
欢迎来到，英雄联盟
#a为一个空，利用号可以使空重复操作变成多个，然后就可以实现上面的效果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
3.3.列表（list）
3.3.1.列表的定义
#列表其实就是一个变量有多个变量值，但是这个变量值叫做元素，所以也叫做，一个列表中有多个元素，使用[]来表示列表
>>> a = ["1","2","3"]
>>> print(a)
['1', '2', '3']
1
2
3
4
3.3.2列表的取值
#列表有两种取值顺序：
1.从左到右索引默认从0开始，最大范围是字符串长度-1，这个0和shell的位置变量有点像
2.从右到左的索引默认从-1开始，最大范围是字符串开头
>>> a = ["1","2","3"]
>>> print(a)
['1', '2', '3']
>>> print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2]) #从0开始到2位置结束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4 #修改a列表中0位置为4
>>> print(a)
[4, '2', '3']
>>> a.append(5) #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6) #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '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
25
26
27
28
29
30
31
32
33
3.3.3.删除列表元素
>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0] #删除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]
1
2
3
4
5
3.3.4.查找列表元素
>>> print(a)
[6, '2', '3', 5]
>>> 6 in a #查看a列表中是否有6，有就返回True没有就返回False
True
>>> 8 in a
False
1
2
3
4
5
6
3.3.5.合并列表
>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b #利用+号，来合并列表，变量也可以这样使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a3) #利用*号，来重复列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']
1
2
3
4
5
6
7
8
9
10
3.3.6.列表常见问题
>>> print(a)
[1, 2, 3]
>>> print(a[6]) #不能直接查看超过列表元素总数的值
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6]) #但是可以指定范围查看
[2, 3]
>>> print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以无限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0个位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0个位置元素的第0个位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串转列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”为分割来切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”为结果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
结果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反转列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一个-1表示从4开始，::表示移动到列表末尾，也就是移动到1，第二个-1表示逆向
print(b)
输出结果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元组（Tuple）
元组类似于一个只读列表，写入元素后，元组中的元素是不可变的，操作速度比列表要快，安全性更强，使用（）来创建元组
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
1
2
3.4.1元组的创建和删除
a = (1,2,3)
print(a)
(1, 2, 3)
a[0] = 4 #元组的元素不能修改，会报错
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
del a #在删除元组时，只能全部删除，不能指定删除某个元素
print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
print(a[1:6]) #但是可以指定范围查看
[2, 3]
>>> print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以无限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0个位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0个位置元素的第0个位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串转列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”为分割来切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”为结果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
结果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反转列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一个-1表示从4开始，::表示移动到列表末尾，也就是移动到1，第二个-1表示逆向
print(b)
#输出结果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元组（Tuple）
元组类似于一个只读列表，写入元素后，元组中的元素是不可变的，操作速度比列表要快，安全性更强，使用（）来创建元组
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
1
2
3.4.1元组的创建和删除
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4 #元组的元素不能修改，会报错
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a #在删除元组时，只能全部删除，不能指定删除某个元素
>>> print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
1
2print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以无限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0个位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0个位置元素的第0个位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串转列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”为分割来切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”为结果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
结果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反转列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一个-1表示从4开始，::表示移动到列表末尾，也就是移动到1，第二个-1表示逆向
print(b)
#输出结果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元组（Tuple）
元组类似于一个只读列表，写入元素后，元组中的元素是不可变的，操作速度比列表要快，安全性更强，使用（）来创建元组
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
1
2
3.4.1元组的创建和删除
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4 #元组的元素不能修改，会报错
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a #在删除元组时，只能全部删除，不能指定删除某个元素
>>> print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
1
2
3
print(a[0:-1]) #指定范围时，可以同时使用正数和负数进行索引
[1, 2]
1
2
3
4
5
6
7
8
9
10
3.3.7.嵌套列表
#列表中也可以是列表，是可以无限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0]) #查看a列表中的第0个位置的元素
[1, 2, 3]
>>> print(a[0][0]) #查看a列表中第0个位置元素的第0个位置的元素
1
1
2
3
4
5
6
7
8
3.3.8.字符串转列表
str1 = "12345"
list1 = list(str1)
print list1
str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ") #以“空”为分割来切割字符串生成列表
print list2
str3 = "www.google.com"
list3 = str3.split(".") #以“.”为结果分割
print list3
1
2
3
4
5
6
7
8
9
10
11
结果如下：
['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']
1
2
3
3.3.9.反转列表元素
a=[1,2,3,4]
b=a[-1::-1] #第一个-1表示从4开始，::表示移动到列表末尾，也就是移动到1，第二个-1表示逆向
print(b)
#输出结果
[4, 3, 2, 1]
1
2
3
4
5
6
3.4.元组（Tuple）
元组类似于一个只读列表，写入元素后，元组中的元素是不可变的，操作速度比列表要快，安全性更强，使用（）来创建元组
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
1
2
3.4.1元组的创建和删除
>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4 #元组的元素不能修改，会报错
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a #在删除元组时，只能全部删除，不能指定删除某个元素
>>> print(a)
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
1
2
3
4
5
6
7
8
9
10
11
12
3.4.2.元组和列表的互相转换
a = [1,2,3]
b = (1,2,3)
c = list(b) #转换时，需要重新定义变量
print(c)
[1, 2, 3]
print(type(c)) #查看c变量的类型，发现是列表
<class 'list'>
d = tuple(a) #把a列表变成元组，并且重新定义变量成d
print(d)
(1, 2, 3)
print(type(d))
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11
12
3.5.集合（Set）
集合是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员
基本功能是进行成员关系测试和删除重复元素
可以使用大括号{ }或者是set( )函数创建集合，要注意的是，创建一个空集合必须使用set( )，因为{ }使用来创建一个空字典的
创建格式：
a = {value1,value2,...}
set(value)
1
2
3.5.1.集合的创建
a = {'aaa','bbb','ccc','ddd'}
print(a)
print(type(a))
输出结果：
{'aaa', 'ddd', 'bbb', 'ccc'}
<class 'set'>
1
2
3
4
5
6
7
b=set("aaaa5cccddd")
print(b)
print(type(b))
输出结果：
{'a', 'd', 'c', '5'}
<class 'set'>
1
2
3
4
5
6
7
3.5.2.成员测试
a = {'aaa','bbb','ccc','ddd'}
if 'aaa' in a:
print("aaa在a集合中")
else:
print("aaa不在a集合中")
输出结果：
aaa在a集合中
1
2
3
4
5
6
7
8
3.5.3.集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
print(a - b) #a和b的差集
print(a | b) #a和b的并集
print(a & b) #a和b的交集
print(a ^ b) #a和b中不同时存在的元素
输出结果：
{'b', 'r', 'd', 'c', 'a'}
{'l', 'z', 'm', 'c', 'a'}
{'r', 'd', 'b'}
{'l', 'z', 'b', 'r', 'd', 'm', 'c', 'a'}
{'a', 'c'}
{'l', 'r', 'z', 'b', 'd', 'm'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
3.6.字典（Dictionary）
字典中的值，是通过键值对来存储的，key-value的方式，使用{ }来创建字典，字典的索引由键和它对应的值组成
列表是有序的对象集合，字典是无序的对象集合两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
键(key)必须使用不可变类型
在同一个字典中，键(key)必须是唯一的
3.6.1.字典的创建
字典中的键具有唯一性，但是值可以相同，键名区分大小写，当有多个相同的键名和值时，只有最后一个键值会生效
a = {"id":1,"name":"zhangsan"}
print(a)
{'id': 1, 'name': 'zhangsan'}
print(type(a))
<class 'dict'>
print(a["id"]) #索引a字典中，id键的值
1
print(a["name"])
zhangsan
a = {"id":1,"id":2,"id":3}
print(a) #字典中有多个相同的键时，只有最后一个键值会生效
{'id': 3}
del a #删除a字典
1
2
3
4
5
6
7
8
9
10
11
12
13
14
3.6.2.字典中键的添加、修改、删除操作
添加：
a={"aaa":1,"bbb":2}
a["ccc"] = 3 #添加不存在的键值即可
print(a)
输出结果：
{'aaa': 1, 'bbb': 2, 'ccc': 3}
——————————————————————————————
修改：
a={"aaa":1,"bbb":2}
a["aaa"] = 3 #修改指定键的值
print(a)
输出结果：
{'aaa': 3, 'bbb': 2}
——————————————————————————————
删除：
a={"aaa":1,"bbb":2}
del a["aaa"] #删除指定的键值
print(a)
输出结果：
{'bbb': 2}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
3.7.Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可
以下几个内置的函数可以执行数据类型之间的转换这些函数返回一个新的对象，表示转换的值
函数 描述\作用
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典d 必须是一个 (key, value)元组序列
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串
4.Python3基础语法
4.1.编码
默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串 当然你也可以为源码文件指定不同的编码：
-- coding: cp-1252 --
1
上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语
一般来说都是直接指定utf-8
-- coding: utf-8 --
1
4.2.标识符
第一个字符必须是字母表中字母或下划线 _
标识符的其他的部分由字母、数字和下划线组成
标识符对大小写敏感
注意：在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了
4.3.Python保留字
保留字即关键字，我们不能把它们用作任何标识符名称Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
import keyword
keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', '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']
1
2
3
4.3.注释
Python中单行注释以# 开头，实例如下：
!/usr/bin/python3
第一个注释
print ("Hello, Python!") # 第二个注释
1
2
3
执行以上代码，输出结果为：
Hello, Python!
1
多行注释可以用多个 # 号，还有 ''' 和 """：
!/usr/bin/python3
第一个注释
第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
print ("Hello, Python!")
1
2
3
4
5
6
7
8
9
10
11
12
执行以上代码，输出结果为：
Hello, Python!
1
4.4.行与缩进
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数实例如下：
if True:
print ("True")
else:
print ("False")
1
2
3
4
以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：
if True:
print ("Answer")
print ("True")
else:
print ("Answer")
print ("False") # 缩进不一致，会导致运行错误
1
2
3
4
5
6
以上程序由于缩进不一致，执行后会出现类似以下错误：
File "test.py", line 6
print ("False") # 缩进不一致，会导致运行错误
^
IndentationError: unindent does not match any outer indentation level
1
2
3
4
4.5.多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \来实现多行语句，例如：
total = item_one +
item_two +
item_three
1
2
3
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 ****，例如：
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
1
2
4.6.空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始类和函数入口之间也用一行空行分隔，以突出函数入口的开始
空行与代码缩进不同，空行并不是Python语法的一部分书写时不插入空行，Python解释器运行也不会出错但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构
注意：空行也是程序代码的一部分
4.7.等待用户输入
执行下面的程序在按回车键后就会等待用户输入：
#!/usr/bin/python3
input("\n\n按下 enter 键后退出") #利用input交互式赋予变量值
1
2
以上代码中 ，\n\n在结果输出前会输出两个新的空行一旦用户按下 enter 键时，程序将退出
4.8.同一行显示多条语句
Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割，以下是一个简单的实例：
#!/usr/bin/python3
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
1
2
使用脚本执行以上代码，输出结果为：
runoob
1
使用交互式命令行执行，输出结果为：
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
runoob
7
1
2
3
此处的 7 表示字符数
4.9.多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组
我们将首行及后面的代码组称为一个子句(clause)
如下实例：
if expression :
suite
elif expression :
suite
else :
suite
1
2
3
4
5
6
4.10.print输出
print默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
#!/usr/bin/python3
x="a"
y="b"
换行输出
print( x )
print( y )
print('---------')
不换行输出
print( x, end=" " )
print( y, end=" " )
print()
1
2
3
4
5
6
7
8
9
10
11
以上实例执行结果为：
a
b
a b
1
2
3
4
4.11.import和from…import
在 python 用 import 或者 from...import 来导入相应的模块
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
导入sys模块
import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
print (i)
print ('\n python 路径为',sys.path)
导入sys模块的argv,path成员
from sys import argv,path # 导入特定的成员
print('================python from import===================================') print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path
1
2
3
4
5
6
7
8
9
10
11
4.12.命令行参数
很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
[ etc. ]
1
2
3
4
5
6
7
8
9
我们在使用脚本形式执行 Python 时，可以接收命令行输入的参数
二、拓展小脚本
-选车牌小程序
import random
import string #导入变量
car_num = string.digits+string.ascii_uppercase #定义一个变量，这个变量的值是随机的数字和大写字母组成的字符串
print("请选择你的车牌号") #提示语
a = 3 #预定义变量用作于while循环
while a > 0: #当a变量的值大于0时进行循环，a变量定义为3
num_list = [] #定义一个空列表
for i in range(20): #定义for循环，循环20次
choice = random.choice(string.ascii_uppercase) #定义变量，这个变量的值是随机的一位大写字母
car = f"京{choice}-{''.join(random.sample(car_num,5))}" #定义变量，这个变量就是车牌号，利用join把上面变量的五位字符串整合到一起
car = str(car) #上面的变量定义为字符串类型
num_list.append(car) #把新建变量加入上面定义的空列表，加入到末尾
print(f"这是第{i}次的车牌号：{car}") #提示语
aaa = input("请选择你的车牌:") #利用交互式函数input对aaa变量进行赋值
if aaa in num_list: #对aaa变量进行判断输入的变量值是否在上面的列表中
print(f"恭喜你选中车牌，车牌号是:{aaa}") #有的话输出提示语并且退出循环
break
else:
a -= 1 #没有的话利用while循环a的值进行提示
print(f"对不起，你没有选中车牌，你还有{a}次机会")
if a == 0:
print("对不起，你已经无法选择车牌了")
else:
print("请重新选择")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
-99乘法表
for a in range(1,9):
for b in range(1,9):
if b <= a:
c = a * b
print(f"{a} * {b} = {c}\t", end="")
print("")
1
2
3
4
5
6
- 年会抽奖小程序
import random
import string
list_1 = []
for i in range(1,300):
name_1 = string.ascii_uppercase
name_2 = random.sample(name_1,2)
name_3 = str(i) + ''.join(name_2)
list_1.append(name_3)
print(list_1)
print(random.choice(list_1))
a = 1
b = 1
c = 1
while a < 4:
while b < 7:
while c < 31:
san = random.choice(list_1)
print(f"抽三等奖，奖品是byt,第{c}位抽奖的是{san},恭喜获得三等奖")
list_1.remove(san)
c = c + 1
er = random.choice(list_1)
print(f"抽二等奖，奖品是iphone,第{b}位抽奖的是{er},恭喜获得二等奖")
list_1.remove(er)
b = b + 1
yi = random.choice(list_1)
print(f"抽一等奖，奖品是泰国五日游,第{a}位抽奖的是{yi},恭喜获得一等奖")
list_1.remove(yi)
a = a + 1
print(list_1)
————————————————
版权声明：本文为CSDN博主「礁之」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/rzy1248873545/article/details/124535728
