python学习笔记（十）——函数

有参函数

def max_number(a,b): #形参
    if a > b:
        print("最大值为",a)
    else:
        print("最大值为",b)
        
max_number(12,674) #实参（实参与形参相对应）      

输出结果

最大值为 674

有参函数——冒泡排序

list1 = [23,56,5,67,89,5678,2,0,456]
def maopao(newlist):
    for j in range(0,len(list1)-1):
        for i in range(0,len(list1)-1):
            if list1[i] > list1[i+1]:
                list1[i],list1[i+1] = list1[i+1],list1[i]
maopao(list1)
print(list1)

输出结果

[0, 2, 5, 23, 56, 67, 89, 456, 5678]

有返回值的函数创建

def max_num(a,b):
    if a > b:
        return a
    else:
        return b
m = max_num(56,97)
print(m)

输出结果

97

如何筛选出一个给定列表的偶数

list1 = [21,34,23,4,23,567,8,800,0,13]
def oushu_list(listone):
    new_list = []
    for i in listone:
        if i % 2 == 0:
            new_list.append(i)
            return new_list

list_new = oushu_list(list1)
print(list_new)

输出结果

[34]

求两个数的平均值

def average_number(a,b):
    c = (a + b)/2
    print(c)
average_number(6,10)

输出结果

[8.0]

求阶乘的函数

def  jc(a):
    sum = 1
    for i in range(1,a+1):
        sum = sum * i
    return sum
    
c = jc(5)
print(c)

输出结果

[120]

求列表中能被3整除的数

def zc_list(lists):
    new_list = []
    for i in lists:
        if i % 3 == 0:
            new_list.append(i)
    return new_list
list = [1,3,5,7,9,27,0,57,99]
list_new = zc_list(list)
print(list_new)

输出结果

[3, 9, 27, 0, 57, 99]

打印输出星号矩阵

def juzhen(a,b):
    for i in range(a):
        print("*"*b,end = '\n')
    return
juzhen(4,4)

输出结果

****
****
****
****

求多个数的平均值

def average(*numbers):
    sum = 0
    print(numbers)
    for i in numbers:
        sum = sum + i
        
    return sum/len(numbers)
a = average(7,4,917,1567)
print(a)

输出结果

(7, 4, 917, 1567)
623.75

位置传参

def max_num(a,b):
    if a > b:
        return a
    else:
        return b
    
m = max_num(56,97)
print(m)

输出结果

97

关键字传参（采用参数 = 值,不考虑参数位置）

def max_num(a,b):
    if a > b:
        return a
    else:
        return b
m = max_num(a = 56,b = 97)
print(m)

输出结果

97

默认值传参

def max_num(a,b = 56):
    if a > b:
        return a
    else:
        return b
m = max_num(12)
print(m)

输出结果

56

可变参数(自动组装元组)*

def animals(*name):
    print(name)
    print(type(name))
    str_name = ""
    for i in name:
        str_name += i
    return str_name
animals("大象","老虎","小狗","小猫")
print(str)

输出结果

('大象', '老虎', '小狗', '小猫')
<class 'tuple'>
<class 'str'>

可变参数(自动组装字典)**

def animals(**name):
    print(name)
    print(type(name))
    
animals(name1 = "大象",name2 = "老虎",name3 = "小狗",name4 = "小猫")

输出结果

{'name1': '大象', 'name2': '老虎', 'name3': '小狗', 'name4': '小猫'}
<class 'dict'>

可变和不可变数据类型

（当该数据类型的对应变量的值发生了改变，内存地址也发生改变就是不可变数据类型，对应内存地址不发生改变就是可变数据类型）

整型为不可变数据类型

a = 1
print(id(a))
a = 12
print(id(a))

输出结果

140725609879200
140725609879552

字符串为不可变数据类型

a = "abc"
print(id(a))
a = a+"d"
print(id(a))

输出结果

1740967694640
1740977049200

元组不可变，相当于只读模式

列表是可变数据类型

a = {"a":12,"b":14,"c":64}
print(id(a))
a["d"] = 20
print(id(a))

输出结果

1912852989120
1912852989120

