全局变量和局部变量

----------------------------------局部变量----------------------------------
1)就是在函数内部定义的变量，作用域仅局限在函数的内部
2)不同的函数 可以定义相同的局部变量，但是各自用各自的，不会产生影响
局部变量的作用：
为了临时的保存数据，需要在函数中定义来存储
----------------------------------全局变量----------------------------------
与局部变量不同的是作用域范围不同
当全局变量和局部变量出现重复时，程序优先执行使用函数定义内部的变量
如果在函数的内部要想对全局变量进行修改，必须使用global关键字进行声明

# 局部变量 就是在函数内部定义的变量，作用域仅局限在函数的内部
# 不同的函数 可以定义相同的局部变量，但是各自用各自的，不会产生影响
# 局部变量的作用：为了临时的保存数据，需要在函数中定义来存储
pro = '软件工程'  # 全局变量
name = 'Tony'
def printInfo():
    name = 'Peter'  #局部变量
    print('{} {}'.format(name,pro))
    pass

def TestMethod():
    name = 'Amy'
    print(name,pro)
    pass

def changeGlobal():
    '''
    修改全局变量
    '''
    global pro
    pro = '物联网工程'
    # pro = '物联网工程'  #局部变量
    pass


print(pro)
changeGlobal()
print(pro)
printInfo()
TestMethod()

函数参数引用传值

对于Python来讲：
1.在Python中，万物皆对象，在函数调用的时候实参传递的就是对象的引用
2.了解了原理之后，就可以更好的去把控在函数的内部处理是否会影响到函数外部数据变化
参数的传递是通过对象引用来完成！！！

a = 1  #不可变类型 +
def func(x):
    print('x的地址{}'.format(id(x)))
    x = 2
    print('x修改后的地址{}'.format(id(x)))
    pass
#调用函数
print('a的地址{}'.format(id(a)))
func(a)
# print(a)

# 可变类型
li = []
def testRenc(parms):
    li.append([1,2,4,54,67])
    print(id(parms))
    print('内部的{}'.format(parms))
    pass

print(id(li))
testRenc(li)
print('外部的{}'.format(li))

匿名函数

语法：
lambda 参数1,参数2,参数3:执行代码语句
特点：
1.使用lambda关键字创建匿名函数
2.没有名字的函数(没有不用def关键词创建的标准函数)
3.匿名函数冒号后面的表达式有且只有一个,注意:是表达式，而不是语句
4.匿名函数自带return，这个return的结果就是表达式计算后的结果，不用显式的返回

lambda与三元运算语句：
                    if a：
                        b
                    else：
                        c

能够由以下等效的表达式来模拟：
b if a else c
这样的表达式(三元运算)能够放在lambda中，他们能够在lambda函数中来实现选择逻辑
缺点：
lambda只能是单个表达式，不是代码块，lambda的设计就是为了简单函数的场景
仅仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def处理

test = lambda x,y:x+y
#  通过变量去调用匿名函数
# print(test(1,3))
# age = int(input('请输入你的年龄:'))
# print('可以参军' if age>18 else '继续上学') #  可以替换传统双分支的写法
max = lambda x,y:x if x>y else y
print('max = {}'.format(max(25,30)))

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

s = (lambda x:(x**2)+890)
print('s = {}'.format(s(10)))

递归函数

1.如果一个函数在内部，不调用其他的函数，而是自己本身的话，这个函数就是递归函数。
2.递归必须有结束条件，否则递归无法结束，会一直递归下去，直到达到最大递归深度报错。
优点：逻辑简单，定义简单
缺点：容易导致栈溢出，内存紧张，甚至内存泄漏

def DGJC(n):
    if n == 1:
        return 1
    return n*DGJC(n-1)
    pass
n = int(input('请输入数值：'))
print('{}! = {}'.format(n,DGJC(n)))

案例

• 模拟实现树形结构的遍历(递归函数)

import os  #引入文件操作模块

def findFile(file_Path):
    '''
    打印该目录下的所有文件
    '''
    listRs = os.listdir(file_Path) #得到该路径下面的所有的文件夹
    for fileItem in listRs:
        full_path = os.path.join(file_Path,fileItem) #获取完整文件路径
        if os.path.isdir(full_path): #判断是否是文件夹
            findFile(full_path) #如果是文件夹，再次去递归
        else:
            print(fileItem)
            pass
        pass
    else:
        return
    pass

#调用搜索文件对象
findFile('D:\\Python')