流畅的python 函数

列表推导：

通常只用列表推到来创建新的列表，且尽量简短，它的作用只有一个，就是生成列表，生成其他序列就要用到生成器表达式了。

a = range(10)
b = [x*x for x in a]   # 列表推导式
print(b)

生成器表达式:

虽然列表推导可以创建元组，数组，或其他序列类型，但生成器表达式是更好的选择。生成器表达式背后遵循了迭代器协议，可以逐个的产出元素，而不是先建立一个完整的列表。写法与列表推导式非常的相似：

# 生成器表达式
a = range(10)
b = (x*x for x in a)   # 生成器表达式
print(tuple(b))

列表推导与生成器表达式对比：

colors = ['white', 'black', 'red']
sizes = ['S', 'M', 'L']
# 列表推导
for x in [(color, size) for color in colors for size in sizes]:
    print(x)

# 生成器表达式
for x in ((color, size) for color in colors for size in sizes):
    print(x)

用了声称其表达式后，内存里不会留下一个有9个组合的列表，因为生成器表达式只有每次执行for循环时才会产生一个元素。

但是列表推导首先会新建一个列表。

将函数视作对象：

# 定义函数
def factorial(n):
    """
    定义函数计算n的阶乘
    :param n:
    :return:
    """
    return 1 if n<2 else n*factorial(n-1)


# 将函数视作对象
fact = factorial
print(fact(10))

# 函数作为参数传递
a = range(10)
b = map(factorial, a)
print(list(b))

高阶函数：接收函数为参数或者将函数作为结果返回的函数叫做高阶函数，例如map()函数

tp = ["apple", 'peaches', 'holland', 'newspaper_stand']
tpp = sorted(tp, key=lambda x: len(x))
print(tpp)


def reverse(word):
    """
    逆序输出
    :param word:
    :return:
    """
    return word[::-1]


tpp = map(reverse, tp)
print(list(tpp))

常用的高价函数：map(), filter(), reduce(),函数式语言通常会提供这三个高阶函数

for x in map(factorial, range(10)):
    print(x)
for x in filter(lambda x: x % 2 == 0, range(20)):
    print(x)

python3中map()，filter()函数返回的是生成器！

from functools import reduce
from operator import add       # add(x,y)函数
print(reduce(add, range(100)))

sum(),  reduce()函数的通用思想是把某个操作连续运用到序列的元素上，累计之前的结果，把一系列值规约为一个值

all(iter),  any(iter)函数

匿名函数：

lambda表达式。一般作为参数传递给高阶函数

可调用对象：

判断对象是否可调用print(callable(factorial))

python数据模型指出七种可调用的类型:

1.用户自定义函数    def

2.内置函数

3. 内置方法

4. 方法       类中定义的函数

5. 类

6. 类的实例

7. 生成器函数

从定位参数到仅限关键字参数：

python提供了极为灵活的参数处理机制：调用*和**展开可迭代对象，映射到单个参数

def tag(name, *content, cls=None, **attrs):
    if cls is not None:
        attrs['class'] = cls
    if attrs:
        attr_string = " ".join(' %s="%s"' % (key, value) for key, value in attrs.items())
    else:
        attr_string = ''

    if content:
        return '\n'.join('<%s%s>%s<%s>' % (name, attr_string, c, name) for c in content)
    else:
        return '<%s%s />' % (name, attr_string)

对函数的调用：

print(tag("br"))   # 传入单个定位参数
print("-"*30)
print(tag('p', 'hello'))  # 第一个后面的人一个参数会被content捕获,存入元组
print('-'*30)
print(tag('p', 'hello', 'world'))  # 第一个后面的人一个参数会被content捕获,存入元组
print('-'*30)
print(tag('p', 'hello', 'world', cls='sidebar'))   # cls只能作为关键字参数传入
print('-'*30)
print(tag('p', 'hello', 'world', id=23, href='http://sina.com', cls='sidebar'))

