Python基础-DAY11

nonlocal 语句

作用：

   告诉解释器，nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量

 

语法:

   nonlocal 变量1, 变量2, ...

 

说明：

  1. nonlocal语句只能在被嵌套的函数内部进行使用

  2. 访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作

  3. 当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近的一层变量进行操作

  4. nonlocal语句的变量列表里的变量名不能出现在此作用域的参数列表中

 

 

闭包 closure

  将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象称为闭包(closure)

 

说明：

  如果一个内嵌函数访问函数外部函数作用域的变量并返回此函数，则这个函数就是闭包

 

 

闭包必须满足以下三个条件：

  1. 必须有一个内嵌函数

  2. 内嵌函数必须引用外部嵌套函数中的变量

  3. 外部嵌套函数返回值必须是内嵌函数

 

示例：

x = 100

def f1():

   print(x):

f2 = f1  # 不是闭包

 

示例2

def f1():

    x = 200

    def f2():

        print(x)

    return f2

 

f3 = f1() # f3是闭包

 

 

函数的可重入性：

    当一个函数没有引用外部变量时，此函数每次调用的执行结果必然是唯一的，此种函数，称为可重入函数

 

例：

  # 可重入函数示例

  def mysum(a, b):

      return a + b

 

  # 不可重入函数示例

  c = 100

  def mysum(a, b):

      return a + b + c

  print(mysum(100, 200))  # 400

  c = 100000

  print(mysum(100, 200))  # 100300

 

 

函数式编程:

  函数式编程是指用一系列函数解决问题

 

函数是一等公民

  函数可以赋值给变量

  函数本身可以作为参数传入另一个函数

  函数允许返回一个函数

 

好处:

  每一个函数完成细小的功能，一系列函数的任意组合可以完成解决大的问题.

 

高阶函数 High Order Function

什么是高阶函数：

  满足下列条件之一：

    函数接受一个或多个函数作为参数传入

    函数返回一个函数

 

map函数:

  map(func, *iterable) 用函数对可迭代对象中的每一个元素作为参数计算出新的迭代器对象,当最短的一个迭代器完成迭代后结束

 

例如:

  # 生成一个迭代器，此迭代器可以生成1~9的整数的平方

  1, 4, 9, 16, ... 81

 

  def pow2(x):

      return x ** 2

 

  mit = map(pow2, range(1, 10))  # 生成一个迭代器

 

  # 计算1 + 4 + 9 + 16 + .....+ 10000 和是多少呢？

  print(sum(map(pow2, range(1, 101))))

 

  生成一个迭代器,此迭代器可以生成1**4, 2**3, 3**2, 4**1

  mit = map(pow, range(1,5), range(4,0,-1))

 

  [x for x in mit]

 

  # 以下为示意:

  # map(pow, [1,2,3,4], [4,3,2,1])

  # pow(1, 4)

  # pow(2, 3)

 

 

filter 函数

  filter(函数function或None, iterable)

 

filter解释为 过滤/筛选

作用：

    筛选可迭代对象iterable中的数据, 返回一个可迭代对象,此可迭代对象将对iterable中的数据进行筛选

 

函数 function 将对iterable中的每个元素进行求值，返回False则将此数据丢弃，返回True,则保留此数据

 

示例：

    # 判断 x是否为奇数，奇数为True

    def is_odd(x):

      return x % 2 == 1

 

    # 生成一个0-10所有奇数的列表

    fit = filter(is_odd, range(11))

    odd = [x for x in fit]

 

sorted 函数:

  格式：

    sorted(iterable, key=None, reverse=False)

  作用：

    排序

  说明：

    key函数是用来提供一个值，这个值将作为排序的依据

 

    key函数只有一个参数.

例：

  L = [5, -2, -4, 0, 3, 1]

  L2 = sorted(L)  # L= [-4, -2, 0, 1, 3, 5]

  L2 = sorted(L, reverse=True)  # L=[5, 3, 1, 0, -2, -4]

 

  L2 = sorted(L, key=abs)  # [0, 1, -2, 3, -4, 5]

  # 原来是[5, -2, -4, 0, 3, 1]

          |   |   |  ,  ,  ,

  # 现在是[5,  2,  4, 0, 3, 1]

 

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

 

  sorted(names) 

  sorted(names, key=len)

 

 

lambda 表达式(又称匿名函数)

作用：

  创建一个匿名函数对象

  同def 类似，但不提供函数名

 

语法:

  lambda [参数1, 参数2, ...] : 表达式

 

示例:

  def myadd(x, y):

      return x + y

 

  # 可以改写为:

  myadd = lambda x, y: x + y

 

  print("20 + 30 =", myadd(20, 30))

  print("111 + 222 =", myadd(111, 222))

 

说明：

　　lambda只是一个表达式,它用来创建一个函数对象

  当lambda表达式执行时，返回的是冒号后面的表达式的值

  lambda表达式创建的函数只能包含一条表达式

  lambda 比较函数简单,且可以随时创建和销毁，少占用内存空间

 

 

globals() 函数

locals()　函数

 

globals()  返回当前全局作用域内变量的字典

locals()   返回当前局部作用域内变量的字典

 

 

 

eval() 和 exec()函数

 

eval() 函数

作用：

　　把一个字符串当成一个表达式来执行，返回表达式执行后的结果

格式:

  eval(source, globals=None, locals=None)

 

例：

  x = 100

  y = 200

  a = eval("x+y")

  print(a)

 

  ls = {"x": 1, "y":2}

  a = eval("x+y", None, ls)

 

  gs = {"x": 10, "y":20}

  a = eval("x+y", gs)

  print(a)  # 30

 

exec 函数:

作用：

　　把一个字符串当成程序来执行

格式：

　　exec(source, globals=None, locals=None)

 

示例：

  x = 100

  y = 200

  s = 'print("x + y = ", x, y)'

  exec(s)  #

 

gs = {"x": 10, "y":20}

ls = {"x": 1, "y":2}

  exec(s, gs, ls)

 

exec的globals 和locals参数的用法与eval相同