day07 回顾:
两个容器:
元组 tuple(不可变的序列)
字典 dict(可变的无序的容器)
元组
序列: 字符串 str, 列表 list, 元组 tuple, bytes, bytearray
元组的表示方式:
() (20,) (1, 2 ,3) 20, 1,2,3
构造函数:
tuple() tuple(可迭代对象)
元组的运算:
+ += * *=
< <= > >= == !=
in / not in
索引取值和切片取值
len(x), max(x), ..........
reversed(x) sorted(x, reverse=False)
字典:
可变的容器,字典的存储是无序的
键值对方式存储, (键: 不可变对象, 值: 可以是任意对象)
字面值:
{1: "hello"}
{'name': 'xiaozhang', 'age': 20, 'score':100}
构造函数
dict()
dict([(1, "壹"), (2, '二')])
dict(name='xiaozhang', age=20, score=100)
字典的运算:
键索引取值:
v = 字典[键]
赋值:
字典[键] = v
del 字典[键]
== !=
能用于字典的函数:
len(x), max(x), min(x), sum(x), any(x), all(x)
字典的方法:
D.clear()
D.pop(key)
D.copy()
D.update(d2) 更新
D.get(key, default=None) # 取值(不会报错)
D.keys()
D.values()
D.items()
字典推导式
{键表达式: 值表达式 for 变量 in 可迭代对象 if 真值表达式}
day08笔记
集合 set
集合是可变的容器
集合内的数据对象都是唯一的(不能重复多次的)
集合是无序的存储结构,集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象(可以用for等遍历)
集合是相当于只有键,没有值的字典(键则是集合的数据)
创建空集合:
set()
创建非空集合的字面值:
s = {1, 2, 3}
集合的构造函数: set
set() 创建一个空的集合对象(不能用{}来创建空集合)
set(iterable) 用可迭代对象创建一个新的集合对象
示例:
s = set()
s = {1, 2, 3, 4}
s = set("ABC")
s = set("ABCABC") # s = {'A', 'B', 'C'}
s = set([1, 0, 3.14, 0.618])
# s = {1, 2, [3, 4], 5} # 报错,集合内不能放列表和字典
# s = {1, 2, {3, 4}, 5} # 出错集合是可变对象
集合的运算:
交集&, 并集|, 补集-, 对称补集^, 子集<, 超级>
& 运算符生成两个集合的交集
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的所有元素的集合
^ 生成两个集合的对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # s3 = {1, 4}
> 判断一个集合是另一个集合的超集
< 判断一个集合是另一个集合的子集
s1 = {1, 2, 3}
s2 = {2, 3}
s1 > s2 # True, s1为s2的超集
s2 < s1 # True, s2为s1的子集
== != 集合相同或不同
s1 = {1, 2, 3}
s2 = {2, 3, 1}
s1 == s2 # True 相同
s1 != s1 # False
>= <= 超集或相同, 子集或相同
in / not in 运算符:
等同于字典, in 用于集合中,当某个值存在于集合中返回True,否
则返回False
not in 与 in 返回值相反
说明:
集合的in / not in 运算符查找速度比较快
能用于集合的内建函数:
len(x) max(x) min(x) sum(x) any(x) all(x)
集合是可迭代对象
练习:
经理有: 曹操, 刘备, 孙权
技术员有: 曹操, 孙权, 张飞, 关羽
用集合求:
1. 即是经理也是技术员的有谁?
2. 是经理,但不是技术人员的都有谁?
3. 是技术人员,但不是经理的人都有谁?
4. 张飞是经理吗?
5. 身兼一职的人都有谁?
6. 经理和技术人员共有几个人?
1 # 练习: 2 # 经理有: 曹操, 刘备, 孙权 3 # 技术员有: 曹操, 孙权, 张飞, 关羽 4 # 用集合求: 5 # 1. 即是经理也是技术员的有谁? 6 # 2. 是经理,但不是技术人员的都有谁? 7 # 3. 是技术人员,但不是经理的人都有谁? 8 # 4. 张飞是经理吗? 9 # 5. 身兼一职的人都有谁? 10 # 6. 经理和技术人员共有几个人? 11 12 13 manager = {"曹操", "刘备", "孙权"} 14 techs = {"曹操", "孙权", "张飞", "关羽"} 15 print("即是经理也是技术员的有:", manager & techs) 16 print("是经理,但不是技术人员的都有:", manager - techs) 17 print("是技术人员,但不是经理的人都有", techs - manager) 18 if "张飞" in manager: 19 print("张飞是经理") 20 else: 21 print("张飞不是经理") 22 23 print("身兼一职的人都有:", manager ^ techs) 24 print("经理和技术人员共有", len(manager | techs), "个人") 25 26 27 28 29 30 31 32
集合的方法:
文档参见:
python_base_docs_html/set.html
集合是可迭代对象
集合推导式:
集合推导式是用可迭代对象创建集合的表达式
语法:
{ 表达式 for 变量 in 可迭代对象 [if 真值表达式]}
示例:
s = { x**2 for x in range(1, 10)}
集合推导式可以嵌套
语法同列表推导式的嵌套相同
固定集合 frozenset
固定集合是不可变的,无序的,含有唯一元组的集合
作用:
固定集合可以作为字典的键,还可以作为集合的值
创建固定集合构造函数 frozenset
frozenset() 创建一个空的固定集合对象
frozenset(iterable) 用可迭代对象创建一个新的固定集合对象
示例:
fz = frozenset()
fz = frozenset(range(10))
fz = frozenset([1, 3, 8, 6, 9])
d = {frozenset({1,2,3}): "集合1,2,3"}
固定集合的运算:
& 交集
| 并集
- 补集
^ 对称补集
< 子集
> 超集
<= >= == !=
in / not in
(以上运算规则等同于set中的规则)
固定集合的方法:
相当于集合的全部方法去掉修改集合的方法
阶段总结:
数据类型:
不可变类型
数字: bool, int, float, complex
容器: str, tuple, frozenset, bytes(后面才学)
可变类型
list, dict, set, bytearray(后面才学)
值:
None, False, True
表达式:
1
1 + 2
print("hello")
max("ABC") + min("123")
条件表达式: x if x > y else y
全部的推导式: 列表, 字典, 集合推导式
语句:
表达式语句:
print("hello")
"""ABCD"""
赋值语句:
a = 100
a = b = c = 200
x, y = 100, 200
L[1] = 200
d['key'] = '键'
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(r=0.0, i=0.0)
str(x)
list(x)
tuple(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(start, stop, step)
reversed(x)
sorted(x, reverse=False)
输入输出相关:
input(x)
print(...)
其它:
type(x)
id(x)
函数 function
什么是函数:
函数是可以重复执行的语句块,可以重复使用
函数是面向过程编程的最小单位
函数的作用:
1. 用于封装语句块,提高代码的重用性
2. 定义用户级别的函数
def 语句
语法:
def 函数名(形参列表):
语句块(代码块)
说明:
1. 函数的名字就是语句块的名称
2. 函数名的命名规则与变量名相同(函数名必须为标识符)
3. 函数名是一个变量(不要轻易对其赋值)
4. 函数有自己的名字空间,在函数外部不可以访问函数内部的变量
在函数内部可以访问函数外部的变量,要让函数处理外部数据
需要传入一些数据
5. 函数如果不需要传入参数,则参数列表可以为空
6. 语句部分不能为空,如果为空需要填充pass语句
作用:
用于创建函数,用函数名这个变量绑定这个函数
示例见:
def.py
def2.py
1 # def.py 2 3 4 # 此示例示意用def语句定义一个没有参数的函数 5 6 def say_hello(): 7 print("hello world!") 8 print("hello china!") 9 print("hello tarena!") 10 11 say_hello() 12 say_hello() 13 say_hello()
1 # def2.py 2 3 4 # 此示例示意用def语句来定义带有参数的函数 5 # 此函数名为mymax, 有两个形式参数a, b 用于接收实参的传递 6 # 此函数计算两个参数的最大值并打印 7 def mymax(a, b): 8 print('a=', a) 9 print('b=', b) 10 if a > b: 11 print(a, "大于", b) 12 else: 13 print(a, '小于等于', b) 14 15 mymax(100, 200) # 函数调用 16 17
函数的调用表达式:
函数名(实际调用传递参数)
说明:
函数调用是一个表达式
如果没有return语句,函数执行完毕后返回None对象
练习:
写一个函数myadd,此函数中的参数列表里有两个参数x,y
此函数的功能是打印 x + y 的和
如:
def myadd(...):
... # ...部分自己实现
myadd(100, 200) # 打印 300
myadd("ABC", "123") # 打印 ABC123
1 # 练习: 2 # 写一个函数myadd,此函数中的参数列表里有两个参数x,y 3 # 此函数的功能是打印 x + y 的和 4 # 如: 5 # def myadd(...): 6 # ... # ...部分自己实现 7 # myadd(100, 200) # 打印 300 8 # myadd("ABC", "123") # 打印 ABC123 9 10 11 def myadd(x, y): 12 z = x + y 13 print('和是:', z) 14 15 myadd(100, 200) # 打印 300 16 myadd("ABC", "123") # 打印 ABC123 17 18 # print(z) # 报错! 19 # print(x) 20 # print(y)
1 2 def myadd(x, y): 3 z = x + y 4 print('和是:', z) 5 6 v = myadd(100, 200) # 打印 300 7 print("v=", v) # v= None 8
1 # 2. 写一个函数myadd,实现给出两个数,返回这两个数的和 2 # 如: 3 # def myadd(x, y): 4 # ... 5 # a = int(input("请输入第一个数: ")) 6 # b = int(input("请输入第二个数: ")) 7 # print("您输入的两个数的和是:", myadd(a, b)) 8 9 # 方法1 10 # def myadd(x, y): 11 # z = x + y 12 # return z 13 14 # 方法2 15 # def myadd(x, y): 16 # return x + y 17 18 a = int(input("请输入第一个数: ")) 19 b = int(input("请输入第二个数: ")) 20 print("您输入的两个数的和是:", myadd(a, b)) 21 22
练习2
写一个函数print_event,传入一个参数n代表终止的整数,打印
0 ~ n 之间所有的偶数
如:
def print_even(n):
..... 此处自己完成
print_even(10)
打印:
0
2
4
6
8
1 # 练习2 2 # 写一个函数print_even,传入一个参数n代表终止的整数,打印 3 # 0 ~ n 之间所有的偶数 4 # 如: 5 # def print_even(n): 6 # ..... 此处自己完成 7 # print_even(10) 8 # 打印: 9 # 0 10 # 2 11 # 4 12 # 6 13 # 8 14 15 16 def print_even(n): 17 for x in range(0, n+1, 2): 18 print(x) 19 20 print_even(10) 21 22 23
return 语句:
语法:
return [表达式]
注: [] 代表其中的内容可省略
作用:
用于函数中,结束当前函数的执行,返回到调用该函数的地方,同
时返回一个对象的引用关系
说明:
1. return 语句先执行右侧的表达式,再将表达式的执行结果送
回给当前函数的调用者
2. return 语句右侧的表达式可以省略,省略后相当
于return None
3. 如果函数内没有return语句,则函数执行完最后一条语句后
返回None(相当于在最后加了一条return None语句)
示例见:
return.py
1 # return.py 2 3 # 此示例示意return语句在函数中的应用 4 5 def say_hello2(): 6 print("hello aaa") 7 print("hello bbb") 8 return # 等同于 return None 9 # return 1 + 2 10 # return [1, 2, 3, 4] 11 print("hello ccc") 12 13 v = say_hello2() 14 print("v=", v) 15 16 v2 = say_hello2() 17 print("v2=", v2) 18 19
1 # return.py 2 3 # 此示例示意return语句在函数中的应用 4 5 def say_hello2(): 6 print("hello aaa") 7 print("hello bbb") 8 print("hello ccc") 9 return None 10 11 v = say_hello2() 12 print("v=", v) 13 14
练习:
1. 写一个函数mymax, 实现返回两个数的最大值:
如:
def mymax(a, b):
.... # 此处自己实现
print(mymax(100, 200)) # 200
print(mymax("ABC", 'ABCD')) # ABCD
1 # 练习: 2 # 1. 写一个函数mymax, 实现返回两个数的最大值: 3 # 如: 4 # def mymax(a, b): 5 # .... # 此处自己实现 6 7 # print(mymax(100, 200)) # 200 8 # print(mymax("ABC", 'ABCD')) # ABCD 9 10 # 方法1 11 # def mymax(a, b): 12 # zuida = a 13 # if b > zuida: 14 # zuida = b 15 # return zuida 16 17 # 方法2 18 # def mymax(a, b): 19 # if a > b: 20 # return a 21 # else: 22 # return b 23 24 # 方法3 25 def mymax(a, b): 26 if a > b: 27 return a 28 return b 29 30 print(mymax(100, 200)) # 200 31 print(mymax("ABC", 'ABCD')) # ABCD 32 33
2. 写一个函数myadd,实现给出两个数,返回这两个数的和
如:
def myadd(x, y):
...
a = int(input("请输入第一个数: "))
b = int(input("请输入第二个数: "))
print("您输入的两个数的和是:", myadd(a, b))
3 写一个函数 input_number
def input_number():
.... # 此处自己实现,此函数返回列表
此函数用来获取用户循环输往返整数,当用户输入负数时结束输入
将用户输入的数字以列表的形式返回,再用内建函数max,min,
sum 求出用户输入的最大值,最小值及和
L = input_number()
print("用户输入的最大数是:", max(L))
print("用户输入的最小数是:", min(L))
print("用户输入的全部数的和是:", sum(L))
1 # 3 写一个函数 input_number 2 # def input_number(): 3 # .... # 此处自己实现,此函数返回列表 4 5 # 此函数用来获取用户循环输往返整数,当用户输入负数时结束输入 6 # 将用户输入的数字以列表的形式返回,再用内建函数max,min, 7 # sum 求出用户输入的最大值,最小值及和 8 9 # L = input_number() 10 # print("用户输入的最大数是:", max(L)) 11 # print("用户输入的最小数是:", min(L)) 12 # print("用户输入的全部数的和是:", sum(L)) 13 14 15 16 17 def input_number(): 18 # 1. 创建空列表 19 myL = [] 20 # 2. 循环读取用户输入的正整数,存入在述列表 21 while True: 22 x = int(input("请输入正整数: ")) 23 if x < 0: 24 break 25 myL.append(x) 26 # 3. 返回上述列表的引用关系 27 return myL 28 29 L = input_number() 30 print("用户输入的最大数是:", max(L)) 31 print("用户输入的最小数是:", min(L)) 32 print("用户输入的全部数的和是:", sum(L)) 33
练习:
1. 定义两个函数:
sum3(a, b, c) 用于返回三个数的和
pow3(x) 用于返回x的三次方(立方)
用以上函数计算:
1. 计算1的立方 + 2的立方+3的立方的和
2. 计算 1+2+3 的和的立方
即:
1**3 + 2**3 + 3**3 和 (1+2+3)**3
1 # 1. 定义两个函数: 2 # sum3(a, b, c) 用于返回三个数的和 3 # pow3(x) 用于返回x的三次方(立方) 4 # 用以上函数计算: 5 # 1. 计算1的立方 + 2的立方+3的立方的和 6 # 2. 计算 1+2+3 的和的立方 7 # 即: 8 # 1**3 + 2**3 + 3**3 和 (1+2+3)**3 9 10 11 def sum3(a, b, c): # 用于返回三个数的和 12 return a + b + c 13 14 def pow3(x): # 用于返回x的三次方(立方) 15 return x ** 3 16 17 18 # 1. 计算1的立方 + 2的立方+3的立方的和 19 print(sum3(pow3(1), pow3(2), pow3(3))) # 36 20 21 # 2. 计算 1+2+3 的和的立方 22 print(pow3(sum3(1, 2, 3))) # 216 23 24
2. 写一个函数 get_chinese_char_count(s), 此函数功能是
给定一个字符串s,返回这个字符串中中文字符的个数
def get_chinese_char_count(s):
...
s = input("请输入中英文混合的字符串: ")
print("中文字符的个数是:",
get_chinese_char_count(s))
注: 中文的编码范围是: 0x4E00~0x9FA5
1 # 2. 写一个函数 get_chinese_char_count(s), 此函数功能是 2 # 给定一个字符串s,返回这个字符串中中文字符的个数 3 # def get_chinese_char_count(s): 4 # ... 5 # s = input("请输入中英文混合的字符串: ") 6 # print("中文字符的个数是:", 7 # get_chinese_char_count(s)) 8 # 注: 中文的编码范围是: 0x4E00~0x9FA5 9 10 11 def get_chinese_char_count(s): 12 count = 0 13 for ch in s: 14 if 0x4e00 <= ord(ch) <= 0x9fa5: 15 count += 1 16 return count 17 18 s = input("请输入中英文混合的字符串: ") 19 print("中文字符的个数是:", get_chinese_char_count(s)) 20 21
3. 改写之前的学生信息管理程序:
用两个函数来封装功能的代码块
函数1: input_student() # 返回学生信息字典的列表
函数2: output_student(L) # 打印学生信息的表格
def input_student():
... 此处自己实现
def output_student(L):
... 此处自己实现
infos = input_student()
print(infos) # 打印列表[{...}, {...}]
output_student(infos) # 根据实参infos打印表格
1 2 # 3. 改写之前的学生信息管理程序: 3 # 用两个函数来封装功能的代码块 4 # 函数1: input_student() # 返回学生信息字典的列表 5 # 函数2: output_student(L) # 打印学生信息的表格 6 7 def input_student(): 8 L = [] # 创建一个列表,准备存放学生数据的字典 9 while True: 10 n = input("请输入姓名: ") 11 if not n: # 如果用户输入空字符串就结束输入 12 break 13 a = int(input("请输入年龄: ")) 14 s = int(input("请输入成绩: ")) 15 d = {} # 一定要每次都创建一个新的字典 16 d['name'] = n 17 d['age'] = a 18 d['score'] = s 19 L.append(d) # 把d加入列表中L 20 return L 21 22 def output_student(L): 23 print("+---------------+----------+----------+") 24 print("| 姓名 | 年龄 | 成绩 |") 25 print("+---------------+----------+----------+") 26 for d in L: 27 name = d['name'] 28 age = str(d['age']) # 转为字符串 29 score = str(d['score']) # 转为字符串 30 print("|%s|%s|%s|" % (name.center(15), 31 age.center(10), 32 score.center(10))) 33 print("+---------------+----------+----------+") 34 35 36 infos = input_student() 37 print(infos) # 打印列表[{...}, {...}] 38 output_student(infos) # 根据实参infos打印表格 39