Python基础知识——函数

函数

将一组语句的集合通过一个名字封装起来

特点：

1、代码重用

2、保持一致性

3、可扩展性

创建及调用：

>>> def hello():
    print("hello!")
>>> hello()
hello!

函数命名规则同变量：

1、不能包含下划线、字母、数字以外的内容

2、必须以字母和下划线开头

3、不能与保留字重复

4、区分大小写

5、描述性的单词，不要用中文或者拼音

6、驼峰式或者下划线分割

保留字查询方式及列表：

>>> from keyword import kwlist
>>> for i in kwlist:
    print(i, end=' ')

保留字列表：
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

参数：

必须参数：

>>> def info(name, age):
    print('name: %s, age: %d' % (name, age))
>>> info('Tom', 9)
name: Tom, age: 9

必须参数即为函数声明时的参数，调用时必须顺序和数量与函数声明时相同

关键字参数：

>>> def info(name, age, sex):
    print('name: %s, age: %d, sex: %s' % (name, age, sex))
>>> info(name = 'Tom', age = 18, sex = 'female')
name: Tom, age: 18, sex: female
>>> info(age = 20, sex = 'male', name = 'Jane')
name: Jane, age: 20, sex: male

参数调用顺序与函数定义时不同时，可使用关键字进行函数内索引
函数优先根据关键字对变量进行赋值，关键字即为函数定义时的形参

默认参数（缺省参数）：

>>> def info(name, age, sex = 'Female'):
    print('name: %s, age: %d, sex: %s' % (name, age, sex))
>>> info('Tom', 18)
name: Tom, age: 18, sex: Female
>>> info(age = 20, sex = 'male', name = 'Jane')
name: Jane, age: 20, sex: male

函数定义时为默认参数设置默认值，当调用时该参数未赋值则采用默认值

不定长参数：

>>> def add(*args):
    sum = 0
    for i in args:
        sum += i
    print(sum)
>>> add(1,2,3,4,5,6)
21

>通过*args参数可以输入任意数量的参数

>>> def test(*args):
    print(args)
>>> test('1', 2, 3, [4, 5])
('1', 2, 3, [4, 5])

>*args参数将输入的参数存入一个数组中

>>> def info(**kwargs):
    print(kwargs)
    for i in kwargs:
        print('%s: %s' % (i, kwargs[i]))    
>>> info(name = 'Tom', age = 18, sex = 'Female')
{'name': 'Tom', 'age': 18, 'sex': 'Female'}
name: Tom
age: 18
sex: Female

>**kwargs参数存放有映射关系的参数，并以字典的方式存储起来

>另外一种调用方式
>>> def test(*args, **kwargs):
    print(args)
    print(kwargs)
>>> test(*[1, 2], **{'name':'Tom'})
(1, 2)
{'name': 'Tom'}
>>> test(*(1, 2), *{3, 4}, **{'name':'Jane'})
(1, 2, 3, 4)
{'name': 'Jane'}

*args参数可输入任意数量的未命名参数，**kwargs可输入任意数量的已命名参数
当传入的参数必须是列表、集合、元组、字典等数据结构时，可以采用上述的调用方法
另外，对于一个不定长参数多次分别传入数据，则会被自动集合成一个元组

参数顺序：

定义时：
def function（必须参数，默认参数， *args， **kwargs）
调用时：
function（必须参数，关键字参数， *args， **kwargs）

返回值：

>>> def add(*args):
    sum = 0
    for i in args:
        sum+=i
    return sum
>>> print(add(1,2,3,4,5))
15

>>> def test():
    print('No return')  
>>> print(test())
No return
None

>>> def test():
    print('return more')
    return 'just', 'test', 1, [2,3]
>>> print(test())
return more
('just', 'test', 1, [2, 3])

return是函数的结束语句，函数遇到return则会结束并返回结果
如果函数没有return语句，则系统会默认返回None
如果有多个返回值，则默认生成元组，返回一个元组

作用域：

作用域分为四种：

>>> b = int(3.3) #Built-in
>>> g = 233  #Globa
>>> def test():
        e = 'cc'  #Enclosing
        def test1():
            l = '666'  #Local
            print(l)
        test1() 
>>> test()
666

L：local，局部作用域，即函数中定义的变量

E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的

G：globa，全局变量，就是模块级别定义的变量

B：built-in，系统固定模块里面的变量，比如int, bytearray等

>>> x = 5
>>> def test():
    print(x)
    x = 6   
>>> test()
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 5
>>> def test():
    x += 1  
