Python函数简介

最新推荐文章于 2024-07-18 20:16:36 发布

z1earn

最新推荐文章于 2024-07-18 20:16:36 发布

阅读量475

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/kepler11/article/details/113861516

版权

Python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

1. 函数的定义

函数以def开头然后是函数名，圆括号里是参数表，然后：后表示函数的具体代码
Python以缩进代表代码块，因此函数体要缩进
return语句结束函数，并返回值。可以没有return语句，表示无返回值

def function_name(parameters):
    "注释"
    function_suite
    return [expression]

2. 函数的调用

def hello():
    # 无返回值
    print("hello world!")
# 调用函数
hello() # hello world!
  
def add(a,b):
    # 返回a+b
    return a+b
#调用函数
a = 1
b = 2
c = add(a, b)
print(c) # 3

3. 函数文档

函数的文档一般用来对函数做出说明

# 比如
def myFunction(str):
    "这是一个函数，形参为str"
    print(str)

help(myFunction)
'''输出

Help on function myFunction in module __main__:

myFunction(str)
    这是一个函数，形参为str
    
'''
print(myFunction.__doc__)
'''输出

这是一个函数，形参为str

'''

4. 函数的参数

Python的函数的参数非常灵活多样：

位置参数 (positional argument)
默认参数 (default argument)
可变参数 (variable argument)
关键字参数 (keyword argument)
命名关键字参数 (name keyword argument)
参数组合

4.1 位置参数

位置参数比较容易理解，就是在调用函数时根据相对位置来确定将实参赋值给哪一个形参

def function(str1, str2):
    print("这是str1: " + str1)
    print("这是str2: " + str2)

str1 = "str1"
str2 = "str2"
function(str1, str2)
print("----------------")
function(str2, str1)

'''输出
这是str1: str1
这是str2: str2
----------------
这是str1: str2
这是str2: str1
'''

很明显，如果没有按照参数的位置调用函数，可能会发生错误

为了避免位置错误的尴尬，Python允许函数调用时参数的顺序与生命时不一致，但是调用函数时要指明参数名

def function(str1, str2):
    print("这是str1: " + str1)
    print("这是str2: " + str2)
    
str1 = "str1"
str2 = "str2"

function(str2=str2, str1=str1)
'''
这是str1: str1
这是str2: str2
'''

4.2 默认参数

默认参数顾名思义就是具有默认值的参数,调用函数时如果不给出参数的值，则会使用函数定义时的默认值

def function(a=1,b=2):
    "a的默认值为1，b的默认值为2"
    return a+b

# a=1,b=2
print(function()) # 3
# a=2,b=4
print(function(2,4)) # 6
# a=4,b=2
print(function(4)) # 6

默认参数一定要放在位置参数的后面，否则会报错

4.3 可变参数

有时候我们并不确定要传入参数的个数，这时就要用到可变参数

def fun(arg1, *args):
    # *arg是可变参数
    print(args)
    print(type(args))
    for arg in args:
        arg1 += arg
    return arg1

print(fun(1,2,3,4,5)) 
'''
(2, 3, 4, 5)
<class 'tuple'>
1
'''

*args 代表可变参数，可以是1个或多个，通过调用fun(1,2,3,4,5)，可以看到，可变参数被组装成元组

4.4 关键字参数

与可变参数类似，关键字参数会被自动组装成字典

def fun(arg1, **kw):
    print(kw)
    print(type(kw))

fun(5,a=1,b=2)
'''
{'a': 1, 'b': 2}
<class 'dict'>
'''

** kw 代表关键字参数，可以是1个或者多个

4.5 命名关键字参数

如果要限制关键字参数的名字，可用命名关键字参数

***，nkw ** 表示指明nkw为命名关键字参数

def printinfo(arg1, *, nkw):
    print(arg1,end=' ')
    print(nkw)

# 使用命名关键字参数是，必须使用参数名
printinfo('hello',nkw='world') # hello world

4.6 函数参数表的顺序

Python函数调用时，实参表由左到右就是简单的两个部分

funcname(【位置实参】,【关键字实参】)

个前后顺序是严格的，两个部分都可以缺省，但不能相互交错！请在阅读下面（尤其是函数定义的部分）时牢牢记住这一点

更加详细的说：

在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：

位置参数、默认参数、可变参数和关键字参数。
位置参数、默认参数、命名关键字参数和关键字参数。

5. 函数的返回值

Python函数的返回值可以是任意的数据类型，可以返回一个或多个

def add(a, b):
    # 返回a+b，类型由a，b决定
    return a + b

def genList():
    li = []
    for i in range(11):
        li.append(i)
    # 返回一个列表
    return li

li  = genList()
print(li) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def changeStr(str1,str2):
    str1 = str1.upper()
    str2 = str2.lower()
    # 返回两个字符串
    return str1, str2

str1, str2 = changeStr('hello','world')
print(str1 + ' ' + str2) # HELLO world

6. Lambda 表达式(匿名函数)

6.1 定义

在 Python 里有两类函数：

第一类：用 def 关键词定义的正规函数
第二类：用 lambda 关键词定义的匿名函数

Python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：

lambda argument_list: expression

lambda - 定义匿名函数的关键词。
argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
:- 冒号，在函数参数和表达式中间要加个冒号。
expression - 只是一个表达式，输入函数参数，输出一些值。

注意：

expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

def f(x):
    return x*2

y = [f(x) for x in range(10)]
print(y) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

lambda_ = lambda x: x*2
# lambda函数中的表达式就是返回值
z = [lambda_(x) for x in range(10)]
print(z) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

6.2 应用

匿名函数常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：

参数是函数 (filter, map)
返回值是函数 (closure)

例子：

filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

map(function, *iterables) 根据提供的函数对指定序列做映射。

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  
# [1, 4, 9, 16, 25]

m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  
# [3, 7, 11, 15, 19]