序列 —— 元组与字典

Python 学习笔记

一、元组（tuple）

1.1、元组的简介

元组就是一个不可变的序列。（操作方式基本与列表相似，但是想给索引、切片赋值，想调用列表的方法来改变对象是不行的。）
一般情况，如果希望数据不改变时，就使用元组，其余情况都使用列表。

1.2、元组的基本操作

# 创建元组, 使用 () 创建的

my_tuple = () 								# 创建一个空的元组
print(my_tuple,type(my_tuple))



# 添加元素

my_tuple = (1,2,3,4,5)
print(my_tuple[3],type(my_tuple))

my_tuple[3] = 10							# 改变索引的值, 会报错



# 如果一个元组不是空的元组，那么它里面至少需要一个 ，

my_tuple = 10 								# my_tuple 是一个整数（int）
print(my_tuple,type(my_tuple))
my_tuple = 10, 								# my_tuple 是一个元组（tuple）
print(my_tuple,type(my_tuple))
my_tuple = 10, 20, 30, 40 					# 还是一个元组, 元组也可不加括号
print(my_tuple,type(my_tuple))

1.3、元组的解包

元组的解包： 指的是将元组当中的每一个元素都赋值给一个变量，变量的数量必须和元组中的元素要一一对应。

my_tuple = 10,20,30,40,50

a,b,c,d = my_tuple

print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)
print(my_tuple,type(my_tuple))

如果量和元素的数量不相等，则可以在变量前面加一个 *。（只能有一个 * ）
这样变量就会将获取元组中所有剩余（除对应位）的元素以 列表 的形式返回。

my_tuple = 10,20,30,40,50

*a,b,c = my_tuple 							# [10, 20, 30] 40 50
a,*b,c = my_tuple						    # 10 [20, 30, 40] 50
a,b,*c = my_tuple 							# 10 20 [30, 40, 50]
a,*b,c = [1,2,3,4,5,6,7]  					# 1 [2, 3, 4, 5, 6] 7
a,b,*c = 'python java'  					# p y ['t', 'h', 'o', 'n', ' ', 'j', 'a', 'v', 'a']
*a = my_tuple								# 报错, 语法有错误, 要先有变量存了值剩下存不了才用 *

有什么用呢？

a = 6
b = 8

b,a = a,b
print('a =',a,'b = ',b)

# 例如：交换变量的值时, 对比其他方法, 它更简洁

temp = a
a = b
b = temp
print('a =',a,'b = ',b)

---

二、可变对象

2.1、对象 与 变量的修改

a = [1,2,3]
print('修改前:',a,id(a))

# 通过索引来改变列表
a[0] = 10
print('修改后:',a,id(a))

# 为变量赋值
a = [4,5,6]
print('修改后:',a,id(a))

2.2、修改索引 与 变量赋值

一般的，对变量的赋值就是对变量的修改，其余的都是对对象的修改。

a = [1,2,3]
b = a

b[0] = 10
print('a',a,id(a))
print('b',b,id(b))

b = [10,2,3]
print('a',a,id(a))
print('b',b,id(b))

---

三、==、!=、is 和 is not

3.1、== 与 != 比较的是 对象的值 是否相等。

a = [1,2,3]
b = [1,2,3]

print(a,b)
print(id(a),id(b))

print(a == b)
print(a != b)

3.2、is 与 is not 比较的是 对象的id 是否相等（比较两个对象是否是同一个对象）

a = [1,2,3]
b = [1,2,3]

print(a,b)
print(id(a),id(b))

print(a is b)
print(a is not b)

---

四、字典

4.1、字典的简介

• 字典属于一个新的数据结构，称之为 “ 映射 ” 。
• 字典的作用，和列表差不多，都是用来存储对象的 容器 。
• 每一个元素都有一个 “ 名字（key）” ，通过 key 可以快速查找指定 元素值（value）。
  所以，字典也称之为 “ 键值对（key — value）结构 ” 。每个字典有多个键值对，每个键值对称之为 “ 一项（item）” 。
• 语法： { key:value, key:value, key:value }

4.2、字典的基本操作

# 字典的键可以是任意不可变对象(int str bool tuple...)
# 字典的值可以是任意对象

d = {'name':'钢铁侠','age':30,'sex':'男'}
print(d,type(d))


# 字典当中的键是不可以重复的，如果重复后边的会替换前边的（如, 下面的 'name'）

d = {'name':'钢铁侠','age':30,'sex':'男','name':'葫芦娃'}
print(d,type(d))


# 可以根据键来获取值

print(d['name'],d['age'],d['sex'])

4.3、字典的使用

• 1、使用 dict()函数来创建字典

d = dict(name='钢铁侠',age=30,sex='男')
print(d,type(d))

• 2、包含双值子序列的序列 转换为 字典
  双值序列： 指序列当中只有2个值，例如：列表 [1,2] ，元组 (‘b’,6) ，字符串 ‘de’
  子序列： 指如果序列当中的 元素也是序列 ，那么我们就称这个元素为 “ 子序列 ” 。 例如：[(2,3),(7,8)]
  （做爬虫时常见）： 比如，爬了一个小说网站，通过正则表达式匹配得出一个（书名，url）

