Python中的元组、字典和集合的基本使用

  • 元组的使用
  • 字典的基本使用
  • 集合的使用
  • 转换相关
  • 通用方法

元组

Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。

1
2
tuple01 = ('Ann','12','54')
tuple01
('Ann', '12', '54')

一、访问元组

1
2
print(tuple01[0])
tuple01[2]
Ann

'54'

二、修改元组

说明: python中不允许修改元组的数据,包括不能删除其中的元素。

1
tuple01[2] = 'hello'
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-5-1042e2b00a9e> in <module>
----> 1 tuple01[2] = 'hello'


TypeError: 'tuple' object does not support item assignment

三、count、index

count 和 index 的使用和列表和字符串的使用相同

1
tuple01.index('12',0,1) # 注意是左闭右开
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-6-aa1ced3c9594> in <module>
----> 1 tuple01.index('12',0,1) # 注意是左闭右开


ValueError: tuple.index(x): x not in tuple
1
tuple01.index('12',0,2)
1
1
tuple01.index('54',2,3)
2
1
tuple01.count('12')
1
1
tuple01.count('54')
1

四、定义只有 一个数据的元组

需要 在唯一的元素后面加一个逗号

1
2
tuple02 = (2)
type(tuple02)
int
1
2
tuple02 = (2,)
type(tuple02)
tuple

五、交换2个变量的值

1、使用中间变量

1
2
3
4
5
6
7
a = 12
b = 15
tmp = a
a = b
b = tmp
print(a)
print(b)
15
12

2、直接交换

1
2
a, b = 6, 8
print(a,b)
6 8
1
2
b, a = a, b
print(a,b)
8 6

字典

  • 列表的缺点:当存储的数据要动态添加、删除的时候,我们一般使用列表,但是列表有时会遇到一些麻烦。
  • 有没有方法,既能存储多个数据,还能在访问元素的很方便就能够定位到需要的那个元素呢?答:字典

一、字典的使用

定义字典的格式:{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}

1
2
3
userinfo = {'id':10001,'name':'Mike','adress':'中国深圳'}
print(userinfo)
print(type(userinfo))
{'id': 10001, 'name': 'Mike', 'adress': '中国深圳'}
<class 'dict'>

说明:

  • 字典和列表一样,也能够存储多个数据
  • 列表中找某个元素时,是根据下标进行的;字典中找某个元素时,是根据’名字’(就是冒号:前面的那个值,例如上面代码中的’name’、’id’、’adress’)
  • 字典的每个元素由2部分组成,键:值。例如 ‘name’:’Mike’ ,’name’为键,’Mike’为值
  • 键可以使用数字、布尔值、元组等不可变数据类型,但是一般习惯使用字符串
  • 每个字典里的key都是唯一的,如果出现了多个key,后面的value会覆盖前一个key对应的value.

在习惯上:

  • 列表更适合保存多个商品、多个姓名、多个时间,这样的相似数据;
  • 字典更适合保存一个商品的不同信息、一个人的不同信息,这样的不同数据。

二、字典的增删改查

1、查看元素

可以使用key查询,也可以使用get获取数据

1
userinfo['name']
'Mike'
1
userinfo.get('name')
'Mike'
2、修改元素

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

1
userinfo
{'id': 10001, 'name': 'Mike', 'adress': '中国深圳'}
1
2
userinfo['adress'] = "亚洲中国深圳"
userinfo
{'id': 10001, 'name': 'Mike', 'adress': '亚洲中国深圳'}
3、添加元素

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

1
userinfo
{'id': 10001, 'name': 'Mike', 'adress': '亚洲中国深圳'}
1
2
userinfo['sex'] = '男'
userinfo
{'id': 10001, 'name': 'Mike', 'adress': '亚洲中国深圳', 'sex': '男'}
4、删除元素

对字典进行删除操作,有一下几种:

  • del
  • clear()
del

del是Python语句,而不是列表方法。因此无法通过list.来调用。使用del可以删除一个元素,当元素删除之后,位于它后面的元素会自动移动填补空出来的位置。

记住,del删除的是变量,而非数据对象。

1
2
3
4
5
6
7
info = {'name':'monitor', 'id':100}
print('删除前,%s'%info)
del info['name'] # del 可以通过键删除字典里的指定元素
print(info)

del info # del 也可以直接删除变量
print('删除后,%s'%info)
删除前,{'name': 'monitor', 'id': 100}
{'id': 100}

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-25-7b3445fe9d8a> in <module>
      5 
      6 del info  # del 也可以直接删除变量
----> 7 print('删除后,%s'%info)


NameError: name 'info' is not defined
clear

clear()方法是用来清除字典中的所有数据,因为是原地操作,所以返回None(也可以理解为没有返回值)

1
2
3
4
info = {'name':'monitor', 'id':100}
print(info)
info.clear()
print(info)
{'name': 'monitor', 'id': 100}
{}

