#导入numpy包
import numpy as np
##from numpy import *
#定义数组
#一维数组
a=np.array([1,2,3,4])
#二维数组
b=np.array([(1,2,3),(4,5,6)])
#定义数组类型
c=np.array([(1,2),(3,4)],dtype=complex)
#array([[ 1.+0.j,  2.+0.j],[ 3.+0.j,  4.+0.j]])#数组的维数
a.shape #(4,)
#数组轴的个数
a.ndim #1
#数组的元素类型
a.dtype #dtype('int32')
#数组的元素类型的名称
a.dtype.name #'int32'
#数组中每个元素的字节大小
#一个元素类型为float64的数组itemsiz属性值为8(=64/8)
#一个元素类型为complex32的数组item属性为4(=32/8).
a.itemsize #4
#数组中元素个数
a.size #4#全零数组
np.zeros((2,2))
#全1数组
np.ones((2,3,4))
array([[[ 1.,  1.,  1.,  1.],[ 1.,  1.,  1.,  1.],[ 1.,  1.,  1.,  1.]],[[ 1.,  1.,  1.,  1.],[ 1.,  1.,  1.,  1.],[ 1.,  1.,  1.,  1.]]])
#内容随机并且依赖与内存状态的数组。默认创建的数组类型(dtype)都是float64。
empty((2,2))
#创建数列，并变为三行五列。
np.arange(15).reshape(3,5)#基本运算
a=array([1,2,3])
b=array([4,5,6])
c=b-a #array([3,3,3])
a**2 #array([1,4,9])
a<3 #array([True,True,False],dtype=bool)
## * dot(a,b)(矩阵乘法) 
## *= +=被用来更改已存在数组而不创建一个新的数组
## a.sum() a.sum(axis=0) 计算每一列的总和 a.max() a.min() a.min(axis=1) 计算每一行的最小值#一维数组
#索引
a[2] 
#切片
a[2:4] a[:8:2] a[::-1]#翻转a
#迭代
for i in a:#多维数组
#索引
a[2,3] 
#切片
a[2:4,1] #第三行和第四行的第二个元素
a[:,1] #每一行的第二个元素
a[1:3,:] #第二行和第三行的所有元素
a[-1] #最后一行的元素
#迭代
for row in a:#对每个数组中元素进行运算
for element in a.flat:print (element,end=",")

# Series 是带有标签的一维数组，可以保存任何数据类型（整数，字符串，浮点数，Python对象等）,轴标签统称为索引
# Series 是一个自带索引index 的数组，有三种创建方法
# 由字典创建
dic={'a':1,'b':2,'c':3}
s=pd.Series(dic)
# 由数组创建
arr=np.random.randn(5)
s=pd.Series(arr,name='test')
# 由标量创建
s=pd.Series(2,index=range(3))
#位置下标
s[2] 
#标签索引 
s = pd.Series(np.random.rand(3), index = ['a','b','c'])
s['a']
s[['a','b']]
#切片
s1 = pd.Series(np.random.rand(5))
s2 = pd.Series(np.random.rand(5), index = ['a','b','c','d','e'])
print(s1[1:4],s1[4])
print(s2['a':'c'],s2['c'])
print(s2[0:3],s2[3])
print('-----')
# 注意：用index做切片是末端包含
print(s2[:-1])
print(s2[::2])
# 下标索引做切片，和list写法一样
# 布尔型索引
s = pd.Series(np.random.rand(3)*100)
s[4] = None  # 添加一个空值
print(s)
bs1 = s > 50
bs2 = s.isnull()
bs3 = s.notnull()
print(bs1, type(bs1), bs1.dtype)
print(bs2, type(bs2), bs2.dtype)
print(bs3, type(bs3), bs3.dtype)
print('-----')
# 数组做判断之后，返回的是一个由布尔值组成的新的数组
# .isnull() / .notnull() 判断是否为空值 (None代表空值，NaN代表有问题的数值，两个都会识别为空值)print(s[s > 50])
print(s[bs3])
# 布尔型索引方法：用[判断条件]表示，其中判断条件可以是 一个语句，或者是 一个布尔型数组！#查看头部、尾部数据,默认5条
s.head() s.tail()
# 重新索引reindex
# .reindex将会根据索引重新排序，如果当前索引不存在，则引入缺失值
# fill_value参数：填充缺失值
s1 = s.reindex(['c','b','a'],fill_value=0)
#删除 .drop
s1=s.drop('c')
s2=s.drop(['b','a'])
# drop 删除元素之后返回副本(inplace=False)
#删除缺失值
s.dropna()
# 添加
s1[2] = 2
s2['a'] = 2
# 直接通过下标索引/标签index添加值
s3 = s1.append(s2)
# 通过.append方法，直接添加一个数组
# .append方法生成一个新的数组，不改变之前的数组
In [15]:
# 修改
s['a'] = 2
s[['b','c']] = 2
# 通过索引直接修改，类似序列#获取描述统计信息
s.describe()

