2022-11-12Python93

函数

1.什么是函数:

函数就是执行特定任何以完成特定功能的一段代码

2.为什么需要函数

复用代码
隐藏实现细节
提高可维护性
提高可读性便于调试

3.函数的创建和调用

函数的创建

Python函数

函数的定义和调用

#函数的创建和调用
def calc_1():
    print("这是一个无返回值的函数")

calc_1()

函数的返回值
函数使用return语句返回值。定义函数时是否需要return语句，需要视情况而定
如果函数没有return语句，Python将认为函数以return None结束，即返回空
函数可以用return语句，返回一个值
函数也可以用return语句返回多个值，多个值以元组类型保存
- 当函数返回多个值时，我们可能需要单独对返回值进行处理，那么我们可以不采用元组的形式接受数据，可使用多变量赋值的形式
  -

def calc_2(a,b):
    c = a + b
    return c
x = calc_2(99,1)
print(x)

def calc_3(a,b):
    return a,b
x = calc_3(1,2)
print(x,type(x))
num_1,num_2 = calc_3(8,9)   #多变量赋值的形式，接受函数内部传递过来的值，但是变量个数要与返回值个数相同
print(num_1,num_2)

4.函数的参数传递

实参和形参
实参：调用函数时向其传递实参，根据不同参数类型，将实参的值或引用传递给形参
形参：定义函数时，圆括号内的参数为形参。
- 参数的类型可分为固定数据类型：（如整数、浮点数、字符串、元组等）和可变数据类型（如列表、字典、集合等）
- 当参数类型为固定数据类型时，在函数内部直接修改形参的值不会影响实参
  *
形参和实参的名字可以不相同

def calc_2(a):  #函数名括号内的a时形参
    a = 3       #当形参的类型为可变数据类型时，在函数内部直接修改值不会影响实参
    return a
b = 2
c = calc_2(b)   #调用函数时，实际传送的b是实参
print(c)        #3
print(b)        #2

def calc_1(a):      #函数名括号内的a时形参
    a.append(1)     #当形参的类型为可变数据类型时，在函数内部直接修改值会影响实参
    return a
list_1 = [1,2,3]
print(list_1)       #[1, 2, 3]
b = calc_1(list_1)  #调用函数时，实际传送的list_1是实参
print(b)            #[1, 2, 3, 1]
print(list_1)       #[1, 2, 3, 1]

函数参数传递的内存分析：

def fun(arg1,arg2):
    print(arg1)     #11
    print(arg2)     #[22, 33, 44]
    arg1 = 100
    arg2.append(10)

n1 = 11
n2 = [22,33,44]
print("调用函数之前n1和n2的值:",n1,n2)   #调用函数之前n1和n2的值: 11 [22, 33, 44]
fun(n1,n2)
print("调用函数之后n1和n2的值:",n1,n2)   #调用函数之后n1和n2的值: 11 [22, 33, 44, 10]

Python函数

参数类型：Python中，有多种参数类型，包括：
位置参数
- 实参和形参的顺序必须严格一致
- 实参和形参的数量必须相同
  +

#定义函数
def calc_1(a,b,c):
    print(a,b,c)

#调用函数
calc_1(1,6,5)
#calc_1(4,5)

默认值参数
- 函数在定义时，给形参设置默认值，只有与默认值不符时，才需要传递实参。
  +

#函数的默认参数
def calc_1(a,b = 10):
    print(a,b)

calc_1(10)              #10 10
calc_1(10,100)          #10 100

关键字参数
- 按参数名字传递值的方式
- 关键字参数允许函数调用时参数的顺序与定义时不一致
  +

#关键字参数传递
def calc_1(a,b,c):
    print("a的值为：",a,"b的值为：",b,"c的值为：",c)

calc_1(b = 1,c = 2 , a = 3)  #a的值为： 3 b的值为： 1 c的值为： 2

不定长参数
- 定义函数时，一个函数可以同时有一个个数可变的位置参数和一个个数可变的关键字形参，但是不能同时存在一个以上的个数可变的位置参数或者一个以上的个数可变的关键字形参
- 个数可变的位置参数：定义函数时，无法确定实参的个数时，可使用可变的位置参数。（接收到的实参存储在元组中）
  +

#不定长参数
def calc_1(*args):      #可变的位置参数
    print(args)

calc_1(1)               #(1,)
calc_1(1,2,3)           #(1, 2, 3)
calc_1(1,5,6,7,8,7)     #(1, 5, 6, 7, 8, 7)

+ 个数可变的关键字形参：定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键形参。（接收到的实参存储在字典中）
+

