Python3基础知识点笔记(元组、字典)

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

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

创建空元组的字面值：
t = () #创建一个空元组用t绑定

创建非空元组的字面值：
t = 200 #创建一个只有一个数字200的元组用t绑定
t = (20,)
t = (1,2,3)
t = 100, 200, 300

创建元组的错误示例：
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” ＃序列赋值，不是元组
－－－－－－－－－－－－－
type(x) 函数返回x的类型
－－－－－－－－－－－－－

元组的构造函数　tuple
tuple() 生成一个空的元组，等同于()
tuple(iterable) 用可迭代对象生成一个新的元组
/
示例：
t = tuple()
t = tuple(‘ABC’)
t = tuple(range(1, 10, 3))

元组的运算：
+ += * *=
/
t = (1, 2, 3) + (4, 5, 6) #t = (1, 2, 3, 4, 5, 6)
比较运算：比较规则与列表的比较规则完全相同
/
in / not in运算符：等同于列表
/
索引　和　切片：
　　索引取值和切片取值的规则与列表完全相同，切出来的类型也依然是元组
　　注：元组不支持　索引赋值和切片赋值
　　
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
/
字典　dict

啥是字典？
１．字典是一种可变的容器，可以存储任意类型的数据
２．字典中的每个数据都是用"键"(key)进行索引的，而不像
序列(str,list,tuple)可以用整数进行索引
３．字典中的数据没有先后顺序关系，字典的存储是无序的
４．字典中的数据以　键(key)-值(value)对　形式进行存储
５．字典的键不能重复，且只能用不可变类型作为字典的键

创建字典的字面值方式：
字典的表示方式以{}括起来，以冒号(:)分割键值对，各值对
之间用逗号分隔开

创建空字典：
d = {}

