课上笔记(3)(Python)
课上笔记(3)(Python)
- 学习使我快乐
函数
- 首先。定义一个函数
公式：
def 函数名(形式参数(用来输入参数)):
"""注释，函数有几个参数，函数用来干嘛的，函数的参数分别是干嘛的"""
函数内容主体
renturn 返回的值
输入：
def fib(n):
"""n是一个数字，函数是用返回小于n的所有斐波那契数列的总数，返回值是小于n的斐波那契数列的总数"""
a,b=1,1
c = []
while a- 在这之后我们将进入主函数：
在那之前我们首先需要进入主函数的一个“开门”的过程
即：
if __name__=='__main__':
然后就是：
输入：
def fib(n):
"""n是一个数字，函数是用返回小于n的所有斐波那契数列的总数，返回值是小于n的斐波那契数列的总数"""
a,b=1,1
c = []
while a实际上这个程序的真正的开始是从主函数也就是
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]