# 创建方法
# 由字典创建
dic={'a':[1,2],'b':[2,3],'c':[3,4]}
s=pd.DataFrame(dic)
s1=pd.DataFrame(dic,columns=['b','d'])#重新指定列的顺序，格式为list，如果现有数据中没有该列（比如'd'），则产生NaN值
s2=pd.DataFrame(dic,index=['e','f','g']#重新定义index，格式为list，长度必须保持一致# 由Series组成的字典创建
s1 = {'one':pd.Series(np.random.rand(2)),'two':pd.Series(np.random.rand(3))}  # 没有设置index的Series
s2 = {'one':pd.Series(np.random.rand(2), index = ['a','b']),'two':pd.Series(np.random.rand(3),index = ['a','b','c'])}  # 设置了index的Series
df1 = pd.DataFrame(s1)
df2 = pd.DataFrame(s2)
# 由Seris组成的字典 创建Dataframe，columns为字典key，index为Series的标签（如果Series没有指定标签，则是默认数字标签）
# Series可以长度不一样，生成的Dataframe会出现NaN值# 通过二维数组直接创建
s = np.random.rand(12).reshape(3,4)
df1 = pd.DataFrame(s)
df2 = pd.DataFrame(s, index = ['a', 'b', 'c'], columns = ['one','two','three','four'])  # 可以尝试一下index或columns长度不等于已有数组的情况
# 通过二维数组直接创建Dataframe，得到一样形状的结果数据，如果不指定index和columns，两者均返回默认数字格式
# index和colunms指定长度与原数组保持一致# 由字典组成的列表
dic = [{'one': 1, 'two': 2}, {'one': 5, 'two': 10, 'three': 20}]
print(dic)
df1 = pd.DataFrame(dic)
df2 = pd.DataFrame(dic, index = ['a','b'])
df3 = pd.DataFrame(dic, columns = ['one','two'])
# 由字典组成的列表创建Dataframe，columns为字典的key，index不做指定则为默认数组标签
# colunms和index参数分别重新指定相应列及行标签# 由字典组成的字典
data = {'Jack':{'math':90,'english':89,'art':78},'Marry':{'math':82,'english':95,'art':92},'Tom':{'math':78,'english':67}}
df1 = pd.DataFrame(data)
# 由字典组成的字典创建Dataframe，columns为字典的key，index为子字典的key
df2 = pd.DataFrame(data, columns = ['Jack','Tom','Bob'])
df3 = pd.DataFrame(data, index = ['a','b','c'])
# columns参数可以增加和减少现有列，如出现新的列，值为NaN
# index在这里和之前不同，并不能改变原有index，如果指向新的标签，值为NaN #标签索引 
s = pd.DataFrame(np.random.rand(12).reshape(3,4), index = ['a','b','c'],columns=['one','two','three','four'])
s['one']#只选择一列输出Series
s[['one','two']]#选择多列输出DataFrame
# s[col]一般用于选择列，[]中写列名;s[]中为数字时，默认选择行，且只能进行切片的选择，不能单独选择（s[0]）
s.loc['a']#只选择一行输出Series
s.loc[['a','b']]#选择多行输出DataFrame#切片
s.loc['a':'c']# s.iloc[] - 按照整数位置（从轴的0到length-1）选择行
s.iloc[0]
s.iloc[[3,2,1]]
s.iloc[1:3]
s.iloc[::2]# 布尔型索引
bs1 = s > 50# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
bs2 = s['one']>50# 索引结果保留 单列判断为True的行数据，包括其他列
bs3 = s[['one','two']]>50# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
bs4= s.loc[['a','b']]>50# 索引结果保留 所有数据：True返回原数据，False返回值为NaN# 多重索引：比如同时索引行和列
# 先选择列再选择行 —— 相当于对于一个数据，先筛选字段，再选择数据量
df['a'].loc[['one','three']]   # 选择a列的one，three行
df[['b','c','d']].iloc[::2]   # 选择b，c，d列的one，three行
df[df['a'] < 50].iloc[:2]   # 选择满足判断索引的前两行数据#查看头部、尾部数据,默认5条
s.head() s.tail() 
# .T 转置
# 添加
s['four'] = 2#列
s.loc[4] = 2#行
# 修改
s['a'] = 2
s[['b','c']] = 2
#删除 
del s['one']#删除列
s.drop(['d'], axis = 1)#删除列，需要加上axis = 1，inplace=False → 删除后生成新的数据，不改变原数据# 排序1 - 按值排序 .sort_values
# 同样适用于Series
df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,columns = ['a','b','c','d'])
print(df1.sort_values(['a'], ascending = True))  # 升序
print(df1.sort_values(['a'], ascending = False))  # 降序
# ascending参数：设置升序降序，默认升序
# 单列排序
df2 = pd.DataFrame({'a':[1,1,1,1,2,2,2,2],'b':list(range(8)),'c':list(range(8,0,-1))})
print(df2.sort_values(['a','c']))
# 多列排序，按列顺序排序# 排序2 - 索引排序 .sort_index
df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = [5,4,3,2],columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['h','s','x','g'],columns = ['a','b','c','d'])
print(df1.sort_index())
print(df2.sort_index())
# 按照index排序
# 默认 ascending=True, inplace=False