Python基础篇五——函数

个人简介

各位猿媛大家好，我是萌新小农，目前大二在读，正在努力学习Py，希望大家能多多关照和支持。同时也期望我的文章能够为大家带来帮助和解决大家的一些困惑。
学习是任何时间都可以的，贵在坚持，愿我们能一起努力，拿下Py~

01学习目标

1，掌握函数的创建和调用
2，熟练运用函数的参数，掌握对应的用法
3，了解函数的返回值，四种类型以及函数的嵌套
4，掌握函数变量的作用域
5，了解并会熟练运用递归函数，匿名函数和随机数函数

02重点难点

重点:
1，函数的参数
2，函数的返回值
3，函数的类型，嵌套
4，函数变量的作用域
难点：
1，函数的参数
2，递归函数
3，匿名函数

03学习任务

一，什么是函数

1，函数的定义

函数是组织好的，可重复使用的，用来实现单一或相关联的代码段，它能够提高应用的模块性和代码的重复率。

• 函数的主要作用是：打包代码！！！

二，函数的创建和调用

1，创建函数

在Python中，我们创建（定义）一个函数用def关键字，格式如下：

def 函数名（参数）:
	函数体			#函数体就是一个代码块，即每次调用函数时将被执行的一个内容。

2，调用函数

当我们定义好函数后，通过调用"函数名()"就可以执行函数体内的代码块了。
举个栗子：

>>>def mylike():	#使用def语句来定义函数，函数名称在此处为mylike()
>>>		pass		#pass在此处是函数体。pass是一个空语句，我们经常将它用做一个占位符来使用
>>>mylike()			#调用该函数

或者：
>>>def mylike():
>>>		for i in range(3):
>>>			print("I Love Python!")
>>>mylike()
>>>I Love Python!
>>>I Love Python!
>>>I Love Python!

三，函数的参数

只要按照函数的要求，将指定的参数给正确的传递进去，那么函数就会按计划进行运算并返回最终的结果！

1，我们可以通过函数的参数来实现功能的定制

>>>def mylike(name):				#在小括号内加上一个参数，参数名是name。
>>>		for i in range(3):			#调用mylike(),函数指定参数name为Python！
>>>			print(f"I Love {name}.")
>>>mylike("Python!")
>>>I Love Python!
>>>I Love Python!
>>>I Love Python!
这样我们就可以通过参数实现对函数的定制了~

2，参数的数量可以有多个

比如我们还可以通过参数指定打印的次数
还是上边的栗子捡回来博主继续吃：

>>>def mylike(name, times):				
>>>		for i in range(times):			
>>>			print(f"I Love {name}.")
>>>mylike("Python!", 5)
>>>I Love Python!
>>>I Love Python!
>>>I Love Python!
>>>I Love Python!
>>>I Love Python!

3，从调用的角度出发

参数的实际叫法分为：
形式参数（简称形参）和实际参数（简称实参）
形参：函数在定义时写的参数的名字。例如上面栗子中的name，times
实参：调用函数时传进去的值。例如上面栗子中的"Python!"，5
占位的叫形参，实际传递数值的叫实参~

4，位置参数

在通常情况下，实参是按照形参定义的顺序进行传递。位置参数可用在实参和形参中。

>>>def func(s, vt, o):
>>>		return "".join((o, vt, s))
>>>myfunc("我", "喜欢揍", "我爹")
>>>我爹喜欢揍我
>>>myfunc("我爹", "喜欢揍", "我")
>>>我喜欢揍我爹
我们将Python中这类位置固定的参数称为位置参数。

5，关键字参数

>>>mylife(o = "博主他爹"， vt = "又揍了"， s = "博主")#在传递时明确指定“博主他爹”给到了“o”这个参数。
>>>"博主他爹又揍了博主"

如果同时使用位置参数和关键字参数，要注意使用的顺序。
Python要求位置参数必须在关键字参数之前，在之间也是不可以的。

>>>mylife = (o = "博主他爹", "又揍了", "博主")	#此处的o = "博主他爹"是关键字参数，后面的参数是位置参数。
>>>......	#Python报错

6，默认参数

Python允许函数的参数在定义的时候就指定默认值，这样在调用没有传入实参的函数时就可以使用默认的参数值来代替。

>>>def myidol(s, vt, o = "博主"):
>>>		return"".join((o, vt, s))
>>>myidol("ikun"，"非常喜欢")
>>>"博主非常喜欢ikun"
>>>myidol("两年半了", "练习ikun", "我")	#指定参数o的值为“我”
>>>我练习ikun两年半了

