首页 > 编程语言 >Python之元组 字典 集合

Python之元组 字典 集合

时间：2023-05-18 12:33:06浏览次数：35  
标签：name Python 元组 葫芦娃 key print 字典 d1


Python列表

Python之元组 字典 集合

元组介绍

元组的表现形式是tuple
元组是一个不可变的序列（一般但这个数据不改变的时候，我们就采用元组，其余情况都用列表。）

  • 创建元组
    通过()创建元素
tup = ()
print(tup,type(tup))
() <class 'tuple'>
  • 添加元素
    直接在元组中添加
tup = ()
print(tup)
tup = (1,2,3,4)
print(tup)
()
(1, 2, 3, 4)
  • 通过索引访问元组中的元素值
tup = (1,2,3,4,5,6)
print(tup[3])
4
  • 注意：元组不能修改其中的值，否则会报一个TypeError
tup = (1,2,3,4,5,6)
# tup[3] = 44元组中的值不可以更改
print(tup)
(1, 2, 3, 4, 5, 6)

接下来我们看一个现象：

tup = 10
print(tup,type(tup))# 10 int型
# 如果在10后面加一个逗号
tup = 10,
print(tup,type(tup))# (10,) tuple型
10 <class 'int'>
(10,) <class 'tuple'>

如果元组不是空的，元组至少要有一个逗号

  • 特殊的用法
    元组可以不加()，但是不能没有逗号
tup = 1,2,3,4,5,
print(tup,type(tup))# (1,2,3,4,5,) tuple型
(1, 2, 3, 4, 5) <class 'tuple'>
  • 元组解包
    元组解包指的是元组中的每一个值分别赋值给变量
tup = 10,20,30,40
a,b,c,d = tup
print(a)
print(b)
print(c)
print(d)
10
20
30
40

再看一个奇怪的现象

tup = 10,20,30,40
*a,b,c = tup
print(a)
print(b)
print(c)
# 结果：a b c依次是[10,20] 30 40
a,*b,c = tup
print(a)
print(b)
print(c)
# 结果：a b c依次是10 [20,30] 40
a,b,*c = tup
print(a)
print(b)
print(c)
# 结果：a b c依次是10 20 [30,40]
[10, 20]
30
40
10
[20, 30]
40
10
20
[30, 40]

其实列表和字符串也可以这样操作

# 列表
list1 = [1,2,3,4,5]
a,b,*c = list1
print(a)
print(b)
print(c)
# 字符串
str_1 = 'python'
a,b,*c = str_1
print(a)
print(b)
print(c)
1
2
[3, 4, 5]
p
y
['t', 'h', 'o', 'n']

综上序列中都可以进行一个这样的操作

字典(键值对)

一种新的数据结构–>印射(mapping)

  • 字典的作用：
    用来存储对象的容器
  • 字典和列表的区别
    列表存储数据的性能特别好，但是查询的数据性能比较差，字典正好与之相反。这是因为字典当中每一个元素都有唯一的一个名字，通过这个为一个名字快速查找到指定的元素。
  • 唯一个名字称之为key,通过key来查询值，值称为value，键值对(key-value) 一项称之为item。
  • 语法:
    字典 = {key:value,key:value…}
    (注意：字典的key可以是任意个不可变对象，字典的value可以是任意对象。字典的key是不可以重复的，如果重复后面的会替换前面的)
d = {'name':'葫芦娃','age':20,'sex':'男'}
print(d,type(d))
d = {'name':'葫芦娃','age':20,'sex':'男','name':'钢特侠'}
print(d,type(d))
{'name': '葫芦娃', 'age': 20, 'sex': '男'} <class 'dict'>
{'name': '钢特侠', 'age': 20, 'sex': '男'} <class 'dict'>

当字典的键值对过多可以有以下这种写法：

headers = {
    'name':'葫芦娃',
    'age':20
}
  • 根据键来获取值：
d = {'name':'葫芦娃','age':20,'sex':'男'}
# 根据键来获取值
print(d['name'],d['age'],d['sex'])
葫芦娃 20 男
  • 使用dict()这个函数来创建字典
