Python基础

一只逃逸的云

已于 2024-05-18 10:26:13 修改

阅读量963

点赞数 42

文章标签： python

于 2024-05-11 20:23:27 首次发布

本文链接：https://blog.csdn.net/I_am_so_soSorry/article/details/138587840

版权

一.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)

# 输出：

来

做

点

交

易

呀

```

```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 集合的存储原理

#### 1.5.2 元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。

目前可哈希的数据类型：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

[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

[] 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

```

- 浮点型的坑（所有语言中）

底层原理视频：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，退出程序。

"""

```

一只逃逸的云

关注

42
点赞
踩
27

收藏

觉得还不错? 一键收藏
2
评论
Python基础

``pythonv1 = 5# 调用v1（int）的独有功能，获取v1的二进制有多少个位组成。v2 = 10# 调用v2（int）的独有功能，获取v2的二进制有多少个位组成。```布尔值，其实就是 “真”、“假”。```python```字符串，我们平时会用他来表示文本信息。例如：姓名、地址、自我介绍等。"""# 三个引号，可以支持多行/换行表示一个字符串，其他的都只能在一行中表示一个字符串。```- list，列表类型，用于存储一些数据的容器（有序 & 可修改）
复制链接

扫一扫