python基础（7）——元组 & 字典

一、元组 tuple

   元组是不可改变的序列，同list一样，元组可以存放任意类型的元素
   元组一但创建将不可改变

1、元组的表示方式:

   用小括号() 括起来，单个元素括起来后加逗号(,)区分单个对象还是元组

2、创建空元组的字面值表达式

   t = ()  # () 是创建一个空的元组对象

3、创建非空元组的字面值表达式:

   t = 200,
   t = (20,)
   t = (1, 2, 3)
   t = 100, 200, 300
     注：type(x)函数 可以返回对象x的类型

  元组错误示例:
 　  t = (200)  # t 绑定20这个对象，不是元组
　　x, y, z = 100, 200, 300  # 序列赋值
　　x, y, z = (100, 200, 300)
　　x, y, z = [100, 200, 300]
　　x, y, z = "ABC"

4、元组的构造函数tuple

   tuple() 生成一个空的元组　，等同于()
   tuple(iterable)  用可迭代对象生成一个元组

  示例:
     t = tuple()
     t = tuple("ABC")
     t = tuple(range(1, 10, 2))

5、元组的运算:

   + 用于用拼接方式创建一个新的元组
   * 用于生成新的重复的元组

   t = (1,2,3)  + (4, 5, 6)  # t = (1,2,3,4,5,6)
   t += (7,8,9)  # t = (1,2,3,4,5,6,7,8,9)

   t = (1,2) * 3  # t = (1,2,1,2,1,2)
   t *= 4  # t = (1,2,1,2,1,2....)

6、列表的比较运算:

  1、< <= > >= == !=  规则与列表的比较规则完全相同

  2、元组的in / not in 运算符
   　用于判断元素是否存在于元组中,规则写列表完全相同

7、索引　index

   用法等于同列表的索引
   元组不支持索引赋值

8、切片

   用法与列表的切片用法相同
   元组的切片返回一个新的元组
   元组不能切片赋值

9、元组的方法:

方法	说明
T.index(v [, begin[, end]])	返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
T.count(x)	返回元组中对应元素的个数

10、序列小结:

   字符串 str
   列表 list(可变的)
   元组 tuple
   字节串　bytes
   字节数组 bytearray(可变的)

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

       reversed(x)  返回反向顺序的可迭代对象

   示例:
     s = "ABC"
     for ch in s:
         print(ch)  # A B C  # C  B  A

     L = [1, 3, 7, 9]
     L2 = [x **2 for x in reversed(L)]  # [81, 49, 9, 1]

二、字典 dict

 什么是字典:
     1. 字典是一种可变的容器，可以存储任意类型的数据
     2. 字典中的每个数据都是用'键'(key)进行索引的，而不像序列可以用索引下标进行索引
     3. 字典中的数据没有先后顺序关系,字典的存储是无序的
     4. 字典中的数据以键-值对(key-value)对形式进行映射存储
     5. 字典的键不能重复,且只能用不可变类型作为字典的键

1、字典的字面值表示方法:

     以{} 括起来,以冒号(:) 分隔键-值对,各键值对用逗号分隔开

2、创建空字典:

     d = {}  # {} 表达式用来创建一个空的字典

3、创建非空字典:

     d = {'name': 'weimingze', 'age': 35}
     d = {'a': 100}
     d = {'a': tuple("ABC")}
     d = {'abc': list("ABC")}
     d = {'a': {'b':100, 'c':200}}
     d = {True:'真值', False: '假值', None:'空', 100:'一百'}
     d = {(1970, 1, 1): '计算机元年'}

4、字典的构造函数 dict

   dict()  创建一个空的字典,等同于{}
   dict(iterable)  用可迭代对象创建一个新的字典
   dict(**kwargs)  用关键字传参形式创建一个新的字典

  示例:
      d = dict()
      d = dict([('name', 'tarena'), ('age', 15)])
      d = dict((['name', 'weimingze'], "AB"))
      d = dict(name='Tarena', age=15)

5、字典的操作

   字典的键索引
         用[] 运算符可以获取字典内'键'对应的'值'
   语法:
         v = 字典[键]
   示例:
        d = {'name': 'tarena', 'age': 15}
        print(d['name'], '今年', d['age'], '岁')

6、添加/修改字典的元素

   语法:
     字典[键] = 表达式
   示例:
     d = {}
     d['name'] = 'tarena'  #创建新的键'name'同时关联值
     d['age'] = 15  # 创建键并绑定15
     d['age'] = 16  # 修改原来的键'age',重新绑定为16
   说明:
       键不存在,创建键,并绑定值
       键存在,修改键的绑定关系

7、删除字典元素 del语句

   del 字典[键]
   示例:
       d = {1:'一', 'hello': 'world', False:'假值'}
       del d['hello']

    #1和Ture 不能同时存在，Ture也为数字1

8、字典的 in / not in 运算符

   in用来判断一个键是否存在于字典中,如果存在返回 True,否则返回False。
   not in 的返回结果与in 相反