调用的结果：（函数的参数收集）

 

operator模块:

operator模块为多个算术运算符提供了对应的函数，从而避免在一些地方写匿名函数：
例如计算阶乘：

from functools import reduce
def fact1(n):
    return reduce(lambda x, y: x*y, range(1, n+1))
print(fact1(10))

为了避免写lambda这样的匿名函数：

from functools import reduce
from operator import mul
def fact1(n):
    return reduce(mul, range(1, n+1))
print(fact1(10))

operator模块中itemgetter和attrgetter函数：能替代从元素中取出元素或者读取对象属性的lambda表达式:
lambda  x: x[n] 或者lambda x: x["attr"]

例如：

person_data = [('Ann', 34, 'boy', 'student'),
               ('Tom', 23, 'boy', 'doctor'),
               ('Liky', 21, 'girl', 'sailor'),
               ('Kate', 19, 'girl', 'queen')]
for x in sorted(person_data, key=lambda x: x[1]):
    print(x)

可以写为：

from operator import itemgetter
person_data = [('Ann', 34, 'boy', 'student'),
               ('Tom', 23, 'boy', 'doctor'),
               ('Liky', 21, 'girl', 'sailor'),
               ('Kate', 19, 'girl', 'queen')]
for x in sorted(person_data, key=itemgetter(1)):
    print(x)

输出结果：

将多个值传递给itemgetter,它构建的函数会返回提取的值构成的元组：

from operator import itemgetter
cc_person = itemgetter(0, 2, 3)
person_data = [('Ann', 34, 'boy', 'student'),
               ('Tom', 23, 'boy', 'doctor'),
               ('Liky', 21, 'girl', 'sailor'),
               ('Kate', 19, 'girl', 'queen')]
for x in person_data:
    print(cc_person(x))

返回值：

attrgetter和itemgetter函数类似，它创建的函数根据名称提取对象的属性，同样也可以将多个属性传递给它：

这里会用到具名元组namedtuple:

from operator import itemgetter
from operator import attrgetter
from collections import namedtuple
person_data = [('Ann', 34, 'boy', 'student', (23.4, 90.5)),
               ('Tom', 23, 'boy', 'doctor', (12.3, 56.1)),
               ('Liky', 21, 'girl', 'sailor', (21.8, 98.1)),
               ('Kate', 19, 'girl', 'queen', (32.1, 89))]

LatLong = namedtuple('LatLong', ['lat', 'long'])  # fieldname参数可以是列表
people = namedtuple('people', 'name age sex occupation coord')   # feildname参数也可以是这样
people_list = [people(name, age, sex, occupation, LatLong(lat, long)) for
               (name, age, sex, occupation, (lat, long)) in person_data]
# 具名元组的访问
print(people_list[0])
print('-'*30)
print(people_list[1].occupation)   # 通过 . 运算符访问具名元组的元素
print('-'*30)
print(people_list[2].coord.long)
print('-'*30)
for x in sorted(people_list, key=attrgetter('age')):
    print(x)
print('-'*30)
name_lat = attrgetter('name', 'coord.lat')
for x in sorted(people_list, key=attrgetter('age')):
    print(name_lat(x))

注意具名元组的使用！

运行结果：

methodcaller()函数，会在对象上调用参数值指定的方法：

from operator import methodcaller
s = 'hello world'
uppercase = methodcaller('upper')
print(uppercase(s))
replacement = methodcaller('replace', ' ', '-')
print(replacement(s))

functools.partial冻结参数：

# 冻结tag()函数的部分参数
from functools import partial
picture = partial(tag, 'img', cls='pic-frame')   # 冻结tag()函数的定位参数以及cls参数
print(picture('pict1', 'pict2'))
print('-'*30)
print(picture('pict1', 'pict2', src='www.xxx.com'))

partial函数对于函数的部分参数进行了冻结，再调用的我们只需要关心我们需要改变的参数即可

--------------------------------------------------------------------------------------------------