python函数

介绍

函数是一段可重用的代码。可以通过输入的参数值，返回需要的结果，并可存储在文件中供以后使用。几乎任何Python代码都可放在函数中。Python为函数提供了强大支持。
函数的定义与调用
格式：
def 函数名(形参表):
函数体语句序列
[return 表达式] #可选项，即有的函数可以没有返回值。

函数调用

	函数名(实参表)

说明：

1. 函数必须先定义，后使用；
2. 函数名与变量名的命名规则相同，只能包含字母，数字和下划线_且不能以数字打头。

例1:
#计算圆的面积
import math

def Area():                                    #函数定义
    reads=int(input("输入圆的半径:"))
    area=math.pi*reads**2
    return area
print(Area())                                 #函数调用
#输入圆的半径:2
#12.566370614359172

函数参数

参数列表的一般顺序是，普通参数，缺省参数，可变位置参数，keyword-only参数（可带缺省值），可变关键字参数
Python通过名称绑定的机制，把实际参数的值和形式参数的名称绑定在一起，形式参数和实际参数指向内存中同一个存储空间。
向函数传递参数时，Python采用按引用传递的方式。这意味着当传递参数时，函数将使用新变量名来引用原始值。

例2：
def Add(a,b):
    return a+b                   #函数操作，计算两个数的和
x,y=99,88                        #使用新变量名向函数传参

print(Add(x,y))
#187

函数的参数类型

形式参数（定义函数时）：
普通参数，默认值参数，位置参数，关键字参数

实际参数（调用函数时）：
位置实参，关键字实参，解构实参

普通参数:

例3：
def add(x,y):
		return x + y
add(x,y)

默认参数：

函数的参数支持默认值。当某个参数没有传递实际的值时，函数将使用默认参数计算。
带默认值的参数不能位于没有默认值的参数前面。

例4：
def Test(sex,age,name="小明"):
    print(name,sex,age)

Test("男",18)                 #默认参数不用传递
Test("男",20,"小华")          #传递参数覆盖默认参数

#小明 男 18
#小华 男 20

位置可变参数(位置可变参数)

在形式参数名称前加一个星号*，则代表使用该形式参数可以接收任意多个参数，而且接收的参数将会以元组的方式组织。

例5：
    def func(*args):
         # args以元组的方式组织传入的实参
          print(args)
   func(1,2,3,4,’abc’)
#(1, 2, 3, 4, 'hello')

关键字可变参数（**）

在形式参数名称前加两个星号，则代表使用该形式参数可以接收任意多个传入的键-值对参数(关键字实参)，而且接收的参数将会以字典的方式组织。
说明：
当位置可变参数(*args)和关键字可变参数(**kwd)一起使用时候，必须先声明位置可变参数(*args),最后声明关键字可变参数(**kwd)

例6：
def func(**kwd):
    print(kwd)
	# kwd以字典的方式组织传入的关键字实参
func(name='Thomos',age=38)
#{'name': 'Thomos', 'age': 38}

Keyword-only参数，实参结构

由于args是位置可变参数，可以截获传递所有的位置实参，所以参数x不能接收到其它位置实参，这时，只能通过关键字实参的方式给x，y传值

例7：
def func(*args, x=99, y, **kwargs):
    print(x)
    print(y)
    print(args)
    print(kwargs)

func('hello','wonderful', x=3, y=5, b='KeithTt')
#3
#5
#('hello', 'wonderful')
#{'b': 'KeithTt'}

实参解构

1.给函数提供实参的时候，可以使用或者把参数解构
2.非字典类型使用解构成位置参数
3.字典类型使用解构成关键字参数

例7：
def add(*args):
    return sum(args)

print(add(1,2,3,))                      #解构元组
print(add(*[1,2,3]))                    #解构列表
print(add(*range(10)))                  #解构可迭代对象
#6
#6
#45

例8:
# 可变关键字参数解构
def city_temp(**kwargs):
    for k,v in kwargs.items():
        print(k,v)

d = {'Tom':'Python','Jack':'Java','Json':'C++'}
city_temp(**d)
#Tom Python
#Jack Java
#Json C++

全局变量与局部变量

