课上笔记(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]