python學習之數據科學庫

numpy建立數組

#導入numppy庫， 對numpy重命名爲np。
import numpy as np

#1). 建立數組: a, b, c建立的數組相同， 任選一種;
#方法一: 直接將數組/列表傳入array方法中， 將數據類型轉換爲ndarray.
a = np.array([1, 2, 3, 4, 5])
 #array方法傳入的值能夠是range對象
b = np.array(range(1, 6))
print(b)
li = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11.8, 12]
]
#轉換數據類型時能夠經過dtype對數組的全部對象轉換類型. eg： dtype=np.int將元素轉成int
li_ndarray = np.array(li, dtype=np.int)

#方法二: 直接生成指定的數值
c = np.arange(1, 6)
##arange和range的基本語法和參數一致。 arange的優勢: 能夠生成小數區間.
#d = np.arange(2.2, 13.3, 0.2)
#print(a, b, c)

##2). 查看numpy建立的數組類型
print(type(a))
print(type(b))
print(type(c))

#3). 查看數組存儲的數據類型, 常見的數據類型還有哪些?
print(a.dtype)   # 爲何是int64？ 由於硬件架構是64位;

#4). 制定建立的數組的數據類型
d = np.array([1.9, 0, 1.3, 0], dtype=np.float)
print(d, d.dtype)
#5). 修改數組的數據類型
e = d.astype('int64')   # 裏面能夠是數據類型， 也能夠是數據代碼;int64---i1
print(e, e.dtype)

#6). 修改浮點數的小數點位數
#隨機建立一個三行四列的數組;
f = np.random.random((3, 4))
print(f)

#修改浮點值的小數位數爲3位
g = np.round(f, 3)
print(g)

矩陣的轉置

import numpy as np

#size = (3, 4) , 生成一個0~1之間的數值, 數值的個數3*4=12個.
#12 = 1*12 = 2*6 = 3*4 = 4*3 = 6*2 = 12*1
#data = np.random.random(size=(3, 4))
data = np.random.random((3, 4))

#轉換數據結構 # 2,6
data = data.reshape((2, 6))

"""
什麼叫轉置?
    1). 原先矩陣的行變成如今矩陣的列
    2). 將A的全部元素繞着一條從第1行第1列元素出發的右下方45度的射線做鏡面反轉，即獲得A的轉置。

案例: 
    # 3*2
    a = [
         [1, 2], 
         [3, 4], 
         [5, 6],    
    ]    

    #轉置
    b = [
        1   3   5 
        2   4   6
    ]  
"""
print(data)
print(data.shape)
print("轉置: ", data.T)
print("轉置: ", data.transpose())
#numpy裏面軸分爲0軸(x行)和1軸(y列)
print("轉置: ", data.swapaxes(1, 0))

numpy的索引和切片

import numpy as np

#1). 生成測試數據
#np.arange(12)  ==> ndarray:[0 1 2 3 4 5 6 7 8 9 10 11]
#reshape((3, 4))  ===>
a = np.arange(12).reshape((3, 4))

print(a)

#*****************取單行或者單列*********************
#取第2行; a[i]=> 獲取第i+1行
print("第2行內容: ", a[1])
#取第3列;a[:,i] => 獲取第i+1列
print("第2列內容: ",a[:, 2])
#獲取第2行3列的數據; a[i, j] ===> 獲取第i+1行j+1列
print("第2行3列的內容: ", a[1, 2])

#*****************取連續行或者列*********************
#取第2行和第3行; a[i:j]===> 獲取第i+1行到第j行
print(a[1:3])

#取第3列和第4列； a[:, i:j] ===> 獲取第i+1列到第j列
print(a[:, 2:4])

#行： 1和2   列: 2, 獲取前2行裏面的第2列
print(a[0:2, 1:2])

"""
需求:拿出2*2的數組
    1 2
    5 6 
1). 先獲取前2行
2). 在前2行的基礎上獲取第2列和第3列      
"""
print(a[:2, 1:3])

#*****************取不連續的行或者列*********************
#行： 1和3   列: all 獲取第一行和第三行的全部元素
print(a[[0, 2], :])
#行: all   列: 1, 4
print(a[:, [0, 3]])
#行： 1 , 3   列： 1 4  獲取第一行第一列的元素， 和第三行第4列的元素
print("*"*10)
print(a[[0, 2], [0, 3]])

numpy數值的修改

import numpy as np

#執行行和指定列的修改
t = np.arange(24).reshape((4, 6))
print(t)

#方法一: 根據索引/切片對元素進行賦值。
#行： all, 列: 3,4
#索引的思路: 2~4-1  列: 3~4
#行/列的位置: 3~4
t[:, 2:4] = 0
print(t)

#方法二: 布爾索引, 知足條件/Bool=True，則賦值， 不然， 不作修改
#返回的是矩陣(和t的size同樣), 存儲的是Bool類型
print(t < 10)

t[t < 10] = 100
print(t)

t[t > 20] = 200
print(t)

#方法三: numpy的三元運算符 t<100?0:10
# 知足條件/Bool=True，則賦值=value1， 不然，賦值=value2
t1  = np.where(t < 100, 0, 10)
print(t)
print(t1)

獲取矩陣的四角元素

"""
獲取了 4X3 數組中的四個角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。

 1 2 3 4
 5 6 7 8
 9 10 11

"""