如果我们要使用默认参数，则应该把默认参数放在最后：

>>>def mylife(vt, s = "博主", o = "坤坤")
>>>		return "".join((o, vt, s))
>>>mylife("还不如")
>>>坤坤还不如博主

补充：使用help()函数可以查看函数文档

>>>help(abs)

或者：
>>>help(sum)

结果如下：


那么上面IDLE返回的结果中斜杠的意义是什么？它表示斜杠左侧的参数必须传递位置参数，不能是关键字参数！

7，不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数。声明时不会命名。
语法格式如下：

>>>def functionname([formal_args,] *args, **kwargs)
>>>		'函数文档字符串'
>>>		function_suite
>>>		return [expression]

注意！
·加了星号*的变量args会存放所有未命名的变量参数，args为元组。
·加了两个星号**的变量kwargs会存放命名参数，即形如key = value的参数，kwargs为字典。

def fun(a, b, *args, **kwargs):

    print("a =%d" % a)
    print("b =%d" % b)
    print("args:")
    print(args)
    print("kwargs: ")
    for key, value in kwargs.items():
        print("key=%s" % value)

fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应

输出：

a =1
b =2
args:
(3, 4, 5)
kwargs: 
key=6
key=7
key=8

四，函数的返回值

1，使用return语句就可以让自定义函数实现返回。

举个栗子~

###一个实现除法的函数
>>>def div(x, y):
>>>		z = x / y
>>>		return z
>>>div(4, 2)
>>>2.0	

或者可以写成介个样子：

>>>def div(x, y):
>>>		return x / y
>>>div(4, 2)
>>>2.0

我们可以完善一下代码：

>>>def div(x, y):
>>>		if y == 0:
>>>			return "除数不能为0！你柿不柿忘了？？？"
>>>		else:
>>>			return x / y
>>>div(4, 2)
>>>2.0
>>>div(4, 0)
>>>"除数不能为0！你柿不柿忘了？？？"

也可以写成介个样子：
>>>def div(x, y):
>>>		if y == 0:
>>>			return "除数不能为0！你柿不柿忘了？？？"
>>>		return x / y
>>>div(4, 2)
>>>2.0
>>>div(4, 0)
>>>"除数不能为0！你柿不柿忘了？？？"

（红色字体）注意：只要执行了return语句，函数就会立刻，马上直接返回，不会再去执行后面的代码块！
如果一个函数没有通过return语句来返回内容，那么他也会在自己执行完函数体中的所有语句之后返回一个None值。
举个栗子：

>>>def mylike():	
>>>		pass		
>>>print(mylike())
>>>None

五，函数的四种类型

根据函数的参数和返回值，函数可分为四种类型：
1，无参数，无返回值
2，无参数，有返回值
3，有参数，无返回值
4，有参数，有返回值

1，无参数，无返回值

#输入：
>>>def kunone():
>>>    print("kunkun敲代码两年半")
>>>kunone()

输出：
>>>kunkun敲代码两年半

2，无参数，有返回值

#输入：
>>>def kunthree():
>>>    return "kunkun敲代码两年半"
>>>print(kunthree())

#输出： 
>>>kunkun敲代码两年半

3，有参数，无返回值

#输入：
>>>def kuntuo(i):
>>>    print(i)
>>>print(kunthree())

#输出：
kunkun敲代码两年半

4，有参数，有返回值

#输入：
>>>def kunfour(i):
>>>   return "kunkun敲代码两年半"
>>>print(kunfour("敲代码两年半"))

#输出：
kunkun敲代码两年半

六，函数的嵌套

Python的函数定义是支持嵌套的，也就是允许在函数内部定义另一个函数，这种函数称为内嵌函数。
举个栗子：

#输入：
>>>def fun1():
>>>print("fun1()正在被调用...")
>>>def fun2():
>>>		print("fun2()正在被调用...")
>>>fun2()

>>>fun1()

#输出：
fun1()正在被调用...
fun2()正在被调用...

关于内部函数的使用，有一个比较值得注意的地方，就是内部函数的整个作用域都在外部函数之内。

七，变量的作用域

1，作用域

指一个变量可以被访问的范围。通常一个变量的范围总是由它在代码中被赋值的位置来决定的。

2，局部变量

如果一个变量定义的位置是在一个函数的里面，那么它的作用域就仅限于该函数中，我们将它称之为局部变量。
所谓局部变量，就是在函数内部定义的变量
局部变量的作用域是函数内部，意味着它只在定义它的函数中有效，一旦函数结束它就会消失。

