【Python】标准数据类型

最新推荐文章于 2023-01-14 00:43:04 发布

Charon_cc

最新推荐文章于 2023-01-14 00:43:04 发布

阅读量681

点赞数 2

分类专栏： python学习笔记文章标签： python 列表字典字符串集合

本文链接：https://blog.csdn.net/qq_45978890/article/details/114000758

版权

python学习笔记专栏收录该内容

7 篇文章 2 订阅

订阅专栏

【Python】标准数据类型

在Python中，每个变量在使用的时候必须进行赋值，赋值之后该变量会自动被创建，并且在Python中，所有的变量都没有类型，变量单纯只是变量而已，我们所说的类型只是这个变量在内存中指向的对象的类型，在Python中，所有的数据类型都是对象

文章目录

【Python】标准数据类型

1. 六种数据类型

Number（数字）
String (字符串)
List（列表）
Tuple（元组）
Set（集合）
Dictionary （字典）

不可变数据：数字，字符串，元组

可变数组：列表，字典，集合

2. 数字

在python中，数字是不允许更改的，如果数字的值被更改了，那么就会重新分配这个数字的内存空间

a = 100
print(id(a))#id函数为获取这个数字所在的内存空间
a += 100
print(id(a))

output
140708766059888 140708766063088

数字在的内存空间的编号改变了。

2.1 整型数字

整型数字就是正整数和负整数，在对一个数字的引用对象赋值的时候，没有小数点的就是整型，在python中，整数没有大小的限制

整数可以强制转换成浮点型数字
```
a = 10
print(type(a))
a = float(a)
print(type(a))
```
output
<class ‘int’>
<class ‘float’>

output
<class ‘int’> <class ‘float’>

2.2 浮点型数字

浮点型数字由整型部分和小数部分组成

浮点型数字也可以强制转换成整型数字
```
b = 10.2
print(type(b))
b = int(b)
print('b = %d'%(b))
print(type(b))
```
output
<class ‘float’>
b = 10
<class ‘int’>

output
<class ‘float’> b = 10 <class ‘int’>

2.3 复数

复数有实部和虚部，可以用 a + bj来表示，其中 a 和 b 是数字表达式，或者可以用complex(a,b)来表示一个复数

我们可以将一个整型或者浮点型转换成复数
不可以将复数转换成一个整型或者浮点型

在数学上面，复数集和实数集韦恩图如下：
在这里插入图片描述

复数集包含实数集

将数字转化为复数

可以使用复数对象自带的函数来获取复数的实部和虚部

假设 j是一个复数，那么：

获取实部：j.real

获取虚部：j.imag
a = 10
j = complex(a)
# 表示了一个实数，实部为 a 虚部为 0 即 
print("复数的实部为: %.1f, 负数的虚部为： %.1f"%(j.real, j.imag))
output
复数的实部为: 10.0, 负数的虚部为： 0.0
a = 10
b = 20
j = complex(a, b)
print("复数的实部为：%.1f, 复数的虚部为： %.1f"%(j.real, j.imag))
output
复数的实部为：10.0, 复数的虚部为： 20.0

output
复数的实部为: 10.0, 负数的虚部为： 0.0

output
复数的实部为：10.0, 复数的虚部为： 20.0

2.4 数字运算

* 和 **

一个单独的 * 是乘法运算，两个 **是幂运算

a = 10
b = 2
print("a * b = %d"%(a * b))#乘法运算 10 * 2
print("a ** b = %d"%(a ** b))#幂运算 10 ^ 2

输出
a * b = 20 a ** b = 100

/ 和 //

一个单独的 /是除运算，//是取整数运算
```
a = 10
b = 3
print("a / b = %.6f"%(a / b))
print("a // b = %.6f"%(a // b))
```
输出
a / b = 3.333333
a // b = 3.000000
%运算
%为取余运算

输出
a / b = 3.333333 a // b = 3.000000

a = 10
b = 3
print("a %% 3 = %d"%(a % 3))
#格式化输出%号使用%%
#格式化字符串的时候会解析 %
#所以 %比较特殊，不能通过添加 转义字符来输出 %

输出
a % b = 1

关于取余取整的问题的简单案例

//为取整

%为取余

当你一个人和三队情侣站在一起的时候，//运算符可以把三队情侣分出来(7个人 // 2 = 3（三队情侣）)，%就可以把你这个单身狗抓出来了(7个人 % 2 = 1(你))

2.5 常用的数学函数

以下是所有函数的简介:
在这里插入图片描述

常量pi，定义于math模块中，需要导入之后使用

from math import pi
print(pi)

输出
3.141592653589793

第二种导入方法

import math
print(math.pi)

输出
3.141592653589793

2.5.1 abs()与fabs()

两个函数都可以返回一个数字的x的绝对值，但是两个函数之间有区别

定义的位置：abs()为内置函数，fabs定义于math模块
abs()几乎万能，fabs()不能对复数取绝对值，abs()对复数取绝对值可以得到复数的模，设复数的模为 m,复数的实部为 a, 虚部为 b, m² = a² + b²