import numpy as np
def get_edge(data):
    """獲取了數組中的四個角的元素"""
    row, column = data.shape
    rows = np.array([[0, 0], [row - 1, row - 1]])
    cols = np.array([[0, column - 1], [0, column - 1]])
    return  data[rows, cols]

if __name__ == '__main__':
    x = np.arange(30).reshape((5, 6))
    print("data：", x)
    print("result: ", get_edge(x))

#x = np.arange(12).reshape((4, 3))
#print('咱們的數組是：')
#print(x)
##獲取四角元素， 它對應的索引是什麼?
##0=(0,0)  2=(0,2) 9=(3,0)  11=(3,2)

#row, column = x.shape  # row=4 column=3
##rows = np.array([[0, 0], [3, 3]])   # 獲取的行信息
##cols = np.array([[0, 2], [0, 2]])   # 獲取的列信息

#rows = np.array([[0, 0], [row-1, row-1]])
#cols = np.array([[0, column-1], [0, column-1]])
#y = x[rows, cols]
#print('這個數組的四個角元素是：')
#print(y)

數組形狀的修改

"""
    reshape 不改變數據的條件下修改形狀
         numpy.reshape(arr, newshape, order='C')
         order：'C' -- 按行，'F' -- 按列，'A' -- 原順序，'k' -- 元素在內存中的出現順序。
    flat    數組元素迭代器

    flatten 返回一份數組拷貝，對拷貝所作的修改不會影響原始數組
    ravel   返回展開數組
"""

import numpy as np

print("****************************************flat********************************")
a = np.arange(9).reshape(3, 3)
print('原始數組：')
for row in a:
    print(row)

##對數組中每一個元素都進行處理(展開)，可使用flat屬性，該屬性是一個數組元素迭代器：
print('迭代後的數組：')
for element in a.flat:
    print(element)

print("*********************************flatten**************************************")
a = np.arange(8).reshape(2, 4)

print('原數組：')
print(a)
print('\n')
 默認按行

print('展開的數組：')
print(a.flatten())
print('\n')

print('以 F 風格順序展開的數組：')
print(a.flatten(order='F'))

print("*********************************ravel*************************************")
a = np.arange(8).reshape(2, 4)

print('原數組：')
print(a)
print('\n')

print('調用 ravel 函數以後：')
print(a.ravel())
print('\n')

print('以 F 風格順序調用 ravel 函數以後：')
print(a.ravel(order='F'))

數組拼接

"""
concatenate 鏈接沿現有軸的數組序列
stack   沿着新的軸加入一系列數組。
hstack  水平堆疊序列中的數組（列方向）
vstack  豎直堆疊序列中的數組（行方向）

"""

import numpy as np

print("******************** concatenate ****************")
a = np.array([[1, 2], [3, 4]])
print('第一個數組：')
print(a)
print('\n')

b = np.array([[5, 6], [7, 8]])
print('第二個數組：')
print(b)
print('\n')

##兩個數組的維度相同
##x軸和y軸， 0軸和1軸
#print('沿軸 0 鏈接兩個數組：')
print(np.concatenate((a, b)))
print('\n')

#print('沿軸 1 鏈接兩個數組：')
print(np.concatenate((a, b), axis=1))

 print("*************************stack*********************************")
#a = np.array([[1, 2], [3, 4]])
#print('第一個數組：')
#print(a)
#print('\n')
#b = np.array([[5, 6], [7, 8]])

#print('第二個數組：')
#print(b)
#print('\n')
#print('沿軸 0 堆疊兩個數組：')
#stack_0 = np.stack((a, b), axis=-1)
#print(stack_0)
#print(stack_0.shape)
#print('\n')
#print('沿軸 1 堆疊兩個數組：')
#print(np.stack((a, b), axis=1))

print("**************************************hstack + vstack*************************************")
a = np.array([[1, 2], [3, 4]])

print('第一個數組：')
print(a)
print('\n')
b = np.array([[5, 6], [7, 8]])

print('第二個數組：')
print(b)
print('\n')

print('水平堆疊：')
c = np.hstack((a, b))
print(c)
print('\n')

print('豎直堆疊：')
c = np.vstack((a, b))
print(c)
print('\n')

數組分割

"""
    split   將一個數組分割爲多個子數組
        numpy.split(ary, indices_or_sections, axis)
    hsplit  將一個數組水平分割爲多個子數組（按列）
    vsplit  將一個數組垂直分割爲多個子數組（按行）
"""

import numpy as np

print("**********************split******************************")
a = np.arange(9)
print('第一個數組：')
print(a)
print('\n')

print('將數組分爲三個大小相等的子數組：')
b = np.split(a, 3)
print(b)
print('\n')

print('將數組在一維數組中代表的位置分割：')
b = np.split(a, [1, 7])
print(b)

print('******************hsplit*****************')
harr = np.arange(12).reshape((3, 4))
print('原array：')
print(harr)

print('橫向拆分後：')
print(np.hsplit(harr, 2))

print("***************************vsplit****************************")

a = np.arange(12).reshape(4, 3)

print('第一個數組：')
print(a)
print('\n')

print('豎直分割：')
b = np.vsplit(a, 2)
print(b)

數組元素的添加與刪除

