一 numpy
简介
nump用来是数组和矢量计算，是高性能科学计算和数据分析的基础包。
ndarry：是一个具有矢量运算和复杂广播能力的快速且节省空间的多维数组。
主要功能：数据整理和清理，子集构造和过滤，转换等快速的矢量化数组运算；数组算法，如排序，唯一化，集合运算等。
（一）.生成ndarry对象
ndarry：多维数组对象，是快速灵活的数据集容器。
import numpy as np
1.a = np.array([1,2,3])/ np.asarray() #可传入list,tuple,数组或其他序列类型
print(a) #[1 2 3]
2.np.zero()
3.np.ones()
4.np.arange()
5.np.linspace(start,end,num) #start~end等间隔产生num个数的序列
a = np.linspace(1,5,3)
print(a) #[1. 3. 5.]
6.numpy.random（随机抽样）
有一个点需要强调：(2,)与(2,1)的区别
[1,2]的shape值(2,)，意思是一维数组，数组中有2个元素。
[[1],[2]]的shape值是(2,1)，意思是一个二维数组，每行有1个元素。
[[1,2]]的shape值是（1，2），意思是一个二维数组，每行有2个元素。
a=np.array([1,2,3])
b=np.array([[1],[2],[3]])
print(a.shape)
print(b.shape)
#结果：
(3,)
(3, 1)
np.random.rand()#返回[0,1)的均匀分布的随机样本
np.random.randn()#回一个样本，具有标准正态分布
numpy.random.randint(low, high=None, size=None, dtype='l')#小于low的size个整数
np.random.seed()
numpy.random.seed()是个很有意思的方法，接下来使用random()或者rand()方法所生成的随机数序列都是相同的（仅限使用一次random()或者rand()方法，第二次以及更多次仍然是随机的数字）
(1)外面
num = 1
np.random.seed(5)
while(num<5):
print(np.random.random())
num+=1
#结果：
0.22199317109
0.870732306177
0.206719155339
0.918610907938
(2)里面
from __future__ import print_function
num = 1
while(num<5):
np.random.seed(5)
print(np.random.random(),'\t',end='')
num+=1
#结果：
0.22199317109 0.22199317109 0.22199317109 0.22199317109
（二）.reshape+transpose
rehsape(a, newshape, order=‘C’)一个参数为-1时，那么reshape函数会根据另一个参数的维度计算出数组的另外一个shape属性值。order('C’和’F’选项不考虑底层数组的内存布局，而只是参考索引的顺序)
a=np.arange(12)
#b=np.reshape(a,(2,2,3)) #等价
b=a.reshape(2,2,3)
print(b)
#result：
[[[ 0 1 2]
[ 3 4 5]]
[[ 6 7 8]
[ 9 10 11]]]
.transpose(a,axes=None):反转的输入数组的维度，当给定这个参数时，按照axes参数所定的值进行数组变换。
a=np.arange(10).reshape(2,5)
b=np.transpose(a)
print(b.shape,a.shape)
#结果:
((5, 2), (2, 5))
(三). np.multiply()/*和np.dot
*/np.multiply():对应元素相乘
b=np.arange(6).reshape(2,3)
copy_b=b.copy()
a=np.arange(6).reshape(3,2)
print('*:')
print(copy_b*b)
print('multiply:')
print(np.multiply(copy_b,b))
print('dot:')
print(np.dot(b,a))
#结果:
*:
[[ 0 1 4]
[ 9 16 25]]
multiply:
[[ 0 1 4]
[ 9 16 25]]
dot:
[[10 13]
[28 40]]
a=np.arange(4).reshape(2,2)
b=np.arange(8).reshape(2,2,2)
a2=np.arange(8).reshape(1,2,2,2)
b2=np.arange(16).reshape(2,2,2,2)
print(a*b)
print(a2*b2)
#结果：
a*b：
[[[ 0 1]
[ 4 9]]
[[ 0 5]
[12 21]]]
a2*b2:
[[[[ 0 1]
[ 4 9]]
[[ 16 25]
[ 36 49]]]
[[[ 0 9]
[ 20 33]]
[[ 48 65]
[ 84 105]]]]
Xn维*Ym维：n>1
n=m：确保2~n维与2~m维数相同，X第一维为1
n<m:确保X维数与Y的m-n+1~m维对应相等，2x2 3x2x2 可以
(四). np.sum,np.prod,np.pad
np.sum: axis表示在哪一维度求和
b=np.arange(24).reshape(2,2,3,2)
print('b----')
print(b)
print('axis=0----')
print(np.sum(b,axis=0))
print('axis=1----')
print(np.sum(b,axis=1))
print('axis=2----')
print(np.sum(b,axis=2))
#结果：
b---- 2x2x3x2
[[[[ 0 1]
[ 2 3]
[ 4 5]]
[[ 6 7]
[ 8 9]
[10 11]]]
[[[12 13]
[14 15]
[16 17]]
[[18 19]
[20 21]
[22 23]]]]
axis=0----3x3x2
[[[12 14]
[16 18]
[20 22]]
[[24 26]
[28 30]
[32 34]]]
axis=1----2x3x2
[[[ 6 8]
[10 12]
[14 16]]
[[30 32]
[34 36]
[38 40]]]
axis=2----2x2x2
[[[ 6 9]
[24 27]]
[[42 45]
[60 63]]]
x_shape = (2, 3, 4, 4)
num=np.prod(x_shape) #对应元素求乘积
num
#96
np.pad
在哪个维度上填充数值，默认填充0
arr3D=np.arange(8).reshape(2,2,2)
print('constant: \n' + str(np.pad(arr3D, ((0, 0), (1, 1), (2, 2)), 'constant')))
#（2，2)/(2,):表示前面两个后面两个
print('constant2: \n' + str(np.pad(arr3D, ((1, ), (2, ), (2, )), 'constant')))
#结果：
constant:
[[[0 0 0 0 0 0]
[0 0 0 1 0 0]
[0 0 2 3 0 0]
[0 0 0 0 0 0]]
[[0 0 0 0 0 0]
[0 0 4 5 0 0]
[0 0 6 7 0 0]
[0 0 0 0 0 0]]]
constant2:
[[[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]]
[[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 1 0 0]
[0 0 2 3 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]]
[[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 4 5 0 0]
[0 0 6 7 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]]
[[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]]]
五np.argsort
numpy.argsort(a, axis=-1, kind=’quicksort’, order=None)
kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional
Sorting algorithm.
axis=0:按列排序
axis=1:按行排序
axis=-1:默认按最后一维度，即按行排序
功能: 将矩阵a按照axis排序，并返回排序后的下标
参数: a:输入矩阵， axis:需要排序的维度
返回值: 输出排序后的下标
a = np.array([[2,32,121],[32,12,23]])
print(a)
b=np.argsort(a,axis=1)
b2=np.argsort(-a)
b3=np.argsort(a,axis=-1)
print(b)
print(b2)
print(b3)
#结果:
[[ 2 32 121]
[ 32 12 23]]
[[0 1 2]
[1 2 0]]
[[2 1 0]
[0 2 1]]
[[0 1 2]
[1 2 0]]
a=np.arange(12).reshape(2,3,2)
print(a)
print('________')
print(np.sum(a,axis=0)) #第一维：3x2
print('________')
print(np.sum(a,axis=1)) #第二维：按列加2x2
print('________')
print(np.sum(a,axis=2)) #第三维:2x3按行加
#结果:
[[[ 0 1]
[ 2 3]
[ 4 5]]
[[ 6 7]
[ 8 9]
[10 11]]]
________
[[ 6 8]
[10 12]
[14 16]]
________
[[ 6 9]
[24 27]]
________
[[ 1 5 9]
[13 17 21]]
六. numpy.bincount
bincount(x, weights=None, minlength=0)
bin是x中最大值max，返回从索引0~max的计数。
weights参数被指定，那么x会被它加权，也就是说，如果值n发现在位置i，那么out[n] += weight[i]而不是out[n] += 1.因此，我们weights的大小必须与x相同，否则报错。
最后，我们来看一下minlength这个参数。文档说，如果minlength被指定，那么输出数组中bin的数量至少为它指定的数（如果必要的话，bin的数量会更大，这取决于x）即bin>=minlength
实例就不举了这篇博客总结的很好
七. stack()，hstack()，vstack()
stack(arrays, axis=0):它就是对arrays里面的每个元素(可能是个列表，元组，或者是个numpy的数组)变成numpy的数组后，再对每个元素增加一维(至于维度加在哪里，是靠axis控制的)
hstack:它其实就是水平(按列顺序)把数组给堆叠起来，vstack()函数正好和它相反。
vstack:它是垂直（按照行顺序）的把数组给堆叠起来。
博客
a=([1,2,3],3,1)
b=[4,5,6]
print(np.hstack((a,b)))
print(np.vstack((a,b)))
#结果:
[list([1, 2, 3]) 3 1 4 5 6]
[[list([1, 2, 3]) 3 1]
[4 5 6]]
八. np.squeeze()
从数组的形状中删除单维条目，即把shape中为1的维度去掉
x = np.array([[[0], [1], [2]]])
print(x.shape)
print(np.squeeze(x).shape)
九. numpy的broadcasting性质
A=np.array([1,2])
B=np.array([[3],[4]])
print(A.shape)
print(B.shape)
print((A+B).shape)
print(A+B)
#结果:
(2,)
(2, 1)
(2, 2)
[[4 5]
[5 6]]
二 数据结构
（一）序列（sequence）
每个元素都分一个数字（位置，索引：从0开始，最后一个是-1）
6种内建序列：列表（list），元组（tuple），字符串，Unicode字符串，buffer对象
dict和set
dict是同java hashMap一样的Key-value数据类型，{}表示。
散列表是无序的，其顺序是被添加的次序而定的，且添加元素可能会改变集合原有次序。
1.初始化
、# dic={}
# dic['a']=1 #增加元素
dic={'a':1}
print(dic)
#result：
{'a': 1}
2.遍历
dic={'a':1,'b':2}
print(dic.items()) # 一列表形式返回可遍历的（K,V）元组list
#结果：[('a', 1), ('b', 2)]
print(dic.keys()) #dic.values()返回值
# 结果：['a', 'b']
3.删除
del dic['b']
print(dic.keys())
#结果：['a']
python3中，keys(),items(),values()返回的都是字典视图，python2返回的是列表。视图具有动态特征，可以实时反馈字典变化。
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key
1.list内置方法
list和tuple
tuple元组，同list，使用（），元素一旦初始化就不可修改，tuple内元素可以为list等其他序列数据类型，其内容可变。
str和tuple加上bytes是不变对象/序列，而list是可变对象
#前python <=>后java对比
1.append()<=>add()
2.len()<=>.size
3.+/.extend()<=>.addAll()
list.append(object) 向列表中添加一个对象object
list.extend(sequence) 把一个序列seq的内容添加到列表中
a=range(5)
new=range(6,10)
a.append(new)
print(a)
#结果:
[0, 1, 2, 3, 4, [5,6, 7, 8, 9]]
a=range(5)
new=range(5,10)
a.extend(new)
print(a)
#结果:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4.in<=>.contains()
5.list.count(val)
6..remove(val)
7.pop(index) #删除索引，default：最后一个
2.list切片（slice）
":" 表示该维度全部数据
b=np.array([1,2,3])
a=b[None,:,None,None]
a2=(b)[None,:,None,None]#与上式等价
print(a)
print(a.shape)
print(a2.shape)
# None是一个特殊的常量,有自己的数据类型NoneType,和False不同,不是0,不是空字符串,和任何其他的数据类型比较永远返回False
#可以将None复制给任何变量，但是你不能创建其他NoneType对象
#结果：
[[[[1]]
[[2]]
[[3]]]]
(1, 3, 1, 1)
(1, 3, 1, 1)
a=np.arange(12).reshape(3,4)
print(a,'\n')
print(a[:,2:],'\n')
print(a[:,:-2:2])
在每一维度中 m：n表示从下标[m,n)的元素
m：n：d 表示从m开始每隔d取一元素
#结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 2 3]
[ 6 7]
[10 11]]
[[0]
[4]
[8]]
3. enumerate
在循环体内访问每个元素的指针
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print '#%d: %s' % (idx + 1, animal)
#结果：
1: cat
2: dog
3: monkey
4 sort/sorted
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sorted(iterable[, cmp[, key[, reverse]]])
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
L=[('b',2),('a',1),('c',3),('d',4)]
print(sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))) # 利用cmp函数
print(sorted(L, key=lambda x:x[1])) # 利用key
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2])) # 按年龄排序
print(sorted(students, key=lambda s: s[2], reverse=True)) # 按降序
#结果:
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
4.列表生成式/列表推导
指把一个序列或其他可迭代类型中的元素过滤或加工，然后再新建一个列表。（比filter/map等lambda表达式更简洁）
symbols='$*^#@%&'
ascii=[ord(s) for s in symbols if ord(s)>40]#if ord(s)>127
ascii_lambda=list(filter(lambda c: c > 40, map(ord, symbols)))
print(ascii)
print(ascii_lambda)
#结果
[36, 42, 94, 35, 64, 37, 38]
[36, 42, 94, 35, 64, 37, 38]
colors=['black','red']
sizes=['S','M','L']
tshirts=[(color, size) for color in colors for size in sizes]
print(tshirts)
#结果：
[('black', 'S'), ('black', 'M'), ('black', 'L'), ('red', 'S'), ('red', 'M'), ('red', 'L')]
其他
一 format
format函数用于字符串的格式化
1.通过关键字
print('{name1}今天{name2}'.format(name1='陈某某',name2='跑步'))#通过关键字
grade = {'name' : '陈某某', 'fenshu': '59'}
print('{name}电工考了{fenshu}'.format(**grade))#通过关键字，可用字典当关键字传入值时，在字典前加**即可
#结果:
陈某某今天跑步
陈某某电工考了59
2.通过位置
print('{1}今天{0}'.format('跑步','陈某某'))#通过位置
print('{0}今天{1}'.format('跑步','拍视频'))
#结果:
陈某某今天跑步
陈某某今天跑步
3.精度
print('{:.1f}'.format(4.234324525254))
print('{:.4f}'.format(4.1))
print('{:,}'.format(100000000))
print('{:,}'.format(235445.234235))
#结果:
4.2
4.1000
100,000,000
235,445.234235
生成器
如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。
1.
g = (x*x for x in range(10))
print(g)
for x in g:
print(x)
#结果:
<generator object <genexpr> at 0x1050e8cd0>
0
1
4
9
16
25
36
49
64
81
2. generator函数
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
f = fib(6)
for x in f:
print(x)
#结果:
1
1
2
3
5
8
简单地讲，yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator
不用generator:
class Fab(object):
def __init__(self,max):
self.max = max
self.n, self.a, self.b = 0,0,1
def __iter__(self):
return self
def next(self):
if self.n < self.max:
r = self.b
self.a,self.b = self.b, self.a + self.b
self.n = self.n + 1
return r
raise StopIteration()
for n in Fab(5):
print(n)
#结果:
1
1
2
3
5
我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代.
对于python2.7 不能包含return，否则报错。
python3可以
用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
f = fib(6)
print(f)
g = fib(6)
while True:
try:
x = next(g)
print('g:',x)
except StopIteration as e:
print('Generator return value:', e.value)
break
#结果:
<generator object fib at 0x10ed0a2b0>
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done