元组和字典

时间 2019-11-19

标签字典繁體版

原文原文链接

学习目录纲要

 1 元组tuple
 2     元组是不可变的序列容器
 3 序列的运算:
 4     + * += *=
 5     < <= > >= == !=
 6     in not in
 7     索引和切片
 8 字典dict
 9 键————值：
10 键不能重复，　且只能用不可变类型做为字典的键
11 字典[键]　= 值＃添加和修改键－值对
12 del 字典[键]
13 {1:100, 2:200}
14 
15 字典的运算
16     键索引
17     字典[键]　＝　value
18     var = 字典[键]
19     in, not in 对键
20 
21 字典推导式
22 {键表达式：值表达式　for 变量 in 可迭代对象　if 真值表达式　for 变量２　}
23 l = [1, 3, 4, 5, 8, 64, 564, 84, 51, 75, 61]
24 d = {k:None for k in l }
25 8 in l
26 
27 可变的容器
28 列表　字典　集合　字节数组

学习知识点

元组　tuple

容器类，元组是不可变的序列，同list同样，元组能够存听任意类型的数据的容器　数组

''字符串　[]列表　　()元组app

元组的表示方法：
用小括号(), 单个元素括起来后用逗号(,)区分单个对象仍是元组
建立空元组的字面值：
t = () 空元组
建立非空元组的字面值表示：
t = 200,
t = (20,)
t = (200)＃整数，提升优先级
t = (1, 2, 3)
t = 100, 200, 300ide

＃查看类型type(t)用来返回t对应的类型
元组的错误
t = (20) #t绑定20这个对象，　不是元组
x, y, z = (100, 200, 300) #序列赋值
x, y, z = 100, 200, 300 #序列赋值
x, y, z　= [100, 200, 300] #序列赋值
x, y, z = "ABC" #序列赋值函数

元组的构造（函数）tuple
tuple() 生成一个空元组，　等同于()
tuple(iterable)用可迭代对象生成一个元组学习