def fun(**args):          #可变的关键字参数
    print(args)

fun(a = 1)                      #{'a': 1}
fun(a = 1 , b = 2 , c = 3)      #{'a': 1, 'b': 2, 'c': 3}

5.函数的特殊调用，与参数顺序问题

def fun(a,b,c):
    print(a,b,c)

list_1 = [1,4,7]
fun(*list_1)        #在调用函数时，将列表的每一个元素都转换为位置实参  注意：列表的元素要与形参相同

tuple_1 = [2,5,8]
fun(*tuple_1)       #在调用函数时，将元组的每一个元素都转换为位置实参  注意：元组的元素要与形参相同

def fun(a,b,c):
    print(a,b,c)

dict_1 = {
    "a":100,
    "b":200,
    "c":300
}
fun(**dict_1)   #在调用函数时，将字典的每键值对都转换为关键字实参  注意：字典的键名要与形参名相同

def fun(a,b,c,d):
    print(a,b,c,d)

fun(10,20,30,40)                #位置参数
fun(a=10,c=20,b=60,d=100)       #关键字参数
fun(10,40,c=20,d=20)            #前面使用位置参数，后面使用关键字参数。注意，不能将位置调换

def fun1(a,b,*,c,d):            #规定*号后面的形参，必须使用关键字参数
    print(a,b,c,d)

#fun1(10,20,30,40)               #位置参数，报错，因为c和d没有使用关键字形参
fun1(a=10,c=20,b=60,d=100)       #关键字参数
fun1(10,40,c=20,d=20)            #前面使用位置参数，后面使用关键字参数。注意，不能将位置调换

'''
定义函数时：形参的顺序问题
'''
def fun1(a,b,*,c,d,**kwargs):
    pass

def fun2(*args,**kwargs):
    pass

def fun1(a,b=10,*args,**kwargs):
    pass

6.变量的作用域

程序代码能够访问该变量的区域
根据变量的有效范围，可以分为
全局变量：函数体外定义的变量，可作用于函数内外。
-

name = "Python"     #变量name为全局变量，所以这个变量在函数体的内外都可以使用
print("这是是函数体外的输出：",name)
def fun1():
    print("这里是函数体内的输出",name)
fun1()

#由下列代码可见，函数体内的修改全局变量的值，只能在函数体内使用，不能作用于函数体外。
name = "Python"     #变量name为全局变量，所以这个变量在函数体的内外都可以使用
print("这是是函数体外的输出1：",name)  #这是是函数体外的输出1： Python
def fun1():
    #print("这里是函数体内的输出1",name) #此行代码会报错，因为函数体内有修改全局变量的值
    name = "HelloWorld" #当我们使用这行代码是，表示：定义了一个局部变量，因此上面这行代码会报错。
    print("这是是函数体内的输出2",name)   #这是是函数体内的输出2 HelloWorld
fun1()
print("这是是函数体外的输出2",name)   #这是是函数体外的输出2 Python

局部变量：在函数内定义的并使用的变量，只在函数内部有效，局部变量在使用global声明，这个变量就会成全局变量。
-

#局部变量
def fun(a,b):
    c = a + b  #c是在函数内部声明的变量，所以c为局部变量；a b 也属于局部变量。作用范围仅限函数内部。
    return c
print(fun(10,20))
#print(a,b,c)   #代码会报错，因为abc都属于局部变量，作用范围都值在函数内部。

#global：在函数体内声明全局变量
num = 1
def fun():
    global num  #函数内部定义的变量，是局部变量，在使用global声明时，这个变量就变成了全局变量
    global num1
    num = 2
    num1 = 3
    print("fun函数体内的num的值：",num)
    print("fun函数体内的num1的值：",num1)
fun()
print("fun函数体外的num的值：", num)
print("fun1函数体外的num1的值：", num1)

#nonlocal:在函数体内嵌套一个函数，要修改嵌套函数中变量的作用域，可使用nonlocal关键字
def fun1():
    num1 = 1
    def fun2():
        nonlocal num1
        #nonlocal num2  #此处会报错，因为外变量中没有num2
        global num3     #也可以在嵌套函数的内部声明全局变量
        num1 = 2
        num3 = 30
        print("这是fun2中的num1",num1)
        print("这是fun2中的num3",num3)
    fun2()
    print("这是fun1中的num1",num1)
    print("这是fun1中的num3",num3)
fun1()
#print("这是函数外的num1",num1)   #此处代码会报错，因为nonlocal不能将局部变量变为全局变量
print("这是函数外的num3",num3)

