2018.7.11
day07回顾
元组tuple
元组是不可变的序列容器
运算：
+ * += *=
< <= > >= == !=
in ,not in
索引和切片
字典dict
键.值（key-value）对
键不能重复，且只能用不可变类型做为字典的键
字典键[键]=值 #添加和修改键-值对
del字典[键]
{1：100,2:200}
字典的运算
键索引
字典[键] = value
var = 字典[键]
in，not in
字典推导式
{键表达式：值表达式 for in 可迭代对象 if 真值表达式...}
DAY 08笔记
集合 set
集合是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的存储结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象
集合相当于只有键没有值的字典（键则是集合的数据）
创建空集合
s = set()
创建非空集合(不能放单一列表，如列表，字典和集合，可以放迭代对象)
s = {1,2,3}
s = {3.14,True,(1970,1,1),'hello'}
集合的构造函数 set
set() 创建一个空的集合对象（不能用{} 创建空集合）
set(iterable) 用可迭代对象创建一个新的集合对象
示例：
s = {1,3,5,7}
s = set('abc')
s = set('abccba')
s = set({1:'1',2:'2',5:'5'})
s = set([1,0,3.14,'hello'])
s = set(('abc','123',True))
集合的运算：
交集，并集，补集，子集，超集
& 生成俩个集合的交集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 & s2
s3 = {2,3}
| 生成俩个集合的并集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2
s3 = {1,2,3,4}
-生成俩个集合的补集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 - s2 #生成属于s1 但不属于s2所有元素的集合
s3 = {1}
s4 = s2 - s1
s4 = {4}
^生成俩个集合的对称补集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2 #(s1 - s2) | s2 - s1
s3 = {1,4}
>判断一个集合是另一个集合的超集
<判断一个集合是另一个集合的子集
s1 = {1,2,3}
s2 = {2,3}
s1 > s2 #True s1为s2的超集
s1 < s2 False s2为s1的子集
= != 集合相同/不同
s1 = {1,2,3}
s2 = {3,2,1}
s1 == s2 #True
in ,not in 运算符
等同于字典in ，not in
作于集合中，判断某个值是否存在于集合中
集合字典的优点：
in / not in 运算符的判断速度快些
能用于集合的函数：
len(x),max(x),min(x),sum(x),any(x),all(x)
集合练习：
经理有：曹操，刘备，孙权
技术员有：曹操，孙权，张飞，关羽
用集合求：
1）即是经理，也是技术员的有谁
2）是经理，但不是技术员的人员都有谁？
3)是技术员，不是经理的都有谁
4）张飞是经历吗？
5）身兼一职的人都有谁？
6）经理和技术员共有几个人
a = set(('曹操','刘备','孙权'))
b = set(('曹操','孙权','张飞','关羽'))
c = a & b
print('即是经理，也是技术员的有谁:',c)
d = a - b
print('是经理，但不是技术员的人员:',d)
e = b - a
print('是技术员，不是经理:',e)
if "张飞" in a:
print('张飞是经理')
else:
print('张飞不是经理')
f = a ^ b
print('身兼一职的人:',f)
g = a | b
print('经理和技术员共有:',g)
print('一共',len(g),'个人')
Python3 集合的方法
方法 意义
S.add(e) 在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做;
S.clear() 清空集合内的所有元素
S.copy() 将集合进行一次浅拷贝
S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2) 用 S与s2得到的全集更新变量S
S.difference(s2) 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2) 等同于 S = S - s2
S.intersection(s2) 等同于 S & s2
S.intersection_update(s2) 等同于S = S & s2
S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回False
S.issubset(s2) 如果S与s2交集为非空返回True,空则返回False
S.issuperset(...) 如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2
S.symmetric_difference_update(s2) 用 S 与 s2 的对称补集更新 S
S.union(s2) 生成 S 与 s2的全集
集合推导式
集合推导式是用可迭代对象生成集合的表达式
语法：
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注：[] 括号部分可省略
示例：
l = [1,3,5,7,2,4,6,8,1,3,5]
s = {x for x in l} #{1, 2, 3, 4, 5, 6, 7, 8}
集合推导式可以嵌套：
语法同列表推导式一致
练习：
任意输入一些数字，存于列表L中，当输入负数时结束输入
1）打印这些数的和
2）打印这些数有多少种（去重）
3）除重复的数字后，打印这些剩余数字的和
提示可以用集合去重
L=[]
while True:
n = int(input('任意输入一些数字'))
if n < 0:
break
L+=[n]
print(L)
print('和',sum(L))
s = set(L)
print('种',len(s))
print('和',sum(s))
固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用：
固定集合可以作为字典的键，还可以作为集合的值
固定集合的构造函数：
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建固定集合
示例：
f = frozenset() #空固定集合
f = frozenset([1,3,5,7]) #f = frozenset({1,3,5,7})
固定集合的运算：
&交集，|并集，-补集，^对称补集
< <= > >= == !=
in ,not in
（以上运算符和集合set中的用法一致）
固定集合的方法
相当于集合的全部方法去掉修改集合的方法
总结
1,数据类型：
数值类型：
int，float，complex，bool
容器：
不可变的容器
str，tuple，frozenset，bytes（字节串）
可变的容器
list，dict，set，bytearray（字节数组）
2,值：
None，False，True
3,运算符
算数运算符
+ - * / // % **
比较运算符
< <= > >= == !=
in / not in
is ,is not
布尔运算：
not，and，or
+（正号）-（负号）
& ^ |
[] (索引，切片，键索引)
表达式：
1
1+2
max（1,2,3） #函数调用是表达式
x if x > y else y, 条件表达式
三种推导式：
列表，字典，集合，推导式（三种）
语句
表达式语句：
所有的表达式都可以单独写在一行，形成一个语句，例:
print('hello world')
赋值语句：
a = 100
a = b = c = 100
x,y = 100,200
a[0] = 100
dict['name'] = 'tarena'
del 语句
if 语句
while语句
for 语句
break语句
continue语句
pass语句
内建函数：
len(x),max(x),min(x),sum(x),any(x),all(x)
构造函数(用来创建同类型的数据对象)
bool(x),int(x),float(x),complex(x),list(x)
tuple(x),str(x),dict(x),set(x),frozenset(x)
abs(x),round(x),pow(x,y,z = None),
bin(x),oct(x),hex(x)
chr(x),ord(x)
range(strat,stop,step)
input(x),print(x)
函数 function
什么是函数：
函数是可以重复执行的语句块，可以重复调用
作用：
1，用于封装语句块，提高代码的重用性
2，定义用户级别的函数
语法：
def 函数名(形参列表)：
语句块
说明：
1.函数的名字就是语句块的名称
2.函数名的命名规则写变量名相同（函数名必须是标识符）
3.函数名是一个变量（不要轻易对其赋值）
4.函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数
可以访问函数外部的变量，但不能修改此变量
5.函数如果不需要传入参数，形参列表可以为空
6.语句部分不能为空，如果为空需要填充pass
示例见：
函数名（实际调用传递参数）
注：实际调用传递参数，以后简称实参
说明：
1.函数调用是一个表达式
2.如果函数内部没有return语句，函数调用完毕后返回None对象
3.如果函数需要返回其它的对象要用到 return 语句
写一个函数，打印出给定俩个数的最大值
def mm(a,b):
print('a=',a)
print('b=',b)
if a > b:
print(a,'最大')
else:
print(b,'最大')
mm(100,200)
mm('ABC','123')
练习：
1，写一个函数myadd，此函数中的参数列表里有两个参数x，y
此函数的功能是打印x + y的和
def myadd(x,y):
print('x=',x)
print('y=',y)
print('和=',x+y)
myadd(100,200)
myadd('abc','123')
2，写一个函数mysum，传入一个参数x代表终止整数，打印出
1+2+3+4+5++++x的和？
方法一：
def mysum(x):
a = 0
i = 1
while i <= x:
# print(i,end='')
a += i
i += 1
print('和',a)
mysum(100)
mysum(4)
方法二：
def mysum(x):
s = 0
for n in range(1,x+1):
#print(n,end = '+')
s += n
print(s)
mysum(100)
mysum(4)
方法三：
def mysum(x):
c = []
for n in range(1,x+1):
#print(n,end = '+')
c+=[n]
print(sum(c))
mysum(100)
mysum(4)
return 语句
语法：
return[表达式]
注：[]代表可省略
作用：
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时
返回一个对象的引用关系
return 语句说明
1.return 语句后跟的表达式可以省略，省略后相当于return None
2.如果函数内没有return语句，则函数执行完最后一条语句后返回
None（相当于在最后加了一条return None语句）
示例：
def my():
print('aaaaaa')
print('bbbbbb')
return[1,2,3,4]
print('cccccc')
v = my() #aaaaaa
#bbbbbb
print(v) #[1, 2, 3, 4]
练习：
1.写一个函数 mymax，给函数传递两个参数，返回两个实参中最大的一个
det mymax(a,b)
方法一：
def mymax(a,b):
if a > b:
return a
else:
return b
v = mymax(100,200)
print('v = ',v) #v = 200
print(mymax('ABC','abc'))
方法二：
def mymax(a,b):
return max(a,b)
v = mymax(100,200)
print('v = ',v) #v = 200
print(mymax('ABC','abc'))
2.写一个函数input_rumber
def input_rumber():
...
此函数用来获取用户循坏输入的整数，当用户输入负数时结束输入，
将用户输入的数字以列表的形式返回，再用内建函数max，min，sum
取出输入最大值，最小值，及和
def input_number():
lst = []
while True:
n = int(input('输入数字： '))
if n < 0:
break
lst +=[n]
return lst
L = input_number()
print(L)
print('最大数',max(L))
print('最小数',min(L))
print('和',sum(L))
练习：
1，写一个函数print_odd，
打印从begin开始，到end结束内的全部奇数
def print_odd(begin,end):
...
peint_old(1,10) #打印13579d
peint_old(1,10) #打印11 13 15 17 19
2，定义两个函数：
sum3(a,b,c) 用于返回三个数的和
pow3(x) 用于返回x的三次方
用以上函数计算：
1.计算1的立方+2的立方+3的立方
既：1**3+2**3+3**3的和
2.计算1+2+3的和的立方，
即：（1+2+3）**3
3，改写之前的学生信息管理程序改为俩个函数：
1.写一个函数input_student()
用于返回学生信息的字典的列表（以前格式一样）
2.写一个函数output_student(lst)
此函数传入一个列表lst，即字典的列表
此函数把lst的内容以表格形式打印出来
def input_student():
...
def output_student():
...
L = input_student() #获取学生信息的列表
output_student(L) #把L以列表的形式打印
day07回顾
元组tuple
元组是不可变的序列容器
运算：
+ * += *=
< <= > >= == !=
in ,not in
索引和切片
字典dict
键.值（key-value）对
键不能重复，且只能用不可变类型做为字典的键
字典键[键]=值 #添加和修改键-值对
del字典[键]
{1：100,2:200}
字典的运算
键索引
字典[键] = value
var = 字典[键]
in，not in
字典推导式
{键表达式：值表达式 for in 可迭代对象 if 真值表达式...}
DAY 08笔记
集合 set
集合是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的存储结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象
集合相当于只有键没有值的字典（键则是集合的数据）
创建空集合
s = set()
创建非空集合(不能放单一列表，如列表，字典和集合，可以放迭代对象)
s = {1,2,3}
s = {3.14,True,(1970,1,1),'hello'}
集合的构造函数 set
set() 创建一个空的集合对象（不能用{} 创建空集合）
set(iterable) 用可迭代对象创建一个新的集合对象
示例：
s = {1,3,5,7}
s = set('abc')
s = set('abccba')
s = set({1:'1',2:'2',5:'5'})
s = set([1,0,3.14,'hello'])
s = set(('abc','123',True))
集合的运算：
交集，并集，补集，子集，超集
& 生成俩个集合的交集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 & s2
s3 = {2,3}
| 生成俩个集合的并集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2
s3 = {1,2,3,4}
-生成俩个集合的补集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 - s2 #生成属于s1 但不属于s2所有元素的集合
s3 = {1}
s4 = s2 - s1
s4 = {4}
^生成俩个集合的对称补集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2 #(s1 - s2) | s2 - s1
s3 = {1,4}
>判断一个集合是另一个集合的超集
<判断一个集合是另一个集合的子集
s1 = {1,2,3}
s2 = {2,3}
s1 > s2 #True s1为s2的超集
s1 < s2 False s2为s1的子集
= != 集合相同/不同
s1 = {1,2,3}
s2 = {3,2,1}
s1 == s2 #True
in ,not in 运算符
等同于字典in ，not in
作于集合中，判断某个值是否存在于集合中
集合字典的优点：
in / not in 运算符的判断速度快些
能用于集合的函数：
len(x),max(x),min(x),sum(x),any(x),all(x)
集合练习：
经理有：曹操，刘备，孙权
技术员有：曹操，孙权，张飞，关羽
用集合求：
1）即是经理，也是技术员的有谁
2）是经理，但不是技术员的人员都有谁？
3)是技术员，不是经理的都有谁
4）张飞是经历吗？
5）身兼一职的人都有谁？
6）经理和技术员共有几个人
a = set(('曹操','刘备','孙权'))
b = set(('曹操','孙权','张飞','关羽'))
c = a & b
print('即是经理，也是技术员的有谁:',c)
d = a - b
print('是经理，但不是技术员的人员:',d)
e = b - a
print('是技术员，不是经理:',e)
if "张飞" in a:
print('张飞是经理')
else:
print('张飞不是经理')
f = a ^ b
print('身兼一职的人:',f)
g = a | b
print('经理和技术员共有:',g)
print('一共',len(g),'个人')
Python3 集合的方法
方法 意义
S.add(e) 在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做;
S.clear() 清空集合内的所有元素
S.copy() 将集合进行一次浅拷贝
S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2) 用 S与s2得到的全集更新变量S
S.difference(s2) 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2) 等同于 S = S - s2
S.intersection(s2) 等同于 S & s2
S.intersection_update(s2) 等同于S = S & s2
S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回False
S.issubset(s2) 如果S与s2交集为非空返回True,空则返回False
S.issuperset(...) 如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2
S.symmetric_difference_update(s2) 用 S 与 s2 的对称补集更新 S
S.union(s2) 生成 S 与 s2的全集
集合推导式
集合推导式是用可迭代对象生成集合的表达式
语法：
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注：[] 括号部分可省略
示例：
l = [1,3,5,7,2,4,6,8,1,3,5]
s = {x for x in l} #{1, 2, 3, 4, 5, 6, 7, 8}
集合推导式可以嵌套：
语法同列表推导式一致
练习：
任意输入一些数字，存于列表L中，当输入负数时结束输入
1）打印这些数的和
2）打印这些数有多少种（去重）
3）除重复的数字后，打印这些剩余数字的和
提示可以用集合去重
L=[]
while True:
n = int(input('任意输入一些数字'))
if n < 0:
break
L+=[n]
print(L)
print('和',sum(L))
s = set(L)
print('种',len(s))
print('和',sum(s))
固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用：
固定集合可以作为字典的键，还可以作为集合的值
固定集合的构造函数：
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建固定集合
示例：
f = frozenset() #空固定集合
f = frozenset([1,3,5,7]) #f = frozenset({1,3,5,7})
固定集合的运算：
&交集，|并集，-补集，^对称补集
< <= > >= == !=
in ,not in
（以上运算符和集合set中的用法一致）
固定集合的方法
相当于集合的全部方法去掉修改集合的方法
总结
1,数据类型：
数值类型：
int，float，complex，bool
容器：
不可变的容器
str，tuple，frozenset，bytes（字节串）
可变的容器
list，dict，set，bytearray（字节数组）
2,值：
None，False，True
3,运算符
算数运算符
+ - * / // % **
比较运算符
< <= > >= == !=
in / not in
is ,is not
布尔运算：
not，and，or
+（正号）-（负号）
& ^ |
[] (索引，切片，键索引)
表达式：
1
1+2
max（1,2,3） #函数调用是表达式
x if x > y else y, 条件表达式
三种推导式：
列表，字典，集合，推导式（三种）
语句
表达式语句：
所有的表达式都可以单独写在一行，形成一个语句，例:
print('hello world')
赋值语句：
a = 100
a = b = c = 100
x,y = 100,200
a[0] = 100
dict['name'] = 'tarena'
del 语句
if 语句
while语句
for 语句
break语句
continue语句
pass语句
内建函数：
len(x),max(x),min(x),sum(x),any(x),all(x)
构造函数(用来创建同类型的数据对象)
bool(x),int(x),float(x),complex(x),list(x)
tuple(x),str(x),dict(x),set(x),frozenset(x)
abs(x),round(x),pow(x,y,z = None),
bin(x),oct(x),hex(x)
chr(x),ord(x)
range(strat,stop,step)
input(x),print(x)
函数 function
什么是函数：
函数是可以重复执行的语句块，可以重复调用
作用：
1，用于封装语句块，提高代码的重用性
2，定义用户级别的函数
语法：
def 函数名(形参列表)：
语句块
说明：
1.函数的名字就是语句块的名称
2.函数名的命名规则写变量名相同（函数名必须是标识符）
3.函数名是一个变量（不要轻易对其赋值）
4.函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数
可以访问函数外部的变量，但不能修改此变量
5.函数如果不需要传入参数，形参列表可以为空
6.语句部分不能为空，如果为空需要填充pass
示例见：
函数名（实际调用传递参数）
注：实际调用传递参数，以后简称实参
说明：
1.函数调用是一个表达式
2.如果函数内部没有return语句，函数调用完毕后返回None对象
3.如果函数需要返回其它的对象要用到 return 语句
写一个函数，打印出给定俩个数的最大值
def mm(a,b):
print('a=',a)
print('b=',b)
if a > b:
print(a,'最大')
else:
print(b,'最大')
mm(100,200)
mm('ABC','123')
练习：
1，写一个函数myadd，此函数中的参数列表里有两个参数x，y
此函数的功能是打印x + y的和
def myadd(x,y):
print('x=',x)
print('y=',y)
print('和=',x+y)
myadd(100,200)
myadd('abc','123')
2，写一个函数mysum，传入一个参数x代表终止整数，打印出
1+2+3+4+5++++x的和？
方法一：
def mysum(x):
a = 0
i = 1
while i <= x:
# print(i,end='')
a += i
i += 1
print('和',a)
mysum(100)
mysum(4)
方法二：
def mysum(x):
s = 0
for n in range(1,x+1):
#print(n,end = '+')
s += n
print(s)
mysum(100)
mysum(4)
方法三：
def mysum(x):
c = []
for n in range(1,x+1):
#print(n,end = '+')
c+=[n]
print(sum(c))
mysum(100)
mysum(4)
return 语句
语法：
return[表达式]
注：[]代表可省略
作用：
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时
返回一个对象的引用关系
return 语句说明
1.return 语句后跟的表达式可以省略，省略后相当于return None
2.如果函数内没有return语句，则函数执行完最后一条语句后返回
None（相当于在最后加了一条return None语句）
示例：
def my():
print('aaaaaa')
print('bbbbbb')
return[1,2,3,4]
print('cccccc')
v = my() #aaaaaa
#bbbbbb
print(v) #[1, 2, 3, 4]
练习：
1.写一个函数 mymax，给函数传递两个参数，返回两个实参中最大的一个
det mymax(a,b)
方法一：
def mymax(a,b):
if a > b:
return a
else:
return b
v = mymax(100,200)
print('v = ',v) #v = 200
print(mymax('ABC','abc'))
方法二：
def mymax(a,b):
return max(a,b)
v = mymax(100,200)
print('v = ',v) #v = 200
print(mymax('ABC','abc'))
2.写一个函数input_rumber
def input_rumber():
...
此函数用来获取用户循坏输入的整数，当用户输入负数时结束输入，
将用户输入的数字以列表的形式返回，再用内建函数max，min，sum
取出输入最大值，最小值，及和
def input_number():
lst = []
while True:
n = int(input('输入数字： '))
if n < 0:
break
lst +=[n]
return lst
L = input_number()
print(L)
print('最大数',max(L))
print('最小数',min(L))
print('和',sum(L))
练习：
1，写一个函数print_odd，
打印从begin开始，到end结束内的全部奇数
def print_odd(begin,end):
...
peint_old(1,10) #打印13579d
peint_old(1,10) #打印11 13 15 17 19
2，定义两个函数：
sum3(a,b,c) 用于返回三个数的和
pow3(x) 用于返回x的三次方
用以上函数计算：
1.计算1的立方+2的立方+3的立方
既：1**3+2**3+3**3的和
2.计算1+2+3的和的立方，
即：（1+2+3）**3
3，改写之前的学生信息管理程序改为俩个函数：
1.写一个函数input_student()
用于返回学生信息的字典的列表（以前格式一样）
2.写一个函数output_student(lst)
此函数传入一个列表lst，即字典的列表
此函数把lst的内容以表格形式打印出来
def input_student():
...
def output_student():
...
L = input_student() #获取学生信息的列表
output_student(L) #把L以列表的形式打印