"""
    resize  返回指定形狀的新數組
    append  將值添加到數組末尾
    insert  沿指定軸將值插入到指定下標以前
    delete  刪掉某個軸的子數組，並返回刪除後的新數組
    unique  查找數組內的惟一元素
            arr：輸入數組，若是不是一維數組則會展開
            return_index：若是爲true，返回新列表元素在舊列表中的位置（下標），並以列表形式儲
            return_counts：若是爲true，返回去重數組中的元素在原數組中的出現次數

"""
import numpy as np

print('***************append****************')
a = np.array([[1, 2, 3], [4, 5, 6]])

print('第一個數組：')
print(a)
print('\n')

print('向數組添加元素：')
#沒有指定行/列追加元素時， 默認先把前面的元素展開，再追加
print(np.append(a, [7, 8, 9]))      # [1 2 3 4 5 6 7 8 9]
print('\n')

print('沿軸 0 添加元素：')
print(np.append(a, [[7, 8, 9]], axis=0))
print('\n')

print('沿軸 1 添加元素：')
print(np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1))

print('******************************insert****************************************')
a = np.array([[1, 2], [3, 4], [5, 6]])

print('第一個數組：')
print(a)
print('\n')

print('未傳遞 Axis 參數。 在插入以前輸入數組會被展開。')
print(np.insert(a, 3, [11, 12]))
print('\n')

print('傳遞了 Axis 參數。 會廣播值數組來配輸入數組。')
print('沿軸 0 廣播：')
print(np.insert(a, 1, [11, 100], axis=0))
print('\n')

print('沿軸 1 廣播：')
print(np.insert(a, 1, [11,12, 13], axis=1))

print('***********************delete******************************************')
a = np.arange(12).reshape(3, 4)

print('第一個數組：')
print(a)
print('\n')

print('未傳遞 Axis 參數。 在插入以前輸入數組會被展開。')
print(np.delete(a, 5))
print('\n')

print('刪除第二列：')
print(np.delete(a, 1, axis=1))
print('\n')

print('刪除第二行：')
print(np.delete(a, 1, axis=0))
print('\n')

print('包含從數組中刪除的替代值的切片：')
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
"""
np.s_ 爲陣列創建索引元組的一種更好的方法。 返回的時slice對象;
也可使用`Slice()‘加上一些特殊的對象來完成全部這些操做但這個版本更簡單，由於它使用了標準的數組索引語法。
"""
print(np.delete(a, np.s_[::2]))

print("刪除二維數組")
data = np.arange(12).reshape((3, 4))
print("數組元素:")
print(data)
#行：  列: 2列開始
print(np.delete(data, np.s_[::2], axis=0))
print(np.delete(data, np.s_[::2], axis=1))

print('****************************unique**********************************************')

a = np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9])

print('第一個數組：')
print(a)
print('\n')

print('第一個數組的去重值：')     # [2 5 6 7 8 9]
u = np.unique(a)
print(u)
print('\n')

print('去重數組的索引數組：')     # [a.index(2), a.index(5), ........a.index(9)]
u, indices = np.unique(a, return_index=True)
print(indices)
print('\n')

print('返回去重元素的重複數量：')
u, indices = np.unique(a, return_counts=True)
print(u)
print(indices)

numpy統計函數

"""
numpy.amin() 用於計算數組中的元素沿指定軸的最小值。
numpy.amax() 用於計算數組中的元素沿指定軸的最大值。
numpy.ptp()函數計算數組中元素最大值與最小值的差（最大值 - 最小值）。
numpy.percentile() 百分位數是統計中使用的度量，表示小於這個值的觀察值的百分比。
numpy.median() 函數用於計算數組 a 中元素的中位數（中值）

#平均值， 各個值的比重/權重同樣. 語文: 100 數學:70 英語: 80 (100+70+80)/3
numpy.mean() 函數返回數組中元素的算術平均值。 若是提供了軸，則沿其計算。
#加權平均值， 各個值的比重/權重不同. 語文: 100 (40%)數學:70(40%) 英語: 80(20%) (10040%+7040%+80*20%)/3
numpy.average() 函數根據在另外一個數組中給出的各自的權重計算數組中元素的加權平均值。 average()

np.std() 標準差是一組數據平均值分散程度的一種度量。
標準差公式以下：std = sqrt(((x - x.mean())2))/n
np.var() 統計中的方差（樣本方差）是每一個樣本值與全體樣本值的平均數之差的平方值的平均數，即 ((x - x.mean()) 2)/n。
標準差是方差的平方根。

# numpy學生身高體重統計分析案例

需求1:
    獲取全部男生的身高, 求平均值;獲取全部女生的身高, 求平均值;並繪製柱狀圖顯示
    1). 讀取文件中的Sex和Height
    2). 根據布爾索引判斷姓名， 獲取男性的身高或者女性的身高  data['gender'] == 'M'
    3). 求平均值mean函數

需求2:
    獲取全部男生的體重, 求平均值;獲取全部女生的體重, 求平均值;並繪製柱狀圖顯示

"""
import numpy as np
def get_avg_height():
    fname = "doc/eg6-a-student-data.txt"
            # 定義讀取列的數據類型
    dtype = np.dtype([('gender', '|S1'), ('height', 'f2')])
            # 讀取文件的第2列和第3列， 前9行忽略;
    data = np.loadtxt(fname=fname, dtype=dtype, skiprows=9,
                      usecols=(1, 3))
            # print(data)
                # print(type(data))         # 經過np加載文件， 返回的是ndarray的數據類型
                    # print(data['gender'])     # 獲取gender列信息
                        # print(data['height'])     # 獲取height列信息

                            # print(data['height'][data['gender'] == b'M'].mean())
                                # print(data['height'][data['gender'] == b'F'].mean())

                            # 判斷是否性別爲那男的表達式
    isMale = (data['gender'] == b'M')
    male_avg_height = data['height'][isMale].mean()
                # ~表明取反
    female_avg_height = data['height'][~isMale].mean()
    return male_avg_height, female_avg_height
