【python入门到精通专题】3.变量类型详解

1. 变量类型1

字符串介绍

定义

如下定义的变量a，存储的是数字类型的值

python">a = 100

如下定义的变量b，存储的是字符串类型的值

python">b = "www.tulingxueyuan.com"
# 或者
b = 'www.tulingxueyuan.com'

小总结：

双引号或者单引号中的数据，就是字符串

下标

下标：就是标记空间的一个数字

有些文档叫法为“索引”，个人觉得其实下标更好的体现它的特点。

如果有字符串：name = 'abcdef'，在内存中的实际存储如下：

下标为正数

第0个空间	第1个空间	第2个空间	第3个空间	第4个空间	第5个空间
a	b	c	d	e	f

下标为负数

第 -6 个空间	第 -5 个空间	第 -4 个空间	第 -3 个空间	第 -2 个空间	第 -1 个空间
a	b	c	d	e	f

特点：

每个字符单独存储，各占一个存储空间
为了方便标记处哪个空间存放的是哪个字符，Python使用了"下标"
如果从左侧开始编号，那么下标从 0 开始
如果从右侧开始编号，那么下标从-1开始
如果字符串只有3个字符例如"abc"，那么能用的下标为0、1、2不能使用超过2以上的，这种情况就是"越界"。很危险会导致程序崩溃

下标的使用

python">name = 'abcdef'print(name[0])
print(name[1])
print(name[2])

运行结果：

a
b
c

字符串切片

什么是切片

较为官方的说法：切片是指对操作的对象截取其中一部分的操作

通俗来说：一种能够从数据中取到一部分数据的方式

例如：

有一个字符串"abcdef"，我们可以通过切片取到"cde"

切片不仅可以在字符串中应用，还可以对列表、元组等进行操作，简言之“切片”功能很重要。

本节课我们以字符串为例讲解“切片”

使用方式

语法

[起始:结束:步长]

注意：

选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔
默认“步长”为1，即取完一个下标的数据之后，第二个下标的是在刚刚下标基础上+1
步长为正数，表示从左向右取数据
步长为负数，表示从右向左取数据

示例代码

示例一：