7.递归函数

什么是递归函数：
如果在一个函数的函数体内调用了该函数本身，这个函数就成为递归函数。
-

def fun():
    print("这是一个递归函数")
    return fun()
fun()

递归的组成部分
递归调用与递归终止条件
递归调用过程
每递归调用一次函数，都会在栈内存分配一个栈帧
每执行完一次函数，都会释放相应的空间递归的优缺点
缺点：占用内存多，效率低下
优点：思路和代码简单
例题：6的阶乘
-

def fun(num):
    if num==1:
        return 1                                   #出口
    else:
        return num * fun(num - 1)        #fun函数内调用fun
print(fun(6))                                    #720

斐波那契数列的练习：
-

#斐波那契数列 1 1 2 3 5 8 13 ···········
def fun(num):
    if num == 1:
        return 1
    elif num == 2:
        return 1
    else:
        return fun(num-1)+fun(num-2)
a = 6
print("斐波那契数列第",a,"位的数值为：",fun(a))           #斐波那契数列第 6 位的数值为： 8

#输出斐波那契数列每一项的值
for x in range(1,a+1):
    print(fun(x),end=" ")   #1 1 2 3 5 8

8.总结：

Python函数

拆包

在调用拥有多值参数的函数时，如果希望元组传递给args,字典传递给*kwargs，就可以使用拆包
在调用时，给实参加上分别加上和*
*

a = (1,2,3,4,5)
b = {"name":"zms","age":35}
fun(a,b)
#运行结果
((1, 2, 3, 4, 5), {'name': 'zms', 'age': 35})     {}
#拆包
fun(*a,**b)   # a会拆成5个位置实参：1,2,3,4,5   b会拆成两个关键字参数： "name":"zms","age":35

#运行结果 (1, 2, 3, 4, 5) {'name': 'zms', 'age': 35}

匿名函数：

语法格式：

函数名 = lambda [参数列表]:表达式

Python函数

1 # 无参数匿名函数
 2 import random
 3
 4 sum = lambda :print("python")
 5 sum()               #python
 6
 7 random_lambda = lambda : random.randint(1,3)
 8 print( random_lambda() )    # 1  2  3
 9
10 # 匿名函数
11 sum = lambda args1,args2=10: args1+args2
12 print(sum(20))      # 30
13 print(sum(20,30))   # 50
14
15 # 利用三元表达式
16 get_odd_even = lambda x: "%s是偶数"%x if x%2==0 else "%s是奇数"%x
17 print(get_odd_even(8))  #8是偶数
18 print(get_odd_even(9))  #9是奇数
19
20 # map函数 与 函数结合
21 def add(x):
22     return x**2
23 mobj = map(add, [1,2,3,4])
24 print( list(mobj) )      # [1, 4, 9, 16]
25 #使用 匿名函数 与 map函数 结合
26 mobj_1 = map(lambda x: x**2, [1,2,3,4,5])
27 print( list(mobj_1) )    #[1, 4, 9, 16, 25]

匿名函数

参数的默认值【面试题】

这个知识点在面试题中出现的概率比较高，但真正实际开发中用的比较少。

def func(a1,a2=18):    print(a1,a2)

原理：Python在创建函数（未执行）时，如果发现函数的参数中有默认值，则在函数内部会创建一块区域并维护这个默认值。

执行函数未传值时，则让a2指向函数维护的那个值的地址。

func("root")

执行函数传值时，则让a2指向新传入的值的地址。

func("admin",20)

在特定情况【默认参数的值是可变类型 list/dict/set】 & 【函数内部会修改这个值】下，参数的默认值有坑。

# 在函数内存中会维护一块区域存储 [1,2,666,666,666] 100010001
def func(a1,a2=[1,2]):
    a2.append(666)
    print(a1,a2)

# a1=100
# a2 -> 100010001
func(100) # 100  [1,2,666]

# a1=200
# a2 -> 100010001
func(200) # 200 [1,2,666,666]

# a1=99
# a2 -> 1111111101
func(99,[77,88]) # 66 [177,88,666]

# a1=300
# a2 -> 100010001
func(300) # 300 [1,2,666,666,666]

大坑

# 在内部会维护一块区域存储 [1, 2, 10, 20,40 ] ,内存地址 1010101010
def func(a1, a2=[1, 2]):
    a2.append(a1)
    return a2

# a1=10
# a2 -> 1010101010
# v1 -> 1010101010
v1 = func(10)
print(v1) # [1, 2, 10]

# a1=20
# a2 -> 1010101010
# v2 -> 1010101010
v2 = func(20)
print(v2) # [1, 2, 10, 20 ]

