Python数据分析-Day1-Numpy模块

1、numpy.genfromtxt读取txt文件

import  numpy
world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",",dtype=str)

#上面一句话是：实例化一个numpy.genfromtxt的对象，第一参数传要读取的文件名，第二个是分割符，最后一个读取后的数据类型。这是用numpy.genfromtxt读取txt文件内容的方法。

 print(type(world_alcohol))
 print(world_alcohol)
#print(help(numpy.genfromtxt))

输出为：

<class 'numpy.ndarray'>
[['Year' 'WHO region' 'Country' 'Beverage Types' 'Display Value']
['1986' 'Western Pacific' 'Viet Nam' 'Wine' '0']
['1986' 'Americas' 'Uruguay' 'Other' '0.5']
...,
['1987' 'Africa' 'Malawi' 'Other' '0.75']
['1989' 'Americas' 'Bahamas' 'Wine' '1.5']
['1985' 'Africa' 'Malawi' 'Spirits' '0.31']]

2、numpy.array建立矩阵

vector = numpy.array([5, 10, 15, 20])　　#使用numpy.array方法把一个list转化为一个向量或者叫一行矩阵。

matrix = numpy.array([[5, 10, 15], [20, 25, 30], [35, 40, 45]])　　#使用numpy.array方法把多个list转化为一个矩阵。

print(vector)

print(matrix)

所以写一维矩阵写一个中括号，写二维矩阵写二个中括号，写三维矩阵写三个中括号。

输出：

　　[ 5 10 15 20]
　　[[ 5 10 15]
　　[20 25 30]
　　[35 40 45]]

3、shape方法打印矩阵形状

vector = numpy.array([5, 10, 15, 20])

print(vector.shape)　　#vector.shape就是打印该矩阵的形状，即几维，几行几列。

matrix = numpy.array([[5, 10, 15], [20, 25, 30], [35, 40, 45]])

print(matrix.shape)　　#matrix.shape就是打印该矩阵的形状，即几维，几行几列。

一般XXX.shape用作调试程序用。

输出：

　　(4,)
　　(3, 3)

4、dtpye方法打印矩阵元素类型

当构建numpy矩阵时，要求里面的所有元素的数据类型为相同的数据类型。

numbers = numpy.array([1, 2, 3, 4])

print(numbers)
print(numbers.dtype)

输出：

　　[1 2 3 4]
　　int32

当上述代码修改成下面时：

numbers = numpy.array([1, 2, 3, 4.0])

print(numbers)
print(numbers.dtype)

输出：

　　[ 1. 2. 3. 4.]
　　float64

5、numpy索引

import  numpy
world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",", dtype="U75", skip_header=1)
print(world_alcohol)
uruguay_other_1986 = world_alcohol[1,4]　　#我们需要取的数据是第2行第5个，同list第一个数据索引值为0
third_country = world_alcohol[2,2]　　　　#这行我们需要取的数据是第3行第3个。
print(uruguay_other_1986)
print(third_country)

输出：

　　0.5

　　Cte d'Ivoire

6、numpy切片

1）向量的切片

vector = numpy.array([5, 10, 15, 20])　　#建立一个向量
print(vector[0:3])　　#向量与list的切片方式一致，顾头不顾尾。

输出：

[ 5 10 15]

2）矩阵的单列或单行切片

matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])　　#建立矩阵
print(matrix[:,1])　　# :表示这一行或一列的所有元素。以“,”为间隔，隔开行和列的位置。如果在第一个位置为行，第二个位置为列。

输出：

　　[10 25 40]

3）矩阵的多列或多行切片

matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(matrix[:,0:2])　　#以","为间隔，隔开行和列的位置。":"表示所有元素。

输出：

　　[[ 5 10]
　　[20 25]
　　[35 40]]

matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(matrix[1:3,0:2])

7、对numpy.array整体的操作

对numpy.array整体的操作=对numpy.array每一个元素做相同的操作。

