【python】函数

#1.形参和实参
#对于以下例子来说:
#Name作为形参充当变量名,其实际的值作为实参
def Fun(Name):
    print(Name)
Fun("HHZ")

#2.函数文档
#作为函数的一部分存储起来,其功能和注释一样
#可以通过 __doc__ 或者 help() 来访问
def Print_Fun(Name):
    """
    print ( "Name" )
    :param Name:
    :return: None
    """
    print('"'+ Name + '"' )
Print_Fun("Tom")
print( Print_Fun.__doc__ )
help( Print_Fun )

#3.默认参数
def say( name = "Tom" , words = "I Love Python"):
    print( name + ' -> ' + words )
say()
say("Jerry" , "I Love C++")

#4.收集参数
#把参数个数设为默认参数
#params称作可变参数

def Test( *params , n = 0 ):
    print("%d个参数:"%n )
    for i in range(n):
        print( params[i] , end='
')
Test()
Test(1,2,4,n=3)
a = ['a','b','c']
Test( *a , n = len(a) )

#5.函数返回值
#通过以下例子可说明返回值为:None
#Python中所有的函数都是有返回值的
def Hello():
    print("Hello")
print( Hello() )

#6.函数的作用域
#对于以下例子:
#a)在函数Discount中局部变量t不能在函数外访问
#其原理:Python在运行函数的时候,利用栈(Stack)进行存储,当执行完该函数后,函数中的所有数据都会被自动删除。
#所以函数外部无法访问到函数内部的局部变量

def Discount(price , rate ):
    t = price * rate
    return t
old_price = 100
rate = 0.8
new_price = Discount(old_price,rate)
print(new_price)
#报错 print(t)

#b)函数内能访问全局变量,但不能直接修改
#python中屏蔽机制(Shadowing)保护全局变量,
# 一旦函数内部试图修改全局变量,
# python就会在函数内部自动创建一个名字一模一样的局部变量,
# 这样结果不会影响到全局变量
# 若要修改则需要在函数内加global关键字
cnt = 5
def myFun():
    global cnt
    cnt = 10
    print(cnt)
myFun()
print(cnt)

#7.内嵌函数
#python是允许在函数中定义函数
#同时也受作用域的限制
#即外部不能直接调用函数里的函数

def fun1():
    def fun2():
        print("Fun2")
    print("Fun1")
    fun2()

fun1()

#8.闭包(closure)
#如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,
#那么内部函数被认为是闭包(closure)
def funX(x):
    def funY(y):
        return x * y
    return funY

#若内部函数向修改外部函数里的局部变量的值,使用nonlocal进行声明
def funX():
    x = 5
    def funY():
        nonlocal x
        x *= x
        return x
    return funY

print(funX()())

#9.lambda表达式
#Python允许使用lambda关键字来创建匿名函数
#lambda使代码更加精简,不需要考虑命名问题,简化代码的可读性.
g = lambda x : 2 * x + 1
print( g(5) )

g = lambda x , y : x + y
print( g(1,2) )

#10.BIF ->  filter() & map()
#filter( function or none , iterable )
#第一个参数可以是函数,第二个可迭代数据里每一个元素将作为函数的参数进行计算
#返回的是filter类型

#例一,筛选为真的数
temp = filter( None , [ 1 , 0 , True , False ] )
print( type(temp) )
print( list(temp) )

#例二,筛选奇数
def odd(x):
    return x % 2
temp = filter( odd , range(10) )
print( list(temp) )

temp = filter( lambda x : x % 2 , range(10) )
print( list(temp) )

#map( function or none , iterable )
#第一个参数可以是函数,第二个可迭代数据里每一个元素将作为函数的参数进行计算
#返回的是map类型

print( list( map( lambda x : x * 2 , range(10) ) ) )

#11.递归函数
#限制递归函数为1e6层
import sys
sys.setrecursionlimit( 1000000 )

#a)递归写阶乘函数
def fac(n):
    if n == 1 :
        return 1
    else :
        return n * fac( n - 1 )
#number = int( input("输入一个数"))
number = 5
print( fac(number) )

#b)汉诺塔问题
def hanoi( n , x , y , z ):
    if n == 1 :
        print( x , ' --> ' , z )
    else:
        hanoi( n-1 , x , z , y )
        print( x , ' --> ' , z )
        hanoi( n-1 , y , x , z )
n = 3
hanoi( n , 'A' , 'B' , 'C' )