课上笔记(3)(Python)

最新推荐文章于 2025-03-03 23:42:52 发布

原创最新推荐文章于 2025-03-03 23:42:52 发布 · 285 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Python #函数

随笔专栏收录该内容

12 篇文章

订阅专栏

本文深入讲解Python函数的定义、调用及各类参数的使用，包括默认值参数、关键参数、可变长度参数等，同时探讨了全局变量的作用及lambda表达式的应用。

课上笔记(3)(Python)

学习使我快乐

函数

首先。定义一个函数

公式：

	def 函数名(形式参数(用来输入参数)):
		"""注释，函数有几个参数，函数用来干嘛的，函数的参数分别是干嘛的"""
		函数内容主体
		renturn 返回的值

输入：

	def fib(n):
	    """n是一个数字，函数是用返回小于n的所有斐波那契数列的总数，返回值是小于n的斐波那契数列的总数"""
	    a,b=1,1
	    c = []
	    while a<n:
	        a,b=b,a+b
	        c.append(a)
	    c = len(c)
	    return c

返回：
	c

在这之后我们将进入主函数：
在那之前我们首先需要进入主函数的一个“开门”的过程

即：

	if __name__=='__main__':

然后就是：

 输入：
	def fib(n):
		"""n是一个数字，函数是用返回小于n的所有斐波那契数列的总数，返回值是小于n的斐波那契数列的总数"""
	    a,b=1,1
	    c = []
	    while a<n:
	        a,b=b,a+b
	        c.append(a)
	    c = len(c)
	    return c
	    
	if __name__=='__main__':
		print(fib(15))


输出：

	7

实际上这个程序的真正的开始是从主函数也就是

if __name__=='__main__':

开始的，而当运行到达了调用函数之时，转而进入对应的【“def 函数“ 】之中
在运行函数主体完毕后，回到主函数继续运行。
####有关函数中的变量
函数中有的变量可以和程序主体是一样的，但是代表的意义是不同的。

函数和程序主体是在两个栈进行的。
即：

可以理解成，函数和主体都是在不同的房间里闭门造车，程序主体把任务交给函数以后，函数在自己的房间里完成任务，上交一个结果给程序主体。但是函数也就交给程序主体了一个结果，而除了这个结果以外，什么都无法影响到程序主体。

即：

输入：

	def hanshu(n):
	    """n是一个数字，函数是用来将实际参数+1，返回的是n+1的值"""

	    c = n+1
	    print('函数里的c是%d'%c)
	    return c
	    
	if __name__=='__main__':
	    c = 0
	    d = hanshu(8)
	    print('函数上交给程序主体的结果d是%d'%d)
	    print('程序主体里的c是%d'%c)

输出：
	函数里的c是9
	函数上交给程序主体的结果d是9
	程序主体里的c是0

默认值参数

在定义参数时允许存在没有实际参数的情况，这时就需要默认参数了

首先，默认函数的公式是
：
	def 函数名(d=默认的值)
如果有默认参数以及非默认参数：默认参数一定要在整个小括号最右面
：
	def 函数名(n,w,d=默认的值,p =默认的值,z=默认的值)

输入：

	def hanshu(n,z=2):
		"""n是一个数字，z是一个数字，函数是用来求z和n的和，返回的是n+z的值"""

	    c = n+z
	    print('函数里的z是%d'%z)
	    print('函数里的c是%d'%c)
	    return c
	    
	if __name__=='__main__':
	    c = 0
	    d = hanshu(8)
	    print('函数上交给程序主体的结果d是%d'%d)
	    print('程序主体里的c是%d'%c)

输出：

	函数里的z是2
	函数里的c是10
	函数上交给程序主体的结果d是10
	程序主体里的c是0

输入：

	def hanshu(n,z=2):
		"""n是一个数字，z是一个数字，函数是用来求z和n的和，返回的是n+z的值"""

		c = n+z
		print('函数里的z是%d'%z)
	    print('函数里的c是%d'%c)
	    return c
	    
	if __name__=='__main__':
		c = 0
		d = hanshu(8,3)
	    print('函数上交给程序主体的结果d是%d'%d)
	    print('程序主体里的c是%d'%c)

输出：

	函数里的z是3
	函数里的c是11
	函数上交给程序主体的结果d是11
	程序主体里的c是0

关键参数

指定实际参数的值，个人觉得如果能记住顺序或者实际参数少的话这东西是没什么用的，但是假如你记不住顺序，这东西就很好用的。

直接按照变量名一一对应就好了
即

输入：

	def hanshu(n,z):
		"""n是一个数字，z是一个数字，函数是用来求z和n的和，返回的是n+z的值"""

		c = n+z
		print('函数里的z是%d'%z)
	    print('函数里的c是%d'%c)
	    return c
	    
	if __name__=='__main__':
		c = 0
		d = hanshu(n=8,z=3)
	    print('函数上交给程序主体的结果d是%d'%d)
	    print('程序主体里的c是%d'%c)