vector = numpy.array([5, 10, 15, 20])
print(vector == 10)

output：

[False  True False False]

这一条定律对矩阵一样适用：

　　matrix = numpy.array([
　　[5, 10, 15],
　　[20, 25, 30],
　　[35, 40, 45]
　　])
　　print(matrix == 25)

output：

　　[[False False False]
　　[False True False]
　　[False False False]]

8、bool值也可以当索引

把某个矩阵的对应布尔值矩阵作为索引传递给原矩阵，则会返回出bool值为真的元素

vector = numpy.array([5, 10, 15, 20])
equal_to_ten = (vector == 10)
print(equal_to_ten)
print(vector[equal_to_ten])

output:

　　[False True False False]
　　[10]

上述规律对矩阵一样适用：

matrix = numpy.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
second_column_25 = (matrix[:,1] == 25)
print(second_column_25)
print(matrix[second_column_25, :])

output:

[False  True False]
[[20 25 30]]

9、bool值表的与、或

1)bool值表的与

vector = numpy.array([5, 10, 15, 20])
equal_to_ten_and_five = (vector == 10) & (vector == 5)
print(equal_to_ten_and_five)

output:　　

　　[False False False False]

2)bool值表的或

　　和上面代码类似，此处略

10、矩阵data类型转换

vector = numpy.array(["1", "2", "3"])　　#元素为字符串类型
print（vector.dtype）　　#打印元素类型
print （vector）
vector = vector.astype(float)　　#用astype（）方法进行强制类型转换。
print （vector.dtype）
print （vector）

11、求矩阵极值等方法

vector = numpy.array([5, 10, 15, 20])
vector.min()　　#求矩阵中最小的元素
#print(help（numpy.array）)　　#想了解更多的方法或函数，打印相关帮助即可。

12、矩阵求和

matrix = numpy.array([
                [5, 10, 15], 
                [20, 25, 30],
                [35, 40, 45]
             ])
matrix.sum(axis=1)　　#按行求和

output：array([ 30,  75, 120])

matrix.sum(axis=0)　　#按列求和

output：array([60, 75, 90])

指数计算和根号计算

B = numpy.arange(3)
print (numpy.exp(B))　　#exp是以e为底数，B的每个元素分别作为指数进行计算，计算结果以矩阵的方式显示
print (numpy.sqrt(B))　　#sqrt是对B的每个元素分别开根号，计算结果以矩阵的方式显示

13、关于矩阵的操作

a = np.floor(10*np.random.random((3,4)))　　#np.random.random((3,4))是-1到1之间的随机，*10让数据扩大10倍便于分辨，floor方法是向下取整又叫舍尾法近似。

print(a.ravel())　　#a.ravel() 方法是把一个二维矩阵拉伸成一个1维向量，顺序是先第1行从左到右，然后第2行从左到右，以此类推

a.shape = (6, 2)　　#把矩阵a的形状设置为6行2列
print(a.T)　　#把a矩阵转置，即把原来的第一列变为新矩阵的第一行，第二列变为新矩阵的第二行，即原来的行变为列，原来的列变为行，依次类推。

a.reshape(3,-1)　　#reshape(3,-1)方法是修改矩阵的形状，3是3行，-1这个数表示让计算机根据其他维度的数据，自动算出-1这个地方应该填写多少，并完成修改。

矩阵的拼接：

　　a = np.floor(10*np.random.random((2,2)))
　　b = np.floor(10*np.random.random((2,2)))

　　print(np.hstack((a,b)))　　# hstack方法是矩阵横向拼接方法

　　print(np.vstack((a,b)))　　# vstack方法是矩阵纵向拼接方法

矩阵的切分：　　

　　a = np.floor(10*np.random.random((2,12)))
　　print (np.hsplit(a,3))　　# hsplit函数是横向切割，传入两个参数，第一个参数是要被切割的矩阵，第二个是切成几份。
　　print (np.hsplit(a,(3,4)))　 # hsplit还有一种用法，指定在某几个位置切。该例子中，第二个位置参数是一个元组形式，表示在位置3,4分别切一刀
　　