测试代码
from math import fabs
#如果要写成import math的话
#fabs()需要写成 math.fabs()
a = -10
b = -10.1
c = complex(3, 4)
print('abs(a) = ',abs(a))
print('abs(b) = ',abs(b))
print('fabs(a) = ',fabs(a))
print('fabs(b) = ',fabs(b))
print('abs(c) = ',abs(c))
#print(fabs(c))报错
输出
abs(a) = 10
abs(b) = 10.1
fabs(a) = 10.0
fabs(b) = 10.1
abs(c）= 5.0

从输出结果上面来看，abs()送进去什么类型的数字返回值就是什么类型，而fabs()送进去什么类型的数字，返回值都是浮点型

输出
abs(a) = 10 abs(b) = 10.1 fabs(a) = 10.0 fabs(b) = 10.1 abs(c）= 5.0

2.5.2 ceil() 和 floor()

两个函数都定义于math模块，ceil()函数对数字向上取整，floor()对数字向下取整

from math import ceil
from math import floor
int a = 4.3
print('ceil(4.3) = ',ceil(a))
print('floor(4.3) = ',floor(a))

输出
ceil(4.3) = 4 floor(4.3) = 4

2.5.3 min() 和 max()

min()和max()属于python的内置函数，min()用于返回序列的最小值，max()用于返回序列的最大值，用法如下:

max(a, b, c, …)

min(a, b, c, …)

print(min(-1, 0, 1))
print(max(-1, 0, 1))

输出
-1 1

2.5.4 pow() 和 sqrt()

pow()和sqrt()都定义于math模块中，需要导入之后进行使用

pow(x, y): 返回 x^y，等于 x ** y

sqrt(x) ：返回 x 的算术平方根

from math import pow
from math import sqrt
print('pow(10, 2) =',pow(10, 2))
print('sqrt(9) =',sqrt(9))

输出
pow(10, 2) = 100.0 sqrt(9) = 3.0

从输出结果中可以看出来，pow() 和 sqrt()的返回值是浮点型数字

2.6 随机数函数

随机数的生成在数学，游戏，安全方面有很大的作用，还有很多高效率的随机化算法需要用到随机数。

下面是随机数函数的简介：
在这里插入图片描述

2.6.1 choice()函数

我称之为摇人函数，这个函数包含于random模块中，使用的时候需要导入random模块

参数可以是列表，元组，字符串

从列表中随机返回一个成员

from random import choice
lis = ['花木兰', '百里守约', '百里玄策', '苏烈', '铠']
print("请选择你的英雄: ",choice(lis))

程序随机返回一个英雄

从range()中随机返回一个数字

from random import choice
print('从 0 到 100 获取一个随机数：',choice(range(0, 101)))

程序随机返回一个x (0 <= x < 101)

从字符串中随机找一个字符

from random import choice
print('随机获取的字符为：',choice('hello world!'))

程序随机返回一个字符

2.6.2 randrange()函数

函数原型： randrange(start, stop, step)

start 和 end 为指定的范围，其中，能取到start，取不到end，左闭右开区间step为递增基数

函数会返回给定的范围内的通过start + i * step的数字

from random import randrange
# 从 0 到 100 拿一个五的倍数
print('randrange(0, 101, 5) = ',randrange(0, 101, 5))
# 从 0 到 100 中拿一个奇数
print('randrange(1, 101, 2) = ', randrange(1, 101, 2))
# 从 0 到 100 中拿一个能除三余一的数字
print('randrange(1, 101, 3) = ', randrange(1, 101, 3))

输出
randrange(0, 101, 5) = 55 randrange(1, 101, 2) = 57 randrange(1, 101, 3) = 88

2.6.3 random()函数

生成一个范围在[0, 1)的数字

from random import random
print('随机数为：',random())
print('随机数为：',random())
print('随机数为：',random())

程序输出为：

随机数为： 0.9995180763602436
随机数为： 0.4107366611375173
随机数为： 0.8579323583529348

2.6.4 shuffle()函数

我称之为洗牌函数，猴子排序算法重要函数😂，从名字可以看出来就是一个把列表重新排序的函数

from random import shuffle
lis = ['花木兰', '百里守约', '百里玄策', '苏烈', '铠']
shuffle(lis)
print('重新排序之后的英雄池为：',lis);
shuffle(lis)
print('重新排序之后的英雄池为：',lis);

程序输出为：

重新排序之后的英雄池为： [‘花木兰’, ‘苏烈’, ‘百里守约’, ‘百里玄策’, ‘铠’]

重新排序之后的英雄池为： [‘花木兰’, ‘铠’, ‘百里守约’, ‘百里玄策’, ‘苏烈’]

2.6.5 uniform()函数和randint()函数

uniform()函数随机生成一个实数，randint()函数随机生成一个整数，在使用的时候需要给定范围

from random import uniform
from random import randint
#生成一个 1000 到 9999 的实数
print('uniform(1000, 10000)', uniform(1000, 10000))
#生成一个 1000 到 9999 的整数
print('randint(1000, 10000)', randint(1000, 10000))

程序输出结果为：

uniform(1000, 10000) = 2970.7055885014615
randint(1000, 10000) = 5957

2.6.6 猜数字小游戏

游戏规则：程序随机生成一个0 到100 的数字，玩家猜这个数字，猜到数字即游戏结束

from random import randint
#生成一个数字
answer = randint(0, 101)
cnt = 0
while True:
    cnt += 1
    path = int(input('请输入你猜的数字: '))
    if path > answer:
        print('你猜的数字大了！')
    elif path < answer:
        print('你猜的数字小了！')
    else:e
        print('恭喜你，猜对了！')
        break
print('你一共猜了 %d 次！'%cnt)
if cnt == 1:
    print('你真是个欧皇！')
if cnt > 7:
    print('你个憨批！')

3. 字符串

字符串是非常常用的一种数据类型，使用单引号'' 或者双引号 ""创建，在python中，没有字符类型，一个字符是长度为1的字符串

python中的字符串截取操作:
在这里插入图片描述

在python中，凡是涉及到区间范围的函数，或者操作符，都是使用左闭右开的区间，底层原因其实和数组为何从 0 开始是同一个原因，左闭右开区间其实是非常优雅的表示范围的方法，比如表示[1 : 5]的这个范围中有多少个元素，我们直接使用 5 - 1 就可以得到这个范围中的元素个数，从左边开始，就是 1， 2 ， 3， 4。左闭右开这种优雅的写法深得python之父Guido老爹的欢心

3.1 python字符串中运算符

3.1.1字符串连接（ + ）

+ 号用来连接字符串
str1 = 'hello '
str2 = 'world!'
str3 = 'python!'
print('str1 + str2 =',str1 + str2)
print('str1 + str2 + str1 + str3 =',str1 + str2 + str1 + str3)
程序输出结果为：

str1 + str2 = hello world!
str1 + str2 + str1 + str3 = hello world!hello python!

3.1.2 字符串相乘（ * ）

* 用来将字符串多次相乘
str1 = 'hello'
print('str1 * 3 =', str1 * 3)
程序输出结果为：

str1 * 3 = hellohellohello

3.1.3 字符串截取（[ ] 和 [ : ]）

[ ]通过索引获取字符串中字符
[ : ]截取字符串中的一部分，遵循左闭右开原则，str[0 : 2]包含 str[0] 和 str[1], 不包含 str[2]
[ : : x]为按照步长为 x 截取
```
str = 'abcdefghijklmnopqrstuvwxyz'
print(str[0:26:1])
print(str[0:26:2])
print(str[0:26:3])
```
程序输出为：

abcdefghijklmnopqrstuvwxyz
acegikmoqsuwy
adgjmpsvy

3.1.4 成员运算符（in && not in）

in, 如果给定字符串包含给定的字符返回True
not in，如果给定的字符串不包含给定的字符返回True

s1 = 'hello world'
s2 = 'he'
s3 = 'no'
if s2 in s1:
   print('bingo')
else:
   print('no bingo')
if s3 in s1:
   print('bingo')
else:
   print('no bingo')

程序输出结果为：

bingo
no bingo

3.2 f-string格式化输出字符串

在格式化输出字符串的时候，我们习惯于使用下面的写法

name = 'ysj'
age = 20
print('大家好，我叫 %s, 我今年 %d 岁啦！'%(name, age))

程序输出为：

大家好，我叫 ysj, 我今年 20 岁啦！

在格式化输出一个字符串的时候，我们使用 %s对字符串进行占位

在python3.6之后添加了f-string来对字符串进行格式化

以上写法还可写成

name = 'ysj'
age = 20
print(f'大家好，我叫{name}, 我今年{age}岁了!')

程序输出为：

大家好，我叫ysj, 我今年20岁了!

如果需要对数字的精度进行控制的话，有以下写法：

name = 'ysj'
age = 20
print(f'大家好，我叫{name}, 我今年{age:.2f}岁了!')

程序输出为：

大家好，我叫ysj, 我今年20.00岁了

这种方式通过一个大括号包括上需要格式化输出的变量，不用再去判断name 需要使用%s, age 需要使用%d进行占位，而是直接把我们输出的变量用大括号括住放上去，简单明了，不愧是python……人生苦短，我用python！

3.3 字符串常用函数

以下为字符串常用函数简介：
在这里插入图片描述

3.3.1 len()函数

该函数用可以来获取字符串，列表，元组的长度

函数原型： len(string)

str1 = 'hello python!'
print(f'str1的长度为{len(str1)}')

程序输出的结果为：

str1的长度为13

3.3.2 count()函数

该函数用来统计字符串中出现某个子字符串的次数

函数原型： str.count(substr, start = 0, end = len(str))

start为在str中开始检索的起始位置，默认为 0

end为在str中结束检索的位置，默认为str整个字符串的长度

str1 = 'adcadcmmlajiaeoj'
print(f'str1中adc出现的次数为: {str1.count("adc", 0, len(str1))}')

程序输出结果为：

str1中adc出现的次数为: 2

3.3.3 find() 和 index()

find()函数用来检测在str指定范围内是否包含子字符串substr,如果包含返回索引值，不包含返回 -1

函数原型：str.find(substr,start = 0, end = len(str))

start为在str中开始检索的起始位置，默认为 0

end为在str中结束检索的位置，默认为str整个字符串的长度

str1 = "abcdefghijklmn"
print(f'str1中，f存在的下标为：{str1.find("f", 0, len(str1))}')
print(f'str1中，z存在的下标为：{str1.find("z", 0, len(str1))}')
#存在 f，返回下标 5，不存在 z, 返回下标 -1

程序输出结果为：

str1中，f存在的下标为：5
str1中，z存在的下标为：-1

index()函数用法和find()一模一样，只是如果不存在需要查找的子字符串，find()函数会返回 -1，而index()函数会报错

str1 = "abcdefghijklmn"
print(f'str1中，f存在的下标为：{str1.index("f", 0, len(str1))}')
#print(f'str1中，z存在的下标为：{str1.index("z", 0, len(str1))}')
#字符串中不存在z,第三句代码会报错

3.3.4 lower() 和 upper()

lower()函数把字符串内的大写字母化成小写
upper()函数把字符串内的小写字母化成大写

str1 = "hello world!"
str2 = "HELLO WORLD!"
print(f'str1化成大写:{str1.upper()}')
print(f'str2化成小写:{str2.lower()}')

程序输出为：

str1化成大写:HELLO WORLD!
str2化成小写:hello world!

3.3.5 replace()函数

replace()函数把原字符串中old(旧字符)替换成new(新字符串)

函数原型str.replace(old, new, max)

old：旧字符
new：新字符
max：最多替换多少次，如果不填则为全部替换

str1 = 'hello world!'
print(f'str1替换 0 次之后为：{str1.replace("world", "python", 0)}')
print(f'str1替换 1 次之后为：{str1.replace("world", "python", 1)}')

程序输出为：

str1替换 0 次之后为：hello world!
str1替换 1 次之后为：hello python!

4. 列表

列表是python中最常用的一个内置数据类型，列表中的每个值都有对应的位置和索引，并且列表中的每一个元素不必为同一个类型

4.1 创建和访问列表

列表是使用逗号分隔的各项使用方括号括起来

list1 = ['花木兰', '兰陵王', '孙悟空', '露娜']
#创建了一个列表，列表的每项都是字符串
list2 = [1, 2, 3, 4, 5]
#创建了一个列表，列表的每项都是数字

列表的索引和字符串的一样，有正向的索引，也有反向的索引，通过索引可以获得对应的值，具体如下图：
在这里插入图片描述

根据反向的索引仍然可以获得列表中的成员，具体如下图：
在这里插入图片描述

4.2 列表的切片

可以使用[ ]获取列表中单个的值，同时也可以使用[ : ]切片同时获取多个值，具体如下图：
在这里插入图片描述

我们可以正向的切片，也可以反向的切片，具体如下图：
在这里插入图片描述

4.3 列表的更新和删除（基础）

4.3.1 列表的更新

有一天，长城守卫军中的苏烈突然不干了，要退群，队伍里面缺少一个坦克，需要盾山加入顶替苏烈的位置

list = ['花木兰', '铠', '守约', '玄策', '苏烈', '伽罗', '沈梦溪']
#首先看看队伍整体人数
print(list)
#苏烈不干了，换盾山替换苏烈的位置list[4]
list[4] = '盾山'
print(list)

程序的输出结果为：

[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’]

4.3.2列表的删除

突然有一天，盾山也不干了，毕竟肉盾这个让人打的活太累了，盾山要退群，需要把盾山的位置删除

需要使用del 关键字删除列表中的元素

list = ['花木兰', '铠', '守约', '玄策', '盾山', '伽罗', '沈梦溪']
print(list)
#盾山不干了，把他删了
del list[4]
print(list)

程序输出结果为：

[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’]
[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘伽罗’, ‘沈梦溪’]

4.4 列表的运算符

4.4.1 列表的拼接( + )

突然又有一天，长城守卫军和三国队伍达成了合作意向，两只队伍合并成一对！

list1 = ['花木兰', '铠', '守约', '玄策', '盾山', '伽罗', '沈梦溪']
list2 = ['刘备', '关羽', '赵云', '马超', '张飞']
print(list1)
print(list2)
newList = list1 + list2
print(newList)

程序输出为：

[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’]
[‘刘备’, ‘关羽’, ‘赵云’, ‘马超’, ‘张飞’]
[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’, ‘刘备’, ‘关羽’, ‘赵云’, ‘马超’, ‘张飞’]

4.4.2 列表的相乘( * )

突然又有一天，木兰姐打开了克隆大作战，一个花木兰变成了 5 个花木兰

list = ['花木兰']
print(list)
#开始克隆
list *= 5
print(list)

程序输出为：

[‘花木兰’]
[‘花木兰’, ‘花木兰’, ‘花木兰’, ‘花木兰’, ‘花木兰’]

4.4.3 列表的寻找(in && not in)

打团战的时候，木兰姐要绕后特别关爱对面的鲁班七号，然后木兰姐就要看鲁班有木有参团！

#对面打团的人数
enemy = ['云中君', '貂蝉', '大乔', '鲁班七号']
print('敌军队伍有', end = ': ')
print(enemy)
#木兰姐开始找人
if '鲁班七号' in enemy:
    del enemy[3]
    print('鲁班七号已被击杀！')
else:
    print('没找到鲁班七号')
print('敌军还剩余: ',end = ': ')
print(enemy)

程序运行结果为：

敌军队伍有: [‘云中君’, ‘貂蝉’, ‘大乔’, ‘鲁班七号’]
鲁班七号已被击杀！
敌军还剩余: : [‘云中君’, ‘貂蝉’, ‘大乔’]

in 关键字为是否在列表中，如果在返回结果为True
not in关键字则表示是否不在列表中，如果不在结果为True

4.4.4 列表的迭代（for… in…）

宫本武藏的台词：“想送死的排好队，一个一个来”

有一天，三国小队偶遇宫本武藏，然后开始了葫芦娃救爷爷的行为

list = ['刘备', '赵云'，'马超', '张飞', '关羽']
#偶遇宫本武藏
str = '宫本武藏'
print("宫本武藏：“想送死的排好队，一个一个来！”")
#开始一个一个送
for x in list:
    print(f'{str}已经击杀{x}!')
print("喷他Q！")

程序输出结果为：

宫本武藏：“想送死的排好队，一个一个来！”
宫本武藏已经击杀刘备!
宫本武藏已经击杀赵云!
宫本武藏已经击杀马超!
宫本武藏已经击杀张飞!
宫本武藏已经击杀关羽!
喷他Q！

4.5 列表的嵌套

话说有一天啊，已经和长城守卫军结盟的刘备突然想到，不对啊，为什么联盟了我们要全部组成一个队伍呢？本来我们是两个队伍，我们应该每个队伍都有自己单独的编号，我们两个队伍再组成一个联盟啊，然后刘备就去找木兰姐商量，木兰姐姐想了想，觉得说的也对，刘备不知道怎么解决，木兰姐姐也不知道，毕竟木兰姐姐平时只会劈人，他们就去问张良，张良读书多，张良微微推了推眼镜说到，这个简单，用列表的嵌套就可以了！

list1 = ['花木兰', '铠', '守约', '玄策', '盾山', '伽罗', '沈梦溪']
list2 = ['刘备', '关羽', '赵云', '马超', '张飞']
#两个队伍结盟
alliance = [list1, list2]
print('整个联盟为', end = ': ')
print(alliance)
print('长城守卫军队伍：', end = '')
print(alliance[0])
print('三国队伍为：', end = '')
print(alliance[1])

程序输出结果为：

整个联盟为: [[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’], [‘刘备’, ‘关羽’, ‘赵云’, ‘马超’, ‘张飞’]]
长城守卫军队伍：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’]
三国队伍为：[‘刘备’, ‘关羽’, ‘赵云’, ‘马超’, ‘张飞’]

4.6 列表常用函数

下面是列表常用函数的简介：
在这里插入图片描述

4.6.1 len()函数

函数原型：len(list)

用来求列表的长度，某一天木兰姐想看看他们守卫军一共有多少人

list = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
print(f'长城守卫军一共有{len(list)}个人!')

程序输出为：

长城守卫军一共有8个人!

4.6.2 max() 和 min()

函数原型max(list) 和 min(list)，用来返回列表中的最大值和最小值

list = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
print(f'长城守卫军{max(list)}最大')
print(f'长城守卫军{min(list)}最小')

程序输出为：

长城守卫军铠最大
长城守卫军伽罗最小

因为汉字的大小无法比较，所以min()和 max()对汉字进行比较和汉字的编码有关系，min() 和 max()一般用于数字列表和字符串列表中

list = [1, 3, 5, 7, 9]
print(f'列表中最大值为{max(list)}')
print(f'列表中最小值为{min(list)}')

程序输出为：

列表中最大值为9
列表中最小值为1

4.6.3 append() 函数和 extend() 函数

append()函数是在列表末尾添加一个元素
extend()函数是使用一个新的列表拓展原来的列表

函数原型：append(obj)，参数是一个元素

函数原型：extend(list)，参数是一个元素列表，可以是列表，字典，元组，集合……

下面先看append()的使用:

有一天，长城守卫军迎来了新的成员，李信，需要在原来的长城守卫军中添加李信的位置

list = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
print('原长城守卫军：', end = ': ')
print(list)
#使用append()在列表中增加一个新的元素
list.append('李信')
print('添加新成员之后', end = ': ')
print(list)

程序输出为：

原长城守卫军：: [‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
添加新成员之后: [‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’, ‘李信’]

下面是extend()的使用：

有一天，四大美女队伍想一起去守长城……她们就进入了长城守卫军…

list = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
beauties = ['貂蝉', '西施', '杨玉环', '王昭君']
print('原长城守卫军：', end = ': ')
print(list)
print('四大美女加入后：', end = '')
list.extend(beauties)
print(list)

程序输出结果为：

原长城守卫军：: [‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
四大美女加入后：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’, ‘貂蝉’, ‘西施’, ‘杨玉环’, ‘王昭君’]

4.6.3.1 append() 和 extend()的区别

append() 和 extend() 都可以在列表末尾增加新的元素，但是append()添加的仅仅为单个元素，extend()是将一个列表整个扩展到另外一个列表中，下面举例看看两个函数的区别

四大美女通过extend()函数加入长城守卫军之后，原先的四大美女的集合就已经不存在了，四大美女是以四个单独的身份加入长城守卫军而非以一个整体的方式加入长城守卫军

def Func_append(list, beauties):
    print('以append的方式添加：')
    print('添加前的队伍：', end = '')
    print(list)
    list.append(beauties)
    print('添加后的队伍：', end = '')
    print(list)
    return
def Func_extend(list, beauties):
    print('以extend的方式添加：')
    print('添加前的队伍：', end = '')
    print(list)
    print('添加之后的队伍：', end = '')
    list.extend(beauties)
    print(list)
    return
if __name__ == '__main__':
    list1 = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
    list2 = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
    beauties = ['西施', '王昭君', '杨玉环', '西施']
    Func_append(list1, beauties)
    Func_extend(list2, beauties)
    print(f'通过append添加后列表的长度:{len(list1)}')
    print(f'通过extend添加后列表的长度:{len(list2)}')

程序输出结果为：

以append的方式添加：
添加前的队伍：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
添加后的队伍：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’, [‘西施’, ‘王昭君’, ‘杨玉环’, ‘西施’]]
以extend的方式添加：
添加前的队伍：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
添加之后的队伍：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’, ‘西施’, ‘王昭君’, ‘杨玉环’, ‘西施’]
通过append添加后列表的长度:9
通过extend添加后列表的长度:12

