Python基础四

函数基础

1. 函数关键字
关键字是python内置的，具有特殊意义的标识符，自定义标识符命名时不可与之重复。

import keyword
print(keyword.kwlist)

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

2. 函数的定义
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。可以自己定义一个函数。

–函数-封装了独立功能，可以直接调用

–函数名(参数)

以下是简单的定义规则：

1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4.函数内容以冒号起始，并且缩进。
5.return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

3. 函数参数与作用域

#1.默认参数
def inc(init,step=1 ):
    return init + step
#调用这个函数
r=inc(3)
s=inc(3,2)
print(r,s)

#默认参数必须指向不变对象
def add_end(l=[]):
    l.append("END")
    return l
d=add_end([1,2,3])
print(d)
h=add_end()
t=add_end()
n=add_end()
print(h)

#修改上面的例子，可以用None这个不变对象来实现
def add_end(l = None):
    if l is None:
        l= []
    l.append("END")
    return l
y = add_end([4,5,6])
print(y)

#2.位置参数
def power(x):
    return x*x
print(power(5))

def power(x,n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

#3.关键字参数
def person(name , age , **kwargs):
    print("name:",name, "age:",age,"other:",kwargs)
per = person("liu",25)
p = person("li",44,city="xi'an")
print(per)
print(p)

#先组装一个dict,然后，把dict装换为关键字参数传入进去：
kwargs = {"city":"bj","job":"test"}
e = person("wang",23,**kwargs)
print(e)

#4.位置参数和关键字参数----可以共存，但是关键字参数必须写到位置参数之后
def minus(x,y):
    return x-y
minus(3,5)      #位置参数，位置传参
minus(x=3,y=5)  #关键字参数，关键字传参


#5.可变位置参数---用*定义，在函数体内，可变位置参数是一个元组。、
def fn(*args):
    print(args)

q = fn((1,2,3,4))
print(q)

tup1 = (1,2,3,4)
fn(tup1)

fn(*tup1)

#可以定义可变参数，
def cacl(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

nums = [1,2,3]
m = cacl(*nums)
print(m)

#6.可变关键字参数----使用**定义，可变关键字参数是一个字典.

def fn(**kwargs):
    print(kwargs)

dict01 = {"name":"liu","age":28}
fn(**dict01)

def fn(*args,**kwargs):
    print(args)
    print(kwargs)

fn(1,2,3,a=1,b=2)

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

fn(1,2,x=3,y=4)


#7.参数组合---参数定义的顺序：必选参数、默认参数、可变参数、关键字参数
def func(a,b,c=0,*args,**kwargs):
    print("a=",a,"b=",b,"c=",c,"args=",args,"kwargs=",kwargs)

func(1,2,3,"a","b",x=99)

#通过一个tuple和dict,也可以调用该函数
args = (1,2,3,4)
kwargs = {"x":99}
func(*args,**kwargs)


#8.参数解构
def fn(a,b,c):
    print(a,b,c)
lst = [1,2,3]
fn(lst[0],lst[1],lst[2])

fn(*lst)     #这种做法叫参数解构

d = {"a":1,"b":2,"c":3}    #字典解构
fn(**d)
#**可以把字典解构成关键字参数

def fn(a,b,c,d):
    print(a,b,c,d)

fn(0,*[2],c=1,**{"d":3})

#9.参数槽（keyword-only参数）

def fn01(*,x=1,y=5):
    print(x)
    print(y)
fn01()

def fn02(x=1,*,y):
    print(x)
    print(y)
fn02(y=3)

#总结：
# *args是可变参数，args接收的是一个tuple;
# **kwargs是关键字参数，kwargs接收的是一个dict;
# 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；
# 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kwargs传入：func({'a': 1, 'b': 2})

函数作用域：

1、作用域
    如果一个变量在def内赋值，他被定位在这个函数内
    如果一个变量在一个嵌套的def中赋值，对于嵌套的函数来说，它非本地的
    如果在def之外赋值，他就是整个文件
2、在交互式模式下，其实是在一个名为__main__的模板内。
3、一个函数的内部的任何类型的赋值都会把一个名称划定为本地的。这包括=语句，import中的模板名称，def中的函数名称，函数参数名称等。如果在一个def中以任意方式赋值的名称，他都将对于该函数是本地的。
    注意：原处改变对象并不会把变量划分为本地变量。
4、变量名解析：LEGB原则
    1变量名引用分为三个作用域进行查找：首先是本地，然后是函数内（如果有的话），之后是全局的，最后是内置的
    2默认情况下，变量名赋值会创建或者改变本地变量
    3全局声明和非本地声明将赋值的变量名映射到模板文件的内部作用域。
    4当在函数中使用未认证的变量名时，python搜索4个作用域（本地作用域，之后是上一层次中的def或者lambda的本地作用域，之后是全局，最后是内置的）并且在第一处能找到这个变量的地方停下来，如果变量名在这个过程中没有找到则会报错。
5、内置作用域
    内置作用域仅仅是一个名为builtins内置模板，要在import builtins才能使用
    import builtins
    print(dir(builtins))
6、全局变量
    全局变量是位于模板文件内部的顶层的变量名
    全局变量如果在函数内部被赋值的话，必须经过声明
    全局变量在函数的内部不经过声明也可以被引用
7、工厂函数（闭合函数）
    一个能够记住嵌套作用变量的函数
    例如：
    def maker(N):
        def action(X):
            return X**N
        return action
    f = maker(2)
    print(f(2))  #输出9
8、这个例子需要思考：
    def f():
        a  = []
        for i in range(5):
            a.append(lambda x ;i**x)
        return a
    t = f()
    print（t[0](2)）  #输出16
    print(t[1](2),t[2](2))  #输出16,16
    解释：因为for循环结束后，i的值是4，记住这个i=4，所以当调用时，x的值才被传进来。
    解决办法是使用默认参数：
    def f():
        a  = []
        for i in range(5):
            a.append(lambda x,i=i ;i**x)  #这里的i等于这次循环时的i
        return a
    t = f()
    print（t[0](2)）  #输出0
    print(t[1](2),t[2](2))  #输出2,4
9、nonlocal使用举例
    def tester(start):
        state = start
        def nested(label):
            nonlocal state  #如果没有这个，下面的是state+=1不行的
            print(label,state)
            state+=1
        return nested

4. 函数返回值
1 没有返回值
不写return的情况下，会默认返回一个None。

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
#因为没有返回值，此时的str_len为None
print('str_len : %s'%str_len)

只写return，后面不写其他内容，也会返回None；一旦遇到return，会结束整个函数。

2.有一个返回值

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

3.有多个返回值
可以返回任意多个、任意数据类型的值。

def ret_demo1():
    '''返回多个任意类型的值'''
    return 1,['a','b'],3,4

ret1 = ret_demo1()
print(ret1)
#返回的多个值会被组织成元组被返回，也可以用多个值来接收
a,b,c,d = ret_demo1()
print(a,b,c,d)