python入门基础知识六（函数）

函数要先定义，再调用！

一、函数参数的类型：

1. 形式参数和实际参数：

def funct_name(arguments):

　　codes...

　　codes...

 

funct_name(real arguments)

 

def funct_name(a,b):    # 定义函数，设置两个参数a、b，用来接收数据
　　"""This function calculates a+b. 两数求和函数"""　　# 函数说明文档位置
    result = a + b    
    print(result)

funct_name(520,1314)    # 对a、b分别赋值520，1314，并调用函数

help(funct_name)　　# 显示函数说明文档

-------------------------------------------------

 

1834
Help on function funct_name in module __main__:

funct_name(a, b)
This function calculates a+b. 两数求和函数

2. 位置参数

定义函数时，参数的名称和位置已经确定

def funct_name(argument1,argument2,argument3...):

def funct_name(number,name,age):
    print(f'No.{number},name:{name},age:{age}.')

funct_name('001','Zhangsan',28)　　# 参数的实际值要按函数形参的顺序给定

----------------------------------------

No.001,name:Zhangsan,age:28.
Process finished with exit code 0

3. 关键字参数

以键-值的方式传入实际参数值，无关乎先后顺序

def funct_name(number,name,age):
    print(f'No.{number},name:{name},age:{age}.')
    
funct_name(age=28,number='001',name='Zhangsan')

No.001,name:Zhangsan,age:28.
Process finished with exit code 0

4. 缺省参数

指定参数的默认值，作为实际参数传入函数。若有位置参数，其必须在默认参数的前面，否则报错。

 def funct_name(name,age,gender='Male'):

　　codes...

funct_name('Zhangsan',28)

funct_name('Lily',20,gender='Female')

5. 收集参数

def funct_name(*args):    # 接收任意数量参数，返回一个元组
    print(args)

funct_name('WTF',9527)

('WTF', 9527)    # 返回的结果是元组


def funct_name(**kwargs):   # 接收键值对，返回一个字典
    print(kwargs)

funct_name(地点='WW',人物='老妖婆',事件='流窜')

{'地点': 'WW', '人物': '老妖婆', '事件': '流窜'}

 

二、函数返回值：return

def funct_name(a,b):

　　return a+b

遇到return，程序就会返回return后面的值或表达式，然后退出函数

 

三、函数递归

就是函数自己调用自己，但必须要有出口，否则成了无限循环。

"""计算1-100的累加结果"""
def funct_name(a):
    if a == 100:
        return 100    # 设置退出的出口
    outcome = a + funct_name(a+1)
    return outcome
result = funct_name(1)
print(result)

 

四、lambda表达式

函数只有一个返回值，且只有一句代码，就可以用lambda表达式简写。

1. lambda语法

lambda 形参: 表达式　　# 形参可以省略，可以接收多个实参，但返回的只有一个表达式的值

 

 2. 带条件语句的lambda表达式

def funct_name(a,b):

　　return a if a > b else b

print(funct_name(1,2))

↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
print((lambda a,b:a if a > b else b)(1,2))

 3. 列表中字典数据的排序

list_name1 =[ {'name':'Zulu','age':47},{'name':'Alpha','age':38},{'name':'Dracula','age':400} ]
list_name1.sort(key=lambda x:x['name'], reverse=False)
print(list_name1)

list_name2 = [ { 'name':'孙兴华','age':20 } , {'name':'赵丽颖','age':33 } , {'name':'李小龙','age':80 } ]
list_name2.sort(key=lambda x:x['name'], reverse=False)
print(list_name2)

--------------------------

[{'name': 'Alpha', 'age': 38}, {'name': 'Dracula', 'age': 400}, {'name': 'Zulu', 'age': 47}]
[{'name': '孙兴华', 'age': 20}, {'name': '李小龙', 'age': 80}, {'name': '赵丽颖', 'age': 33}]

注意中文的排序和英文的排序逻辑不同，个人猜想造成这个现象的原因是语系问题。

 

五、高阶函数

基于已有的函数定义新函数，以函数作为参数，返回给函数

def func_name1(a,b):
    return abs(a)+abs(b)
result = func_name1(-5,3)
print(result)

def func_name2(a,b,c):
    return c(a) + c(b)
outcome = func_name2(-5,3,abs)
print(outcome)

---------------------------------

8
8

第二个函数设置了三个参数，然后将a,b作为c的参数，最后在给出实际参数时，将c的值赋为绝对值函数abs。

1. filter(函数名,迭代对象)

 筛选序列中符合条件的元素

a =  list(range(1,11))

def funct_name1(x):
    return x%2 == 0　　# 将除2余数为零的数返回出来

outcome = filter(funct_name1,a)
print(outcome)    # 打印的是对象的内存地址
print(list(outcome))

-------------------------------

<filter object at 0x000001AC3A7F6970>
[2, 4, 6, 8, 10]

print(list(filter((lambda x:x%2 == 0),(range(1,11)))))　　# 简略写法

2. map(函数名,迭代对象)

将序列中每个元素作为函数的参数进行运算

a =  list(range(1,5))

def funct_name(x):
    return x ** 2    # 计算该数的二次方

outcome = map(funct_name,a)
print(list(outcome))


print(list(map((lambda x:x ** 2),(range(1,5)))))    # 简略写法

-----------------------------

[1, 4, 9, 16]
[1, 4, 9, 16]

3. reduce(函数名(x,y),迭代对象)

函数中必须有2个参数，每次的计算结果继续和序列的下一个元素做累加计算

import functools    # 导入模块
a = list(range(1,101))
def funct_name(a,b):
    return a + b    # 计算加和
outcome =  functools.reduce(funct_name,a)    # 引入reduce函数后，将函数的每次计算结果和序列的下一元素做累加
print(outcome)


print(functools.reduce((lambda x,y : x + y),(range(1,101))))    # 简略写法

---------------------------------------

5050
5050

和前面两例相比，为什么这次不用list()转类型了？因为最终的加和结果是一个值，而不是列表，所以不需要用list转类型。