Python基础-函数

Python 函数

参数的解包（拆包）

def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

#创建一个元组
t=(10,20,30)
fn4(*t)

#传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
#这里要求序列中元素的个数必须和形参的个数的一致

#创建一个字典
d={'a':100,'b':200,'c':300}
#通过**来对一个字典进行解包操作
fn4(**d)

返回值

#返回值就是函数执行以后返回的结果
#在函数中，return后的代码都不会执行

#break用来退出当前循环
#continue用来跳过当次循环

def sum(*nums):
	#定义一个变量，来保存结果
    result = 0
	#遍历元组，并将元组中的数进行累加
    for n in nums:
    result +=n
    #print(result)
    return result

r = sum(123,456,789)
print(r)
'''
#sum 和 sum( )的区别
print(sum)#sum是函数对象，打印sum实际是在打印函数对象<function sum at0 xg5771BB8>
print( sum( ) )#sum( ) 是在调用函数，打印sum( ) 实际上是在打印sum( )函数的返回值

'''

文档字符串

#help（）是Python中的内置函数
#通过help（）函数可以查询pythont中的函数的用法
#语法：help（函数对象）
#help(print)#获取print（）函数的使用说明

#文档字符串(doc str)
#在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
#当我们编写了文档字符串时，就可以通过help（）函数来查看函数的说明
#文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
def fn(a:int,b:int,c:str) -> int:
    '''
    ->int(表示返回值为 int 类型)
    这是一个文档字符串的示例
    函数的作用
    函数的参数：
    a,作用, 类型，默认值...
    b,作用，类型，默认值...
    c,作用，类型，默认值...
    '''
    return 10

help(fn)

作用域和命名空间

作用域

1. 全局作用域

2. 函數作用域

3. 变量的查找

• 当我们使用变量时，会优先在当前作用域中寻找该变量，如果有則使用，没有就继续去上一级作用域中寻找，直到找到全局作用域依然没找到，则会抛出异常（NameError）

4. global
   • 如果希望在函数内部修改全局变量，则需要使用 global 关键字，来声明变量

#在Python中一共有两种作用域
#全局作用域
# 1.全局作用域在程序执行时创建，在程序执行结束时销毁
# 2.所有函数以外的区域都是全局作用域
#在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问

#函数作用域
#1.函数作用域在函数调用时创建，在调用结束时销毁
#2.函数每调用一次就会产生一个新的函数作用域
#3.在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问




def fn2():
    a=30  #在函数中为变量赋值时，默认都是为局部变量赋值
    def fn3():
    	print('fn3中：'，'a=',a)
    fn3()

fn2()
a=20
#全局函数 'fn3'
def fn3():
    global a   #声明在函数内部的使用a是全局变量，此时再去修改a时，就是在修改全局的a
    a=10       #修改全局变量
    print('函数内部a:',a)
    
fn3()

命名空间（namespace）

1. 命名空间指的是变量存诸的位置，每一个变量都需要存储到指定的命名空间当中
2. 每一个作用域都会有一个它对应的命名空间
3. 全局命名空间，用来保存全局变量。函数命名空间用来保存函数中的变量
4. 命名空间实际上就是一个字典，是一个专门用来存储变量的字典

# locals() 用来获取当前作用域的命名空间
#如果在全局作用域中调用 locals() 则获取全局命名空间，如果在函数作用域中调用 locals() 则获取函数命名空间
#返回的是一个字典
a=10
set = locals()
print(type(set))
#向 set 中添加一个 key-value
set['c'] = 100  #向 set 中添加一个 key-value就相当于创建了一个 全局变量 （一般不建议）
print(c)

def fn1():
    a=10
    set = locals()  #获取函数命名空间
    set['d'] = 100  #在函数作用域中添加变量 d
    print(d)
    #globals( ) 函数可以在任意位置获取全局命名空间
    global_set = globals()
    global_set['a'] = 200 #修改全局变量 a
    global_set['c'] = 200 #修改刚添加的全局变量 c
    
    
fn1()
print(a,c)

递归

1. 递归思想：将一个大的问题分解成一个个小问题，直到无法分解时，再去解决问题

• 基线条件：问题可以被分解成小问题，当满足基线条件，递归就不在执行
• 递归条件：将问题继续分解的条件

2. 递归式的函数: 在函数中自己调用自己
3. 无穷递归：如果这个函数被调用，程序内存会溢出，效果类似死循环
4. 递归和循环类似，基本可以互相代替

#创建一个函数可以求任意数的阶乘
def fun(n):
    '''
    	用求任意数的阶乘
    	参数：
    		n  要求阶乘的数字
    '''
    if n ==1:return n   #基线条件
    result = n
    for i in range(1,n):result *= i        
    #递归条件
    return n*fun(n-1)



print(fun(1))
#求10的阶乘
print(fun(10))

函数式编程

1. 在Python中，函数是一等对象
2. 一等对象特点

• 对象是在运行时创建的

• 能赋值给变量或作为数据结构中的元素

• 能作为参数传递

• 能作为返回值返回