示例:
   d = {'name': '小张', 'age': 20}
   'name' in d  # True
   'age' not in d  # False
   '小张' in d   # False  (只判断键,不判断值)
   20 not in d  # True

练习:
     写程序,实现以下要求:
     1) 将如下数据形成一个字典 seasons
         键             值
         1          '春季有1,2,3月'
         2          '夏季有4,5,6月'
         3          '秋季有7,8,9月'
         4          '冬季有10,11,12月'

# 方法1
seasons = {}
seasons[1] = '春季有1,2,3月'
seasons[2] = '夏季有4,5,6月'
seasons[3] = '秋季有7,8,9月'
seasons[4] = '冬季有10,11,12月'
print(seasons)


# 方法2
seasons = {
    1: '春季有1,2,3月',
    2: '夏季有4,5,6月',
    3: '秋季有7,8,9月',
    4: '冬季有10,11,12月'
}
print(seasons)

     2)  让用户输入一个整数代表这个季度,打印这个季度有信息
          如果用户输入的信息不在字典中,则打印"信息不存在"

n = int(input("请输入季节: "))
if n in seasons:
    print(n, ' : ', seasons[n])
else:
    print("信息不存在")

9、字典的迭代访问

   字典是可迭代对象,字典只能对'键'进行访问

  示例:
     d= {'aaa': 111, 'bbb': 222, 'ccc': 333}
     for k in d:
         print(k)

那么python可以根据值寻找键吗？

　　字典中的value不保证唯一性，因此根据值查出来的是一个list。
　　不过字典中key的值是唯一的，因此根据key将可以查到唯一的一个value。

#根据值查询对应的键

key_list=[]
value_list=[]
mydisc = {'key1':'123','key2':'234','key3':'345'}

for key,value in mydisc.items():
    key_list.append(key)
    value_list.append(value) 
get_value = raw_input("请输入要查值：")
if get_value in value_list:
    get_value_index = value_list.index(get_value)
    print "你要查询的值对应的键为：%s" %key_list[get_value_index]
else:
    print "你要查询的值%s不存在" %get_value

#假如值唯一
mydisc = {'key1':'123', 'key2':'234', 'key3':'345'}
get_value = input('请输入要查值：')
if get_value in mydisc.values():
    print(list(mydisc.keys())[list(mydisc.values()).index(get_value)])
else:
    print('你要查询的值'+get_value+'不存在')



# 假如值不唯一
mydisc = {'key1':'123', 'key2':'234', 'key3':'345','key5':'123'}
get_value = input('请输入要查值：')
if get_value in mydisc.values():
    for a in range(0,len(mydisc)):
        if list(mydisc.values())[a]==get_value:
            print(list(mydisc.keys())[a])
else:
    print('你要查询的值'+get_value+'不存在')
————————————————
版权声明：本文为CSDN博主「胸怀大海」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/edians/article/details/99296269

10、可以用于字典的函数:

   len(x)  返回字典的键值对个数
   max(x)  返回字典键的最大值
   min(x)  返回字典键的最小值
   sum(x)  返回字典所有键的和
   any(x)  真值测试,只对键进行测试
   all(x)  真值测试,全部键为真值.结果才为True
　 示例:
 　　  d = {0: '零', 5:'伍', 8:'捌', 3:'叁'}
 　　  len(d)  # 4
　　   max(d)  # 8
　　   min(d)  # 0
　　   sum(d)  # 16
   　　any(d)  # True
   　　all(d)  # False

11、字典的方法

函数	说明
D代表字典对象
D.clear()	清空字典
D.pop(key)	移除键，同时返回此键所对应的值
D.copy()	返回字典D的副本,只复制一层(浅拷贝)
D.update(D2)	将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default=None)	返回键key所对应的值,如果没有此键，则返回default的值
	例： D.get(10,'不存在')  # 不存在
D.keys()	返回可迭代的 dict_keys 集合对象
D.values()	返回可迭代的 dict_values 集合对象
D.items()	返回可迭代的 dict_items 对象

　　示例:

  　　 d = {1: 'One', 2: "Two"}
 　　  d2 = {2: '二', 3: '三'}
 　　  d3 = d.copy()  # 复制
 　　  d3.pop(1)  # d3 = {2: "Two"}
 　　  d.update(d2)  # d = {1: 'One', 2: '二', 3: '三'}

 　　  d = {1: 'One', 2: '二', 3: '三'}
 　　  for k in d.keys():
  　　     print(k)   # 1 2 3
　　   for v in d.values():
      　　 print(v)  # 'One' '二' '三'
  　　 for t in d.items():
       　　print(t)  # (1, 'One') (2, '二') (3, '三')

练习:
   输入任意一段字符串,打印出这个字符串中出现过的字符及出现过的次数:
     如:
         输入: ABCDABCABA
     打印如下:
       A: 4次
       B: 3次
       D: 1次
       C: 2次
     注: 不要求打印的顺序