字典是可变数据类型

a = {"a":12,"b":14,"c":64}
print(id(a))
a["d"] = 20
print(id(a))

输出结果

1650089673856
1650089673856

集合是可变数据类型

a = {23,4,45,56,34,6}
print(id(a))
a.add(13)
print(id(a))

输出结果

2659122171968
2659122171968

值传递和引用传递

值传递：不可变数据类型对象，在函数里进行值的修改，源对象不会被修改
引用对象：可变数据类型，在函数里进行值的修改，源对象也会被修改

a = 10 #表示不可变类型
b = [12,34,56,678] #表示可变类型
#定义函数
def change(x,y):
    #分别修改值
    x = 2
    y[0] = 1
    
change(a,b)
print(a)
print(b)    

输出结果

10
[1, 34, 56, 678]

变量与作用域

局部变量：定义在函数中，作用域在函数内部

def func():
    a = 1
    print(a)

全局变量：定义在函数外的变量，在全局都可以使用的变量

a = 12#这是一个全局变量
def func():
     print(a+23)
print(a)
func()

输出结果

12
35

global关键字
当内部作用域想修改外部作用域的变量时，就要用到global关键字。

a = 12
def func():
    global a
    a = 200
    print(a+23)
func()
print(a)

输出结果

223
200

函数嵌套和嵌套调用

函数的嵌套（在函数的内部再定义函数）

def func1():
    print("这是外部函数")
    def func2():
        print("这是内部函数")#内部函数不能直接被调用
    func2()
func1()    

输出结果

这是外部函数
这是内部函数

函数的嵌套调用（在一个函数中调用另一个函数）

def func1():
    print("第一个函数")
def func2():
    print("第二个函数")
    func1()
func2()        

输出结果

第二个函数
第一个函数

递归函数

递归函数：一个函数内部自己调用自己（递归函数调用的次数过多，会导致栈溢出）
1、必须要有一个明确的结束条件。
2、每次进入更深一层递归时，问题规模比上次递归都应有所减少。
3、相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作业为后一次的输入）。

return的两个作用：
1.用来返回一个值给函数
2.用来结束函数

递归求sum = n+(n-1)+(n-2)+(n-3)…1的和

def sum(n):
    if n > 0:
        return n + sum(n-1)
    else:
        return 0
print(sum(4))
        

输出结果

10

递归求n!=1x2x3x…x(n-1)n阶乘

def sum(n):
    if n == 1:
        return 1
    else:
        return n*sum(n-1)
print(sum(10))        

输出结果

3628800

if…else…三元运算

普通判断

a = int(input("请输入有理数："))
if a>0:
    print(a)
else:
    print(-a)

将此程序改为三元函数

a = int(input("请输入有理数："))
print(a) if a > 0 else print(-a)

def max2(x,y):
    if x >y:
        return x
    else:
        return y
print(max2(2,3))

将此程序改为三元函数

def max2(x,y):
	return x if x>y else y #函数中的应用
print(max2(2，3))

匿名函数(程序不复杂时使用)
变量名= lambda 参数列表：表达式

func = lambda:1 == 3 #创建一个匿名函数
f = func()
print(f)

func2 = lambda x, y,z:x+y+z#传递多个参数
f = func2(1,2,3)
print(f)

func3 = lambda x, y : y if x > y else x#使用if...else..语句
f = func3(1,2)
print(f)

普通判断

def max2(x,y):
    if x >y:
        return x
    else:
        return y
print(max2(2,3))

将此程序改为匿名函数

func = lambda x:y if x>y else y
f = func

函数闭包（在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量并且外函数的返回值是内函数的引用，这样就构成了一个闭包）

step1:嵌套函数

def outer():
    b = 20
    print(b)
    def inner():
        a = 10
        print(a)
    inner()
outer()
test()#调用内函数

step2:返回函数

def outer():
    b = 20
    print(b)
    def inner():
        a = 10
        print(a)
    return inner
test = outer()
test()#调用内函数

step3:闭包

def outer():
    b = 20
    print(b)
    def inner():
        a = 10
        print(a+b)
    return inner
test = outer() 
test()#调用内函数