目录

• 函数的定义
  • 概念：
  • 在函数中输入形参和实参：
• 函数的参数
  • 规定：
  • 不指定关键字：
  • *args和 **kwargs ：
• 用函数打印乘法表
• 函数中字典的应用
  • 字典中get的用法：
• 函数中列表的用法
  • sort的用法
• 高阶函数：
  • 1. map
  • 2. filter: 过滤
  • 3. reudce

函数的定义

概念：

定义函数是一个赋值的过程：

def => define： 定义

def function_name(args-参数列表)：

statement1

return values => 有返回值时使用return，可以return多个值，return时，用","隔开

def print_university():
    print("北大")
    return 1, 2, 3

test_reture = print_university()    #以元组形式显示返回值
int_x, int_y, int_z = print_university()
print(test_reture) 
print(int_x, int_y, int_z)

输出结果为：

在函数中输入形参和实参：

形参： 形式参数，定义在函数时的参数叫做形参

实参： 实际参数，实际传递的时候叫做实参

def print_university(name):   #name: 形参
    print(name)

university = "北大"   #university: 实参
print_university(university)
print(type(print_university))  #函数定义的数据类型为function
function_test = print_university  #可以将结果赋给另一个变量
print(type(function_test))   #查看其数据类型仍未function
function_test(university)   #调用

输出结果为：

函数的参数

*args： 参数的复数 arguments：可以传递多个参数

规定：

1. 关键字参数必须放在参数列表的末尾。即从第一个关键字开始，后边必须都是关键字参数
2. 没指定关键字，传参根据顺序去找

def test_arg(arg1, arg2=None):   #arg1:位置参数  arg2：关键字参数
print(arg1)
print(arg2)

test_arg("arg1")
print(80 * "*")
test_arg("arg2")
print(80 * "*")
test_arg("arg1", "arg2")

输出结果为：

不指定关键字：

def test_function(arg1, arg2=None, arg3=None):
    print(arg1, arg2, arg3)

test_function(arg1=1)  #默认按顺序打印关键字参数

其输出结果为：

*args和 **kwargs ：

*args: 将传入的参数打包成一个元组，在不确定传入参数的个数时使用

** kwargs: keyword args, 是把传入的关键字参数打包成字典

print("*args----------------------------------------")
def function_args(arg1, arg2, *args):
    print(args)
function_args(1, 2, 3, 4, 5, 6)  #将对应未打印的剩余元素全部打包给*args

print("**kwargs--------------------------------------")
def function_kwargs(arg1, arg2, **kwargs):  
    print(kwargs)
function_kwargs(1, 2, arg3=1, arg4=6, arg5=8)  #将关键字参数打包成字典输出

输出结果为：

用函数打印乘法表

def mul_table(number):
    if number in range(1, 10):
        for i in range(1,number+1):
            for j in range(1, i+1):
                print(i, "*", j, "=", i*j, end="\t")
            print()
    else:
        print("The number is illegal")
mul_table()

在mul_table里边输入数字即可打印乘法表
若输入9打印九九乘法表，则输出结果为：

输入超过9的值，比如输入10，则执行结果为：

函数中字典的应用

字典中get的用法：

格式： get(self, key, default=None, /)
Return the value for key if key is in the dictionary, else default.
/ : 表示"/"前边都是仅位置参数，不能使用关键字参数
*：*后边必须使用关键字参数

def test_get(value, default=None):
    return default     #定义函数，要求返回默认值

data = test_get(1, default=4)  #返回定义的默认值
print(data)
 
def test_get(value1, value2, /, *, kwd1, kwd2):
    print("Test")   # /和*的使用
                           
test_get(1, 2, kwd1=3, kwd2=4)   #返回函数定义的值

返回结果为：

函数中列表的用法

sort的用法

格式： sort(self, /, *, key=None, reverse=False)
If a key function is given, apply it once to each list item and sort them, ascending or descending, according to their function values.
key: 是指定你排序规则的函数

list_data = [1, 7, 8, 9, 0, 6, 5, 3, 4]  #定义一个列表
print(list_data)
def sort_function(element):
    return element % 2

list_data.sort(key=sort_function)  #按照取余结果由小到大排序
print(list_data)
print("lambda--------------------------------------------")
#lambda表达式：匿名函数
#格式：lambda arguments: element % 2
list_data.sort(key=lambda element: element % 2)  #和前边函数定义按取余排序一样
print(list_data)

输出结果为：

高阶函数：

1. map

格式： map(fun, *iterrable) -> map object
作用： Make an iterator that computes the function using arguments from
each of the iterables. Stops when the shortest iterable is exhausted.
(创建一个迭代器，使用每个可迭代对象的实参计算函数。当最短的可迭代对象耗尽时停止。)

list_data_1 = [1, 2]
list_data_2 = [3, 4, 5]
list_data_3 = [6, 7, 8, 9]

def function_test(i, j, x):
return i + 1, j + 1, x + 1

第一种用法
for i in map(function_test, list_data_1, list_data_2, list_data_3):
print(i)      #将每个列表相同下标的元素以元组形式打包

第二种用法
list_data = list(map(function_test, list_data_1, list_data_2, list_data_3))
print(list_data)

输出结果为：

总结：

（1）map的结果取决于最短列表元素的个数，也取决于返回值
（2）map的数据类型其实是一个序列

2. filter: 过滤

格式： filter(function or None, iterable) --> filter object
作用： Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true.
（返回一个迭代器，生成对于某一个函数为可迭代的项为真值。如果function为None，则返回为真值的项。）

data = list(filter(lambda x : x % 2,  [1, 2, 3, 0]))

print(data)         #定义一个lambda函数，按照取余结果返回所有的真值

输出结果为： [1, 3]

3. reudce

迁移到functools这个模块中
格式： def reduce(function, sequence, initial=_initial_missing):

作用： Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value.
（将一个有两个参数的函数从左到右累加到序列的项上，以便将序列简化为单个值。）

ruduce作用练习

from functools import reduce
data = reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
print(data)

输出结果为： 15