python

1.图片处理

PIL

from PIL import Imageim=Image.open('/Users/edz/Downloads/6.jpeg')       //120*120w,h=im.sizeim.thumbnail((w//2,h//2))im.save('/Users/edz/Downloads/7.jpeg','jpeg')      //60*60

2.NumPy

标准安装的Python中用列表保存一组值，可以用来当做数组使用，不过由于列表的元素可以是任何对象，因此列表中所保存的是对象的指针。如为了保存[1,2,3]，需要有3个指针和三个整数对象。对于数值运算的话这种结构显然比较浪费内存和CPU。此外Python还提供了一个array模块，array对象和列表不同，它直接保存数值，和C语言一维数值类似。但是它不支持多维，也没有各种运算函数，因此不适合做数值运算。
NumPy的诞生弥补了这些不足，NumPy提供了2种基本对象：ndarray(N-dimensional array object)和ufunc(universal function object)。ndarray(下文统一称之为数组)是存储单一数据类型的多维数组，而ufunc是能够对数组进行处理的函数
a=numpy.array([1,2,3,4])
b=numpy.array((5,6,7,8))
c=numpy.array([[1,2,3,4],[4,5,,6,7],[7,8,9,10]])

2.1 shape

数组的大小可以通过其shape属性

a.shape   //(4,)c.shape   //(3,4)

数组a的shape只有一个元素，因此其是一维数组。而数组c的shape由2个元素，因此它是二维数组，其中第0轴的长度是3，第一轴长度是4。还可以通过数组的shape属性，在保持数组元素个数不变的情况下，改变每个轴长度。如c.shape=4,3并不是对数组进行转置，而只是改变了每个轴的大小，数组元素在内存中的位置并没有改变：
c.shape=4,3
//array([[1,2,3],[4,4,5],[6,7,7],[8,9,10]])

当某个轴的元素为-1时候，将根据数组元素的个数自动计算此轴的长度，因此下面将数组c的shape改成了(2,6)
c.shape=2,-1
array([[1,2,3,4,4,5],[6,7,7,8,9,10]])

2.2reshape

使用数组的reshape方法，可以创建一个改变了尺寸的新数组，原来数组shape保存不变

d=a.reshape((2,2))d     //array([[1,2],[3,4]])a     //array([1,2,3,4])

数组a和d其实共享数据存储内存区域，因此修改其中任意一个数组的元素都会同时修改另外一个数组的内容
a[1]=100
d //array([1,100],[3,4]])

2.3判断数组元素类型dtype

数组的元素类型可以通过dytype属性获得。上面例子中的参数序列化的元素都是整数，因此所创建数组的元素类型也是整数，并且是32bit的长整数。可以通过dtype参数在创建时候指定

>>>np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]],dtype=np.float)    array([[1.,2.,3.,4.,],        [4.,5.,6.,7.,],        [7.,8.,9.,10.]])>>>np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]],dtype=np.complex)    array([[1.+0.j,2.+0.j.,3.+0.j,4.+0.j,],        [4.+0.j,5.+0.j.,6.+0.j,7.+0.j,],        [7.+0.j,8.+0.j.,9.+0.j,10.+0.j,]])

2.4 arange

上面的例子都是首先创建一个python序列，然后通过array函数将其转换成数组，这样做显然效率不高。因此NumPy提供了很多专门用来创建数组的函数
arange函数类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，数组不包含终值：

np.arange(0,1,0.1)array([0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9])

2.5 linspace

linspace函数，通过指定开始值、终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包含终值，缺省设置是包含终值：

np.linspace(0,1,12)array([ 0.        ,  0.09090909,  0.18181818,  0.27272727,  0.36363636,        0.45454545,  0.54545455,  0.63636364,  0.72727273,  0.81818182,        0.90909091,  1.        ])

2.5 logspace

logspace函数和linspace类似，不过它创建等比数列：
下面的例子产生1(10^0)到100(10^2)、有20个元素的等比数列：

np.logspace(0,2,20)array([   1.        ,    1.27427499,    1.62377674,    2.06913808,          2.6366509 ,    3.35981829,    4.2813324 ,    5.45559478,          6.95192796,    8.8586679 ,   11.28837892,   14.38449888,         18.32980711,   23.35721469,   29.76351442,   37.92690191,         48.32930239,   61.58482111,   78.47599704,  100.        ])

