0
点赞
收藏
分享

微信扫一扫

Python之元组 字典 集合


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之函数


举报

相关推荐

0 条评论