三、字典的遍历

1、遍历字典中的key键
1
userinfob
{'id': 10001, 'name': 'Mike', 'adress': '亚洲中国深圳', 'sex': '男'}
1
userinfo.keys()
dict_keys(['id', 'name', 'adress', 'sex'])
1
2
for key in userinfo.keys():
print(key)
id
name
adress
sex
2、遍历字典中的value值
1
userinfo.values()
dict_values([10001, 'Mike', '亚洲中国深圳', '男'])
1
2
for value in userinfo.values():
print(value)
10001
Mike
亚洲中国深圳
男
3、遍历字典中的项
1
userinfo.items()
dict_items([('id', 10001), ('name', 'Mike'), ('adress', '亚洲中国深圳'), ('sex', '男')])
1
2
for item in userinfo.items():
print(item)
('id', 10001)
('name', 'Mike')
('adress', '亚洲中国深圳')
('sex', '男')
4、遍历字典中的key-value值(键值对)
1
2
for key,value in userinfo.items():
print("key=%s, value=%s"%(key,value))
key=id, value=10001
key=name, value=Mike
key=adress, value=亚洲中国深圳
key=sex, value=男

集合的使用

  • 集合(set)是一个无序的不重复元素序列
  • 可以使用大括号 { } 或者 set() 函数创建集合。

注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

创建格式:

parame = {value01,value02,…}

或者

set(value)

一、添加元素

格式:s.add(x)

  • 如果元素已存在,则不进行任何操作。
  • 还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式:s.update( x ),x 可以有多个,用逗号分开。
1
2
3
4
5
6
s1 = {'Ann','1212','hello'}
s2 = set(('jindong','taobao','pdd'))
print(s1)
print(s2)
print(type(s1))
print(type(s2))
{'hello', 'Ann', '1212'}
{'jindong', 'taobao', 'pdd'}
<class 'set'>
<class 'set'>
1
2
s1.add('Ann')
s1
{'1212', 'Ann', 'hello'}
1
2
s1.add('Mark')
s1
{'1212', 'Ann', 'Mark', 'hello'}
1
2
s1.update(('Kim','Mario'))
s1
{'1212', 'Ann', 'Kim', 'Mario', 'Mark', 'hello'}

2、移除元素

  • s.remove( x ),将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
  • s.discard( x ),也是移除集合中的元素,且如果元素不存在,不会发生错误。
  • s.pop(),也可以设置随机删除集合中的一个元素
1
2
print(s1)
print(s2)
{'Ann', '1212', 'Kim', 'Mark', 'hello', 'Mario'}
{'jindong', 'taobao', 'pdd'}
1
2
s1.remove('1212')
s1
{'Ann', 'Kim', 'Mario', 'Mark', 'hello'}
1
2
s1.remove('ann')
s1
---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-64-4821ddceea00> in <module>
----> 1 s1.remove('ann')
      2 s1


KeyError: 'ann'
1
2
s1.discard('hello')
s1
{'Ann', 'Kim', 'Mario', 'Mark'}
1
2
s1.discard('hello') # discard 元素不存在时不发生错误
s1
{'Ann', 'Kim', 'Mario', 'Mark'}
1
2
3
x = s1.pop()
print(x)
print(s1)
Ann
{'Kim', 'Mark', 'Mario'}

set常见方法列表

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

练习

有一个无序且元素数据重复的列表nums, nums=[5,8,7,6,4,1,3,5,1,8,4],要求对这个列表里的元素去重,并进行降序排序。

1
2
3
4
5
6
7
# 方法一
nums=[5,8,7,6,4,1,3,5,1,8,4]
nums2 = list(set(nums))
print(nums2)
nums2.sort(reverse=True)
print(nums2)

[1, 3, 4, 5, 6, 7, 8]
[8, 7, 6, 5, 4, 3, 1]
1
2
3
4
5
6
# 方法二
nums=[5,8,7,6,4,1,3,5,1,8,4]
nums2 = list(set(nums))
print(nums2)
nums3 = sorted(nums2,reverse=True)
nums3
[1, 3, 4, 5, 6, 7, 8]

[8, 7, 6, 5, 4, 3, 1]

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别:

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

转换相关

一、执行字符串

使用Python内置的eval函数,可以执行字符串里的Python代码。使用这种方式,可以将字符串转换成为其他类型的数据。

1
2
x = '1 + 1'
print(eval(x))
2
1
2
3
4
y = '{"name":"zhangsan","age":18}'
print(eval(y))
print(type(y))
print(type(eval(y)))
{'name': 'zhangsan', 'age': 18}
<class 'str'>
<class 'dict'>

二、转换成为字符串

