1.函数定义：
使用def关键字定义函数，然后一个空格加函数名，接下来是一对圆括号和冒号，用来传递参数，格式如下

def 函数名([参数]):
'''注释'''
#注释
函数体

使用案例①
比较两个数的大小

def compare(a,b):
    if a>b:
        print('The bigger is:',a,end='\n')
        print('The smaller is:',b,end='\n')
    elif a<b:
        print('The bigger is:', b, end='\n')
        print('The smaller is:', a, end='\n')
    else:
        print('They are equal together',a,'=',b,end='\n')
compare(int(input('请输入数字a：')),int(input('请输入数字b：')))

输出结果：

请输入数字a：15
请输入数字b：20
The bigger is: 20
The smaller is: 15

案例②
关于形参和实参
定义是函数参数为形参，调用时调用的参数为实参

#使用默认参数值。形参,
#默认参数值必须在最右边，即在默认参数值的左边不能再有默认值
def say(message,times=1):
    print((message+'')*times,end='')
#查看默认参数值
print(say.__defaults__ ,end='\n')

函数定义错误案例：

#错误案例
def abc(a=0,b,c):
    print(a,b,c)
def abc1(a,b=0,c):
    print(a,b,c)
#正确案例
def abc2(a=1,b=2,c=3):
    print(a,b,c)

当参数值省略时

#当参数值省略时的情况
def listm(new,old=None):
    if old is None:
        old=[]
    else:
        old.append(new)
    return old
print(listm('a',[1,2,3]),end='\n')
print(listm('1',['a','b']),end='\n')
print(listm('a'),end='\n')

输出结果如下

(1,)
[1, 2, 3, 'a']
['a', 'b', '1']
[]

关键参数机制
根据参数的传递方式，通过关键参数可以按参数名传递参数，使得可以打乱参数的传递顺序，当不影响函数运行

def q(a,b,c=0):
    print(a,b,c)
q(b=0,c=3,a=8)

输出结果：

8 0 3

通过指针实现可变长度参数的函数以及自带的解包机制

#通过指针实现可变长度参数
def dem(*p):
    print(p)
dem(1,2,3)
dem(1,2)
#通过指向指针的指针实现可变长度参数,实现的是字典形式
def dem1(**p):
    for item in p.items():
        print(item)
dem1(x=1,y=2)

#参数传递序列解包
def dem2(a,b):
    print(a+b,end='\n')
dem2(*[1,2])    #解包列表
dem2(*(1,2))    #解包元组
dem2(*{1:'23',2:'33'})  #解包字典，默认为键
dem2(*{1,2})    #解包集合
dem2(*{1:23,2:23}.values()) #解包字典中值
dem2(*{1:'32',2:'35'}.items())  #解包字典的键值对

输出结果：

(1, 2, 3)
(1, 2)
('x', 1)
('y', 2)
3
3
3
3
46
(1, '32', 2, '35')

调用函数需要注意是否会修改原始数据的值，是否有返回值
作用域：

a=5 #在函数外定义全局变量
def dem3():
    global a    #声明或创建全局变量
    a=3         #修改全局变量的值
    y=a
    print(a,y)
dem3()  #本次调用会修改全局变量的值
#可以在模块间声明和调用全局变量
#A模块中声明 global_value=0
#B模块调用 import A A.global_value=1
#c模块调用  import A print(A.global_value)

输出结果：

3 3

2.lambda表达式
格式：

lambda x:expert
x:变量，不限个数
expert:关于变量的表达式
#lambda表达式
f=lambda x,y:x+y
print(f(1,2))
l=[(lambda x:x**2),(lambda x:x**3)]
print(l[0](5),l[1](5))
d={'f1':(lambda x:x**2),'f2':(lambda x:x**4)}
print(d['f1'](1),d['f2'](5))

g=lambda x,y=2:x+y
print(g(1,3))
L=[12]
#print(map((lambda x:x+10),L))

r=[]
for x in range(5):
    r.append(lambda n=x:n**2)
print(r[4]())

结果如下图：

3
25 125
1 625
4
16

案例3：

#案例3实现计算圆的面积
import math
r=int(input())
def area(r):
    if isinstance(r,int) or isinstance(r,float):
        return math.pi*r*r
    else:
        return ('Input error!')
print(area(r))

输出结果：

5
78.53981633974483

案例4：

#案例4输出一个首项为参数平均数，且其他各项大于平均数的元组
def array(*p):
    average=sum(p)//len(p)
    d=[i for i in p if i>average]
    return (average,)+tuple(d)
print(array(1,2,3,4,5,6,3))

输出结果：

(3, 4, 5, 6)

案例5：

#案例5返回第一个为大写字母元素的个数，第二元素为小写字母个数的元组
def dem3(s):
    result=[0,0]
    for i in s:
        if 'a'<=i<='z':
            result[0]+=1
        else:
            result[1]+=1
    return tuple(result)
print(dem3('aaaaAAA'),end='')

案例6：

#案例6逆序三次列表，根据k值，逆序下标在k之前、之后的元素、合起来再逆序一次
def dem4(l,k):
    if l is None:
        l=[]
    x=l[:k]
    x.reverse()
    y=l[k:]
    y.reverse()
    r=x+y
    r.reverse()
    print(r,end='')
l=[1,2,3,4,5,6,7,8]
dem4(l,4)

案例7：

import random
print([random.randint(1,20) for i in range(50)],end='\n')

#打印杨辉三角
def dem5(t):
    print([1],end='\n')
    print([1,1],end='\n')
    line=[1,1]
    for i in range(2,t):
        r=[]
        for j in range(0,len(line)-1):
            r.append(line[j]+line[j+1])
        line=[1]+r+[1]
        print(line)
dem5(10)

学习笔记：
1.关于函数有三部分构成：函数名，参数，以及函数体
2.函数的声明形式为def faction():函数体
3.函数参数形式主要有形参（声明时的参数）和实参（函数调用时传过来的参数）
4.参数可以为可变参数，通过指针实现，具体有两种形式：*p(不限传递个数和形式)/**p(使用时在返回时，类似于字典)
5.lambda表达式：形式为lambda 变量:表达式，返回的是表达式的值，具体参考上面的案例
6.函数的使用需要注意参数形式，是否有返回值以及是否会修改实参