此外使用frombuffer fromstring fromfile函数可以从字节序列中创建数组

Python中字符串其实是字节序列，每个字符占用一个字节，因此如果从字符串s创建一个8bit的整数数组的话，所得的数组正好就是每个字符的ASCII编码：
s=”abcdefgh”
np.fromstring(s,dtype=np.int8)
array([97,98,99,100,101,102,103,104],dtype=int8)
//如果从字符串s创建16bit的整数数组，那么2个相邻的字节就表示一个整数，把字节98和字节97当作一个16位的整数，他的值是98*256+97=25185.可以看出内存是小端方式保存数据的
np.fromstring(s,dtype=np.int16)
array([25185,25699,26213,26727],dtype=int16)

如果把整个字符串转换成一个64位的双精度浮点数数组，那么它的值是：

>>> np.fromstring(s, dtype=np.float)array([  8.54088322e+194])

fromfunction

fromfunction函数的第一个参数为计算每个数组元素的函数，第二个参数为数组的大小(shape)，因为它支持多维数组，所以第一个参数必须是一个序列

def func(i):    return i%4+1np.fromfunction(func,(10,))

#创建九九乘法def func(i,j):    return (i+1)*(j+1)a=np.fromfunction(func2,(9,9))#array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.],       [  2.,   4.,   6.,   8.,  10.,  12.,  14.,  16.,  18.],       [  3.,   6.,   9.,  12.,  15.,  18.,  21.,  24.,  27.],       [  4.,   8.,  12.,  16.,  20.,  24.,  28.,  32.,  36.],       [  5.,  10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.],       [  6.,  12.,  18.,  24.,  30.,  36.,  42.,  48.,  54.],       [  7.,  14.,  21.,  28.,  35.,  42.,  49.,  56.,  63.],       [  8.,  16.,  24.,  32.,  40.,  48.,  56.,  64.,  72.],       [  9.,  18.,  27.,  36.,  45.,  54.,  63.,  72.,  81.]])

3.存取元素

数组元素存取方法和Python的标准方法相同
a=np.arange(10)
a[5];
a[3:5] ;//用范围作为下标获取数组的一个切片，从a[3]开始但是不包括a[5]
a[:5] ;//<==>a[0:5]
a[:-1];//下标可以使用负数，表示从数组往后向前数组
array([0,1,2,3,4,5,6,7,8])
下标还可以修改元素的值
a[2:4]=100,101
a[1:-1:2] //第三个参数表示步长，2表示隔一个元素取一个元素

a[::-1]; //省略范围的开始下标和结束下标，步长为-1，整个数组头尾颠倒
a[5:1:-2] //步长为负数时候，开始下标必须大于结束下标

和Python的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视图，它与原始数组共享同一块数据空间
b=a[3:7] //通过下标范围产生一个新数组b，b和a共享同一块数据空间
b[2]=-10 ; b和a的第三个元素同时被修改成-10

整数序列

当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间

x=np.arange(10,1,-1)>>> x    array([10,9,8,7,6,5,4,3,2])>>>x[[3,3,1,8]]    获取x中的下标为3，3，1，8的4个元素，组成一个新的数组>>>b=x[np.array([3,3,-3,8])] #下标可以是负数>>>b    array([7,7,9,2])

布尔数组

当使用布尔数组b作为下标存取数组x中的元素时，将收集数组x中所有在数组中对应下标为True的元素。使用布尔数组作为下标获得的数组不和原来数组共享数据空间。只针对布尔数组，不针对布尔列表

>>>x=np.arange(5,0,-1)>>>x    array([5,4,3,2,1])>>>x[np.array([True,False,True,False,False])]    //布尔数组中下标为0，2的元素为True，因此获取x中下标为0，2的元素    array([5,3])>>>x[[True,False,True,False,False]]    布尔列表，把True当做1，False当做0，按照整数序列方式获取x中的元素    array([4,5,4,5,5])

布尔数组一般不是手工产生的，而是使用布尔运算的ufunc函数产生的

4.多维数组

多维数组的存取和一维数组类似，因为多维数组有多个轴，因此它的下标需要多个值来表示。Numpy采用组元(tuple)作为数组的下标。