因为列表中的元素不必为同一类型，列表使用append()函数将四大美女团队添加进长城守卫军时，四大美女是作为一个整体被添加到长城守卫军列表中的，所以append()添加一次，列表的长度只会增加 1， extend()添加一次，原列表长度的变化和用来添加的列表的长度有关

一图胜千言：
在这里插入图片描述

4.6.4 count()函数

函数原型count(obj)函数用来统计列表中某个元素出现的次数

在一盘游戏中，有一个特殊的列表，每英雄如果死亡一次，他的名字就会被加到这个列表中，游戏结束的时候，让你统计整盘游戏鲁班七号死亡的次数

die = ['鲁班七号', '孙悟空', '牛魔', '铠', '诸葛亮', '鲁班七号', '鲁班七号', '鲁班七号', '吕布', '鲁班七号', '鲁班七号']
print(f'鲁班七号的死亡次数为：{die.count("鲁班七号")}')

程序输出为：

鲁班七号的死亡次数为：6

4.6.5 insert()函数

函数原型：insert(index, obj)

功能：将一个元素插入到列表中指定的位置

如果正向的index > len(list)，元素会被插在列表尾部
如果反向的index < -[len(list) + 1] ，元素会被插在列表首部

之前长城守卫军加人都是在末尾加，现在我们需要找个合适的位置插入，把李信插在第一个位置，取代木兰姐姐的位置