1、作用域
如果一个变量在def内赋值，则它被定位在这个函数内，只能在这个函数内引用。
如果一个变量在一个嵌套的def中赋值，对于嵌套的函数来说，它非本地的。
如果变量字在函数名以外赋值，则它作用于这个文件。
2、在交互式模式下，其实是在一个名为__main__的模板内。
3、函数变量的查找规则,L （Local） 局部作用域>E （Enclosing） 闭包函数外的函数中>G （Global） 全局作用域>B （Built-in） 内建作用域
4、全局变量
全局变量是位于模板文件内部的顶层的变量名
全局变量如果在函数内部被赋值的话，必须经过声明(global)
全局变量在函数的内部不经过声明也可以被引用

**例1：局部变量**
def Test1(x):                          #局部作用域
    print("before change:",x)                     #这里调用的变量是y="000"
    x="Faker"
    print("after change:",x)                      #这里调用的是局部变量x="Faker"

y="000"
Test1(y)                                          #调用函数，传入参数

#before change: 000
#after change: Faker

**例2：全局变量**
week="Friday"                                   #在这里定义了一个全局变量
def change_week(week1):
    print("Today is", week1)
    global week                                  #将局部变量修改为全局变量
    week="Thursday"                              #更改之后修改变量week，即修改之后全局变量week="Friday"

change_week(week)                                #将week="Tuesday" 传入函数
print("Today is",week) 

#Today is Friday
#Today is Thursday                    #全局变量以被修改

装饰器

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。

#例3：装饰函数func()
import time
def func():
    time.sleep(3)
    print("in the func")

def test(func):                              #为函数func增加额外的功能
    Start_time=time.time()
    func()                                   
    Stop_time=time.time()
    print(Stop_time-Start_time)
    return func                              #返回func函数

func=test(func)                  
func()

#in the func
#3.0011610984802246
#in the func

#例4：装饰器传入参数，用参数组完成
import time

def timmer(func):
    def foo(*args,**kwargs):
        Starm_time=time.time()
        func(*args,**kwargs)
        Stop_time=time.time()
        print(Stop_time-Starm_time)
    return foo
@timmer                    #test=timmer(test)
def test():
    time.sleep(3)
    print("in the test")

test=timmer(test)
test()

#in the test
#3.000169038772583                      time.sleep(3)
#3.000169038772583                      Stop_time-Starm_time

匿名函数

1.Lambda函数用于创建一个匿名函数，函数名未和标识符进行绑定。
2.使用Lambda函数可以返回一些简单的运算结果。
3.格式：
lambda 变量1,变量2…:表达式
例：使用lambda定义求相反数的匿名函数
print((lambda x:-x) (-2)) #定义了匿名函数lambda x:-x
===> 2 #用于返回数组的值

函数的递归

就是函数不断调用自身的过程

Sum=0
def ADD(n):
    global Sum
    if n>0:
        Sum+=n
        return ADD(n-1)                      #调用函数ADD本身
    print(Sum)

ADD(10)
#55

实例(函数与循环实现简单日历)

input_year=int(input("请输入年份："))
input_month=int(input("请输入月份:"))

def run_ping(x):
    if (x%4==0 and x%100!=0)\
            or x%400==0:
        # print("闰年")
        return True
    else:
        # print("平年")
        return False
Sum=0
for i in range(1900,input_year):
    if run_ping(i):
        Sum+=366
    else:
        Sum+=365
# print(Sum)

for k in range(1,input_month):
    if input_month ==(1,3,5,7,8,10,12):
        Sum+=31
    elif input_month ==2:
        if run_ping(input_year):
            Sum+=29
        else:
            Sum+=28
    else:
        Sum+=30
# print(Sum)

if input_month in [1,3,5,7,8,10,12]:
    day=31
elif input_month ==2:
    if run_ping(input_year):
        day=29
    else:
        day=28
else:
    day=30
print("日\t一\t二\t三\t四\t五\t六")
count=0
for c in range((Sum+1)%7):
    count+=1
    print("\t",end="")
for m in range(1,day+1):
    print(m,end="\t")
    count+=1
    if count%7==0:
        print("\n",end="")

"""
请输入年份：2019
请输入月份:5
日	一	二	三	四	五	六
			1	2	3	4	
5	6	7	8	9	10	11	
12	13	14	15	16	17	18	
19	20	21	22	23	24	25	
26	27	28	29	30	31	
"""