python基础（8）函数（内置函数，lambda函数，自定义函数）

最新推荐文章于 2024-06-25 18:02:57 发布

Me_ing

最新推荐文章于 2024-06-25 18:02:57 发布

阅读量1.3k

点赞数 29

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/2302_79711722/article/details/135499785

版权

python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一.内置函数

内置函数即为python提供的，可以被直接使用的函数，下面列举几个常见函数

1.1 输入输出函数

输入函数和输出函数都是我们常用的

输入：input（）

输出：print（）

1.1.1 输入一个数字

#输入一个数字
num = input("请输入一个数字：")
print(num)
print(type(num))

在这里，input表示输入，print 把我们想要的结果输出出来，需要注意的是，input输出的类型是“str”，这就表明当输入数字时，其不能进行数的加减，或者进行类似操作。

运行结果：

由于类型不同，直接进行比如数的运算会报错。如下,

num = input("请输入一个数字：")
print(6 + 4)
print(num + 4)

运行结果：

1.1.2 输入多个数字

当输入多个数字时，我们需要用到split（）。它的作用是拆分字符串，通过指定分隔符对字符串进行切片，并返回分割后的字符串列表。

#输入多个数字
num1 = input("请输入您想要输入的数字：").split()#以空格隔开
print(type(num1))
num2 = input("请输入您想要输入的数字：").split(";")#以;隔开
print(num2)
print(type(num2))

运行结果：

需要注意的是，我们在输入两个数时，中间需要用分隔符来隔开，第一个的分隔符是一个空格，第二个的分隔符是；分隔符分号的英文输入还是中文输入对结果也会产生影响。

我们可以看到在这里，我采用的代码是以 ; (英文)的为分隔符，当我没有用间隔符时，展示出的列表里只有一个元素，不同于上文的有三个元素。

当我们以；(中文)在输入时作为分隔符时，也只有一个元素，其无法识别输入内容的中午分号（我们在编写程序时使用了英文分号作为分隔符）

在python中是以英文符号为主，尽量不使用中文符号

1.2 与数学有关的函数

在python中，存在一些内置函数，可以进行简单的数学运算，如求和，取绝对值


#求绝对值abs()
print(abs(-6))
#求序列和sum()
print(sum([1, 2, 3, 6]))

运行结果：

1.3 与序列有关的函数

与序列有关的内置函数通常包括：

len()：求取序列长度

min()：求取可迭代对象或者多个参数的最小值

max()：求取可迭代对象或者多个参数的最大值

sorted()：正序排列可迭代对象

reversed（）：倒序排列可迭代对象

1.语法格式：len(__obj)

__obj：要计算的字符串，列表，字典等

返回值：字符串，列表，字典等的长度（返回值在后文自定义函数中会详细解释）

#len():求取序列长度
l = [1, 2, 3, 4, 5, 6]
print(len(l))

在这里，len() 求出来了序列 l 的长度

2.max()&min()

语法格式：

max(iterable)

max(arg1, arg1, *args)

min()中填入的参数同理（参数在后文自定义函数中也会详细解释）

iterable：可迭代对象

arg1, arg1, *args：参数值，可输入多个参数，比较的参数必须大于两个

#max()& min()
#输入iterable
l = [1, 12, 36, 49, 55, 6, 10]
print(max(l))
print(min(l))
#直接输入数据
print(max(1, 5, 9, 7))
print(min(1, 5, 9, 7))

运行结果：

3.sorted（）

语法格式：sorted（iterable, reverse）

iterable: 可迭代对象

reverse:指定排序规则，True为降序，False为升序（默认）

返回值是一个列表

l = (1, 12, 36, 49, 55, 6, 10)  #元组
print(sorted(l))
print(sorted(l, reverse=True))

运行结果：

由运行结果可以看出，sorted（）默认进行升序排序，规定之后可以进行降序排序。返回值是一个列表。

