万物皆有裂痕，那是光照进来的地方--(存在即是定数！)
In the face of love,spare no effort to like.
目录
#### 2.3.1数字Number(Python3中支持int,float,bool,complex)
#### 2.3.3内置函数type()和isinstance()
## 1.计算机基础
软件：由程序员使用编程语言开发出来的代码集合
python语言输出的语法规则：
print("我是小美！")
输出结果：
我是小美！编程语言分类：
翻译维度：解释性语言，编译型语言
高低维度：低级编程语言（代码可被计算机直接识别--机器语言，汇编语言等），高级编程语言（代码无法被计算机直接识别，可通过某种方式转换为计算机可以识别的语言--python，C++等）
编译器/解释器：将代码翻译为计算机能够识别的命令
解释器（边执行边转换）：实时编译 解释型语言(eg:PHP、Shell、JavaScript、Python等)
编译器（一次性转换为二进制指令）：全文编译 编译型语言(C语言、C++、汇编语言等)
| 类型 | 原理 | 优点 | 缺点 |
| 编译型语言 | 通过专门编译器，将所有源代码一次性转成特定平台（windows、linux、macos）的机器码（以可执行文件的形式存在） | 编译一次后，脱离了编译器也可运行，且运行效率高 | 可移植性差，不够灵活 |
| 解释型语言 | 通过专门解释器，根据需要可将部分或全部源代码转换成特定平台（windows、linux、macos）的机器码 | 跨平台性好，通过不同的解释器，将相同的源代码解释成不同平台下的机器码1 | 边执行边转换，效率较低 |
硬件、操作系统、软件简单介绍：
计算机硬件包括：cpu、内存、磁盘、网卡、主板等
操作系统：运行在计算机上，对计算机的硬件资源进行分配，协调各个硬件之间协作，将用户的操作转化为计算机可以识别的命令
软件：指有程序员开发并在操作系统上安装，能够在操作系统上运行的程序
系统环境变量的作用：
在将某个程序的目录添加到环境变量后，如果在终端再去执行这个程序的时候，就可以不带程序的路径直接执行
python与pycharm区别：
python是解释器，用于将python代码解释为计算机可以识别的命令
pycharm是编译器，可以便捷的编写python代码并能够运行
计算机中对于数据的存储都是以0和1的组合完成的
## 2.python基础语法知识
### 2.1 输出简述
print()函数：用于打印输出，默认print会在结尾加换行符
print("南征北战")
print("南来北往")
输出结果：
南征北战
南来北往语法
print(objects,sep=' ',end='\n',file=sys.stdout,flush=False)objects：复数，表示可以一次输出多个对象，可以是字符串、数字、变量等。输出多个对象时，需要用","分隔
sep：间隔多个对象，，默认值是一个空格
end：用于指定输出结束时的字符，默认值是换行符
file：用于指定输出的文件对象，默认值是sys.stdout，即输出到控制台
flush：用于指定是否刷新输出缓冲区，默认值是False
在Python中，我们可以使用print函数输出各种类型的数据，例如字符串、数字、变量等。
print("Hello, World!") # 输出字符串
print(123) # 输出整数
print(3.14) # 输出浮点数
name = "Alice"
print("My name is", name) # 输出变量
输出结果：
Hello, World!
123
3.14
My name is Alice
print函数的高级用法
除了基本用法外，print函数还有一些高级用法，可以根据需要进行定制输出。
1. 使用sep参数分隔多个对象
通过设置sep参数，我们可以指定输出多个对象时的分隔符。默认情况下，分隔符是一个空格。
print("apple", "banana", "orange")
print("apple", "banana", "orange", sep=',')
print("apple", "banana", "orange", sep=' | ')
输出结果：
apple banana orange
apple,banana,orange
apple | banana | orange2. 使用end参数指定输出结束符
通过设置end参数，我们可以指定输出结束时的字符。默认情况下，结束符是一个换行符。
print("Hello", end='')
print("World!")
print("Hello", end=' ')
print("World!")
输出结果：
HelloWorld!
Hello World!3. 输出到文件
除了输出到控制台，我们还可以将内容输出到文件中。通过设置file参数，我们可以指定输出的文件对象。
with open('output', 'w') as f:
print("Hello, World!", file=f)
上述代码将字符串"Hello, World!"输出到名为output的文件中输出带有变量的字符串
可使用print函数的字符串拼接功能，将变量与字符串拼接在一起输出
name = "Alice"
age = 20
print("My name is " + name + ", and I am " + str(age) + " years old.")
输出结果：
My name is Alice, and I am 20 years old.在输出中插入换行符
可在字符串中使用转义字符\n来表示换行符
print("Hello\nWorld!")
输出结果：
Hello
World!格式化输出数字
可使用print函数的格式化字符串功能，通过占位符来指定数字的格式
num = 3.14159
print("The value of pi is %.2f." % num)
输出结果：
The value of pi is 3.14.将输出内容保存到变量中
可使用字符串的IO操作，将输出内容保存到变量中
import io
output = io.StringIO()
print("Hello, World!", file=output)
result = output.getvalue()
print(result)
输出结果：
result中保留：
Hello, World!### 2.2 变量简述
变量：对某个值赋予名称，这个名称以后就指这个值
python中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。变量就是变量，它没有类型，我们所说的“类型”是变量所指的内存中对象的类型。等号“=”用来给变量赋值，格式：[变量名 = 值]
#单变量赋值
age = 18
#多变量赋值
a = b = c = 666
d, e, f = 2, 4, "stereotype"变量名的规范
变量名只能由字母、数字、下划线组成
数字不能开头
不能用python内置的关键字 在使用pycharm时会有提示
### 2.3 数据类型
python中有六个标准的数据类型：
Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)
其中:
不可变数据：Number(数字)、String(字符串)、Tuple(元组)
可变数据：List(列表)、Set(集合)、Dictionary(字典)
#### 2.3.1数字Number(Python3中支持int,float,bool,complex)
整型int
可在命令行界面输入"python"直接进行运算
>>> 5+4 #加法
9
>>> 3*7 #乘法
21
>>> 2**2 #平方
4
>>> 2//4 #除法，得到一个整数
0
>>> 2/4 #除法，得到一个浮点数
0.5
>>> 17%3 #取余
2
>>> 2**5 #5次方
32
#混合运算中，python会把整型转换为浮点数浮点型float--小数类型
print(1.0+1.2)
print(0.1*0.1)
print(4.4/2)
print(4.4//2)
print(0.1**2)
print(4.4%2)
输出结果：
2.2
0.010000000000000002
2.2
2.0
0.010000000000000002
0.40000000000000036布尔类型bool
共两个值 真（True） 假（False）
print(1>2)
print(1==1)
输出结果：
False
True复数类型complex
复数由实数部分和虚数部分构成，可以用a+bj，或complax(a,b)表示，复数的实部和虚部都是浮点型。
#### 2.3.2字符串String
python中的字符串用单引号、双引号、三双引号、三单引号括起来，同时，使用\转义特殊字符
#python使用反斜杠\转义特殊字符，若不想让反斜杠发生转义，可在字符串前添加一个r，表示原始字符串
print('hello\nworld')
print(r'hello\nworld')
输出结果：
hello
world
hello\nworld
#反斜杠可以作为续行符，表示下一行是上一行的延续。也可以使用"""..."""或'''...'''跨越多行。
name = 'abc \
def'
name1 = '''qwer
cxz
nbv'''
print(name)
print(name1)
输出结果:
abc def
qwer
cxz
nbv
字符串操作
#字符串拼接
print("我是"+"好孩子")
practice_str1="好孩子"
practice_str2="是我"
print("介绍一下，{}，{}。".format(practice_str1,practice_str2))
输出结果：
我是好孩子
介绍一下，好孩子，是我。
#字符串相乘
print(3*"天青色等烟雨\n")
输出结果：
天青色等烟雨
天青色等烟雨
天青色等烟雨#### 2.3.3内置函数type()和isinstance()
内置的type()函数可以用来查询变量所指定的对象类型
isinstance()函数用来判断
#type()函数
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
输出结果：
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
isinstance()函数
a = 111
print(isinstance(a, int))
输出结果：
Trueisinstance和type区别在于：
type()不会认为子类是一种父类类型
isinstance()会认为子类是一种父类类型
注意：python3中，bool是int的子类，True(值为1)和False(值为0)可以和数字相加
#### 2.3.4数据类型转换
- int整型定义时，必须是数字无引号
- str字符串定义时，必须用引号括起来
- bool布尔值定义时，只能写True/False
- float浮点型定义时，必须是带小数的数字
##### 2.3.4.1转换为整型
#字符串转换为整型
print("6" + "9")
print(int("6") + int("9"))
输出结果：
69
15
#布尔型转换为整型
print(int(True))
print(int(False))
输出结果：
1
0
#浮点型转换为整型
print(int(1.1))
输出结果：
1##### 2.3.4.2转换为浮点型
print(float(1)) #整数
print(float(112)) #整数
print(float(-123.6)) #整数
print(float('123')) #字符串
输出结果：
1.0
112.0
-123.6
123.0##### 2.3.4.3转换为字符串
#整型转为字符串
print(str(123))
print(str(456) + str(7))
输出结果：
123
4567
#布尔型转换为字符串
print(str(True))
print(str(False))
输出结果：
True
False##### 2.3.4.4转换为布尔型
bool()函数用于将给定参数转换为布尔类型，若没有参数，返回False
bool是int的子类
#整型转换为布尔型
print(bool(1))
print(bool(0))
print(bool(-10))
输出结果：
True
False
True
#字符串转换为布尔型
print(bool("xiaomei"))
print(bool("123"))
print(bool(""))
print(bool(" "))
输出结果：
True
True
False
True##### 2.3.4.5类型转换口诀
- 其他所有类型转换布尔类型时，均除了空字符串和整数0以外其他都是True
- 字符串转整型时，只有引号里是数字的才可以转换，其余皆报错
- 想转换为那种类型，就写入此类型的函数里str(),int(),bool(),float()
### 2.4 注释简述
- 单行注释：使用#在行首
- 多行注释：使用三个单引号'''...'''或三个双引号"""..."""将注释内容包含起来
- 选取一部分：ctrl+/注释
### 2.5 输入简述
input( )函数：input()函数从控制台获得用户输入，无论用户在控制台输入什么内容，input()函数都以字符串类型返回结果。
name=input()//将用户输入的字符串存储到name变量中
#用户输入姓名，完成拼接
name_str1 = input("请输入姓名1：")
name_str2 = input("请输入姓名2：")
text = name_str1 + "爱" + name_str2
print(text)
输出结果：
请输入姓名1：鹿晗
请输入姓名2：关晓彤
鹿晗爱关晓彤
#输入两个数字，计算两个数字之和
number1 = input("请输入一个数字：")
number2 = input("请输入另一个数字：")
value = int(number1) + int(number2)
print(value)
输出结果：
请输入一个数字：140
请输入另一个数字：526
666### 2.6 条件语句
if条件:
条件成立之后的代码
else:
条件不成立之后的代码
缩进：四个表格=tab
举例：
name = input("请输入一个姓名：")
if name == "xiaomei":
print("妹妹")
else:
print("陌生人")
输出结果1：
请输入一个姓名：meimei
陌生人
输出结果2：
请输入一个姓名：xiaomei
妹妹#### 2.6.1基本条件语句
#例一
print("开始")
if True:
print("123")
else:
print("456")
print("结束")
输出结果：
开始
123
结束
#例二
print("开始")
if 6==6
print("123")
else:
print("456")
print("结束")
输出结果：
开始
123
结束
#例三
num = 18
if num > 10:
print("num变量对应值大于10")
else:
print("num变量对应值不大于10")
输出结果：
num变量对应值大于10
#例四
username = "meimei"
password = "20141212"
if username == "meimei" and password == "20141212":
print("恭喜你，登录成功！")
else:
print("登录失败!!!")
输出结果：
恭喜你，登录成功！
#例五
username = "zhangsan"
if username == "zhangsan" or username == "wangwu":
print("VIP用户")
else:
print("普通用户")
输出结果：
VIP用户
#例六
number = 18
if number%2 ==1:
print("number是奇数")
else:
print("number是偶数")
输出结果：
number是偶数
#猜数字游戏
number = input("请输入您要猜的三位数字：")
if number == "666":
print("猜对啦!")
else:
print("猜错了-_-")
输出结果1：
请输入您要猜的三位数字：333
猜错了-_-
输出结果2：
请输入您要猜的三位数字：666
猜对啦!
#### 2.6.2多条件语句
python中elif代替了else if，所以if语句的关键字为：if-elif-else
注意：
- 每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块
- 使用缩进来划分语句块，相同缩进的语句在一起组成一个语句块
- 在python中没有switch...case语句
#猜一位数字
num = input("请输入一位数字：")
data = int(num)
if data > 6:
print("过大！")
elif data == 6:
print("刚刚好！")
else:
print("太小！")
输出结果：
请输入一位数字：6
刚刚好！
#判断成绩
score = input("请输入分数：")
data = int(score)
if data > 90:
print("优秀的孩子！")
elif data > 80:
print("给个良好！")
elif data > 70:
print("一般哦！加油！")
elif data > 60:
print("感情好，刚及格-_-")
else:
print("及格线就很接近了，努把力！")
输出结果：
请输入分数：46
及格线就很接近了，努把力！#### 2.6.3条件嵌套
#开发一个存取款小程序，用户通过登录后进入程序，然后可以进行存款取款等操作，要求用户子菜单选择退出后到登录界面，登录界面菜单退出后直接结束程序
#内置默认金额10000元，用户可进行存取款
main_menu = """
###########欢迎来到中国工商银行############
1、登录
2、退出
#######################################
"""
sub_menu = """
**********************显示界面*****************************
1.查询
2.取款
3.存款
4.退出
*********************************************************
"""
register = "admin"
passwd = 123456
default = 10000
chance = 3
flag = True
print(main_menu)
Num = int(input("请输入您选择的操作："))
while Num == 1:
username = input("请输入您的用户名：")
userpwd = int(input("请输入您的密码:"))
if username == register and userpwd == passwd:
print("登录成功！")
while flag:
print(sub_menu)
num = int(input("请选择您的操作："))
if num == 1:
print(f"您的账户余额为：{default}")
continue
elif num == 2:
withdrawal = int(input("请输入您要取款的数目："))
if withdrawal > default:
print(f"您存款的数目{withdrawal}超过了目前的金额{default}！")
continue
else:
default = default - withdrawal
print(f"取款成功！您目前还剩{default}元")
continue
elif num == 3:
deposit = int(input("请输入您要存款的数目："))
default = default + deposit
print(f"存款成功！您目前还剩{default}元")
continue
else:
flag = False
break
else:
opp = 1
chance = chance - opp
print(f"您的用户名或密码输入错误！您还有{chance}次机会！")
opp += 1
if chance == 0:
print("3次机会使用完毕，您已无法登录！！！")
exit(0)
输出结果：
###########欢迎来到中国工商银行############
1、登录
2、退出
#######################################
请输入您选择的操作：1
请输入您的用户名：admin
请输入您的密码:123456
登录成功！
**********************显示界面*****************************
1.查询
2.取款
3.存款
4.退出
*********************************************************
请选择您的操作：1
您的账户余额为：10000
**********************显示界面*****************************
1.查询
2.取款
3.存款
4.退出
*********************************************************
请选择您的操作：2
请输入您要取款的数目：666
取款成功！您目前还剩9334元
**********************显示界面*****************************
1.查询
2.取款
3.存款
4.退出
*********************************************************
请选择您的操作：2
请输入您要取款的数目：20000
您存款的数目20000超过了目前的金额9334！
**********************显示界面*****************************
1.查询
2.取款
3.存款
4.退出
*********************************************************
请选择您的操作：3
请输入您要存款的数目：10000
存款成功！您目前还剩19334元
**********************显示界面*****************************
1.查询
2.取款
3.存款
4.退出
*********************************************************
请选择您的操作：4
#退出程序### 2.7 循环语句
python中的循环语句有for和while
- while循环
while 判断条件(condition）:
执行语句(statements)...
- for循环
python中for循环可以遍历任何可迭代对象，如一个列表或一个字符串
for <variable> in <sequence>:
<statements>
else:
<statements>
#### 2.7.1无限循环
var = 1
while var == 1:
num = int(input("输入一个数字："))
print("你输入的数字是：",num)
print("Good bye!")
输出结果：
输入一个数字：5
你输入的数字是： 5
输入一个数字：6
你输入的数字是： 6
输入一个数字：5
你输入的数字是： 5
输入一个数字：4
你输入的数字是： 4#### 2.7.2简单语句组
类似if语句的语法，如果while循环体中只有一条语句，可以将该语句与while写在同一行中：
flag = 1
while (flag):print("欢迎学习while循环！")
print("Good bye!")
输出结果：(未休止的循环)
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！
欢迎学习while循环！#### 2.7.3 range()函数
#遍历数字序列
for i in range(6):
print(i)
输出结果：
0
1
2
3
4
5
#使用range指定区间的值
for i in range(6,9):
print(i)
输出结果：
6
7
8
#指定数字开始，并指定不停的步长--每隔三个输出
for i in range(6,20,3):
print(i)
输出结果：
6
9
12
15
18#### 2.7.4循环语句基本使用
#例1--循环输出不作结果演示
data = True
print("开始")
while data:
print("纵然万劫不复,纵然相思入骨,我待你眉眼如初,岁月如故")
print("结束")
#例二
print("开始")
flag = True
while flag:
print("红了樱桃，绿了芭蕉")
flag = False
print("结束")
输出结果：
开始
红了樱桃，绿了芭蕉
结束
#例三
print("开始")
num = 1
while num < 3:
print("红了樱桃，绿了芭蕉")
num = 5
print("结束")
输出结果：
开始
红了樱桃，绿了芭蕉
结束
#例四
print("开始")
num = 1
while num < 5:
print("外婆桥")
num = num + 1
print("结束")
输出结果：
开始
外婆桥
外婆桥
外婆桥
外婆桥
结束#### 2.7.5 break简述
用于在while循环中帮助停止循环
#例1
print("开始")
while True:
print("1")
break
print("2")
print("结束")
输出结果：
开始
1
结束
#例2
print("开始运行系统")
while True:
user = input("请输入用户名：")
pwd = input("请输入密码：")
if user == "admin" and pwd == "123456":
print("登录成功^-^")
break
else:
print("用户名或密码输入错误，请重新登录-_-")
print("系统结束")
输出结果1：
开始运行系统
请输入用户名：admin
请输入密码：123456
登录成功^-^
系统结束
输出结果2：
开始运行系统
请输入用户名：admin
请输入密码：543
用户名或密码输入错误，请重新登录-_-#### 2.7.6 continue简述
在循环中用于结束本次循环，开始下一次循环
print("开始")
i = 1
while i < 12:
if i == 6:
i = i + 1
continue
print(i)
i = i + 1
print("结束")
输出结果：
开始
1
2
3
4
5
7
8
9
10
11
结束#### 2.7.7 while else简述
当while后的条件不成立时，else中的代码就会执行
#例1
while True:
print(123)
break
else:
print(456)
输出结果：
123
#例2
num = 1
while num < 5:
print(num)
num = num + 1
else:
print(666)
输出结果：
1
2
3
4
666#### 2.7.8 pass语句
pass是空语句，是为了保持程序结构的完整性
pass不作任何事情，一般作占位语句
while True:
pass #当没想好作何安排是占位
else:
print(666)
### 2.8 字符串格式化
#### 2.8.1基本格式化操作
#例1
name = "xiaoming"
age = 18
text = "我叫%s,今年%d岁" %(name,age)
print(text)
输出结果：
我叫xiaoming,今年18岁
#例2
message = "%(name)s何时上号？%(people)s在线等你！" %{"name":"亲","people":"全宿舍"}
print(message)
输出结果：
亲何时上号？全宿舍在线等你！#### 2.8.2百分比简述
text = "%s观看进度,20%%" %"明星大侦探"
print(text)
输出结果：
明星大侦探观看进度,20%#### 2.8.3 format简述
text_1 = "我叫{0},今年{1}岁，是的，{1}岁是一枝花的年纪".format("小美",18)
text_2 = "介绍一下，这部电影是《{font}》,看完后，我和{name}都深受启发".format(font="第二十条",name="小妹")
text_3 = "{0}和{1},你值得拥有"
data1 = text_3.format("家人健康","工作愉悦")
text_4 = "%d岁，希望面试顺利，找到一个%s"
data2 = text_4 %(21,"男盆友")
print(text_1)
print(text_2)
print(data1)
print(data2)
输出结果：
我叫小美,今年18岁，是的，18岁是一枝花的年纪
介绍一下，这部电影是《第二十条》,看完后，我和小妹都深受启发
家人健康和工作愉悦,你值得拥有
21岁，希望面试顺利，找到一个男盆友#### 2.8.4 "f"格式化方式简述
text_1 = f"所有的{'爸爸'}都喜欢{'女儿'}"
name = "哈士奇"
action = "拆家"
text_2 = f"所有的{name}都喜欢{action}"
name_1 = "kids"
action_1 = "上幼稚园"
text_3 = f"所有{1+3=}岁的{name_1.upper()}都不喜欢{action_1}"
print(text_1)
print(text_2)
print(text_3)
输出结果：
所有的爸爸都喜欢女儿
所有的哈士奇都喜欢拆家
所有1+3=4岁的KIDS都不喜欢上幼稚园### 2.9 运算符
- 算术运算符
| 运算符 | 描述 | 实例 a=10 b=20 |
| + | 两个对象相加 | a+b输出结果30 |
| - | 相减 | a-b输出结果-10 |
| * | 相乘 | a*b输出结果200 |
| / | 除 | b/a输出结果30 |
| % | 取余 | a+b输出结果2 |
| ** | 返回x的y次幂 | a**b输出结果10的20次方 |
| // | 取整除，返回商的整数部分 | 9//2输出结果4，9.0/2.0输出结果4.0 |
- 比较运算符
| 运算符 | 描述--所有比较运算符返回1表示真，返回0表示假，分别与True和False等价--注意大小写 | 实例 a=10 b=20 |
| == | 比较对象是否相等 | a==b返回False |
| != | 比较对象是否不相等 | a!=b返回True |
| <> | 比较对象是否不相等 | a<>b返回True |
| > | 返回x是否大于y | a>b返回False |
| < | 返回x是否小于y | a<b返回True |
| >= | 返回x是否大于等于y | a>=b返回False |
| <= | 返回x是否小于等于y | a<=b返回True |
- 赋值运算
| 运算符 | 描述 | 实例 |
| = | 简单的赋值运算符 | c=a+b |
| += | 加法赋值运算符 | c+=a等效c=c+a |
| -= | 减法赋值运算符 | c-=a等效c=c-a |
| *= | 乘法赋值运算符 | c*=a等效c=c*a |
| /= | 除法赋值运算符 | c/=a等效c=c/a |
| %= | 取模赋值运算符幂 | c%=a等效c=c%a |
| **= | 幂赋值运算符 | c**=a等效c=c**a |
| //= | 取整除赋值运算符 | c//=a等效c=c//a |
- 成员运算
| 运算符 | 描述 | 实例 |
| in | 若在指定序列中找到值返回True，否则返回False | x在y序列返回True |
| not in | 若在指定序列中没找到值返回True，否则返回False | x不在y序列返回True |
test = "china" in "chinese"
print(test)
text = "xiaomei"
user_int = input("请输入内容：")
if user_int in text:
print(f"{user_int}在{text}中")
else:
print(f"{user_int}不在{text}中")
输出结果：
False
请输入内容：mei
mei在xiaomei中- 逻辑运算
| 运算符 | 描述 | 实例 |
| and | 若x为False，x and y返回False，否则返回y的计算值 | a and b返回True |
| or | 若x为True，则返回True，否则返回y的计算值 | a or b返回True |
| not | 若x为True，返回False，若x为False，则返回True | not(a and b)返回False |
#### 2.9.1运算符优先级
- 算数优先级大于比较优先级
- 比较优先级大于逻辑运算符
- 逻辑运算符内部三个优先级not > and > or
总结：加减乘除 > 比较 > not and or
#练习
v1 = 1 or 2
v2 = "" or "xiaomei"
v3 = "meimei" or "xiaomei"
v4 = 0 or 8
v5 = 0 or ""
v6 = -1 or 0
v7 = -1 or 100
print(v1,v2,v3,v4,v5,v6,v7)
输出结果：
1 xiaomei meimei 8 -1 -1### 2.10 字符串类型
#### 2.10.1字符串独有功能
- 判断字符串是否以**开头，得到一个布尔值
- 判断字符串是否以**结尾，得到一个布尔值
- 判断字符串是否为十进制数，得到一个布尔值
- 去除字符串两边的空格、换行符、制表符，得到一个新的字符串
- 去除字符串两边指定的内容
- 字符串变大写，得到一个新字符串
- 字符串变小写，得到一个新字符串
- 字符串内容替换，得到一个新字符串
- 字符串切割，得到一个列表
- 字符串拼接，得到一个新字符串
- 格式化字符串，得到一个新字符串
- 字符串转化为字节类型
- 将字符串内容居中、居左、居右展示
- 帮助填充0
# 判断字符串是否以**开头，得到一个布尔值
#例1
text_1 = "喜欢晴朗的天气，会让人心情愉悦，学习效率倍增"
result = text_1.startswith("心情愉悦")
print(result)
输出结果：
False
#例2
text_2 = input("请输入住址：")
if text_2.startswith("北京市"):
print("在京户口")
else:
print("非在京户口")
输出结果：
请输入住址：北京市朝阳区
在京户口
# 判断字符串是否以**结尾，得到一个布尔值
address = input("请输入住址：")
if address.endswith("村"):
print("农村户口")
else:
print("非农村户口")
输出结果：
请输入住址：陕西省西安市**村
农村户口
# 判断字符串是否为十进制数，得到一个布尔值
num_1 = input("请输入值：")
num_2 = input("请输入值：")
if num_1.isdecimal() and num_2.isdecimal():
data = int(num_1) + int(num_2)
print(data)
else:
print("请输入正确数字")
输出结果：
请输入值：23
请输入值：34
57
# 去除字符串两边的空格、换行符、制表符，得到一个新的字符串
# 去除字符串两边指定的内容
str_1 = " Good bye collage life! "
str_2 = "bye Good bye collage life! bye"
print(str_1.strip())
print(str_1.rstrip())
print(str_1.lstrip())
print(str_2.strip("bye"))
print(str_2.lstrip("bye"))
print(str_2.rstrip("bye"))
输出结果：
Good bye collage life!
Good bye collage life!
Good bye collage life!
Good bye collage life!
Good bye collage life! bye
bye Good bye collage life!
# 字符串变大写，得到一个新字符串
# 字符串变小写，得到一个新字符串
str_3 = "Queen of Hearts21"
print(str_3.upper())
print(str_3.lower())
输出结果：
QUEEN OF HEARTS21
queen of hearts21
# 字符串内容替换，得到一个新字符串
str_4 = "Red Queen"
print(str_4.replace("Red","White"))
输出结果：
White Queen
# 字符串切割，得到一个列表--切割时无左切割
str_5 = "小妹|妹妹|小美|meimei"
result_1 = str_5.split('|')
result_2 = str_5.rsplit("|",1)
print(str_5)
print(result_1)
print(result_2)
输出结果：
小妹|妹妹|小美|meimei
['小妹', '妹妹', '小美', 'meimei']
['小妹|妹妹|小美', 'meimei']
# 字符串拼接，得到一个新字符串
list_1 = ["美美","是","淘气包"]
str_6 = "_".join(list_1)
print(str_6)
输出结果：
美美_是_淘气包
# 格式化字符串，得到一个新字符串
str_7 = "{}最好有很多爱好，例{}、{}、{}等"
insert_1 = str_7.format("对方","唱歌","健身","收纳")
print(str_7)
print(insert_1)
输出结果：
{}最好有很多爱好，例{}、{}、{}等
对方最好有很多爱好，例唱歌、健身、收纳等
# 字符串转化为字节类型
str_8 = "我喜欢你"
trans_1 = str_8.encode("utf-8")
trans_2 = str_8.encode("gbk")
trans_3 = trans_1.decode("utf-8")
trans_4 = trans_2.decode("gbk")
print(trans_1)
print(trans_2)
print(trans_3)
print(trans_4)
输出结果：
b'\xe6\x88\x91\xe5\x96\x9c\xe6\xac\xa2\xe4\xbd\xa0'
b'\xce\xd2\xcf\xb2\xbb\xb6\xc4\xe3'
我喜欢你
我喜欢你
# 将字符串内容居中、居左、居右展示
str_9 = "隔离线"
print(str_9.center(21,"-"))
print(str_9.ljust(21,"-"))
print(str_9.rjust(21,"-"))
输出结果：
---------隔离线---------
隔离线------------------
------------------隔离线
# 帮助填充0
str_10 = "我想休息"
print(str_10.zfill(6))
输出结果：
00我想休息#### 2.10.2字符串公共功能
①相加：字符串 + 字符串
str_1 = "天青色等烟雨，" + "没人会在原地等你！"
print(str_1)
输出结果：
天青色等烟雨，没人会在原地等你！②相乘：字符串 * 整数
str_2 = "朋友一生一起走！" * 6
print(str_2)
输出结果：
朋友一生一起走！朋友一生一起走！朋友一生一起走！朋友一生一起走！朋友一生一起走！朋友一生一起走！③长度
str_3 = "光，拿乌云揉成团"
print(len(str_3))
输出结果：
8④汇入字符串中的字符--索引值方法
str_4 = "总有刁民想害朕,is you?"
print(len(str_4)) # 输出字符串长度为：15
print(str_4[0]) # 输出索引值为0的元素：总
print(str_4[4]) # 输出索引值为4的元素：想
print(str_4[8]) # 输出索引值为8的元素：i
print(str_4[-1]) # 输出索引值为-1的元素：?
print(str_4[-7]) # 输出索引值为-7的元素：i
print(str_4[-9]) # 输出索引值为-9的元素：朕
# 总 有 刁 民 想 害 朕 , i s '空格' y o u ?
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
# -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
输出结果：
15
总
想
i
?
i
朕注：字符串中只能通过索引取值，无法修改值
字符串在内部存储时不允许对内部元素修改，想修改只可重新创建
#例1
str_4 = "总有刁民想害朕,is you?"
index = 0
while index < len(str_4):
value = str_4[index]
print(value)
index += 1
输出结果：
总
有
刁
民
想
害
朕
,
i
s
y
o
u
?
#例2
str_4 = "总有刁民想害朕,is you?"
index = len(str_4) - 1
while index >= 0:
value = str_4[index]
print(value)
index -= 1
输出结果：
?
u
o
y
s
i
,
朕
害
想
民
刁
有
总⑤获取字符串中的子序列--切片方法(前取后不取)
str_4 = "总有刁民想害朕,is you?"
print(str_4[2:4]) # 输出索引值为2-4的元素("[2,4)"):刁民
print(str_4[8:]) # 输出索引值为8及其之后的元素("[8,15)"--总长度为15):is you?
print(str_4[0:7]) # 输出索引值为0-7的元素("[0,7)"):总有刁民想害朕
print(str_4[:7]) # 输出索引值为0-7的元素("[0,7)"):总有刁民想害朕
print(str_4[8:-1]) # 输出索引值为8——-1的元素("[8,-1)"):is you
print(str_4[2:-8]) # 输出索引值为2——-8的元素("[2,-8)"):刁民想害朕
print(str_4[2:len(str_4)]) # 输出索引值为2-字符串长度15的元素("[2,15)"):刁民想害朕,is you?
# 总 有 刁 民 想 害 朕 , i s '空格' y o u ?
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
# -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
输出结果：
刁民
is you?
总有刁民想害朕
总有刁民想害朕
is you
刁民想害朕
刁民想害朕,is you?注：字符串中的切片只能读取数据，无法修改数据
# 例：添加一段字符串
str_4 = "总有刁民想害朕,is you?"
value = str_4[:8] + "是你吗" +str_4[-8:]
print(value)
输出结果：
总有刁民想害朕,是你吗,is you?
⑥步长--隔着输出字符串
#例1--从索引号为12的元素"更"开始，每隔一个输出一个元素，一直到字符串完
str_5 = "生活不是电影，生活比电影更要复杂，也更加残酷"
print(str_5[12::2])
输出结果：
更复，更残
#例2--从索引号为0的元素开始，到索引号为7的元素"生"，逆序输出元素，一直到字符串完
str_5 = "生活不是电影，生活比电影更要复杂，也更加残酷"
print(str_5[7::-1])
输出结果：
生，影电是不活生
#例3--逆序输出字符串
str_5 = "生活不是电影，生活比电影更要复杂，也更加残酷"
##逆序两种都可以
print(str_5[::-1])
print(str_5[-1::-1])
输出结果：
酷残加更也，杂复要更影电比活生，影电是不活生
酷残加更也，杂复要更影电比活生，影电是不活生
⑦循环
- whie循环
#按列输出字符串--一行一个元素
str_6 = "罗密欧与朱丽叶" index = 0 while index < len(str_6): value = str_6[index] print(value) index += 1
- for循环
#按列输出字符串--一行一个元素
str_6 = "罗密欧与朱丽叶" for i in str_6: print(i)
- range()函数--按规则创建数字列表
range(6) # 指[0,1,2,3,4,5] range(1,6) # 指[1,2,3,4,5] range(1,6,2) # 指[1,3,5] range(6,1,-1) # 指[5,4,3,2,1]
- for+range()
#例1--按列输出[1,6)
for i in range(6):
print(i)
#例2--按列输出元素
str_6 = "罗密欧与朱丽叶"
for i in range(7):
print(str_6[i])
#例3--按列输出元素
str_6 = "罗密欧与朱丽叶"
for i in range(len(str_6)):
print(str_6[i])
一般应用场景：
- while：一般在做无限制(未知)循环时使用
#用户输入一个值，如果不是整数则一直输入，直到是整数了便结束
num = 0
while True:
user_in = input("请输入内容：")
if user_in.isdecimal():
num = int(user_in)
break
else:
print("输入错误，请重新输入！")
输出结果：
请输入内容：我爱beijing天安门
输入错误，请重新输入！
请输入内容：21- for循环，一般应用在已知的循环数量的场景
#按列输出字符串--两种方法
##方法一
str_7 = "谁不想遇见真爱"
for i in str_7:
print(i)
###方法二
str_7 = "谁不想遇见真爱"
for x in range(len(str_7)):
print(str_7[x])- break和contiue关键字
- continue：结束当前循环体中剩余的代码，并开始下一轮循环
- break：用于完全退出循环，跳出当前循环体，不再进行后续的迭代
#continue示例--当i等于3时，使用continue跳过了后续的代码，直接进入下一轮循环
for i in range(1,6):
if i == 3:
continue
print(i)
输出结果：
1
2
4
5
#break示例--当i等于3时，使用break完全退出了循环，不再进行后续的迭代
for i in range(1,6):
if i == 3:
break
print(i)
输出结果：
1
2#### 2.10.3字符串转换
一般情况下，只用整型转字符串最有意义
#整型转字符串
num = 666 data = str(num) print(data) # 输出字符串："666"#
data_list = ["xiaomei","HerryPoter",666] data = str(data_list) print(data) # 输出的"666"已转换为字符串['xiaomei', 'HerryPoter', 666]
补充：字符编码相关
#字符编码转换（“解决中文乱码问题”）
name = "寒风呼呼的吹"#电脑无法识别的文本
data = name.encode("utf-8")#转换为计算机可读的二进制编码
# "utf-8"全球统一编码
# 以可读可写的方式打开文件
f = open('myfile','wb')
f.write(data)#以二进制格式编写
f.close()
print(data.decode('utf-8'))#将二进制编码还原为文件格式
#python2的编码是ascii码，python3的默认编码是utf-8
#### 2.10.4Python 的字符串内建函数
- capitalize()：将字符串的第一个字符转换为大写
- center(width,fillchar)：返回一个指定的宽度width居中的字符串，fillchar为填充的字符，默认为空格
- zfill(width)：返回长度为width的字符串，原字符串右对齐，前面填充0
- count(str,beg=0,end=len(string))：返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数
- bytes.decode(encoding="utf-8",errors="strict")：python 3中没有decode方法，但可以使用bytes对象的decode()方法来解码给定的bytes对象
- encode(encoding='UTF-8',errors='strict')：以encoding指定的编码格式编码字符串，如果出错默认报一个ValueError的异常，除非errors指定的是'ignore'或者'replace'
- endswith(suffix,beg=len(string))：检查字符串是否以suffix结束，如果beg或者end指定则检查指定的范围内是否以suffix结束，如果是，返回True，否则返回False
- startswith(substr,beg=len(string))：检查字符串是否以指定字符串substr开头，如果beg和end指定则检查指定的范围内是否以指定字符串substr开头，如果是则返回True，否则返回False
- expandtabs(tabsize=8)：把字符串string中的tab符号转为空格，tab符号默认的空格数是8
- find(str,beg=0,end=len(string))：检测str是否包含在字符串中，如果指定范围beg和end，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
- index(str,beg=0,end=len(string))：跟find()方法一样，当str不在字符串中会报一个异常
- isalnum()：如果字符串至少有一个字符，并且所有字符都是字母或数字则返回True，否则返回False
- isalpha()：如果字符串至少有一个字符，并且所有字符都是字母或文字则返回True，否则返回False
- isdigit()：如果字符串只包含数字则返回True，否则返回False
- islower()：如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False
- isupper()：如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False
- isnumeric()：如果字符串中只包含数字字符则返回True，否则返回False
- isspace()：如果字符串中只包含空白则返回True，否则返回False
- istitle()：如果字符串是标题化的则返回True，否则返回False
- title()：返回"标题化"的字符串，表示为所有单词都是以大写开始，其余字母均为小写
- isdecimal()：检查字符串是否只包含十进制字符，若是则返回True，否则返回False
- join(seq)：以指定字符串作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串
- len(string)：返回字符串长度
- ljust(width,[fillchar])：返回一个原字符串左对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格
- rjust(width,[fillchar])：返回一个原字符串右对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格
- lower()：转换字符串中所有大写字符为小写
- upper()：转换字符串中所有小写字符为大写
- lstrip()：截掉字符串左边的空格或指定字符
- rstrip()：截掉字符串右边的空格或指定字符
- strip([chars])：在字符串上执行lstrip()和rstrip()
- maketrans()：创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
- max(str)：返回字符串str中最大的字母
- min(str)：返回字符串str中最小的字母
- replace(old,new,[max])：将字符串中的old替换成new，如果max指定，则替换不超过max次
- rfind(str,beg=0,end=len(string))：类似于find()函数，但是是从右边开始查找
- rindex(str,beg=0,end=len(string))：类似于index()，但是是从右边开始索引
- split(str="",num=string.count(str))：以str为分隔符截取字符串，如果num有指定值，则仅截取num+1个子字符串
- splitlines([keepends])：按照行('\r','\r\n','\n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为False，不包含换行符，如果为True，则保留换行符
- swapcase()：将字符串中大写转换为小写，小写转换为大写
- translate(table,deletechars="")：根据table给出的表(包含256个字符)转换string的字符，要过滤掉的字符放到deletechars参数中
#部分示例：将字符串"WeLovePython"转化为为"We love python"
s = ''
str_1 = "WeLovePython"
for i in str_1:
if i != 'W':
if i.isupper():
i = ' ' + i.lower()
s += i
print(s.capitalize())
#将字符串"Life is a journey,not the destination,but the scenery along the way should be and the mood at the view."按照英文逗号进行切割，然后使用中文的逗号进行拼接输出
str_2 = "Life is a journey,not the destination,but the scenery along the way should be and the mood at the view."
print('，'.join(str_2.split(',')))
word = "我爱**学校!爱自己!爱专业!"
# 字符串内置方法
# count()方法用来统计在字符串中出现的次数
print(word.count('爱'))
# split()实现字符串切割，切割后是一个列表，切割符号默认是一个空格或制表符,也可以指定分割符进行分割
print(word.split('!'))
#join可以以指定字符对列表或者可迭代的成员进行拼接
print('/'.join(word.split('!')))
#index()方法可以返回某个字符在字符串中的索引位置，如果有多个，只返回第一次出现的索引位置，如果子字符串找不到则抛出ValueError错误
print(word.index('爱'))
#find()方法根index()方法类似，也是返回索引位置，但如果子字符串找不到不会抛出堆栈错误，而是返回-1
print(word.find('山'))
name = "file.txt"
#removesuffix()移除指定后缀，不常用
print(name.removesuffix(".txt"))
#removeprefix()移除指定前缀，不常用
print(name.removeprefix("file"))
# strip()用来去除字符串左右两边的空格，注意此处是返回处理后的一个副本，并不是直接修改之前的字符串
test_string = ' A b C d '
print(len(test_string))
print(test_string.strip())
print(len(test_string.strip()))
print(len(test_string))
#去除字符串"*你好，python*"中两边的*号（要求使用至少一种方法实现）
str_1 = "*你好，python*"
print(str_1.replace('*',''))
news = "today is a good day"
print(news.title())
#startswith()以某个字母开头 endswith（）以某个字母结尾
print(news.endswith('y'))
print(news.startswith('x'))
#rfind()从右往左进行查找，如果出现多次，返回索引最高的那个索引
print(news.rfind('d'))
print(news.find('d'))
num_str = 'abc'
#zfill() = zero fill 通常用来进行指定字符串长度的填充，不够长度时，用0填充 不常用
print(num_str.zfill(5))
#isnumeric()判断是否是数值化的字符串
print(num_str.zfill(5))
print(num_str.isnumeric())
#isdigit（）判断是否是整数的字符串
print(num_str.isdigit())
#isalnum()判断是否由数字和字母组合
print(num_str.isalnum())
#isdecimal()判断是否是十进制的数字
print(num_str.isdecimal())
#isalpha()判断是否为纯字母
print(num_str.isalpha())
#islower()判断是否为小写字母，isupper()是否为大写字母
print(num_str.islower())
print(num_str.isupper())
empty_string = ' '
#isspace()判断字符串是否为空格或制表符
print(empty_string.isspace())
menu_name = '中国工商银行'
print(menu_name.center(30, '#'))
#ljust()对字符串指定长度，然后居左处理，不够的填充对应字符 rjust()居右处理
print(menu_name.ljust(30,'#'))
#capitalize()将字符串的首字母转换大写，不常用
news = "today is a good day"
print(news.capitalize())
#splitlines()按照行的分隔符进行分割，并生成一个列表
poet = """锦瑟无端五十弦，
一弦一柱思华年。
庄生晓梦迷蝴蝶，
望帝春心托杜鹃。
"""
print(poet.splitlines())
#英文所有标点
print(string.punctuation)
# 字符串切片
# 字符串是一个不可变的序列
english_name = "WhiteHouse"
#字符串正向切片 从左到右取值 string_name[start_index:end_index:step]
#默认的起始索引是0，可以省略
print(english_name[0:5])
# english_name[4] = 'E' ×字符串不能通过下标赋值方法实现修改字符串数据
print(english_name[0:5:2])
#负向索引
#'W h i t e H o u s e'
#-10-9-8-7-6-5-4-3-2-1
print(english_name[-10:-5])
#反向切片 通常步长要设置成 -1
print(english_name[::-1])#反向输出esuoHetihW
print(english_name[-1:-6:-1][::-1])
#如果反向切片要有结果值，必须步长方向和索引区间取值一致 不然没有交集
print(english_name[-6:-1:-1])#反向取不到交集
#根据标点符号对字符串进行分行
userprint = input("输入字符串:")
s = ""
for i in userprint:
s += i
if i in string.punctuation:
s += "\n"
print(f"输出换行字符串格式为\n{s}")### 2.11 列表类型
#### 2.11.1定义
list(列表)是python中使用最频繁的数据类型
列表可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，它支持数字，字符串，甚至可以包含列表(所谓嵌套)
列表是写在方括号[ ]之间，用逗号分隔开的元素列表
不可变类型：字符串、布尔、整型(已最小，内部数据无法进行修改)
可变类型：列表(内部数据元素可以修改)
# 列表举例
user_list = ["张三","李四","王五"]
number_list = [66,88,222,-1]
data_list = [1,True,"鹿晗","关晓彤"]
#空列表追加输出
user_list = []
user_list.append("前途光明！")
user_list.append(345)
user_list.append(True)
user_list.append("crush")
print(user_list)
输出结果：
['前途光明！', 345, True, 'crush']#### 2.11.2列表切片
与字符串相同，列表可以被索取和截取，列表被截取后返回一个包含所需元素的新列表
列表接取的语法格式：
变量[头下标:尾下标]
索引值以0为开始值，-1为末尾的开始位置
# 例
t = ['a','b','c','d','e']
0 1 2 3 4
-5 -4 -3 -2 -1
# t [1:3]
['b','c']
# t [3:]
['d','e']
# t [:4]
['a','b','c','d']
# t [:]
['a','b','c','d','e']
# 加号 + 是列表连接运算符，星号 * 是重复操作
# 例
list = ['abcd',786,2.23,'nebula',70.2]
tinylist = [123,'nebula']
print(list)
print(list[0])
print(list[1:3])
print(list[2:])
print(tinylist * 2)
print(list + tinylist)
输出结果：
['abcd', 786, 2.23, 'nebula', 70.2]
abcd
[786, 2.23]
[2.23, 'nebula', 70.2]
[123, 'nebula', 123, 'nebula']
['abcd', 786, 2.23, 'nebula', 70.2, 123, 'nebula']#### 2.11.3独有功能
字符串列表对比：
- 字符串：不可变，即：创建好之后内部就无法修改[独有功能都是新创建一份数据]
name = "wangduoyu"
data = name.upper()
print(name)
print(data)
输出结果：
wangduoyu
WANGDUOYU- 列表：可变，即：创建好之后内部元素可以修改[独有功能基本上都是直接操作列表内部，不会创建新的一份]
user_list = ["花车","新娘"]
user_list.append("新郎")
print(user_list)
输出结果：
['花车', '新娘', '新郎']列表中常见独有功能：
- 1.追加，可在原列表中尾部追加值
# 例1
data_list = []
v1 = input("请输入姓名：")
data_list.append(v1)
v2 = input("请输入姓名：")
data_list.append(v2)
print(data_list)
输出结果：
请输入姓名：xiaoming
请输入姓名：alice
['xiaoming', 'alice']
# 例2
user_list = []
while True:
user = input("请输入用户名(Q退出)：")
if user == "Q":
break
user_list.append(user)
print(user_list)
输出结果：
请输入用户名(Q退出)：xiaolan
请输入用户名(Q退出)：meiqi
请输入用户名(Q退出)：meixue
请输入用户名(Q退出)：youle
请输入用户名(Q退出)：moxiannvwang
请输入用户名(Q退出)：Q
['xiaolan', 'meiqi', 'meixue', 'youle', 'moxiannvwang']
# 例3
welcome = "欢迎进入盗版游戏".center(30,'*')
print(welcome)
user_count = 0
while True:
count = input("请输入游戏人数：")
if count.isdecimal():
user_count = int(count)
break
else:
print("输入格式错误，人数必须是数字")
message = f"{user_count}人参加盗版游戏"
print(message)
user_name_list = []
for i in range(1,user_count + 1):
tips = "请输入玩家姓名（{}/{}）：".format(i,user_count)
name = input(tips)
user_name_list.append(name)
print(user_name_list)
输出结果：
***********欢迎进入盗版游戏***********
请输入游戏人数：二
输入格式错误，人数必须是数字
请输入游戏人数：2
2人参加盗版游戏
请输入玩家姓名（1/2）：辣辣
请输入玩家姓名（2/2）：神之
['辣辣', '神之']- 2.批量追加，将一个列表中的元素逐一添加到另外一个列表
# 例1
changes = ["变美","变强"]
weapon = ["要自信","要自私"]
weapon.extend(changes)
print(changes)
print(weapon)
输出结果：
['变美', '变强']
['要自信', '要自私', '变美', '变强']
# 例2
changes = ["变美","变强"]
for item in changes:
print(item)
weapon = ["要自信","要自私"]
for item in weapon:
changes.append(item)
print(changes)
输出结果：
变美
变强
['变美', '变强', '要自信', '要自私']- 3.插入，在原列表的制定索引位置插入值
name_list = []
while True:
name = input("请购买火车票，输入用户姓名(Q/q退出)：")
if name.upper() == 'Q':
break
if name.startswith("刁"):
name_list.insert(0,name)
else:
name_list.append(name)
print(name_list)
输出结果：
请购买火车票，输入用户姓名(Q/q退出)：亿万富翁
请购买火车票，输入用户姓名(Q/q退出)：王多鱼
请购买火车票，输入用户姓名(Q/q退出)：q
['亿万富翁', '王多鱼']- 4.在原列表中根据值删除(从左到右找到第一个删除)[里面没有会报错]
# 例1
user_list = ["陌生人","王心凌","甜心教主","爱你"]
while True:
if "陌生人" in user_list:
user_list.remove("陌生人")
else:
break
print(user_list)
输出结果：
['王心凌', '甜心教主', '爱你']
# 例2
import random
data_list = ["叮！恋爱一日体验卡","全身按摩一次","再购一次机会更甚哦！","iphone14","谢谢惠顾","冬季尔滨一周游"]
while data_list:
name = input("自动抽奖程序，请输入自己的姓名(Q或q退出)：")
value = random.choice(data_list)
if name.lower() == "q":
break
else:
print(f"恭喜{name}，抽中{value}")
data_list.remove(value)
输出结果：
自动抽奖程序，请输入自己的姓名(Q或q退出)：张三
恭喜张三，抽中再购一次机会更甚哦！
自动抽奖程序，请输入自己的姓名(Q或q退出)：李四
恭喜李四，抽中叮！恋爱一日体验卡
自动抽奖程序，请输入自己的姓名(Q或q退出)：王五
恭喜王五，抽中冬季尔滨一周游
自动抽奖程序，请输入自己的姓名(Q或q退出)：Q- 5.在原列表中根据索引踢出某个元素(根据索引位置删除)
# 仅有三张票的自动卖票系统
user_queue = []
while True:
name = input("北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：")
if name.lower() == "q":
break
user_queue.append(name)
ticket_count = 3
for i in range(ticket_count):
username = user_queue.pop(0)
message = f"恭喜{username}，购买火车票成功！"
print(message)
failed_user = "、".join(user_queue)
failed_message = f"非常抱歉，票已售完，以下几位用户请选择其他出行方式，名单为：{failed_user}"
print(failed_message)
输出结果：
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：牙医
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：牙医实习生
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：歌手
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：说唱歌手
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：小十八
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：崔十八
北京--上海火车票，如需购买请输入姓名排队(Q或q退出)：q
恭喜牙医，购买火车票成功！
恭喜牙医实习生，购买火车票成功！
恭喜歌手，购买火车票成功！
非常抱歉，票已售完，以下几位用户请选择其他出行方式，名单为：说唱歌手、小十八、崔十八- 6.清空原列表
user_list = ["瑞幸","小十八","崔十八"]
user_list.clear()
print(user_list)
输出结果：
[]- 7.根据值获取索引(从左到右找到第一个删除)
user_list = ["瑞幸","小十八","崔十八"]
# 0 1 2
if "说唱歌手" in user_list:
index = user_list.index("说唱歌手")
print(index)
else:
print("该元素不存在于列表！")
输出结果：
该元素不存在于列表！- 8.列表元素排序--排序时内部元素无法进行比较时，程序会报错(数据类型尽量统一)
# 数字排序 num_list = [112,36,66,99,88,22] ## 从小到大排序--正向排序--默认排序 num_list.sort() print(num_list) ## 反向排序 num_list.sort(reverse=True) print(num_list) 输出结果： [22, 36, 66, 88, 99, 112] [112, 99, 88, 66, 36, 22] # 字符串排序 user_list = ["王老五","张老三","杨戬","1"] user_list.sort() print(user_list) 输出结果： ['1', '张老三', '杨戬', '王老五'] - 9.反转原列表
user_list = ["王老五","张老三","杨戬","1"] user_list.reverse() print(user_list) 输出结果： ['1', '杨戬', '张老三', '王老五']#### 2.11.4公共功能
- 相加，两个列表合成一个新列表
v1 = ["风吹过山","船靠了岸"]
v2 = ["我走向北","你去往南"]
v3 = v1 + v2
print(v3)
输出结果：
['风吹过山', '船靠了岸', '我走向北', '你去往南']- 相乘，列表*整型：将列表中的元素再创建n份并生成一个新的列表
v1 = ["晚霞","行人","夜晚的星","最好的自己!\n"]
v2 = v1[3] * 2
print(v2)
输出结果：
最好的自己!
最好的自己!- 运算符in：包含
由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中
# 是否存在，存在则删除
user_list = ["什么叫天花板!","我比烟花闪!","老子脾气爆的根本没有办法管","油门vroom vroom!"]
result = "我比烟花闪!" in user_list
## 打印上条内容是否存在
print(result)
if "老子脾气爆的根本没有办法管" in user_list:
print("该字符串存在，即将删除")
user_list.remove("老子脾气爆的根本没有办法管")
## 上条删除语句可改为：
## index = user_list.index("老子脾气爆的根本没有办法管")
## user_list.pop(index)
else:
print("不存在该字符串！")
print(f"删除后的列表为{user_list}")
输出结果：
True
该字符串存在，即将删除
删除后的列表为['什么叫天花板!', '我比烟花闪!', '油门vroom vroom!']
- 获取长度
user_list = ["什么叫天花板!","我比烟花闪!","老子脾气爆的根本没有办法管","油门vroom vroom!"]
print(len(user_list))
输出结果：
4- 索引：对元素操作
user_list = ["什么叫天花板!","我比烟花闪!","老子脾气爆的根本没有办法管","油门vroom vroom!"]
## 读
print(user_list[1])
## 改
user_list[2] = "如此温顺一孩子怎么没有办法管!"
print(user_list)
## 删
del user_list[2]
user_list.remove("油门vroom vroom!")
delete = user_list.pop(1)
print(user_list)
print(delete)
输出结果：
我比烟花闪!
['什么叫天花板!', '我比烟花闪!', '如此温顺一孩子怎么没有办法管!', '油门vroom vroom!']
['什么叫天花板!']
我比烟花闪!- 切片：多个元素操作(少用)
user_list = ["什么叫天花板!","我比烟花闪!","老子脾气爆的根本没有办法管","油门vroom vroom!"]
## 读
print(user_list[0:2])
## 改
user_list[3:] = ["忙忙碌碌寻宝藏",66,99]
print(user_list)
## 删
del user_list[1:]
print(user_list)
输出结果：
['什么叫天花板!', '我比烟花闪!']
['什么叫天花板!', '我比烟花闪!', '老子脾气爆的根本没有办法管', '忙忙碌碌寻宝藏', 66, 99]
['什么叫天花板!']- 步长
user_list = ["什么叫天花板!","我比烟花闪!","老子脾气爆的根本没有办法管","油门vroom vroom!"]
## 0 1 2 3
print(user_list[4:1:-1])
## 列表翻转-1
user_list.reverse()
print(user_list)
## 列表翻转-2
new_user = user_list[::-1]
print(new_user)
输出结果：
['油门vroom vroom!', '老子脾气爆的根本没有办法管']
['油门vroom vroom!', '老子脾气爆的根本没有办法管', '我比烟花闪!', '什么叫天花板!']
['什么叫天花板!', '我比烟花闪!', '老子脾气爆的根本没有办法管', '油门vroom vroom!']- for循环
user_list = ["什么叫天花板!","我比烟花闪!","老子是一名德才兼备的前辈","老子脾气爆的根本没有办法管","油门vroom vroom!"]
## 删除“老子脾气爆的根本没有办法管”--得不到想要的结果(删不完)
for i in user_list:
if i.startswith("老"):
user_list.remove(i)
print(user_list)
## 倒着删除
for x in range(len(user_list) -1, -1, -1):
y = user_list[x]
if y.startswith("老"):
user_list.remove(y)
print(user_list)
输出结果：
['什么叫天花板!', '我比烟花闪!', '老子脾气爆的根本没有办法管', '油门vroom vroom!']
['什么叫天花板!', '我比烟花闪!', '油门vroom vroom!']#### 2.11.5转换
- int ,bool无法转换为列表
- str
name = "小十八"
data = list(name)
print(data)
输出结果：
['小', '十', '八']- 元组，集合
v1 = (11,22,33,44)
v2 = list(v1)
v3 = {"张三","李四","王五"}
v4 = list(v3)
print(v2)
print(v4)
输出结果：
[11, 22, 33, 44]
['李四', '王五', '张三']#### 2.11.6Python列表函数&方法
python包含以下函数：
| 序号 | 函数 |
| 1 | len(list)：返回列表元素个数 |
| 2 | max(list)：返回列表元素最大值 |
| 3 | min(list)：返回列表元素最小值 |
| 4 | list(seq)：将元组装换为列表 |
| 序号 | 方法 |
| 1 | list.append(obj)：在列表末尾添加新的对象 |
| 2 | list.count(obj)：统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
| 4 | list.index(obj)：从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index,obj)：将对象插入列表 |
| 6 | [list.pop(index=-1)]：移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值 |
| 7 | list.remove(obj)：移除列表中某个值的第一个匹配项 |
| 8 | list.reverse()：反向列表中的元素 |
| 9 | list.sort(key=None,reverse=False)：对原列表进行排序 |
| 10 | list.clear()：清空列表 |
| 11 | list.copy()：复制列表 |
#### 2.11.7嵌套
列表属于容器，内部可以存放各种数据，因此其支撑列表的嵌套，如：
data = ["小沈阳",["赵本山","白云","黑土"],True,[22,66,33],"宋小宝"]
user_list = []
while True:
user = input("请输入用户名(Q退出)：")
if user == "Q":
break
pwd = input("请输入密码：")
data = [user,pwd]
user_list.append(data)
print(user_list)
输出结果：
请输入用户名(Q退出)：小十八
请输入密码：孩童
请输入用户名(Q退出)：崔十八
请输入密码：孩童老爸
请输入用户名(Q退出)：Q
[['小十八', '孩童'], ['崔十八', '孩童老爸']]### 2.12 元组类型
- 列表(list)：是一个有序且可变的容器，在里面可以存放多个不同类型的元素
- 元组(tuple)：是一个有序且不可变的容器，在里面可以存放多个不同类型的元素
#### 2.12.1定义
元组(tuple)与列表类似，不同之处在于元组的元素不能修改。元组写在小括号()里，元素之间用逗号隔开。
v1 = (11,22,33)
v2 = ("张杰","xiena")
v3 = (True,123,"landuoduo",[11,22,33,44],)
# 建议在元组的最后多加一个逗号，用于标识它是一个元组
1.比较v1 = (1)和v2 = 1和v3 = (1,)有什么区别 ？
# 解：v1，v2相当于是一个整型，v3是一个元组
2.比较值v1 = ((1),(2),(3))和v2 = ((1,),(2,),(3,),)有什么区别？
# 解：v1相当于元组中三个整型，v2相当于元组中还有三个元组
#### 2.12.2公共功能
1.相加，两个元组相加获取生成一个新的元组
data = ("添砖JAVA","Vans如意") + ("Bee有回想","star皆空")
print(data)
v1 = ("添砖JAVA","Vans如意")
v2 = ("Bee有回想","star皆空")
v3 = v1 + v2
print(v3)
输出结果：
('添砖JAVA', 'Vans如意', 'Bee有回想', 'star皆空')
('添砖JAVA', 'Vans如意', 'Bee有回想', 'star皆空')2.相乘，元组*整型 将元组中的元素再创建N份并生成一个新的元组
data = ("duck不必","藏龙wolf") * 2
print(data)
v1 = ("duck不必","藏龙wolf")
v2 = v1 * 2
print(v1)
print(v2)
输出结果：
('duck不必', '藏龙wolf', 'duck不必', '藏龙wolf')
('duck不必', '藏龙wolf')
('duck不必', '藏龙wolf', 'duck不必', '藏龙wolf')3.获取长度
user_list = ("扁桃体不发言","关你什么柿","颜值颠疯")
print(len(user_list))
输出结果：
34.切片
user_list = ("添砖JAVA","Vans如意","Bee有回想","star皆空")
print(user_list[0:2])
print(user_list[1:])
print(user_list[:-1])
输出结果：
('添砖JAVA', 'Vans如意')
('Vans如意', 'Bee有回想', 'star皆空')
('添砖JAVA', 'Vans如意', 'Bee有回想')5.索引
user_list = ("添砖JAVA","Vans如意","Bee有回想","star皆空")
print(user_list[0])
print(user_list[2])
print(user_list[3])
输出结果：
添砖JAVA
Bee有回想
star皆空6.步长
# 例1
user_list = ("添砖JAVA","Vans如意","Bee有回想","star皆空","对方正在长头发")
print(user_list[1:4:2])
print(user_list[0::2])
print(user_list[1::2])
print(user_list[4:1:-1])
输出结果：
('Vans如意', 'star皆空')
('添砖JAVA', 'Bee有回想', '对方正在长头发')
('Vans如意', 'star皆空')
('对方正在长头发', 'star皆空', 'Bee有回想')
# 字符串 & 元组
test_list = ("添砖JAVA","Vans如意","Bee有回想","star皆空","对方正在长头发")
data = test_list[::-1]
# 例2
# 列表
test_list = ["添砖JAVA","Vans如意","Bee有回想","star皆空","对方正在长头发"]
test = test_list[::-1]
test_list.reverse()
print(test_list)
输出结果：
['对方正在长头发', 'star皆空', 'Bee有回想', 'Vans如意', '添砖JAVA']7.for循环
# 例1
user_list = ("添砖JAVA","Vans如意","Bee有回想","star皆空","对方正在长头发")
for item in user_list:
print(item)
输出结果：
添砖JAVA
Vans如意
Bee有回想
star皆空
对方正在长头发
# 例2
user_list = ("添砖JAVA","Vans如意","Bee有回想","star皆空","对方正在长头发")
for item in user_list:
if item == "对方正在长头发":
continue
print(item)
输出结果：
添砖JAVA
Vans如意
Bee有回想
star皆空
目前：只有str、list、tuple可以被for循环
8.删除元组
元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组
tuple_1 = ('Google','nebula',2003,1997)
print(tuple_1)
del tuple_1
print("删除后的元组:")
print(tuple_1)
输出结果：
('Google', 'nebula', 2003, 1997)
删除后的元组:
NameError: name 'tuple_1' is not defined.变量已经被删除
#### 2.12.3 转换
其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组
tuple_1 = tuple(['Google','nebula',2003,1997])
print(tuple_1)
输出结果：
('Google', 'nebula', 2003, 1997)#### 2.12.4 元组内置函数
| 序号 | 方法及描述 | 实例 |
| 1 | len(tuple)计算元素个数 | >>>tuple1 = ('Google','Nebula','Taobao')>>>len(tuple1) 3>>> |
| 2 | max(tuple)返回元组中元素最大值 | >>>tuple2 = ('5','4','8')>>>max(tuple2) '8'>>> |
| 3 | min(tuple)返回元组中元素最小值 | >>>tuple2 = ('5','4','8')>>>min(tuple1) 3>>> |
| 4 | tuple(iterable)将可迭代系列转换为元组 | >>>list1 = ['Google','Nebula','Taobao','baidu']>>>tuple1 = tuple(list1)>>>tuple1('Google','Nebula','Taobao','baidu')>>> |
### 2.13 集合类型
集合是一个无序、可变、不允许数据重复的容器。
#### 2.13.1 定义
v1 = { 6 , 66 , 666 , "xiaomei" }
- 无序：无法通过索引取值
- 可变：可以添加和删除元素
a1 = {11,22,33,44} a1.add(55) print(a1) 输出结果： {33, 11, 44, 22, 55}
- 不允许数据重复
a1 = {11,22,33,44} a1.add(11) print(a1) 输出结果： {33, 11, 44, 22}
使用场景：
要维护大量不重复的数据时需要。例：做爬虫去网上找图片的连接，为了避免链接重复，可选择用集合去存储链接地址。
注：定义空集合时，只能使用v = set()，不能使用v={}（这样定义是指：定义一个空字典）。
#### 2.13.2 独有功能
①添加元素
data = set()
data.add("鹿晗")
data.add("关晓彤")
print(data)
输出结果：
{'关晓彤', '鹿晗'}②删除元素
data = {"刘嘉玲","关之琳","王祖贤","张曼玉","李若彤"}
data.discard("关之琳")
print(data)
输出结果：
{'王祖贤', '李若彤', '张曼玉', '刘嘉玲'}③交集
a1 = {"刘备","关羽","张飞"}
a2 = {"妲己","关羽","王昭君","安琪拉"}
a3 = a1.intersection(a2)
print(a3)
a4 = a1 & a2
print(a4)
输出结果：
{'关羽'}
{'关羽'}④并集
a1 = {"刘备","关羽","张飞"}
a2 = {"妲己","关羽","王昭君","安琪拉"}
a3 = a1.union(a2)
print(a3)
a4 = a1 | a2
print(a4)
输出结果：
{'王昭君', '张飞', '关羽', '安琪拉', '妲己', '刘备'}
{'王昭君', '张飞', '关羽', '安琪拉', '妲己', '刘备'}⑤差集
a1 = {"刘备","关羽","张飞"}
a2 = {"张飞","关羽","王昭君","安琪拉"}
# a1中有，a2中没有的值
a3 = a1.difference(a2)
# a2中有，a1中没有的值
a4 = a2.difference(a1)
# a1中有，a2中没有的值
a5 = a1 - a2
# a2中有，a1中没有的值
a6 = a2 - a1
print(a3)
print(a4)
print(a5)
print(a6)
输出结果：
{'刘备'}
{'安琪拉', '王昭君'}
{'刘备'}
{'安琪拉', '王昭君'}#### 2.13.3 公共功能
①减，计算差集
a1 = {"刘备","关羽","张飞"}
a2= {"张飞","关羽","王昭君","安琪拉"}
a3 = a1 - a2
a4 = a2 - a1
print(a3)
print(a4)②&，计算交集
a1 = {"刘备","关羽","张飞"}
a2= {"张飞","关羽","王昭君","安琪拉"}
a3 = a1 & a2
print(a3)
输出结果：
{'关羽', '张飞'}③|，计算并集
a1 = {"刘备","关羽","张飞"}
a2= {"张飞","关羽","王昭君","安琪拉"}
a3 = a1 | a2
print(a3)
输出结果：
{'刘备', '张飞', '王昭君', '关羽', '安琪拉'}④长度
a2= {"张飞","关羽","王昭君","安琪拉"}
a3 = len(a2)
print(a3)
输出结果：
4⑤for循环
a2= {"张飞","关羽","王昭君","安琪拉"}
for item in a2:
print(item)
输出结果：
王昭君
张飞
安琪拉
关羽#### 2.13.4 转换
其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：list/tuple/dict都可以转换为集合
# 例一
a1= "妲己"
a2 = set(a1)
print(a2)
输出结果：
{'妲', '己'}
# 例二
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2)
输出结果：
{33, 3, 99, 11, 22}
# 例三
v1 = (11,22,3,11)
v2 = set(v1)
print(v2)
输出结果：
{3, 11, 22}提示：这也是去重的一个字段
data = {11,22,33,3,99} v1 = list(data) v2 = tuple(data) print(v1) print(v2) 输出结果： [33, 99, 3, 22, 11] (33, 99, 3, 22, 11)
#### 2.13.5 其他
##### 2.13.5.1 集合的存储原理
##### 2.13.5.2 元素必须可哈希
因存储原理，集合的元素必须是可哈希的值。即：内部通过哈希函数把值转换成一个数字
a1 = hash("钟无艳")
print(a1)
a2 = hash((11,22,33,44,))
print(a2)
输出结果：
-8560708022979931734
8386256510965472093目前可哈希的数据类型：int,bool,str,tuple而list,set,dict是不可哈希的
总结：集合的元素只能是int,bool,str,tuple
- 转换成功
a1 = [11,22,33,11,3,99,22] a2 = set(a1) print(a2) 输出结果: {33, 3, 99, 11, 22}
- 转换失败
a1 = [11,22,["xiaowang","xiaomei"],11] a2 = set(a1) print(a2) 输出结果： 报错！
##### 2.13.5.3 查找速度特别快
因存储原理特殊，集合的查找效率非常高（数据量大了才明显）
- 效率低
a1_list= ["妲己","王昭君","安琪拉","xiaomei"] if "xiaomei" in a1_list: print("存在") else: print("不存在") a2_tuple = ("王昭君","安琪拉","xiaomei") if "xiaomei" in a2_tuple: print("存在") else: print("不存在") 输出结果： 存在 存在
- 效率高
a1_list= {"妲己","王昭君","安琪拉","xiaomei"} if "xiaomei" in a1_list: print("存在") else: print("不存在") 输出结果： 存在
将0-100 000 000(一亿)以内的所有整数存到列表和集合中，对比列表和集合查询元素的效率时间长短
# 列表用时 import time new_list = [x for x in range(1,100000000)] new_set = {x for x in range(1,100000000)} start_time = time.time() # 下行的new_list可换为new_set，对比列表和集合的用时 if 99999 in new_list: end_time = time.time() used_time = end_time - start_time print(f"存在，查找用时为{used_time}") else: print("不存在") 输出结果： 存在，查找用时为0.004836559295654297 # 集合用时 import time new_list = [x for x in range(1,100000000)] new_set = {x for x in range(1,100000000)} start_time = time.time() # 下行的new_list可换为new_set，对比列表和集合的用时 if 99999 in new_set: end_time = time.time() used_time = end_time - start_time print(f"存在，查找用时为{used_time}") else: print("不存在") 输出结果： 存在，查找用时为0.0020613670349121094
##### 2.13.5.4 对比和嵌套
| 类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
| list | 是 | 是 | 无 | 否 | list(其他) | v=[]或v=list() |
| tuple | 否 | 是 | 无 | 是 | tuple(其他) | v=()或v=tuple() |
| set | 是 | 否 | 可哈希 | 否 | set(其他) | v=set() |
注：由于True和False本质上存储的是1和0，而集合又不允许重复，所以在整数0,1和False，True出现在集合中会有如下现象;
v1 = {True, 1}
print(v1)
# {True}
v2 = {1, True}
print(v2)
# {1}
v3 = {0, False}
print(v3)
# {0}
v4 = {False, 0}
print(v4)
# {False}
### 2.14 集合内置方法完整列表
| 方法 | 描述 |
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回True，否则返回False |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| issubset() | 判断指定集合是否为该方法参数集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
下面哪些值不能作集合的元素：
0
[11,22,33] # 不能
[] # 不能
(123)
{1,2,3} # 不能
user_info_set = set()
while True:
name = input("请输入姓名：")
age = input("请输入年龄：")
item = (name,age,)
if item in user_info_set:
print("该用户已录入")
else:
user_info_set.add(item)
输出结果：
请输入姓名：美美
请输入年龄：10
请输入姓名：美美
请输入年龄：10
该用户已录入
请输入姓名：小妹
请输入年龄：10### 2.15 None类型
python 的数据类型中有一个特殊的值None，意味着这个值"啥都不是"或"表示空"。相当于其他语言中null作用一样。
在一定程度上可以帮助我们节省内存。
### 2.16 字典类型(dict)
字典是无序、键不重复，且元素只能是键值对的可变的容器
data = {"k1":1, "k2":2}
- 容器
- 元素必须键值对
- 键不重复，重复则会被覆盖
data = {"k1":1, "k1":2}
print(data)
# {'k1': 2}
- 无序(在Python3.6+的字典就是有序了，之前的字典都是无序)
data = {"k1":1, "k2":2}
print(data)
# {'k1': 1, 'k2': 2}
#### 2.16.1 定义
字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值对key=>value用冒号分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中，格式如下所示：
d = {key1 : value1, key2 : value2, key3 : value3 }
注意：dict作为Python的关键字和内置函数，变量名不建议命名为dict
键必须是唯一的，但值则不必
值可以取任何数据类型，但键必须是不可变的，如字符串，数字
空字典创建
v1 = {}
v2 = dict()字典的value值可以是整数也可以是其他任何数据类型
data = {
"k1":1,
"k2":2
}info = {
"age":12,
"status":True,
"name":"xiaomei",
"hobby":['踢毽子','足球']
}字典中对键值对要求：
- 键：必须可哈希。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。
- 值：任意类型
# 合法
data_dict = {
"小美":10,
True:5,
123:5,
(11,22,33):["liuyimei","meimei"]
}# 不合法
v1 = {
[1, 2, 3] : '周杰伦',
"age" : 18
}
v2 = {
{1, 2, 3} : "hahaha",
'name' : "meimei"
}
v3 = {
{"k1":123,"k2":456}: 'hehehe',
"age":999
}使用场景：
要表示一组固定信息时，用字典可以更加直观。例：
# 用户列表 user_list = [{"name":"meimei","pwd":"123"},{"name":"xiaomei","pwd":"345"}] print(user_list) 输出结果： [{'name': 'meimei', 'pwd': '123'}, {'name': 'xiaomei', 'pwd': '345'}]
#### 2.16.2 独有功能
①获取值
# 例一
info = {
"name":"xiaomei",
"age":10,
"status":True,
"data":None
}
data1 = info.get("name")
print(data1)
data2 = info.get("age")
print(data2)
data3 = info.get("hobby",123)
print(data3)
data4 = info.get("email")
print(data4)
输出结果：
xiaomei
10
123
None# 例二
user_list = {
"xiaomei":"1250",
"meimei":"admin",
}
username = input("请输入用户名：")
password = input("请输入密码：")
user = user_list.get(username)
if user == None:
print("用户名不存在")
else:
if password == user:
print("登录成功")
else:
print("密码错误")
输出结果：
请输入用户名：xiaomei
请输入密码：1250
登录成功# 例三
user_list = {
"xiaomei":"1250",
"meimei":"admin",
}
username = input("请输入用户名：")
password = input("请输入密码：")
user = user_list.get(username)
if user:
if password == user:
print("登录成功")
else:
print("密码错误")
else:
print("用户名不存在")
输出结果：
请输入用户名：meimei
请输入密码：admin
登录成功# 例四
user_list = {
"xiaomei":"1250",
"meimei":"admin",
}
username = input("请输入用户名：")
password = input("请输入密码：")
user = user_list.get(username)
if not user:
print("用户名不存在")
else:
if password == user:
print("登录成功")
else:
print("密码错误")
输出结果：
请输入用户名：meimei
请输入密码：123
密码错误②所有的键
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
data = info.keys()
print(data)
result = list(data)
print(result)
输出结果：
dict_keys(['age', 'status', 'name', 'email'])
['age', 'status', 'name', 'email']注意：在python2中，字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。
# 循环
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
for i in info.keys():
print(i)
输出结果：
age
status
name
email
# 是否存在
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
if "age" in info.keys():
print("age是字典的键")
else:
print("age不是字典的键")
输出结果：
age是字典的键③所有的值
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
data = info.values()
print((data))
输出结果：
dict_values([10, True, 'xiaomei', '××@live.com'])# 循环
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
for i in info.values():
print(i)
输出结果：
10
True
xiaomei
××@live.com
# 是否存在
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
if 12 in info.values():
print("12是字典的值")
else:
print("12不是字典的值")
输出结果：
12不是字典的值④所有的键值
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
data = info.items()
print(data)
输出结果：
dict_items([('age', 10), ('status', True), ('name', 'xiaomei'), ('email', '××@live.com')])# item 是一个元组(键，值)
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
for item in info.items():
print(item[0],item[1])
输出结果：
age 10
status True
name xiaomei
email ××@live.com# key代表键，value代表值，将键值从元组中直接拆分)
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
for key,value in info.items():
print(key,value)
输出结果：
age 10
status True
name xiaomei
email ××@live.com# key代表键，value代表值，将键值从元组中直接拆分)
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
data = info.items()
if ('age',10) in data:
print("在")
else:
print("不在")
输出结果：
在⑤设置值
data = {
"name" : "小美",
"email" : '***@mail.com'
}
data.setdefault("age",10)
print(data)
data.setdefault("name","小妹")
print(data)
输出结果：
{'name': '小美', 'email': '***@mail.com', 'age': 10}
{'name': '小美', 'email': '***@mail.com', 'age': 10}⑥更新字典键值对
data = {
"name" : "小美",
"email" : '***@mail.com'
}
data.update({"name":"小妹"})
print(data)
输出结果：
{'name': '小妹', 'email': '***@mail.com'}⑦移除指定键值对
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
data = info.pop("age")
print(info)
print(data)
输出结果：
{'status': True, 'name': 'xiaomei', 'email': '××@live.com'}
10⑧按照顺序移除（后进先出）
info = {"age":10,"status":True,"name":"xiaomei","email":"××@live.com"}
data = info.popitem()
print(info)
print(data)
输出结果：
{'age': 10, 'status': True, 'name': 'xiaomei'}
('email', '××@live.com')
- Python3.6之后，popitem移除最后的值
- Python3.6之前，popitem随机删除
#### 2.16.3 公共功能
1.求并集(Python3.9新加入)
v1 = {"k1":1,"k2":2}
v2 = {"k2":22,"k3":33}
v3 = v1 | v2
print(v3)
输出结果：
{'k1': 1, 'k2': 22, 'k3': 33}2.长度
info = {"age":12,"status":True,"name":"小妹"}
data = len(info)
print(data)
输出结果：
33.是否包含
info = {"age":12,"status":True,"name":"小妹"}
v1 = "age" in info
print(v1)
v2 = "age" in info.keys()
print(v2)
if "age" in info:
print("在")
else:
print("不在")
输出结果：
True
True
在4.索引(键)
字典不同于元组和列表，字典的索引是键，而列表和元组则是0、1、2等数值。
info = {"age":12,"status":True,"name":"小妹"}
print(info["age"])
print(info["name"])
print(info["status"])
# 报错，通过键为索引去获取索引之后时，键不存在会报错（项目开发时建议使用get方法根据键去获取值）
print(info["xxxx"])
value = info.get("xxxxx")
print(value)
输出结果：
12
小妹
True
Traceback (most recent call last):
File "E:\pythonProject\review_three.py", line 5, in <module>
print(info["xxxx"])
KeyError: 'xxxx'5.根据键修改值和删除键值对
info = {"age":12,"status":True,"name":"小妹"}
info["gender"] = "女"
info["class"] = "四年级一班"
# 删除info字典中键为age的那个键值对(键不存在则报错)
del info["age"]
print(info)
输出结果：
{'status': True, 'name': '小妹', 'gender': '女', 'class': '四年级一班'}6.for循环
由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值进行循环
#### 2.16.4 转换
#### 2.16.5 其他
#### 2.16.6 速度快
info = {
"meimei":["美美","小美"],
"学习技术":["linux","java"]
}
if "meimei" in info:
print("存在")
v1 = info["meimei"]
v2 = info.get("meimei")
print(v1)
print(v1)
输出结果：
存在
['美美', '小美']
['美美', '小美']#### 2.16.7 嵌套
在涉及多种数据类型之间的嵌套时，需注意：
- 字典的键必须可哈希(list/set/dict不可哈希)
# 错误：list--列表不可哈希 info = { (11,[11,22,],22):"meimei" } print(info)输出错误：
TypeError: unhashable type: 'list'# 正确格式
info = { (11,22):"meimei" } print(info) 输出结果： {(11, 22): 'meimei'}
- 字典的值可以使任意类型
info = { "k1":{12,3,5}, "k2":{"xx":"x1"} } print(info) 输出结果： {'k1': {3, 12, 5}, 'k2': {'xx': 'x1'}}
- 字典的键和集合的元素在遇到布尔值和1，0时，需注意重复的情况。
- 元组的元素不可以被替换
dic = { 'name':'汪峰', 'age':48, 'wife':[{'name':'国际章','age':38},{'name':'李杰','age':48}], 'children':['first child','two childs'] } # 获取汪峰妻子姓名 d1 = dic['wife'][0]['name'] print(d1) # 获取汪峰的孩子们 d2 = dic['children'] print(d2) # 获取汪峰的第一个孩子 d3 = dic['children'][0] print(d3) # 汪峰老婆的姓名修改为"章子怡" dic['wife'][0]['name'] = "章子怡" print(dic) # 妻子追加 dic['wife'].append({'name':'章女士','age':25}) print(dic) # 给汪峰追加爱好 dic['hobby'] = "sing songs" print(dic) # 删除汪峰年龄 del dic['age'] ## 或 dic.pop('age') print(dic) 输出结果： 国际章 ['first child', 'two childs'] first child {'name': '汪峰', 'age': 48, 'wife': [{'name': '章子怡', 'age': 38}, {'name': '李杰', 'age': 48}], 'children': ['first child', 'two childs']} {'name': '汪峰', 'age': 48, 'wife': [{'name': '章子怡', 'age': 38}, {'name': '李杰', 'age': 48}, {'name': '章女士', 'age': 25}], 'children': ['first child', 'two childs']} {'name': '汪峰', 'age': 48, 'wife': [{'name': '章子怡', 'age': 38}, {'name': '李杰', 'age': 48}, {'name': '章女士', 'age': 25}], 'children': ['first child', 'two childs'], 'hobby': 'sing songs'} {'name': '汪峰', 'wife': [{'name': '章子怡', 'age': 38}, {'name': '李杰', 'age': 48}, {'name': '章女士', 'age': 25}], 'children': ['first child', 'two childs'], 'hobby': 'sing songs'}
#### 2.16.8 字典内置方法
| 序号 | 函数及描述 |
| 1 | dict.clear() 删除字典内所有元素 |
| 2 | dict.copy() 返回一个字典的浅复制 |
| 3 | dict.fromkeys()创建一个字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | dict.get(key,default=None) 返回指定键的值，如果键不在字典中，返回default设置的默认值 |
| 5 | key in dict 如果键在字典dict里返回true，否则返回false |
| 6 | dict.keys() 返回一个视图对象 |
| 7 | dict.items() 以列表返回一个视图对象 |
| 8 | dict.setdefault(key,default=None)和get()类似，但如果键不存在于字典中，将会添加键，并将值设为default |
| 9 | dict.update(dict2) 把字典dict2的键值对更新到dict里 |
| 10 | dict.values()返回一个视图对象 |
| 11 | [pop(key,default)] 删除字典key(键)所对应的值，返回被删除的值 |
| 12 | popitem()返回并删除字典中的最后一对键和值 |
#### 2.16.9 浮点型 ( float )
一般在开发中用于表示小数
v1 = 3.14
v2 = 9.89
关于浮点型：
- 在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉
v1 = 3.14 data = int(v1) print(data) 输出结果： 3
- 要保留小数点后n位
v1 = 3.1415926 result = round(v1,3) print(result) 输出结果： 3.142
- 浮点型的坑(所有语言中)
在项目中若遇到精确的小数计算：
#### 2.16.10 小结
- 集合：是无序、不重复、元素必须可哈希，可变的一个容器（子孙元素都必须是可哈希）
- 集合的查找速度比较快（底层是基于哈希进行存储）
- 集合可以具有“交并差”的功能
- 字典：是无序、键不重复且元素只能是键值对的可变的一个容器（键子孙元素都必须是可哈希）
- python3.6之后，字典变为有序
- python3.9新增了{ } | { }运算
- 字典的常见功能
- 在python2,3中，字典的keys()、values()、items()三个功能获取的数据类型不一样
- None是代表内存中的一个空值
- 浮点型用于表示小数，但是由于其内部存储原理可能会引发数据存储不够精准
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