json是一种轻量级的数据交换格式,采用完全独立于编程语言的文本格式来存储和表示数据。JSON本质是一个字符串
JSON的功能强大,使用场景也非常的广,目前我们只介绍如何使用Python的内置JSON模块,实现字典、列表或者元组与字符串之间的相互转换。

  • 使用json的dumps方法,可以将字典、列表或者元组转换成为字符串。
  • 使用json的loads方法,可以将格式正确的字符串转换成为字典、列表。
1
2
import json
userinfo
{'id': 10001, 'name': 'Mike', 'adress': '亚洲中国深圳', 'sex': '男'}
转为json字符串
1
2
3
x = json.dumps(userinfo)
print(x)
print(type(x))
{"id": 10001, "name": "Mike", "adress": "\u4e9a\u6d32\u4e2d\u56fd\u6df1\u5733", "sex": "\u7537"}
<class 'str'>
1
2
3
4
nums = [1, 9, 0, 4, 7]
y = json.dumps(nums)
print(y)
print(type(y))
[1, 9, 0, 4, 7]
<class 'str'>
1
2
3
4
words = ('hello','good','yes')
z = json.dumps(words)
print(z)
print(type(z))
["hello", "good", "yes"]
<class 'str'>
loads 方法将格式正确的字符串转换成为字典、列表。
1
2
3
4
5
info = '{"id": 10001, "name": "Mike", "adress": "\u4e9a\u6d32\u4e2d\u56fd\u6df1\u5733", "sex": "\u7537"}'
print(type(info))
info1 = json.loads(info)
print(info1)
print(type(info1))
<class 'str'>
{'id': 10001, 'name': 'Mike', 'adress': '亚洲中国深圳', 'sex': '男'}
<class 'dict'>
1
2
3
4
5
y1 = '[1, 9, 0, 4, 7]'
print(type(y1))
y2 = json.loads(y1)
print(y2)
print(type(y2))
<class 'str'>
[1, 9, 0, 4, 7]
<class 'list'>

通用方法

字符串、列表、元组、字典和集合,它们有很多相同点,都是由多个元素组合成的一个可迭代对象,它们都有一些可以共同使用的方法。

算术运算符

在Python里,常见的算数运算符,有一些可以使用于可迭代对象,它们执行的结果也稍有区别。

运算符 Python 表达式 结果 描述 支持的数据类型
+ [1, 2] + [3, 4] [1, 2, 3, 4] 合并 字符串、列表、元组
- {1,2,3,4} - {2,3} {1,4} 集合求差集 集合
* [‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 复制 字符串、列表、元组
in 3 in (1, 2, 3) True 元素是否存在 字符串、列表、元组、字典
not in 4 not in (1, 2, 3) True 元素是否不存在 字符串、列表、元组、字典
+

加法运算符可以用于字符串、列表和元组,用来拼接多个可迭代对象,不能用于字典和集合(思考:为什么字典和集合不能使用)。

1
"hello " + "world"
'hello world'
1
[1, 2] + [3, 4]
[1, 2, 3, 4]
1
('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')
-

只能用于集合,用于求2个集合的差集

1
{1, 6, 9, 10, 12, 3} - {4, 8, 2, 1, 3}
{6, 9, 10, 12}
*

加法运算符可以用于字符串、列表和元组,用来将可迭代对象重复多次,同样不能用于字典和集合。

1
'ab' * 4
'abababab'
1
[1,2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
1
('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
in 和 not in

in和not in成员运算符可以用于所有的可迭代对象。但是需要注意的是,in 和 not in 在对字典进行判断时,是查看指定的key是否存在,而不是value.

1
'hel' in 'hello word'
True
1
3 in [1,2]
False
1
2 not in [1, 2]
False
1
'name' in {'id':'1001','name':'Ann'}
True
1
'Ann' in {'id':'1001','name':'Ann'} # 判断的是key而非value
False

遍历

通过for … in … 我们可以遍历字符串、列表、元组、字典、集合等可迭代对象。

字符串遍历
1
2
3
a_str = "hello world"
for char in a_str:
print(char,end=' ')
h e l l o   w o r l d 
列表遍历
1
2
3
a_list = [1, 2, 3, 4, 5]
for a in a_list:
print(a,end=' ')
1 2 3 4 5 
元组遍历
1
2
3
a_tuple = (1, 2, 3, 4, 5)
for t in a_tuple:
print(t,end=' ')
1 2 3 4 5 
带下标的遍历

可迭代对象都可以使用 enumerate 内置类进行包装成一个 enumerate 对象。对enumerate进行遍历,可以同时得到一个可迭代对象的下标和元素。

1
2
3
nums = [12, 9, 8, 5, 4, 7, 3, 6]
for i,num in enumerate(nums):
print(i,num)
0 12
1 9
2 8
3 5
4 4
5 7
6 3
7 6

Python中的元组、字典和集合的基本使用

http://fahsa.cn/python/test-tuple/

作者

Fahsa

发布于

2021-01-08

更新于

2021-01-08

许可协议

评论