Python第8讲

元组

• 元组是不可变序列
• 元组可以使用通用操作
• 通常希望数据不改变时使用元组，其他情况用列表

创建元组方式

• 小括号 —— x = ()
• 函数 —— x = tuple([iterable]) 可迭代对象str、list
• 逗号 —— x = a，或 x = (a,) 或 x = a,b,c 或 x = (a,b,c) 元组不为空时，至少有1个逗号

元组的解包

• 解包概念 —— 指将元组当中每一个元组赋值给一个变量
• 解包时变量的数量应与元组中的元素数量保持一致。如变量小于元素时，在变量前面加星号（任意变量均可，但有且只有一个变量可以加星号），可获取剩余所有元素，并以列表形式返回。如变量大于元素会报错

> # 变量与元组数量一致
> tup = 1,2,3,4
> a,b,c,d = tup
> print ('a = ', a) # a = 1
> print ('b = ', b) # b = 2
> print ('c = ', c) # c = 3
> print ('d = ', d) # d = 4

> # 变量小于元组数量
> tup = 1,2,3,4
> a,b = tup
> '''
> File "<stdin>", line 1, in <module>
> ValueError: too many values to unpack (expected 2)
> '''
> a,b,*c = tup
> print ('a = ', a) # a = 1
> print ('b = ', b) # b = 2
> print ('c = ', c) # c = [3,4]

> # 变量大于元组数量
> tup = 1,2,3,4
> a,b,c,d,e = tup
> '''
> File "<stdin>", line 1, in <module>
> ValueError: not enough values to unpack (expected 5, got 4)'''

可变对象

• 对象保存的数据 —— id（标识），type（类型），value（值）共三个
• 可变对象指对象里面的value可以被改变

> # 列表是可变对象
> ## 改对象id内的value值操作
> a = [1,2,3]
> print ('修改前', a, id(a))
> a[2] = 30	# 通过索引修改对象里面的值
> print ('修改后', a, id(a))
> 修改前 [1, 2, 3] 2443729819008
> 修改后 [1, 2, 30] 2443729819008 # 不改变变量所指向的对象id

> ## 改对象id的值和value的值操作（俗称改变量）
> a = [1,2,3]
> print ('修改前', a, id(a))
> a = [2,3,4] # 为变量重新赋值
> print ('修改后', a, id(a))
> 修改前 [1, 2, 3] 2443729819008
> 修改后 [2, 3, 4] 2443729855104

可变对象的常用使用方法

> # 改对象id内的value值操作
> a = [1,2,3]
> b = a
> b[2] = 30
> print ('a', a, id(a))
> print ('b', b, id(b))
> a [1, 2, 30] 1714370434624
> b [1, 2, 30] 1714370434624

> # 改对象id的值和value的值操作
> a = [1,2,3]
> b = a
> b = [1,2,30]
> print ('a', a, id(a))
> print ('b', b, id(b))
> a [1, 2, 3] 2273083446848
> b [1, 2, 30] 2273083454272

==、 !=、 is、 is not 比较的内容

• == 和 != 比较的是对象的值是否相等
• is 和 is not 比较的是对象的id是否相等（比较2个对象是否是同一个对象）

> a = [1,2,3]
> b = [1,2,3]
> print (a, b)
> print ('a', a, id(a))
> print ('b', b, id(b))
> print (a == b) # True
> print (a is b) # False
> a [1,2,3] 2427924108608
> b [1,2,3] 2427924120128
> True
> False

字典

字典简介

• 概念 —— 字典属于一种数据结构，称为映射（mapping）
• 作用 —— 用来存储对象的容器
• 对比列表 —— 列表存储数据性能好，查询数据性能差。字典数据存储性能差，查询数据性能好
• 功能 —— 数据中每个元素都有唯一的名字，通过名字可以快速查找到指定的数据
• 结构 —— 字典中唯一的名字称为键（key），通过键（key）可以快速查找到值（value）。所以字典又称为键值对（key - value）结构
• 存储方法 —— 字典当中可以有多个键值对，每个键值对称为一项（item）
• 语法：{key:value, key:value,…}
  • 字典的键最好不要重复，如果重复后边的键值对会替换前面的键值对
  • 根据键获取值（变量[key]，当key值不是整型、浮点型和布尔型数据时，需使用字符串格式）