d = dict(name = '葫芦娃',age = 18,sex= '男')
print(d,type(d))
# 双值序列：序列中有两个值[3,4]
# 双值子序列：如果序列中的元素也是序列，那么我们称这个元素是子序列[(2,3),(4,5)] 
d = dict([('name','葫芦娃'),('age',19)])
print(d)
{'name': '葫芦娃', 'age': 18, 'sex': '男'} <class 'dict'>
{'name': '葫芦娃', 'age': 19}
  • len()获取键值对中的个数
d = dict(name = '葫芦娃',age = 18,sex= '男')
print(len(d))
3
  • in或者not in 检查字典中是否包含（不包含）指定的键。
d = dict(name = '葫芦娃',age = 18,sex= '男')
print('name' in d)
print('葫芦娃' in d)
print('sex' not in d)
True
False
False
  • 根据键来获取字典当中的值
    语法：dict[key]
    (注意：key一定要加上引号)
d = dict(name = '葫芦娃',age = 18,sex= '男')
print(d['age'])
18

那么什么时候可以不加引号呢？

d = dict(name = '葫芦娃',age = 18,sex= '男')
n = 'name'
print(d[n])
葫芦娃

如果key赋值给变量时，可以不加引号。

  • get()函数
    get(key[,default])该方法用来根据字典中的key来获取值，如果key不存在则返回None
d = dict(name = '葫芦娃',age = 18,sex= '男')
print(d.get('name'))
葫芦娃

也可以指定第二个参数，当这个key值不存在的时候会返回一个默认值

d = dict(name = '葫芦娃',age = 18,sex= '男')
print(d.get('n','key值不存在'))
key值不存在
  • 修改字典
d = dict(name = '葫芦娃',age = 18,sex= '男')
d['name'] = '钢特侠'# 修改键值对
print(d)
{'name': '钢特侠', 'age': 18, 'sex': '男'}
  • 添加键值对
