万物皆有裂痕,那是光照进来的地方--(存在即是定数!)
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 | orange
2. 使用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))
输出结果:
True
isinstance和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))
输出结果:
3
4.切片
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)
输出结果:
3
3.是否包含
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是代表内存中的一个空值
- 浮点型用于表示小数,但是由于其内部存储原理可能会引发数据存储不够精准