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

时间  2019-12-10
标签 python 旅途 函数 应用 lambda 内置 闭包 栏目 Python 繁體版
原文   原文链接

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

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

1.函数的初级应用场景

以前咱们学过了不少的数据类型，其中容器类型的有集合、字典、列表等，而函数也能够做为元素放进这些容器类型的数据类型面试

  1. 函数能够放在集合里，也能够放在字典里，在字典中的时候通常做为字典的值闭包

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

  2. 函数名当变量来使用app

    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

    混淆：dom

    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)
# 以上的两种写法是彻底等价的

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

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

3.内置函数

  1. 内置函数code

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

  2. 输入输出ip

    • 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函数的简单使用，以及函数的相对高级的概念，什么是闭包，这些都是咱们之后再敲代码的时候须要紧紧掌握的。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程