Python 函数

函数

1.引子：

求和

def sum(x,y):
    sum1 = 0
    if x <= y:
        for i in range(x, y+1):
            sum1 += i
    return(sum1)
print(sum(2,5))
>>>和为 14

程序而言：函数就是对程序逻辑进行结构化或者过程话的一种编程方法。

bulit- in function 内置函数——>BIF

2.函数的定义

声明函数的一般形式

def function_name(arg1,arg2, ... ,argn):   #def(define)
    '''statements'''
    func_statements
    return Value

def add(x,y):
    '''求和'''
    return x+y
print(add.__doc__)
>>>求和

3.函数调用

4.函数文档说明

5.函数参数

• 不传参函数
• 传参函数
  • 顺序：位置要在赋值前，同为赋值参数时顺序可以颠倒

6.函数返回值

7.函数参数种类

形参和实参

• 形参
  • 只有在调用时才分配内存单元。调用结束后，即释放所分配的内存单元。因此，形参只在函数内部有效，函数调用结束返回主调用函数后则不能再使用该形参变量。
• 实参
  • 实参是一个确定的值，能够传递给形参
    • 作为位置参数或者关键字参数传递

7.1 位置参数

def user(name, age, job, hobby):  
    print("用户管理系统".center(16, '-'))
    print("\tName:\t", name)
    print("\tAge:\t", age)
    print("\tJob:\t", job)
    print("\tHobby:\t", hobby)
    print("用户管理系统".center(16, '-'))
user('tom', 18, 'stu', 'play')

只传递实参，位置一一对应 ——> 位置参数

使用位置参数时和函数头定义的实参、个数以及类型上匹配。

7.2 默认值参数

def user(name, age, job, hobby='Trip'):
    print("用户管理系统".center(16, '-'))
    print("\tName:\t", name)
    print("\tAge:\t", age)
    print("\tJob:\t", job)
    print("\tHobby:\t", hobby)
    print("用户管理系统".center(16, '-'))
user('tom', 18, 'stu')

默认值参数（数字），关键字参数（字符串），必须放置于位置参数之后。

7.3 不定参数

在Python中不定参数主要是指*args(返回元祖)和**kwrgs(返回字典)两个魔法变量。

他们主要用于函数定义，我们可以将不定数量的参数传递给一个函数。