def parser_weight(weight):
    # 對於體重數據的處理, 若是不能轉換爲浮點數據類型, 則返回缺失值;
    try:
        return  float(weight)
    except ValueError as e:
        return  -99
def get_avg_weight():
    fname = "doc/eg6-a-student-data.txt"
                # 定義讀取列的數據類型
    dtype = np.dtype([('gender', '|S1'), ('weight', 'f2')])
                    # 讀取文件的第2列和第4列， 前9行忽略;
    data = np.loadtxt(fname=fname, dtype=dtype, skiprows=9,
                      usecols=(1, 4), converters={4:parser_weight})

                # 判斷是否性別爲男的平均身高
    isMale = data['gender'] == b'M'

            # 判斷是否性別爲男的平均體重
    is_weight_vaild = data['weight'] > 0
    male_avg_weight = data['weight'][isMale & is_weight_vaild].mean()
    female_avg_weight = data['weight'][~isMale & is_weight_vaild].mean()
    return  male_avg_weight, female_avg_weight
if __name__ == '__main__':
    print(get_avg_height())
    print(get_avg_weight())
"""

基於numpy的股價統計分析和應用

#股票數據信息的獲取
    1. 網絡爬蟲
    2. 網站下載： 專門的股票網站, Kaggle(數據分析和機器學習交流的網站)
    3. 使用已經開發好的股票API接口： tushare

data.csv文件中存儲了股票的信息， 其中第4-8列,即EXCEL表格中的D-H列,(K線=)
分別爲股票的開盤價,最高價,最低價,收盤價,成交量。
分析角度:
    1. 計算成交量加權平均價格
    概念:成交量加權平均價格,英文名VWAP(Volume-Weighted Average Price,成交量加權平均價格)是一個很是重要的經
    濟學量,表明着金融資產的「平均」價格。
    某個價格的成交量越大,該價格所佔的權重就越大。VWAP就是以成交量爲權重計算出來的加權平均值。

    2. 計算最大值和最小值: 計算股價近期最高價的最大值和最低價的最小值
    3. 計算股價近期最高價的最大值和最小值的差值;----(極差)
    計算股價近期最低價的最大值和最小值的差值
    4. 計算收盤價的中位數
    5. 計算收盤價的方差
    6. 計算對數收益率， 股票收益率、年波動率及月波動率
     ***收盤價的分析經常是基於股票收益率的。
     股票收益率又能夠分爲簡單收益率和對數收益率。
            簡單收益率：是指相鄰兩個價格之間的變化率。  diff
            對數收益率：是指全部價格取對數後兩兩之間的差值。
            #[1, 2,3 4]   ======>[-1, ]
    ***使用的方法: NumPy中的diff函數能夠返回一個由相鄰數組元素的差值構成的數組。
    不過須要注意的是，diff返回的數組比收盤價數組少一個元素。
    ***在投資學中,波動率是對價格變更的一種度量,歷史波動率能夠根據歷史價格數據計算得出。計算曆史波動率時,須要用
    到對數收益率。
        年波動率等於對數收益率的標準差除以其均值,再乘以交易日的平方根,一般交易日取252天。
        月波動率等於對數收益率的標準差除以其均值,再乘以交易月的平方根。一般交易月取12月。
    7. 獲取該時間範圍內交易日周1、周2、周3、周4、週五分別對應的平均收盤價
    8. 平均收盤價最低,最高分別爲星期幾

"""
import numpy as np

print("**********************************************")

#收盤價,成交量
endPrice, countNum = np.loadtxt(
    fname="doc/data.csv",
    delimiter=",",  # 指定文件分隔符;
    usecols=(6, 7),
    unpack=True)
#print(endPrice, countNum)
VWAP = np.average(endPrice, weights=countNum)  # 價格的權重和成交量成正比
print("1. 計算成交量加權平均價格：", VWAP)

print("**********************************************")

#最高價和最低價
highPrice, lowPrice = np.loadtxt(
    fname="doc/data.csv",
    delimiter=",",
    usecols=(4, 5),
    #對於返回的數據進行解包， 有幾列信息返回幾個數據， 解包幾個數據。
    unpack=True
)

print(highPrice, lowPrice)
#最高價的最大值和最低價的最小值
print("2.最高價的最大值： ", highPrice.max())
print("2.最低價的最小值： ", lowPrice.min())

print("**********************************************")
#計算股價近期最高價的最大值和最小值的差值;----(極差)
#計算股價近期最低價的最大值和最小值的差值

print("3. 近期最高價的極差： ", np.ptp(highPrice))
print("3. 近期最低價的極差： ", np.ptp(lowPrice))

print("**********************************************")
#計算收盤價的中位數
print("4. 計算收盤價的中位數:", np.median(endPrice))

print("**********************************************")
#計算收盤價的方差
print("5. 計算收盤價的方差:", np.var(endPrice))

print("**********************************************")