list1 = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
print(list1)
list1.insert(0, '李信')
print(list1)

程序输出为：

[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
[‘李信’, ‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]

4.6.6 index()函数

index(obj)返回某个元素第一个匹配项的索引

如果找不到，程序报错

在长城守卫军中，木兰姐姐想要知道伽罗妹妹在军队中的几号位置，就使用index()函数进行获取

list1 = ['花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
print(f'伽罗妹妹在{list1.index("伽罗")}号位置')

程序输出为：

伽罗妹妹在6号位置

4.6.7 pop()函数和 remove()函数

函数原型：pop(index = -1)

函数原型：remove(obj)

pop和remove函数都用于移除元素，但是pop()函数是通过索引对元素进行移除，remove是通过值进行移除

pop() 和 remove()要移除的值在列表中没有代码都会报错
pop()默认移除最后一个元素

通过下标对元素进行移除：

在长城守卫军中，李信居然敢霸占木兰姐姐的位置，这还得了？

把他移除了，由于他是在木兰姐姐T0的位置，所以我们直接把0号的元素移除了

list = ['李信', '花木兰', '铠', '守约', '玄策', '盾山', '苏烈', '伽罗', '沈梦溪']
print(list)
#移除李信
list.pop(0)
print(list)

程序输出为：

[‘李信’, ‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]
[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘苏烈’, ‘伽罗’, ‘沈梦溪’]

通过名字对元素进行移除：

李信又霸占了别人的位置，但是不知道他霸占的位置是那个，我们就想把李信移除了，不管他在那个位置

list = ['花木兰', '铠', '守约', '玄策', '盾山', '李信', '伽罗', '沈梦溪']
print(list)
#移除李信
list.remove('李信')
print(list)

程序输出为：

[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘李信’, ‘伽罗’, ‘沈梦溪’]
[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘伽罗’, ‘沈梦溪’]

4.6.7 reverse()函数

这个函数是将整个列表反转的一个函数

list = ['花木兰', '铠', '守约', '玄策', '盾山', '李信', '伽罗', '沈梦溪']
print(f'列表反转之前：{list}')
list.reverse()
print(f'列表反转之后：{list}')

程序输出为：

列表反转之前：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘李信’, ‘伽罗’, ‘沈梦溪’]
列表反转之后：[‘沈梦溪’, ‘伽罗’, ‘李信’, ‘盾山’, ‘玄策’, ‘守约’, ‘铠’, ‘花木兰’]

4.6.8 sort()函数

函数原型：sort(key = None, reverse = False)

sort()函数用来对列表进行排序

参数解析：

key：是用来进行比较的元素，一个列表能排序的前提是这个列表中的元素之间可以比较，并且通过比较能够得出先后顺序的关系

reverse：排序的规则，reverse = True 为降序，reverse = False为升序，默认为升序

下面对数字列表进行:

list = [1, 3, 2, 8, 0, 5, 3]
print(f'排序前：{list}')
list.sort()
print(f'排序后：{list}')
list.sort(reverse = True)
print(f'逆向排序:{list}')

程序输出为：

排序前：[1, 3, 2, 8, 0, 5, 3]
排序后：[0, 1, 2, 3, 3, 5, 8]
逆向排序:[8, 5, 3, 3, 2, 1, 0]

对下面的字符列表进行排序：

list = ['a', 'c', 'f', 'd']
print(f'排序前：{list}')
list.sort()
print(f'排序后：{list}')
list.sort(reverse = True)
print(f'逆向排序:{list}')

程序输出为：

排序前：[‘a’, ‘c’, ‘f’, ‘d’]
排序后：[‘a’, ‘c’, ‘d’, ‘f’]
逆向排序:[‘f’, ‘d’, ‘c’, ‘a’]

4.5.9 clear()函数

清空列表

不用守长城了，长城守卫军散伙了

list = ['花木兰', '铠', '守约', '玄策', '盾山', '李信', '伽罗', '沈梦溪']
print(f'散伙前：{list}')
list.clear()
print(f'散伙后:{list}')

程序输出为：

散伙前：[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘李信’, ‘伽罗’, ‘沈梦溪’]
散伙后:[]

4.5.10 copy()函数

将整个列表复制给另外一个列表

list = ['花木兰', '铠', '守约', '玄策', '盾山', '李信', '伽罗', '沈梦溪']
list2 = list.copy()
print(f'原来的部队{list}')
print(f'复制的部队{list2}')

程序输出为:

原来的部队[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘李信’, ‘伽罗’, ‘沈梦溪’]
复制的部队[‘花木兰’, ‘铠’, ‘守约’, ‘玄策’, ‘盾山’, ‘李信’, ‘伽罗’, ‘沈梦溪’]

5.元组

元组和列表在逻辑上十分相似，唯一不同的是，元组中的任何元素都不能修改，尽管网上各种千方百计修改元组中的元组，但是本质上元组本身并没有被修改，那些被修改的元素我们使用id()函数查看所在的内存，id()得到的内存地址必改变，所以元组不可以修改本质上的意义是元组所对应的内存空间上面的值不可以被修改，所有名义上修改元组的值都是换了块内存空间填了一个新的值而已。

5.1 元组的创建

元组的创建很简单，只需要在一个完整的小括号中添加元素，每个元素之间用逗号隔开，甚至不用添加小括号也可以，但是还是建议添加小括号

tup1 = (1, 3, 4, 5, 8)
tup2 = ('a', 'b', 'c', 'd', 'e')
tup3 = ('moon', 'sun', 3, 5) #元素可以不同
tup4 = 'moon', 'sun', 'river', '花木兰'     #可以不添加小括号
print(f'tup1 = {tup1}')
print(f'tup2 = {tup2}')
print(f'tup3 = {tup3}')
print(f'tup4 = {tup4}')

程序输出为：

tup1 = (1, 3, 4, 5, 8)
tup2 = (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)
tup3 = (‘moon’, ‘sun’, 3, 5)
tup4 = (‘moon’, ‘sun’, ‘river’, ‘花木兰’)

创建一个空元组和只有一个元素的元组

tup = ()		#空元组
tup2 = (1, )	#只有一个元素的元组一定要在第一个元素之后添加小括号
#不然会把小括号当作运算符

5.2 元组的访问

元组的访问和列表一样，通过下标访问，并且拥有切片访问操作
在这里插入图片描述

5.3 元组的运算符与内置函数

在这里插入图片描述

5.3.1 len()运算符

用来计算元组的长度

tup = (1, 2, 3, 4, 5)
print(f'tup的长度为{len(tup)}')

程序输出为：

tup的长度为5

5.3.2 ( + )运算符

用来连接两个元组

tup1 = (1, 2, 3, 4, 5)
tup2 = (6, 7, 8, 9, 0)
tup3 = tup1 + tup2
print(f'tup3 = {tup3}')

程序输出为：

tup3 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

5.2.3 （ * ）运算符

用来复制元组

tup = ('花木兰',)
tup2 = tup * 5
print(f'tup2 = {tup2}')

程序输出为：

tup2 = (‘花木兰’, ‘花木兰’, ‘花木兰’, ‘花木兰’, ‘花木兰’)

5.3.4 in 关键字

用来判断元素是否存在

tup = ('花木兰','铠','守约','玄策','苏烈','伽罗','沈梦溪')
if '貂蝉' in tup:
    print('貂蝉也去守长城了！')
else:
    print('貂蝉没有去守长城！')

程序输出结果为：

貂蝉没有去守长城！

5.3.5 迭代（for…in…）

用来遍历元组中的所有元素

tup = ('花木兰','铠','守约','玄策','苏烈','伽罗','沈梦溪')
for hero in tup:
    print(hero, end = ',')

程序输出结果为：

花木兰,铠,守约,玄策,苏烈,伽罗,沈梦溪,

5.3.6 max()函数

获取元组中的最大值

tup = (1, 2, 3, 4, 5)
print(f'元组中的最大值为：{max(tup)}')

程序输出为：

元组中的最大值为：5

5.3.7 min()函数

获取元组中最小值

tup = (1, 2, 3, 4, 5)
print(f'元组中的最小值为：{min(tup)}')

程序输出为：

元组中的最小值为：1

5.3.8 list()函数

把元组转成列表

tup = (1, 2, 3, 4, 5)
print(f'tup的类型为：{type(tup)}')
list = list(tup)
print(f'tup的类型为：{type(tup)}')
print(f'list的类型为：{type(list)}')

程序输出为：

tup的类型为：<class ‘tuple’>
tup的类型为：<class ‘tuple’>
list的类型为：<class ‘list’>

5.4 元组的删除

元组是不可变数据类型，所有元组的元素不可以删除，但是我们仍然可以使用del关键字删除整个元组，被删除的元组后续进行任何操作都会被视为非法操作，包括打印输出~

tup = (1, 3, 5, 7, 9)
del tup
print(tup)#报错

6. 字典

字典是一个可变的数据类型，字典可以理解成一个自定义下标的列表，列表的下标默认为0 到任意数，也可以说成是哈希表（散列表）

6.1 字典的两个核心

键（key值）和值（value值）

dict[key] = value

一个字典中，key值必须是唯一的，value值可以重复。
key值必须是不可变数据类型，比如数字，字符串，value值任意数据类型都可以。

所谓字典，就是一个对应关系
在这里插入图片描述

每个不同的软件都可以当作一个key值，key值不能重复
对应关系就是这些软件所属的公司
而这些公司就是value值，如上图的腾讯，阿里巴巴，可以重复

如果键值重复，那么第一个键值对应的value值会被后面的相同的键值的value值覆盖

6.2 创建一个字典

创建一个字典可以使用时，key值和value值之间用:分割，key值在前，value值在后，每一对之间使用逗号分割,整个字典在{ }之中

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海宽娱', '抖音' : '字节跳动'}
print(f'微信的母公司是{dict["微信"]}')
print(f'淘宝的母公司是dict["淘宝"]')

程序输出为：

微信的母公司是腾讯
淘宝的母公司是阿里巴巴

6.3 修改一个字典

上海宽娱改成上海幻电

PS~ 坤坤：“这个我熟😂”
添加网易云音乐，公司为网易公司
删除其中一个软件

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海宽娱', '抖音' : '字节跳动'}
dict['网易云音乐'] = '网易公司'#增加公司
dict['bilibili'] = '上海幻电'#修改哔哩哔哩公司为上海幻电
del dict['微信']# 删除微信
print(dict)

程序输出为：

{ ‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’, ‘bilibili’: ‘上海幻电’, ‘抖音’: ‘字节跳动’, ‘网易云音乐’: ‘网易公司’}

del 关键字也可以用来删除一个字典，一个字典被删除之后任何对这个字典的操作都属于非法操作，包括打印

6.4 字典的遍历

使用for…in…循环遍历字典

这里使用dict.items()内置函数生成一个可以遍历的，类似列表的数据类型，然后使用key，和value遍历返回的这个数据类型，后面会说到items()函数并且怎么把返回的这个可遍历的，类似列表的数据类型改变成一个列表

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
print('整个字典遍历结果如下：')
for key, value in dict.items():
    print(key,'\t',value)

程序输出为：

整个字典遍历结果如下：
微信腾讯
QQ 腾讯
淘宝阿里巴巴
钉钉阿里巴巴
bilibili 上海幻电
抖音字节跳动

6.5 字典的常用函数

字典常用函数简介如下：

在这里插入图片描述

6.5.1 len()函数

返回字典的长度，也就是字典的键的数量

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海宽娱', '抖音' : '字节跳动'}
print(f'字典的长度为：{len(dict)}')

程序输出为：

字典的长度为：6

6.5.2 fromkeys()函数

fromkeys()函数是通过一个列表或者一个元组创建一个字典的函数

函数原型为：dict.fromkeys(seq, default = None)

参数解析：

seq：一个列表或者一个元组
default：默认的value值

list = ['微信', 'QQ', '淘宝', '钉钉', 'bilibili', '抖音']
#default 默认都为互联网
dict = dict.fromkeys(list)
print(f'默认为None时的字典{dict}')
dict2 = dict.fromkeys(list, '互联网')
print(f'默认为互联网的字典{dict2}')

程序输出为：

默认为None时的字典{‘微信’: None, ‘QQ’: None, ‘淘宝’: None, ‘钉钉’: None, ‘bilibili’: None, ‘抖音’: None}
默认为互联网的字典{‘微信’: ‘互联网’, ‘QQ’: ‘互联网’, ‘淘宝’: ‘互联网’, ‘钉钉’: ‘互联网’, ‘bilibili’: ‘互联网’, ‘抖音’: ‘互联网’}

6.5.3 get()函数和 setdefault()函数

get()函数是通过key值来访问value值的内置函数

函数原型为：dict.get(key, default = None)

参数解析：

key：key值
default：如果key值在整个字典中不存在，则返回default的值，默认为None

setdefault()函数也是通过key值访问value值的函数

函数原型为：dict.setdefault(key, default = None)

参数解析：

key：key值
default：如果key值在整个字典中不存在，那么这个函数会把该key值插入到字典中，并且key值对应的value值就是default

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
print(f'微信的公司为：{dict.get("微信")}')
print(f'快手的公司为：{dict.get("快手","字典中不存在快手")}')
print(f'快手的公司为：{dict.setdefault("快手", "北京快手科技")}')
print(dict)

程序的输出为：

微信的公司为：腾讯
快手的公司为：字典中不存在快手
快手的公司为：北京快手科技
{‘微信’: ‘腾讯’, ‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’, ‘bilibili’: ‘上海幻电’, ‘抖音’: ‘字节跳动’, ‘快手’: ‘北京快手科技’}

get()函数和中括号访问的方法都可以通过key值访问字典中的value值，但是使用中括号的方法访问的话，如果字典中不存在该key值，程序就会报错

get()函数和setdefault()函数十分相似，但是通过setdefault()函数，如果需要查找的key值不存在，setdefault()函数会把用来查找的key值插入的字典中，并且该key值对应的value值就是参数中的default参数

6.5.4 in 和 not in 操作符False

in 用来查找key值是否存在于字典中，如果存在返回True，反之返回False
not in用来查找key值是否不存在字典中，如果不存在返回True, 反之返回False

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
if '微信' in dict:
    print('微信在字典中')
else:
    print('微信不在字典中')
if '酷狗音乐' in dict:
    print('酷狗音乐在字典中')
else:
    print('酷狗音乐不在字典中')

程序输出为：

微信在字典中
酷狗音乐不在字典中

6.5.5 items()函数

items()函数以列表嵌套元组的方法返回一个可以用来遍历的元组列表，但是返回的并不是一个真正的列表，而dict_items类型的数据结构

函数原型：dict.items()

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
list = dict.items()
print(list)
print(f'list的类型为{type(list)}')

程序输出为：

dict_items([(‘微信’, ‘腾讯’), (‘QQ’, ‘腾讯’), (‘淘宝’, ‘阿里巴巴’), (‘钉钉’, ‘阿里巴巴’), (‘bilibili’, ‘上海幻电’), (‘抖音’, ‘字节跳动’)])
list的类型为<class ‘dict_items’>

从程序输出结果可以看出来返回值并不是列表，而是一个可以用于迭代的dict_items，如果想要把这个函数的返回值转化成列表，需要使用list()函数转化，list()函数可以将元组转化成列表，也可以把dict_items转化成列表

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
list = list(dict.items())
print(list)
print(f'list的类型为：{type(list)}')

程序输出为：

[(‘微信’, ‘腾讯’), (‘QQ’, ‘腾讯’), (‘淘宝’, ‘阿里巴巴’), (‘钉钉’, ‘阿里巴巴’), (‘bilibili’, ‘上海幻电’), (‘抖音’, ‘字节跳动’)]
list的类型为：<class ‘list’>

从这里我们得到的才是一个真正的元组列表

6.5.6 keys()函数和values()函数

dict.keys()函数用于返回一个可以遍历迭代的，类似列表的数据类型，用来获取字典的所有key值

函数原型：dict.keys()

dict.values()函数和dict.keys()函数类似，返回值也是类似列表的数据类型，用来获取字典的所有value值

函数原型：dict.values()

6.5.6.1 keys()函数

下面先来看看dict.keys()的返回值类型以及迭代方法

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
list = dict.keys()
print(list)
print(f'list的类型为:{type(list)}')
for key in dict.keys():
    print(key)

程序输出为：

dict_keys([‘微信’, ‘QQ’, ‘淘宝’, ‘钉钉’, ‘bilibili’, ‘抖音’])
list的类型为:<class ‘dict_keys’>
微信
QQ
淘宝
钉钉
bilibili
抖音

从程序输出可以看出来，dict.keys()的返回值是'dict_keys'的一种数据类型，并不是我们认为的列表类型，这种'dict_keys'类型可以用来迭代，遍历，如果想要把这个'dict_keys'的数据类型变成我们熟悉的list类型，同样使用list()函数

下面来看怎么把dict.keys()的返回值变成一个列表类型

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
list = list(dict.keys())#使用list()
print(list)
print(f'list的类型为:{type(list)}')

程序输出为：

[‘微信’, ‘QQ’, ‘淘宝’, ‘钉钉’, ‘bilibili’, ‘抖音’]
list的类型为:<class ‘list’>

6.5.6.2 values()函数

values()函数和keys()函数用法上一摸一样，返回类型同样也能迭代

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
list = dict.values()
print(list)
print(f'list的类型为:{type(list)}')
for value in dict.values():
    print(value)

对标keys()函数

程序输出为：

dict_values([‘腾讯’, ‘腾讯’, ‘阿里巴巴’, ‘阿里巴巴’, ‘上海幻电’, ‘字节跳动’])
list的类型为:<class ‘dict_values’>
腾讯
腾讯
阿里巴巴
阿里巴巴
上海幻电
字节跳动

keys()函数的返回值为dict_keys类型， values()的返回值也为dict_values类型

同样也能够使用list()函数把values()的返回值转化成为一个列表

6.5.7 update()函数

将一个字典合并到另外一个字典中

dict1 = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴'}
dict2 = {'bilibili' : '上海幻电', '抖音' : '字节跳动'}
print(f'dict1中的元素为：{dict1}')
print(f'dict2中的元素为：{dict2}')
dict1.update(dict2)
print(f'dict1添加dict2后：{dict1}')

程序输出为：

dict1中的元素为：{‘微信’: ‘腾讯’, ‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’}
dict2中的元素为：{‘bilibili’: ‘上海幻电’, ‘抖音’: ‘字节跳动’}
dict1添加dict2后：{‘微信’: ‘腾讯’, ‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’, ‘bilibili’: ‘上海幻电’, ‘抖音’: ‘字节跳动’}

6.5.8 pop()函数和 popitem()函数

pop()函数通过key值删除字典中对应的value值，并且函数的返回值为key值对应的value值

函数原型：dict.pop(key,default)

参数解析：

key：需要删除的键值
default：如果需要删除的键值不存在，pop()需要一个返回值，这个default就是返回值

popitem()函数删除字典最后一对的key值和value值

函数原型：dict.popitem()，无参数，返回值是被删除的那一对key值和value值，以元组的方式返回

pop()函数的使用

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
print(f'删除微信之前：{dict}')
dict.pop('微信')
print(f'删除微信之后：{dict}')
dict.pop('快手')#快手不存在，这句代码错误
dict.pop('快手', None)#虽然快手不存在，但是pop有默认的返回值，这句代码正确

程序输出为：

删除微信之前：{‘微信’: ‘腾讯’, ‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’, ‘bilibili’: ‘上海幻电’, ‘抖音’: ‘字节跳动’}
删除微信之后：{‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’, ‘bilibili’: ‘上海幻电’, ‘抖音’: ‘字节跳动’}

popitem()函数的使用

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
tup = dict.popitem()#最后一项被删除
#tup为dict.popitem()的返回值
print(f'dict.popitem()执行后：{dict}')
print(f'tup中的内容为：{tup}')
print(f'tup的类型为：{type(tup)}')

程序输出为：

dict.popitem()执行后：{‘微信’: ‘腾讯’, ‘QQ’: ‘腾讯’, ‘淘宝’: ‘阿里巴巴’, ‘钉钉’: ‘阿里巴巴’, ‘bilibili’: ‘上海幻电’}
tup中的内容为：(‘抖音’, ‘字节跳动’)
tup的类型为：<class ‘tuple’>

6.5.9 clear()函数

清空一个字典

dict = {'微信' : '腾讯', 'QQ' : '腾讯', '淘宝' : '阿里巴巴', 
        '钉钉' :'阿里巴巴', 'bilibili' : '上海幻电', '抖音' : '字节跳动'}
dict.clear()
print(f'清空之后的字典为：{dict}')

程序输出为：

清空之后的字典为：{}

一个字典被清空之后，再使用popitem()函数代码会发生错误

6.5.10 copy()和deepcopy()函数

这里的copy()函数是一个浅拷贝，deepcopy()函数为深拷贝

下面是新的字典的逻辑图片
在这里插入图片描述

在字典对象中，还嵌套了一个列表的对象，这个列表的对象就是子对象，字典对象我们统一成为父对象

直接赋值

#直接赋值，浅拷贝，深拷贝
dict = {'腾讯' : ['王者荣耀', '微信', 'QQ'], '阿里巴巴':['支付宝', '淘宝', '天猫']}
#直接赋值
dict2 = dict
#我们对dict2进行修改
#dict2把阿里巴巴以及阿里巴巴列表中的软件删除
dict2.popitem()
#打印dict2
print(f'dict2 为：{dict2}')
#结果为只有腾讯公司
#我们并没有对dict进行任何操作
#接下来打印dict
print(f'dict 为：{dict}')
#发现结果也只有腾讯了

程序输出为：

dict2 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’]}
dict 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’]}

