day 10

day10
函数变量
函数名是变量,它在创建时绑定一个函数

示例:

  def f1(lst=[]):
      print("f1函数被调用")
  f1()
  f1 = None
  f1() # 出错,f1 绑定的是None

示例:

def f1():
    print("hello")

def f2():
    print("world")

f1, f2 = f2, f1
f1()  # world

一个函数可以作为另一个函数的参数(实参)传递
示例:

 def f1():
      print("f1函数被调用")

  def f2():
      print("f2函数被调用")
  
  def fx(fn):
      print("fn绑定的函数是:", fn)
      # 在fx内调用fn绑定的函数
      fn()
  fx(f1)  # 调用fx,把f1作为实参传数
  fx(f2)

看懂下列代码在做什么?为什么?

def goodbye(L):
    for x in L:
        print("再见:", x)

def hello(L):
    for x in L:
        print("欢迎:", x)

def fx(fn, L):
    print("fx被调用")
    fn(L)

fx(hello, ['Tom', 'Jerry', 'Spike'])
fx(goodbye, ['小张', '小李'])
结果：
fx被调用
欢迎: Tom
欢迎: Jerry
欢迎: Spike
fx被调用
再见: 小张
再见: 小李

函数可以做为另一个函数的返回值:
函数可以返回另一个函数

示例:

 def get_op():
    print("请输入您的操作：")
    print("您可以输入以下指令：")
    s = input("求最大，求最小，求和: ")
    if s == "求最大":
        return max
    elif s == '求最小':
        return min
    elif s == '求和':
        return sum


L = [2, 4, 6, 8, 10]
print(L)
f = get_op()
print(f(L))

函数嵌套定义:
def 语句的作用是用来创建一个函数
def 语句可以写在函数内部,在函数执行时可以动态创建一个函数

示例:

def get_func(value):
    if value == 1:
        def myadd(x, y):
            return x + y

    return myadd
elif value == 2:
    def mysub(x, y):
        return x - y

    return mysub


fx = get_func(1)
print(fx(400, 300))  # 700
fx = get_func(2)
print(fx(400, 300))  # 100

全局变量和局部变量
局部变量:
1. 定义在函数内部的变量称为局部变量(函数的形参也是局部变量)
2. 局部变量只能在函数内部使用
3. 局部变量在函数调用时才能够被创建,在函数调用之后会自动销毁
全局变量:
定义在函数外部,模块内部的变量称为全局变量
全局变量,所有函数都可以直接访问(但函数内部不能直接修改全局变量的绑定关系)

示例:

 a = 100
    b = 200
    def fn(c):
        d = 300
        print(a, b, c d)

fn(300)
print('a =', a)
print('b =', b)

局部变量说明:

1. 在函数内首次对变量赋值是创建局部变量,再次为变量赋值是修改局部变量的绑定关系
2. 在函数内部的赋值语句不会对全局变量造成影响

python作用域:
作用域也叫命名空间,是访问变量时查找变量名的范围空间

python的四个作用域LEGB
作用域 英文解释 英文简写
局部作用域(函数内) Local(function) L
外部嵌套函数作用域 Enclosing function locals E
函数定义所在模块的作用域 Global(module) G
python 内置模块的作用域 Builtin(python) B

示例见:

v = 100  # 全局变量

def fun1():
    v = 200
    print('fun1里的v的值是: ', v)
    # 定义另一个函数 fun2,然后调用一个
    def fun2():
        v = 300
        print('fun2里的v=', v)
    fun2()


fun1()
print('全局的 v=', v)
结果：
fun1里的v的值是:  200
fun2里的v= 300
全局的 v= 100

变量名的查找规则(顺序):

1. 查找本地变量
2. 查找包裹此函数的外部嵌套函数内部的变量
3. 全局变量
4. 内置变量

globals() / locals() 函数
globals() 返回全局作用内变量的字典
locals() 返回局部作用域内变量的字典

# 此示例示意globals 和 locals 函数的用法
a = 100
b = 200

def fx(b, c):
    print(a, b, c)
    # 思考在此函数内部能否获取到全局变量b绑定的值?
    print("全局变量的字典是:", globals())
    print("局部变量的字典是:", locals())
    print("此处访问全局的b的值是:", globals()['b'])