4.reversed()

语法格式：reversed（seq）

seq:要反转的序列

返回值是反向迭代器（return a reverse iterator）

l = [1, 12, 36, 49, 55, 6, 10]  #元组
print(reversed(l))
print(list(reversed(l)))

运行结果：

返回值并不能直接被观察到，我们需要使用类型转换函数来进行转换以得到结果，如这里的list()

1.4 与类型转换有关函数

与类型转换有关函数有：int() , float(), str(), bool(), list(), tuple(), set(), dict()

使用这些函数，可以把其他类型的函数转换成此类型

s = '333' #字符串
print(type(s))
s = int(s)
print(type(s))
l = (1, 12, 36, 49, 55, 6, 10)  #元组
print(type(l))
l = list(l)
print(type(l))

1.5 zip（）函数

将可迭代对象作为参数，返回一个元组迭代器

1.5.1 没有参数

没有参数时，返回一个空的迭代器

record = zip()
print(record)
print(list(record))

运行结果：

我们需要运用转换函数，才能看到想看到的结果

1.5.2 两个参数

ID = [1, 2, 3, 4]
leaders = ['H', 'L', 'M', 'N']
record = zip(ID, leaders)
print(record)
print(list(record))

运行结果：

我们需要运用转换函数，才能看到想看到的结果

1.5.3 长度不等的参数

默认情况下，zip（）函数的结果基于最短的可迭代对象

ID = [1, 2]                    #长度为 2
leaders = ['H', 'L', 'M', 'N'] #长度为 4
record = zip(ID, leaders)
print(list(record))

运行结果：

总结：

可以传入零个参数，一个参数，两个参数，三个参数...... 但由于返回值是元组迭代器，所以我们需要运用转换函数，才能看到想看到的结果

无论我们传给zip函数多少个可迭代对象，其均能按照预期来工作，返回一个元组迭代器

1.6 filter（）函数

对序列进行过滤，过滤掉不符合条件的元素。比如function是一个数除2余数为零（即要寻找偶数），则经过filter（）函数作用后，会把iterable中所有偶数过滤出来并返回一个迭代器对象。

语法格式：filter（function， iterable）

function：判断的条件

iterable：可迭代对象

返回值：返回一个迭代器对象

fi = filter(lambda x:x > 5 , range(1,9))
print(fi)
print(list(fi))

运行结果：

此处代码依旧采用了转换函数，不然我们只能看到迭代器对象。此处代码采用了lambda匿名参数，在后文也有详细描述。

1.7 enumerate（）函数

枚举，列举的作用

对于一个可迭代对象，enumerate（）函数将其组成一个索引序列，利用这个函数可以获得索引和值。

语法格式：enumerate（ iterable）

返回值：enumerate对象

leaders = ['H', 'L', 'M', 'N']
l = enumerate(leaders)
print(l)
print(type(l))
print(list(l))

运行结果：

1.8 map（）函数

拥有映射的功能，把function依次作用于 iterable上。比如，function是把一个数变成原来的二倍，则在iterable里的每一个数经过map() 都会被变成原来的二倍，并返回一个map对象。

语法格式：map（function， iterable）

function：判断的条件

iterable：可迭代对象

返回值：map对象

print(map(lambda x:x ** 2 , range(1,9)))
print(list(map(lambda x:x ** 2 , range(1,9))))

运行结果：

在这个代码中的function是把一个数平方，则在iterable里的每一个数经过map() 都会被变成原来的平方，并返回一个map对象，经过list（）转换函数进行转换，获得一个列表。

二.标准模块的函数（以math库为例）

python中有很多第三方库，在使用时需要导入进行使用

使用第三方库可以简化代码，第三方库中有很多代码可以使复杂的操作简单化，实现功能更快

导入方式：

import 模块名

import 模块名 as 名称缩写

from 模块名 import 模块名

... ...

import math
print(math.sin((math.pi)/2))
print(math.sqrt(9))