从这里我们其实可以看出来，dict对dict2直接赋值之后，dict2不是直接存在的，dict2只是dict的一个新的名字，当你换了一个新的名字，别人叫你新的名字和叫你原来的名字是不是都是你，如下图：
在这里插入图片描述

无论对dict操作还是对dict2操作，两个变量共享同一块内存，所以dict对这块内存操作，dict2也需要同时承受dict操作后的结果

浅拷贝

#直接赋值，浅拷贝，深拷贝
dict = {'腾讯' : ['王者荣耀', '微信', 'QQ'], '阿里巴巴':['支付宝', '淘宝', '天猫']}
#浅拷贝
dict2 = dict.copy()
#请记住，浅拷贝只复制了父对象，并没有复制子对象
#我们对复制出来的dict2的父对象操作
#父对象是字典，那么就对字典进行操作
dict2['网易云音乐'] = '网易公司'
#我们对dict2进行了操作
#对dict没有进行操作
print(f'dict2 为：{dict2}')
print(f'dict 为：{dict}')

程序输出为：

dict2 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’], ‘阿里巴巴’: [‘支付宝’, ‘淘宝’, ‘天猫’], ‘网易云音乐’: ‘网易公司’}
dict 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’], ‘阿里巴巴’: [‘支付宝’, ‘淘宝’, ‘天猫’]}

