python进阶_基础篇6（元组和字典）

元组和字典

元组（tuple)

1.元组是不可变的列表

1)元素可以是任何类型的数据

tuple1 = (10, 20, 30,"abc",[1,2])
print(tuple)    # (10, 20, 30, 'abc', [1, 2])

2)列表获取元素的方法都使用于元组
tuple2 = (‘杨幂’,‘刘亦菲’,‘赵丽颖’,‘孙俪’,‘白冰’)
获取单个元素

print(tuple2[1])   #刘亦菲
print(tuple2[-1])  #白冰

3) 遍历

for x in tuple2:
    print('x',x)

for index,value in enumerate(tuple2):
    print(index,value)

4）切片

print(tuple2[::-1])
print(tuple2[1:4:2])

5)列表相关操作都适用于元组

print((1,2,3)+('a','b'))  #(1, 2, 3, 'a', 'b')
print((1,2,3)*3)     #(1, 2, 3, 1, 2, 3, 1, 2, 3)
print((1,2,3)==(1,3,2))      #False
print((1,2,3)==(1,2,3))      #True
print((100,200,300)>(100,1000))   #False
print(100 in (100,200,300))       #True
nums=(10,34,56,40,89,30)
print(max(nums))       #89
print(min(nums))        #10
print(sorted(nums))  #转换出来是列表，不支持sort
print(len(nums))       #6
print(tuple('abc'))      #('a', 'b', 'c')

6）相关方法

nums = (10,34,56,40,10,30)
print(nums.count(10))     #2
print(nums.index((34)))      #1

2.元组特有的一些方法和功能

1） 只有一个元素的元组
需要在元素后面添加一个“,”号

list1=[100]
print(type(list1))     #<class 'list'>

tuple1=(100)
print(type(tuple1))     #<class 'int'>

tuple1 = (100,)
print(type(tuple1))     #<class 'tuple'>

2)直接多个数据用逗号隔开，表示的也是一个元组（元组括号在没有歧义的情况下可以省略）

tuple2=(100,200,300)
tuple3=100,200,300
print(type(tuple3),tuple3)  #<class 'tuple'> (100, 200, 300)

3)获取元素的时候可以通过让变量的个数和元组中元素的个数保持一致，来分别获取元组中每个元素的值

point=(100,200)
x,y=point    # 100 200

point = (100,200,300)
x,y,z=point
print(x,y,z)   # 100 200 300

a,b,c=10,0,30     # 其实也是a,b,c=（10,0,30）

4）变量的个数少于元组中元素的个数，并且在一个变量前加*
先让没有*的变量依次获取元素，然后把剩下的所有元素作为一个列表返回

stu=('小明','30','男','89' ,'78' ,'100')
name,age,gender,*scores=stu
print(name,age,gender)     #小明 30 男
print(scores)   # 返回的是列表['89', '78', '100']

a,*b,c=stu     
print(a,c)      #小明 100
print(b)	#['30', '男', '89', '78']

a,*b,c,d=stu    
print(a,c,d)    #小明 78 100
print(b)        #['30', '男', '89']

字典

1.什么是字典(dict)

字典是容器型数据类型的数据，将{}作为容器的标志，里面的多个元素用逗号隔开，其中的元素必须是键值对
{键1：值1，键2：值2，键3：值3，…}
字典是可变的（支持增删改）；字典是无序的（不支持下标操作）
字典的元素：键是不可变（除了字典和列表，其他不可变类型），唯一的；
值可以是任何类型的数据，并且可以重复；
“”"

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})
dict1 = {
    10: 100,
    'abc': 200,
    (10,): 300
}
dict2 = {[10,20]:100 } # TypeError: unhashable type: 'list'  列表不能作为字典的键（可变类型),键是不可变类型
dict3 = {'name': 'huchaolin', 'name': 'fyl'}
print(dict3)   # {'name': 'fyl'}

字典举例：定义一个字典，保存一条狗的信息，包括：名字、品种、颜色、年龄

dog1 = {
    'name': '叮当',
    'var': '狮子狗',
    'color': 'white',
    'age': 10
}

2.元素的增删改查

1）查 - 获取字典的值
(1).字典[key] - 获取字典中，指定key对应的值movie(如果key不存在会报错)
(2).字典.get(key) - 获取字典中指定key对应的值（如果key不存在不会报错，返回None）
(3).字典.get(key,alt) - 获取字典中指定key对应的值（如果key不存在不会报错，返回alt）