python">name = 'abcdef'
print(name[0:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间

运行结果：

abc

示例二：

python">name = 'abcdef'
print(name[:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间'''
如果第一个参数没写则默认为0开始
'''

运行结果:

abc

示例三：

python">name = 'abcdef'
print(name[3:5])  # 取下标为3、4 的字符

运行结果：

de

示例四：

python">name = 'abcdef'
print(name[2:])  # 取下标为2开始到最后的字符

运行结果:

cdef

示例五：

python">name = 'abcdef'
print(name[1:-1])  # 取下标为1开始到右侧最后一个字符之前的所有字符

运行结果：

bcde

示例六：

python">name = 'abcdef'
print(name[1:5:2])'''
步长为2表示间隔1个值取一次
'''

运行结果：

bd

示例七：

python">name = 'abcdef'
print(name[5:1:-1])'''
5: 起始位置
1: 结束位置 （不包含）
-1: 步长，表示从右往左取值
'''

运行结果：

fedc

示例八：

python">name = 'abcdef'
print(name[5:1:-2])'''
5: 起始位置
1: 结束位置 （不包含）
-2: 步长，表示从右往左取值并间隔一个值
'''

运行结果：

fd

示例九：

python">name = 'abcdef'
print(name[::1])'''
起始位置: 未设置
结束位置:	未设置
1: 步长表示从最左边取值到最右边(包含最右边)
'''

运行结果：

abcdef

示例十：

python">name = 'abcdef'
print(name[::])

运行结果：

abcdef

说明：

开始位置、结束位置都未指定，且步长也未指定那么步长用默认的1，则此时从最左取到最右

示例十一：

python">name = 'abcdef'
print(name[::-1])

运行结果：

fedcba

说明：

开始位置、结束位置都未指定，步长为-1，此时从最右取到最左

示例十二：

python">name = 'abcdef'
print(name[::-2])

运行结果：

fdb

说明

开始、结束位置都未指定，且步长是-2，那么就意味着从右侧往左取数据，且步长为2（即隔一个取一个）

练习

给定一个字符串变量s，请反转字符串：

python">s = 'Hello World!'
print(s[4])
print(s)
print(s[:]) # 取出所有元素（没有起始位和结束位之分），默认步长为1
print(s[1:]) # 从下标为1开始，取出 后面所有的元素（没有结束位）
print(s[:5])  # 从起始位置开始，取到 下标为5的前一个元素（不包括结束位本身）
print(s[:-1]) # 从起始位置开始，取到 倒数第一个元素（不包括结束位本身）
print(s[-4:-1]) # 从倒数第4个元素开始，取到 倒数第1个元素（不包括结束位本身）
print(s[1:5:2]) # 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）
# python 字符串快速逆序
print(s[::-1])  # 从后向前，按步长为1进行取值

总结

切片使用规则中，要么一个冒号[开始位置:结束位置]，要么两个冒号[开始位置:结束位置:步长]
不写步长时，默认为1
步长为正数，表示从左向右取数据
步长为负数，表示从右向左取数据
当开始位置、结束位置都没有设定时，要看步长，如果步长为正数此时开始位置理解为最左结束位置为最右，如果步长为负数此时开始位置理解为最右结束位置为最左

字符串常见操作

find 方法

检测str是否包含在 my_str中，如果是返回开始的索引值，否则返回-1

python">my_str.find(str, start=0, end=len(mystr))

python">In [2]: my_str = "welcome to www.tulingxueyuan.com"In [3]: my_str.find("to")
Out[3]: 8

说明：

上述运行中数值8表示"to"这个字符串在原字符串的开始下标值是8

rfind 方法

类似于 find()函数，不过是从右边开始查找，返回的索引是从左边开始

python">my_str.rfind(str, start=0, end=len(my_str) )

python">In [2]: my_str = "welcome to www.tulingxueyuan.com"In [3]: my_str.rfind("to")
Out[3]: 8

count 方法

返回 str在start和end之间在 my_str里面出现的次数

python">my_str.count(str, start=0, end=len(mystr))

python">In [2]: my_str = "welcome to www.tulingxueyuan.com"In [3]: my_str.count("w")
Out[3]: 4

replace 方法

把 my_str 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

python">my_str.replace(str1, str2,  mystr.count(str1))

python">In [2]: my_str = "welcome to www.tulingxueyuan.com"In [3]: my_str.replace('w', 'W', 1)
Out[3]: 'Welcome to www.tulingxueyuan.com'

split 方法

以 str 为分隔符切片 my_str，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

python">my_str.split(str=" ", maxsplit)

python">In [1]: my_str = "welcome to www.tulingxueyuan.com"In [2]: my_str.split(" ")
Out[2]: ['welcome', 'to', 'www.tulingxueyuan.com']In [3]: my_str.split(" ", 1)
Out[3]: ['welcome', 'to www.tulingxueyuan.com']In [4]:

startswith 方法

检查字符串是否是以 指定的字符串 开头, 是则返回 True，否则返回 False

python">my_str.startswith('这里写入你指定的字符串')

python">In [1]: my_str = "welcome to www.tulingxueyuan.com"
...
In [4]: my_str.startswith('welcome')
Out[4]: TrueIn [5]: my_str.startswith('Welcome')
Out[5]: False

endswith 方法

检查字符串是否以指定字符串结束，如果是返回True,否则返回 False

python">my_str.endswith('这里写入你指定的字符串')

python">In [1]: my_str = "welcome to www.tulingxueyuan.com"
...
In [6]: my_str.endswith('com')
Out[6]: True

lower 方法

转换 my_str 中所有大写字符为小写

python">my_str.lower()

python">In [8]: my_str = "WELCOME to www.tulingxueyuan.com"In [9]: my_str.lower()
Out[9]: 'welcome to www.tulingxueyuan.com'

upper 方法

转换 my_str 中所有小写字母为大写

python">my_str.upper()

python">In [10]: my_str = "welcome to www.tulingxueyuan.com"In [11]: my_str.upper()
Out[11]: 'WELCOME TO WWW.TULINGXUEYUAN.COM'

strip 方法

删除字符串两端的空白字符

python">In [12]: my_str = "   welcome to www.tulingxueyuan.com   "In [13]: my_str.strip()
Out[13]: 'welcome to www.tulingxueyuan.com'

partition 方法

把my_str以str分割成三部分,str前，str和str后

python">my_str.partition(str)

python">In [14]: my_str = "welcome to www.tulingxueyuan.com"In [15]: my_str.partition('to')
Out[15]: ('welcome ', 'to', ' www.tulingxueyuan.com')

splitlines 方法

按照行分隔，返回一个包含各行作为元素的列表

python">my_str.splitlines()

python">In [16]: my_str = """welcome to www.tulingxueyuan.com...: thank you...: good good study day day up...: """In [17]: my_str.splitlines()
Out[17]: ['welcome to www.tulingxueyuan.com', 'thank you', 'good good study day day up']

isalpha 方法

如果 my_str 所有字符都是字母则返回 True,否则返回 False

python">my_str.isalpha()

python">In [18]: my_str = "abc123"In [19]: my_str.isalpha()
Out[19]: FalseIn [20]: my_str = "abc"In [21]: my_str.isalpha()
Out[21]: True

isdigit 方法

如果 my_str 只包含数字则返回 True 否则返回 False

python">my_str.isdigit()

python">In [60]: my_str = "abc123"In [61]: my_str.isdigit()
Out[61]: FalseIn [62]: my_str = "123"In [63]: my_str.isdigit()
Out[63]: True

isalnum 方法

如果 my_str 所有字符都是字母或数字则返回 True,否则返回 False

python">my_str.isalnum()

python">In [2]: my_str = 'abc123'In [3]: my_str.isalnum()
Out[3]: TrueIn [4]: my_str = 'abc123_'In [5]: my_str.isalnum()
Out[5]: False

join 方法

my_str 中每个元素后面插入str,构造出一个新的字符串

python">my_str.join(str)

python">In [6]: my_str = '-'In [7]: str_list = ['welcome', 'to', 'changsha']In [8]: my_str.join(str_list)
Out[8]: 'welcome-to-changsha'

说明

关于字符串的常见操作上面列举了16个，其实还有很多，但各位同学们要注意

不要背，理解即可
忘记没关系，可以查阅资料
学会怎么用，什么时候用什么这是关键点

列表

引入

通过前面学习的字符串我们可以实现用它存储一串信息，例如一个人的名字 "顾安"，那么如何存储咱们班所有同学的名字呢？

定义100个变量，每个变量存放一个学生的姓名可行吗？有更好的办法吗？

答：列表

定义

定义列表的方式是[]

如下：用列表存储了3个学生的姓名

python">stu_names = ['张三', '李四', '王五']

如下：用列表存储了5个分数

python">scores = [100, 99, 100, 95, 90]

基本使用

下标

列表中存储的多个数据，我们可以对这些数据任意的使用

方式是：通过下标可以实现定位，然后就可以用这个数据

例如：

python">stu_names = ['张三', '李四', '王五']
print(stu_names[0])  # 此时只输出张三
stu_names[0] = "顾安"
print(stu_names[0])  # 此时只输出顾安

注意：下标依然是从0开始使用

切片

切片具体的知识我们已经学习过了，在列表也是支持切片操作的

python">stu_names = ['张三', '李四', '王五']
stu_names[1:3]  # 此时得到一个新列表 [李四', '王五']

列表逆序：

python">stu_names = ['张三', '李四', '王五']
stu_names = [::-1]  # 得到一个新列表['王五', '李四', '张三']

遍历

所谓列表遍历，就是指将列表中的所有的数据依次获取打印

方式一：使用for循环 (首选)

python">stu_names = ['张三', '李四', '王五']
for name in stu_names:print(name)

运行结果：

张三
李四
王五

方式二：使用while循环

python">stu_names = ['张三', '李四', '王五']
length = len(stu_names)
i = 0
while i < length:print(stu_names[i])i += 1

运行结果：

张三
李四
王五

注意点

学习其他编程语言的同学，此时能够看到Python中的列表与C语言、C++语言、Java中的数组很类似

相同点：列表和数组都能实现多个数据的存储

不同点：列表可以存储不同类型的数据，而数组只能存储相同数据类型。

如下代码，完成了一个列表存储了多个信息

python">teacher = ["顾安", "湖南省长沙市", 18, 176.5]  # 18为年龄，176.5为身高

技巧：虽然Python中的列表可以存储多个不同的数据类型，但一般情况下我们很少这么做，而是把数据类型相同的数据放到一个列表，这样操作时会更加方便，否则就会出现一会整数，一会字符串很容易出错

如果真的需要存储多个数据，例如一个人的信息由多个组成，此时一般用Python中的字典来进行存储

列表的相关操作

列表，最大的特点能够存储多个数据，一般情况下我们需要对这个列表进行数据的增删改查，详细功能如下

数据增加（append、extend、insert）

append 方法

通过append可以向列表添加元素

格式：

python">列表.append(新元素数据)

示例：

python"># 定义列个表存储3个学生的姓名
stu_names = ['张三','李四','王五']
print("-----添加之前，列表的数据-----")
for name in stu_names:print(name)# 提示、并添加元素
temp = input('请输入要添加的学生姓名:')
stu_names.append(temp)print("-----添加之后，列表的数据-----")
for name in stu_names:print(name)

extend 方法

通过extend可以将另一个列表中的元素逐一添加到列表中

格式：

python">列表.extend(另外一个列表)

示例：

python">>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]

insert 方法

insert(index, object)在指定位置index（索引，理解为下标即可）前插入元素object

python">>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]

数据修改

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

格式：

python">列表[下标] = 新数据

示例：

python"># 定义列个表存储3个学生的姓名
stu_names = ['张三', '李四', '王五']
print("-----修改之前，列表的数据-----")
for name in stu_names:print(name)# 修改元素
stu_names[1] = '赵六'
print("-----修改之后，列表的数据-----")
for name in stu_names:print(name)

数据查询（in、not in、count）

所谓的查找，就是看看指定的元素是否存在

in、not in 查询列表中的元素是否存在

查找的常用方法为：

in（存在），如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false

in格式：

python">数据 in 列表

not in 格式：

python">数据 not in 列表

示例：

python"># 待查找的列表
stu_names = ['张三','李四','王五']# 获取用户要查找的名字
find_name = input('请输入要查找的姓名:')# 查找是否存在
if find_name in stu_names:print('找到了名字')
else:print('没有找到')

count 查询元素个数

格式：

python">列表.count("要查询的数据")  # 结果就是找到的数据的个数

python">In [5]: nums = [1, 2, 3, 4, 5, 1, 2, 3]In [6]: nums.count(1)  # 查找的数据1 一共有2个，所以结果为2
Out[6]: 2In [7]: nums.count(9)  # 没有找到数据9 所以结果为0
Out[7]: 0

数据删除（del、pop、remove）

列表元素的常用删除方法有：

del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除

del

python">movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']print('------删除之前------')
for name in movie_names:print(name)del movie_names[2]  # 这里根据下标进行删除print('------删除之后------')
for name in movie_names:print(name)

pop

python">movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']print('------删除之前------')
for name in movie_names:print(name)movie_names.pop()  # 删除最后1个print('------删除之后------')
for name in movie_names:print(name)

remove

python">movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']print('------删除之前------')
for name in movie_names:print(name)movie_names.remove('指环王')  # 删除指定的数据print('------删除之后------')
for name in movie_names:print(name)

数据排序（sort、reverse）

sort

sort方法是将列表按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

python">>>> a = [1, 4, 2, 3]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

reverse

reverse方法是将列表倒叙

python">>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]

列表嵌套

什么是列表嵌套

类似while循环的嵌套，列表也是支持嵌套的

一个列表中的元素又是一个列表，那么这就是列表的嵌套

python">school_names = [['北京大学', '清华大学'],['南开大学', '天津大学', '天津师范大学'],['山东大学', '中国海洋大学']
]

应用

一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

python">import random# 定义一个列表用来保存3个办公室
offices = [[], [], []]# 定义一个列表用来存储8位老师的名字
names = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']# 遍历所有的老师，随机安排到0、1、2号办公室
for name in names:random_num = random.randint(0, 2)offices[random_num].append(name)i = 1
for office_names in offices:print('办公室%d的人数为:%d' % (i, len(office_names)))i += 1for name in office_names:print("%s" % name, end=' ')print("\n")print("-" * 20)

运行结果如下: (因为是随机所以每次运行结果都可以不同)

办公室1的人数为:1
G --------------------
办公室2的人数为:2
A B --------------------
办公室3的人数为:5
C D E F H

2. 变量类型2

元组

什么是元组

元组是存储多个数据的一种方式

元组与列表类似，不同之处在于元组的元素不能修改

元组使用小括号()，列表使用方括号[]

python">>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)

元组的使用

访问元组

python"># 定义一个元组
nums = (100, 200, 300)# 获取元组中的元素
print(nums[0])# 遍历
for temp in nums:print(temp)

不能修改元组

示例代码：

python"># 定义一个元组
nums = (100, 200, 300)nums[0] = 400  # 这里会报错，元组中的数据不能被修改

运行结果：

Traceback (most recent call last):File "/Users/poppies/Desktop/元组.py", line 4, in <module>nums[0] = 400
TypeError: 'tuple' object does not support item assignment

不能修改元组中的元素指的是如果当前元组中的元素为不可变对象则不能修改，如果是可变对象在不修改元素类型的情况下可以修改可变对象中的值。

可变对象：list、dict、set

不可变对象：tuple、string、int、float、bool

元组的作用

到现在我们知道元组也是可以存储多个数据的，列表也可以存储多个数据，那为什么有了列表还要有元组呢？而且元组还不能修改

why?

正是因为元组的特点是不能被修改，所以才有了存在它的理由，试想一个程序中有很多场景是有很多数据不能被修改的，这种情况下用列表容易被篡改，反而用元组恰到好处

多提一句，后面学习函数时，一个函数可以通过return返回多个数据，那时就是用的元组。

集合

什么是集合

集合是一种能够存储多个数据的方式

它最大的特点是：数据不能重复

也就是说

列表可以存储多个数据，支持增删改查
元组可以存储多个数据，不能修改
集合依然可以存储多个数据，数据不能重复

可见Python发明的列表、元组、集合各有特点各有千秋，希望大家多练习以便更快掌握它们的精髓

集合的使用

定义

python">{元素1, 元素2, 元素3...}

示例

python"># 定义一个集合
nums = {100, 200, 300}# 测试数据类型真的是集合吗？
print(type(nums))# 遍历
for temp in nums:print(temp)

运行结果：

<class 'set'>
200
100
300

集合的数据去重

python"># 定义一个集合
nums = {100, 200, 200, 300, 300, 300}# 测试数据类型真的是集合吗？
print(type(nums))# 遍历
for temp in nums:print(temp)

运行结果：

<class 'set'>
200
100
300

集合无序

代码示例：

python"># 定义一个集合
set_data = {'a', 'b', 'c', 'd', 'e', 'f'}
print(set_data)

运行结果：

python">In [1]: set_data = {'a', 'b', 'c', 'd', 'e', 'f'}In [2]: print(set_data)
{'c', 'd', 'f', 'b', 'a', 'e'}

注意点

列表、元组在定义时的顺序是怎样的，那么顺序就是怎样的
而集合的实际存储顺序与定义的顺序没有什么关系，而是与一个特殊的算法有关(把数据进行了哈希，这个我们暂不做深入讨论，只需要知道集合的顺序不确定即可)

容器类型的类型互转

引入

所谓互转，就是把一种数据类型在数值不变的情况下转换为另外一种表示方式

当前容器类型的互转不包含字典！！！

基本使用

python">nums1 = [11, 22, 33]  # 定义列表
nums2 = (44, 55, 66)  # 定义元组
nums3 = {77, 88, 99}  # 定义集合# 列表转换为元组、集合
print("-----------")
nums1_tuple = tuple(nums1)
print(type(nums1_tuple))
nums1_set = set(nums1)
print(type(nums1_set))# 元组转换为列表、集合
print("-----------")
nums2_list = list(nums2)
print(type(nums2_list))
nums2_set = set(nums2)
print(type(nums2_set))# 集合转换为列表、元组
print("-----------")
nums3_list = list(nums3)
print(type(nums3_list))
nums3_tuple = tuple(nums3)
print(type(nums3_tuple))

快速去重

使用set，可以快速的完成对list、tuple中的元素去重复的功能

python">nums1 = [11, 22, 44, 33, 22, 11, 55, 666, 44, 33, 22]
nums2 = (11, 22, 44, 33, 22, 11, 55, 666, 44, 33, 22)print(set(nums1))  # 将nums1转换为集合的时候，就自动去重了
print(set(nums2))  # 将nums2转换为集合的时候，就自动去重了

运行效果：

{33, 11, 44, 22, 55, 666}
{33, 11, 44, 22, 55, 666}

集合中的内置方法

方法	描述
`add()`	为集合添加元素
`clear()`	移除集合中的所有元素
`copy()`	拷贝一个集合
`difference()`	返回多个集合的差集
`difference_update()`	移除集合中的元素，该元素在指定的集合也存在。
`discard()`	删除集合中指定的元素
`intersection()`	返回集合的交集
`intersection_update()`	返回集合的交集。
`isdisjoint()`	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
`issubset()`	判断指定集合是否为该方法参数集合的子集。
`issuperset()`	判断该方法的参数集合是否为指定集合的子集
`pop()`	随机移除元素
`remove()`	移除指定元素
`symmetric_difference()`	返回两个集合中不重复的元素集合。
`symmetric_difference_update()`	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
`union()`	返回两个集合的并集
`update()`	给集合添加元素

3 - 变量类型3

字典

引入

场景一：

声明一个列表

python">nameList = ['张三', '李四', '王五']

如果发现 "李四" 这个名字写错了，通过下标修改

python">nameList[1] = '赵六'

但是如果列表元素的顺序发生了变化，如下列代码

python">nameList = ['张三', '王五', '李四']

此时就必须需要修改下标，才能完成姓名的修改

python">nameList[2] = '赵六'

问：有没有方法，既能存储多个数据，还能在访问元素的很方便就能够定位到需要的那个元素呢？

场景二：

学生信息列表，每个学生信息包括学号、姓名、年龄等，如何从中找到某个学生的信息？

python">students = [[1001, "张三", 24], [1002, "李四", 23], [1005, "王五"，24], ...]

假如上述列表有100个人的信息，此时会发现想要找到某个人的信息虽然我们可以数数0、1、2、。。。。但这也太麻烦了

问：有没有更方便的方式呢？

通过上面的2个场景的描述，发现虽然列表可以很轻松的实现数据的增删改查，但当多个数据时，想要快速定位到某个数据就会很不方便

基于此原因，Python发明了一种特殊的下标，可以快速的找到想要的数据

拥有这种特殊下标的数据类型就是字典

基本使用

定义格式

python">{key: value, key2: value ...}

说明：

key可以理解为：我们自己可以定义的下标
value可以理解为：我们要存储的真正的数据
字典只要存储一个数据，就必须用key: value（我们常称为键值对）组成

代码示例

定义一个字典，存储顾安老师的信息

python">teacher_info = {'name': '顾安', 'age': 18, 'home': '湖南省长沙市'}

如果感觉一行太长，写不开，可以用如下的方式

python">teacher_info = {'name': '顾安','age': 18, 'home': '湖南省长沙市'
}

说明：

字典能够存储多个数据
列表中找某个元素时，是根据下标进行的，字典中找某个元素时，是根据’key’（就是冒号:前面的那个值，例如上面代码中的’name’、‘home’、‘age’）
字典的每个元素由2部分组成，键:值

根据 key 访问 value

python">teacher_info = {"name": "顾安","age": 18,"home": "湖南省长沙市"
}print(teacher_info['name'])  # 获取姓名
print(teacher_info['age'])  # 获取年龄
print(teacher_info['home'])  # 获取住址

运行结果：

顾安
18
湖南省长沙市

遍历字典（keys、values、items）

keys() 方法

遍历字典的键（key）

python">teacher_info = {"name": "顾安","age": 18,"home": "湖南省长沙市"
}for key in teacher_info.keys():print(key)

运行结果：

name
age
home

values() 方法

遍历字典的值（value）

python">teacher_info = {"name": "顾安","age": 18,"home": "湖南省长沙市"
}for val in teacher_info.values():print(val)

运行结果：

顾安
18
湖南省长沙市

items() 方法

遍历字典的项（元素）

python">teacher_info = {"name": "顾安","age": 18,"home": "湖南省长沙市"
}for item in teacher_info.items():print(item)

运行结果：

('name', '顾安')
('age', 18)
('home', '湖南省长沙市')

字典的常见操作

数据查询 - 普通方式

python">teacher_info = {"name": "顾安","age": 18,"home": "湖南省长沙市"
}print(teacher_info['QQ'])  # 当前字典不存在QQ这个键

运行结果：

python">Traceback (most recent call last):File "/Users/poppies/Desktop/字典.py", line 8, in <module>print(teacher_info["QQ"])
KeyError: 'QQ'

数据查询 - get 方式

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

python">teacher_info = {"name": "顾安","age": 18,"home": "湖南省长沙市"
}print(teacher_info.get('QQ', '当前字典不存在QQ这个key'))  # 当前字典不存在QQ这个键

运行结果：找不到指定的key则使用默认值，程序不会因为key的不存在而崩溃

当前字典不存在QQ这个key

数据修改

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

python">info = {'name': '班长', 'id': 100, 'sex': '男', 'address': '中国北京'}new_id = input('请输入新的学号:')
info['id'] = int(new_id)print('修改之后的id为: %d' % info['id'])

运行结果：

请输入新的学号:1010
修改之后的id为: 1010

数据增加

新的key以及value就表示添加一个新的键值对

即：如果在使用 变量名['键'] = 数据 时，这个“键”在字典中不存在，那么就会新增这个元素。

python">info = {'name': '班长', 'id': 100, 'sex': '男', 'address': '中国北京'}print(info)
info['web_address'] = "www.tulingxueyuan.com"  # 添加一个新的键值对
print(info)

执行结果：

python">{'name': '班长', 'id': 100, 'sex': '男', 'address': '中国北京'}
{'name': '班长', 'id': 100, 'sex': '男', 'address': '中国北京', 'web_address': 'www.tulingxueyuan.com'}

数据删除

对字典进行删除操作，有一下几种：

del
clear()

del 删除指定的元素

示例代码：

python">teacher_info = {'name': '顾安', 'age': 18, 'home': '湖南省长沙市'}print(teacher_info)
del teacher_info['home']
print(teacher_info)

运行结果：

python">{'name': '顾安', 'age': 18, 'nome': '湖南省长沙市'}
{'name': '顾安', 'age': 18}

del 删除整个字典

示例代码：

python">teacher_info = {'name': '顾安', 'age': 18, 'home': '湖南省长沙市'}print(teacher_info)
del teacher_info
print(teacher_info)

执行结果：

{'name': '顾安', 'age': 18, 'nome': '湖南省长沙市'}
Traceback (most recent call last):File "/Users/poppies/Desktop/字典常见操作.py", line 7, in <module>print(teacher_info)
NameError: name 'teacher_info' is not defined

clear 清空整个字典元素

示例代码：

python">teacher_info = {'name': '顾安', 'age': 18, 'home': '湖南省长沙市'}print(teacher_info)
teacher_info.clear()
print(teacher_info)

运行结果：

{'name': '顾安', 'age': 18, 'nome': '湖南省长沙市'}
{}

推导式

引入

推导式：就是一种能够快速生成数据的方式

例如，想要快速生成由1~20内所有偶数数组成的列表，就可以用"推导式"，代码如下：

python">[x for x in range(1, 21) if x % 2 == 0]

运行结果如下：

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

列表推导式

列表推导式：一种可以快速生成列表的方式

代码格式：

python">[变量 for 变量 in 可迭代对象]

基本使用：

案例一：

python">In [1]: a = [x for x in range(4)]In [2]: a
Out[2]: [0, 1, 2, 3]In [3]: a = [x for x in range(3, 4)]In [4]: a
Out[4]: [3]In [5]: a = [x for x in range(3, 19)]In [6]: a
Out[6]: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]In [7]: a = [x for x in range(3, 19, 2)]In [8]: a
Out[8]: [3, 5, 7, 9, 11, 13, 15, 17]

案例二：列表推导式中用到了 if

注意：列表推导式如果for中用到了if，for不用写:

python">In [9]: a = [x for x in range(3, 10) if x % 2 == 0]In [10]: a
Out[10]: [4, 6, 8]In [11]: a = [x for x in range(3, 10) if x % 2 != 0]In [12]: a
Out[12]: [3, 5, 7, 9]

案例三：在列表推导式中使用两个 for 循环

python">In [13]: a = [(x, y) for x in range(1, 3) for y in range(3)]In [14]: a
Out[14]: [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

案例四：在列表推导式中使用三个 for 循环

python">In [15]: a = [(x, y, z) for x in range(1, 3) for y in range(3) for z in range(4, 6)]In [16]: a
Out[16]: 
[(1, 0, 4),(1, 0, 5),(1, 1, 4),(1, 1, 5),(1, 2, 4),(1, 2, 5),(2, 0, 4),(2, 0, 5),(2, 1, 4),(2, 1, 5),(2, 2, 4),(2, 2, 5)]

练习

请写出一段 Python 代码实现分组：一个 list 里面的元素,比如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....]

参考答案：

python">a = [x for x in range(1,101)]
b = [a[x:x+3] for x in range(0, len(a),3)]
print(b)

集合推导式

集合推导式：一种快速生成集合的方式

示例代码：

python">In [5]: a = {x for x in range(1, 21) if x % 2 == 0}In [6]: type(a)
Out[6]: setIn [7]: a
Out[7]: {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

集合推导式中也可以用if等，与列表推导式在格式上很类似，这里就不做过多的介绍，请类别列表推导式进行学习

字典推导式

字典推导式：一种快速生成字典的方式

案例一：快速生成一个1~10内key为某个数此时value为平方的字典

python">{x: x ** 2 for x in range(1, 11)}

运行效果：

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

案例二：快速生成一个1~10内key可以1时value为2，key为2时value3…依次类推的字典

python">{x: (x + 1) for x in range(1,11)}

运行效果：

{1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10, 10: 11}

练习

编写代码用推导式，实现如下效果（列表中嵌套字典）

[{1: 1},{2: 4},{3: 9},{4: 16},{5: 25},{6: 36},{7: 49},{8: 64},{9: 81},{10: 100}]

参考代码：

python">[{x: x ** 2} for x in range(1, 11)]

拆包

引入

拆包：是一种快速提取数据的方式

例如，有一个元组(11, 22, 33, 44)想快速的提取每个元素且赋值给num1, num2, num3, num4这4个变量

普通的做法，较为繁琐：

python">nums = (11, 22, 33, 44)  # 定义一个元组
num1 = nums[0]  # 通过下标来提取
num2 = nums[1]  # 通过下标来提取
num3 = nums[2]  # 通过下标来提取
num4 = nums[3]  # 通过下标来提取

拆包的方式，可以见非常简洁：

python">num1, num2, num3, num4 = (11, 22, 33, 44)  # 一行代码搞定

列表拆包

示例：

python">a, b = [11, 22]
print(a)
print(b)

效果：

11
22

元组拆包

示例：

python">a, b = (11, 22)
print(a)
print(b)

效果：

11
22

集合拆包

示例：

python">a, b = {11, 22}
print(a)
print(b)

效果：

11
22

字典拆包

一般用法

python">a, b = {"name": "顾安", "age": 18}
print(a)
print(b)

name
age

默认取到的是字典的key，而不是value

常见用法

python">teacher_info = {"name": "顾安", "age": 18}for k, v in teacher_info.items():print('k = %s, v = %s' % (k, v))

k = name, v = 顾安
k = age, v = 18

注意点

=右边要拆的数据元素的个数要与=左边存的变量个数相同

错误示例如下：

python">a, b = [11, 22, 33]

运行结果如下：

ValueError                                Traceback (most recent call last)
<ipython-input-19-887c339c8076> in <module>
----> 1 a, b = [11, 22, 33]ValueError: too many values to unpack (expected 2)

经典面试题：交换两个变量的值

方式一：普通方式

python">a = 4
b = 5
print("交换之前a=%d, b=%d" % (a, b))# 额外定义一个变量，用来临时使用
c = a
a = b
b = c
print("交换之后a=%d, b=%d" % (a, b))

运行结果：

交换之前a=4, b=5
交换之后a=5, b=4

方式二：巧妙方式

python">a = 4
b = 5
print("交换之前a=%d, b=%d" % (a, b))# 巧妙之处（没有用额外的变量）
a = a+b
b = a-b
a = a-b
print("交换之后a=%d, b=%d" % (a, b))

运行结果：

交换之前a=4, b=5
交换之后a=5, b=4

方式三：拆包方式

python">a = 4
b = 5
print("交换之前a=%d, b=%d" % (a, b))# Python独到之处
a, b = b, a  # 
print("交换之后a=%d, b=%d" % (a, b))

执行结果：

交换之前a=4, b=5
交换之后a=5, b=4

说明：

a, b = b, a首先要计算=右边b, a此时他们会被当做一个元组即(b, a)就相当于(5, 4)
然后再将a, b = (5, 4)进行计算，此时a为5，b为4

结语

以上就是关于python专题中的基础知识全部内容了，欢迎同学们在评论区讨论交流，有任何python开发、数据采集相关需求也可以后台或V加regentwan与我联系哟~