例：
t = tuple() #等同于t = ()
t = tuple(range(1, 10, 3))#t = (1, 4, 7)
t = tuple("ABC")
t = tuple([1, 2, 3 # t = (1, 2, 3)测试

容器都是可迭代的
t = tuple(range(1, 10, 3))
for x in t:
print(x)
　
元组的运算
+ += * *=
< <= >= > == !=
in not in
索引[ 切片[:]/[::]

+ 拼接元组
* 生成重复的元组ui

>>> t = 1, 2, 3
>>> id(t)
140516944054456
>>> t +=('abc',)
>>> t
(1, 2, 3, 'abc')
>>> t += ('A', 'B', 'C')
>>> t
(1, 2, 3, 'abc', 'A', 'B', 'C')
>>> id(t)
140516936989608
>>> t = (1, 2, 3)
>>> t *=2
>>> tspa

>>> (1, 2, 3) < (1, 3, 2)
True
>>> 2 in (1, 2, 3)
True
>>> 2 not in(1, 2, 3)
False3d

>>> t = tuple(range(1, 10))
>>> t
(1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> t[1]
2
>>> t[::2]
(1, 3, 5, 7, 9)
>>> t[1] = 2.2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignmentcode

元祖的比较运算与列表彻底相同
in / not in 运算符与列表彻底相同
索引取值和切片取值的规则彻底相同
元组不支持索引赋值和切片赋值（由于元组不可被改变）

元组的方法：
T.index(v[, begin[, end]])
返回对应元素的索引下标
T.count(x)
返回元组中对应的元素个数
详见：>>> help(tuple)

序列的种类：
　字符串　str ,列表　list ,　元组　tuple,
字节串　bytes ,字节数组bytearray

序列相关的函数总结：
len(x), max(x), min(x),
sum(x), any(x), all(x)

构造函数：
str(obj) 将对象转为字符串
list(iterable)　　将可迭代对象转为列表
tuple(iterable) ..............元组

示例：
t= (4,8,6,2,7)
L = [x for x in reversed(t)]
# t= [7,2,6,8,4] # 原来前后顺序的反向
for x in reversed(t):
print(x) # 打印：7 2 6 8 4
L2 =sorted(t) # L2=[2,4,6,7,8]
L3=sorted(t,reverse=True)
# [8,7,6,4,2]

>>> for x in reversed("ABCD"):
... print(x)
...
D
C
B
A

>>> L = [4, 8, 6, 2, 7]#列表
>>> L.sort()
>>> L
[2, 4, 6, 7, 8]
>>> t = [4, 8, 6, 2, 7]#元组
>>> sorted(t)
[2, 4, 6, 7, 8]
>>> sorted(t, reverse=True)
[8, 7, 6, 4, 2]
>>> sorted("wold")
['d', 'l', 'o', 'w']

容器小结：
字符串str #不能变的序列，　只能存字符
列表list　　　#可变的序列，　能够存任意数据
元组tuple　　　#不可变序列，　能够存任意数据

字典 dict

字典是一种可变的容器，　能够存储任意类型的数据
字典中的每一个数据都是用‘键’（key)进行索引，　而不像序列能够用整数下标来进行索引
字典中的数据没有前后关系，　字典的储存是无序的
字典中的数据以键(key)-值(value)对形式进行映射存储
字典的键不能重复，　且只能用不可变类型做为字典的键

字典的字面值表示方式：
　　字典的表示方式是以{} 括起来　，以冒号(:) 　　　分隔键-值对，各键-值对用逗号(,)分隔开

建立空字典的字面值　
　d={}　　 # 空字典

建立非空字典
d={'name':{tarena},'age':15}
d={1:'星期一',2:'星期二',3:'three'}
d={'国籍':'中国'}
d={1:[1,2,3],'abc':(1.1,2.2,3.3s)}
d={123:list('123')}
d={'a':{'b':200,'c':[1,2,3]}}
d={(1970,1,1):'computer year'}
　　如下写法会出错（由于键不能重复）
d={'a':1,'b':2,'a':'一'}

建立非字典的字面值：
d= {'name': 'songzihong', 'aea':19}
d = {1:'one', 2: 'two', 3:'three'}
>>> d = {1:'one', 2: 'two', 3:'three'}
>>> d
{1: 'one', 2: 'two', 3: 'three'}
>>> len(d)
3

d = {'国籍': '中国'}
d = {1: [1, 2, 3], 'abc': (1.1, 2.2, 2.3)}
>>> d = {1: [1, 2, 3], 'abc': (1.1, 2.2, 2.3)}
>>> len(d)
2
d

d = {123: list("123")}
d = {'a': {'b': 200, 'c': [1, 2, 3]}}

>>> d = {'a': {'b': 200, 'c': [1, 2, 3]}}
>>> len(d)
1

d = {(1970, 1, 1): 'computer year'}

字典的构造函数dict
dict() 生成一个字的字典　　等同于{}
dict(iterable) 用可迭代对象初始化一个字典
dict(**kwargs) 用关键字

>>> d = dict(name='宋梓鸿')
>>> d
{'name': '宋梓鸿'}

>>> d = dict(([1, 2], "AB"))
>>> d
{1: 2, 'A': 'B'}ｄｉｃｔ

>>> d = dict(("AB", "CD"))
>>> d
{'A': 'B', 'C': 'D'}

>>> d = {'name':'tarena', 'age':15}
>>> d
{'age': 15, 'name': 'tarena'}
>>> d = dict(name= 'tarena', age=15)
>>> d
{'age': 15, 'name': 'tarena'}
>>> print( d['age'])
15
>>> print(d ['name'])
tarena

字典的键(key)必须为不可变类型
bool int float complex str tuple
frozenset bytes(后面再讲)

字典的基本操做：
　　字典的键索引
　　　用[]运算符能够获取和修改键所对应的值
　语法：
　　字典[键]
示例：
　　d={'name':'tarena','age':15}
print('姓名:',d['name'], '年龄：':d['age'])

添加/修改字典的元素
字典[键]＝值

d={}
d['name']='tarena'

字典的值(value)　可使任意类型（不可作键）
可变的数据类型四种：
list列表
dict字典
ser集合
bytearray字节数组
其余不可变的可作键

字典的基本操做：
字典的键索引
用[]运算符能够获取字典里的'键'对应的值，也能够用[]运算符来修改＇键＇对应的值
键索引的语法：
字典［键］
例
>>> d = {'name':'tarena', 'age':15}
>>> print('姓名是:', d['name'], '的年龄是:':d['age'])

字典的增删改

添加/修改字典的元素
字典[键]＝值

d={}
d['name']='tarena'

键索引赋值说明：
　当键不存在时，建立键并绑定键对应的值
　当键存在时，修改键绑定的对象

说明
>>> d = {}
>>> d['name'] ='tarena'
>>> d
{'name': 'tarena'}
>>> d[0] = 100
>>> d
{0: 100, 'name': 'tarena'}
>>> d ['age'] = 15
>>> d
{0: 100, 'age': 15, 'name': 'tarena'}
>>> d['age'] = 16
>>> d
{0: 100, 'age': 16, 'name': 'tarena'}
>>> d['age'] +=1
>>> d
{0: 100, 'age': 17, 'name': 'tarena'}

赋值运算左边
变量 =
列表[100]=
字典[键］　

删除字典元素
del 字典[键]
例：
d = {'name':'tarena', 'age':15}
del d['name']
>>> d = {'name':'tarena', 'age':15}
>>> del d['name']
>>> d
{'age': 15}
>>> del d['age']
>>> d
{}

字典的成员资格判断in 运算符
能够用in 运算符判断一个键是否存在于字典中，　若是'键'在则返回True，　不然返回False
不判断值
not in与in

示例：
　d={1:'a',2:'b','三':'c'}
1 in d # True
'三'　in d # True

>>> d = {'name':'tarena', 'age':15}
>>> 'tarena' in d
False
>>> 'name' in d
True
>>> 'age' not in d
False

１．）
写程序，将下数据造成一个字典seasons:
'键’ '值''
１ '春季有１，　２，　３月'
２ '夏季有４，　５，　６月'
３ ’秋季有７，　８，　９月‘
４ ’冬季有10, 11, 12月‘

月份季节显示

２．）
让用户输入一个整数，　表明一个季度，　打印这个季度对应的信息，　若是用户输入的信息不在字典内，　则打印信息不存在

 1 seasons = {'1':'春季有１，　２，　３月',     #1
 2            '2': '夏季有４，　５，　６月',    #2
 3            '3': '秋季有７，　８，　９月',    #3
 4            '4': '冬季有10, 11, 12月'     #4
 5            }
 6 n = input("请输入一个：")#或 n = int(input("请输入整数："))
 7 if n in seasons:
 8     print(seasons[n])
 9 else:
10     print(信息不存在)

季节对应月份显示

字典的迭代访问：
　　字典是可迭代对象，字典只能对键进行迭代访问

例：
d = {'name':'tarena', 'age':15}
for k in d:
print(k, '对应的值是:', d[k])

>>> d = {'name':'tarena', 'age':15}
>>> for x in d:
... print(x)
...
age
name

能够用于字典的内键(built-in)函数
len(x) 　　返回字典的键值对的个数
man(x)　　返回字典的键的最大值
min(x)　　返回字典的键的最小值
sum(x)　　返回字典的键的和
any(x)　真值测试，若是字典中的一个键为真，则结果为真True
all(x)　　　真值测试，若是字典中全部键为真，则结果才为真

例：
d= {0:'零', 5:'伍'，８:'捌', 3:'叁'}
print(len(d)) # 4
print(max(d)) # 8
print(min(d)) # 0
print(sum(d)) # 16
print(any(d)) # True
print(all(d)) # False

字典的方法
函数说明
D表明字典对象
D.clear() 清空字典
D.pop(key) 移除键，同时返回此键所对应的值
D.copy() 返回字典D的副本,只复制一层(浅拷贝)
D.update(D2) 将字典 D2 合并到D中，若是键相同，则此键的值取D2的值做为新值
D.get(key, default) 返回键key所对应的值,若是没有此键，则返回default
D.keys() 返回可迭代的 dict_keys 集合对象
D.values() 返回可迭代的 dict_values 值对象
D.items() 返回可迭代的 dict_items 对象

例子：

>>> d1 = {1:'one', 2:'二', 3:'三'}
>>> d1.get(4)
>>> d1.get(3)
'三'
>>> d1.get(3, '不存在此键')
'三'
>>> d1.get(100, '不存在此键')
'不存在此键'

>>> for v in d1.values():
... print(v)
...
one
二
三

>>> for t in d1.items():
... print(t)
...
(1, 'one')
(2, '二')
(3, '三')

>>> d1
{1: 'one', 2: '二', 3: '三'}
>>> for k, v in d1.items():
... print('键:', k, '值:', v)
...
键: 1 值: one
键: 2 值: 二
键: 3 值: 三

练习：
输入一段字符串，　打印出这个字符串中出现过的字符的出现次数
如：
输入：abcdabcaba
打印： a: 4次
　 b:3次
d:１次
c:２次

 1 s = input("请输入：")
 2 d = {}#建立字典保存字符的个数
 3 for ch in s:
 4     #先判断这个字符之前是否出现过
 5     if ch not in d:#第一次出现
 6         d [ch] = 1#将出现次数设置为１
 7     else:#不是第一次出现
 8         d[ch] +=1
 9 for k in d:
10     print(k, ':', d[k], '次')

单类字符数目计算

字典推导式

　　字典推导式是用可迭代的对象依次生成字典的表达式

语法：
{键表达式：值表达式　for 变量　in 可迭代对象　if 真值表达式}
－－－－－比较列表表达式
说明：
if 子句部分可省略
例：
生成一个字典，键为１－９的整数，值为键的平方
d= {x : x ** 2 for x in range(1,10)}

>>> d= {x : x ** 2 for x in range(1,10)}
>>> d
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

练习：
有字符串的列表以下：
L = ['tarena', 'xiaozhang', 'tyke']
用上述列表生成以下字典：
d = {'tarena': 6, 'xianzhang': 9, 'tyke':4}
注：
字典的值为键

 1 # 法一
 2 L = ['tarena', 'xiaozhang', 'tyke']
 3 a = {x : len(x) for x in L}
 4 print(a)
 5 
 6 # 法二
 7 L = ['tarena', 'xiaozhang', 'tyke']
 8 d = {}
 9 for s in L:
10     d[s] = len(s)
11 print(d)
12 
13 
14 # 法三   ???有误
15 str = input('请输入：')
16 dict_char_tmp = {i:str.count(i) for i in str}
17 dict_char= {}
18 for k, v in dict_char_tmp.items():
19     if dict_char.get(v):
20         dict_char[v].append(k)
21     else:
22         dict_char[v]=[k]
23 print(dict_char)
24 dict_char_k= sorted(dict_char.items(), key =1)
25 print(dict_char_k)
26 char_l=dict_char_k[0][1]
27 char_l.sort()
28 print('获得出现最多的：', char_l[0])

字符长度计算

字典　vs 列表
１．都是可变对象
２．索引方式不一样，列表用整数索引，字典用键索引
３．字典的插入，　删除，　修改数据的速度可能会快于列表（重要）
４．列表的存储是有序的，字典的存储是无序的

练习：
１．已知有两个等长的列表　list1　和 list2 以list1中的元素为键，　以list2中的元素为值，　生成相应的字典

 1 list1 = [1001, 102, 1003, 1004]
 2 list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']
 3 
 4 s = 0
 5 x ={}
 6 list1 = [1001, 102, 1003, 1004]
 7 list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']
 8 for z in list1:
 9     x[z] = list1[s]
10 a = {x : z for x in list2}
11 print(a)

练习

２．输入任意个学生的姓名，年龄，成绩，每一个学生的信息存入字典中，而后放入到列表中，每一个学生
的信息须要手动输入，当输入姓名为空时结束输入
如：
　　请输入姓名：xiaozhang
　　请输入年龄：20
　　请输入成绩：100
　　请输入姓名：xiaoli
　　请输入年龄：18
　　请输入成绩：98
　　请输入姓名：<回车>结束输入
要求内部存储格式以下：
[{'name':'xiaozhang','age':20,'score':100},
{'name':'xiaoli','age':18,'score':98}]
打印全部学生的信息以下：
+--------------------+--------------+-------------+
| name | age | score |
+--------------------+--------------+-------------+
| xiaozhang | 20 | 100 |
| xiaoli | 18 | 98 |
+--------------------+--------------+-------------+

 1 L = []  # 建立一个容器准备放入
 2 while True:
 3     name = input('请输入姓名: ')
 4     if not name:  # 若是名字为空,结束输入操做
 5         break
 6     age = int(input("请输入年龄: "))
 7     score = int(input("请输入成绩: "))
 8     d = {}  # 每次都会执行{} 来建立新的字典
 9     d['name'] = name
10     d['age'] = age
11     d['score'] = score
12     L.append(d)
13 
14 print(L)
15 
16 # 打印表格
17 print("+---------------+----------+----------+")
18 print("|     name      |   age    |   score  |")
19 print("+---------------+----------+----------+")
20 for d in L:
21     n = d['name'].center(15)
22     a = str(d['age']).center(10)
23     s = str(d['score']).center(10)
24     print("|%s|%s|%s|" % (n, a, s))
25 
26 # print("|   xiaozhang   |    20    |   100    |")
27 # print("|     xiaoli    |    18    |    98    |")
28 print("+---------------+----------+----------+")