可以看出来，在对父对象(字典对象)层面上操作的时候，两个字典是分开的，并没有相互影响，当我们对子对象(列表层面进行操作的时候)

#直接赋值，浅拷贝，深拷贝
dict = {'腾讯' : ['王者荣耀', '微信', 'QQ'], '阿里巴巴':['支付宝', '淘宝', '天猫']}
#浅拷贝
dict2 = dict.copy()
#请记住，浅拷贝只复制了父对象，并没有复制子对象
#我们对复制出来的dict2的子对象操作
#子对象是列表，那么就对列表进行操作
dict2['腾讯'].append('和平精英')
dict['阿里巴巴'].append('钉钉')
#同时对dict2和dict进行了操作
#看看打印的结果
print(f'dict2 为：{dict2}')
print(f'dict 为：{dict}')

程序输出为：

dict2 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’, ‘和平精英’], ‘阿里巴巴’: [‘支付宝’, ‘淘宝’, ‘天猫’, ‘钉钉’]}
dict 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’, ‘和平精英’], ‘阿里巴巴’: [‘支付宝’, ‘淘宝’, ‘天猫’, ‘钉钉’]}

从上面我们可以看出来，dict2我们只对腾讯进行了操作，dict我们只对阿里巴巴进行了操作，可是打印出来的结果两个列表都改变了，这就是浅拷贝，只拷贝了父类对象，子类对象其实还是共享中，这里的子类对象是指列表，而不是key值和value值的关系，不要混淆