fx(300, 400)
结果：
100 300 400
全局变量的字典是: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B415206470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/python/python_work/Study.py', '__cached__': None, 'a': 100, 'b': 200, 'fx': <function fx at 0x000001B4151BC2F0>}
局部变量的字典是: {'b': 300, 'c': 400}
此处访问全局的b的值是: 200

练习:
  1. 写一个函数 mysum 此函数的功能是返回:
     1 + 2 + 3 + 4 + 5 + ..... + n 的和
  def mysum(n):
 def mysum(n):
    s = 0
    for i in range(n + 1):
        s = i + s
    return s

print(mysum(100))

2. 写一个函数 mysum2 此函数可以传入一个参数,两个参数和三个参数:

1. 当传入一个参数时,这个参数代表 终止数

2. 当传入两个参数时,第一个参数代表起始值,第二个参数代表终止值

3. 当传入三个参数时,第三个参数代表步长
   此函数的功能是返回从开始到终止值的和
   如:

   print(mysum2(5)) # 10 (0+1+2+3+4)
   print(mysum2(4, 6)) # 9 (4+5)
   print(mysum2(5, 10, 2)) # 21 (5+7+9)
   def mysum2(start, stop=None, step=1):
   if stop == None:
   stop = start
   start = 0
   sum = 0
   for i in range(start, stop, step):
   sum += i
   return sum

print(mysum2(5))
print(mysum2(4, 6))
print(mysum2(5, 10, 2))

global 语句
作用:
1. 告诉解释执行器,global语句声明的一个或多个变量,这些变量的作用域为模块级的作用域的变量,也称作全局变量
2. 全局声明(global) 将赋值变量映射到模块文件内部的作用域
语法:
global 变量1, 变量2, …
示例:
global ga, gb
global gc
global声明示例见:

# 以下示例示意global语句的用法

v = 100

def fx():
    global v  # 声明v为全局变量,不是局部变量
    v = 200  # 想修改全局的v怎么办?
    print(v)

fx()
print(v)  # 200
结果
200
200

说明:
1. 全局变量如果要在函数内部被赋值,则必须经过全局声明(否则会被认为是局部变量)
2. 全局变量在函数内部不经过声明就可以直接访问
3. 不能先声明局部变量,再用global声明为全局变量,此做法不附合规则
4. global变量列表里的变量名不能出现在此作用域内的形参列表里

nonlocal语句
作用:
告诉解释器, nonloca声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量
语法:
nonlocal 变量名1, 变量名2, …
示例见:

v = 100

def outter():
    v = 200
    print("outter里的v=", v)
    # 在函数内创建一个函数并调用
def inner():
    nonlocal v  # 声明v为外部嵌套函数的作用域内的变量
    v += 1
    print("innter里的v=", v)

inner() # 调用上面的函数
print('调用inner后,outter里的v=', v)

outter()
print(“全局里的v的值是:”, v)
结果：
outter里的v= 200
innter里的v= 201
调用inner后,outter里的v= 201
全局里的v的值是: 100

说明:
1. nonlocal语句只能在被嵌套函数内部进行使用
2. 访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作
3. 当有两层或两层以上函数嵌套时,访问nonlocal变量只对最近一层的变量进行操作
4. nonlocal语句的变量列表的变量名不能出现在此函数的参数列表里

说明3示例:
def f1():
    v =100
    def f2():
        v = 200
        def f3():
            nonlocal v
            v += 1 # 此时只对f2的v进行操作
        f3()
    f2()

练习:

1. 创建一个列表L = []
   写一个函数 input_number读取数据放入列表L中
   程序如下:

   L = []
   def input_number():
   # 此处自己加入代码
   while True:
   i = int(input(“请输入数字(-1结束):”))
   # 此处自己完成
   input_number()
   print(“您刚才输入的整数值是:”, L)
   L = []

def input_number():
    global L
    while True:
        number = int(input("请输入数字（-1结束：）"))
        if number != -1:
            L.append(number)
        else:
            break


input_number()
print("您刚才输入的整数值是：", L)

2. 写一个函数isprime(x) 判断x是否为素数,如果为素数返回True,否则返回False
   测试代码:
   if isprime(5):
   print(“5素数”)

def isprime(x):
    for i in range(2, x):
        if x % i == 0:
            return False
        else:
            return True