def get_week(date):
    """根據傳入的日期28-01-2011獲取星期數, 0-星期一 1-"""
    from datetime import datetime
    #默認傳入的不是字符串， 是bytes類型;
    date = date.decode('utf-8')
    """
    Monday == 0 ... Sunday == 6
    """
    return datetime.strptime(date, "%d-%m-%Y").weekday()
#星期數和收盤價
week, endPrice = np.loadtxt(
    fname="doc/data.csv",
    delimiter=",",
    usecols=(1, 6),
    converters={1: get_week},
    unpack=True
)
#print(week, endPrice)
allAvg = []
for weekday in range(5):
    # 依次判斷獲取星期一的平均收盤價, .......星期五
    average = endPrice[week == weekday].mean()
    allAvg.append(average)
    print("7. 星期%s的平均收盤價：%s" % (weekday + 1, average))

print(allAvg)

print("**********************************************")
#[12, 23, 34, 45, 56]

print("8.平均收盤價最低是星期", np.argmin(allAvg) + 1)
print("8. 平均收盤價最高是星期", np.argmax(allAvg) + 1)

print("***********************************************************")
#簡單收益率
simpleReturn = np.diff(endPrice)
print(simpleReturn)
#對數收益率: 全部價格取對數後兩兩之間的差值。
logReturn = np.diff(np.log(endPrice))
print("6. 對數收益率:", logReturn)
#年波動率等於對數收益率的標準差除以其均值,再乘以交易日的平方根,一般交易日取252天。
annual_vol = logReturn.std() / logReturn.mean() * np.sqrt(252)
print("6. 年波動率:", annual_vol)
#月波動率等於對數收益率的標準差除以其均值,再乘以交易月的平方根。一般交易月取12月。
month_vol = logReturn.std() / logReturn.mean() * np.sqrt(12)
print("6. 月波動率:", month_vol)

pandas建立series數據類型

"""
Pandas是一個強大的分析結構化數據的工具集；它的使用基礎是Numpy（提供高性能的矩陣運算）；用於數據挖掘和數據分析，同時也提供數據清洗功能。
利器之一：Series
    相似於一維數組的對象，是由一組數據(各類NumPy數據類型)以及一組與之相關的數據標籤(即索引)組成。僅由一組數據也可產生簡單的Series對象。
利器之二：DataFrame
    是Pandas中的一個表格型的數據結構，包含有一組有序的列，每列能夠是不一樣的值類型(數值、字符串、布爾型等)，DataFrame即有行索引也有列索引，能夠被看作是由Series組成的字典。

常見的數據類型:
    - 一維: Series
    - 二維: DataFrame
    - 三維: Panel  ....
    - 四維: Panel4D  .....
    - N維: PanelND  ....

Series是Pandas中的一維數據結構，相似於Python中的列表和Numpy中的Ndarray，不一樣之處在於：Series是一維的，能存儲不一樣類型的數據，有一組索引與元素對應。
"""

import pandas as pd
import numpy as np
import  string

#查看pandas版本信息
print(pd.__version__)

#********************建立Series對象
#1). 經過列表建立Series對象
array = ["粉條", "粉絲", "粉帶"]
#若是不指定索引， 默認從0開始;
s1 = pd.Series(data=array)
print(s1)
#若是不指定索引， 默認從0開始;
ss1 = pd.Series(data=array, index=['A', 'B', 'C'])
print(ss1)

#2). 經過numpy的對象Ndarray建立Series；
n = np.random.randn(5)   # 隨機建立一個ndarray對象;
s2 = pd.Series(data=n)
print(s2)
#修改元素的數據類型;
ss2 = s2.astype(np.int)
print(ss2)

#3). 經過字典建立Series對象;字典的全部key值做爲索引， 全部的value值做爲Series值
#{'key1':'value1', "key2":'value2'}
#字典生成式
dict = {string.ascii_lowercase[i]:i for i in range(10)}
print(dict)
s3 = pd.Series(dict)
print(s3)

Series 基本操做:

編號 屬性或方法 描述
1 axes 返回行軸標籤列表。
2 dtype 返回對象的數據類型(dtype)。
3 empty 若是系列爲空，則返回True。
4 ndim 返回底層數據的維數，默認定義：1。
5 size 返回基礎數據中的元素數。
6 values 將系列做爲ndarray返回。
7 head() 返回前n行。
8 tail() 返回最後n行。