>>> test()
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 5
>>> def test():
    print(x)
>>> test()
5

作用域的级别： B > G > E > L

高级别作用域的变量在低级别作用域中只有可读属性，不可修改

低级别作用域修改高级别变量时，系统默认会在低级别作用域搜索是否存在该变量，而不会去上一层作用域去搜索

如果低级别作用域不存在该变量或者在修改之后定义的该变量，则会报出定义前使用的错误

关键字：

>>> x = 5
>>> def test():
    global x
    x = 6
    print(x)    
>>> test()
6

>>> def test():
    x = 5
    def test1():
        nonlocal x
        x = 6
        print(6)
    test1() 
>>> test()
6

global关键字声明变量为全局变量

nonlocal关键字声明变量为enclosing变量

变量在声明后即可跨作用域进行修改

注：

在作用域中对变量进行搜索的顺序：
L > E > G > B，即对变量进行查找时，按这个顺序查找
作用域的形成：
在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）不会引入新的作用域

高阶函数：

>>> def f(x):
    return x
>>> def add(a, b, func):
    return f(a)+f(b)
>>> print(add(1,2, f))  #以函数作为参数被调用
3

>>> def f():
    def test():
        print("返回一个函数")
    test()
    return test() #返回时加上括号会自动执行
>>> print(f())
返回一个函数
返回一个函数
None
>>> def f():
    def test():
        print("返回一个函数")
    test()
    return test  #不加括号则返回的这个函数
>>> print(f())
返回一个函数
<function f.<locals>.test at 0x006F32B8>

高阶函数满足的条件（以下两条至少一条）：

接受一个或多个函数作为输入

输出一个函数

递归函数：

阶乘:
>>> def Fact_Recurs(n):
    if n == 1:
        return 1
    return n * Fact_Recurs(n-1)
>>> Fact_Recurs(5)
120

>>> def Fact_Iter(n):
    mux = 1
    for i in range(1, n+1):
        mux *= i
    return mux
>>> Fact_Iter(5)
120

斐波那契数列：
>>> def Fibo_Recurs(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return Fibo_Recurs(n-1)+Fibo_Recurs(n-2)
>>> Fibo_Recurs(8)
21

>>> def Fibo_Iter(n):
    before = 0
    after = 1
    temp = 0
    for i in range(1, n):
        temp = after
        after += before
        before = temp
    return after
>>> Fibo_Iter(8)
21

在函数内部调用自身的函数即是递归函数
特性：1、必须要有结束条件， 2、每进入一层递归应该能减小问题规模， 3、递归效率不高
另：相对于迭代，递归定义简单、逻辑清晰，而所有递归能解决的问题，都可以用迭代来解决

内置函数：

https://docs.python.org/3/library/functions.html 内置函数官方文档

重要的内置函数：

filter(function or None, iterable)：

>>> a = ['h', 'e', 'l', 'l', 'o']
>>> def func(s):
    if s != 'l':
        return s    
>>> ret = filter(func, a)
>>> print(ret)
<filter object at 0x02CE93F0>  #迭代器
>>> print(list(ret))
['h', 'e', 'o']

a中的元素依次执行func函数，返回一个由各个返回值组成的filter object迭代器

map(func, *iterables)：

>>> def add(x, y):
    return x+y
>>> a = [1, 2, 3, 4, 5]
>>> b = [2, 3, 4, 5]
>>> print(map(add, a, b))
<map object at 0x02D0A870>
>>> print(list(map(add, a, b)))
[3, 5, 7, 9]

将a、b两个列表里的数分别作为add函数的x、y参数进行调用

并且在某一个列表结束时结束调用，将每一个返回值组合起来形成一个map object的迭代器返回

reduce(function, sequence[, initial])：

>>> from functools import reduce
>>> def add(x, y):
    return x+y

>>> print (reduce(add, range(1, 10)))
45
>>> a = [2, 4, 6, 8]
>>> print(reduce(add, a))
20

使用前需导入模块

将一个序列中的元素对函数进行反复调用，例如a中2+4的值6又与6一同做参数调用add

返回一个最终的返回结果

匿名函数lambda：

>>> add = lambda a, b : a + b
>>> print(add（2, 3）)

命名规则：用lamdba 关键字标识，冒号（：）左侧表示函数接收的参数（a,b） ,冒号（：）右侧表示函数的返回值（a+b）

lambda后只能由一个表达式，该表达式即作为函数的返回值

posted @ 2018-03-07 09:06 Clingyu 阅读(88) 评论(0) 收藏举报

刷新页面返回顶部

Clingyu