元组和字典

学习目录纲要

元组tuple
    元组是不可变的序列容器
序列的运算:
    + * += *=
    < <= > >= == !=
    in not in
    索引和切片
字典dict
键————值：
键不能重复，　且只能用不可变类型作为字典的键
字典[键]　= 值＃添加和修改键－值对
del 字典[键]
{1:100, 2:200}

字典的运算
    键索引
    字典[键]　＝　value
    var = 字典[键]
    in, not in 对键

字典推导式
{键表达式：值表达式　for 变量 in 可迭代对象　if 真值表达式　for 变量２　}
l = [1, 3, 4, 5, 8, 64, 564, 84, 51, 75, 61]
d = {k:None for k in l }
8 in l

可变的容器
列表　字典　集合　字节数组

元组　tuple

容器类，元组是不可变的序列，同list一样，元组可以存放任意类型的数据的容器　

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

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

＃查看类型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
索引[ 切片[:]/[::]

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

>>> 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
>>> t

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

>>> 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 assignment

元祖的比较运算与列表完全相同
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月‘

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

seasons = {'1':'春季有１，　２，　３月',     #1
           '2': '夏季有４，　５，　６月',    #2
           '3': '秋季有７，　８，　９月',    #3
           '4': '冬季有10, 11, 12月'     #4
           }
n = input("请输入一个：")#或 n = int(input("请输入整数："))
if n in seasons:
    print(seasons[n])
else:
    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:２次

s = input("请输入：")
d = {}#创建字典保存字符的个数
for ch in s:
    #先判断这个字符以前是否出现过
    if ch not in d:#第一次出现
        d [ch] = 1#将出现次数设置为１
    else:#不是第一次出现
        d[ch] +=1
for k in d:
    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}
注：
字典的值为键

# 法一
L = ['tarena', 'xiaozhang', 'tyke']
a = {x : len(x) for x in L}
print(a)

# 法二
L = ['tarena', 'xiaozhang', 'tyke']
d = {}
for s in L:
    d[s] = len(s)
print(d)


# 法三   ???有误
str = input('请输入：')
dict_char_tmp = {i:str.count(i) for i in str}
dict_char= {}
for k, v in dict_char_tmp.items():
    if dict_char.get(v):
        dict_char[v].append(k)
    else:
        dict_char[v]=[k]
print(dict_char)
dict_char_k= sorted(dict_char.items(), key =1)
print(dict_char_k)
char_l=dict_char_k[0][1]
char_l.sort()
print('得到出现最多的：', char_l[0])

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

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

list1 = [1001, 102, 1003, 1004]
list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']

s = 0
x ={}
list1 = [1001, 102, 1003, 1004]
list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']
for z in list1:
    x[z] = list1[s]
a = {x : z for x in list2}
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 |
+--------------------+--------------+-------------+

L = []  # 创建一个容器准备放入
while True:
    name = input('请输入姓名: ')
    if not name:  # 如果名字为空,结束输入操作
        break
    age = int(input("请输入年龄: "))
    score = int(input("请输入成绩: "))
    d = {}  # 每次都会执行{} 来创建新的字典
    d['name'] = name
    d['age'] = age
    d['score'] = score
    L.append(d)

print(L)

# 打印表格
print("+---------------+----------+----------+")
print("|     name      |   age    |   score  |")
print("+---------------+----------+----------+")
for d in L:
    n = d['name'].center(15)
    a = str(d['age']).center(10)
    s = str(d['score']).center(10)
    print("|%s|%s|%s|" % (n, a, s))

# print("|   xiaozhang   |    20    |   100    |")
# print("|     xiaoli    |    18    |    98    |")
print("+---------------+----------+----------+")