如下图：
在这里插入图片描述

深拷贝：需要使用copy模块的内容

from copy import deepcopy
#直接赋值，浅拷贝，深拷贝
dict = {'腾讯' : ['王者荣耀', '微信', 'QQ'], '阿里巴巴':['支付宝', '淘宝', '天猫']}
#浅拷贝
dict2 = deepcopy(dict)
#使用深拷贝之后
#我们对父类对象进行操作
dict2['网易云音乐'] = '网易公司'
#同时对子类对象进行操作
dict2['腾讯'].append('和平精英')
dict['阿里巴巴'].append('钉钉')
#看看打印的结果
print(f'dict 为：{dict}')
print(f'dict2 为：{dict2}')

程序输出结果为：

dict 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’], ‘阿里巴巴’: [‘支付宝’, ‘淘宝’, ‘天猫’, ‘钉钉’]}
dict2 为：{‘腾讯’: [‘王者荣耀’, ‘微信’, ‘QQ’, ‘和平精英’], ‘阿里巴巴’: [‘支付宝’, ‘淘宝’, ‘天猫’], ‘网易云音乐’: ‘网易公司’}

可以看出来，进行了深拷贝之后，dict和dict2互不影响，是两个独立的个体了

如下图：
在这里插入图片描述

简单总结一下直接赋值，深拷贝和浅拷贝

直接赋值：同生共死
浅拷贝：藕断丝连
深拷贝：恩断义绝

7. 集合

回想高中数学中集合的三要素

无序性
确定性
互异性

python中的集合也一样，集合是一个序列，集合中元素不能够重复

7.1 创建一个集合

创建集合使用大括号或者set()函数创建

heros = {'花木兰', '花木兰', '铠', '守约', '百里玄策', '百里玄策'}
print(heros)

程序输出为：

{‘花木兰’, ‘铠’, ‘百里玄策’, ‘守约’}