运行结果：

在python中，有一些库不需要下载，有一些库需要下载才能使用。

python的第三方库很多，如可以进行网络爬虫的requests库，scrapy库；数据分析方向的numpy库，scipy库；可用于绘画的turtle库，用于可视化的matplotlib库... ....

三.lambda表达式（匿名函数）

lambda表达式又称为匿名表达式，常用来表示比较简单的函数

lambda表达式是匿名函数，意味着该函数没有名字。

语法格式：lambda[参数] ：表达式（对参数进行的操作）

x = int(input("请输入一个数："))
y = int(input("请输入一个数："))
f = lambda x, y: x+y
print(f(x, y))

运行结果：

四.自定义函数

自定义函数使用 def 来定义函数，自主创建一个函数，用于执行特定的功能。

函数三要素：函数名，参数，返回值

语法格式：def 函数名（参数列表）：

函数体

return 返回值

#写一个函数，返回到平面上的一个点
def getPoint():
    x = 20
    y = 30
    return x,y
print(getPoint())

运行结果：

在这段代码中，我们定义了一个名为getpoint( )的函数，其中没有参数，返回值是（x, y）

在这里，print语句中的 getpoint( )代码是进行了函数的调用。如果只是定义了函数代码而不进行调用，则函数内的代码就不会执行。

同时，需要明白的是，函数经过定义后，可进行多次调用。如下，

def test ():
    print('执行函数代码')
    print('执行函数代码')
    print('执行函数代码')

print('11111111')
test()
print('2222222222')
test()
print('333333333333')
test()
print('444444444')

再这里，我们可以看到，我们先定义了一个函数名为test（）的函数，返回值为None，没有参数。接着，在后面的代码执行时，先使用了print函数进行了'11111111'的打印，然后跳到了test（）函数的代码块那里并进行了test（）函数的调用，接着使用了print函数进行了'2222222222'的打印，然后跳到了test（）函数的代码块那里并进行了test（）函数的调用... ...以此类推。此处进行了函数test（）的多次调用。

运行结果：

只有先定义才能调用函数，先调用后定义会报错。python的代码是一行行执行的。会报如下错，并且使用pycharm的话，在调用时会报错（划红线）。

五.函数参数和返回值

函数的参数：

形参（形式参数）：在定义函数时，参数列表里的参数（函数名后面括号中的参数）

实参（实际参数）：调用函数时，传递给函数的参数

位置参数：形参和实参的位置一一对应（顺序，数量）

默认值参数：在形参处进行赋值

关键字参数：以形参=实参的形式去指定，不受传递参数的位置影响。

不定长参数：可以传入多个参数。（*p(元组), **q（字典））

参数传递的顺序：位置参数，默认值参数，关键字参数，不定长参数（在定义时就要遵循）

def test(a, b, c=3):
    print(a, b, c)
test(1, 2)
test(1, 2, 6)

运行结果：

对于此代码，我们可以看到其中，a, b为位置参数，依照传入的顺序依次对a,b进行赋值。c 为其中的默认值参数，可传值也可不传值（因为在开始我们给其定义了值）。但a,b 必须传值，不传值会报错。如下：

针对于关键字参数：

def test(a, b, c=3):
    print(a, b, c)
test(1, 2)
test(b=2, a =1)

运行结果：

在这里我们可以看到，我们采用了形参=实参的形式，则可以不受位置的影响，对我们想要传值的参数进行传值。关键字传参的原因是你不清楚参数顺序，但记住了参数的名称。

针对于不定长参数：

def test(a, b, *p,**q):
    print(a, b, p, q)
test(1, 2, 3, 4, 5, 6, h = 1,hh = 2)

运行结果：

在这里，我们可以看到，当1，2对位置参数a,b传完参数之后，剩余的3，4，5，6被传给了不定长参数p （元组）,当我们采用上文中h = 1,hh = 2的样子时，我们开始了对不定长参数q（字典）进行传参，在此处传了两个。注意与关键字传参区分开来。

