2018.7.11
day07回顾
元组tuple
- 元组是不可变的序列容器
运算:
- + * += *=
- < <= > >= == !=
- in ,not in
- 索引和切片
字典dict
- 键.值(key-value)对
键不能重复,且只能用不可变类型做为字典的键
字典键[键]=值 #添加和修改键-值对
- del字典[键]
{1:100,2:200}
字典的运算
- 键索引
- 字典[键] = value
- var = 字典[键]
- in,not in
字典推导式
- {键表达式:值表达式 for in 可迭代对象 if 真值表达式...}
day08笔记
集合 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)经理和技术员共有几个人
manager = {'曹操', '刘备', '孙权'}
techs = {'曹操', '孙权', '张飞', '关羽'}
print("即是经理,也是技术员的有", manager & techs)
print("是经理,但不是技术员的人员都有", manager - techs)
print("是技术员,不是经理的都有", techs - manager)
if '张飞' in manager:
print("张飞是经理")
else:
print("张飞不是经理")
print("身兼一职的人都有", manager ^ techs)
print('经理和技术员共有%d个人' % len(manager | techs))
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')
- 1+2
赋值语句:
- 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)
- >>>help(__builtins__)
函数 function
什么是函数:
- 函数是可以重复执行的语句块,可以重复调用
作用:
- 用于封装语句块,提高代码的重用性
- 定义用户级别的函数
语法:
- def 函数名(形参列表):
- 语句块
说明:
- 函数的名字就是语句块的名称
- 函数名的命名规则写变量名相同(函数名必须是标识符)
- 函数名是一个变量(不要轻易对其赋值)
- 函数有自己的名字空间,在函数外部不可以访问函数内部的变量,在函数可以访问函数外部的变量,但不能修改此变量
- .函数如果不需要传入参数,形参列表可以为空
- 语句部分不能为空,如果为空需要填充pass
示例见:
def say_hello():
print("hello world!")
print("hello tarena!")
print("hello everyone!")
say_hello() # 调用函数
say_hello()
say_hello()
函数调用
函数名(实际调用传递参数)
注:实际调用传递参数,以后简称实参
说明:
- 函数调用是一个表达式
- 如果函数内部没有return语句,函数调用完毕后返回None对象
- 如果函数需要返回其它的对象要用到 return 语句
写一个函数,打印出给定俩个数的最大值
def mymax(a, b):
print('a =', a)
print('b =', b)
if a > b:
print(a, "最大")
else:
print(b, '最大')
mymax(100, 200)
mymax("ABC", "123")
练习:
1,写一个函数myadd,此函数中的参数列表里有两个参数x,y
此函数的功能是打印x + y的和
def myadd(x, y):
print(x + y)
myadd(100, 200) # 300
myadd("ABC", "123") # ABC123
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 语句说明
- return 语句后跟的表达式可以省略,省略后相当于return None
- 如果函数内没有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,给函数传递两个参数,返回两个实参中最大的一个
# 方法1
# def mymax(a, b):
# if a > b:
# return a
# else:
# return b
# 方法2
# def mymax(a, b):
# if a > b:
# return a
# return b
# 方法3
def mymax(a, b):
return max(a, b)
v = mymax(100, 200)
print('v =', v) # v = 200
print(mymax('ABC', '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.append(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) #打印13579
peint_old(1,10) #打印11 13 15 17 19
# 方法1
def print_odd(a, b=0):
if b == 0:
for x in range(1, a, 2):
print(x, end=' ')
else:
print()
else:
if a % 2 == 0: # 如果是偶数,变为奇数
a += 1
for x in range(a, b, 2):
print(x, end=' ')
else:
print()
def print_odd(a, b=None):
if b is None:
start = 1
end = a
else:
start = a
end = b
# 如果开始的偶数,做校正
if start % 2 == 0:
start += 1
for x in range(start, end, 2):
print(x, end=' ')
print()
print_odd(10) # 1 3 5 7 9
print_odd(11, 20) # 11 13 15 17 19
print_odd(10, 20)
print_odd(5, 0)
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
def sum3(a, b, c):
return a + b + c
def pow3(x):
return x ** 3
# 1. 计算1的立方 + 2的立方 + 3的立方的和
# 即: 1**3 + 2**3 + 3**3的和
print(sum3(pow3(1), pow3(2), pow3(3)))
# 2. 计算1 + 2 + 3 的和的立方,
# 即: (1+2+3)**3
print(pow3(sum3(1, 2, 3)))
3,改写之前的学生信息管理程序改为俩个函数:
1.写一个函数input_student()
用于返回学生信息的字典的列表(以前格式一样)
2.写一个函数output_student(lst)
此函数传入一个列表lst,即字典的列表
此函数把lst的内容以表格形式打印出来
def input_student():
...
def output_student():
...
L = input_student() #获取学生信息的列表
output_student(L) #把L以列表的形式打印
def input_student():
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)
return L
def output_student(lst):
# 打印表格
print("+---------------+----------+----------+")
print("| name | age | score |")
print("+---------------+----------+----------+")
for d in lst:
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("+---------------+----------+----------+")
L = input_student() # 获取学生信息的列表
# print(L)
output_student(L) # 把L 以列表的形式打印