> a = {'name' : '呵呵', 'age' : '18', 'sex' : '男'}
> {'name': '呵呵', 'age': '18', 'sex': '男'}

> # 有重复的键
> a = {'name' : '呵呵', 'age' : '18', 'sex' : '男', 'age' : '20'}
> {'name': '呵呵', 'age': '20', 'sex': '男'}

> # 根据键获取值
> a = {'name' : '呵呵', 'age' : '18', 'sex' : '男'}
> print (a['name'], a['age'], a['sex'])
> 呵呵 18 男

字典的使用

使用函数创建字典 —— dict()

> # 第一种方法
> d = dict(name = '呵呵', age = 18, sex = '男'）
> print(d,type(d))
> {'name': '呵呵', 'age': 18, 'sex': '男'}  <class 'dict'>

• 双值序列 —— 序列中只有2个值
  例如：‘ab’, [1,2], (‘a’,1)
• 子序列 —— 序列中的元素也是个序列，这个元素称为子序列
  例如：[(‘a’,1), (‘b’,2)]

> # 第二种方法，将包含双值子序列的序列转换为字典
> d = dict([('name','呵呵'),('age',10),('sex','男')])
> print(d,type(d))
> {'name': '呵呵', 'age': 10, 'sex': '男'}  <class 'dict'>

字典的方法

字典的方法	含义
d.get(key[,default]	如果key在字典中则返回key的值，否则返回default。default默认为None
d.setdefault(key[,default])	如果key在字典中则返回key的值。如果key不存在，插入值为default的键key，并返回default。default默认为None。
d.keys()	返回字典中的键
d.values()	返回字典中的值
d.items()	返回字典中的键值对
d.pop(key[,default])	如果key在字典中则将其删除并返回其值，否则返回default。如果default未设置且key不在字典中则报KeyError错误
d.popitem()	从字典中删除并返回键值对。会按后进先出原则删除（通常由后往前删）
d.update([other])	使用other的键值对对字典进行更新
d[key] = value	将字典d中key键的值修改为value。如果无key值，新增新的key和value
del d[key]	将字典d中的key删除，如果映射不存在则返回KeyError错误
d.clear()	清空字典
d.copy()	返回字典的浅拷贝

• d.get()使用方法

> d = dict([('name','呵呵'),('age',10)])
> d['sex']
> '''
> File "<stdin>", line 1, in <module>
> KeyError: 'sex'
> '''

> # 使用get()方法
> d.get('sex','未找到')
> '未找到'

• 修改字典

> # 修改字典内的值
> d = dict([('name','呵呵'),('age',10)])
> d['name'] = '猫咪'
> {'name': '猫咪', 'age': 10}

> # 无key值，新增键值对
> d = dict([('name','呵呵'),('age',10)])
> d['sex'] = '男'
> {'name': '猫咪', 'age': 10, 'sex': '男'}

• d.update()使用方法

> d1 = {'name': '猫咪', 'age': 10}
> d2 =  = dict([('name','呵呵'),('age',18),('sex','男')])
> d1.update(d2)
> {'name': '呵呵', 'age': 18, 'sex': '男'}

• del删除

> d = {'name': '猫咪', 'age': 10}
> del d['name']
> {'age': 10}

• d.popitem()使用方法

> d = dict([('name','呵呵'),('age',10)])
> result = d.popitem()
> print (d, result)
> {'name' = '呵呵'}  ('age',10)

• d.pop(key[,default])使用方法(与get()方法原理一样）

> d = dict([('name','呵呵'),('age',10)])
> result = d.pop('name')
> print (d, result)
> {'name' = '呵呵'}  10

• d.clear()使用方法

> d = dict([('name','呵呵'),('age',10)])
> d.clear()
> {}

作业

1、找到字典指定值

a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
lst = list()

while isinstance(a, (dict,list,tuple)):
    if isinstance(a, dict) is True:
        for i in a.values():
           a = i
    else:
        for i in a:
            for x in i:
                lst.append(i[x])
        break 
print(lst)     

2、

a =[11,22,33,44,55,66,77,88,99,90]
dic = dict(small=None, big=None)
lst_small = list()
lst_big = list()

for i in a:
    if i > 66:
        lst_small.append(i)
    elif i < 66:
        lst_big.append(i)

dic['small'] = lst_small
dic['big'] = lst_big
print (dic)