Python函数基础

1 函数存在的意义

• 1,减少重复的代码

• 2,可读性强

• 3,以功能为导向

• 4,函数里面形参和实参

1.1 函数语法

'''
def 函数名(参数1,参数2,参数3,...):
    注释
    函数体
    return 返回的值
什么时候该有返回值？
　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
　　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
什么时候不需要有返回值？
　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
　　　　通常无参函数不需要有返回值
'''

def fun():
    return 1

print(fun())

1.2  函数参数

'''
#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型

#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs
'''

#*args
def fun_args(x,y,*args):
    print(x,y)
    print(args)

fun_args(1,2,3,4,5,6)    #多余的位置参数会放到一个元组中

def fun_args(x,y,*args):
    print(x,y)
    print(args)

fun_args(1,2,*[3,4,5,6]) #会打散放到一个元组中


#**kwargs
def fun_kwargs(a,b,**kwargs):
    print(a,b)
    print(kwargs)

fun_kwargs(a=1,b=2,c=3)                     #多余的关键字参数会存入到一个字典中

def fun_kwargs(a,b,**kwargs):
    print(a,b)
    print(kwargs)

fun_kwargs(a=1,b=2,**{"c":3,"d":4})         #会打散字典存入到一个字典中

def fun_args_kwargs(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)

fun_args_kwargs(1,2,3,4,5,a=1,b=2,c=3)

1.3 函数嵌套　　

#替代if
def fun1():
    return 1
def fun2():
    return 2

dic={
    "fun1":fun1,
    "fun2":fun2,
}

choice=input("your choice>>:").strip()
if choice in dic:
    print(dic[choice]())
#
# #比较大小
def my_max(x,y):
    return x if x >y else y

print(my_max(1,2))

def my_maximum(a,b,c,d):
    res=my_max(a,b)
    res1=my_max(res,c)
    res2=my_max(res1,d)
    return res2

print(my_maximum(1,2,3,4))

x=100
def fun1(): 
    #global x 加上则全局变量更在在fun1函数中,fun2的x不生效
    x=1    
    print(x)
    def fun2():
        x=2
        print(x)
    fun2()
    print(globals())   #显示所有的全局变量
    print(locals())    #显示所有的局部变量

fun1()
print(x)

1.4 闭包函数　　

#内部函数包含对外部作用域而非全局作用域的引用
#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇
#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

from urllib.request import urlopen

def index(url):
    def get():
        return urlopen(url).read()

    return get

baidu = index('http://www.baidu.com')
print(baidu().decode('utf-8'))

1.5 装饰器

#内部函数包含对外部作用域而非全局作用域的引用
#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇
#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

from urllib.request import urlopen

def index(url):
    def get():
        return urlopen(url).read()

    return get

baidu = index('http://www.baidu.com')
print(baidu().decode('utf-8'))


#装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。
#强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式
#装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能
#开放封闭原则：对修改封闭，对扩展开放


import time

def timer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        func()
        end_time=time.time()
        res=end_time-start_time
        return res
    return wrapper

@timer
def fun1():
    time.sleep(1)
    print("fun1:sleep 1")

@timer
def fun2():
    time.sleep(2)
    print("fun2:sleep 2")

@timer
def fun3():
    time.sleep(3)
    print("fun3:sleep 3")

fun1()
fun2()
fun3()