s = input("请输入: ")
d = {}  # 容器用来存储 字符(键)-个数(值)

for ch in s:
    if ch not in d:  # 第一次出现在d中
        d[ch] = 1  # 将个数置为 1
    else:  # ch之前已经出现过
        d[ch] += 1

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

三、字典推导式

   是用可迭代对象生成字典的表达式
语法:
     {键表达式 : 值表达式 for 变量 in 可迭代对象[if 真值表达式]}
        注: []表示其中的内容可省略
示例:
     # 生成一个字典,键为数字 1 ~ 9,值为键的平方
     d = {x : x ** 2 for x in range(1, 10)}

字典推导式练习:
  1. 已知有如下字符串列表
       L = ['tarena', 'xiaozhang', 'abc']
      生成如下字典:
        d = {'tarena': 6, 'xiaozhang': 9, 'abc': 3}
        注: 字典的值为键的长度

L = ['tarena', 'xiaozhang', 'abc']
# d = {'tarena': 6, 'xiaozhang': 9, 'abc': 3}
# 方法1
# d = {}  # 创建一个空字典
# for s in L:
#     d[s] = len(s)

#方法2:（最佳）
d = {s: len(s) for s in L}
print(d)

#方法3
a=len(L[0])
b=len(L[1])
c=len(L[2])
d = {L[0]:a,L[1]:b,L[2]:c}
print('d=',d)

  2. 已知有如下两个列表:
     nos = [1001, 1002, 1005, 1008]
     names = ['Tom', 'Jerry', 'Spike', 'Tyke']
     用上述两个列表生成如下字典:
     {1001: 'Tom', 1002: 'Jerry', 1005: 'Spike', 1008: 'Tyke'}

nos = [1001, 1002, 1005, 1008]
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
# d = {k: v for k in nos for v in names}  #错误方法

# 方法1
# d = {}
# for index in range(len(nos)):  # 让range生成索引
#     print(index)  # 0, 1, 2, 3
#     d[nos[index]] = names[index]
# print(d)

# 方法2:用推导式实现
d = {nos[index]: names[index] for index in range(len(nos))}
print(d)

# 方法3:用zip
# print(dict(zip(nos,names)))

注意：字典推导式的嵌套等同于列表推导式的嵌套

四、字典 VS 列表

   1. 都是可变对象
   2. 索引方式,列表用整数索引,字典用键索引
   3. 字典的插入,删除,修改的速度可能会快行于列表(重要)
   4. 列表的存储是有序的,字典的存储是无序的

  示例:
    L = [9, 4, 10043, 5, 12, 3......., 123]

    1006 in L  #

练习:

   1. 写一个程序模拟现实电子字典
      1) 输入一些单词和解释,将单词作为键,将解释作用值,将这些数据输入到字典中,当输入空单词时结束输入
      2) 输入要查找的词,给出该单词的解释.如果单词不存在则提示用户不存在该单词

d = {}  # 创建空典
while True:
    words = input('请输入单词: ')
    if words == '':
        break
    trans = input('请输入解释: ')
    d[words] = trans

while True:
    words = input("请输入要查找的单词: ")
    if words in d:
        print(words, "的解释是:", d[words])
    else:
        print(words, '这个单词在字典中不存在')

   2. 学生信息管理项目
     输入任意个学生的姓名,年龄,成绩.每个学生的信息存入一个字典内,然后放入到列表中
        (每个学生需要手动输入)
     如:
       请输入姓名: tarena
       请输入年龄: 20
       请输入成绩: 99
       请输入姓名: name2
       请输入年龄: 30
       请输入成绩: 88
       请输入姓名: <回车> 结束输入
     形成内部存储格式如下:
       [{'name':'tarena', 'age':20, 'score':99}, {'name':name2, 'age':30, 'score':88}]
     1) 打印出存有学生信息的字典的列表
     2) 按表格形式打印出学生信息:
       +---------------+----------+----------+
       |     name          |    age     |    score   |
       +---------------+----------+----------+
       |     tarena        |     20      |      99     |
       |     name2        |     30      |      88     |
       +---------------+----------+----------+

L = []  # 创建一个新的列表，用此列表准备保存学生信息
# 录入学生信息
while True:
    n = input("请输入姓名: ")
    if not n:
        break
    a = int(input("请输入年龄: "))
    s = int(input('请输入成绩: '))
    # 创建一个新的字典，把学生的信息存入字典中
    d = {}  # 每一次都重新创建一个新的字典
    d['name'] = n
    d['age'] = a
    d['score'] = s
    L.append(d)
print(L)  # 打印结果

print("+---------------+----------+----------+")
print("|     name      |   age    |   score  |")
print("+---------------+----------+----------+")
for d in L:
    n = d['name']
    a = d['age']
    s = d['score']
    print('|%s|%s|%s|' % (n.center(15),str(a).center(10),str(s).center(10))
          )
# print("|    tarena     |    20    |     99   |")
# print("|     name2     |    30    |     88   |")
print("+---------------+----------+----------+")