2021小白Python学习记录Day5 Python函数学习 下（全局变量和局部变量 函数参数引用传值 匿名函数 递归函数）

'''

每日更新内容为10天前当天学习内容，想通过写博客的方式复习和记录，欢迎大佬提意见、纠错和萌新学习与讨论。

'''

目录

一、Python全局变量和局部变量

1.局部变量

2.全局变量

当全局变量和局部变量同名

在函数的内部想要对全局变量进行修改（global 关键字）

二、函数参数引用传值

1.不可变类型

2.可变类型

3.匿名函数

语法

特点

扩展：语句A  if  (条件语句)  else  语句B

4.递归函数

---

一、Python全局变量和局部变量

1.局部变量

局部变量，只能在该函数内部使用

局部变量的作用：为了临时的保存数据，需要在函数中定义来进行存储

不同的函数可以定义同名的局部变量，各自用各自的 不会产生影响

def printInfo():
    name='peter'  #局部变量  只能在该函数内部使用
    pass
# print(name)   #报错    NameError: name 'name' is not defined

代码种name 就是一个局部变量，在函数外部是不能直接使用的

2.全局变量

全局变量 【作用域的范围更广】
当全局变量和局部变量出现重复定义的时候，程序会优先执行使用函数内部定义的变量【地头蛇】
如果在函数的内部想要对全局变量进行修改的话 必须使用global 关键字进行声明

name='dashizi'
pro='计算机'    #全局变量
def dayingPro():
    print(pro)
    pass
dayingPro()

可以看到 全局变量在函数内也是可以使用的

当全局变量和局部变量同名

pro='计算机'    #全局变量
def youXian():
    pro=100        #当全局变量和局部变量出现重复定义的时候，函数程序会优先执行使用函数内部定义的变量【地头蛇】
    print(pro)
youXian()          #结果为100  函数优先使用函数内部定义的变量
print(pro)         # 结果为计算机

运行结果：

可以看到调用函数时，会优先使用函数内部定义的变量

在函数外则只有全局变量有意义，不能使用局部变量

在函数的内部想要对全局变量进行修改（global 关键字）

name='dashizi'
def xiuGai():
    global name # 如果在函数的内部想要对全局变量进行修改的话 必须使用global 关键字进行声明
    name='xiaolaohu'
    pass

print(name)     # dashizi
xiuGai()
print(name)     # xiaolaohu

在没调用xiuGai()之前 name为原全局变量dashizi，在函数内通过global 声明后修改可以发现全局变量发生变化。

二、函数参数引用传值

1.python中，万物皆对象，在函数调用的时候，实参传递的就是对象的引用

2.了解了原理之后，就可以更好的去把控 在函数内部的处理是否会影响到函数外部的数据变化

                                    参数的传递是通过对象引用来完成

1.不可变类型

#不可变类型
a=1
def func(x):
    print('x的地址:{}'.format(id(x)))   # 地址与a相同  这样传的是对象的引用
    x=2
    print('x的值修改之后的地址{}'.format(id(x)))   # 内存地址变了 变化不会作用在a上
    print(x)
    pass
# 调用参数
print('a的地址:{}'.format(id(a)))
func(a)            # 地址相同  这样传的是对象的引用
print(a)     # 这里还是1

运行结果：

形参x相当于对实参a进行引用

2.可变类型

# 可变类型
li=[]
def testRenc(parms):
    print('内部变量对象内存地址{}'.format(id(parms)))
    parms.append([1,2,3,4,5])
    print('list操作后内部变量对象内存地址{}'.format(id(parms)))  # 没有改变
    print('内部的变量对象：{}'.format(parms))  # 内部的变量对象：[[1, 2, 3, 4, 5]]
    pass

print('外部变量对象初始情况{}'.format(li))
print('外部变量对象内存地址{}'.format(id(li)))

testRenc(li)
print('调用函数后外部的变量对象：{}'.format(li))         #外部的变量对象：[[1, 2, 3, 4, 5]]

 运行结果：

 可以看到，在函数内对列表进行内置操作时，列表的内存地址没有发生变化，函数内列表种数据项的变化，也反应在了全局变量上。parms.append()相当于直接对全局变量li 进行了操作。

3.匿名函数

语法

变量名=lambda 参数1,参数2,参数3...,参数n:表达式

变量()       #调用

特点

1.使用lambda关键字去创建函数

2.没有名字的函数

3.匿名函数冒号后面的表达式有且只有一个，注意：是表达式，而不是语句

4.匿名函数自带return，而这个return的结果就是表达式计算后的结果 通过变量去调用匿名函数

       缺点： lambda只能是单个表达式，不是一个代码块，仅仅能封装有限的逻辑

示例：

test=lambda x,y:x+y  # 通过变量去调用匿名函数
print(test(2,3))

cao=lambda a,b,c,d,e:a*b+c*d+e
print(cao(1,2,3,4,5))

扩展：语句A  if  (条件语句)  else  语句B

示例：

age=15
print('可以工作'if age>18 else '继续上学')  #可以替代传统双分支的写法 # 输出为'继续上学'

 带入使用lambda

funcTest=lambda x,y:x if x>y else y   # 选出较大的数
print(funcTest(2,8))      #打印结果为8

print('---------------------------------')
rs=(lambda x,y:x if x>y else y)(16,12)    # 直接调用
print(rs)

 运行结果：

4.递归函数

递归：自己调用自己

必须有一个明确的结束条件

优点：逻辑简单、定义简单

缺点：容易导致栈溢出，内存紧张，甚至内存泄漏

示例：求阶乘

# 用循环去实现
def jiecheng(n):
    result=1
    for item in range(1,n+1):
        result*=item
        pass
    return result
print('5的阶乘为{}'.format(jiecheng(5)))

 结果为：5的阶乘为120

递归实现求阶乘

# 递归方式去实现
def diguiJc(n):
    '''
    递归实现
    :param n: 阶乘参数
    :return: 阶乘值
    '''
    if n==1:
        return 1
    else:
        return n*diguiJc(n-1)
    pass
print('5的阶乘{}'.format(diguiJc(5)))

当n=1时不在继续递归

可以看到递归逻辑非常简单 不为1就返回n*diguiJc(n-1)

相当于diguiJc(5)-->5*diguiJc(4)-->5*4*diguiJc(3)-->5*4*3*diguiJc(2)-->5*4*3*2*diguiJc(1)