自定义函数与全局变量

自定义函数

• 自定义函数

• 如何创建函数？def语句

定义函数

# 定义函数

def f(x):
    if x < 5:
        print('输入值小于5')
    else:
        print('输入值大于等于5')  # 定义函数，其中x是参数（局部变量）
f(10)  # 运行函数

==============
输入值大于等于5

关于retuen

# 关于retuen

def f1(x):
    y = 2**x  # 没有return
    
def f2(x):
    y = 2**x
    return y # 含有return

print(f1(2),f2(2))
# return语句退出函数，并返回一个表达式。不带参数值的return语句返回None


# 关于retuen

def f1(x):
    y = 2**x  # 没有return
    
def f2(x):
    y = 2**x
    return y # 含有return


print(f2(13))

# f1函数 未将函数中的内容return，故不返回值
print(f1(13))

==========================
None 4

默认参数

# 默认参数

def f(x,n = 2):
    return(x**n)
print(f(10))
print(f(10,3))
# n = 2,这里n的默认值为2，如果不输入则以默认值为主

===========
100
1000

可变参数

# 可变参数

def f(*x):
    print(x)
    return x
f(1)
f('a','b')
f(1,2,3,[44,33])
print(type(f('a','b')))
# 通过*来定义可变参数
# 默认会把可变参数传入一个元祖！

=============
(1,)
('a', 'b')
(1, 2, 3, [44, 33])
('a', 'b')
<class 'tuple'>

局部变量及全局变量

• 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

• 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

演示案例

• f（m）中，m是函数的参数，f(x)是吧x的值赋予了m，但x值自己本身不受影响，所以执行函数后，是在函数局部“变化”了x

• 什么是局部变量？ → 当函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系!

• 即变量名称对于函数来说是“局部”的。这称为变量的作用域。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。

# 演示案例

def f(m):
    m = '呵呵哒'  # 函数作用：把输入变量指向“呵呵哒”
    print("函数内为局部变量：%s" % m)    

a = input('请输入一个数字：')
f(a)
print("函数外为全局变量：%s" % a)
# f（m）中，m是函数的参数，f(x)是吧x的值赋予了m，但x值自己本身不受影响，所以执行函数后，是在函数局部“变化”了x
# 什么是局部变量？ → 当函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系!
# 即变量名称对于函数来说是“局部”的。这称为变量的作用域。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。
=========================
请输入一个数字：60
函数内为局部变量：呵呵哒
函数外为全局变量：60

global语句 → 把局部变量变为全局变量

# global语句 → 把局部变量变为全局变量

def f():
    global a
    a = '呵呵哒'  
    print("函数内转为全局变量：%s" % a)    

a = input('请输入一个数字：')
print("输入变量值：%s" % a)
f()

=============
请输入一个数字：60
输入变量值：60
函数内转为全局变量：呵呵哒

匿名函数Lambda

• lambda 语句创建匿名函数。

• lambda作为匿名函数，是不需要函数名的 → 需要一个函数，又不想动脑筋去想名字，这就是匿名函数

• lambda的主体是一个表达式，而不是一个代码块。

• lambda只有一行，仅仅能在lambda表达式中封装有限的逻辑进去。

# 示例

def fun(a,b,c):
    return a+b+c
print(fun(2,3,4))
# def创建自定义函数，求和

f = lambda a,b,c:a+b+c
print(f(2,3,4))
# lambda作为匿名函数，是不需要函数名的 → 需要一个函数，又不想动脑筋去想名字，这就是匿名函数
# lambda的主体是一个表达式，而不是一个代码块。
# lambda只有一行，仅仅能在lambda表达式中封装有限的逻辑进去。


==================
9
9