输出：

	函数里的z是3
	函数里的c是11
	函数上交给程序主体的结果d是11
	程序主体里的c是0

也可以调换实际参数的顺序

输入：

	def hanshu(n,z):
		"""n是一个数字，z是一个数字，函数是用来求z和n的和，返回的是n+z的值"""

		c = n+z
		print('函数里的z是%d'%z)
	    print('函数里的c是%d'%c)
	    return c
	    
	if __name__=='__main__':
		c = 0
		d = hanshu(z=8,n=3)
	    print('函数上交给程序主体的结果d是%d'%d)
	    print('程序主体里的c是%d'%c)

输出：

	函数里的z是8
	函数里的c是11
	函数上交给程序主体的结果d是11
	程序主体里的c是0

可变长度参数

*parameter ←用来接收任意多个实际参数，并且将其放在一个元组中：

输入：
		def demo(*p):
			print(p)
			
		if __name__=='__main__':
			demo(1,2,3)

输出：
		(1,2,3)

**parameter ←接收类似关键参数形式的赋值形式组成字典：

输入：
		def demo(**p):
			print(p)
			
		if __name__=='__main__':
			demo(a=1,b=2,c=3)

输出：
		{'a':1 , 'b':2 , 'c'=3 }

参数传递时的序列解包

如果实际参数是整个Python容器中的元素，那么你大可以不比a[0],a[1]这样，而是进行序列解包即可,Python会帮助你自动按顺序进行赋值

元组：

输入：
		def demo(a,b,c):
			print(a,b,c)

		if __name__=='__main__':
			a = (1,2,3)
			demo(*a)

输出：
		1 2 3

列表：

输入：
		def demo(a,b,c):
			print(a,b,c)

		if __name__=='__main__':
			a = [1,2,3]
			demo(*a)

输出：
		1 2 3

字典

首先你要知道，字典在解包时默认是赋值key

输入：
		def demo(e,d,g):
			print(e,d,g)
		if __name__=='__main__':
			a = {'a':1 , 'b':2 , 'c':3}
			demo(*a)

输出：
		a b c

但是如果你想要解包字典的value，那就需要values()方法了

输入：
		def demo(e,d,g):
			print(e,d,g)
		if __name__=='__main__':
			a = {'a':1 , 'b':2 , 'c':3}
			demo(*a.values())

输出：
		1 2 3

就在此时我突然萌生了这样一个想法：如果Python容器中元素的数量大于形式参数的数量会怎样？

首先我猜测大于的可能无效

输入：
		def demo(a,b,c):
			print(a,b,c)

		if __name__=='__main__':
			a = [1,2,3,4,5]
			demo(*a)

输出：
		报错：
		TypeError: demo() takes 3 positional arguments but 5 were given

那如果形式参数的数量大于Python容器中元素的数量呢？

首先我猜测可能是none

输入：
		def demo(a,b,c,d,e):
			print(a,b,c)

		if __name__=='__main__':
			a = [1,2,3]
			demo(*a)

输出：
		报错：
		TypeError: demo() missing 2 required positional arguments: 'd' and 'e'

全局变量

之前我们提到过，函数中的变量和主程序的变量是不同的，但是实际参数和形式参数赋值来赋值去的会很麻烦，于是就有人做出了全局变量→使用global声明这个变量为全局变量

输入：
		def demo(x, y):
    		global a
   		 	a = x + 1
   	 		b = y + 2
    		print(a, b)
		if __name__=='__main__':
    		a, b = 1, 3
    		demo(a, b)
    		print(a, b)

输出：
		2 4
		2 3

我们可以看到，我们使用global声明过的变量a，在经过demo函数以后变化了，而未使用global声明过的变量b，则还是原来赋予的值。

global可以同时声明多个变量

输入：
		def demo(x, y):
    		global a, d, c
   		 	c = 100
   	 		d = 99
    		a = x + 1
    		b = y + 2
    		print(a, b)
		if __name__=='__main__':
    		a, b = 1, 3
    		demo(1, 2)
    		print(a, b, c, d)

输出：
		2 4
		2 3 100 99

lambda表达式

用来声明匿名函数：无名字的小函数（即：临时）
适合用于需要一个函数作为另一个函数参数的地方，
其计算结果看一看做函数的返回值，其表达式可以调用其他函数。

lambda 形参:函数体:

输入：
		f = lambda x, y, z:x+y+z
		print(f(1, 2, 3))

输出：
		6

lambda函数其实和def创建函数没啥区别：

输入：
		a = [1, 2, 3, 4, 5]
		print(list(map(lambda x:x+10, a)))

输出：
		[11, 12, 13, 14, 15]

输入：
		def demo(n):
    		n = n+10
    		return n

		if __name__=='__main__':
    		a = [1, 2, 3, 4, 5]
    		print(list(map(demo, a)))
  
 输出：
 		[11, 12, 13, 14, 15]