"""

import pandas as pd
import numpy as np
import string

array = ["粉條", "粉絲", "粉帶"]
s1 = pd.Series(data=array)
print(s1)
print(s1.axes) # [RangeIndex(start=0, stop=3, step=1)]
print(s1.dtype)
print(s1.empty) # False
print(s1.ndim ) # 維度1
print(s1.size) # 3
print(s1.values) # 獲取全部的value值(不顯示索引)

#1). 修改Series索引
print(s1.index)
s1.index = ['A', 'B', 'C']
print(s1)

#2). Series縱向拼接;
array = ["粉條", "粉絲", "westos"]
#若是不指定索引， 默認從0開始;
s2 = pd.Series(data=array)
s3 = s1.append(s2)
print(s3)

#3). 刪除指定索引對應的元素;
s3 = s3.drop('C') # 刪除索引爲‘C’對應的值;
print(s3)

#4). 根據指定的索引查找元素
print(s3['B'])
s3['B'] = np.nan # None, null, pandas數據爲空, 或者數據缺失, np.nan
print(s3)

#5). 切片操做 --- 同列表
print(s3[:2]) # 獲取前2個元素
print(s3[::-1]) # 元素進行反轉
print(s3[-2:]) # 顯示最後兩個元素

series運算

import numpy as np
import pandas as pd

#values = [0, 1, 2, 3, 4], index=['a', 'b', 'c', 'd', 'e']
s1 = pd.Series(np.arange(5), index=['a', 'b', 'c', 'd', 'e'])  # s1.index=[a, b, c, d, e]   s1.value=[0 1 2 3 4]
#values = [2, 3, 4, 5, 6, 7], index=['c', 'd', 'e', 'f', 'g', 'h']
s2 = pd.Series(np.arange(2, 8), index=['c', 'd', 'e', 'f', 'g', 'h'])  # s2.index = [c,d,e,f]

print(s1)
#print(s2)
##*****************按照對應的索引進行計算， 若是索引不一樣，則填充爲Nan;
##加法, 缺失值+ 真實值===缺失值
#print(s1 + s2)
#print(s1.add(s2))

#print(s1 - s2)
#print(s1.sub(s2))

#print(s1 * s2)
#print(s1.mul(s2))

#print(s1 / s2)
#print(s1.div(s2))

#求中位數
print(s1)
print(s1.median())

#求和
print(s1.sum())

#max
print(s1.max())

#min
print(s1.min())

特殊的where方法

import pandas as pd
import numpy as np
import string

#&**********series中的where方法運行結果和numpy中徹底不一樣;
s1 = pd.Series(np.arange(5), index=['a', 'b', 'c', 'd', 'e'])
#判斷s1的value值是否大於3， 若是大於3，值不變， 不然，設置爲缺失值
print(s1.where(s1 > 3))

#對象中不大於3的元素賦值爲10；判斷s1的value值是否大於3， 若是大於3，值不變， 不然，設置值爲10
print(s1.where(s1 > 3, 10))

#對象中大於3的元素賦值爲10；
print(s1.mask(s1 > 3))
print(s1.mask(s1 > 3, 10))
"""

建立dataframe數據類型

Series只有行索引，而DataFrame對象既有行索引，也有列索引
    行索引，代表不一樣行，橫向索引，叫index，
    列索引，代表不一樣列，縱向索引，叫columns，

"""

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

#方法1： 經過列表建立
li = [
    [1, 2, 3, 4],
    [2, 3, 4, 5]
]

#DataFRame對象裏面包含兩個索引， 行索引(0軸， axis=0)， 列索引(1軸， axis=1)
d1 = pd.DataFrame(data=li, index=['A', 'B'], columns=['views', 'loves', 'comments', 'tranfers'])
print(d1)

#方法2： 經過numpy對象建立
#[0 1 2 3 4 5 6 7]  ====> [[0 1 2 3], [4 5 6 7]]
narr = np.arange(8).reshape(2, 4)
#DataFRame對象裏面包含兩個索引， 行索引(0軸， axis=0)， 列索引(1軸， axis=1)
d2 = pd.DataFrame(data=narr, index=['A', 'B'], columns=['views', 'loves', 'comments', 'tranfers'])
print(d2)

#方法三: 經過字典的方式建立;
dict = {
    'views': [1, 2, ],
    'loves': [2, 3, ],
    'comments': [3, 4, ]

}
d3 = pd.DataFrame(data=dict, index=['粉條', "粉絲"])
print(d3)

#日期操做的特例:
#pd.date_range()
dates = pd.date_range(start='1/1/2019', end='1/08/2019')
print(dates)

#行索引
dates = pd.date_range(start='today', periods=6, freq='2D' ) # periods=6從今天開始向後產生6個日期
print(dates)

#列索引
columns = ['A', 'B', 'C', 'D']
d4 = pd.DataFrame( np.random.randn(6, 4), index=dates, columns=columns)
print(d4)

#一維對象: 創建一個以2019年每一天做爲索引， 值爲隨機數；
dates = pd.date_range(start='1/1/2021', end='1/3/2021', freq='D')
print(dates)
s1 = pd.Series([1, 2, 3], index=dates)
print(s1)

dataframe基礎屬性和總體狀況查詢

"""
a)基礎屬性
    df.shape  #行數、列數
    df.dtype #列數據類型
    df.ndim #數據維度
    df.index #行索引
    df.columns #列索引
    df.values #對象值，二維ndarray數組

b)總體狀況查詢
    df.head(3) #顯示頭部幾行，默認5行
    df.tail(3) #顯示末尾幾行，默認5行
    df.info() #相關信息概覽：行數、列數、索引、列非空值個數、列類型、內存佔用
    df.describe() #快速綜合統計結果： 計數、均值、標準差、最大值、四分位數、最小值等

