Python自学笔记_day04

一、函数基础

定义：一般是完成具体独立功能的代码块，为了最小化代码冗余，提高代码的复用率，问题局部化

1.1函数分类

def functionA():
    '''
    无参无返回值函数
    :return:无
    '''
    print('Hello,鹿鸣松')
functionA()

def functionB(name):
    '''
    带参无返回值函数
    :return:
    '''
    print('Hello,%s'%(name))
functionB('鹿鸣松')

def functionC():
    '''
    无参有返回值函数
    :return:
    '''
    a=1
    b=2
    return a+b
params=functionC()
print(params)

def functionD(a,b):
    '''
    带参有返回值函数
    :return:
    '''
    return a+b
params=functionD(1,2)
print(params)

1.2参数分类

定义：参数是为了实现某项特定的功能所需要的数据

分类：必选参数、默认（缺省）参数、可选参数、关键字参数

# 1.必选参数
def sum(a, b):  # 形参：只是意义上的一种参数，并没有开辟内存空间
    sum = a + b
    print(sum)
sum(1, 4) #实参：实际开辟了内存空间

#2.缺省参数
def sum1(a=1,b=2):
    '''
    如果不传参数值，则使用默认参数值；另外默认参数一定要放在最后面，放在形参前面会有报错
    :param a:
    :param b:
    :return:
    '''
    print(a+b)
sum1(5)#输出结果为7，因5给了a

#3.不定长参数，当参数的个数不确定时使用
def functionA(*args):
    '''
    是元组类型的数据
    :param args:
    :return:
    '''
    print(type(args))
    for item in args:
        print(item,end=' ')

functionA(1,2,3,4,5,6)
print()

#4.关键字参数，在函数体内，参数关键字是一个字典类型，key是一个字符串
def functionB(**kwargs):
    '''

    :return:
    '''
    print(kwargs)
dictA={'name':'鹿鸣松','age':24}
functionB(**dictA)
functionB(name='鹿鸣松',age=24)

#5.不定长和关键字混合使用
def complexFunc(*args,**kwargs):
    '''
    可选参数必须放到关键字参数之前，也就是括号中两个参数的顺序不能换
    可选参数接受的是元组类型
    关键字可选参数接受的是字典类型
    :param args:
    :param kwargs:
    :return:
    '''
    # print(type(args))
    # print(type(kwargs))
    print(args)
    print(kwargs)
complexFunc(1,2,3,4,name='鹿鸣松')#这边的字典类型参数能被正常识别
complexFunc(1,2,3,4,dictA)#这边的dictA被放入可选参数了

1.3函数嵌套调用

def functionA(a=10,b=30):
    return a+b

def functionB(a,b=96):
    result=functionA(a,b)
    return result

print(functionB(10))

二、全局变量和局部变量

定义：局部变量的作用域是在函数体内的，而全局变量作用域整个文件。局部变量优先于全局变量，也就是在函数内，如果出现和全局变量一样的参数，则优先使用函数体内的变量。

name='鹿鸣松'
def printName():
    name='鹿鸣雪'
    print(name)
printName()#输出结果为鹿鸣雪

修改全局变量的方法

name='鹿鸣松'
def modName():
    global name #得先声明
    name='鹿鸣雪'

modName()
print(name)

三、匿名函数

语法：lambda 参数1、参数2、参数3：表达式

特点：

• 使用lambda关键字去创建函数
• 没有名字的函数
• 匿名函数冒号后面的表达式有且只有一个，注意：是表达式，而不是语句
• 匿名函数自带return，而这个return的结果，就是表达式计算后的结果

#语法结构 lambda 参数1、参数2、参数3：表达式
#特点
add=lambda x,y:x+y
#通过变量去调用函数
print(add(22,18))

'''
这里a,b,c是参数，值在后面的括号里，冒号后面就是表达式，只能有一条表达式
表达式的意思是，如果a>b，就返回a，反之返回c
'''
result=(lambda a,b,c:a if a>b else c)(10,20,30)#替换单分支
print(result)

#把上面的式子拆分写一下，如下
#创建匿名函数
fun=lambda a,b,c:a if a>b else c
rs=fun(10,20,30)
print(rs)

四、递归函数

定义：在函数体内再调用自己

特点：

• 必须有一个明确的结束条件
• 逻辑简单、定义简单
• 容易导致栈溢出、内存资源紧张，甚至内存泄漏

def jiecheng(n):
    '''
    n的阶乘函数，递归函数简洁，逻辑清晰
    :param n:
    :return:
    '''
    if n == 1:
        return 1
    else:
        return n * jiecheng(n - 1)


print(jiecheng(5))


# 模拟实现树形结构的遍历，找到文件夹下的文件
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)
    else:
        return


findFile('F:\\英雄时刻')

五、内置函数