我们在创建集合的时候，在集合中设置了重复的元素，但是集合会自动的把重复的元素去掉

或者可以用下面这种创建方法

heros = set(('花木兰', '花木兰', '铠', '守约', '百里玄策', '百里玄策'))
print(heros)

程序输出为：

{‘百里玄策’, ‘守约’, ‘花木兰’, ‘铠’}

7.2 集合中的运算

集合常见的四种运算
在这里插入图片描述

odd = {1, 3, 5, 7, 9, 0}#奇数 + 0
even = {2, 4, 6, 8, 0}#偶数 + 0
print(f'两个集合的差集为：{odd - even}')
print(f'两个集合的并集为：{odd | even}')
print(f'两个集合的交集为：{odd & even}')
print(f'两个集合的对称差集为：{odd ^ even}')

程序输出为：

两个集合的差集为：{1, 3, 5, 7, 9}
两个集合的并集为：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
两个集合的交集为：{0}
两个集合的对称差集为：{1, 2, 3, 4, 5, 6, 7, 8, 9}

7.3 集合的常用函数

集合常用函数简介如下：
在这里插入图片描述

7.3.1 add()函数和update()函数

add()函数为给集合添加一个元素，如果元素已经存在了，那么就不会进行任何操作

update()函数用于给调用的集合加入另外一个集合，同样可以去重

set1 = {'花木兰', '铠', '百里守约'}
set2 = {'百里玄策', '苏烈','沈梦溪'}
set1.add('伽罗')
set1.update(set2)
print(set1)

程序输出为：

{‘花木兰’, ‘百里玄策’, ‘伽罗’, ‘沈梦溪’, ‘铠’, ‘百里守约’, ‘苏烈’}

7.3.2 discard()函数和remove()函数

discard()函数和remove函数用法一模一样，都用于删除集合中的某个元素

set = {'花木兰', '百里玄策', '伽罗', '沈梦溪', '铠', '百里守约', '苏烈'}
set.remove('花木兰')
set.discard('铠')
print(set)

程序输出为：

{‘百里守约’, ‘苏烈’, ‘百里玄策’, ‘沈梦溪’, ‘伽罗’}

唯一的区别在于，使用remove()函数移除集合中的元素的时候，如果集合中不存在该元素，代码会报错，而discard()不会报错

7.3.3 difference()函数和difference_update()函数

difference()函数用于返回两个集合的差集，有返回值，对原集合没有影响

difference_update()用于把调用该集合的函数变为difference()函数的返回值

set1 = {'花木兰', '百里守约', '铠'}
set2 = {'花木兰', '百里玄策', '伽罗'}
set3 = set1.difference(set2)
print(f'set3为：{set3}')
print(f'set1没有调用difference_update前：{set1}')
set1.difference_update(set2)
print(f'set1调用difference_update后：{set1}')

程序输出为：

set3为：{‘铠’, ‘百里守约’}
set1没有调用difference_update前：{‘百里守约’, ‘铠’, ‘花木兰’}
set1调用difference_update后：{‘百里守约’, ‘铠’}

从输出可以看出，difference()函数的返回值其实就是difference_update()函数调用之后的结果

7.3.4 intersection() 和 intersection_update()函数

intersection()函数用于返回集合之间的交集，有返回值，对原集合无影响

intersection_update()函数用于把调用的该函数的集合变成intersection()函数的返回值

set1 = {'花木兰', '百里守约', '铠'}
set2 = {'花木兰', '百里玄策', '伽罗'}
set3 = set1.intersection(set2)
print(f'set3 = {set3}' )
print(f'set1没有调用intersection_update前：{set1}')
set1.intersection_update(set2)
print(f'set1调用intersection_update后：{set1}')

程序输出为：

set3 = {‘花木兰’}
set1没有调用intersection_update前：{‘花木兰’, ‘百里守约’, ‘铠’}
set1调用intersection_update后：{‘花木兰’}

7.3.5 symmetric_difference() 和 symmetric_difference_update()函数

symmetric_difference()函数用于返回两个集合的对称差集，有返回值，对原集合无影响

symmetric_difference_update()函数用于把调用该函数的集合变成symmetric_difference()函数的返回值

set1 = {'花木兰', '百里守约', '铠'}
set2 = {'花木兰', '百里玄策', '伽罗'}
set3 = set1.symmetric_difference(set2)
print(f'set3 = {set3}' )
print(f'set1没有调用symmetric_difference_update函数前：{set1}')
print(f'set1调用symmetric_difference_update函数后：{set1}')

程序输出为：

set3 = {‘百里守约’, ‘铠’, ‘百里玄策’, ‘伽罗’}
set1没有调用symmetric_difference_update函数前：{‘百里守约’, ‘铠’, ‘花木兰’}
set1调用symmetric_difference_update函数后：{‘百里守约’, ‘铠’, ‘百里玄策’, ‘伽罗’}

7.3.6 issubset()和issuperset()函数

issubset()函数用来判断调用该函数的集合是不是作为参数的集合的子集，是返回True,不是返回False

issuperset()函数用来判断作为参数的集合是不是调用该函数的集合的子集，是返回True，不是返回False；

set = {1, 2, 3, 4, 5, 7, 8, 9, 10}
set1 = {1, 3, 5, 7, 9}
if set1.issubset(set):
    print('set1是set的子集')
else:
    print('set1不是set的子集')
if set.issuperset(set1):
    print('set1是set的子集')
else:
    print('set1不是set的子集')

程序输出为：

set1是set的子集
set1是set的子集

7.3.7 isdisjoint()函数

isdisjoint()函数用于判断两个函数是否有交集，如果没有交集返回True，有返回False

set = {1, 2, 3, 4, 5, 7, 8, 9, 10}
set1 = {1, 3, 5, 7, 9}
set2 = {11, 12}
if set.isdisjoint(set1):
    print('set1 和 set 没有交集')
else:
    print('set1 和 set 有交集')
if set.isdisjoint(set2):
    print('set2 和 set 没有交集')
else:
    print('set2 和 set 有交集')

程序输出为：

set1 和 set 有交集
set2 和 set 没有交集

7.3.8 union()函数

返回两个集合的并集

set1 = {1, 3, 5, 7, 9}
set2 = {2, 4, 6, 8}
set3 = set1.union(set2)
print(f'set1 和 set2 的并集为：{set3}')

程序输出为：

set1 和 set2 的并集为：{1, 2, 3, 4, 5, 6, 7, 8, 9}

7.3.9 copy()函数和clear()函数

copy()函数复制集合，clear()清空集合

set1 = {1, 3, 5, 7, 9}
set2 = set1.copy()
set1.clear()
print(f'set2为：{set2}')
print(f'set1清空后：{set1}')

程序输出为：

set2为：{1, 3, 5, 7, 9}
set1清空后：set()

7.3.10 pop()函数

理论上来说，随机从集合中删除一个元素，但是计算机的世界中，所有的随机都是由数学公式进行推导来的

set = {1, 3, 5, 7, 9}
x = set.pop()
print(x)
print(set)

程序输出结果为：

1
{3, 5, 7, 9}

7.3.11 len()函数

计算集合的数量

set = {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(f'集合的长度为：{len(set)}')

程序输出为：

集合的长度为：9

❤️完结撒花❤️

Charon_cc

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
6
评论
【Python】标准数据类型

Python标准数据类型在Python中变量不需要赋值，每个变量在使用的时候必须进行赋值，赋值之后该变量会自动被创建，并且在Python中，所有的变量都没有类型，变量单纯只是变量而已，我们所说的类型只是这个变量在内存中指向的对象的类型，在Python中，所有的数据类型都是对象文章目录Python标准数据类型1. 六种数据类型2. 数字2.1 整型数字2.2 浮点型数字2.3 复数2.4 数字运算2.5 常用的数学函数2.5.1 abs()与fabs()2.5.2 ceil() 和 floor()2.5.
复制链接

扫一扫