• *args用来接收任意非键值对的参数并返回元组
• **kwargs`用来接收不定长的键值对（双参数变量）并返回字典

8.函数引用

9.函数属性

函数属性是python中另外一个使用了句点属性标识并拥有名字空间的领域。

python -i day01.py 进入解释器同时打开

def foo():
    'foo() --- Properly created doc string.'

def bar():
    pass
bar.__doc__ = "Oops, forget the doc str above"
bar.version = 0.1

10.内嵌函数

作用域

bar()整个函数都处于外部foo()函数的作用域里（foo()是我们可以从外部访问的一个对象区域）。除了在foo()内部，其他地方无法对bar()进行调用。

11.变量作用域

11.1 作用域的产生

就作用域而言，python和C有很大差别，只有当变量在module、class、函数中定义时，才有作用域的概念。

def foo()
    a = 'foo'
    print(a)
foo()
print(a)  #报错

在作用域中定义的变量，一般只在作用域内有效。需要注意的是，在if-elif-else，for - else，while-else，try - except(else - finally)等关键字的语句块中不会产生作用域。（即外部可引用）

11.2 作用域的类型

Python中，使用一个变量时并不要求预先声明。但在真正使用时，必须绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在当前作用于引入新的变量，同时屏蔽外层作用域中的同名变量。

• 局部作用域（locate — L）

• 嵌套作用域（enclosing — E）

  • E也包含在def 关键字中，E和L是相对的，E相对于跟上层的函数而言也是L。与L的区别在于，对于一个函数而言，L是定义在此函数内部的局部作用域。

  • 主要为了实现Python的闭包，而增加的实现。

• 全局作用域（Global —G）

  即在模块层次中定义的变量。模块顶层申明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性。

• 内置作用域（built-in — B）

  • 系统固定模块中定义的变量。

搜索变量名的优先级：局部作用域 > 嵌套作用域 > 全局作用域 > 内置作用域

11.3 全局变量和局部变量

gbl_str = 'foo'
def foo():
    loc_str = "bar"
    return gbl_str +loc_str
print(foo())
print(loc_str)

在函数内部部分引用全局变量需要先定义，但如果完全引用全局变量则不用定义：

a = 6688
def foo():
    print("foo(),a:", a) #报错，a没有定义
    a = 888
    print("foo(),a:", a)

def bar():
    print("bar(),a:", a)
foo()
bar()

11.4 全局变量global

a = 6688
def foo():
    a = 666
    def inner_foo():
        global a
        print('a=', a)
        a = 888
        print('a=', a)
    inner_foo()
    print('foo()', a)
print(a)
print(foo())
>>>6688
>>>a= 6688
>>>a= 888
>>>foo() 666

11.5 可变类型的全局变量

类似列表的可变的数据类型，可在定义的函数中直接添加

li = ['a','b']
def foo():
  li.append('c')
  print(li)
foo()

12 其他函数

12.1 递归函数

在一个函数体内部，调用这个函数本身

def sum(n):
        if n == 1:
            return 1
        elif n == 2:
            return 1
        else:
            return sum(n-1) + sum(n-2)
print(sum(5))
>>>5

12.2 匿名函数(lambda)

格式：

lambda paral,para2,....,paraN:expression using paras（定义函数表达式）
f =lambda x,y,z:x+y+z #参数可以有默认值，可以定义多个参数
print(type(f))
print(f(1,2,3))
>>><class 'function'>
>>>6

12.3 高阶函数

li = ['zhejiang', 'University', 'City', 'College']
def filter(para):
    ret = []
    for i in para:
        if not i.startswith('C'):
            ret.append(i)
    return ret
print(filter(li))

def filter_1(para):
    ret = []
    for i in para:
        if not i.endswith('ty'):
            ret.append(i)
    return ret
def delete(a,b,c):
    return c(b(a))
print(delete(li,filter,filter_1))
>>>['zhejiang']

12.4 过滤函数(filter)

功能：

• 过滤掉序列中不符合函数条件的元素，当序列中需要保留的元素可以用某些函数描述时，就应该想到filter函数

• filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 **list()**来转换。

• 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

调用格式：

filter(function,sequence)

function :可以是自定义的函数，也可以匿名函数

sequence: 列表，元组，字符串

def num(n):
    if str(n) == str(n)[::-1]:
        return n
f = filter(num,range(101))
print(list(f))
>>>[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99]

12.5 map 映射

功能：

• 求一个序列或者多个序列进行函数映射后的值。(用list()强转)

x = [1, 2, 3, 4, 5]
y = [2, 3, 4, 5, 6]
f1 = map(lambda x, y: x*y, x, y)
print(list(f1))
>>>[2, 6, 12, 20, 30]

12.6 reduce函数

功能

• 对一个序列进行压缩运算。得到一个value。
• python2中，reduce()是内置函数，而现在，py3中，他被一直到functools模块中
• from functools import reduce

格式

• reduce(function, iterable, [initial])
  • function必须要传入两个参数
  • Iterable ——>列表/元组

from functools import reduce
y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: x+y, y)
print(z)                         #累加
>>>20

y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: x*y, y)
print(z)                         #阶乘
>>>120

y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: 10*x+y, y)
print(z)
>>>23456

12.7 apply函数

功能：

• pandas中，应用对象是pandas中的Dataframe或者Series
• 直接对DataFrame或者Series应用函数
• 对pandas中groupby

import numpy as np
import pandas as pd
a = np.random.randint(low=0, high=4, size=(2, 4))
print(a)
>>>[[1 3 1 3]
>>> [0 3 1 0]]

12.8 zip函数

功能：

• 将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由这些元祖构成的对象。
• 长度不一样的时候，以长度短的为准。

注：

利用*号操作符，与zip相反，进行解压。

格式

zip(iterable1, iterable2, …)

iterable：两个或多个可迭代序列（字符串，列表，元祖，字典）

• py2，返回的是由元组组成的列表
• py3，返回的是一个对象，如果需要得到列表，需要list()强转

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
ziptest = zip(b, c)
for i in ziptest:
    print(i)
>>>(4, 4)
>>>(5, 5)
>>>(6, 6)
print(list(ziptest))
>>>[(4, 4), (5, 5), (6, 6)]

star_zip = zip(*ziptest)
print(list(star_zip))
>>>[(4, 5, 6), (4, 5, 6)]