python基础day11笔记

2018.7.16
day10回顾:
局部变量全局变量

locals() globals()

def fa(a, b):
pass
一个函数可以作为参数传入另一个函数
def fx(fn):
pass
fx(max) # 传入一个函数
函数可以作为另一个函数的返回值
　　　　def fx():
return max

m = fx() # 此函数调用返回一个max函数

def fy():
def hello():
print("hello")
return hello
h = fy()
h() # 此

函数嵌套定义

python 四个作用域:
局部作用域　
外部嵌套函数作用域
全局作用域
内建模块的作用域

　　　　global 语句
nonlocal 语句

def 语句创建函数
lambda 表达式
myadd = lambda x, y: x + y

eval(s) 函数
... 表达式 ...

exec(s) 函数
... 语句(程序) ...

day11笔记:
函数式编程
　　函数式编程是指用一系列函数解决问题
好处:
1．　用每一个函数完成细小的功能，一系列函数的任意组合可以完成大问题
2．　函数仅接受输入并产生输入，不包含任何能影响输出的内部状态

函数的可重入性
如果一个函数的输入参数一定，则返回结果必须一定的函数称为可重入函数
示例:
# 可重入函数，传入参数一定．结果必然一定
def myadd(x, y):
return x + y

　　　　# 不可重入函数:
y = 200
def myadd2(x):
return x + y
print(myadd2(10)) # 210
y = 300
print(myadd2(10)) # 310

函数式编程的要求:
def 创建的函数最好不要访问局部作用域以外的变量，这样可以保证返回结果的唯一性(可重入性)

高阶函数 High Order Function
什么是高阶函数:
满足下列条件之一的即为高阶函数
1. 函数接受一个或多个函数作为参数传入
2. 函数返回一个函数

python内建的高阶函数:
map, filter, sorted
详见:
python_base_docs_html/内建函数(builtins).html

map函数:
格式:
map(func, *iterables)
示例见:
map.py

# 生成一个可迭代对象，此可迭代对象可以生成1~9自然数的平方
# 1 4 9 16 ..... 81
def power2(x):
return x ** 2

for x in map(power2, range(1, 10)):
print(x) # 1 4 9 16 ....

print('---------------------')
# 生成 1**3 , 2**3, 3**3
def power3(x):
return x ** 3

for x in map(power3, range(1, 10)):
print(x)

print('======================')
for x in map(lambda x: x**4, range(1, 10)):
print(x)

练习:
1. 用map函数求:
1**3 + 2**3 + 3 ** 3 + .... 9**3 的和

def power_a_b(a, b):
return a ** b

for x in map(power_a_b,
[1, 2, 3, 4, 5, 6, 7, 8],
[4, 3, 2, 1]):
print(x)

2. 用map函数求:
1**4 + 2**4 + 3 ** 4 + .... 20**4 的和

提示: sum(map(.....))

map示例:
求 1**9 + 2**8 + 3**7 + ...... 9**1

s = 0
for x in map(pow, range(1, 10), range(9, 0,-1)):
s += x
print(s)

filter 函数:
filter(function, iterable)

filter示例见:
filter.py

# 写一个函数判断x是否为奇数，奇数返回True,偶数返回False
def is_odd(x):
if x % 2 == 1:
return True
return False

# 生成1~10以内奇数的列表 # [1, 3, 5, 7, 9]
for x in filter(is_odd, range(1, 10)):
print(x)

L = [x for x in filter(is_odd, range(1, 10))]

print(L) # [1, 3, 5, 7, 9]

练习:
1. 将 1 ～　２０　的偶数用filter生成可迭代对象后将可迭代对象生成的数放入到列表L中
def d(x):
if x % 2 ==0:
return True
return False

for x in filter(d,range(1,21)):
print(x)

L=[x for x in filter(d,range(1,21))]
print(L)

2. 写一个函数is_prime(x) 判断x是否是素数
用filter函数打印出: 20 ~ 30之间的全部素数
def d(x):
if x < 2:
return False
for i in range(2,x):
if x % i ==0:
return False
return True
for x in filter(d,range(20,31)):
print(x)

sorted 函数:
作用:
将原可迭代对象的数据进行排序，生成排序后的列表
格式:
sorted(iterable, key=None, reverse=False)
说明:
iterable 可迭代对象
key 函数是用来提供一个值，这个值将做为排序的依据
reverse 标志用来设置是否降序排序
示例见:
sorted.py
L=[5,-2,-4,0,3,1]
L4=sorted(L,key=abs)
print(L4) #L4=[0,1,-2,3,-4,5]
L5=sorted(L,key=abs,reverse=True) #绝对值大小降序排序
print(L5) #L5=[5, -4, 3, -2, 1,

练习:
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
排序的依据为字符串的反序:
'moT' yrreJ ekipS ekyT
结果:
['Spike', 'Tyke', 'Tom', 'Jerry']

names = ['Tom', 'Jerry', 'Spike', 'Tyke']

def k(s):
print("k()传入:", s, "返回去的", s[::-1])
return s[::-1]

L = sorted(names, key=k)
print(L) # ['Spike', 'Tyke', 'Tom', 'Jerry']

递归函数 recursion
函数直接或间接的调用自身

递归示例:
# 函数直接调用自己
def f():
f() # 调用自己
f()

# 函数间接的调用自己
def fa():
fb()

def fb():
fa()

fa()

递归说明:
递归一定要控制递归的层数，当符合一定条件时要终止递归
几乎所有的递归都能用while循环来代替

递归的优缺点:
优点:
递归把问题简单化，让思路更为清晰，代码更简洁
缺点：
　　递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