movie1 = {
    'name': '战狼',
    'director': '吴京',
    'actor': '吴京',
    'release_time': '2015',
    'type': 'Action/War'
}
movie2 = {
    'name': '沉默的羔羊',
    'director': '乔纳森.黛米',
    'actor': '福斯特',
    'release_time': '1991',
    'type': '惊悚'
}
print(movie1['name'])  # 战狼
print(movie2['name'])  # 沉默的羔羊
#print(movie2['score'])   # KeyError: 'score'，key不存在会报错
print(movie2.get('type'))  # 惊悚
print(movie2.get('score'))  # None
print(movie2.get('score', 1.0))  # key不存在返回1.0

2)遍历字典
方法一:（推荐使用）：
for 变量 in 字典：
循环体（变量在循环体中得到的是字典的key）

for x in movie1:
   print(x, movie1[x])

方法二：效率低于方法一
for key,value in 字典.items():
循环体（循环体中key取到的是所有的键，value取到的是所有键对应的值）
“”"

for x, y in movie2.items():
    print(x, y)

2.增/改 - 添加键值对/修改键值对值

1)字典[key] = 值 - 当key不存在时，就是添加键值对，当key存在的时候，就是修改key内的值

subject = {
    'name': 'python',
    'score': 3,
    'class_hour': 20,
    'direction': ['数据分析', 'web后端', '爬虫', '自动化测试', '自动化运维']
}
subject['teacher'] = '余婷'  #添加键值对
print(subject)
subject['score'] = 4    #修改键值对
print(subject)

3.删

1）del 字典[key] - 删除字典指定key对应的键值对
2）字典.pop(key) - 取出子典中指定key对应的值
3）字典.clear()- 清空字典

del subject['class_hour']
print(subject)

del_item=subject.pop('direction')     # 可以把值取出来
print(subject)
print(del_item)

subject.clear()
print(subject)

4.相关操作

1)字典不支持加法、乘法和比较大小的运算

#print({'a':10}+{'b':20}) #unsupported operand type(s) for +: 'dict' and 'dict'
#print({'a':10}>{'b':20}) #TypeError: '>' not supported between instances of 'dict' and 'dict'

2)判断是否相等
(1)==

print({'a':10,'b':20}=={'b':20,'a':10})  #True

(2) is -判断两个数据的地址是否相等

a={'a':10}
b={'a':10}
c=a
print(id(a),id(b),id(c))
print(a==b)    #True
print(a is b)  #False
print(a is c)  #True

3)in 和 not in
key in 字典 --判断字典中是否有指定的key

dict1 = {'a':10,'b':20,'c':30}
print(10 in dict1)   #False
print('b' in dict1)   #True

4)相关函数：len，dict
len(字典) - 获取字典中键值对的个数

print(len(dict1))

dict(数据) - 将其他数据转换成字典
数据的要求：1.序列 2.序列中的元素还是序列 3.内部的序列有且只有两个元素，第一个元素为不可变类型

list1 = ['ab',(10,20),['name','张三']]
print(dict(list1))     #{'a': 'b', 10: 20, 'name': '张三'}

5)将字典转换成其他数据

stu={'name':'小明','age':18,'scores':90}

(1)将字典转换成列表/元组 - 将字典的key作为列表/元组的元素

print(list(stu))         #['name', 'age', 'scores']
print(tuple(stu))    #('name', 'age', 'scores')

(2）将字典转换成字符串

print(str(stu))

(3)将字典转换成bool

print(bool({}))      #False
print(bool(stu))     #True

5.相关方法

1）字典.clear()

stu={'name':'小明','age':18,'scores':90}
stu.clear()

2) 字典.copy()

stu={'name':'小明','age':18,'scores':90}
stu1=stu.copy()     #赋值一个相同的字典，但是地址不同

3)dict.fromkeys(序列，默认值=None) - 创建一个新的字典，序列中所有的元素会作为新字典的key，默认值是所有key对应的值

new_dict = dict.fromkeys('abc')
print(new_dict)   #{'a': None, 'b': None, 'c': None}

new_dict = dict.fromkeys(['name','age','sex'],0)
print(new_dict)

4)字典.items()、字典.keys()、字典.values()

print(stu.items())
print(stu.keys())
print(stu.values())

5)字典.setdefaule(key,value) - 在字典中添加键值对(单纯的添加键值对，不会修改)

stu={'name':'小明','age':18,'scores':90}

stu.setdefault('weight',50)       #添加键值对
stu.setdefault('name','小花')   #不会修改键‘name’所对应的值

6)字典1.update(字典2) - 将字典2中所有的键值对全部添加到字典1中

stu.update({'a':10,'b':20})
print(stu)      #{'name': '小明', 'age': 18, 'scores': 90, 'weight': 50, 'a': 10, 'b': 20}

本文地址：https://blog.csdn.net/qq_17495489/article/details/107645635