1. lambda 匿名表达式

类似于定义函数

#lambda 表达式（匿名表达式）
#定义求和函数
def_sum = lambda x, y: x + y
print(def_sum(2, 5))

D:\Anaconda\python.exe E:/project/python_math/python_math.py
7

2. map函数

map函数，映射，对所有的元素进行相同的操作，注意返回的是个object，要打印出结果的话需要类型强制转换。

#map函数，映射，对所有的元素进行相同的操作
x_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#利用map对所有的元素进行乘方
result = map(lambda x: x**2, x_list)
print(list(result))#利用map将所有元素变成浮点数
result = map(lambda x: float(x), x_list)
print(list(result))

[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

3. filter函数

fileter函数，对序列进行过滤，输入的第一个参数是某个函数，该函数返回bool值。
filter函数会保留True对应的元素，例如第一个参数返回[True， False， True]，则filter函数返回列表中第0、2号元素

#保留偶数
def get_even(n):return n % 2 == 0
result = filter(get_even, x_list)
print(list(result))#保留字符串，删除空字符
def get_str(string):return len(string.strip()) > 0
result = filter(get_str, [' ','  ','I','am','so',' ','handsome',' ','!'])
print(list(result))

[2, 4, 6, 8]
[‘I’, ‘am’, ‘so’, ‘handsome’, ‘!’]

4. reduce函数

reduce函数，以迭代的方式对元素进行相同的操作，例如，利用reduce求和,依次进行：
r1 = x[0]+x[1]
r2 = r1 + x[2]
r3 = r2 + x[3]
…

from functools import reducedef_sum = lambda x, y: x + y
result = reduce(def_sum, x_list)
print(result)

45

5. Python推导式

5.1 列表推导式

对列表、集合、字典的元素进行相同操作，除了利用map映射，也可以采用更简洁的推导式；map会返回一个对象，需要打印列表结果时需要list强制转换，而推导式不需要

#将所有元素转成平方，并保存为列表
result = [x**2 for x in x_list]
print(result)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

5.2 集合推导式

#集合元素筛选，保留大于0的元素
set_example = {1, 0, -4, 2, -7, 3, -8, 4, 5}
result = {x for x in set_example if x > 0}
print(result)

{1, 2, 3, 4, 5}

5.3 字典推导式

#字典key或value也可以进行类似的筛选
dic_example = {0: 'I', 1: 'am', 2: 'so', 3: 'handsome', 4: '!'}
result = {key: value for key, value in dic_example.items() if key > 2} #筛选出key大于2的items
print(result)#字典key value互换位置
result = {value: key for key, value in dic_example.items()}
print(result)#将字典按照value从大到小进行排序，例如key为word，value 为词频
dic_example1 = {'I': 100, 'am': 1, 'so': 50, 'handsome': 666, '!': 888}
result = list(sorted(dic_example1.items(), key=lambda x: x[1], reverse=True))
print(result)

{3: ‘handsome’, 4: ‘!’}
{‘I’: 0, ‘am’: 1, ‘so’: 2, ‘handsome’: 3, ‘!’: 4}
[(’!’, 888), (‘handsome’, 666), (‘I’, 100), (‘so’, 50), (‘am’, 1)]

6. 装饰器

6.1 简单参数装饰器

#装饰器
import time
#计算函数的运行时间
def run_time(func):def wrapper(x,y):before_run = time.time()f = func(x,y)after_run = time.time()print("time_run: {}".format(after_run - before_run))return freturn wrapper#使用装饰器计算加法运算时间
@run_time
def sum(x, y):return x+y
sum(2, 5)#使用装饰器计算加法运算时间
@run_time
def sub(x, y):return x-y
sub(2, 5)

time_run: 0.0
time_run: 0.0

6.2 通用参数装饰器

以上的例子固定输入参数个数是2个，不具有普遍性，例如想要输入更多参数或者关键字参数。这时可以通过* 和**来实现。经过修改后，多个参数通过*args(元组类型)实现，关键字参数通过**kwargs（字典类型），args可以看作变长的元组，kwargs可以看作字典。key是调用时使用的关键字，value是对应的值。

#带参数的装饰器,经过修改后，调用时可以传入2个参数、3个参数，关键字参数
def run_time1(func):def wrapper(*args, **kwargs):before_run = time.time()func(*args, **kwargs)after_run = time.time()print("time_run: {}".format(after_run - before_run))return Nonereturn wrapper@run_time1
def sub(*args, **kwargs):print("Done nothing")  #运行到此处时，sub函数已经传入了func,此时返回了wrapper函数sub(1, i = 2, j = 5)#运行到此处时，运行wrapper函数

Done nothing
time_run: 0.0

6.3 对输入参数类型进行筛选

让函数仅仅接受int类型输入。

def run_time2(func):def wrapper(*args, **kwargs):for x in args:if type(x) != int:print("数据类型错误！！必须为int")#若不为int类型，直接结束运行exit()before_run = time.time()func(*args, **kwargs)after_run = time.time()print("time_run: {}".format(after_run - before_run))return Nonereturn wrapper@run_time2
def sub(*args, **kwargs):return args[0] - kwargs['i'] -kwargs['j']
sub('i', i = 2, j = 5)

数据类型错误！！必须为int

7. numpy库的使用

7.1 数组的创建

import numpy as np
print(np.zeros((2, 3)))#生成初始值为0的2X3数组
print(np.ones((2, 3)))#生成初始值为1的2X3数组
print(np.full((2, 3), 20))#生成初始值为20的2X3数组#生成以start为起始值，stop为终止值（取不到），step为间隔的一维数组，后rehape成3X3
x = np.arange(start=10, stop=100, step=10).reshape((3, 3))
print(x)#对数组进行转置操作
print(x.T)

D:\Anaconda\python.exe E:/project/python_math/python_math.py
[[0. 0. 0.]
[0. 0. 0.]]
[[1. 1. 1.]
[1. 1. 1.]]
[[20 20 20]
[20 20 20]]
[[10 20 30]
[40 50 60]
[70 80 90]]
[[10 40 70]
[20 50 80]
[30 60 90]]

7.2 花式索引

#花式索引
#获取数组的第0 、 2行
print(x[[0, 2]])
#依次获取数组的第（0，0）（1，1）（2，2）位置的元素
print(x[[0, 1, 2], [0, 1,  2]])

[[10 20 30]
[70 80 90]]
[10 50 90]

7.3 条件逻辑转数组

7.3.1 np.where()

#条件逻辑转数组
X = np.array([1,2,3,4])
Y = np.array([5,6,7,8])
condition = np.array([True, False, False, True])
result = [x if c else y for x, y, c in zip(X,Y,condition)]
print(result)
print(np.where(condition, X, Y))#对数组中的数据进行调整，例如大于2的全变为0
print(np.where(X >= 2, 0, X))

[1, 6, 7, 4]
[1 6 7 4]
[1 0 0 0]

7.3.2 多维数组排序

arr = np.random.randn(4, 4)
print("Before sorting:{}".format(arr))
arr.sort(0)
print("After sorting:{}".format(arr))#对0轴进行操作，也就是按行排序，每一列由大到小排列

Before sorting:[[ 0.2890804 0.90846815 -0.60711112 -0.31092294]
[-1.62709031 -0.75044591 0.29248143 -0.58838969]
[ 1.25654216 -2.55491797 -1.03059249 -0.2735129 ]
[-0.52335646 0.69117994 -1.3475542 0.02046329]]
After sorting:[[-1.62709031 -2.55491797 -1.3475542 -0.58838969]
[-0.52335646 -0.75044591 -1.03059249 -0.31092294]
[ 0.2890804 0.69117994 -0.60711112 -0.2735129 ]
[ 1.25654216 0.90846815 0.29248143 0.02046329]]

8. pandas的使用

未完待更

9. 总结

1. 即使东西再简单，也得过一遍，肯定会有知识的盲区，用了一年的Python, *args 、**kwargs还真没使用过，知道了两者的使用方法是最大的收获之一吧。
2. 还有个盲区是装饰器（基础真的不牢靠），印象中在师姐的笔试题出现过，当时是网上直接搜的答案，打铁还需自身硬啊，现在也算是补救了一些。
3. 之前也一直用推导式，但字典、集合用的比较少，这次加深了理解与使用，至少知道了术语是推导式。
4. map函数使用的比较少，只见过他人的使用，下次可以考虑在恰当的时候使用。