递归的两个阶段
递推阶段: 从原问题出发，按递归公式递推从末知到已经，最终达到递归的终止条件
回归阶段: 按递归终止条件求出结果,逆向逐步代入递归公式．回归到原问题求解

示例见:
recursion.py
def fx(n):
print("fx进入第", n, '层')
if n == 3:
return
fx(n + 1)
print("fx退出第", n, '层')

fx(1)
print("程序结束")

recursion_fac.py
# n! = 1 * 2 * 3 * 4 * ..... * n
# n! = n * (n-1) * (n-2) * ..... 3 * 2 * 1
# 100! = 100 * 99 * 98 * ..... 3 * 2 * 1

def fac(n):
# 此函数用递归的方式实现阶乘
if n == 1: # 1! 直接返回1
return 1
return n * fac(n - 1)

print(fac(5)) # 120

练习:
写函数 mysum(n)用递归方式实现求和
def mysum(n):
# 用递归方式求和
def mysum(n):
if n == 1:
return 1
return n + mysum(n-1)
print(mysum(100))

思考题:
已知五位朋友在一起
第五位朋友比第四位朋友大2岁
第四位朋友比第三位朋友大2岁
第三位朋友比第二位朋友大2岁
第二位朋友比第一位朋友大2岁
第一位朋友说它10岁

闭包 closure
什么是闭包:
闭包是指引用了此函数外部的变量的函数

说明:
在本质上，闭包是将内部嵌套函数和函数外部的执行环境绑定在一起的对象

闭包必须满足三个条件:
1. 必须有一个内嵌函数
2. 内嵌函数必须引用外部函数中的变量
3. 外部函数返回值必须是内嵌函数

示例见:
closure.py
# 闭包示例:
def make_power(y):
def fn(arg):
return arg ** y
return fn

pow2 = make_power(2) # 请问pow2绑定的是什么？
print('5的平方是:', pow2(5))

# 求1**2 + 2 ** 2 + 3 ** 2 + .... 100 ** 2
print(sum(map(lambda x: x ** 2, range(1, 101))))
print(sum(map(make_power(2), range(1, 101))))

print("1 ** 3 + 2**3 + ...... + 100 ** 3=")
print(sum(map(lambda x: x ** 3, range(1, 101))))
print(sum(map(make_power(3), range(1, 101))))
# print(sum(map(lambda x: x ** 3, range(1, 101))))

# 闭包的应用见:
closure2.py

def get_fx(a, b, c):
def fx(x):
return a * x ** 2 + b * x + c
return fx
f123 = get_fx(1, 2, 3)
print(f123(20))
print(f123(50))
f654 = get_fx(6,5,4)
print(f654(10))
print(f654(30))

练习：
1.　已知五位朋友在一起
第五位朋友比第四位朋友大2岁
第四位朋友比第三位朋友大2岁
第三位朋友比第二位朋友大2岁
第二位朋友比第一位朋友大2岁
第一位朋友说它10岁
写程序打印出第五位朋友　和第三位朋友　的年龄

def sui(n):
if n == 1:
return 10
return sui(n-1)+2
print(sui(1))
print(sui(2))
print(sui(3))
print(sui(4))
print(sui(5))

　　2. 已知有列表:
L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]
1) 写一个函数print_list(lst) 打印出所有元素
print(L) # 打印 3 5 8 10 13 14 ....
2) 写一个函数sum_list(lst) 返回这个列表中所有元素的和
print(sum_list(L)) # 86
注:
type(x) 可以返回一个变量的类型
如:
>>> type(20) is int # True
>>> type([1, 2, 3]) is list # True

L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]
# 1) 写一个函数print_list(lst) 打印出所有元素
def print_list(lst):
for x in lst:
if type(x) is list: # 如果x是列表，则再次再印
print_list(x)
else:
print(x)
print_list(L) # 打印 3 5 8 10 13 14 ....
# 2) 写一个函数sum_list(lst) 返回这个列表中所有元素的和
def sum_list(lst):
s = 0
for x in lst:
if type(x) is list: # 是列表
s += sum_list(x)
else: # 不是列表
s += x
return s
print(sum_list(L)) # 106

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("+---------------+----------+----------+")
def output_student_by_score_desc(lst):
def k(d):
return d['score']
L = sorted(lst, key=k, reverse=True)
output_student(L)
def output_student_by_score_asc(lst):
L = sorted(lst, key=lambda d: d['score'])
output_student(L)
def output_student_by_age_desc(lst):
L = sorted(lst, key=lambda d: d['age'],
reverse=True)
output_student(L)
def output_student_by_age_asc(lst):
L = sorted(lst, key=lambda d: d['age'])
output_student(L)
def show_menu():
print('+----------------------------------+')
print('| 1) 添加学生信息 |')
print('| 2) 显示学生信息 |')
print('| 3) 删除学生信息 |')
print('| 4) 修改学生成绩 |')
print('| 5) 按学生成绩高-低显示学生信息　|')
print('| 6) 按学生成绩低-高显示学生信息　|')
print('| 7) 按学生年龄高-低显示学生信息　|')
print('| 8) 按学生年龄低-高显示学生信息　|')
print('| q) 退出 |')
print('+----------------------------------+')
def main():
docs = [] # 用于存放学生信息的空列表
while True:
show_menu()
s = input("请选择: ")
if s == '1':
docs += input_student()
elif s == '2':
output_student(docs)
elif s == '3':
print("开始删除")
elif s == '4':
print("开始修改成绩")
elif s == '5':
output_student_by_score_desc(docs)
elif s == '6':
output_student_by_score_asc(docs)
elif s == '7':
output_student_by_age_desc(docs)
elif s == '8':
output_student_by_age_asc(docs)
elif s == 'q':
break
main()

python基础day11笔记

猜你喜欢