（6）python 之 函数 详解

1.定义

函数python中最重要、最基础的代码组织和代码复用方式；函数声明时使用def，返回时用return

如达到函数尾部时仍没有return，就会自动返回none

方法定义 例子：

def my_function(x, y, z=1.5): 
    if z > 1: 
        return z * (x + y) 
    else: 
        return z / (x + y)

调用例子：

my_function(5, 6, z=0.7)
my_function(3.14, 7, 3.5)

my_function(10, 20)

2 命名空间、作用域和本地函数

函数内部的任意变量默认分配到本地命名空间。被调用时生成，函数执行完毕后销毁

方法内部变量：

def func():

   a = []

   for i in range(5):

      a.append(i)

外部变量

a = []

def func():

   for i in range(5):

      a.append(i)

a = None
def bind_a_variable():
    global a
    a = []
bind_a_variable()
print(a)

在函数外部给变量赋值是可以的，但是必须使用 global关键字声明为全局变量

如果大量使用了全局变量。可能表明需要使用面向对象编程（使用类）

3 返回多个值

函数中可以返回多个值，例如：

def f():
    a=5
    b=6
    c=5
    return a,b,c
aa, bb, cc = f()
aa

return_value = f()

def f():
    a=5
    b=6
    c=5
    return {'a':a,'b':b,'c':c}
aa, bb, cc = f()
bb

 

4 函数是对象，也可作为参数

4.1 常见场景 数据清洗:

将凌乱的数据规整成标准数据，结合标准库中的正则表达式

states = ['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda',
          'south   carolina##', 'West virginia?']
import re
def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip() #去空格
        value = re.sub('[!#?]', '', value) #正则表达式：特殊符号替代为空
        value = value.title() #字符首字母大写
        result.append(value)#循环追加结果
    return result
clean_strings(states)

4.2 函数优化- 函数作为参数传递：

def remove_punctuation(value):
    return re.sub('[!#?]', '', value)

clean_ops = [str.strip, remove_punctuation, str.title] #作为处理管道

def clean_strings(strings, ops): #strings需要处理的数据; ops传递的函数数组
    result = []
    for value in strings:
        for function in ops:  #循环获取数据处理的函数
            value = function(value)
        result.append(value) #处理后追加至数组中
    return result
clean_strings(states, clean_ops)

4.3 函数作为参数，传递给其他函数

如内建的map函数：

for x in map(remove_punctuation, states):
    print(x)

 5 匿名 lambda 函数

匿名函数是一种通过单个语句生成函数的方式，其结果是返回值，使用lambda关键字定义格式：

赋值后的变量=lambda x（处理变量）: x * 2  （处理逻辑）

常见场景举例：

正常的函数：

def short_function(x):

  return x * 2

lambda函数：

equiv_anon = lambda x: x * 2 

推导式：

[x * 2 for x in ints]

生成器：

（x * 2 for x in ints）

lambda函数 代码量少，将函数赋值给局部变量，作为参数传递

def apply_to_list(some_list, f):

#定义函数，入参some_list需的处理数据；f另处理逻辑的函数，也可以是lam
    return [f(x) for x in some_list]
ints = [4, 0, 1, 5, 6]
apply_to_list(ints, lambda x: x * 2) 

作为参数，传递给sort
strings = ['foo', 'card', 'bar', 'aaaa', 'abab']
strings.sort(key=lambda x: len(set(list(x))))
strings

 6 柯里化：部分参数应用

通过部分参数应用方式从已有的函数中衍生出新的函数

把柯里化函数做成嵌套函数，外层函数的返回值是内层函数，这样，外层函数调用完，返回的是一个函数，然后能接着调用

理解样例:

def add(x,y):
    return x + y
print(add(1,2))

柯里化：

def add_currying(x):
    def _add(y):
        return x + y
    return _add
print(add_currying(1)(2))
# 输出：3

常见使用场景：

add_five = lambda y: add(5, y)

样例1：

from functools import partial

add_five = partial(add, 5) #5为固定值，也是add(x,y) 柯里化了，后续只需用新函数传入一个入参

样例2：

from functools import partial

def foo(a,b,c):

    return a+b+c

foo2 = partial(foo, b=2) #固定值：b=2，返回新foo2，后面调用时，仅需传入a和b的值

foo2(a=1, c=3)

注解：fun_new=partial(fun,x) 

调用fun函数，固定传入其中参值x，返回新函数fun_new，再调用时，仅需传入其他函数

参考链接：

(7条消息) python partial函数_笨小孩的博客-CSDN博客

7 生成器 

样例：（x * 2 for x in rang(100)）

7.1 定义

通过一致的方式遍历序列，如列表中的对象或文件中的一行行，通过了迭代器协议实现的

some_dict = {'a': 1, 'b': 2, 'c': 3}
for key in some_dict:
    print(key)

some_dict生成了迭代器，大部分以列表或列表对象为参数的方法，可接受任意的迭代器对象

包括内建方法如min、max、sum及类型构造函数如list、tuple：

dict_iterator = iter(some_dict)
dict_iterator
list(dict_iterator)

生成器是构造新的可遍历对象的一种简洁方式，普通的函数执行并一次返回单个结果，而生成器则惰性地返回一个多结果的序列，基本方式，将函数的return替代成 yield

def squares(n=10):
    print('Generating squares from 1 to {0}'.format(n ** 2))
    for i in range(1, n + 1):
        yield i ** 2
gen = squares() #实际调用生成器时，代码不会立即执行
gen
for x in gen: #直到直接访问生成器中的元素，才会执行代码
    print(x, end=' ')

 7.2 生成器表达式

用生成器表达式来创建生成器，与推导式类似，将中括号换成小括号
常见例子：(x+2 for x in range(10))
作为入参可以去掉省略括号：如 sum(x+2 for x in range(10))

将上面的代码等同，如下：
gen = (x ** 2 for x in range(10))
gen

sum(x ** 2 for x in range(100))
dict((i, i **2) for i in range(5))

 7.3 itertools  模块

此模块使用于大多数数据算法的生成器集合，如groupby

据任意的序列和一个函数，通过函数的返回值对序列中连续的元素进行分组

import itertools
first_letter = lambda x: x[0]
names = ['Alan', 'Adam', 'Wes', 'Will', 'Albert', 'Steven']
for letter, names in itertools.groupby(names, first_letter):
    print(letter, list(names)) # names is a generator

常用的itertools模块的函数：

combinations(iterable,k) :创建一个迭代器，返回iterable中所有长度为r的子序列

import itertools
list1 = [1, 3, 4, 5]
list2 = list(itertools.combinations(list1, 2))
print(list2)

返回结果：
[(1, 3), (1, 4), (1, 5), (3, 4), (3, 5), (4, 5)]

combinations_with_replacement:表示允许元素在子集中重复的所有可能的布置或子集

permutations(iterable,r):连续返回由 iterable 元素生成长度为 r 的排列

import itertools
nums = ['a','b','c']
for num in itertools.permutations(nums):
    print(num)
输出：
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')

 product(list1,list2):返回list1和list2中的元素组成的笛卡尔积的元组

本篇知识点参考《利用python进行数据分析》，更多知识请阅读原书