Python学习笔记-函数进阶之三元表达式匿名函数内置函数

Posted 2020-10-30 wangzhiwei10

一、三元表达式

name=input(‘姓名>>: ‘).strip()
res=‘SB‘ if name == ‘alex‘ else ‘NB‘
print(res)

# 执行结果：
姓名>>: alex
SB

姓名>>: lionel
NB

三元表达式

二、列表推导式

l=[]
for i in range(1,11):
    l.append(‘egg‘ + str(i))
print(l)

# 执行结果：
[‘egg1‘, ‘egg2‘, ‘egg3‘, ‘egg4‘, ‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘, ‘egg10‘]

# 升级版（使用列表推导式）：
l=[‘egg‘ + str(i) for i in range(1,11)]
print(l)

# 执行结果：
[‘egg1‘, ‘egg2‘, ‘egg3‘, ‘egg4‘, ‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘, ‘egg10‘]

# 加一层判断：
l1=[‘egg‘ + str(i) for i in range(1,11) if i >=6]
print(l1)

# 执行结果：
[‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘, ‘egg10‘]

列表推导式

[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
类似于
res=[]
for item1 in iterable1:
    if condition1:
        for item2 in iterable2:
            if condition2
                ...
                for itemN in iterableN:
                    if conditionN:
                        res.append(expression)

列表推导式语法

优点：方便，改变了编程习惯，可称之为声明式编程

三、生成器表达式

1、把列表推导式的[]换成()就是生成器表达式

g=(‘egg‘ + str(i) for i in range(1,11))
print(g)
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(list(g))    #因为g可迭代，因而可以转成列表

# 执行结果：
<generator object <genexpr> at 0x10242eeb8>
egg1
egg2
egg3
egg4
[‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘, ‘egg10‘]

2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性

3、优点：省内存，一次只产生一个值在内存中

四、递归调用

1、递归调用定义

　　在调用一个函数的过程中，直接或者间接又调用该函数本身，称之为递归调用

2、递归必备的两个阶段：递推和回溯

# python打印阶乘结果（普通方法）
def factorial(n):
    result = n
    for i in range(1,n):
        result *= i
    return result

num = int(input(‘>>: ‘))
result = factorial(num)
print(‘%d的阶乘是：%d‘ %(num,result))

# 执行结果：
>>: 5
5的阶乘是：120

# python打印阶乘结果（递归方法）
def factorial(n):
    if n == 1:
        return n
    else:
        return n * factorial(n-1)
num = int(input(‘>>: ‘))
result = factorial(num)
print(‘%d的阶乘是：%d‘ %(num,result))

# 执行结果：
>>: 5
5的阶乘是：120

代码示例

# 求5的阶乘实现解析
factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1

3、总结

1. 调用函数本身
2. 必须有一个明确的结束条件
3. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
4. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

4、修改递归最大深度

import sys
sys.getrecursionlimit()
sys.setrecursionlimit(2000)

五、二分法

l=[1,2,10,30,33,99,101,200,301,402]

def binary_search(l,num):
    print(l)
    #如果值不存在，则列表切为空
    if len(l) == 0:
        print(‘not exists‘)
        return
    mid_index=len(l) // 2
    if num > l[mid_index]:
        # 往右找
        binary_search(l[mid_index+1:],num)
    elif num < l[mid_index]:
        # 往左找
        binary_search(l[0:mid_index],num)
    else:
        print(‘find it‘)

binary_search(l,301)

# 执行结果：
[1, 2, 10, 30, 33, 99, 101, 200, 301, 402]
[101, 200, 301, 402]
find it

想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法

六、匿名函数

1、什么是匿名函数

　　Python使用lambda关键字来创建匿名函数。lambda表达式语法非常精简，基本语法是在冒号（:）左边放原函数的参数，可以有多个参数，用逗号（,）隔开；冒号右边是返回值。

匿名就是没有名字
def func(x,y,z=1):
    return x+y+z

匿名
lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
func=lambda x,y,z=1:x+y+z 
func(1,2,3)
#让其有名字就没有意义

2、lambda表达式的作用

　　（1）Python写一些执行脚本时，使用lambda就可以省下定义函数过程，比如说只需要写个简单的脚本来管理服务器时，就不需要专门定义一个函数然后再写调用，使用lambda就可以使代码更加精简。

　　（2）对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候给函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名的问题了。

　　（3）简化代码的可读性，由于阅读普通函数经常要跳到开头def定义的位置，使用lambda函数就可以省去这样的步骤。

3、有名函数和匿名函数对比

　　有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能
　　匿名函数：一次性使用，随时随时定义

4、匿名函数的应用（部分内置函数）

• zip()函数，又称拉链

　　zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

s=‘hello‘
l=[1,2,3]
g=zip(s,l)
print(list(g))

# 执行结果：
[(‘h‘, 1), (‘e‘, 2), (‘l‘, 3)]

zip()函数

• max()、min()函数

　　max() 方法返回给定参数的最大值，参数可以为序列。

　　min() 方法返回给定参数的最小值，参数可以为序列。

salaries={
    ‘egon‘:3000,
    ‘alex‘:100000000,
    ‘wupeiqi‘:10000,
    ‘yuanhao‘:2000
}

g=zip(salaries.values(),salaries.keys())
print(max(g))

res1=max(salaries,key=lambda k:salaries[k])
print(res1)
res2=min(salaries,key=lambda k:salaries[k])
print(res2)

# 执行结果：
(100000000, ‘alex‘)
alex
yuanhao

max()、min()函数

• sorted函数

　　sorted()函数对所有可迭代的对象进行排序操作。

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

# 参数说明：
# iterable -- 可迭代对象。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

sorted()函数语法

salaries={
    ‘egon‘:3000,
    ‘alex‘:100000000,
    ‘wupeiqi‘:10000,
    ‘yuanhao‘:2000
}
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

# 执行结果：
[‘alex‘, ‘wupeiqi‘, ‘egon‘, ‘yuanhao‘]

sorted()函数

• map()函数

　　map()会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map(function, iterable, ...)

# 参数说明：
# function -- 函数，有两个参数
# iterable -- 一个或多个序列

map()函数语法

# 对指定序列做映射
l=[]
for name in names:
    res=‘%s_SB‘ %name
    l.append(res)
print(l)

# 执行结果：
[‘alex_SB‘, ‘wupeiqi_SB‘, ‘yuanhao_SB‘]

# 使用map()函数结合匿名函数
g=map(lambda name:‘%s_SB‘ %name,names)
print(list(g))

# 执行结果：
[‘alex_SB‘, ‘wupeiqi_SB‘, ‘yuanhao_SB‘]

map()函数

• filter()函数

　　filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

filter(function, iterable)

# 参数作用：
# function -- 判断函数。
# iterable -- 可迭代对象。

filter()函数语法

names=[‘alex_sb‘,‘wupeiqi_sb‘,‘yuanhao_sb‘,‘egon‘]
g=filter(lambda x:x.endswith(‘sb‘),names)
print(list(g))

# 执行结果：
[‘alex_sb‘, ‘wupeiqi_sb‘, ‘yuanhao_sb‘]

filter()函数

• reduce()函数

　　reduce()函数会对参数序列中元素进行累积。函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

reduce(function, iterable[, initializer])

# function -- 函数，有两个参数
# iterable -- 可迭代对象
# initializer -- 可选，初始参数

reduce()函数语法

from functools import reduce
print(reduce(lambda x,y:x+y,range(1,101),100))

# 执行结果：
5150

reduce()函数

七、内置函数

 

• divmod()函数

 　　divmod()函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。用于分页，如果数据库有10001条数据，每页只显示25条，答需要401页显示完整数据。

print(divmod(10001,25))

# 执行结果：
(400, 1)

• enumerate()函数

　　enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

enumerate(sequence, [start=0])

# 参数作用：
# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。

l=[‘a‘,‘b‘,‘c‘]
for item in enumerate(l):
    print(item)

# 执行结果：
(0, ‘a‘)
(1, ‘b‘)
(2, ‘c‘)

for i,v in enumerate(l):
    print(i,v)

# 执行结果：
0 a
1 b
2 c

enumerate()函数

• eval()函数

　　eval()函数用来执行一个字符串表达式，并返回表达式的值。

eval(expression[, globals[, locals]])

# 参数作用：
# expression -- 表达式。
# globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
# locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

eval()函数语法

res=eval(‘[1,2,3]‘)
print(res,type(res))

# 执行结果：
[1, 2, 3] <class ‘list‘>

eval()函数

• pow()函数

　　pow(x,y,z),x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z。

res=pow(2,3,3) # (2 ** 3)%3
print(res)

# 执行结果：
2

• round()函数

　　round()函数返回浮点数x的四舍五入值。

print(round(3.5))

# 执行结果：
4

# __import__,用于动态加载类和函数。
choice=input(‘>>: ‘)
m=__import__(choice)
m.sleep(3)

# 执行结果：
>>: time

进程已结束,退出代码0

__import__动态加载类和函数