2018.7.10
day06回顾
列表：
是可变的序列
是容器
索引和切片操作，可以索引切片赋值
del语句
用于删除列表中的元素
del 列表[整数表达式]
del 列表[切表]
序列相关的函数
len(x) max(x) min(x) sum(x) any(x) all(x)
列表中的方法：
L.index(x)
L.insert(index,obj)
L.count(x)
L.remove(x)
L.copy() 浅拷贝
L.append(x)
L.extend(lst) #L+=lst
L.clear()
L.sort()
L.pop(索引)
L.reverse() 列表的反转
深拷贝deep copy，浅拷贝shallow copy
字符串的方法：
str.split() 分割
str.join() 连接
列表推导式
day 07笔记
元组tuple
元组是不可变的序列，同list一样，元组可以存放任意类型数据的容器
元组的表示方法：
用小括号()括起来，单个元素括起来后加逗号(,) 区分单个对象还是元组
创建空元组的字面值：
t = () 空元组
创建非空元组的字面值表示：
t = 200,
t = (20,)
t = (1,2,3)
t = 100,200,300
函数type（x）用来返回x对应的类型
元组的错误示例：
t = (20) #绑定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 = ('A','B','C')
t = tuple([1,2,3]) #t = (1,2,3)
元组的运算：
算术运算:
+ += * *=
比较运算
< <= > >= == !=
in / not in 运算
索引[] 和 切片[:]或[::]
+加号用于拼接元组
*用于生成重复的元组
元组的比较运算：
规则与列表的比较规则完全相同
in / not in 运算符
规则与列表的规则完全相同
索引和切片
索引取值和切片取值的规则与列表完全相同
元组不支持索引赋值和切片赋值（因为元组不可被改变）
元组的方法：
T.index(v[,begin[,end]]) 返回对应元素的索引下标
T.count(x) 返回元组中的元素个数
序列相关的函数：
len(x) max(x) min(x) sum(x) any(x) all(x)
构造函数：
str(x) 创建字符串
list(iterable) 创建列表
tuple(iterable) 创建元组
序列的相关函数：
reversed（可迭代对象） 返回反向顺序的可迭代对象
sorted(iterable,key=None,reverse=false)
返回已排序的列表
示例：
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) #打印 72684
L2 = sorted(t) #L2 = [2,4,6,7,8]
L3 = sorted还没打完
容器小结：
字符串str （不可变序列，只能存字符）
列表 list （可变序列，可以存任意数据）
元组 tuple （不可变序列，可以存任意数据）
字典dict
1，字典是一种可变的容器，可以存储任意类型的数据，
2，字典中的每个数据都是用'键'(key) 进行索引，而不像序列可以
用整数下标来进行索引
3，字典中数据没有先后关系，字典中的存储是无序的
4，字典中的数据以键(key)-值(value) 对形式进行映射存储
5，字典的键不能重复，且只能用”不可变类型”作为字典的键
字典的字面值表示方法：
字典的表示方式是以{} 括起来，以冒号（：）
分隔键-值对, 各键-值对之间用逗号(,)分割开
创建空字典的字面值：
d = {} #d 绑定空字典
创建非空字典的字面值：
d = {name: 'wesdasd','age':35}
d = {1:'one',2:'two',3:'three'}
d = {1:[1,2,3],'abc':(1.1,1.2,1.3)}
d ={'a':{'b':200,'c':[1,2,3]}}
d = {(1970,1,1):'computer year'}
字典的构造函数dict
dict() 生成一个字的字典等同于{}
dict(iterable) 用可迭代对象初始化一个字典
dict(**kwargs) 用关键字传参形式创建一个字典
键是变量名规则
示例：
d = dict()
d = dict([('name','tarena'),['age','15']])
字典的键(key) 必须为不可变类型
bool,int,float,complex,str,tuple,frozenset,bytes(后面讲)
字典的值(value) 可以是任意类型
可变的数据类型有四种：
list 列表
dict 字典
set 集合
bytearray 字节数组
字典的基本操作：
字典的键索引
用[] 运算符可以获取字典内‘键’对应的值
也可以用[]运算符来修改‘键’对应的值
键索引的语法：
字典[键]
示例：
获取值：
d = {'name': 'tarena','age':35}
print(d['name'],'的年龄',d['age'])
# tarena 的年龄 35
添加修改字典的元素
语法：
字典[键]=值
说明：
键不存在时，创建键，并绑定对应的值
当键存在时，修改键绑定的值
示例：
d = {}
d['name'] = 'tarena' #创建新的键值对
d['age'] = 15
d['age'] = 16 #修改'age'所对应的值
d['age']+=1 #17,数值同样修改
删除字典元素
del 字典[键]
示例：
d = {'name': 'tarena','age':15}
del d['name']
print(d) #{'age': 35}
字典的成员资格判断 in 运算符
可以用 in 运算符判断一个键是否存在于字典中，如果'键'存在则返回True
否则返回false
not in 与 in 结果相反
示例：
d = {'name': 'tarena','age':15}
if 'name' in d:
print('name 在字典中')
print(15 in d)#False,只判断键，不判断值
练习：
1，写程序，实现以下要求：
将如下数据形成一个字典seasons：
'键' '值'
1 '春季有1,2,3月'
2 '春季有4,5,6月'
3 '春季有7,8,9月'
4 '春季有10,11,12月'
方法一
# d = {}
# d[1]='春季有1,2,3月'
# d[2]='春季有4,5,6月'
# d[3]='春季有7,8,9月'
# d[4]='春季有10,11,12月'
# print(d)
方法二
seasons = {
1:'春季有1,2,3月',
2:'春季有4,5,6月',
3:'春季有7,8,9月',
4:'春季有10,11,12月'
}
print(seasons)
2，让用户输入一个整数，代表一个季度，打印这个季度对应的信息，
如果用户输入的信息不在字典内，则打印信息不存在
字典的迭代访问
字典是可迭代对象，字典只能对键进行迭代访问
示例：
d = {'name': 'tarena','age':15}
for k in d:
print(k,'对应的值是：',d[k])
可以用于字典的内建函数
len(x) 返回字典的键值对个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典中所有键的和
any(x) 真值测试，只要有一个键为True，返回True
all(x) 真值测试，当全部键为真值是，返回True
示例：
d = {0:'零',5:'伍',8:'捌',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 对象 这个可以看下下面
D = {0:'零',5:'伍',8:'捌',3:'叁'}
for k,v in D.items():
print(k,v)
#0 零
8 捌
3 叁
5 伍
D = {0:'零',5:'伍',8:'捌',3:'叁'}
for v in D.items():
print(v)
#(0, '零')
(8, '捌')
(3, '叁')
(5, '伍')
练习：
输入一段字符串，打印出这个字符串中出现过的字符的出现次数
如：
输入：
abcdabcaba
打印：
a：4次
b：3次
c：2次
d：1次
注：不要钱打印顺序
s = input('输入一段字符串: ')
d = {}
for ch in s:
if ch not in d:
d[ch] = 1
else:
d[ch]+=1
print(d)
for k in d:
print(k,':',d[k],'次')
字典推导式：
字典推导式是用可迭代对象的创建字典的表达式
语法：
{键表达式：值表达式 for 变量 in 可迭代对象 if 真值表达式}
说明：
if子句可以省略
示例：
生成一个字典，键为数字（10以内），值为键的平方
d = {x:x**2 for x in range(10)}
练习：
有字符串的列表如下：
L = ['tarena','xiaozhang','tyke']
用上述列表生成如下字典：
d = {'tarena':6,'xiaozhang':9,'tyke':4}
注：字典的值为键的长度
L = ['tarena','xiaozhang','tyke']
# d = {}
# for s in L:
# print(s)
# d[s]=len(s)
# print(d)
d = {s:len(s) for s in L}
print(d)
字典 vs 列表
1.都是可变对象
2.索引方式不同，列表用整数索引，字典用键索引
3.字典的插入，删除，修改数据的速度可能会快于列表（重要）
4.列表的存储是有序的，字典的存储是无序的
练习：
1.已知有俩个等长的列表list1 和list2，以list1中的元素为键，
以list2中的元素为值，生成相应的字典
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
生成的字典为：
{1001；'Tom',1002:'Jerry',...}
方法一：
d = {}
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
i = 0
while i <= 3:
d[list1[i]] = list2[i]
#print(d)
i += 1
print(d)
方法二：
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
d = {}
for i in range(len(list1)):
d[list1[i]] = list2[i]
print(d)
2.输入任意个学生的姓名，年龄，成绩，每个学生的信息存入字典中，然后放入至列表中，
每个学生的信息需要手动输入，当输入姓名为空时结束输入：
如：
请输入姓名：xiaozhang
请输入年龄：20
请输入成绩：100
请输入姓名：xiaoli
请输入年龄：18
请输入成绩：98
请输入姓名：<回车> 结束输入
要求内部储蓄格式如下：
[{'name':'xiaozhang','age':20,'score':100,
'name':'xiaoli','age':18,'score':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('+---------------+----------+----------+')
+---------------+----------+----------+
| name | age | score |
+---------------+----------+----------+
| xiaozhang | 20 | 100 |
| xiaoli | 18 | 98 |
+---------------+----------+----------+
day06回顾
列表：
是可变的序列
是容器
索引和切片操作，可以索引切片赋值
del语句
用于删除列表中的元素
del 列表[整数表达式]
del 列表[切表]
序列相关的函数
len(x) max(x) min(x) sum(x) any(x) all(x)
列表中的方法：
L.index(x)
L.insert(index,obj)
L.count(x)
L.remove(x)
L.copy() 浅拷贝
L.append(x)
L.extend(lst) #L+=lst
L.clear()
L.sort()
L.pop(索引)
L.reverse() 列表的反转
深拷贝deep copy，浅拷贝shallow copy
字符串的方法：
str.split() 分割
str.join() 连接
列表推导式
day 07笔记
元组tuple
元组是不可变的序列，同list一样，元组可以存放任意类型数据的容器
元组的表示方法：
用小括号()括起来，单个元素括起来后加逗号(,) 区分单个对象还是元组
创建空元组的字面值：
t = () 空元组
创建非空元组的字面值表示：
t = 200,
t = (20,)
t = (1,2,3)
t = 100,200,300
函数type（x）用来返回x对应的类型
元组的错误示例：
t = (20) #绑定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 = ('A','B','C')
t = tuple([1,2,3]) #t = (1,2,3)
元组的运算：
算术运算:
+ += * *=
比较运算
< <= > >= == !=
in / not in 运算
索引[] 和 切片[:]或[::]
+加号用于拼接元组
*用于生成重复的元组
元组的比较运算：
规则与列表的比较规则完全相同
in / not in 运算符
规则与列表的规则完全相同
索引和切片
索引取值和切片取值的规则与列表完全相同
元组不支持索引赋值和切片赋值（因为元组不可被改变）
元组的方法：
T.index(v[,begin[,end]]) 返回对应元素的索引下标
T.count(x) 返回元组中的元素个数
序列相关的函数：
len(x) max(x) min(x) sum(x) any(x) all(x)
构造函数：
str(x) 创建字符串
list(iterable) 创建列表
tuple(iterable) 创建元组
序列的相关函数：
reversed（可迭代对象） 返回反向顺序的可迭代对象
sorted(iterable,key=None,reverse=false)
返回已排序的列表
示例：
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) #打印 72684
L2 = sorted(t) #L2 = [2,4,6,7,8]
L3 = sorted还没打完
容器小结：
字符串str （不可变序列，只能存字符）
列表 list （可变序列，可以存任意数据）
元组 tuple （不可变序列，可以存任意数据）
字典dict
1，字典是一种可变的容器，可以存储任意类型的数据，
2，字典中的每个数据都是用'键'(key) 进行索引，而不像序列可以
用整数下标来进行索引
3，字典中数据没有先后关系，字典中的存储是无序的
4，字典中的数据以键(key)-值(value) 对形式进行映射存储
5，字典的键不能重复，且只能用”不可变类型”作为字典的键
字典的字面值表示方法：
字典的表示方式是以{} 括起来，以冒号（：）
分隔键-值对, 各键-值对之间用逗号(,)分割开
创建空字典的字面值：
d = {} #d 绑定空字典
创建非空字典的字面值：
d = {name: 'wesdasd','age':35}
d = {1:'one',2:'two',3:'three'}
d = {1:[1,2,3],'abc':(1.1,1.2,1.3)}
d ={'a':{'b':200,'c':[1,2,3]}}
d = {(1970,1,1):'computer year'}
字典的构造函数dict
dict() 生成一个字的字典等同于{}
dict(iterable) 用可迭代对象初始化一个字典
dict(**kwargs) 用关键字传参形式创建一个字典
键是变量名规则
示例：
d = dict()
d = dict([('name','tarena'),['age','15']])
字典的键(key) 必须为不可变类型
bool,int,float,complex,str,tuple,frozenset,bytes(后面讲)
字典的值(value) 可以是任意类型
可变的数据类型有四种：
list 列表
dict 字典
set 集合
bytearray 字节数组
字典的基本操作：
字典的键索引
用[] 运算符可以获取字典内‘键’对应的值
也可以用[]运算符来修改‘键’对应的值
键索引的语法：
字典[键]
示例：
获取值：
d = {'name': 'tarena','age':35}
print(d['name'],'的年龄',d['age'])
# tarena 的年龄 35
添加修改字典的元素
语法：
字典[键]=值
说明：
键不存在时，创建键，并绑定对应的值
当键存在时，修改键绑定的值
示例：
d = {}
d['name'] = 'tarena' #创建新的键值对
d['age'] = 15
d['age'] = 16 #修改'age'所对应的值
d['age']+=1 #17,数值同样修改
删除字典元素
del 字典[键]
示例：
d = {'name': 'tarena','age':15}
del d['name']
print(d) #{'age': 35}
字典的成员资格判断 in 运算符
可以用 in 运算符判断一个键是否存在于字典中，如果'键'存在则返回True
否则返回false
not in 与 in 结果相反
示例：
d = {'name': 'tarena','age':15}
if 'name' in d:
print('name 在字典中')
print(15 in d)#False,只判断键，不判断值
练习：
1，写程序，实现以下要求：
将如下数据形成一个字典seasons：
'键' '值'
1 '春季有1,2,3月'
2 '春季有4,5,6月'
3 '春季有7,8,9月'
4 '春季有10,11,12月'
方法一
# d = {}
# d[1]='春季有1,2,3月'
# d[2]='春季有4,5,6月'
# d[3]='春季有7,8,9月'
# d[4]='春季有10,11,12月'
# print(d)
方法二
seasons = {
1:'春季有1,2,3月',
2:'春季有4,5,6月',
3:'春季有7,8,9月',
4:'春季有10,11,12月'
}
print(seasons)
2，让用户输入一个整数，代表一个季度，打印这个季度对应的信息，
如果用户输入的信息不在字典内，则打印信息不存在
字典的迭代访问
字典是可迭代对象，字典只能对键进行迭代访问
示例：
d = {'name': 'tarena','age':15}
for k in d:
print(k,'对应的值是：',d[k])
可以用于字典的内建函数
len(x) 返回字典的键值对个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典中所有键的和
any(x) 真值测试，只要有一个键为True，返回True
all(x) 真值测试，当全部键为真值是，返回True
示例：
d = {0:'零',5:'伍',8:'捌',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 对象 这个可以看下下面
D = {0:'零',5:'伍',8:'捌',3:'叁'}
for k,v in D.items():
print(k,v)
#0 零
8 捌
3 叁
5 伍
D = {0:'零',5:'伍',8:'捌',3:'叁'}
for v in D.items():
print(v)
#(0, '零')
(8, '捌')
(3, '叁')
(5, '伍')
练习：
输入一段字符串，打印出这个字符串中出现过的字符的出现次数
如：
输入：
abcdabcaba
打印：
a：4次
b：3次
c：2次
d：1次
注：不要钱打印顺序
s = input('输入一段字符串: ')
d = {}
for ch in s:
if ch not in d:
d[ch] = 1
else:
d[ch]+=1
print(d)
for k in d:
print(k,':',d[k],'次')
字典推导式：
字典推导式是用可迭代对象的创建字典的表达式
语法：
{键表达式：值表达式 for 变量 in 可迭代对象 if 真值表达式}
说明：
if子句可以省略
示例：
生成一个字典，键为数字（10以内），值为键的平方
d = {x:x**2 for x in range(10)}
练习：
有字符串的列表如下：
L = ['tarena','xiaozhang','tyke']
用上述列表生成如下字典：
d = {'tarena':6,'xiaozhang':9,'tyke':4}
注：字典的值为键的长度
L = ['tarena','xiaozhang','tyke']
# d = {}
# for s in L:
# print(s)
# d[s]=len(s)
# print(d)
d = {s:len(s) for s in L}
print(d)
字典 vs 列表
1.都是可变对象
2.索引方式不同，列表用整数索引，字典用键索引
3.字典的插入，删除，修改数据的速度可能会快于列表（重要）
4.列表的存储是有序的，字典的存储是无序的
练习：
1.已知有俩个等长的列表list1 和list2，以list1中的元素为键，
以list2中的元素为值，生成相应的字典
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
生成的字典为：
{1001；'Tom',1002:'Jerry',...}
方法一：
d = {}
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
i = 0
while i <= 3:
d[list1[i]] = list2[i]
#print(d)
i += 1
print(d)
方法二：
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
d = {}
for i in range(len(list1)):
d[list1[i]] = list2[i]
print(d)
2.输入任意个学生的姓名，年龄，成绩，每个学生的信息存入字典中，然后放入至列表中，
每个学生的信息需要手动输入，当输入姓名为空时结束输入：
如：
请输入姓名：xiaozhang
请输入年龄：20
请输入成绩：100
请输入姓名：xiaoli
请输入年龄：18
请输入成绩：98
请输入姓名：<回车> 结束输入
要求内部储蓄格式如下：
[{'name':'xiaozhang','age':20,'score':100,
'name':'xiaoli','age':18,'score':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('+---------------+----------+----------+')
+---------------+----------+----------+
| name | age | score |
+---------------+----------+----------+
| xiaozhang | 20 | 100 |
| xiaoli | 18 | 98 |
+---------------+----------+----------+