Python旅途——函数的应用、lambda函数、内置函数、闭包

Python——函数的应用、lambda表达式、内置函数

今天主要分享函数的一般的应用场景，这里给大家分为初级一些的应用场景，以及高级的应用场景。还有一种特殊的函数形式——lambda表达式

1.函数的初级应用场景

之前我们学过了很多的数据类型，其中容器类型的有集合、字典、列表等，而函数也可以作为元素放进这些容器类型的数据类型

1. 函数可以放在集合里，也可以放在字典里，在字典中的时候一般作为字典的值

   def func():
       print(123)
   def bar():
       print(666)
   info = {'k1': func, 'k2': bar}
   info['k1']()
   info['k2']()
   

2. 函数名当变量来使用

   def func():
       print(1,2,3)
   x = func()
   print(x)  
   lis = [func(),func(),func()]
   print(lis)
   

   def func():
       print(123)
       
   func_list = [func, func, func]
   # func_list[0]()
   # func_list[1]()
   # func_list[2]()
   for item in func_list:
       v = item()
       print(v)   # 123 None 123 None 123 None
   

   def func():
       print(123)
   
   def bar():
       print(666)
   
   info = {'k1': func, 'k2': bar}
   
   info['k1']()
   info['k2']()  #  123 666
   

   混淆：

   def func():
       return 123
   
   func_list1 = [func,func,func]
   func_list2 = [func(),func(),func()]
   
   print(func_list1)  # [<function func at 0x000002C1829BBA60>, <function func at 0x000002C1829BBA60>, <function func at 0x000002C1829BBA60>]
   print(func_list2)  #[123, 123, 123]
   

3. 函数可以当参数进行传递

   def func(arg):
       v1 = arg()
       print(v1)
       
   def show():
       print(666)
       
   func(show)  #  666 None
   

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

2.函数的lambda表达式

• lambda表达式是用来表达简单的函数，默认有返回值return

  def func(a1,a2):
      return a1+a2
  func2 = lambda a1,a2:a1+a2
  v = func2(1,2)
  # 以上的两种写法是完全等价的
  

• 输入两个数，比较大小，返回大的那个

  func5 = lambda a,b:a if a>b else b  #输入两个数，返回其中大的数字
  v = func5(3,4)
  

3.内置函数

1. 内置函数

   • len：取长度
   • open：文件操作
   • range：范围
   • id：判断id
   • type：判断类型

2. 输入输出

   • input
   • print

3. 强制转换

   • dict()：转字典
   • list()：转列表
   • tuple()：转元组
   • str()：转字符串
   • int()：转数字
   • set()：转集合
   • bool()：转布尔