函数的返回值：

没有定义返回值，则认为函数的返回值为None

函数的返回值通常在return后面，return可以出现在函数中的任何位置，当执行到return语句时，函数停止执行，return后面的代码停止执行。

5.1 返回值

def kill_monstor(name):
    print(f'妖怪的名字是{name}')
result = kill_monstor('白骨精')
print(result)

运行结果：

def kill1(name):
    print(f'妖怪的名字是{name}')
    return 5
result1 = kill1('白骨精')
print(result1)

运行结果：

通过观察上面的两个例子和结果，我们可以看到第一个例子print（result）的结果是None，第二个在定义了return后面的返回值之后，print（result）的结果是5。我们在这里需要明白的是，result和result1都调用了函数，调用函数会执行函数体，执行完成之后返回None（第二个例子中返回5），并赋值给result，经过print语句打印出来。

5.2 一个返回值

def sum (begin,end):
    theSum = 0
    for i in range(begin,end+1):
        theSum += i
    print(theSum)
sum(3, 6)
print(sum(3, 6))

运行结果：

第一个18，是sum(3，6)的调用结果，第二个18和None是print(sum(3, 6))的结果，在这里先调用了sum(3，6)打印出18，然后打印了其返回值。在此段代码中，我们并没有定义返回值，其返回值为默认值None。

通常，不在自定义函数中使用print语句，而是定义其返回值，然后赋值，然后再函数体外部使用print语句。

5.3 两个返回值

# 多个返回值
def isOdd(num):
    """
    用来判定  num 是不是奇数！如果是奇数就返回 True,不是就返回False
    :param num:要判定的整数
    :return:返回 True False 表示是不是奇数
    """
    if num % 2 == 0:
        return False
    else:
        return True
print(isOdd(15))

运行结果：

在这段代码中，我们可以看到两个返回值，一个False一个True。

在这里，三引号引起的内容起到注释的作用。三引号可进行多行注释，#只能进行单行注释。

函数名为 isOdd，参数有一个num，返回值两个。当满足 if 语句，则返回值是False,，不满足则返回值是True。我们需要理解到的是，在自定义函数中，return是一个出口，当我们输入的参数num满足 if 语句，则其返回值是False并跳出了该函数。在上述例子中，isOdd（15）的值为True，我们打印的结果也是True.

我们现在来着重理解一下return相当于一个出口，return后面的语句不在执行。

我们可以看到，调用了test（）函数后，在这里print（‘hello’）语句并未执行。在pycharm中，该代码标黄证明该代码无用或者不能执行。

六.函数递归

在自定义函数中代码自己调用自己。

函数递归的两个要素：

1.递归结束条件

2.递归的递推公式

举个例子：

#输入n，计算1+2+3+...+N的值
def add(x):
    if x == 1:
        return 1
    return x + add(x-1)
print(add(5))

此代码是为了计算从1加到n的值，我们可以看到，在return中再次调用了函数add（）。由此进行了函数调用函数，直至满足条件x == 1。

在此段代码中，我们首先输入实参为5，我们在print语句中调用了函数add（），接着进行了函数调用。如下，

运行结果：

函数递归的代码不会无限的往下执行，会在每一次递归的时候，逐渐逼近结束的条件。

再举一个例子：

#写一个函数，求函数的阶乘
def factor(n):
    if n == 1 :
        return 1
    return n * factor(n - 1)
print(factor(5))

在这个代码中，我们调用函数时传入的实际参数是5，执行代码是，会先判断传入的参数5是否等于1，判断5不等于1后，返回到5 * factor(5 - 1)，那么，我们传入的参数相当于是4，对factor(5 - 1)再次进行判断，判断4不等于1后，再次进行... ...直到最后满足递归结束条件，n==1，结束。