第五章.函数

5.1三元运算（三目运算）

v =  前面  if 条件 else 后面 
if 条件：
    v = '前面'
else:
    v = '后面'

# 让用户输入值，如果值是整数，则转换成整数，否则赋值为None
data = input('>>>')
value =  int(data) if data.isdecimal() else None

5.2函数编程

5.2.1面向过程编程

可读性差/可重用性差

# 发送邮件的程序
​
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
​
msg = MIMEText('要发送的内容。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '自己邮箱地址'])
msg['To'] = formataddr(["老板", '要发送目标邮箱地址'])
msg['Subject'] = "情爱的导演"
​
server = smtplib.SMTP("smtp.126.com", 25)
server.login("自己邮箱地址", "自己邮箱密码")
server.sendmail('自己邮箱地址', ['要发送目标邮箱地址', ], msg.as_string())
server.quit()

5.2.2函数型编程

• 本质：将N行代码拿到别处并给他起个名字，以后通过名字就可以找到这段代码并执行。

• 适用于代码重复执行或代码量特别多超过一屏，可以选择通过函数进行代码的分割。

  # 函数的定义
  def 函数名():
      # 函数内容
      pass
  ​
  # 函数的执行
  函数名()

  def get_list_first_data():
      v = [11,22,33,44]
      print(v[0])
  ​
  get_list_first_data()  # 注意：函数如果不被调用，则内部代码永远不会被执行。

5.3参数

• 可以传任意参数，任意类型

• 严格按照顺序传参数：位置方式传参位于关键字传参之前

def get_list_first_data(aaa): # aaa叫形式参数(形参)
    v = [11,22,33,44]
    print(v[aaa])
​
get_list_first_data(1) # 2/2/1调用函数时传递叫：实际参数（实参）
get_list_first_data(2)
get_list_first_data(3)
get_list_first_data(0)

# 1. 请写一个函数，函数计算列表 info = [11,22,33,44,55] 中所有元素的和。
​
def get_sum():
    info = [11,22,33,44,55]
    data = 0
    for item in info:
        data += item
    print(data)
​
get_sum()
​
# 2. 请写一个函数，函数计算列表中所有元素的和。
​
def get_list_sum(a1):
    data = 0
    for item in a1:
        data += item
    print(data)
    
get_list_sum([11,22,33])
get_list_sum([99,77,66])
v1 = [8712,123,123]
get_list_sum(v1)
​
# 3. 请写一个函数，函数将两个列表拼接起来。
def join_list(a1,a2):
    result = []
    result.extend(a1)
    result.extend(a2)
    print(result)
    
join_list([11,22,33],[55,66,77]
​
# 4. 计算一个列表的长度
def my_len(arg):
    count = 0
    for item in arg:
          count += 1
    print(count)
​
v = [11,22,33]
my_len(v)
len(v)

5.3.1位置传参【执行】

def func(a1,a2):
    print(a1,a2)
    
func(1,3)

5.3.2关键字传参【执行】

def func(a1, a2):
    print(a1, a2)
​
func(a2=99,a1=2)
​
# 关键字传参数和位置传参可以混合使用（位置传入的参数 > 关键字参数在后 = 总参数个数）
def func1(a1, a2, a3):
    print(a1, a2, a3)
​
# func(1, 2, a3=9)
# func(1, a2=2, a3=9)
# func(a1=1, a2=2, a3=9)
# func(a1=1, 2,3) # 错误

5.3.3默认参数【定义】

def func(a1,a2,a3=9,a4=10):
    print(a1,a2,a3,a4)
​
func(11,22)
func(11,22,10)
func(11,22,10,100)
func(11,22,10,a4=100)
func(11,22,a3=10,a4=100)
func(11,a2=22,a3=10,a4=100)
func(a1=11,a2=22,a3=10,a4=100)

5.3.4万能参数（打散）

*args

• 可以接受任意个数的位置参数，并将参数转换成元组。

• 调用函数无 *

  def func(*args):
      print(args)
  ​
  func(1,2,3,4)

• 调用函数有 *

  def funcs(*args):
      print(args)
  ​
  func(*(1,2,3,4))
  func(*[1,2,3,4])

**kwargs

• 可以接受任意个数的关键字参数，并将参数转换成字典。

• 调用函数无 **

  def func(**kwargs):
      print(kwargs)
  ​
  func(k1=1,k2="alex")

• 调用函数有**

  def func(**kwargs):
      print(kwargs)
  func(**{'k1':'v2','k2':'v2'}) # kwargs={'k1':'v2','k2':'v2'}

5.4返回值

默认返回值：None

def func(arg):
    # ....
    return 9 # 返回值为9 默认：return None
​
val = func('adsfadsf')

# 1. 让用户输入一段字符串，计算字符串中有多少A字符的个数。有多少个就在文件a.txt中写多少个“李邵奇”。
def get_char_count(data):
    sum_counter = 0
    for i in data:
        if i == 'A':
            sum_counter += 1
    return sum_counter
​
def write_file(line):
    if len(line) == 0:
        return False  # 函数执行过程中，一旦遇到return，则停止函数的执行。
    with open('a.txt',mode='w',encoding='utf-8') as f:
        f.write(line)
    return True 
​
content = input('请输入:')
counter = get_char_count(content)
write_data = "李邵奇" * counter 
status = write_file(write_data)
if status:
    print('写入成功')
else:
    print('写入失败')

# 1. 写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。
#    提示：type('x') == int 判断是否是数字。
"""
# 方式一：
def get_list_counter1(data_list):
    count = 0
    for item in data_list:
        if type(item) == int:
            count += 1
    msg = "列表中有%s个数字" %(count,)
    print(msg)
    
get_list_counter1([1,22,3,'alex',8])
​
# 方式二：
def get_list_counter2(data_list):
    count = 0
    for item in data_list:
        if type(item) == int:
            count += 1
    return count
    
v = get_list_counter1([1,22,3,'alex',8])
msg = "列表中有%s个数字" %(v,)
print(msg)
"""
​
# 2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。
"""
# 方式一：
def get_data_list1(arg):
    v = arg[::2]
    return v
​
data = get_data_list1([11,22,33,44,55,66])
​
# 方式二：
def get_data_list2(arg):
    v = []
    for i in range(0,len(arg)):
        if i % 2 == 0:
            v.append(arg[i])
    return v
​
data = get_data_list2([11,22,33,44,55,66])
"""
​
# 3. 读取文件，将文件的内容构造成指定格式的数据，并返回。
"""
a.log文件
    alex|123|18
    eric|uiuf|19
    ...
目标结构：
a.  ["alex|123|18","eric|uiuf|19"] 并返回。
b. [['alex','123','18'],['eric','uiuf','19']]
c. [
    {'name':'alex','pwd':'123','age':'18'},
    {'name':'eric','pwd':'uiuf','age':'19'},
   ]
"""

5.5作用域

注意：全局变量以后必须全部大写

5.5.1 global/nonlocal

• py文件：全局作用域

• 函数：局部作用域。

  • 一个函数是一个作用域

    def func():
        x = 9
        print(x)
    func()
    print(x)

  • 作用域中查找数据规则：优先在自己的作用域找数据，自己没有就去 "父级" -> "父级" -> 直到全局，全部么有就报错。注意：父级作用域中的值到底是什么？

    x = 10
    def func():
        x = 9
        print(x)
        def x1():
            x = 999
            print(x)
    ​
    func()        # 9 
    #原因：只是调取了函数func，所以x会得到一值，而函数X1没被调取，故不运行。

    x = 10
    def func():
        x = 8
        print(x)
        def x1():
            print(x)
    ​
        x1()
        x = 9
        x1()
        x = 10         #8
        print(x)       #8
                       #9
    func()             #10

  • 子作用域中只能 找到父级中的值 ，默认无法重新为父级的变量进行赋值。(global/nonlocal可以强制做)

    #例一：
    x = 10
    def func():        #8
        x = 8     #这一步是在自己的作用域中在创建一个x,而父级的x并没有改变
        print(x)
        
    func()  
    ​
    #例二：
    data = [11,22,33]
    def func():
        data.append(44)    #直接将将44追加进data，而不是赋值
        print(data)       
    func()                 #[11,22,33，44]
    print(data)            #[11,22,33，44]

    #对全局变量进行赋值
    ​
    #**************global***************
    #例一:
    data = ['张三'，'李四']
    def func():
        global name           #global后面添加想要被重新赋值的全局变量
        data = ['王二']
    func()
    print(data)         #['王二']
    ​
    #例二：
    name = "老男孩"
    def func():
        name = 'alex'
        def inner():
            global name
            name = 999
        inner()
        print(name)     #'alex'
    func()                 
    print(name)         #999
    ​
    #************nonlocal***************
    name = "老男孩"
    def func():
        name = 'alex'
        def inner():
            nonlocal name # 找到上一级的name
            name = 999
        inner()
        print(name)        #999
    func()
    print(name)           #"老男孩"

5.5.2 递归

递归就是函数自己调用自己(效率低)

def func():
    print(1)
    func()
    
func()
# 递归的返回值
def func(a):
    if a == 5:
        return 100000
    result = func(a+1) + 10
v = func(1)
​
name = 'alex'
def func():
    def inner():
        print(name)
     return inner
v =func()

5.6函数相关

5.6.1函数小高级

5.6.1.1.函数名当作变量来使用

def func():
    return 123
​
func_list1 = [func,func,func]
func_list2 = [func(),func(),func()]
​
print(func_list1)    #func为函数的内存地址
print(func_list2)
​
info = {
    'k1':func,
    'k2':func(),
}
​
print(info)

5.6.1.2.函数可以当作参数进行传递

def func(arg):
    v1 = arg()
    print(v1)
    
def show():
    print(666)
    
result = func(show)
print(result)

5.6.2函数中高级

5.6.2.1.函数可以做返回值

def func()
    print(123)
​
def bar()
    return func
​
v = bar()
v()

5.6.2.2.闭包

为函数创建一块区域（内部变量供自己使用），为他以后执行提供数据。

注意：函数在何时被创建

5.6.2.3.高阶函数

• 对函数进行赋值

• 把函数作为参数进行传递

• 把函数当做返回值

5.6.2.3 lambda表达式

又被称为匿名函数：用于简单函数的计算

# 三元运算，为了解决简单的if else的情况，如：
if 1 == 1:
    a = 123
else:
    a = 456
​
a =  123  if 1 == 1 else 456
​
# lambda表达式，为了解决简单函数的情况，如：
def func(a1,a2):
    return a1 + 100 
​
func = lambda a1,a2: a1+100

# 练习题1
USER_LIST = []
def func0(x):
    v = USER_LIST.append(x)  #这一步是将x追加到USER_LIST，是对全局变量进行修改，本身不能产生一个新值，所以v接收不到值，导致最后结果输出为None
    return v      

result = func0('alex')
print(result)     #None

# 练习题2
def func0(x):
    v = x.strip()    #这一步是对字符串进行操作，去掉x两边空格，会产生一个列表
    return v 

result = func0(' alex ')
print(result)     #'alex'

总结：列表所有方法基本上都是返回None；字符串的所有方法基本上都是返回新值

5.7内置函数

5.7.1输入输出：

• input()

• print()

5.7.2数学相关：

• max，找最大值

  v = [1,2,311,21,3]
  result = max(v)
  print(result)   #311

• min，找最小值

  v = [1,2,311,21,3]
  result = min(v)
  print(result)   #1

• sum，求和

  v = [1,2,311,21,3]
  result = sum(v)
  print(result)   #338

• abs，绝对值

  v = -12
  result = abs(v)
  print(result)  #12

• float，转换成浮点型（小数）

  v = 55
  v1 = float(55)
  print(v1)   #55.0

• divmod，两数相除的商和余数

  #法一：
  a,b = divmod(1001,10)
  print(a,b)   #100 1
  #法二：
  a = divmod(1001,10)
  print(a)     #结果得到的是一个元组（100,1）

  分页展示：

  # 练习题  请通过分页对数据进行展示
  """
  要求：
      每页显示10条数据
      让用户输入要查看的页面：页码
  """
  USER_LIST = []
  for i in range(1,836):
      temp = {'name':'你少妻-%s' %i,'email':'123%s@qq.com' %i }
      USER_LIST.append(temp)
  ​
  # 数据总条数
  total_count = len(USER_LIST)
  ​
  # 每页显示10条
  per_page_count= 10
  ​
  # 总页码数
  max_page_num,a = divmod(total_count,per_page_count)
  if a>0:
      max_page_num += 1
  ​
  while True:
      pager = int(input('要查看第几页：'))
      if pager < 1 or pager > max_page_num:
          print('页码不合法，必须是 1 ~ %s' %max_page_num )
      else:
          """
          # 第1页：USER_LIST[0:10] -> 0123456789
          # 第2页：USER_LIST[10:20]
          # 第3页：USER_LIST[20:30]
          ...
          """
          start = (pager-1) * per_page_count
          end = pager * per_page_count
          data = USER_LIST[start:end]
          for item in data:
              print(item)

5.7.3强制转换：

• str()

• bool()

• int()

• list()

• tuple()

• dict()

• set()

5.7.4.进制转换

• bin，将十进制转换为二进制(0b 开头)

  num = 13
  v1 = bin(num)
  print(v1)   #0b1101

• oct，将十进制转换为八进制(0o 开头)

  num = 13
  v1 = oct(num)
  print(v1)   #0o15

• int，将其他进制转换为十进制

  # 二进制转化成十进制
  v1 = '0b1101'
  result = int(v1,base=2)
  print(result)
  ​
  # 八进制转化成十进制
  v1 = '0o1101'
  result = int(v1,base=8)
  print(result)
  ​
  # 十六进制转化成十进制
  v1 = '0x1101'
  result = int(v1,base=16)
  print(result)

• hex，将十进制转换成十六进制(0x 开头)

  num = 16
  v1 = hex(num)
  print(v1)

5.7.5编码相关

• chr：将十进制数字转换为unicode编码中的字符串。

  v = chr(100)
  print(v)      #d

• ord:根据字符在unicode编码中的的对应关系找到其对应的十进制

  num = ord('中')

• 应用

  import random
  ​
  v = random.randint(起始位置，结束位置)  #得到一个随机生成

  做一个随机生成码：

  import random    #导入随机模块
  ​
  def get_random_code(length=6):  #创建一个随机生成码，字符串默认长度为6
      data = []
      for i in range(length)：     #进行字符串长度次循环
          v = random.randint(0,100)  #生成1~100内的随机数
          data.append(chr(v))       #将这个随机数转换为二进制数加入到列表中
          
      return ''.join(data)      #调用随机模块并将得到的返回值赋值给code
  code = get_random_code()
  print(code)

5.7.6其他

• len

• open

• range

• id

• type查看类型

  class Foo:
      pass
  ​
  obj = Foo()
  ​
  if type(obj) == Foo:         #查看obj是是不是Foo类的对象
      print('obj是Foo类的对象')     

• issubclass 判断参数 class 是否是类型参数 xx 的子类

  class Base:
      pass
  ​
  class Base1(Base):
      pass
  ​
  class Foo(Base1):
      pass
  ​
  class Bar:
      pass
  ​
  print(issubclass(Bar,Base))    #False
  print(issubclass(Foo,Base))    #True

• isinstance

  class Base(object):
      pass
  ​
  class Foo(Base):
      pass
  ​
  obj = Foo()
  ​
  print(isinstance(obj,Foo))  # 判断obj是否是Foo类或其基类的实例（对象）
  print(isinstance(obj,Ba

• super

  #例一:
  class Base(object):
      def func(self):
          print('base.func')
          return 123
  ​
  class Foo(Base):
      def func(self):
          v1 = super().func()
          print('foo.func',v1)
  ​
  obj = Foo()
  obj.func()
  # super().func() 去父类中找func方法并执行

  class Bar(object):
      def func(self):
          print('bar.func')
          return 123
  ​
  class Base(Bar):
      pass
  ​
  class Foo(Base):
      def func(self):
          v1 = super().func()
          print('foo.func',v1)
  ​
  obj = Foo()
  obj.func()
  # super().func() 根据类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

  class Bar(object):
      def func(self):
          print('bar.func')
          return 123
  ​
  class Base(Bar):
      pass
  ​
  class Foo(Base):
      def func(self):
          v1 = super().func()
          print('foo.func',v1)
  ​
  obj = Foo()           #'bar.func'
  obj.func()            #'foo.func',123
  # super().func() 根据类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

   

5.7.7高级一点的内置函数

1.map

• 格式：map（v1，v2）

  v1必须是一个函数，v2必须是一个可迭代类型（能被for循环）。循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

• 例子：

  v1 = [11,22,33,44]
  result = map(lambda x :x+100,v2)  #自动将新生成的元素加入到一个新列表中
  print(result)         #<map object at 0x0000000002928B70>
  print(type(result))   #<class 'map'>
  print(list(result))  #特殊,必须加list()    
                       #[111, 122, 133, 144]

2.filter

过滤器,该函数有两个参数，第一个参数是一个函数，第二个是一个序列，

函数的返回值是使得第一个参数中的函数为True的序列中的元素.

#法一：
v1 = [11,22,33,'qwe',44,'rt']
def func(x):
    if type(x) == int:   #判断数据类型是不是数字
        return True
    return False
​
result = filter(func,v1)  #result接受的是使得第一个参数中的函数为True的序列中的元素.
print(list(result))  #[11, 22, 33, 44]
​
#法二：
v1 = [11,22,33,'qwe',44,'rt']
result = filter(lambda x：True if type(X) == int else False,v1)
print(list(result))   #[11, 22, 33, 44]
​
#法三：
v1 = [11,22,33,'qwe',44,'rt']
result = filter(lambda x:type(x) == int,v1)
print(list(result))

3.reduce

在Python中是一个函数，使用它需要引入**.用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果

• 格式：reduce(函数,有两参数 ，可迭代对象，可选，初始参数）

  #法一：
  import functools
  v1 = ['wo','hao','xiang','ni']
  def func(x,y):
      return x+y
  ​
  result = functools.reduce(func,v1)
  print(result)
  ​
  #法二：
  import functools
  v1 = ['wo','hao','xiang','ni']
  result = functools.reduce(lambda x,y:x+y,v1)
  print(result)

5.8装饰器

5.8.1目的

在不改变原函数的基础上，在函数执行前后自定义功能

5.8.2 应用场景

想要为函数扩展功能时可以用装饰器

5.8.2.1普通装饰器

#基本格式：
def func(arg):
    def inner(*args,**kwargs)
        print('before')
        data = arg(*args,**kwargs)
        print('after')
        return data
    return inner
​
@func
def index():
    print(123)
    return 666

#例一：
def func(arg):
    def inner():
        data = arg()
    return inner
​
def f1():
    print(123)
    return 666
​
v1 = func(f1)   #arg = f1  返还一个inner函数
result = v1()   #执行inner函数
print(result)   #None  因为inner()执行后没有返回值，默认返回None
​
#例二：
def func(arg)：
    def inner():
        return arg()
    return inner
​
def f1():
    print(123)
    return 666
​
v1 = func(f1)  #arg = f1 返还一个inner函数
result = v1()  #执行inner函数，返还f1函数——>打印123，返还666
print(result)  #666

5.8.2.2带参数的装饰器

应用场景：flask框架 / django缓存 / 写装饰器实现被装饰的函数要执行N次

def x(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            data = func(*args,**kwargs) # 执行原函数并获取返回值
            return data
        return inner
    return wrapper
​
@x(9)             #第一步：执行x(9),并将返回值wrapper赋给x(9)
def index():      #第二步：将index当参数传递给func
pass              #第三步：index = inner

练习题

# 习题一：
# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，把每次结果添加到列表中，最终返回列表。
def xxx(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            v = []
            for i in range(counter):
                data = func(*args,**kwargs) # 执行原函数并获取返回值
                v.append(data)
            return v
        return inner
    return wrapper
​
@xxx(5)
def index():
    return 8
v = index()
print(v)
​
# 习题二：
# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回最后一次执行的结果【面试题】
def xxx(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            for i in range(counter):
                data = func(*args,**kwargs) # 执行原函数并获取返回值
            return data
        return inner
    return wrapper
​
@xxx(5)
def index():
    return 8
v = index()
print(v)
​
# 习题三：
# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次，并返回执行结果中最大的值。
def xxx(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            value = 0
            for i in range(counter):
                data = func(*args,**kwargs) # 执行原函数并获取返回值
                if data > value:
                    value = data 
            return value
        return inner
    return wrapper
​
@xxx(5)
def index():
    return 8
v = index()
print(v)

5.9迭代器

5.9.1基本知识

• 用途:对某种对象(str/list/tuple/dict/set类创建的对象-可迭代对象)中的元素进行逐一获取

• 表象:具有__next__方法且每次调用都获取可迭代对象中的元素(从前到后一个一个获取)

• 判断:内部是否有 next方法 。

  #法一：
  v = [11,22,33,44]
  v1 = iter(v)    #将列表转换为迭代器
  print(v1)
  ​
  #法二：
  v = [11,22,33,44]
  v1 = v.__iter__()
  print(v1)      #将列表转换为迭代器

• 想获取每个值：反复调用"v1 = v1.next()"

  v = [11,22,33,44]
  #列表转换为迭代器
  v1 = iter(v)
  result1 = v1.__next__()
  print(result1)        #11
  result2 = v1.__next__()
  print(result2)        #22
  result3 = v1.__next__()
  print(result3)        #33
  result4 = v1.__next__()
  print(result4)        #44
  result5 = v1.__next__()
  print(result5)        #报错
  ​
  #字符串转换为迭代器
  v1 = 'alex'
  v2 = iter(v1)
  while True:
      v3 = v2.__next__()
      print(v3)
  #程序跑到最后会出错，显示StopIteration错误，表示迭代已完成
  ​
  #改进：
  v1 = 'alex'
  v2 = iter(v1)
  while True:
      try:
          v3 = v2.__next__()
          print(v3)
      except Exception as e:
          break

• for循环：

  v = [11,22,33]
  for item in v:     #1.内部会将v转换为迭代器
      print(item)    #2.内部反复执行：迭代器.__next__()
                     #3.取完后程序不报错

5.10生成器(函数的变异)

• 判断:内部是否包含yield

• 总结:函数中如果存在yield，那么该函数就是一个生成器函数，调用生成器函数会返回一个生成器，生成器只有被for循环时，生成器函数内部的代码才会执行，每次循环都会获取yield返回的值。

  def func():
      print('F1')
      yield 1
      print('F2')
      yield 2
      print('F3')
      yield 3        
      
  v1 = func()   #函数内部代码不会执行，返还一个生成器对象
  for item in v1:
      print(item)

• 读取大文件

  def func():
      #  分批去读取文件中的内容，将文件的内容返回给调用者。
      cursor = 0
      while True:
          f = open('db', 'r', encoding='utf-8')    # 通过网络连接上redis
          # 代指  redis[0:10]
          f.seek(cursor)
          data_list =[]
          for i in range(10):
              line = f.readline()
              if not line:
                  return
              data_list.append(line)
          cursor = f.tell()
          f.close()  # 关闭与redis的连接
  ​
          for row in data_list:
              yield row
  ​
  for item in func:
      print(item)

5.11推导式

5.11.1 列表推导式

目的:方便生成列表

#基本格式:
v1 = [i for i in 可迭代对象 ]
v2 = [i for i in 可迭代对象 if 条件 ]      #条件为true才进行添加

# 示例：
v1 = [ i for i in 'alex' ]  
v2 = [i+100 for i in range(10)]
v3 = [99 if i>5 else 66  for i in range(10)]
​
def func():
    return 100
v4 = [func for i in range(10)]
​
v5 = [lambda : 100 for i in range(10)]
result = v5[9]()
​
v6 = [lambda :i for i in range(10)]
result = v6[5]()
​
# 新浪微博面试题
v7 = [lambda x:x*i for i in range(10)] 
# 1.请问 v7 是什么？
# 2.请问 v7[0](2) 的结果是什么？
​
# 面试题
def num():
    return [lambda x:i*x for i in range(4)]
# num() -> [函数,函数,函数,函数]
print([ m(2) for m in num() ]) # [6,6,6,6]

5.11.2 集合推导式

# 目的：方便的生成一个集合
# 格式：
v1 = { i for i in 'alex' }

5.11.3 字典推导式

# 目的：方便的生成一个字典
# 格式：
v1 = { 'k'+str(i):i for i in range(10)}