# a1=30
# a2 -> 11111111111        [11, 22,30]
# v3 -> 11111111111
v3 = func(30, [11, 22])
print(v3) #  [11, 22,30]

# a1=40
# a2 -> 1010101010
# v4 -> 1010101010
v4 = func(40)
print(v4) # [1, 2, 10, 20,40 ]

深坑

# 内存中创建空间存储 [1, 2, 10, 20, 40] 地址：1010101010
def func(a1, a2=[1, 2]):
    a2.append(a1)
    return a2

# a1=10
# a2 -> 1010101010
# v1 -> 1010101010
v1 = func(10)

# a1=20
# a2 -> 1010101010
# v2 -> 1010101010
v2 = func(20)

# a1=30
# a2 -> 11111111111   [11,22,30]
# v3 -> 11111111111
v3 = func(30, [11, 22])

# a1=40
# a2 -> 1010101010
# v4 -> 1010101010
v4 = func(40)

print(v1) # [1, 2, 10, 20, 40]
print(v2) # [1, 2, 10, 20, 40]
print(v3) # [11,22,30]
print(v4) # [1, 2, 10, 20, 40]

undefined

Original: https://www.cnblogs.com/fjfsu/p/15419121.html
Author: J.FengS
Title: Python函数

Title: 【光学】Matlab实现迈克尔逊干涉仪动态仿真

1 内容介绍

从光的干涉理论出发,分析了迈克尔逊干涉实验原理和光程差表达式,利用Matlab改变参数对迈克尔逊干涉实验现象进行二维和三维仿真模拟,通过仿真提供了更加直观清晰的实验图像,这对于迈克尔逊干涉仪的实验教学起到很好的相辅作用.

2 仿真代码

% 脚本用于绘制迈克尔逊等倾干涉光路图及干涉图像；

%% 绘制前处理

clear %清除变量

clc; %清空历史窗口中的内容

close all; %关闭所有图形窗口

%% 图像绘制

r_max=1; %最大半径(相对坐标)

[h1,h2,hT,R]=Michelson_Draw_1(r_max); %绘制第一帧图像并得到句柄

theta_i=atan(R); %夹角

%pause %暂停

for d=-5:0.05:5

e=2*d;

DD=2ecos(theta_i); %光程差

I=cos(pi*DD).^2./(1+R.^2); %相对光强

set(h1,'YData',[20+d 20+d]); %M1'位置

set(hT,'Position',[10 20+d 0]); %M1'文字标注

set(h2,'CData',100*I) %设置光强

drawnow %更新屏幕

if get(gcf,'CurrentCharacter')==char(27)

break,

end % 按ESC键退出

%% 保存为gif文件：

gifname = 'Michelson_Draw_1.gif'; %建立一个gif文件

drawnow %图像实时更新

frame = getframe(1); %获取当前图像作为影片帧

im = frame2im(frame); %返回与影片帧关联的图像数据

[imind,cm] = rgb2ind(im,500); %格式转换

if d == -5

imwrite(imind,cm,gifname,'gif'); %创建一个gif文件

else

imwrite(imind,cm,gifname,'gif','WriteMode','append','DelayTime',0.01);

%向gif文件中添加一张图片

end %结束循环

end

3 运行结果

Python函数

4 参考文献

[1]邹智星, 胡卫东, 王子涵,等. 基于MATLAB的迈克尔逊干涉仪干涉视频处理[J]. 西南师范大学学报：自然科学版, 2019, 44(7):5.

[2]冯明春, 王玉杰. 基于Matlab对迈克尔逊干涉实验仿真的分析研究[J]. 大学物理实验, 2021.

博主简介：擅长智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，相关matlab代码问题可私信交流。

部分理论引用网络文献，若有侵权联系博主删除。

Original: https://blog.51cto.com/u_15287693/5609862
Author: matlab科研助手
Title: 【光学】Matlab实现迈克尔逊干涉仪动态仿真

2023年 9月
一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

函数

1.什么是函数:

2.为什么需要函数

3.函数的创建和调用

4.函数的参数传递

5.函数的特殊调用，与参数顺序问题

6.变量的作用域

7.递归函数

8.总结：

拆包

匿名函数：

参数的默认值【面试题】

相关阅读

Title: 【光学】Matlab实现迈克尔逊干涉仪动态仿真

1 内容介绍

2 仿真代码

3 运行结果

4 参考文献

博主简介：擅长智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，相关matlab代码问题可私信交流。

部分理论引用网络文献，若有侵权联系博主删除。