d = dict([('name','钢铁侠'),('age',18)])
print(d,type(d))

• 3、获取字典中的长度 len()

d = dict(name='钢铁侠',age=30,sex='男')
print(len(d))

• 4、in 与 not in 检查字典当中是否包含指定的键

d = dict(name='钢铁侠',age=30,sex='男')

print('name' in d)
print('name' not in d)

• 5、获取字典当中的值, 根据键 (key) 来获取

# 语法  字典名[key]

d = dict(name='钢铁侠',age=30,sex='男')

print(d['name'])

w = 'name'
print(d[w])

# print(d['aa'])       						# 若 key 不存在, 则会报错
print(d.get('aa'))      					# 使用 get 方法, 则不会报错, 默认返回 None
print(d.get('aa','自定义返回值'))      		# 使用 get 方法, 则不会报错, 默认返回 None

• 6、修改字典 —— d [key] = value

d = dict(name='钢铁侠',age=30,sex='男')

d['name'] = '葫芦娃'
print(d)

d['Python'] = '葫芦娃'						# 如果 Key 值存在覆盖, 不存在就添加
print(d)

• 7、修改字典 —— setdefault ( key [ , default ] )

# 就是向字典中添加 key-value

d = dict(name='钢铁侠',age=30,sex='男')

result = d.setdefault('name','葫芦娃')		# 如果 Key 已经存在字典中, 则返回 key的值, 不会对字典做任何操作
print(result, d)

result = d.setdefault('python','葫芦娃')	# 如果 Key 不存在, 则向字典中添加这个 Key, 并设置 value
print(result, d)

• 8、修改字典 —— update()

# 将其他字典中的 key-value 添加到当前字典中

d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6}
d3 = {'d':4,'e':5,'f':6,'a':8}				# 如果有重复的 key, 则后边的会替换掉前面的

d.update(d2)
print(d)

d.update(d3)
print(d)

• 9、del d [key] 指定删除键值对

d = {'a':1,'b':2,'c':3}

del d['a']
print(d)

• 10、popitem() 随机删除键值对

# 随机删除, 一般都会删除最后一个键值对
d = {'a':1,'b':2,'c':3,'d':4,'e':5}

d.popitem() 								# {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(d)

result = d.popitem() 						# {'a': 1, 'b': 2, 'c': 3}
print(result)								# 删除之后会将删除的 key-value 作为 "元组(key, value)" 返回
print(d)

• 11、clear() 清空字典

d = {'a':1,'b':2,'c':3,'d':4,'e':5}

d.clear()
print(d)

• 12、更多可查看官网文案：
  https://docs.python.org/zh-cn/3/library/stdtypes.html#mapping-types-dict

4.4、字典的浅复制 copy()

# 复制以后的对象 和 原对象就是相互独立的, 修改一个不会影响另一个

d = {'a':1,'b':2,'c':3}

d2 = d										# 输出结果一样, 但是其指向同一个对象（id 一样）, 不是复制
d3 =d.copy()								# 输出结果一样, 其指向不同对象（id 不一样）, 是复制

d['b'] = 10									# 故, 改变 d, d2 也改变, d3 不变

print('d = ',d,id(d))
print('d2 = ',d2,id(d2))
print('d3 = ',d3,id(d3))

为什么说是 “浅复制” ？

# 只会简单复制对象内部的值，如果这个值也是一个可变对象，则这个可变对象是不会被复制的

d = {'a':{'name':'葫芦娃','age':20},'b':2,'c':3}
d2 = d.copy()

d2['b'] = 10 
d2['a']['name'] = '钢铁侠'					# 内部值是一个可变对象（字典）, 一个改变另一个也跟着改变

print('d = ',d,id(d))
print('d2 =',d2,id(d2))

											# 说明这两个对象 d, d2 的内部可变对象, 实际指向的是同一个对象
c = d['a']
c2 = d2['a']

print('c = ',c,id(c))
print('c2 =',c2,id(c2))

4.5、字典的遍历

• 1、通过 key() 来遍历

d = {'name':'钢铁侠','age':30,'sex':'男'}

for k in d.keys():							# 通过遍历keys()来获取所有的键
    print(k,d[k])

• 2、通过 values() 来遍历

d = {'name':'钢铁侠','age':30,'sex':'男'}

for v in d.values():
    print(v)			# 只能看到 '值', 看不到 '键', 所以一般不用

• 3、通过 itemss() 来遍历

# 该方法会返回字典中所有的项
# 它会返回一个序列，序列包含有双值子序列
# 双值分别是 字典中的 key 和 value

d = {'name':'钢铁侠','age':30,'sex':'男'}

print(d.items())

for k,v in d.items():
    print(k,'=',v)

---

五、练习

# 字典练习

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

b = a['data'] # {"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}

c = b['result'] # [{"src":"python1"},{"src":"python2"},{"src":"python3"}]

for i in c:
    print(i['src'])