d = dict(name = '葫芦娃',age = 18,sex= '男')
d['phone'] = 347889
print(d)
{'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}

使用setdefault(key,[,default])方法可以向字典中添加键值对：
如果key已经存在在字典中，则返回key的值，不会对字典有任何的操作

d = dict(name = '葫芦娃',age = 18,sex= '男')
d['phone'] = 347889
print(d)
d.setdefault('name','钢特侠')
r = d.setdefault('name','钢特侠')
print(d)
print(r)
{'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}
{'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}
葫芦娃

如果key不存在，则向字典中添加这个key,并设置value。

d = {'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}
d.setdefault('address','china')
print(d)
r = d.setdefault('address','china')
print(r)
{'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889, 'address': 'china'}
china

update()方法将其他的字典的键值对添加到当前的字典中
（注意： 如果有重复的key,后面的会替换掉前面的）

d1 = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6}
d1.update(d2)
print(d1)
d2 = {'d':4,'e':5,'f':6,'a':9}
d1.update(d2)
print(d1)
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  • 删除元素–>删除字典中的键值对
    通过del来删除字典中的键值对
d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d1['a']
print(d1)
{'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

通过popitem()方法随机删除字典中的键值对，但是一般都会删除最后一个。
注意：有返回值，删除之后会将删除后的键值对的元素以元组的形式进行返回，并且第一项是删除的键值对的key，第二项是删除键值对的value。

d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
print(d1)
d1.popitem()
print(d1)
r = d1.popitem()
print(r)
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
('e', 5)

通过pop()来删除键值对
pop(key[,default])
根据key来删除字典中的键值对，会将删除的value返回，如果删除一个没有的值则会进行报错。

d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
r = d1.pop('b')
print(r)
print(d1)
2
{'a': 9, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

那么如何让程序不报错呢？

d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
r = d1.pop('u','这个key值不存在')
print(r)
print(d1)
这个key值不存在
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  • 浅复制
    什么叫复制呢？先看以下代码：
d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
d2 = d1
print(d1)
print(d2)
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

上述代码算不算复制呢，所谓的复制指的是把对方的元素抄过来但是可以做一些修改，两者没关系。所以上述代码不算是复制，更谈不上是浅复制。
那么再看下列代码：

d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
d2 = d1.copy()
d1['b'] = 59907
print(d1,id(d1))
print(d2,id(d2))
{'a': 9, 'b': 59907, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2109244840840
{'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2109244840920

上述代码才是实现了复制，由此可见：复制以后的对象和原对象是独立的，修改其中的一个值不会对另一个值产生影响。

浅复制只会复制字典本身，如果字典中还有一个字典，是不会被复制的，这个值也可以是一个可变对象，这个可变对象也不会被复制。

d1 = {'a': {'name':'葫芦娃','age':89,'sex':'男'}, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
d2 = d1.copy()
d2['a']['name'] = '黑猫警长'
print(d1,id(d1))
print(d2,id(d2))
{'a': {'name': '黑猫警长', 'age': 89, 'sex': '男'}, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2752341089240
{'a': {'name': '黑猫警长', 'age': 89, 'sex': '男'}, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2752341090040
  • 遍历字典
    通过keys()遍历字典，该方法会返回字典中的所有的key
d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
print(d1.keys())
for  k in d1.keys():
    print(k)
dict_keys(['a', 'b', 'c', 'd', 'e', 'f'])
a
b
c
d
e
f

通过values()遍历字典，该方法会返回一个序列，序列中保存有字典的值

d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
print(d1.values())
for v in d1.values():
    print(v)
dict_values([9, 2, 3, 4, 5, 6])
9
2
3
4
5
6

通过items()遍历字典，该方法会返回字典中的所有项,但是所有项会以双值序列的方式进行返回。

d1 = {'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
print(d1.items())
for k,v in d1.items():
    print(k,'=',v)
dict_items([('a', 9), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6)])
a = 9
b = 2
c = 3
d = 4
e = 5
f = 6

集合

集合和列表非常相似

  • 集合和列表的不同点：
    集合只能存储区不可变的对象。
    集合中存储的对象是无序的,输出的值也是无序的。

集合不可以出现重复元素

  • 集合的创建
s = {1,2,3,4}
print(s,type(s))
{1, 2, 3, 4} <class 'set'>

如若{}中不添加值会发生什么？

s = {}
print(s,type(s))
{} <class 'dict'>

可见集合就变成了字典
如果集合中的元素在创建的时候是无序的

s = {4,6,3,8,7,'o',' ','p'}
print(s,type(s))
{'o', 3, 4, 'p', 6, 7, 8, ' '} <class 'set'>
{'o', 3, 4, 6, 7, 8, ' ', 'p'} <class 'set'>
{3, 4, 6, 7, 8, ' ', 'o', 'p'} <class 'set'>

可见在集合输出的时候也是无序的。
那么集合中如果出现多个相同的值呢？会发生什么？

s = {4,6,3,8,7,1,1,1,1,1,1}
print(s,type(s))
{1, 3, 4, 6, 7, 8} <class 'set'>

由结果可以知道多个相同的值会去除。所以集合中的值是不可以出现重复的。
通过set()函数来创建集合

s = set([9,868,8,0])
print(s,type(s))
s = set('python')
print(s,type(s))
s = set({'a':1,'b':2,'c':3})# 如果是字典则会返回字典中的key值给集合
print(s,type(s))
{8, 9, 868, 0} <class 'set'>
{'p', 't', 'n', 'y', 'o', 'h'} <class 'set'>
{'a', 'b', 'c'} <class 'set'>

集合可不可以根据索引找值？

s = {1,2,3,4,5}
print(s[0])
print(s[0])
TypeError: 'set' object is not subscriptable

会报一个TypeError，所以集合不可以通过索引找值。
那么如何通过列表找值？

s = {1,2,3,4,5}
print(list(s)[0])
1
  • 集合的使用
    len()来获取集合中元素的数量
    add()向集合中添加元素
    update()将一个集合中的元素添加到另一个集合中
    pop()随机删除集合中的一个元素，一般是删除最后一个元素
    remove()删除集合中的指定元素
    clear()清空集合
s = {4,6,3,8,7,'o',' ','p'}
print(len(s))
s.add(50)
s.add(100)
print(s)
s2 = set('python')
s.update(s2)
print(s)
r = s.pop()# 有返回值
print(s)
print(r)
s.remove(8)
print(s)
s.clear()
print(s)
8
{3, 4, 100, 6, 7, 8, 'o', 'p', 50, ' '}
{3, 4, 100, 6, 7, 8, 'h', 'o', 'n', 'p', 50, 'y', ' ', 't'}
{4, 100, 6, 7, 8, 'h', 'o', 'n', 'p', 50, 'y', ' ', 't'}
3
{4, 100, 6, 7, 'h', 'o', 'n', 'p', 50, 'y', ' ', 't'}
set()
  • 集合的运算
    &交集运算
    |并集运算
    -差级运算
    ^亦或集

<=检查一个集合是否是另一个集合的子集
<检查一个集合是否是另一个集合的真子集
>= 检查一个集合是否是另一个集合的超集
*>*检查一个集合是否是另一个集合的真超集

# & 交集运算
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result = s1 & s2
print(s1,s2,result)
# | 并集运算
result = s1 | s2
print(s1,s2,result)
# - 差集运算
result = s1 - s2
print(s1,s2,result)
result = s2 - s1
print(s1,s2,result)
# ^ 亦或集:两个集合中不相交的部分
result = s1 ^ s2
print(s1,s2,result)
# <=检查一个集合是否是另一个集合的子集，另一个集合就是这个集合的超集
# <检查一个集合是否是另一个集合的真子集，另一个集合就是这个集合的真超集
# >= 检查一个集合是否是另一个结合的超集
# # > 检查一个集合是否是另一个集合的真超集
a = {1,2,3,4,5}
b = {1,2,3,4,5}
result = a <= b# a是b的子集，b是a的超集
print(result)
a = {1,2,3}
b = {1,2,3,4,5}
result  = a < b# a是b的真子集，b是a的真超集
print(result)
{1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {3, 4, 5}
{1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {1, 2}
{1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {6, 7}
{1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {1, 2, 6, 7}
True
True

可变对象

每个对象当中都保存了3个数据 id(标识) type(类型) value(值)
列表是一个可变的对象
a = [1,2,3]
指向的对象
a[0] = 10(改对象 改对像里面的值)
这个操作是通过变量来修改对象里面的值，不会改变变量指向的对象
a = [4,5,6]
这个操作是在给变量重新赋值，会改变变量

# 可变对象
a = [1,2,3]
print('修改前：',a,id(a))
# 通过索引来修改列表
a[0] = 10
print('修改后：',a,id(a))
# 为变量重新赋值
a = [4,5,6]
print('修改后：',a,id(a))
a = [1,2,3]
b = a
b[0] = 10
print('a = ',a,id(a))
print('b = ',b,id(b))
a = [1,2,3]
b = a
b = [20,2,3]
print('a = ',a,id(a))
print('b = ',b,id(b))
修改前： [1, 2, 3] 2262078280264
修改后： [10, 2, 3] 2262078280264
修改后： [4, 5, 6] 2262083237384
a =  [10, 2, 3] 2262078280264
b =  [10, 2, 3] 2262078280264
a =  [1, 2, 3] 2262083237384
b =  [20, 2, 3] 2262078280264

现在有一个字典
a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{‘src’:“python2”},{“src”:“python3”}]}}中找到python1和python2和python3

a = {"name":"123","data":{"result":[{"src":"python1"},{'src':"python2"},{"src":"python3"}]}}
b = a["data"]
c = b["result"]
for i in c:
    print(i["src"])
python1
python2
python3

有如下值的列表[11,22,33,44,55,66,77,88,99,90]将所有大于66的值保存到字典的第一个key的值中，将小于66的值保存至第二个key的值中

lst = [11,22,33,44,55,66,77,88,99,90]
dic = {}
n = []# 大于66的元素
m = []# 小于66的元素
for i in lst:
    if i > 66:
        n.append(i)
    else:
        m.append(i)
#print(m,n)
dic.update(k1 = n,k2 = m)
print(dic)
{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}

python之函数


标签：name,Python,元组,葫芦娃,key,print,字典,d1
From： https://blog.51cto.com/u_15016660/6296707

相关文章

  • Python之函数
    python元组，字典，集合Python之函数函数的简介函数也是一个对象函数可以用来保存可执行的代码，并且可以在需要是，对这些语句进行多次调用创建函数语法：>def函数名(形参1，形参2......):>代码块注意：函数名必须符合标识符的命名规范(可以包含字母、数字、下划线但是不......
  • python之基本数据类型
    搭建python环境python中的基本数据类型:1.表达式1.1表达式的概念：1.1.1表达式，是由数字、算符、数字分组符号(括号)、自由变量和约束变量等以求得数值的有意义排列方法所得的组合1.2表达式的特点：1.2.1表达式一般仅仅用于计算一些结果，不会对程序产生实质性的影响1.2.2如果在交互模式......
  • python之列表
    python条件控制语句python之列表序列：一种数据结构指计算机中数据的存储方式有顺序通过索引加以操作序列的分类：可变的序列列表不可变的序列字符串列表列表的概念：是python中的一种对象,可以保存多个有序的数据。注意：索引是从零开始的，依次向下类推,并且每一个元素之间要用逗号......
  • Python之计算机要点
    Python之计算机要点:1.计算机的概念：计算机俗称电脑，是现代用于高速计算的机器特点：数值计算存储记忆功能逻辑计算总结：能够按照程序运行、自动、高速处理数据的现代化智能电子设备计算机的组成：硬件+软件软件：就是一系列按照特定顺序组织的计算机数据和特定指令的集合2.计算机语言:......
  • python之字符串和运算符
    python基本数据类型python之字符串和运算符字符串格式化字符串print(6+6)print('6'+'6')print('jerr'+'y')#print(6+'6')两个不同类型的相加会报一个类型错误1266jerry拼串s='hello'print('s='+s)用+号来进行拼串s=hello传递参数s=......
  • python之条件控制语句
    python字符串和运算符python之条件控制语句if语句：语法格式：if条件表达式：代码块ifFalse:print('hello')#默认情况下，if语句只会控制紧跟其后的那条语句print('hello')ifFalse: #代码块：是一种代码分组的机制，是一个整体，要么就都执行，要么就都不执行，代码块以缩进开始，直到代码恢复......
  • < Python全景系列-4 > 史上最全文件类型读写库大盘点！什么？还包括音频、视频？
    欢迎来到我们的系列博客《Python全景系列》！在这个系列中，我们将带领你从Python的基础知识开始，一步步深入到高级话题，帮助你掌握这门强大而灵活的编程语言！本文系列第四篇，介绍史上最全PYTHON文件类型读写库大盘点！包含常用和不常用的大量文件格式！文本、音频、视频应有尽有！废话不多说！......
  • python 线程池使用
    代码应用场景：需要对数据库中的数据进行批量查询，然后将查询到的结果每条分别写入不同的文本文件中。由于数据数量较多，考虑使用线程池减少时间开销。#核心代码逻辑importpymysqlfromdbutils.pooled_dbimportPooledDBimportthreadingclassprocessing:def__init__(s......
  • python 性能测试之获取app fps
    一、功能描述该脚本主要是获取视频/语音通话、语音房、看视频等app的fps 二、代码实现importos,csvimporttimeimportnumpyasnpfrommatplotlibimportpyplotaspltfromsubprocessimportPopen,PIPEfromcheck_packageimportcheck_packageimportmath......
  • python基础学习-发送邮件
    importsmtplibfromemail.headerimportHeaderfromemail.mime.multipartimportMIMEMultipartfromemail.mime.textimportMIMEText"""发送普通邮件"""#创建邮件主体对象email=MIMEMultipart()#设置发件人、收件人和主题email['From']=&#......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99