高阶函数

3. 高阶函数 （至少符合以下两个特点的一个）

• 接收一个或多个函数作为参数
• 将函数作为返回值返回

#filter()
#filter()可以从序列中过滤出符合条件的元素，保存到一个新的序列中
#参数：
#1.函数，根据该函数来过滤序列（可迭代的结构）
#2.需要过滤的序列（可迭代的结构）
#返回值：
#过滤后的新序列（可迭代的结构）

#高阶函数
def fun4(i):
    if i % 2 == 0:return True
    return False

l = [1,2,3,4,5,6,7,8,]
def fn(func,l):
    new_list=[]
    for i in l:
        #判断
        if func(i):
            new_list.append(i)
    return new_list


print(fn(fun4,l))
#fun4就是作为filter()的参数
r = filter(fun4, l)
print(list(r))

匿名函数

#匿名函数lambda函数表达式
#lambda函数表达式专门用来创建一些简单的函数，他是函数创建的又一种方式
#语法：lambda参数列表：返回值
#* 匿名函数一般都是作为参数使用，其他地方一般不会使用

l = [1,2,3,4,5,6,7,8,9]
def fn(func,l):
    new_list=[]
    for i in l:
        #判断
        if func(i):
            new_list.append(i)
    return new_list

def fun4(i):
    '''
    if i % 2 == 0:return True
    return False
    '''
    return i % 2 ==0

lambda i : i % 2 ==0
r=filter(fun4,l)
print("fn(fun4,l):",fn(fun4,l))
print('filter(fun4,l):',list(r))
print('filter(lambda i:i % 2 == 0, l)',list(filter(lambda i:i % 2 == 0, l)))


#map()
#map()函数可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
r2 = map(lambda i:i+1, l)
print(r2,list(r2))

sort(),sorted()

该方法用来对列表中的元素进行排序
sort() 方法默认是直接比较列表中的元素的大小
在sort() 可以接收一个关键字参数，key
key需要一个函数作为参数，当设置了函数作为参数
每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小

l = ['bb','aaaa','c','ddddddddd','fff']
l.sort(key=len)
print(l)
j = [2, 4, 6, '10', '5', '7']
#j.sort(key=int)  #只是在比较是做转化
#print(j)
#sorted()
#这个函数和sort() 的用法基本一致，但是sorted() 可以对任意的序列进行排序
#并且使用sorted() 排序不会影响原来的对象，而是返回一个新对象 
print("排序前", j)
print('sorted(j,key=int)排序：',sorted(j,key=int))
print('排序后：',j)

闭包

• 形成闭包的要件

1. 函数嵌套
2. 将内部函数作为返回值返回
3. 内部函数必须要使用到外部函数的变量

#将函数作为返回值也是一种高阶函数
#这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
#可以将一些私有的数据藏到的闭包中
from tkinter import N


def fn():
    mun=[]
    a=10
    def fn2():
        print("闭包1",a)
    #将内部函数 fn2 作为返回值返回
    return fn2
r=fn()  
r()
# 求多个数的平均值？
nums = [50,20,30,10,20]
# sum() 用来求一个列表中所有元素的和
#print("nums-平均数：",sum(nums)/len(nums))
#
def mak_fn():
    num1=[]
    def fn(n):
        #将n添加列表num1
        num1.append(n)
        #求平均值
        return sum(num1)/len(num1)
    return fn

r2 = mak_fn()
print(r2(50))
print(r2(10))
print(r2)

装饰器

def add(a,b):
    return a+b

def new_add(a,d):
    print("计算开始....")
    r = add(a,d)
    print("计算结束")
    return r

print(new_add(1,2))
'''
上边的方式，已经可以在不修改源代码的情况下对函数进行扩展了
但是，这种方式要求我们每扩展一个函数就要手动创建一个新的函数，实在是太麻烦了
为了解决这个问题，我们创建一个函数，让这个函数问以自动的帮助我们生产函数
'''
def new_old(old):
    '''
    用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束
参数：
     old要扩展的函数对象
    '''
    def new_fn(*args,**kwargs):   # 封包
        print("开始执行...")
        r = old(*args, **kwargs)   #解包
        print("执行结束....")
        return r
    return new_fn
'''
像 new_pld() 这种函数我们就称它为装饰器
通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
在开发中，我们都是通过装饰器来扩展函数的功能的
'''

r = new_old(add)
print(r(2,5))

def new_old1(old):
    '''
    用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束
参数：
     old要扩展的函数对象
    '''
    def new_fn(*args,**kwargs):   # 封包
        print("new_old1开始执行...")
        r = old(*args, **kwargs)   #解包
        print("new_old1执行结束....")
        return r
    return new_fn

'''
在定义函数时，可以通过@装饰器，来使用指定的装饰器，来装饰当前的函数
可以同时为一个函数指定多个装饰器,这样的话  函数会由内向外的顺序依次被装饰（从离函数最近的装饰器开始 ）
'''
#装饰器用法
@new_old1
@new_old
def hello_word():
    print('hello word!!')

hello_word()