python數據分析之numpy基礎代碼展示

python數據分析之numpy基礎代碼展示

#coding:utf-8
import scrapy
import xlwt, lxml
import re, json,time
import matplotlib.pyplot as plt
import numpy as np
import pylab
from scipy import linalg

'''
points=np.arange(-5,5,0.01)
xs,ys=np.meshgrid(points,points)
print(xs)

z=np.sqrt(xs **2+ys**2)
print(z)
print(np.arange(32))
plt.imshow(xs,cmap=plt.cm.gray)
# plt.colorbar()
plt.title("haha")
pylab.show()
'''


'''利用數組進行數據處理 將條件邏輯表述為數組運算
列表推導的局限性
 純python代碼，速度不夠快
 無法應用于高維數組
where 和where的嵌套
'''
# l=[i for i in np.arange(4).reshape(2,2)]
# #np.where(condition,x,y)如果條件成立執行x，否則執行y。另外，x和y可以繼續寫成np.where()的形式構成嵌套
# x=[i for i in np.arange(11,20)]
# y=[j for j in np.arange(21,30)]
# print(l)
# print(np.array(l))
# result=np.where(np.linalg.det(l)<0,x,y)
# print(result)
# print((np.array(l)>0).sum())
# bool=np.array(l)>0
# print(bool)
# print(bool.any())#有一個為True則返回True
# print(bool.all())#有一個為False則返回False
'''
關于zip函數的一點解釋，zip可以接受任意多參數，然后重新組合成1個tuple列表。
zip([1, 2, 3], [4, 5, 6], [7, 8, 9])
返回結果：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
'''


'''
#排序sort()
#找到位置在5%的數字
large_arr=np.random.randn(1000)
large_arr.sort()
print(large_arr[int(0.05*len(large_arr))])

#去重以及其他集合運算
'''

'''
unique(x) 計算x中的唯一元素，并返回有序結果
intersectld(x,y) 計算x和y中的公共元素，并返回有序結果
unionld(x,y)計算x和y的并集，并返回有序結果
inld(x,y)得到一個表述“x的元素是否包含于y”的布爾數組
setdiffld(x,y) 集合的差，即元素在x中且不在y中
setxorld(x,y) 集合的異或，即存在于一個數組中但不同時存在于兩個數組中的元素
'''
set_arr=np.array([1,1,2,3,4,5])
print(np.unique(set_arr))
set_arr2=np.unique(set_arr)
print(np.intersect1d(set_arr,set_arr2))

'''
#文件的輸入輸出
#arr=np.loadtxt('file.txt',delimiter=',') 讀取csv
arr=np.arange(10)
#np.save('some_array',arr)
print(np.load('some_array.npy'))

np.savez('array_archive.npz',a=arr,b=arr)#多個數組壓縮存儲
arch=np.load('array_archive.npz')
print(arch['a'])
'''

'''
線性代數 常用的numpy.linalg函數
diag 以一維數組的形式返回方陣的對角線（或非對角線元素），或將一維數組轉換為方陣（非對角線元素為0）
dot 矩陣乘法
trace 計算對角線元素的和
det 計算矩陣行列式
eig 計算方陣的特征值和特征向量
inv 計算方陣的逆
pinv 計算矩陣的Moore-Penrose偽逆
qr 計算QR分解
svd 計算奇異值分解
solve 解線性方程Ax=b，其中A為一個方陣
lstsq 計算Ax=b的最小二乘解
'''

#數組重塑 reshape()
'''
#數組的合并與拆分
concatenate 最一般化的連接，沿一條軸連接一維數組 [兩個數組連接的axis需要規格一致]
vstack，row_stack 以面向行的方式對數組進行堆疊（沿軸0）
hstack 以面向行的方式對數組進行堆疊（沿軸1）
column_stack 類似于hstack，但會先將一維數組轉換為二維列向量
dstack 以面向“深度”的方式對數組進行堆疊（沿軸2）
split 沿指定軸在指定的位置拆分數組
hsplit,vsplit,dsplit split的便捷化函數，分別沿著軸0，1，2進行拆分
'''
# r_對象
# c_對象

arr1=np.arange(1,7).reshape((2,3))
arr2=np.arange(7,13).reshape((2,3))
arr3=np.arange(13,28).reshape((5,3))
#
# print(arr1)
# print(arr2)
#連接
# print(np.concatenate([arr1,arr2],0))
# print(np.concatenate([arr1,arr2],1))
# # print(np.concatenate([arr1,arr3],0))
#
# #堆疊
# print(np.vstack((arr1,arr2)))#垂直堆疊
# print(np.hstack((arr1,arr2)))#水平堆疊

#拆分
print(np.split(arr3,[0,1],axis=1))
arr4=np.random.randn(5,5)
print(arr4)
first,second,third=np.split(arr4,[1,3],axis=0)#其中[1,3]為下刀的位置
# first,second,third=np.split(arr4,[1,3],axis=1)
print(first)
print('888888888888')
print(second)
print('888888888888')
print(third)
print('888888888888')

#堆疊輔助類

arr5=np.arange(6).reshape((3,2))
arr6=np.random.randn(3,2)
#r_用于按行堆疊
print(np.r_[arr5,arr6])

#c_用于按列堆疊
print(np.c_[np.r_[arr5,arr6],np.arange(6)])

#切片直接轉為數組
print(np.c_[1:6,-10:-5])

#元素的重復操作
print(arr5.repeat(3))#按元素
print(arr5.repeat([1,2,3,4,5,6]))#按元素,長度要匹配

#repeat(n,axis)指定軸
print(arr5.repeat(2,0))#按行
print(arr5.repeat(2,1))#按列

#tile
print(np.tile(arr5,(2)))#貼瓷磚
print(np.tile(arr5,(2,3)))#指定每個軸的tile次數

#距離矩陣計算
#給定mxn階矩陣X，滿足X=[x1,x2,...,xn],這里第i列向量是m維向量。  求nxn矩陣，使得Dij=||Xi-Xj||^2
X = np.array([range(0, 500), range(500, 1000)])
m, n = X.shape

t = time.time()
D = np.zeros([n, n])
for i in range(n):
 for j in range(i + 1, n):
  D[i, j] = linalg.norm(X[:, i] - X[:, j]) ** 2
  D[j, i] = D[i, j]
print(time.time() - t)

t = time.time()
D = np.zeros([n, n])
for i in range(n):
 for j in range(i + 1, n):
  d = X[:, i] - X[:, j]
  D[i, j] = np.dot(d, d)
  D[j, i] = D[i, j]
print(time.time() - t)

t = time.time()
G = np.dot(X.T, X)
D = np.zeros([n, n])
for i in range(n):
 for j in range(i + 1, n):
  D[i, j] = G[i, i] - G[i, j] * 2 + G[j,j]
  D[j, i] = D[i, j]
print(time.time() - t)

t = time.time()
G = np.dot(X.T, X)
H = np.tile(np.diag(G), (n, 1))
D = H + H.T - G * 2
print(time.time() - t)