举个栗子~

#输入：
>>>def myfunc():
>>>		x = 520
>>>		print(x)
>>>myfunc()		#调用myfunc()函数
#输出：
>>>520

>>>print(x)		#变量x是在函数myfunc()中定义的，所以它的作用域仅限于myfunc()函数，如果尝试在函数的外部去访问这个变量就会报错！
>>>......(Python报错)

3，全局变量

如果是在任何函数的外部去定义一个变量，那么它的作用域就是全局的，我们也将其称之为全局变量。
·定义在函数外的，拥有全局作用域
·全局变量可以在整个程序范围内访问
·如果出现全局变量和局部变量名字相同的情况，则在函数中访问的是局部变量。

举个栗子~

>>>x = 521			#定义一个x = 520，此时定义的位置是在任何函数的外边的。
>>>def myfunc():	#定义一个新的myfunc()函数
>>>		print(x)	#打印x的值
>>> myfunc()		#调用myfunc()函数。（可以访问，具有全局作用域的变量在函数的内部是完全可以访问到的）

#输出：
>>>521

当函数中存在一个跟全局变量一模一样的局部变量，则局部变量会覆盖同名的全局变量。
举个栗子：

>>>def myfunc():	#重新定义myfunc()函数，在这个函数内部存在一个跟全局变量一样的一个局部变量x，在内部给x赋值为520
>>>		x = 520
>>>		print(x)	
>>>myfunc()			#调用myfunc()，打印520
>>>520

>>>print(x)			#在外部打印x的值，则为521
>>>521
总结：在此处调用myfunc()函数时，打印的是局部变量x的值，但只要出了函数，由于作用域的关系，局部变量就失效了，因此就会打印全局变量的值。

注意：在代码中，两个x并非同一个变量，只是由于作用域不同，它们同名，但是不同样！

八，递归函数和匿名函数

1，递归函数

一个函数的内部可以调用其它函数。但是，如果一个函数在内部不调用其他函数，而是自己本身的话，这个函数就是递归函数。

#输入：
def fact():
	if n = 1
		return 1
	return n * fact(n - 1)

#输出：
120

2，匿名函数

匿名函数，就是没有名称的函数，也就是不再使用def语句定义的函数，如果要声明匿名函数，则需要使用lambda关键字，匿名函数的声明格式如下：

lambda [arg1 [,arg2,.....argn]]:expression

举个栗子~

sum = lambda arg1, arg2: arg1 + arg2
print(“运行结果：", sum( 10, 20 ))
print("运行结果：", sum( 20, 20 ))

注意：
使用lambda声明的匿名函数能接收任何数量的参数，但只能返回一个表达式的值，匿名函数不能直接调用print，因为lambda需要一个表达式。

九，随机数函数

1，random.random()

用于生成一个从0到1的随机浮点数：0 <= n <= 1.0

import random# 生成第一个随机数
print("random():", random.random())# 生成第二个随机数 
print("random():", random.random())

2，random.uniform(a, b)

返回a和b之间的随机浮点数，范围[a, b]或者[a, b]取决于四舍五入，a不一定比b小。

3，random.randint(a, b)

返回a和b之间的整数，范围[a, b]。注意：传入的参数必须是整数，a一定要比b小！

4，random.randrange([start], stop[,step])

返回区间内的整数，可以设置step的值，只能传入整数。

5，random.choice(sequence)

从sequence（序列，是有序类型的）中随机获取一个元素，列表，元组，字符串都属于sequence。

random.randrange(10, 100, 2)
random.choice(range(10, 100, 2))
#两串代码是等效的

6，random.shuffle(x[,random])

用于打乱列表中的元素的顺序。

p = ["Python", 520, "只因你太美", "ikun"]
random.shuffle(p)

7，random.sample(sequence, k)

从指定序列中随机获取K个元素作为一个片段返回。
sample函数不会修改原有的序列

import random
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
slice = random.sample(list, 5)
print(slice)
[5, 7, 2, 8, 10]
print(list)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

04本章小结

本文主要对Python的函数进行了详细的讲解，其中包括函数的定义，调用，函数的多种参数，函数的返回值，函数的嵌套，递归和匿名函数以及随机数函数。内容偏多，知识点较多，也不易理解，希望大家能多动手敲代码理解相关的知识点以便加深记忆，巩固。最后如果大家觉得对自己有帮助希望大家可以点赞评论支持一下~~
今天的分享就到这里啦，我们下期再会~感谢大家