一.python的两种运行方式
1.交互式:运行在终端
2.脚本式:eg:运行在pycharm解释器
二.python的进制与编码
1.进制
注意:计算机中底层所有的数据都是以 `010101`的形式存在(图片、文本、视频等)
v1 = bin(25) # 十进制转换为二进制
print(v1) # "0b11001"
v2 = oct(23) # 十进制转换为八进制
print(v2) # "0o27"
v3 = hex(28) # 十进制转换为十六进制
print(v3) # "0x1c"
```python
i1 = int("0b11001",base=2) # 25
i2 = int("0o27",base=8) # 23
i3 = int("0x1c",base=16) # 28
```
2.计算机中的单位
由于计算机中本质上所有的东西以为二进制存储和操作的,为了方便对于二进制值大小的表示,所以就搞了一些单位。
b(bit),位 | ``` 1,1位 10,2位 111,3位 1001,4位 ``` |
B(byte),字节 | ``` 8位是一个字节。 10010110,1个字节 10010110 10010110,2个字节 ``` |
-KB(kilobyte),千字节 | ``` 1024个字节就是1个千字节。 10010110 11010110 10010111 .. ,1KB 1KB = 1024B= 1024 * 8 b ``` |
M(Megabyte),兆 | ``` 1024KB就是1M 1M= 1024KB = 1024 * 1024 B = 1024 * 1024 * 8 b ``` |
G(Gigabyte),千兆 | ``` 1024M就是1G 1 G= 1024 M= 1024 *1024KB = 1024 * 1024 * 1024 B = 1024 * 1024 * 1024 * 8 b ``` |
- T(Terabyte),万亿字节,1024个G就是1T```
- ...其他更大单位 PB/EB/ZB/YB/BB/NB/DB 不再赘述。
3.编码
编码:文字和二进制之间的一个对照表。
①ascii编码
ascii规定使用1个字节来表示字母与二进制的对应关系。
②gb-2312编码
gb-2312编码,由国家信息标准委员会制作(1980年)。
gbk编码,对gb2312进行扩展,包含了中日韩等文字(1995年)。
在与二进制做对应关系时,由如下逻辑:
- 单字节表示,用一个字节表示对应关系。2**8 = 256
- 双字节表示,用两个字节表示对应关系。2**16 = 65536种可能性。
③ unicode
unicode也被称为万国码,为全球的每个文字都分配了一个码位(二进制表示)。
ucs2和ucs4指的是使用多少个字节来表示unicode字符集的码位
- ucs2
```
用固定的2个字节去表示一个文字。
00000000 00000000 悟
...
2**16 = 65535
```
- ucs4
```
用固定的4个字节去表示一个文字。
00000000 00000000 00000000 00000000 无
...
2**32 = 4294967296
```
```
文字 十六进制 二进制
ȧ 0227 1000100111
ȧ 0227 00000010 00100111 ucs2
ȧ 0227 00000000 00000000 00000010 00100111 ucs4
乔 4E54 100111001010100
乔 4E54 01001110 01010100 ucs2
乔 4E54 00000000 00000000 01001110 01010100 ucs4
😆 1F606 11111011000000110
😆 1F606 00000000 00000001 11110110 00000110 ucs4
```
无论是ucs2和ucs4都有缺点:浪费空间
```python
文字 十六进制 二进制
A 0041 01000001
A 0041 00000000 01000001
A 0041 00000000 00000000 00000000 01000001
```
unicode的应用:在文件存储和网络传输时,不会直接使用unicode,而在内存中会unicode。
④ utf-8编码
包含所有文字和二进制的对应关系,全球应用最为广泛的一种编码(站在巨人的肩膀上功成名就)。
本质上:utf-8是对unicode的压缩,用尽量少的二进制去与文字进行对应。
```
unicode码位范围 utf-8
0000 ~ 007F 用1个字节表示
0080 ~ 07FF 用2个字节表示
0800 ~ FFFF 用3个字节表示
10000 ~ 10FFFF 用4个字节表示
```
具体压缩的流程:
- 第一步:选择转换模板
```
码位范围(十六进制) 转换模板
0000 ~ 007F 0XXXXXXX
0080 ~ 07FF 110XXXXX 10XXXXXX
0800 ~ FFFF 1110XXXX 10XXXXXX 10XXXXXX
10000 ~ 10FFFF 11110XXX 10XXXXXX 10XXXXXX 10XXXXXX
例如:
"B" 对应的unicode码位为 0042,那么他应该选择的一个模板。
"ǣ" 对应的unicode码位为 01E3,则应该选择第二个模板。
"武" 对应的unicode码位为 6B66,则应该选择第三个模板。
"沛" 对应的unicode码位为 6C9B,则应该选择第三个模板。
"齐" 对应的unicode码位为 9F50,则应该选择第三个模板。
😆 对应的unicode码位为 1F606,则应该选择第四个模板。
注意:一般中文都使用第三个模板(3个字节),这也就是平时大家说中文在utf-8中会占3个字节的原因了。
```
- 第二步:在模板中填入数据
```
- "武" -> 6B66 -> 110 101101 100110
- 根据模板去套入数据
1110XXXX 10XXXXXX 10XXXXXX
1110XXXX 10XXXXXX 10100110
1110XXXX 10101101 10100110
11100110 10101101 10100110
在UTF-8编码中 ”武“ 11100110 10101101 10100110
- 😆 -> 1F606 -> 11111 011000 000110
- 根据模板去套入数据
11110000 10011111 10011000 10000110
```
⑤Python相关的编码
```
字符串(str) "alex媳妇叫铁锤" unicode处理 一般在内存
字节(byte) b"alexfdsfdsdfskdfsd" utf-8编码 or gbk编码 一般用于文件或网络处理
汉字,用gbk编码需要用2个字节;用utf-8编码需要用3个字节。
```
```python
v1 = "武"
v2 = "武".encode("utf-8")
v2 = "武".encode("gbk")
```
三.数据类型(上)
1.整型
1.1 定义
整型其实就是十进制整数的统称,比如:1、68、999都属于整型。他一般用于表示 年龄、序号等。
1.2 独有功能:无
```python
v1 = 5
print(bin(v1)) # 0b101
# 调用v1(int)的独有功能,获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1) # 3
v2 = 10
print(bin(10)) # 0b1010
# 调用v2(int)的独有功能,获取v2的二进制有多少个位组成。
result2 = v2.bit_length()
print(result2) # 4
```
1.3 公共功能
加减乘除
地板除
- Py3:
```python
v1 = 9/2
print(v1) # 4.5
```
- py2:
```python
v1 = 9/2
print(v1) # 4
```
```python
from __future__ import division
v1 = 9/2
print(v1) # 4.5
```
```python
v1 = 4
v2 = 8
v3 = v1 + v2
```
1.4 转换
在项目开发和面试题中经常会出现一些 "字符串" 和 布尔值 转换为 整型的情况。
```python
# 布尔值转整型
n1 = int(True) # True转换为整数 1
n2 = int(False) # False转换为整数 0
# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值,然后再转换为 十进制整数,结果:v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值,然后再转换为 十进制整数,结果:v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8) # 把字符串看成八进制的值,然后转换为 十进制整数,结果:v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16) # 把字符串看成十六进制的值,然后转换为 十进制整数,结果:v1 = 89 (0x表示十六进制)
# 浮点型(小数)
v1 = int(8.7) # 8
```
所以,如果以后别人给你一个按 二进制、八进制、十进制、十六进制 规则存储的字符串时,可以轻松的通过int转换为十进制的整数。
2. 布尔类型
2.1 定义
布尔值,其实就是 “真”、“假” 。
```python
data = False
alex_is_sb = True
```
2.2 独有功能
无
2.3 公共功能
无
```python
v1 = True + True
print(v1) # 2
```
2.4 转换
在以后的项目开发中,会经常使用其他类型转换为布尔值的情景,此处只要记住一个规律即可。
```
整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False
其他均为True
```
```python
# 练习题:查看一些变量为True还是False
v1 = bool(0)
v2 = bool(-10)
v3 = bool(10)
v4 = bool("武沛齐")
v5 = bool("")
v6 = bool(" ")
v7 = bool([]) # [] 表示空列表
v8 = bool([11,22,33]) # [11,22,33] 表示非空列表
v9 = bool({}) # {} 表示空字典
v10 = bool({"name":"武沛齐","age":18}) # {"name":"武沛齐","age":18} 表示非空字典
```
2.5 做条件自动转换
如果在 `if` 、`while` 条件后面写一个值当做条件时,他会默认转换为布尔类型,然后再做条件判断。
3.字符串类型
3.1 定义
字符串,我们平时会用他来表示文本信息。例如:姓名、地址、自我介绍等。
"""
# 三个引号,可以支持多行/换行表示一个字符串,其他的都只能在一行中表示一个字符串。
```
3.2 独有功能
1. 判断字符串是否以 XX 开头?得到一个布尔值
```python
v1 = "叨逼叨的一天,烦死了"
# True
result = v1.startswith("叨逼叨的一天")
print(result) # 值为True
```
```python
# 案例
v1 = input("请输入住址:")
if v1.startswith("北京市"):
print("北京人口")
else:
print("非北京人口")
```
2. 判断字符串是否以 XX 结尾?得到一个布尔值
```python
v1 = "叨逼叨的一天,烦死了"
result = v1.endswith("烦死了")
print(result) # 值为True
```
```python
# 案例
address = input("请输入地址:")
if address.endswith('村'):
print("农业户口")
else:
print("非农户口")
```
3. 判断字符串是否为十进制数?得到一个布尔值
```python
v1 = "1238871"
result = v1.isdecimal()
print(result) # True
```
```python
# 案例,两个数相加。
v1 = input("请输入值:") # ”666“
v2 = input("请输入值:") # ”999“
if v1.isdecimal() and v2.isdecimal():
data = int(v1) + int(v2)
print(data)
else:
print("请正确输入数字")
```
```python
v1 = "123"
print(v1.isdecimal()) # True
v2 = "①"
print(v2.isdecimal()) # False
v3 = "123"
print(v3.isdigit()) # True
v4 = "①"
print(v4.isdigit()) # True
```
4. 去除字符串两边的 空格、换行符、制表符,得到一个新字符串
```python
data = input("请输入内容:") #武沛齐,武沛齐
print(data)
```
```python
msg = " H e ll o啊,树哥 "
data = msg.strip()
print(data) # 将msg两边的空白去掉,得到"H e ll o啊,树哥"
```
```python
msg = " H e ll o啊,树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉,得到"H e ll o啊,树哥 "
```
```python
msg = " H e ll o啊,树哥 "
data = msg.rstrip()
print(data) # 将msg两边的空白去掉,得到" H e ll o啊,树哥"
```
补充:去除 空格、换行符、制表符。
```python
# 案例
code = input("请输入4位验证码:") # FB87
data = code.strip()
if data == "FB87":
print('验证码正确')
else:
print("验证码错误")
```
再补充:去除字符串两边指定的内容
```python
msg = "哥H e ll o啊,树哥"
data = msg.strip("哥")
print(data) #去前,后面的“哥”, 得到"H e ll o啊,树"
```
```python
msg = "哥H e ll o啊,树哥"
data = msg.lstrip("哥")
print(data) # 去前面的“哥”,得到"H e ll o啊,树哥"
```
```python
msg = "哥H e ll o啊,树哥"
data = msg.rstrip("哥")
print(data) # 去后面的“哥”,得到"哥H e ll o啊,树"
```
5. 字符串变大写,得到一个新字符串
```python
msg = "my name is oliver queen"
data = msg.upper()
print(msg) # my name is oliver queen
print(data) # 输出为:MY NAME IS OLIVER QUEEN
```
```python
# 案例
code = input("请输入4位验证码:") # FB88 或者 fb88
value = code.upper() # FB88
data = value.strip() # FB88
if data == "FB87":
print('验证码正确')
else:
print("验证码错误")
6. 字符串变小写,得到一个新字符串
```python
msg = "My Name Is Oliver Queen"
data = msg.lower()
print(data) # 输出为:my name is oliver queen
```
```python
# 案例
code = input("请输入4位验证码:")
value = code.strip().lower()
if value == "fb87":
print('验证码正确')
else:
print("验证码错误")
```
7. 字符串内容替换,得到一个新的字符串
```python eg1
data = "你是个好人,但是好人不合适我"
value = data.replace("好人","贱人")
print(data) # "你是个好人,但是好人不合适我"
print(value) # "你是个贱人,但是贱人不合适我"
```
```python eg2
# 案例
video_file_name = "高清无码爱情动作片.mp4"
new_file_name = video_file_name.replace("mp4","avi") # "高清无码爱情动作片.avi"
final_file_name = video_file_name.replace("无码","步兵") # "高清步兵爱情动作片.mp4"
print(final_file_name)
```
8. 字符串切割,得到一个列表
```python
data = "武沛齐|root|wupeiqi@qq.com"
result = data.split('|') # ["武沛齐","root","wupeiqi@qq.com"]
print(data) # "武沛齐|root|wupeiqi@qq.com"
print(result) # 输出 ["武沛齐","root","wupeiqi@qq.com"] 根据特定字符切开之后保存在列表中,方便以后的操作
```
```python
# 案例:判断用户名密码是否正确
info = "武沛齐,root" # 备注:字符串中存储了用户名和密码
user_list = info.split(',') # 得到一个包含了2个元素的列表 [ "武沛齐" , "root" ]
# user_list[0]
# user_list[1]
user = input("请输入用户名:")
pwd = input("请输入密码:")
if user == user_list[0] and pwd == user_list[1]:
print("登录成功")
else:
print("用户名或密码错误")
```
再扩展
```python
data = "武沛齐,root,wupeiqi@qq.com"
v1 = data.rsplit(',')
print(v1) # ['武沛齐', 'root', 'wupeiqi@qq.com']
v2 = data.rsplit(',',1)
print(v2) # ['武沛齐,root', 'wupeiqi@qq.com']
```
应用场景:
```python
file_path = "xxx/xxxx/xx.xx/xxx.mp4"
data_list = file_path.rsplit(".",1) # ["xxx/xxxx/xx.xx/xxx","mp4"]
data_list[0]
data_list[1]
```
9. 字符串拼接,得到一个新的字符串
```python
data_list = ["alex","是","大烧饼"]
v1 = "_".join(data_list) # alex_是_大烧饼
print(v1)
```
10. 格式化字符串,得到新的字符串
```python
name = "{0}的喜欢干很多行业,例如有:{1}、{2} 等"
data = name.format("老王","护士","嫩模")
print(data) # 老王的喜欢干很多行业,例如有:护士、嫩模 等
print(name) # "{0}的喜欢干很多行业,例如有:{1}、{2} 等"
```
```python
name = "{name}的喜欢干很多行业,例如有:{h1}、{h2} 等"
data = name.format(name="老王",h1="护士",h2="嫩模")
print(data) # 老王的喜欢干很多行业,例如有:护士、嫩模 等
```
11. 字符串转换为字节类型
```python
data = "嫂子" # unicode,字符串类型
v1 = data.encode("utf-8") # utf-8,字节类型
v2 = data.encode("gbk") # gbk,字节类型
print(v1) # b'\xe5\xab\x82 \xe5\xad\x90'
print(v2) # b'\xc9\xa9 \xd7\xd3'
s1 = v1.decode("utf-8") # 嫂子
s2 = v2.decode("gbk") # 嫂子
print(s1)
print(s2)
```
12. 将字符串内容居中、居左、居右展示
```python
v1 = "王老汉"
# data = v1.center(21, "-")
# print(data) #---------王老汉---------
# data = v1.ljust(21, "-")
# print(data) # 王老汉------------------
# data = v1.rjust(21, "-")
# print(data) # ------------------王老汉
```
13. 帮助填充:0
```python
data = "alex"
v1 = data.zfill(10)
print(v1) # 000000alex
```
```python
# 应用场景:处理二进制数据
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"
```
3.3 公共功能
1. 相加:字符串 + 字符串
```python
v1 = "alex" + "大sb"
print(v1)
```
2. 相乘:字符串 * 整数
```python
data = "嫂子" * 3
print(data) # 嫂子嫂子嫂子
```
3. 长度
```python
data = "嫂子满身大汉"
value = len(data)
print(value) # 6
```
4. 获取字符串中的字符,索引
```python
message = "来做点py交易呀"
# 0 1 2345 6 7
# ... -3 -2 -1
print(message[0]) # "来"
print(message[1]) # "做"
print(message[2]) # "点"
print(message[-1]) # 呀
print(message[-2]) # 呀
print(message[-3]) # 呀
```
注意:字符串中是能通过索引取值,无法修改值。【字符串在内部存储时不允许对内部元素修改,想修改只能重新创建。】
```python
message = "来做点py交易呀"
index = 0
while index < len(message):
value = message[index]
print(value)
index += 1
```
```python
message = "来做点py交易呀"
index = len(message) - 1
while index >=0:
value = message[index]
print(value)
index -= 1
```
5. 获取字符串中的子序列,切片
```python
message = "来做点py交易呀"
print(message[0:2]) # "来做"
print(message[3:7]) # "py交易"
print( message[3:] ) # "py交易呀"
print( message[:5] ) # "来做点py"
print(message[4:-1]) # "y交易"
print(message[4:-2]) # "y交"
print( message[4:len(message)] ) # "y交易呀"
```
注意:字符串中的切片只能读取数据,无法修改数据。【字符串在内部存储时不允许对内部元素修改,想要修改只能重新创建】
```python
message = "来做点py交易呀"
value = message[:3] + "Python" + message[5:]
print(value)
```
6. 步长,跳着去字符串的内容
```python
name = "生活不是电影,生活比电影苦"
print( name[ 0:5:2 ] ) # 输出:生不电 【前两个值表示区间范围,最后一个值(此处为2)表示步长,步长为2==第2个值】
print( name[ :8:2 ] ) # 输出:生不电, 【区间范围的前面不写则表示起始范围为0开始】、
# print( name[ 2::2 ] ) # 输出:不电,活电苦
# print( name[ 2::3 ] ) # 输出:不影活影
print( name[ 2::3 ] ) # 输出:不电,活电苦 【区间范围的后面不写则表示结束范围为最后】
print( name[ ::2 ] ) # 输出:生不电,活电苦 【区间范围不写表示整个字符串】
print( name[ 8:1:-1 ] ) # 输出:活生,影电是不 【倒序】
```
```python
name = "生活不是电影,生活比电影苦"
print(name[8:1:-1]) # 输出:活生,影电是不 【倒序】
print(name[-1:1:-1]) # 输出:苦影电比活生,影电是不 【倒序】
# 面试题:给你一个字符串,请将这个字符串翻转。
value = name[-1::-1]
print(value) # 苦影电比活生,影电是不活生
```
7. 循环
- while循环
```python
message = "来做点py交易呀"
index = 0
while index < len(message):
value = message[index]
print(value)
index += 1
```
- for循环
```python
message = "来做点py交易呀"
for char in message:
print(char)
```
- range,帮助我们创建一系列的数字
```python
range(10) # [0,1,2,3,4,5,6,7,8,9]
range(1,10) # [1,2,3,4,5,6,7,8,9]
range(1,10,2) # [1,3,5,7,9]
range(10,1,-1) # [10,9,8,7,6,5,4,3,2]
```
- For + range
```python
for i in range(10):
print(i)
```
```python
message = "来做点py交易呀"
for i in range(5): # [0,1,2,3,4]
print(message[i])
```
```python
message = "来做点py交易呀"
for i in range( len(message) ): # [0,1,2,3,4,5,6,7]
print(message[i])
```
一般应用场景:
- while,一般在做无限制(未知)循环此处时使用。
# 用户输入一个值,如果不是整数则一直输入,直到是整数了才结束。
num = 0
while True:
data = input("请输入内容:")
if data.isdecimal():
num = int(data)
break
else:
print("输入错误,请重新输入!")
```
- for循环,一般应用在已知的循环数量的场景。
```python
message = "来做点py交易呀"
for char in message:
print(char)
```
```python
for i in range(30):
print(message[i])
```
- break和continue关键字
```python
message = "来做点py交易呀"
for char in message:
if char == "p":
continue
print(char)
# 输出:
来
做
点
y
交
易
呀
```
```python
message = "来做点py交易呀"
for char in message:
if char == "p":
break
print(char)
# 输出:
来
做
点
```
```python
for i in range(5):
print(i)# 0 1 2 3 4
for j in range(3):
break
print(j) # 0 1 2 # 0 1 2 # 0 1 2 # 0 1 2 # 0 1 2
```
3.4 转换
```python
num = 999
data = str(num)
print(data) # "999"
```
```python
data_list = ["alex","eric",999]
data = str(data_list)
print(data) # '["alex","eric",999]'
```
一般情况下,只有整型转字符串才有意义。
3.5字符串不可被修改
```python
name = "武沛齐"
name[1]
name[1:2]
```
```python
num_list = [11,22,33]
num_list[0]
num_list[0] = 666
```
四.数据类型(下)
4.列表
1.1 定义
- list,列表类型,用于存储一些数据的容器(有序 & 可修改)
- tuple,元组类型,用于存储一些数据的容器(有序 & 不可修改) 1.列表(list)
列表(list),是一个**有序**且**可变**的容器,在里面可以存放**多个不同类型**的元素。
```python
user_list = ["苍老师","有坂深雪","大桥未久"]
number_list = [98,88,666,12,-1]
data_list = [1,True,"Alex","宝强","贾乃亮"]
```
```python
user_list = []
user_list.append("铁锤")
user_list.append(123)
user_list.append(True)
print(user_list) # ["铁锤",123,True]
```
不可变类型:字符串、布尔、整型(已最小,内部数据无法进行修改)
可变类型:列表(内部数据元素可以修改)
1.2 独有功能
在开始学习列表的独有功能之前,先来做一个字符串和列表的对比:
- 字符串,不可变,即:创建好之后内部就无法修改。【独有功能都是新创建一份数据】
```python
name = "alex"
data = name.upper()
print(name)
print(data)
```
- 列表,可变,即:创建好之后内部元素可以修改。【独有功能基本上都是直接操作列表内部,不会创建新的一份数据】
```python
user_list = ["车子","妹子"]
user_list.append("嫂子")
print(user_list) # ["车子","妹子","嫂子"]
```
列表中的常见独有功能如下:
1. 追加,在原列表中尾部追加值。
```python
data_list = []
v1 = input("请输入姓名")
data_list.append(v1)
v2 = input("请输入姓名")
data_list.append(v2)
print(data_list) # ["alex","eric"]
```
```python
# 案例1
user_list = []
while True:
user = input("请输入用户名(Q退出):")
if user == "Q":
break
user_list.append(user)
print(user_list)
```
```python
# 案例2
welcome = "欢迎使用NB游戏".center(30, '*')
print(welcome)
user_count = 0
while True:
count = input("请输入游戏人数:")
if count.isdecimal():
user_count = int(count)
break
else:
print("输入格式错误,人数必须是数字。")
message = "{}人参加游戏NB游戏。".format(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. 批量追加,将一个列表中的元素逐一添加另外一个列表。
```python
tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中
print(tools) # ["搬砖","菜刀","榔头",11,22,33]
```
```python
tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
#tools.extend(weapon) # weapon中的值逐一追加到tools中
#print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]
weapon.extend(tools)
print(tools) # ["搬砖","菜刀","榔头"]
print(weapon) # ["AK47","M6","搬砖","菜刀","榔头"]
```
```python
# 等价于(扩展)
weapon = ["AK47","M6"]
for item in weapon:
print(item)
# 输出:
# AK47
# M6
tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
for item in weapon:
tools.append(item)
print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]
```
3. 插入,在原列表的指定索引位置插入值
```python
user_list = ["苍老师","有坂深雪","大桥未久"]
user_list.insert(0,"马蓉")
user_list.insert(2,"李小璐")
print(user_list)
```
```python
# 案例
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)
```
4. 在原列表中根据值删除(从左到右找到第一个删除)【慎用,里面没有会报错】
```python
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.remove("Alex")
print(user_list)
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
user_list.remove("Alex")
print(user_list)
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
while True:
if "Alex" in user_list:
user_list.remove("Alex")
else:
break
print(user_list)
```
```python
# 案例:自动抽奖程序
import random
data_list = ["iphone12", "二手充气女友", "大保健一次", "泰国5日游", "避孕套"]
while data_list:
name = input("自动抽奖程序,请输入自己的姓名:")
# 随机从data_list抽取一个值出来
value = random.choice(data_list) # "二手充气女友"
print( "恭喜{},抽中{}.".format(name, value) )
data_list.remove(value) # "二手充气女友"
```
5. 在原列表中根据索引踢出某个元素(根据索引位置删除)
```python
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
# 0 1 2 3 4
user_list.pop(1)
print(user_list) # ["王宝强","Alex","贾乃亮","Alex"]
user_list.pop()
print(user_list) # ["王宝强","Alex","贾乃亮"]
item = user_list.pop(1)
print(item) # "Alex"
print(user_list) # ["王宝强","贾乃亮"]
```
```python
# 案例:排队买火车票
# ["alex","李杰","eric","武沛齐","老妖","肝胆"]
user_queue = []
while True:
name = input("北京~上海火车票,购买请输入姓名排队(Q退出):")
if name == "Q":
break
user_queue.append(name)
ticket_count = 3
for i in range(ticket_count):
username = user_queue.pop(0)
message = "恭喜{},购买火车票成功。".format(username)
print(message)
# user_queue = ["武沛齐","老妖","肝胆"]
faild_user = "、".join(user_queue) # "武沛齐、老妖、肝胆"
faild_message = "非常抱歉,票已售完,以下几位用户请选择其他出行方式,名单:{}。".format(faild_user)
print(faild_message)
```
6. 清空原列表
```python
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.clear()
print(user_list) # []
```
7. 根据值获取索引(从左到右找到第一个删除)【慎用,找不到报错】
```python
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
# 0 1 2 3 4
if "Alex" in user_list:
index = user_list.index("Alex")
print(index) # 2
else:
print("不存在")
```
8. 列表元素排序
```python
# 数字排序
num_list = [11, 22, 4, 5, 11, 99, 88]
print(num_list)
num_list.sort() # 让num_list从小到大排序
num_list.sort(reverse=True) # # 让num_list从大到小排序
print(num_list)
# 字符串排序
user_list = ["王宝强", "Ab陈羽凡", "Alex", "贾乃亮", "贾乃", "1"]
# [29579, 23453, 24378]
# [65, 98, 38472, 32701, 20961]
# [65, 108, 101, 120]
# [49]
print(user_list)
"""
sort的排序原理
[ "x x x" ," x x x x x " ]
"""
user_list.sort()
print(user_list)
```
注意:排序时内部元素无法进行比较时,程序会报错(尽量数据类型统一)。
9. 反转原列表
```python
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.reverse()
print(user_list)
```
1.3 公共功能
1. 相加,两个列表相加获取生成一个新的列表。
```python
data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
print(data) # ["赵四","刘能","宋晓峰","范德彪"]
v1 = ["赵四","刘能"]
v2 = ["宋晓峰","范德彪"]
v3 = v1 + v2
print(v3) # ["赵四","刘能","宋晓峰","范德彪"]
```
2. 相乘,列表*整型 将列表中的元素再创建N份并生成一个新的列表。
```python
data = ["赵四","刘能"] * 2
print(data) # ["赵四","刘能","赵四","刘能"]
v1 = ["赵四","刘能"]
v2 = v1 * 2
print(v1) # ["赵四","刘能"]
print(v2) # ["赵四","刘能","赵四","刘能"]
```
3. 运算符in包含
由于列表内部是由多个元素组成,可以通过in来判断元素是否在列表中。
```python
user_list = ["狗子","二蛋","沙雕","alex"]
result = "alex" in user_list
# result = "alex" not in user_list
print(result) # True
if "alex" in user_list:
print("在,把他删除")
user_list.remove("alex")
else:
print("不在")
```
```python
user_list = ["狗子","二蛋","沙雕","alex"]
if "alex" in user_list:
print("在,把他删除")
user_list.remove("alex")
else:
print("不在")
text = "打倒小日本"
data = "日" in text
```
```python
# 案例
user_list = ["狗子","二蛋","沙雕","alex"]
if "alex" in user_list:
print("在,把他删除")
user_list.remove("alex")
else:
print("不在")
```
```python
# 案例
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
index = user_list.index("Alex")
user_list.pop(index)
```
```python
# 案例:敏感词替换
text = input("请输入文本内容:") # 按时打发第三方科技爱普生豆腐啊;了深刻的房价破阿偶打飞机
forbidden_list = ["草","欧美","日韩"]
for item in forbidden_list:
text = text.replace(item,"**")
print(text)
```
注意:**列表检查元素是否存在时,是采用逐一比较的方式,效率会比较低。**
4. 获取长度
```python
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( len(user_list) )
```
5. 索引,一个元素的操作
```python
# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0] )
print( user_list[2] )
print( user_list[3] ) # 报错
```
```python
# 改
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
user_list[0] = "武沛齐"
print(user_list) # ["武沛齐","刘华强",'尼古拉斯赵四']
```
```python
# 删
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
del user_list[1]
user_list.remove("刘华强")
ele = user_list.pop(1)
```
注意:超出索引范围会报错。
提示:由于字符串是不可变类型,所以他只有索引读的功能,而列表可以进行 读、改、删
6. 切片,多个元素的操作(很少用)
```python
# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )
```
```python
# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']
```
```python
# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']
```
7. 步长
```python
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
# 0 1 2 3 4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )
```
```python
# 案例:实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)
data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)
# 给你一个字符串请实现字符串的翻转?
name = "武沛齐"
name[::-1]
```
8. for循环
```python
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
print(item)
```
```python
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for index in range( len(user_list) ):
item = user_index[index]
print(item)
```
切记,循环的过程中对数据进行删除会踩坑【面试题】。
```python
# 错误方式, 有坑,结果不是你想要的。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
if item.startswith("刘"):
user_list.remove(item)
print(user_list)
```
```python
# 正确方式,倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
item = user_list[index]
if item.startswith("刘"):
user_list.remove(item)
print(user_list)
```
1.4 转换
- int、bool无法转换成列表
```python
name = "武沛齐" #- str
data = list(name) # ["武","沛","齐"]
print(data)
```
```python
v1 = (11,22,33,44) # 元组
vv1 = list(v1) # 列表 [11,22,33,44]
v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]
```
1.5. 嵌套
列表属于容器,内部可以存放各种数据,所以他也支持列表的嵌套,如:
```python
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]
```
对于嵌套的值,可以根据之前学习的索引知识点来进行学习,例如:
```python
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]
print( data[0] ) # "谢广坤"
print( data[1] ) # ["海燕","赵本山"]
print( data[0][2] ) # "坤"
print( data[1][-1] ) # "赵本山"
data.append(666)
print(data) # [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝",666]
data[1].append("谢大脚")
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],"宋小宝",666 ]
del data[-2]
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],666 ]
data[-2][1] = "alex"
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,"alex",33,44],666 ]
data[1][0:2] = [999,666]
print(data) # [ "谢广坤",[999,666,"谢大脚"],True,[11,"alex",33,44],666 ]
```
```python
# 创建用户列表
# 用户列表应该长: [ ["alex","123"],["eric","666"] ]
# user_list = [["alex","123"],["eric","666"],]
# user_list.append(["alex","123"])
# user_list.append(["eric","666"])
user_list = []
while True:
user = input("请输入用户名:")
pwd = input("请输入密码:")
data = []
data.append(user)
data.append(pwd)
user_list.append(data)
```
```python
user_list = []
while True:
user = input("请输入用户名(Q退出):")
if user == "Q":
break
pwd = input("请输入密码:")
data = [user,pwd]
user_list.append(data)
print(user_list)
```
5.元组
列表(list),是一个**有序**且**可变**的容器,在里面可以存放**多个不同类型**的元素。
元组(tuple),是一个**有序**且**不可变**的容器,在里面可以存放**多个不同类型**的元素。
> 如何体现不可变呢?
> 记住一句话:《"我儿子永远不能换成是别人,但我儿子可以长大"》
1 定义
```python
v1 = (11,22,33)
v2 = ("李杰","Alex")
v3 = (True,123,"Alex",[11,22,33,44])
# 建议:议在元组的最后多加一个逗v3 = ("李杰","Alex",)
```
```python
d1 = (1) # 1
d2 = (1,) # (1,)
d3 = (1,2)
d4 = (1,2)
```
注意:建议在元组的最后多加一个逗号,用于标识他是一个元组。
```python
# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别?
2. 比较值 v1 = ( (1),(2),(3) ) 和 v2 = ( (1,) , (2,) , (3,),) 有什么区别?
(1,2,3)
```
2 独有功能
无
3 公共功能
1. 相加,两个列表相加获取生成一个新的列表。
```python
data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")
v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 + v2
print(v3) # ("赵四","刘能","宋晓峰","范德彪")
```
2. 相乘,列表*整型 将列表中的元素再创建N份并生成一个新的列表。
```python
data = ("赵四","刘能") * 2
print(data) # ("赵四","刘能","赵四","刘能")
v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")
```
3. 获取长度
```python
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( len(user_list) )
```
4. 索引
```python
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )
```
5. 切片
```python
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )
```
6. 步长
```python
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )
```
```python
# 字符串 & 元组。
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
data = user_list[::-1]
# 列表
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data = user_list[::-1]
user_list.reverse()
print(user_list)
```
7. for循环
```python
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
print(item)
```
```python
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
if item == '刘华强':
continue
print(name)
```
目前:只有 str、list、tuple 可以被for循环。 "xxx" [11,22,33] (111,22,33)
```python
# len + range + for + 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for index in range(len(user_list)):
item = user_list[index]
print(item)
```
4 转换
其他类型转换为元组,使用`tuple(其他类型)`,目前只有字符串和列表可以转换为元组。
```python
data = tuple(其他)
# str / list
```
```python
name = "武沛齐"
data = tuple(name)
print(data) # 输出 ("武","沛","齐")
```
```python
name = ["武沛齐",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("武沛齐",18,"pythonav")
```
5.嵌套
由于元组和列表都可以充当`容器`,他们内部可以放很多元素,并且也支持元素内的各种嵌套。
```python
tu = ( '今天姐姐不在家', '姐夫和小姨子在客厅聊天', ('姐夫问小姨子税后多少钱','小姨子低声说道说和姐夫还提钱') )
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]
print(tu1) # 今天姐姐不在家
print(tu2) # 姐夫和小姨子在客厅聊天
print(tu3) # 姐夫问小姨子税后多少钱
print(tu4) # 小姨子低声说道说和姐夫还提钱
```
练习题1:判断是否可以实现,如果可以请写代码实现。
```python
li = ["alex", [11,22,(88,99,100,),33], "WuSir", ("ritian", "barry",), "wenzhou"]
# 0 1 2 3 4
# 1.请将 "WuSir" 修改成 "武沛齐"
li[2] = "武沛齐"
index = li.index("Wusir")
li[index] = "武沛齐"
# 2.请将 ("ritian", "barry",) 修改为 ['日天','日地']
li[3] = ['日天','日地']
# 3.请将 88 修改为 87
li[1][2][0] = 87 # (报错,)
# 4.请将 "wenzhou" 删除,然后再在列表第0个索引位置插入 "周周"
# li.remove("wenzhou")
# del li[-1]
li.insert(0,"周周")
```
练习题2:记住一句话:《"我儿子永远不能换成是别人,但我儿子可以长大"》
```python
data = ("123",666,[11,22,33], ("alex","李杰",[999,666,(5,6,7)]) )
# 1.将 “123” 替换成 9 报错
# 2.将 [11,22,33] 换成 "武沛齐" 报错
# 3.将 11 换成 99
data[2][0] = 99
print(data) # ("123",666,[99,22,33], ("alex","李杰",[999,666,(5,6,7)]) )
# 4.在列表 [11,22,33] 追加一个44
data[2].append(44)
print(data) # ("123",666,[11,22,33,44], ("alex","李杰",[999,666,(5,6,7)]) )
```
练习题3:动态的创建用户并添加到用户列表中。
```python
# 创建用户 5个
# user_list = [] # 用户信息
user_list = [ ("alex","132"),("admin","123"),("eric","123") ]
while True:
user = input("请输入用户名:")
if user == "Q":
brek
pwd = input("请输入密码:")
item = (user,pwd,)
user_list.append(item)
# 实现:用户登录案例
print("登录程序")
username = input("请输入用户名:")
password = input("请输入密码:")
is_success = False
for item in user_list:
# item = ("alex","132") ("admin","123") ("eric","123")
if username == item[0] and password == item[1]:
is_success = True
break
if is_success:
print("登录成功")
else:
print("登录失败")
```
- set集合,一个不允许重复重复 & 可变类型(元素可哈希)。
- dict字典,一个容器且元素必须是键值对。
- float类型,我们生活中常见的小数。
6.集合(set)
集合是一个 无序 、可变、不允许数据重复的容器。
1.1 定义
```python
v1 = { 11, 22, 33, "alex" }
```
- 无序,无法通过索引取值。
- 可变,可以添加和删除元素。
```python
v1 = {11,22,33,44}
v1.add(55)
print(v1) # {11,22,33,44,55}
```
- 不允许数据重复。
```python
v1 = {11,22,33,44}
v1.add(22)
print(v1) # {11,22,33,44}
```
一般什么时候用集合呢?
> 就是想要维护一大堆不重复的数据时,就可以用它。比如:做爬虫去网上找图片的链接,为了避免链接重复,可以选择用集合去存储链接地址。
**注意**:定义空集合时,只能使用`v = set()`,不能使用 `v={}`(这样是定义一个空字典)。
```python
v1 = []
v11 = list()
v2 = ()
v22 = tuple()
v3 = set()
v4 = {} # 空字典
v44 = dict()
```
1.2 独有功能
1. 添加元素
```python
data = {"刘嘉玲", '关之琳', "王祖贤"}
data.add("郑裕玲")
print(data)
```
```python
data = set()
data.add("周杰伦")
data.add("林俊杰")
print(data)
```
2. 删除元素
```python
data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
data.discard("关之琳")
print(data)
```
3. 交集
```python
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.intersection(s2) # 取两个集合的交集
print(s4) # {"⽪⻓⼭"}
s3 = s1 & s2 # 取两个集合的交集
print(s3)
```
4. 并集
```python
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.union(s2) # 取两个集合的并集 {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
print(s4)
s3 = s1 | s2 # 取两个集合的并集
print(s3)
```
5. 差集
```python
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.difference(s2) # 差集,s1中有且s2中没有的值 {"刘能", "赵四"}
s6 = s2.difference(s1) # 差集,s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}
s3 = s1 - s2 # 差集,s1中有且s2中没有的值
s5 = s2 - s1 # 差集,s2中有且s1中没有的值
print(s5,s6)
```
1.3 公共功能
1. 减,计算差集
```python
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 - s2
s4 = s2 - s1
print(s3)
print(s4)
```
2. &,计算交集
```python
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 & s2
print(s3)
```
3. |,计算并集
```python
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 | s2
print(s3)
```
4. 长度
```python
v = {"刘能", "赵四", "尼古拉斯"}
data = len(v)
print(data)
```
5. for循环
```python
v = {"刘能", "赵四", "尼古拉斯"}
for item in v:
print(item)
```
1.4 转换
其他类型如果想要转换为集合类型,可以通过set进行转换,并且如果数据有重复自动剔除。
提示:int/list/tuple/dict都可以转换为集合。
```python
v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}
```
```python
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
```
```python
v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}
```
提示:这其实也是去重的一个手段。
```python
data = {11,22,33,3,99}
v1 = list(data) # [11,22,33,3,99]
v2 = tuple(data) # (11,22,33,3,99)
```
1.5 其他
#### 1.5.1 集合的存储原理
<img src="assets/image-20201120193837492.png" alt="image-20201120193837492" style="zoom:50%;" />
#### 1.5.2 元素必须可哈希
因存储原理,集合的元素必须是可哈希的值,即:内部通过通过哈希函数把值转换成一个数字。
<img src="assets/image-20201120190454120.png" alt="image-20201120190454120" style="zoom: 25%;" />
目前可哈希的数据类型:int、bool、str、tuple,而list、set是不可哈希的。
总结:集合的元素只能是 int、bool、str、tuple 。
- 转换成功
```python
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
```
- 转换失败
```python
v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错
print(v2)
```
#### 1.5.3 查找速度特别快
因存储原理特殊,集合的查找效率非常高(数据量大了才明显)。
- 低
```python
user_list = ["武沛齐","alex","李璐"]
if "alex" in user_list:
print("在")
else:
print("不在")
user_tuple = ("武沛齐","alex","李璐")
if "alex" in user_tuple:
print("在")
else:
print("不在")
```
- 效率高
```python
user_set = {"武沛齐","alex","李璐"}
if "alex" in user_set:
print("在")
else:
print("不在")
```
#### 1.5.4 对比和嵌套
| 类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
| ----- | -------- | -------- | -------- | ---------- | ----------- | ----------------- |
| list | 是 | 是 | 无 | 否 | list(其他) | `v=[]或v=list()` |
| tuple | 否 | 是 | 无 | 是 | tuple(其他) | `v=()或v=tuple()` |
| set | 是 | 否 | 可哈希 | 否 | set(其他) | `v=set()` |
```python
data_list = [
"alex",
11,
(11, 22, 33, {"alex", "eric"}, 22),
[11, 22, 33, 22],
{11, 22, (True, ["中国", "北京"], "沙河"), 33}
]
```
注意:由于True和False本质上存储的是 1 和 0 ,而集合又不允许重复,所以在整数 0、1和False、True出现在集合中会有如下现象:
```python
v1 = {True, 1}
print(v1) # {True}
v2 = {1, True}
print(v2) # {1}
v3 = {0, False}
print(v3) # {0}
v4 = {False, 0}
print(v4) # {False}
```
### 练习题
1. 写代码实现
```python
v1 = {'alex','武sir','肖大'}
v2 = []
# 循环提示用户输入,如果输入值在v1中存在,则追加到v2中,如果v1中不存在,则添加到v1中。(如果输入N或n则停止循环)
while True:
name = input("请输入姓名(N/n退出):")
if name.upper() == "Q":
break
if name in v1:
v2.append(name)
else:
v1.add(name)
```
2. 下面那些值不能做集合的元素
```python
""
0
[11,22,33] # 不能
[] # 不能
(123)
{1,2,3} # 不能
```
3. 模拟用户信息录入程序,已录入则不再创建。
```python
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)
```
4. 给你个列表去重。
```python
v = [11,22,11,22,44455]
data = set(v) # {11,22,44455}
result = list(data) # [11,22,44455]
```
## 强插:None类型
Python的数据类型中有一个特殊的值None,意味着这个值啥都不是 或 表示空。 相当于其他语言中 `null`作用一样。
在一定程度上可以帮助我们去节省内存。例如:
```python
v1 = None
v2 = None
..
v1 = [11,22,33,44]
v2 = [111,22,43]
```
```python
v3 = []
v4 = []
...
v3 = [11,22,33,44]
v4 = [111,22,43]
```
注意:暂不要考虑Python内部的缓存和驻留机制。
目前所有转换为布尔值为False的值有:
```python
0
""
[] or list()
() or tuple()
set()
None
```
```python
if None:
pass
```
## 2.字典(dict)
字典是 **无序**、**键不重复** 且 元素只能是**键值对**的**可变的** 个 **容器**。
```python
data = { "k1":1, "k2":2 }
```
- 容器
- 元素必须键值对
- 键不重复,重复则会被覆盖
```python
data = { "k1":1, "k1":2 }
print(data) # {"k1":2}
```
- 无序(在Python3.6+字典就是有序了,之前的字典都是无序。)
```python
data = { "k1":1, "k2":2 }
print(data)
```
### 2.1 定义
```python
v1 = {}
v2 = dict()
```
```python
data = {
"k1":1,
"k2":2
}
```
```python
info = {
"age":12,
"status":True,
"name":"wupeiqi",
"hobby":['篮球','足球']
}
```
字典中对键值得要求:
- 键:必须可哈希。 目前为止学到的可哈希的类型:int/bool/str/tuple;不可哈希的类型:list/set/dict。(集合)
- 值:任意类型。
```python
data_dict = {
"武沛齐":29,
True:5,
123:5,
(11,22,33):["alex","eric"]
}
```
```python
# 不合法
v1 = {
[1, 2, 3]: '周杰伦',
"age" : 18
}
v2 = {
{1,2,3}: "哈哈哈",
'name':"alex"
}
v3 = {
{"k1":123,"k2":456}: '呵呵呵',
"age":999
}
```
```python
data_dict = {
1: 29,
True: 5
}
print(data_dict) # {1: 5}
```
一般在什么情况下会用到字典呢?
当我们想要表示一组固定信息时,用字典可以更加的直观,例如:
```python
# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]
...
```
```python
# 用户列表
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]
```
### 2.2 独有功能
1. 获取值
```python
info = {
"age":12,
"status":True,
"name":"武沛齐",
"data":None
}
data1 = info.get("name")
print(data1) # 输出:武沛齐
data2 = info.get("age")
print(data2) # 输出:12
data = info.get("email") # 键不存在,默认返回 None
"""
if data == None:
print("此键不存在")
else:
print(data)
if data:
print(data)
else:
print("键不存在")
"""
"""
# 字典的键中是否存在 email
if "email" in info:
data = info.get("email")
print(data)
else:
print("不存在")
"""
data = info.get("hobby",123)
print(data) # 输出:123
```
```python
# 案例:
user_list = {
"wupeiqi": "123",
"alex": "uk87",
}
username = input("请输入用户名:")
password = input("请输入密码:")
# None,用户名不存在
# 密码,接下来比较密码
pwd = user_list.get(username)
if pwd == None:
print("用户名不存在")
else:
if password == pwd:
print("登录成功")
else:
print("密码错误")
```
```python
# 案例:
user_list = {
"wupeiqi": "123",
"alex": "uk87",
}
username = input("请输入用户名:")
password = input("请输入密码:")
# None,用户名不存在
# 密码,接下来比较密码
pwd = user_list.get(username)
if pwd:
if password == pwd:
print("登录成功")
else:
print("密码错误")
else:
print("用户名不存在")
```
```python
# 案例:
user_list = {
"wupeiqi": "123",
"alex": "uk87",
}
username = input("请输入用户名:")
password = input("请输入密码:")
# None,用户名不存在
# 密码,接下来比较密码
pwd = user_list.get(username)
if not pwd:
print("用户名不存在")
else:
if password == pwd:
print("登录成功")
else:
print("密码错误")
# 写代码的准则:简单的逻辑处理放在前面;复杂的逻辑放在后面。
```
2. 所有的键
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys()
print(data) # 输出:dict_keys(['age', 'status', 'name', 'email']) py2 -> ['age', 'status', 'name', 'email']
result = list(data)
print(result) # ['age', 'status', 'name', 'email']
```
注意:在Python2中 字典.keys()直接获取到的是列表,而Python3中返回的是`高仿列表`,这个高仿的列表可以被循环显示。
```python
# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
print(ele)
```
```python
# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
# info.keys() # dict_keys(['age', 'status', 'name', 'email'])
if "age" in info.keys():
print("age是字典的键")
else:
print("age不是")
```
3. 所有的值
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()
print(data) # 输出:dict_values([12, True, 'wupeiqi', 'xx@live.com'])
```
注意:在Python2中 字典.values()直接获取到的是列表,而Python3中返回的是高仿列表,这个高仿的列表可以被循环显示。
```python
# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for val in info.values():
print(val)
```
```python
# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
if 12 in info.values():
print("12是字典的值")
else:
print("12不是")
```
4. 所有的键值
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
print(data) # 输出 dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ])
```
```python
for item in info.items():
print(item[0],item[1]) # item是一个元组 (键,值)
```
```python
for key,value in info.items():
print(key,value) # key代表键,value代表值,将兼职从元组中直接拆分出来了。
```
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
if ('age', 12) in data:
print("在")
else:
print("不在")
```
5. 设置值
```python
data = {
"name": "武沛齐",
"email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data) # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}
data.setdefault("name", "alex")
print(data) # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}
```
6. 更新字典键值对
```python
info = {"age":12, "status":True}
info.update( {"age":14,"name":"武沛齐"} ) # info中没有的键直接添加;有的键则更新值
print(info) # 输出:{"age":14, "status":True,"name":"武沛齐"}
```
7. 移除指定键值对
```python
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.pop("age")
print(info) # {"status":True,"name":"武沛齐"}
print(data) # 12
```
8. 按照顺序移除(后进先出)
```python
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.popitem() # ("name","武沛齐" )
print(info) # {"age":12, "status":True}
print(data) # ("name","武沛齐")
```
- py3.6后,popitem移除最后的值。
- py3.6之前,popitem随机删除。
```python
# 练习题
"""
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息,格式如下:
SH601778,股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
SH688566,股票名称:吉贝尔、当前价:... 。
...
"""
header = ['股票名称', '当前价', '涨跌额']
stock_dict = {
'SH601778': ['中国晶科', '6.29', '+1.92'],
'SH688566': ['吉贝尔', '52.66', '+6.96'],
'SH688268': ['华特气体', '88.80', '+11.72'],
'SH600734': ['实达集团', '2.60', '+0.24']
}
```
### 2.3 公共功能
1. 求`并集`(Python3.9新加入)
```python
v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}
v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}
```
2. 长度
```python
info = {"age":12, "status":True,"name":"武沛齐"}
data = len(info)
print(data) # 输出:3
```
3. 是否包含
```python
info = { "age":12, "status":True,"name":"武沛齐" }
v1 = "age" in info
print(v1)
v2 = "age" in info.keys()
print(v2)
if "age" in info:
pass
else:
pass
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
v1 = "武佩奇" in info.values()
print(v1)
```
```python
info = {"age": 12, "status": True, "name": "武沛齐"}
# 输出info.items()获取到的 dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ])
v1 = ("age", 12) in info.items()
print(v1)
```
4. 索引(键)
字典不同于元组和列表,字典的索引是`键`,而列表和元组则是 `0、1、2等数值` 。
```python
info = { "age":12, "status":True, "name":"武沛齐"}
print( info["age"] ) # 输出:12
print( info["name"] ) # 输出:武沛齐
print( info["status"] ) # 输出:True
print( info["xxxx"] ) # 报错,通过键为索引去获取之后时,键不存在会报错(以后项目开发时建议使用get方法根据键去获取值)
value = info.get("xxxxx") # None
print(value)
```
5. 根据键 修改值 和 添加值 和 删除键值对
上述示例通过键可以找到字典中的值,通过键也可以对字典进行添加和更新操作
```python
info = {"age":12, "status":True,"name":"武沛齐"}
info["gender"] = "男"
print(info) # 输出: {"age":12, "status":True,"name":"武沛齐","gender":"男"}
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
info["age"] = "18"
print(info) # 输出: {"age":"18", "status":True,"name":"武沛齐"}
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
del info["age"] # 删除info字典中键为age的那个键值对(键不存在则报错)
print(info) # 输出: {"status":True,"name":"武沛齐"}
```
```python
info = {"age": 12, "status": True, "name": "武沛齐"}
if "agea" in info:
# del info["age"]
data = info.pop("age")
print(info)
print(data)
else:
print("键不存在")
```
6. for循环
由于字典也属于是容器,内部可以包含多个键值对,可以通过循环对其中的:键、值、键值进行循环;
```python
info = {"age":12, "status":True,"name":"武沛齐"}
for item in info:
print(item) # 所有键
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.key():
print(item)
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.values():
print(item)
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
for key,value in info.items():
print(key,value)
```
### 2.4 转换
想要转换为字典.
```python
v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )
print(v) # { "k1":"v1", "k2":"v2" }
```
```python
info = { "age":12, "status":True, "name":"武沛齐" }
v1 = list(info) # ["age","status","name"]
v2 = list(info.keys()) # ["age","status","name"]
v3 = list(info.values()) # [12,True,"武沛齐"]
v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]
```
### 1.5 其他
#### 1.5.1 存储原理
![image-20201121131221807](assets/image-20201121131221807.png)
#### 1.5.2 速度快
```python
info = {
"alex":["肝胆","铁锤"],
"老男孩":["二蛋","缺货"]
}
for "alex" in info:
print("在")
```
```python
info = {
"alex":["肝胆","铁锤"],
"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")
```
#### 1.5.3 嵌套
我们已学了很多数据类型,在涉及多种数据类型之间的嵌套时,需注意一下几点:
- 字典的键必须可哈希(list/set/dict不可哈希)。
```python
info = {
(11,22):123
}
# 错误
info = {
(11,[11,22,],22):"alex"
}
```
- 字典的值可以是任意类型。
```python
info = {
"k1":{12,3,5},
"k2":{"xx":"x1"}
}
```
- 字典的键和集合的元素在遇到 布尔值 和 1、0 时,需注意重复的情况。
- 元组的元素不可以被替换。
```python
dic = {
'name':'汪峰',
'age':48,
'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字
d1 = dic['wife'][0]['name']
print(d1)
2. 获取汪峰的孩子们
d2 = dic['children']
print(d2)
3. 获取汪峰的第一个孩子
d3 = dic['children'][0]
print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
dic['wife'][0]['name] = "章子怡"
print(dic)
5. 汪峰再娶一任妻子
dic['wife'].append( {"name":"铁锤","age":19} )
print(dic)
6. 给汪峰添加一个爱好:吹牛逼
dic['hobby'] = "吹牛逼"
print(dic)
7. 删除汪峰的年龄
del dic['age']
或
dic.pop('age')
print(dic)
"""
```
## 3.浮点型(float)
浮点型,一般在开发中用于表示小数。
```python
v1 = 3.14
v2 = 9.89
```
关于浮点型的其他知识点如下:
- 在类型转换时需要,在浮点型转换为整型时,会将小数部分去掉。
```python
v1 = 3.14
data = int(v1)
print(data) # 3
```
- 想要保留小数点后N位
```python
v1 = 3.1415926
result = round(v1,3)
print(result) # 3.142
```
- 浮点型的坑(所有语言中)
<img src="assets/image-20201121190846593.png" alt="image-20201121190846593" style="zoom: 33%;" />
底层原理视频:https://www.bilibili.com/video/BV1354y1B7o1/
在项目中如果遇到精确的小数计算应该怎么办?
```python
import decimal
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3
```
10. 浮点型用于表示小数,但是由于其内部存储原理可能会引发数据存储不够精准。
## 作业
1. 根据需求写代码
```python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# 请在字典中添加一个键值对,"k4": "v4",输出添加后的字典
# 请在修改字典中 "k1" 对应的值为 "alex",输出修改后的字典
# 请在k3对应的值中追加一个元素 44,输出修改后的字典
# 请在k3对应的值的第 1 个位置插入个元素 18,输出修改后的字典
```
2. 根据需求写代码
```python
dic1 = {
'name':['alex',2,3,5],
'job':'teacher',
'oldboy':{'alex':['python1','python2',100]}
}
# 1,将name对应的列表追加⼀个元素’wusir’。
# 2,将name对应的列表中的alex全变成大写。
# 3,oldboy对应的字典加⼀个键值对’⽼男孩’:’linux’。
# 4,将oldboy对应的字典中的alex对应的列表中的python2删除
```
3. 循环提示用户输入,并将输入内容添加到字典中(如果输入N或n则停止循环)
```python
例如:用户输入 x1|wupeiqi ,则需要再字典中添加键值对 {'x1':"wupeiqi"}
```
4. 判断以下值那个能做字典的key ?那个能做集合的元素?
- 1
- -1
- ""
- None
- [1,2]
- (1,)
- {11,22,33,4}
- {'name':'wupeiq','age':18}
5. 将字典的键和值分别追加到 key_list 和 value_list 两个列表中,如:
```python
key_list = []
value_list = []
info = {'k1':'v1','k2':'v2','k3':'v3'}
```
6. 字典dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
```python
a. 请循环输出所有的key
b. 请循环输出所有的value
c. 请循环输出所有的key和value
```
7. 请循环打印k2对应的值中的每个元素。
```python
info = {
'k1':'v1',
'k2':[('alex'),('wupeiqi'),('oldboy')],
}
```
8. 有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典 {'k':1,'k1':2....}
9. 写代码
```python
"""
有如下值 li= [11,22,33,44,55,66,77,88,99,90] ,将所有大于 66 的值保存至字典的第一个key对应的列表中,将小于 66 的值保存至第二个key对应的列表中。
result = {'k1':[],'k2':[]}
"""
```
11. 输出商品列表,用户输入序号,显示用户选中的商品
```python
"""
商品列表:
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998}
]
要求:
1:页面显示 序号 + 商品名称 + 商品价格,如:
1 电脑 1999
2 鼠标 10
...
2:用户输入选择的商品序号,然后打印商品名称及商品价格
3:如果用户输入的商品序号有误,则提示输入有误,并重新输入。
4:用户输入Q或者q,退出程序。
"""
```