python开发10
今日内容：
全局变量和局部变量
函数的嵌套定义
gobal，nonlocal语句
lambda 表达式
局部变量：
1.定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
2.局部变量只能在函数内部使用
3.局部变量在函数调用时才能够被创建，在函数调用结束之后会自动销毁
全局变量：
1.定义在函数外部，模块内部的变量称为全局变量
2.所有的函数都可以直接访问全部变量，但函数内部不能直接通过赋值土局来来改变全部变量
示例：
# a = 100
# b = 200
# def fx(c):
# print('hello')
# d = 400
# a = 10#次赋值语句在函数，他只能创建局部变量，不能改变全局变量
# print(a,b,c,d,sep=' =>')
# print('a=',a,'b=',b)
# fx (300)
# print('a=',a,'b=',b)
# #print(c) #局部变量只能在函数内部使用
结果为：
a= 100 b= 200
hello
10 =>200 =>300 =>400
a= 100 b= 200
局部变量说明：
1. 在函数内首次对变量赋值是创建局部变量，再次为变量赋值是修改局部变量的绑定关系
2. 在函数内部的赋值语句不能对全局变量造成影响
3. 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个模块同访问
练习：
创建一个全局变量：
L = []
写一个函数：
def input_number()
读入正整数 放在L列表内
input_number() #输入123
print（L）# [ 123]
input_number() #输入4,5
print（L）# [ 1,2,3,4,5]
答案：
# L = []
# def input_number():
# s = []
# while True:
# a = int(input('请输入一个正整数:')or"-1")
# if a < 0:
# break
# s.append(a)
# #走到此时，s里本次函数调用时用户输入的正整数
# return s
# L += input_number()
# print(L)
# L += input_number()
# print(L)
结果：
请输入一个正整数:1
请输入一个正整数:2
请输入一个正整数:3
请输入一个正整数:4
请输入一个正整数:5
请输入一个正整数:-1
[1, 2, 3, 4, 5]
请输入一个正整数:6
请输入一个正整数:7
请输入一个正整数:8
请输入一个正整数:9
请输入一个正整数:10
请输入一个正整数:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
globals（）函数和locals函数
globals（） 返回当前全局作用域内变量的字典
locals（） 返回当前局部作用域内变量的字典
示例：
# a = 1
# b = 2
# c = 3
# def fx(c,d):
# e = 300
# print('locals()返回=',locals())
# print('globals()返回=',globals())
# print(c) #100
# print(globals()['c']) #3
# fx (100,200)
结果：
locals()返回= {'e': 300, 'c': 100, 'd': 200}
globals()返回= {'__package__': None, '__spec__': None, 'c': 3, '__cached__': None, '__doc__': None, '__file__': 'jbbl.py', 'a': 1, 'fx':
100
3
函数变量
函数名是变量，它在创建时绑定一个函数
示例：
# def f1():
# print('hello f1')
# def f2():
# print('hello f2')
# fx = f1 #注意此处f1没有加（）
# fx()
# f1()
# f1 = f2 #让f1改变绑定关系，去绑定f2
# f1() #调用f2
# f2 = fx
# f2() #调用f1交换法，
结果：
hello f1
hello f1
hello f2
hello f1
一个函数可以作为另一个函数实参传递
实例：
def f1():
print(‘f1被调用’)
def f2():
print(‘f2被调用’)
def fx(fn):
print(‘fn绑定的是：’，fn)
fn（）#调用fn绑定的函数，此处调用谁就在传过来的是谁
fx (f1)
fx (f2)
函数调用
def myinput(fn):
L = []
while True:
x = int(input("请输入大于0的整数:") or '-1')
if x < 0:
break
L.append(x)
return fn(L) # <<< 注意此处
print(myinput(max))
print(myinput(min))
print(myinput(sum))
函数作为另一个函数的返回值
示例：
# def get_op():
# s = input('输入您要做的操作:')
# if s == '求最大':
# return max
# elif s == '求最小':
# return min
# elif s == '求和':
# return sum
# l = [1,2,3,4]
# fx = get_op()
# print(fx(l))
结果：
输入您要做的操作:求最大
4
输入您要做的操作:求和
10
输入您要做的操作:求最小
1
函数的嵌套定义
函数嵌套定义是指一个函数里用def
语句来创建其它函数情况
实例：
def fun_outer():
print('fun_outer被调用．．．')
# 在此处创建另一个函数，并在下面调用
def fun_inner():
print('fun_inner被调用')
fun_inner() #调用一次
fun_inner()#调用二次
print('fun_outer调用结束')
fun_outer()#调用函数
结果：
fun_outer被调用．．．
fun_inner被调用
fun_inner被调用
fun_outer调用结束
如果想要调用内部的函数fun_inner怎么调用呢？
答：在print（调用结束后）加
return fun_inner
就能实现调用
Python的作用域
作用域也叫命字空间，是访问变量时找变量名的范围空间
Python的四个作用域 LEGB
作用域 英文解释 英文简写
局部作用域（函数内） Local（function） L
外部嵌套函数作用域 Enclosing function locals E
函数定义所在模块（文件）的作用域 Globals（module） G
Python 内置模块的作用域 Builtin(python) B
示例：
# v = 100
# def fun1():
# v = 200
# print('fun1.v = ',v)
# def fun2():
# v = 300
# print('fun2.v =',v)
# fun2()
# fun1()
# print('全局的v=',v)
结果：
fun1.v = 200
fun2.v = 300
全局的v= 100
变量名的查找规则：
在访问变量时先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置（内建）变量
L -->> E --->> G --->> B
2.在默认情况下，变量名赋值会创建或改变本地作用域变量
问题：
V = 10
Def change_v(a)
V = a #请问能修改全局的v吗？
Changw_v（200）
Global 语句
作用：
告诉解释器，global语句声明的一个或多个变量，这些变量的作用域为模块的作用域（也成全局变量）
2.全局声明（global）
将赋值的变量映像到模块文件内部的作用域
语法：
Global 变量1，变量2，…
示例：
Global v,a,b,c
Global d
示例：
# v = 100
# def fn():
# #添加全局声明，告诉解释执行器，本函数内的v
# global v
# v = 200#本意i想要修改全局变量v让他绑定200
# fn()
# print('v = ',v)
结果：
v = 100
v = 200
global说明
1. 全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为是局部变量）
2. 全局变量在函数内部不经过声明就可以直接访问
3. 不能先创建局部变量，再用global声明为全局变量，此做法不符合规则
4. Global变量列表里的变量名不能出现在此作用域内形参列表里
练习：
写一个函数
def hello（name）：
count = 0
hello（‘小张’）
hello（‘小李’）
print（‘函数hello已经被调用%d次’%count）#2
hello（‘小赵’）
print（‘函数hello已经被调用%d次’%count）#3
答案：
# def hello(name):
# print(name)
# global count
# count += 1
# count = 0
# hello('小张')
# hello('小李')
# print('函数hello已经被调用%d次'%count)#2
# hello('小赵')
# print('函数hello已经被调用%d次'%count)#3
结果：
小张
小李
函数hello已经被调用2次
小赵
函数hello已经被调用3次
Noulocal 语句
作用：
告诉解释器，noulocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量
Nonlocal的语法
示例：
# var = 100
# def f1():
# car = 200
# print('f1里的var=',var)
# print('f1调用结束时var=',var)
# def f2():
# global var
# var = 300
# f2()
# print('f1调用结束时var=',var)
# f1()
# print('全局的var=',var)
结果：
f1里的var= 100
f1调用结束时var= 100
f1调用结束时var= 100
全局的var= 100
f1里的var= 100
f1调用结束时var= 100
f1调用结束时var= 300
全局的var= 300
说明：
1.nonlocal 语句只能在被嵌套的函数内部进行使用
2.访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作
3.当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近一层的变量进行操作
4.nonlocal语句的变量列表里的变量名，不能出现在此函数参数列表中。
问题：
请问‘def’语句干什么用？
Lambda 表达式（又称匿名函数）
作用：
创建一个匿名函数对象
同def类似，但不提供函数名
语法格式：
Lambda[形参1，形参2，…]：表达式
示例：
# def myadd(a,b):
# return a+b
myadd = lambda a,b : a+b
print('10+20=',myadd(10,20))
print('30+40=',myadd(30,40))
结果：
10+20= 30
30+40= 70
语法说明：
1.Lambda只是一个表达式，他用来创建一个函数对象当2.lambda表达式调用时，先执行冒号（：）后的表达式，并返回表达式的结果的引用
3.lambda 表达式创建的函数只能包含一条表达式
4.lambda 比函数简单而且可以随时创建和销毁，有利于减少程序的耦合度
练习：
1. 写一个lambda表达式，判断这个数的2次方+1是否能被5整除，如果能被整除返回True，否则返回False
Fx = lambda n：………
Print(fx(3)) #True
Print(fx(4)) #False
2. 写一个lambda表达式求两个变量的最大值
Def mymax（x，y）：
…………
Mymax = lambda …………..
解：
#1
fx = lambda s :((s**2)+1)%5 == 0
# print(fx(3)) #True
# print(fx(4)) #False
结果：
True
False
#2
Print（mymax（100,200）） #200
# mymax = lambda a,b : max(a,b)
# print('最大为:',mymax(100,200))
结果：
最大为: 200
练习:
1. 写一个函数mysum(n)来计算
1+2+3+4+…………….n的和
（要求用函数来做）
Def mysum(n):
………..
Print(mysum(100)) #5050
2. 写一个函数myfac 来计算n！（n的阶乘）
n！= 1*2*3*4…*n
def myfac(n):
……….
Print(myfac(5)) #120
3. 给出一个数n，写出一个函数计算：
1+2**2+3**3+4**4+………….+n***n的和
（n给个小点的数）
4. 修改之前的学生信息管理项目为项目添加菜单界面
+----------------------------------------------+ 、
| 1）添加学生信息 |
| 2）显示学生信息 |
| 3）删除学生信息 |
| 4）修改学生信息 |
| 5）退出程序 |
+-------------------------------------------+
请选择：
（要求，每个功能至少对应一个函数）
答案：
#1
# def mysum(n):
# a = 0
# for x in range(1,n+1):
# a += x
# return a
# print('最终n(100)的和为:',mysum(100))
#2
# def myfac(n):
# a = 1
# for l in range(1,n+1):
# a *= l
# return a
# print("5的阶乘是:",myfac(5))
# def myfac(n):
# a = 1
# i = 1
# while i <= n:
# a=a*i
# i=i+1
# return a
# print ("6的阶乘是:",myfac(6))
#3
# def myaes(n):
# a = 0
# for x in range(1,n+1):
# a += x ** x
# return a
# print('最终n**n(3)的和为:',myaes(3))、
#4
def input_student():
'''此函数返回用户输入的学生信息的列表
返回的列表格式写之前完全相同
'''
L = [] # 创建一个列表，用来保存所有学生的字典
# 读取学生数据放入列表中
while True:
n = input("请输入学生姓名: ")
if not n: # 如果学生姓名为空则结束输入
break
a = int(input("请输入学生年龄: "))
s = int(input("请输入学生成绩: "))
# 把上述n, a, s 所表示的信息形成字典，并加入到列表
d = {} # 创建一个新字典，准备存入学生信息数据
d['name'] = n
d['age'] = a
d['score'] = s
L.append(d) # 把字典存入列表中
return L
def output_student(L):
'''此函数把传入的列表L 打印成为表格'''
# 第二步，显示所有学生的信息
print("+---------------+----------+----------+")
print("| name | age | score |")
print("+---------------+----------+----------+")
# 此处打印所有学生的信息
for d in L: # 把每个学生的数据取出来，用d绑定对应的字典
center_name = d['name'].center(15)
str_age = str(d['age']) # 先将年龄转为字符串
center_age = str_age.center(10) # 生成居中的字符串
center_score = str(d['score']).center(10)
line = "|%s|%s|%s|" % (center_name,
center_age,
center_score)
print(line)
print("+---------------+----------+----------+")
def del_student(L): # 删除学生信息
name = input("请输入要删除学生的姓名: ")
print('删除成功')
def modify_student_score(L): # 删除学生信息
name = input("请输入要修改学生的姓名:")
# 查找name 是不是在列表L里
# 如果name在L里
score = int(input("请输入要修改的成绩: "))
# ...
def show_menu():
print("+-----------------------------+")
print("| 1) 添加学生信息 |")
print("| 2) 显示学生信息 |")
print("| 3) 删除学生信息 |")
print("| 4) 修改学生成绩 |")
print("| q) 退出程序 |")
print("+-----------------------------+")
def show_menu():
print("+-----------------------------+")
print("| 1) 添加学生信息 |")
print("| 2) 显示学生信息 |")
print("| 3) 删除学生信息 |")
print("| 4) 修改学生成绩 |")
print("| q) 退出程序 |")
print("+-----------------------------+")
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！