　　a = np.floor(10*np.random.random((12,2)))
　　np.vsplit(a,3)　　# vsplit函数是纵向切割，传入两个参数，第一个参数是要被切割的矩阵，第二个是切成几份。

14、关于复制的操作

1）赋值符号：指向一样，数据共享

a = np.arange(12)　　#建立一个12个元素的向量，命名为a
b = a　　
print(b is a)　　　　#打印判断b是不是a的结果
b.shape = 3,4　　#把一维向量b的形状转化成3行4列的而二维矩阵
print a.shape　　#打印a的形状
print id(a)　　　　#打印a的id，id是某个变量在内存中生成时，被赋予的具有唯一性的内存标识
print id(b)　　　　#打印b的id

output：

　　True

　　(3, 4)

　　82691200

　　82691200

由上述例子得出，a和b只是同一个矩阵的不同名称，他们俩指向的是同一个矩阵，所以不论对a还是b操作，都会引起被指向矩阵的变化。

2）浅复制：指向不同，数据共享

c = a.view()　　# 矩阵的view方法是浅复制，即c和a指向不同，但又同时共享着数据
print(c is a)　　#打印c是不是a的结果
c.shape = 2,6　　
print a.shape
c[0,4] = 1234　　#把矩阵c第1行第5列元素赋值为1234
print (a)

output：

　　False

　　array([[ 0, 1, 2, 3],

　　[1234, 5, 6, 7],

　　[ 8, 9, 10, 11]])

由此得出，矩阵的view方法是浅复制，即c和a指向不同，但又同时共享着数据。

3）深复制：指向不同，数据不同

　　d = a.copy() 　　# 矩阵的copy方法是深复制，即d和a指向不同，数据不同
　　print(d is a)
　　d[0,0] = 9999
　　print d
　　print a

output:

　　False

　　[[9999 1 2 3]

　　[1234 5 6 7]

　　[ 8 9 10 11]]

　　[[ 0 1 2 3]

　　[1234 5 6 7]

　　[ 8 9 10 11]]

15、矩阵的排序和索引

1）最值：

data = np.sin(np.arange(20)).reshape(5,4)　　#随机创建一个矩阵
ind = data.argmax(axis=0)　　#矩阵的argmax方法是求每列或每行的最大值，axis=0这个参数指按列统计，axis=1是按行统计。
print ind
#data_max = data[ind, xrange(data.shape[1])]　　#把每列最大的元素取出来。
print data_max　　

2）扩展

a = np.arange(0, 40, 10)　　#随机建立一个矩阵
b = np.tile(a, (3, 5)) 　　　　# tile方法是矩阵拓展方法，第一参数是把a作为整体当做一个元素进行扩展，第二个参数是扩展成3行5列的矩阵。
print b　　

3）排序

a = np.array([[4, 3, 5], [1, 2, 1]])
#b = np.sort(a, axis=1)　　#按照行对矩阵a排序，默认是从小到大排序，把新矩阵赋值给b

#a.sort(axis=1)　　　　# 这种调用方法和np.sort(a,axis=1)效果一样

a = np.array([4, 3, 1, 2])
j = np.argsort(a)　　　　# argsort方法是先对矩阵a排序，然后对应求出每个元素在原来矩阵a中的索引
print j　　　　　　　　
print a[j]　　　　　　　#把这个索引传入原矩阵就可以得到排序后的新矩阵。

output：

　　[2 3 1 0]

　　[1 2 3 4]

16、对numpy库的总结

整体来看numpy库已经包含了对矩阵的基本处理方式，有替代matlab的倾向。想比matlab，numpy库的优势还是很明显的。不过单纯学完numpy库，我还是没办法把它和程序化交易结合起来。不过学完这个库，以后就不用安装巨大的matlab 2012R 这个软件了。