4. 数字相关

   • abs() : 绝对值

     v = abs(-1)
     print(v)
     

   • float() :浮点型（小数）

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

   • max() :最大值

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

   • min() :最小值

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

   • sum() :求和

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

   • divmod() :两数相除，得商和余数

     a,b = divmod(1001,5)
     
     print(a,b)
     

   • 分页功能

     # 练习题  请通过分页对数据进行展示
     """
     要求：
         每页显示10条数据
         让用户输入要查看的页面：页码
     """
     lis = []
     for i in range(1,845):
         info = {'name':'大栗%s'%i,'age':'1%s'%i}
         lis.append(info)
     
     per_page= 10
     total_data = 845
     page,other = divmod(total_data,per_page)
     if other != 0:
         page += 1
     #  1    0-10
     #  2    10-20
     #  3    20-30
     while True:
         message = input('请输入页数：')
         message = int(message)
         if message>845 or message<1:
             print('错误')
         else :
             start_position = (message-1)*per_page
             end_position = message*per_page
             data = lis[start_position:end_position]
             print(data)
             for item in data:
                 print(item)
     
     

     LIS = []
     for i in range(1,934):
         info = {'name':'小猪%s'%i,'hobby':'睡觉%s'%i}
         LIS.append(info)
     how_many = 7
     hole_length = len(LIS)
     print(hole_length)
     hole_length,rest = divmod(hole_length,how_many)
     if rest != 0:
         hole_length += 1
         # 1    0,7
         #2     7,14
         #3     14,21
         #4     21,28
     
     while True:
         message = input("请输入")
         message = int(message)
         if message>hole_length or message<1:
             print('输入有误，请在范围内输入;')
         else:
             start_location =(message-1)*how_many
             end_location = message*how_many
             total = LIS[start_location:end_location]
             for line in total:
                 print(line)
     """
     
     

5. 编码相关

   • chr ：将十进制转化为Unicode编码中对应的字符串

     v = chr(99)
     print(v)
     

   • ord ：将Unicode编码中对应的字符串找到并转化为其对应的十进制

     num = ord('中')
     

     # 应用
     # 随机验证码
     import random  
     def get_random_code(length = 6):
         LIS = []
         for i in range(length):
             v = random.randint(65,90)
             LIS.append(chr(v))
             var = "".join(LIS)
         return var
     v1 = get_random_code(7)
     print(v1)
     

     import random # 导入一个模块 
     
     v = random.randint(起始,终止) # 得到一个随机数
     

6. 高级一点的内置函数

   • map：循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表里并返回。（有返回值）

     v1 = [11,22,33,44]
     result = map(lambda x:x+100,v1)
     print(list(result)) # 特殊
     #  每个数乘以10
     v1 = [12,34,45,23]
     var = map(lambda x:x*10,v1)
     print(list(var))
     

   • filter

     v1 = [11,22,33,'asd',44,'xf']
     
     def func(x):
         if type(x) == int:
             return True
         return False
     result = filter(func,v1) # [11,]
     print(list(result))
     
     
     result = filter(lambda x: True if type(x) == int else False ,v1)
     print(list(result))
     
     result = filter(lambda x: type(x) == int ,v1)
     print(list(result))
     

   • reduce

     import functools
     v1 = ['wo','hao','e']
     
     def func(x,y):
         return x+y
     result = functools.reduce(func,v1)
     print(result)
     
     result = functools.reduce(lambda x,y:x+y,v1)
     print(result)
     

   • 面试题：

   • 常用的内置函数有哪些？

   • filter/map/reduce是什么意思？

   • 什么是匿名函数？

7. 进制转换相关

• bin：将十进制转换为二进制

  num = 13
  v1 = bin(num)
  print(v1)
  

• oct：将十进制转换为八进制

  num = 13
  v1 = oct(num)
  print(v1)
  

• int：将十进制转换为十进制

  num = 13
  v1 = int(num)
  print(v1)
  

• hex：将十进制转换为十六进制

  num = 13
  v1 = hex(num)
  print(v1)
  

• 二进制转换为十进制

  v1 = "0b1101"
  result = int(v1,base = 2)
  print(result)
  

• 二进制转换为八进制

  v1 = "0o1101"
  result = int(v1,base = 2)
  print(result)
  

• 二进制转换为十六进制

  v1 = "0x1101"
  result = int(v1,base = 2)
  print(result)
  

• ip地址转换成二进制数（面试）

  # 1字节等于8位
  # IP: 192.168.12.79  ->  001010010 . 001010010 . 001010010 . 001010010
  
  # 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
  # 简单版——假面试
  lis = []
  ip = "192.168.12.79"
  var = ip.split(".")
  for i in var:
      new_i = int(i)
      x = bin(new_i)
      lis.append(x)
      result = ",".join(lis)
  print(result)
  # 加强版——真面试
  lis = []
  ip = "192.168.12.79"
  a = ip.split(".")
  for i in a:
      new_i = int(i)
      var = bin(new_i)
      var = var[2:]
      if len(var) != 8:
          var = var.rjust(8,'0')
      lis.append(var)
      x = "".join(lis)
  print(int(x,base=2))
  

4.函数的高级应用场景

• 函数内部执行相互之间不会混乱，执行完毕+内部元素不被其他人使用

• 函数可以做返回值进行返回

  def func():
      print(123)
  
  def bar():
      return func
  # bar函数加括号执行经过return返回给v，此时v为func函数，但是并没有执行
  v = bar() 
  # v加括号，执行func函数
  v()
  

  def bar():
      def inner():
          print(123)
      return inner
  # bar函数加括号执行，将inner函数加载到内存，但是没有执行，返回inner函数
  v = bar()
  # 此时的v为inner函数，加括号执行
  v()
  

• 函数的变量位置问题

  # 此时全局变量name为大栗
  name = '大栗子'
  def bar():
      name = '小栗子'
      def inner():
          print(name)
      return inner
  # bar函数加括号执行时，将name=大栗子修改成了name=小栗子，并保存到内存
  v = bar()
  # 此时v为inner函数，执行打印name为小栗子
  v()
  

  # 再来看一个
  name = '糖炒栗子'
  def bar(name):
      def inner():
          print(name)
      return inner
  v1 = bar('大栗') # { name=alex, inner }  # 闭包，为函数创建一块区域（内部变量供自己使用），为他以后执行提供数据。
  v2 = bar('小栗') # { name=eric, inner }
  v1()
  v2()
  # 打印的name分别为大栗、小栗
  

• 带闭包、传参的面试题

  # 简单版面试题
  info = []
  
  def func():
      print(item)
  # 此时的for循环已经结束，在内存地址中的item已经为9
  for item in range(10):
      info.append(func)
  
  info[0]() # 9
  
  # 加强版
  info = []
  
  def func(i):
      def inner():
          print(i)
  	return inner
  # 循环的时候，把每个item封装到了内存地址，为后面的使用进行保留（闭包）
  for item in range(10):
      info.append(func(item))
  # 0 1 4
  info[0]()
  info[1]()
  info[4]()
  

• 闭包：为函数创建一块区域（内部变量供自己使用），为以后的执行提供数据

  def func(name):
      def inner():
          print(name)
  	return inner 
  
  v1 = func('alex')
  v1()
  v2 = func('eric')
  v2()
  

• 注：函数何时被创建，进而判断将变量保存到了内存地址

• 高阶函数：把函数当做参数传递、把函数当做返回值

• 总结：函数执行的流程分析

  • 闭包的概念：为函数创建一个区域并为其维护自己的数据，以后执行时方便调用
  • 应用场景：装饰器、SQLAlchemy源码

今天主要分享了函数的一些简单的应用、高级的应用、传参、lambda函数的简单使用，以及函数的相对高级的概念，什么是闭包，这些都是我们以后再敲代码的时候需要牢牢掌握的。