创建非空字典:
d = {‘姓名’: 'MLXG, ‘年龄’: 25}
d = {‘one’: 1, ‘two’: 2}

创建字典的构造函数：
dict() #生成一个空的字典,等同于{}
dict(iterable) #用可迭代对象创建一个列表
dict(**kwargs) #关键字传参形式生成一个字典

字典的键必须为不可变类型的值

可变的类型有四种：
list(列表),dict(字典),set(集合),bytearray(字节数组)
(除上述四种其他为不可变类型)

字典基本操作
　　 字典的键索引
　　 语法：
　　 字典[键]
　　
　　 作用：
　　 用键获取字典的键对应的值　
　　
　　 示例：
　　 print(d[‘name’], ‘的年龄是’, d[‘age’])
　　 d = {‘name’: ‘tom’, 'ag
　　
添加和修改字典的元素
语法：
字典[键] = 值
/
说明：
键不存在是，创建键，并让键绑定对应的值
键存在，修改键绑定的值
/
示例：
d = {}
d[‘name’] = ‘ALEX’ #添加一个键值对
d[‘年龄’] = 20 #添加一个键值对
d[‘年龄’] += 1 #修改’年龄’这个键对应的值
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　 　　　　　　　
练习： |
写一个程序，让用户分两次输入一个人的信息： |
信息包含：姓名　和　电话号码 |
让用户输入多个人的信息，当输入姓名为空是结束输入 |
把用户输入的数据存于字典中 |
姓名作为键，电话号码作为值 |
最后打印存储数据的字典 |
如： |
请输入姓名：校长 |
请输入电话：18888888888
请输入姓名:UZI
请输入电话：11001100111
请输入姓名：<回车>
打印：
{‘校长’:18888888888, ‘UZI’: 11001100111}

d = {}
while True:
    name = input('请输入姓名：')
    if not name:
        break
        
    tel = int(input('请输入电话：'))
    
    d[name] = tel
    
print(d)

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

删除字典元素
del 语句
语法：
del 字典[键]
/
示例：
d = dict(name=‘小詹’, age=20)
del d[‘age’]
print(d) #{‘name’: ‘小詹’}

字典的键判断
in , not in　运算符
可以用　in　运算符判断一个键是否存在于字典中，如果存在则返回True,否则返回False
not in 返回值与in相反(只判断键，不判断值)
例如：
d = {‘name’: 'aike, ‘age’: 15}
‘name’ in d #True
15 in d #False

字典的迭代访问
字典是可迭代对象，字典只能对键进行迭代访问
/
示例：
d = {0:‘零’, 5:‘伍’, 1:‘壹’, 2:‘贰’}
for n in d:
print(n) #0, 1, 2, 5

可以用于字典的函数
len(x) 返回字典的　键值对　的个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典的所有键的和
any(x) 真值测试，只对键进行测试，只要有一个键为真值结果就为True
all(x) 真值测试，所有键为真值结果才为True

字典的方法

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

字典推导式
字典推导式是用可迭代对象来创建字典的表达式
／
语法：
{键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注释：[]的内容代表可省略
／
示例：
生成一个字典：键为数字０～９，值为键的平方
#如｛0: 0, 1: 1, 2: 4, 3: 9, … 9: 81}
d = {x: x**2 for x in range(10)}

字典推导式的嵌套
语法同列表推导式嵌套

练习：
已知有如下字符串的列表：(值为键的长度）
Ｌ＝　[‘tarena’, ‘xiaohu’, ‘xiaogou’]
生成如下字典：
d = {‘tarena’: 6, ‘xiaohu’: 6, ‘xiaogou’: 7}

L = ['tarena', 'xiaohu', 'xiaogou']
print('----------办法一-----------')
d = {x: len(x) for x in L}

print(d)

print('----------办法二-----------')
d1 = {}
for s in L:
    d1[s] = len(s)

print(d1)

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

练习题：

1. 生成前40个斐波那契数 (Fibonacci 数列)
   　 1 1 2 3 5 8 13 21 …
   要求: 将这些数存入在列表中
   最后打印出这些数

L = []
#创建一个变量限制斐波那契数的个数,并且从零开始用于累加，直到第四十个斐波那契数停止
for n in range(41):
    if n <= 1:
        
        L.append(1)
    else:    
        # L1[n] = L([n-1] + L[n-2])
        L.append(L[n-1] + L[n-2])
        
print(L)

print('--------方法二------------')
L = []
a = 0   #a表示当前数b的前一个
b = 1   #b永远绑定当前的一个Fibonacci数
while len(L) < 40:
    #　需要将
    L.append(b)

print('-------------方法三------')
L = [1, 1]
while len(L) < 41:
    L.append(L[-1] + L[-2])
print(L)

2. 有一只小猴子，摘了很多桃,
   第一天吃了全部的桃子的一半，感觉不饱又吃了一个
   第二天吃了剩下的一半，感觉不饱又吃了一个
   以此类推…
   到第10天，发现只剩下一个了
   问: 第一天摘了多少桃子?

x = 1  # 第十天
# x = (x + 1) * 2  # 第九天
# x = (x + 1) * 2  # 第八天的
for day in range(9, 0, -1):
    x = (x + 1) * 2
    print("第%d天的桃子是:%d" % (day, x))

3. 打印九九乘法表:
   1x1=1
   1x2=2 2x2=4
   1x3=3 2x3=6 3x3=9
   …
   …9x9=81

for x in range(1,10):   #x代表当前行
    #打印第x行
    for y in range(1,x + 1):    #y代表被乘数
        z = x * y
        print('%dx%d=%d' % (y,x,z), end=' ')
    print()

4. 任意输入很多个学生的姓名,年龄，成绩,每个学生的信息
   　　存入到字典中，然入再放在列表内.
   每个学生的信息需要手动输入:
   如:
   请输入姓名: xiaoming
   请输入年龄: 15
   请输入成绩: 99
   请输入姓名: china
   请输入年龄: 70
   请输入成绩: 98
   请输入姓名: <回车>　结束输入
   内部存储格式如下:
   infos = [{‘name’:‘xiaoming’, ‘age’:15, ‘score’:99},
   {‘name’:‘china’, ‘age’:70, ‘score’:98}]
   1. 打印以上的列表
   2. 按如下表格打印学生信息

请输入姓名:xiaoming
请输入年龄: 15
请输入成绩: 99
请输入姓名: china
请输入年龄: 70
请输入成绩: 98
请输入姓名:
[{'name': 'xiaoming', 'score': 99, 'age': 15}, {'name': 'china', 'score': 98, 'age': 70}]
+---------------+-----------+----------+
|     姓名      |    年龄   |   成绩   　|
+---------------+-----------+----------+
|     xiaoming  |     15    |    99    |
|     china     |     70    |    98    |
+---------------+-----------+----------+

答案（不唯一）：

infos = []  # 创建一个列表容器准备存放每个学生信息的字典
while True:
    n = input("请输入姓名: ")
    if not n:  # 如果姓名为空,则结束输入
        break
    a = int(input("请输入年龄: "))
    s = int(input("请输入成绩: "))
    # 新创建一个字典 {}  dict()
    d = {'name':n, 'age':a, 'score':s}  # d = dict(name=n, age=a, score=s)
    infos.append(d)

# 打印存有学生信息的字典的列表
print(infos)

print("+---------------+-----------+----------+")
print("|     姓名      |    年龄   |   成绩   |")
print("+---------------+-----------+----------+")
for d in infos:  # d绑定字典
    n = d['name']
    a = d['age']
    s = d['score']
    a = str(a)  # 将整数转为字符串
    s = str(s)
    print("|" + n.center(15) + '|'
              + a.center(11) + '|'
              + s.center(10) + '|')
print("+---------------+-----------+----------+")