"""

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

narr = np.arange(8).reshape(2, 4)
#DataFRame對象裏面包含兩個索引， 行索引(0軸， axis=0)， 列索引(1軸， axis=1)
d2 = pd.DataFrame(data=narr, index=['A', 'B'], columns=['views', 'loves', 'comments', 'tranfers'])
print(d2)

#**********************1). 查看基礎屬性***********************
print(d2.shape)  # 獲取行數和列數;
print(d2.dtypes)  # 列數據類型
print(d2.ndim)  # 獲取數據的維度
print(d2.index)  # 行索引
print(d2.columns)  # 列索引
print(d2.values, type(d2.values))  # 對象的值， 二維ndarray數組;

#******************************2). 數據總體情況的查詢*************
print(d2.head(1))  # 顯示頭部的幾行， 默認5行
print(d2.tail(1))  # 顯示頭部的尾行， 默認5行

print("*" * 10)
#相關信息的預覽： 行數， 列數， 列類型， 內存佔用
print("info:", d2.info())

print("統計".center(50, '*'))
#快速綜合用計結果： 計數， 均值， 標準差， 最小值， 1/4位數， 中位數， 3/4位數， 最大值;
print(d2.describe())

#3). 轉置操做
print("d2: \n", d2)
#print("d2 T: \n", d2.transpose())
print("d2 T: \n", d2.T)
#print("d2 T: \n", d2.swapaxes(1, 0))

#4). 按列進行排序
print(d2)
#按照指定列進行排序， 默認是升序， 若是須要降序顯示，設置ascending=False;
print(d2.sort_values(by=["views", 'tranfers'], ascending=False))

#5). 切片及查詢
print(d2)
print(d2[:2])  # 能夠實現切片， 可是不能索引;
print('1:\n', d2['views'])  # 經過標籤查詢， 獲取單列信息
print('2:\n', d2.views)  # 和上面是等價的;
print(d2[['views', 'comments']])  # 經過標籤查詢多列信息

#6). 經過相似索引的方式查詢;
        #       - iloc(經過位置進行行數據的獲取),
        #        - loc(t經過標籤索引行數據)
            # print(d2[0])
                # print(d2)
print(d2.iloc[0])
print(d2.iloc[-1])

            # print(d2['A'])    # 報錯
print(d2)
print(d2.loc['A'])

        # 7). 更改pandas的值；
d2.loc['A'] = np.nan
print(d2)

print(d2.info())

文件的讀取與寫入

import os

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

#csv, excel, json........
#). csv文件的寫入

df = pd.DataFrame(
    {'province': ['陝西', '陝西', '四川', '四川', '陝西'],
     'city': ['咸陽', '寶雞', '成都', '成都', '寶雞'],
     'count1': [1, 2, 3, 4, 5],
     'count2': [1, 2, 33, 4, 5]
     }
)

print(df)

filename = os.path.join('doc', 'csvFile.csv')
"""
index=True/False   是否存儲行索引, 通常狀況下不存儲
mode='w'           文件寫入的方式, 默認是'w'(清空原有的文件內容, 再寫入), 'a'追加
header=True/False  是否寫入頭部信息(列索引), 通常狀況是須要的
"""
#df.to_csv(filename, index=False, mode='a', header=False, sep=' ')  # index=False不存儲行索引
#print("csv文件保存成功")

##2). csv文件的讀取
#df2 = pd.read_csv('doc/csvFile.csv')
#print(df2)

#3). excel文件的寫入
df.to_excel("doc\excelFile.xlsx", sheet_name="省份統計", index=False)
print("excel文件保存成功")

分組與聚合操做之group_by

"""
pandas提供了一個靈活高效的groupby功能，
    1). 它使你能以一種天然的方式對數據集進行切片、切塊、摘要等操做。
    2). 根據一個或多個鍵（能夠是函數、數組或DataFrame列>名）拆分pandas對象。
    3). 計算分組摘要統計，如計數、平均值、標準差，或用戶自定義函數。

"""

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

df = pd.DataFrame(
    {'province': ['陝西', '陝西', '四川', '四川', '陝西'],
     'city': ['咸陽', '寶雞', '成都', '成都', '寶雞'],
     'count1': [1, 2, 3, 4, 5],
     'count2': [1, 2, 33, 4, 5]
     }
)
        # 陝西      咸陽    1
        #          寶雞     1

print(df)
    # 根據某一列的key值進行統計分析;
grouped = df['count1'].groupby(df['province'])
print(grouped.describe())
print(grouped.median())

    # 根據城市統計分析cpunt1的信息;
grouped = df['count1'].groupby(df['city'])
print(grouped.max())

    # 指定多個key值進行分類聚合;
grouped = df['count1'].groupby([df['province'], df['city']])
print(grouped.max())
print(grouped.sum())
print(grouped.count())

    #  經過unstack方法， 實現層次化的索引;
print(grouped.max().unstack())

案例：商品數據分析案例

"""
文件描述: 每列數據分別表明以下: 訂單編號, 訂單數量, 商品名稱， 商品詳細選擇項， 商品總價格
需求1：
    1). 從文件中讀取全部的數據;  如何讀取csv文件? to_csv
    2). 獲取數據中全部的商品名稱；如何獲取dataframe對象中的某一列信息? df['列名'], df.列名稱
    3）. 跟據商品的價格進行排序， 降序，   如何對df對象排序? d2.sort_values(by=["排序的列名稱"], ascending=True)
    將價格最高的20件產品信息寫入mosthighPrice.xlsx文件中;   如何獲取df的前20行並寫入文件? df.head(20)   df1.to_csv(xxxxxx)

需求2：
    1). 統計列[item_name]中每種商品出現的頻率，繪製柱狀圖
            (購買次數最多的商品排名-繪製前5條記錄)
    2). 根據列 [odrder_id] 分組，求出每一個訂單花費的總金額。
    3). 根據每筆訂單的總金額和其商品的總數量畫出散點圖。
"""

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

##需求1：
##1). 從文件中讀取全部的數據;
##2). 獲取數據中全部的商品名稱；
#goodsInfo = pd.read_csv('doc/chipo.csv')
##print(goodsInfo.head())
##print(goodsInfo.tail())
##print(goodsInfo.info())
##print(goodsInfo.describe())
#print("商品名稱顯示: \n", goodsInfo['item_name'].head())
#print("商品名稱顯示: \n", goodsInfo.item_name.head())

##需求1：

 #3). 跟據商品的價格進行排序， 降序，
##將價格最高的20件產品信息寫入mosthighPrice.xlsx文件中;
##從新賦值；
#goodsInfo.item_price = goodsInfo.item_price.str.strip('$').astype(np.float)
#highPriceData = goodsInfo.sort_values('item_price', ascending=False).head(20)
##print(highPriceData.head(5))
#filename = 'doc\mostHighPrice.xlsx'
#highPriceData.to_excel(filename)
#print("保存成功.......")

#需求2：
#1). 統計列[item_name]中每種商品出現的頻率，繪製柱狀圖
#(購買次數最多的商品排名-繪製前5條記錄)
goodsInfo = pd.read_csv('doc\chipo.csv')
#new_info會統計每一個商品名出現的次數;其中 Unnamed: 0就是咱們須要獲取的商品出現頻率；
newInfo = goodsInfo.groupby('item_name').count()
mostRaiseGoods = newInfo.sort_values('Unnamed: 0', ascending=False)['Unnamed: 0'].head(5)
print(mostRaiseGoods)       # Series對象

#獲取對象中的商品名稱;
x = mostRaiseGoods.index
#獲取商品出現的次數;
y = mostRaiseGoods.values

#from pyecharts import Bar
#bar = Bar("購買次數最多的商品排名")
#bar.add("", x, y)
#bar.render(）
#需求2：
#2). 根據列 [odrder_id] 分組，求出每一個訂單花費的總金額======訂單數量(quantity), 訂單總價(item_price)。
#3). 根據每筆訂單的總金額和其商品的總數量畫出散點圖。

goodsInfo = pd.read_csv('doc/chipo.csv')
#獲取訂單數量
quantity = goodsInfo.quantity
#獲取訂單item_price價格
item_price = goodsInfo.item_price.str.strip('$').astype(np.float)
print(item_price)

#根據列 [odrder_id] 分組
order_group = goodsInfo.groupby("order_id")
#每筆訂單的總金額
x = order_group.item_price.sum()
#商品的總數量
y = order_group.quantity.sum()

字符串經常使用操做

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

series1= pd.Series(['$A:1', '$B:2', '$C:3', np.nan, '$cat:3'])
print(series1)

#將全部的字母轉換爲小寫字母， 除了缺失值
print(series1.str.lower())

#將全部的字母轉換爲大寫字母， 除了缺失值
print(series1.str.upper())

#分離
print(series1.str.split(":"))

#去掉左右兩端的某個字符
print(series1.str.strip('$'))
"""

文件內容: 總消費金額， 小費金額， 性別， 是否抽菸， 日期， 時間， 星期
需求:

• 分別吸菸顧客與不吸菸顧客的消費金額與小費之間的散點圖; #
• 女性與男性中吸菸與不吸菸顧客的消費金額與小費之間的散點圖關係;
  """

消費金額和小費之間的關聯與性別和抽菸與否的關係

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt

filename = 'doc/tips.csv'
data = pd.read_csv(filename)
#print(data.head())
#print(data.info())

    # # 實現吸菸顧客消費金額與小費之間的散點圖
    # smoker = data[data['smoker'] == 'Yes']          # 篩選吸菸的顧客信息
    # x_total_bill1 = smoker['total_bill']
    # y_tip1 = smoker['tip']

##實現不吸菸顧客消費金額與小費之間的散點圖
#no_smoker = data[data['smoker'] != 'Yes']
##print(smoker.head())
#x_total_bill2 = no_smoker['total_bill']
#y_tip2 = no_smoker['tip']

#from pyecharts import  Scatter
#scatter = Scatter("吸菸/不吸菸顧客消費金額與小費之間的散點圖")
#添加第1個數據信息: x和y
#scatter.add("吸菸", x_total_bill1, y_tip1)
##添加第2個數據信息: x和y
#scatter.add("不吸菸", x_total_bill2, y_tip2)
#scatter.render()

##女性中吸菸與不吸菸顧客的消費金額與小費之間的散點圖關係;
is_smoker = data['smoker'] == 'Yes'
is_female = data['sex'] == 'Female'

female_smoker = data[is_female & is_smoker]
female_no_smoker = data[is_female & ~is_smoker]
male_smoker = data[~is_female & is_smoker]
male_no_smoker = data[~is_female & ~is_smoker]

#3). 繪製散點圖
from pyecharts import  Scatter
scatter = Scatter("消費金額與小費之間的散點圖")
scatter.add("吸菸女顧客", female_smoker['total_bill'], female_smoker['tip'])
scatter.add("不吸菸女顧客", female_no_smoker['total_bill'], female_no_smoker['tip'])
scatter.add("吸菸男顧客", male_smoker['total_bill'], male_smoker['tip'])
scatter.add("不吸菸男顧客", male_no_smoker['total_bill'], male_no_smoker['tip'])

scatter.render()