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()