Python 函数3000字使用总结

  • A+
所属分类:安全开发

来自公众号:Python与算法社区

今天是Python函数专题,目录结构:

  • Python 函数专题

  • 基础部分

    • 1 函数组成

    • 2 引用传参

    • 3 默认参数与关键字参数

    • 4 可变参数

    • 5 内置函数

  • 进阶部分

    • 6 偏函数

    • 7 递归函数

    • 8 匿名函数

    • 9 高阶函数

    • 10 嵌套函数

  • 总结

Python 函数专题

函数是一个接受输入、进行特定计算并产生输出的语句集。

我们把一些经常或反复被使用的任务放在一起,创建一个函数,而不是为不同的输入反复编写相同的代码。

Python提供了printsortedmaxmap等内置函数,但我们也可以创建自己的函数,称为用户定义函数。

基础部分

1 函数组成

如下自定义函数:

def foo(nums):
    """ 返回偶数序列"""
    evens = []
    for num in nums:
        if num%2==0:
            evens.append(num)
    return evens

可以看到函数主要组成部分:

  • 函数名:foo
  • 函数形参:nums
  • :: 函数体的控制字符,作用类似JavaC++的一对{}
  • 缩进:一般为4个字符
  • """:为函数添加注释
  • return: 函数返回值

以上函数求出列表nums中的所有偶数并返回,通过它了解Python函数的主要组成部分。

2 引用传参

定义好一个函数后,使用:函数名+()+实参,调用函数,如下方法:

foo([10,2,5,4])
Python 函数3000字使用总结

其中[10,2,5,4]为实参,它通过by reference方式传给形参nums,即nums指向列表头,而不是重新复制一个列表给nums.

再看一个引用的例子:

def myFun(x): 
    x[0] = 20

如下调用:

lst = [101112131415
myFun(lst)

实参lst和形参x都指向同一个列表:

Python 函数3000字使用总结

因此,对x[0]修改实际就是对实参lst的修改,结果如下:

Python 函数3000字使用总结

但是,有时在函数内部形参指向改变,因此实参与形参的指向分离,如下例子:

def myFun(x):  
    x = [203040]
    x[0] = 0

调用:

lst = [101112131415
myFun(lst)

x 被传参后初始指向lst,如下所示:

Python 函数3000字使用总结

但是,执行x = [20, 30, 40]后,对象x重新指向一个新的列表对象[20,30,40]

Python 函数3000字使用总结

因此,对于x内元素的任何修改,都不会同时影响到lst,因为指向已经分离。

3 默认参数与关键字参数

Python函数的参数,可以有初始默认值,在调用时如果不赋值,则取值为默认值,如下例子:

def foo(length,width,height=1.0):
    return length*width*height

调用foo函数,没有为height传参,所以取为默认值1.0

r = foo(1.2,2.0)
print(r) # 2.4

使用默认值有一点需要区分,有的朋友会与关键字参数混淆,因为它们都是para=value的结构,但是有一个很明显的不同:默认值是声明在函数定义时,关键字参数是在函数调用时使用的此结构。如下例子:

def foo(length,width,height=1.0): # height是默认参数
    return length*width*height

foo(width=2.0,length=1.2#确定这种调用后才确定width和length是关键字参数

确定以上调用后,才确定widthlength是关键字参数,并且关键字参数不必按照形参表的顺序调用。

4 可变参数

JavaC++在解决同一个函数但参数个数不同时,会使用函数重载的方法。Python使用可变参数的方法,非常灵活。

可变参数是指形参前带有*的变量,如下所示:

def foo(length,*others):
    s = length
    for para in others:
        s *= para
    return s

我们可以像下面这样方便的调用:

foo(1.2,2.0,1.0# 2.4
Python 函数3000字使用总结

如上,带一个星号的参数被传参后,实际被解释为元组对象。我们还可以这样调用:

foo(1.2# 1.2

5 内置函数

总结完函数的参数后,再举几个Python内置的常用函数。

pow

大部分朋友应该知道pow是个幂次函数,比如求

pow(2,3

除此以外,pow还有第三个参数,使用更高效的算法实现求幂后再求余数:

pow(2,3,5# 3

max,min

max,min用来求解最大最小值,实现relu函数:

def relu(x):
    return max(x,0)

sorted

sorted函数完成对象排序,它能接收一个指定排序规则的函数,完成定制排序。如下,根据字典值绝对值从小到大排序:

d = {'a':0,'b':-2,'c':1}
dr = sorted(d.items(),key=lambda x:abs(x[1])) 
print(dr) # [('a', 0), ('c', 1), ('b', -2)]

进阶部分

Python有一个专门操作函数的模块:functools,能实现一些关于函数的特殊操作。

6 偏函数

偏函数固定函数的某些参数后,重新生成一个新的函数。

通常用法,当函数的参数个数太多,需要简化时,使用partial创建一个新的函数。

假设我们要经常调用int函数转换二进制字符,设置参数base为2:

int('1010',base=2)

为了避免每次都写一个参数base,我们重新定义一个函数:

def int2(s):
    return int(s,base=2)

以后每次转化字符串时,只需int2('1010)即可,更加简便。

偏函数也能实现上述功能:

from functools import partial

intp = partial(int,base=2

那么有的朋友会问,偏函数就是个鸡肋,重新定义的int2更加直观容易理解,这个角度讲确实是这样。但是int2不能再接收base参数,但是intp函数还是能接收base参数,依然保留了原来的参数:

intp('10',base=16# 16

可能看到这里的读者还是有些迷糊,不太确定怎么使用偏函数。可以先记住:修改内置函数的默认参数,就像内置函数int默认参数base等于10,使用偏函数调整默认base值为2.

7 递归函数

递归函数是指调用自身的函数。如下使用递归反转字符串:

def reverseStr(s): 
    if not s:
        return s 
    return reverseStr(s[1:])+s[0]
    
print(reverseStr('nohtyp')) # python

reverseStr函数里面又调用了函数reverseStr,所以它是递归函数。

使用递归函数需要注意找到正确的递归基,防止陷入无限递归。

更多使用递归的例子大家可参考此公众号之前推送。

8 匿名函数

匿名函数是指使用lambda关键字创建的函数。它的标准结构如下:

lambda 形参列表: 含有形参列表的表达式

表达式的计算值即为lambda函数的返回值。

如下lambda函数:

lambda x,y: x+y

它等价于下面的f函数:

def f(x,y):
    return x+y

lambda函数常做为max,sorted,map,filter等函数的key参数。

9 高阶函数

可以用来接收另一个函数作为参数的函数叫做高阶函数。

如下f有一个参数g,而g又是函数,所以f是高阶函数:

def f(g):
    g()

Python 中经常会遇到高阶函数,今天介绍几个内置的常用的高阶函数。

map

map 函数第一个参数为函数,它作用于列表中每个的元素。

如下,列表中的单词未按照首字母大写其他字符小写的规则,使用map一一capitalize每个元素:

m = map(lambda s: s.capitalize(), ['python','Very','BEAUTIFUL'])
print(list(m))

结果:

['Python', 'Very', 'Beautiful']

reduce

reduce 高阶函数实现化简列表,它实现的效果如下:

Python 函数3000字使用总结

如下例子,函数f等于x+y,求得两数之和,然后再与第三个数相加,依次下去,直到列表尾部,进而得到整个列表的和:

from functools import reduce 

def f(x,y):
    return x+y

r = reduce(f, [1,3,2,4])
print(r) # 10

以上reduce求解过程等于:

Python 函数3000字使用总结

需要注意:reduce函数要求f必须带2个参数,只有这样才能完成归约化简。

10 嵌套函数

嵌套函数是指里面再嵌套函数的函数。

如下例子,将列表转化为二叉树。已知列表nums

nums = [3,9,20,None,None,15,7],转化为下面二叉树:

Python 函数3000字使用总结

二叉树定义:

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

构建满足以上结构的二叉树,可以观察到:树的父节点和左右子节点的关系:


Python 函数3000字使用总结

基于以上公式,再使用递归构建二叉树。

递归基情况:

if index >= len(nums) or nums[index] is None:
    return None

递归方程:


Python 函数3000字使用总结

根据以上分析,得到如下代码,list_to_binarytree函数是嵌套函数,它里面还有一个level子函数:

def list_to_binarytree(nums):
    def level(index):
        if index >= len(nums) or nums[index] is None:
            return None
        
        root = TreeNode(nums[index])
        root.left = level(2 * index + 1)
        root.right = level(2 * index + 2)
        return root

    return level(0)

binary_tree = list_to_binarytree([3,9,20,None,None,15,7])

通常使用嵌套函数的场景:实现一个功能只需要编写2个函数,写成一个class好像显得有些不必要,写成嵌套后更简洁,并且某些参数能共享,亲和性会更好。不妨体会上面的nums参数。

总结

函数专题主要总结了以下:

  • Python 函数专题

  • 基础部分

    • 1 函数组成

    • 2 引用传参

    • 3 默认参数与关键字参数

    • 4 可变参数

    • 5 内置函数

  • 进阶部分

    • 6 偏函数

    • 7 递归函数

    • 8 匿名函数

    • 9 高阶函数

    • 10 嵌套函数

  • 总结



●输入m获取文章目录

推荐↓↓↓

Python 函数3000字使用总结

人工智能与大数据技术

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: