pandas稍微比numpy处理数据起来还是要慢一点，pandas呢是numpy的升级版，可以说各有所长，numpy的优势是用来处理矩阵，而pandas的优势是处理数表。
1. Series 线性数表
serier一个线性数表，所谓线性数表就是他的数据比较单一，没有那么多的分类要么行为1要么列为1
通常serier我们用来自动生成数表的列啊，行啊什么的
import pandas as pd
import numpy as np
s = pd.Series([1,3,6,np.nan,44,1])print(s)
"""
0 1.0
1 3.0
2 6.0
3 NaN
4 44.0
5 1.0
dtype: float64
""
2.DataFrame
dataframe是一个支持行索引和列索引的这么一个大型的数表
df2 = pd.DataFrame({'A' : 1.,
'B' : pd.Timestamp('20130102'),
'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
'D' : np.array([3] * 4,dtype='int32'),
'E' : pd.Categorical(["test","train","test","train"]),
'F' : 'foo'})print(df2)"""
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
"""dataframe的简单操作，
df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
1.查看数表的某一列的每个元素的类型
print(df2.dtypes)
2.查看所有的行
print(df2.index)
3.查看所有的列
print(df2.columns)
4.查看所有的值
print(df2.values)
5.查看所有数据的总结
print(df.describe)
6.如果想对数据的 index 进行排序并输出
print(df2.sort_index(axis=1, ascending=False))
7.如果是对数据 值 排序输出:
print(df2.sort_values(by='B'))
8.转置 T
dataframe的增删改查
1.查
查呢有四种方式可以查看，一种就是和list一般直接在list后加上[ ]引用即可，然后就是loc，iloc，ix
loc就要求引用的索引是名字，iloc是序号，而ix两者都可
shubiao = pd.DataFrame(np.arange(24).reshape((6, 4)), index=date, columns=['A', 'B', 'C', 'D'])
print(shubiao)print(shubiao[:'20160208']['A'])
# loc纯标签
print(shubiao.loc[:, 'A': 'B']) # 前后就都可以用了 前行后列
# iloc 纯数字下标
print(shubiao.iloc[0:5, 0:2]) # 由此可见的 标签来引用似乎不满足左闭右开 前行后列
# ix loc与iloc的混合版
print(shubiao.ix[0:3, 'A': 'B']) # 混合版哦 前行后列
2.改
改其实和查是一样的，只不过加上等于即可
3.删
我们要执行删除某行某列操作的时候就需要该行该列存在numpy的NaN元素，这时候我们就可以执行删除操作
# 直接去掉有 NaN 的行或列
shubiao.dropna(axis=0, how='any') # 0 - 对行操作，1 - 对列操作。any - 只要有则删除， all - 全都是则删除
# 将 NaN 的值用其他值代替, 比如代替成 0:
shubiao.fillna(value=0)
# 判断是否有缺失数据nan 为 True 表示缺失数据
shubiao.isnull() # 按照相应的位置返回true or false
# 检测在数据中是否存在 NaN, 如果存在就返回 True:
print(np.any(shubiao.isnull()) == True)
4.增
shubiao.loc['2016-02-14'] = 0 # 增加一行 如果数表之前就有初始index就一定要loc如果没有就可以iloc
shubiao['lpo'] = 0 # 增加一列 值为0
合并
concat合并
# 合并 concat
df = pd.DataFrame(np.arange(12).reshape((3, 4)), columns=['A', 'B', 'C', 'D'], index=[1, 2, 3])
df2 = pd.DataFrame(np.arange(12, 24).reshape((3, 4)), columns=['A', 'B', 'C', 'D'], index=[2, 3, 4])
# 合并第一种情况 列都相同 和并行（上下合并）
res = pd.concat([df, df2], axis=0)
print(res)
# A B C D
# 1 0 1 2 3
# 2 4 5 6 7
# 3 8 9 10 11
# 2 12 13 14 15
# 3 16 17 18 19
# 4 20 21 22 23 # 由此可以看出我们按照行合并的 但是index却并没有自动排序
# 第二种 忽略 index排序 （忽略index生成的res就会自己生成新的index）
res = pd.concat([df, df2], axis=0, ignore_index=True) # ignore_index改为Ture 即可
print(res)
# A B C D
# 0 0 1 2 3
# 1 4 5 6 7
# 2 8 9 10 11
# 3 12 13 14 15
# 4 16 17 18 19
# 5 20 21 22 23# 第三种 但实际上很多时候我们是column是不同的，那我们要合并改怎么合并呢？
df3 = pd.DataFrame(np.arange(12, 24).reshape((3, 4)), columns=['B', 'C', 'D', 'E'], index=[2, 3, 4])
res = pd.concat([df, df3], axis=0)
print(res)
# A B C D E
# 1 0.0 1 2 3 NaN
# 2 4.0 5 6 7 NaN
# 3 8.0 9 10 11 NaN
# 2 NaN 12 13 14 15.0
# 3 NaN 16 17 18 19.0
# 4 NaN 20 21 22 23.0 但是已经爆红了但是结果还是出来了，是因为我们这样合并少了一个参数join
res = pd.concat([df, df3], axis=0, ignore_index=True, join='outer', sort=True) # join有两种参数 outer 与inner
# 这里要加上sort=True 是因为：
# FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
# of pandas will change to not sort by default.
#
# To accept the future behavior, pass 'sort=False'.
#
# To retain the current behavior and silence the warning, pass 'sort=True'.
print(res)
# A B C D E
# 0 0.0 1 2 3 NaN
# 1 4.0 5 6 7 NaN
# 2 8.0 9 10 11 NaN
# 3 NaN 12 13 14 15.0
# 4 NaN 16 17 18 19.0
# 5 NaN 20 21 22 23.0 # 没有的变为nan代替res = pd.concat([df, df3], join='inner', axis=0, ignore_index=True, sort=True)
print(res)
# B C D
# 0 1 2 3
# 1 5 6 7
# 2 9 10 11
# 3 12 13 14
# 4 16 17 18
# 5 20 21 22 把相同column 组合了# 按照某一个df特定 index或者column 合并（也就是说这个df的column，和index 不会变 合并的那个相同的才会合并，没有的补nan）
# 若是按照index 这column不同的会叠加
# 按照df.index合并
res = pd.concat([df, df3], join_axes=[df.index], ignore_index=True, sort=True, axis=1)
print(res)
# 0 1 2 3 4 5 6 7
# 1 0 1 2 3 NaN NaN NaN NaN
# 2 4 5 6 7 12.0 13.0 14.0 15.0
# 3 8 9 10 11 16.0 17.0 18.0 19.0# append 叠加(注叠加后本身没有变需要用一个变量来接受他)
res = df.append([df2, df3], ignore_index=True, sort=True) # df若要“扩大”就必须要sort=True
print(res)# A B C D E
# 0 0.0 1 2 3 NaN
# 1 4.0 5 6 7 NaN
# 2 8.0 9 10 11 NaN
# 3 12.0 13 14 15 NaN
# 4 16.0 17 18 19 NaN
# 5 20.0 21 22 23 NaN
# 6 NaN 12 13 14 15.0
# 7 NaN 16 17 18 19.0
# 8 NaN 20 21 22 23.0
merge合并
right = pd.DataFrame({'key': ['k0', 'k2', 'k2'],
'key1': ['K00', 'K22', 'K22'],
'A': ['A1', 'A2', 'A3'],
'B': ['B1', 'B2', 'B3']})left = pd.DataFrame({'key': ['k1', 'k2', 'k3'],
'key1': ['K11', 'K22', 'K33'],
'C': ['C1', 'C2', 'C3'],
'D': ['D1', 'D2', 'D3']})print(right)
'''
key key1 A B
0 k0 K00 A1 B1
1 k2 K22 A2 B2
2 k2 K22 A3 B3
'''
print(left)
'''
key key1 C D
0 k1 K11 C1 D1
1 k2 K22 C2 D2
2 k3 K33 C3 D3
'''
# 基础的合并 若参数是outer 则先排left，在排right里面多余的，若是inner则合并相同的, right就是以right的为基准没有补nan，left亦然
res = pd.merge(left, right, how='left', on='key') # how = ['left', 'right', 'outer', 'inner']
print(res)
'''
key key1_x C D key1_y A B
0 k1 K11 C1 D1 NaN NaN NaN
1 k2 K22 C2 D2 K22 A2 B2
2 k2 K22 C2 D2 K22 A3 B3
3 k3 K33 C3 D3 NaN NaN NaN
'''res = pd.merge(left, right, how='outer', on=['key', 'key1'])
print(res)
'''
key key1 C D A B
0 k1 K11 C1 D1 NaN NaN
1 k2 K22 C2 D2 A2 B2
2 k2 K22 C2 D2 A3 B3
3 k3 K33 C3 D3 NaN NaN
4 k0 K00 NaN NaN A1 B1
'''
# 由此可见 遍历顺序是由 left来决定的# indicator 会将合并信息放一边
# 例如
res = pd.merge(left, right, how='outer', on=['key', 'key1'], indicator=True)
print(res)
'''
key key1 C D A B _merge
0 k1 K11 C1 D1 NaN NaN left_only
1 k2 K22 C2 D2 A2 B2 both
2 k2 K22 C2 D2 A3 B3 both
3 k3 K33 C3 D3 NaN NaN left_only
4 k0 K00 NaN NaN A1 B1 right_only # only是因为没有的数据补了nan
'''# 按照index合并 类似于pd.concat(join_axes=right.index) #依据左右资料集的index进行合并，how='outer',并打印出right = pd.DataFrame({'key': ['k0', 'k2', 'k2'],
'key1': ['K00', 'K22', 'K22'],
'A': ['A1', 'A2', 'A3'],
'B': ['B1', 'B2', 'B3']},
index=['w', 's', 'd'])left = pd.DataFrame({'key': ['k1', 'k2', 'k3'],
'key1': ['K11', 'K22', 'K33'],
'C': ['C1', 'C2', 'C3'],
'D': ['D1', 'D2', 'D3']},
index=['w', 'a', 'd'])
print(right)
'''
key key1 A B
w k0 K00 A1 B1
s k2 K22 A2 B2
d k2 K22 A3 B3
'''
print(left)
'''
key key1 C D
w k1 K11 C1 D1
a k2 K22 C2 D2
d k3 K33 C3 D3
'''
res = pd.merge(left, right, how='inner', left_index=True, right_index=True)
print(res)
# key_x key1_x C D key_y key1_y A B
# w k1 K11 C1 D1 k0 K00 A1 B1
# d k3 K33 C3 D3 k2 K22 A3 B3# 解决overlapping的问题res = pd.merge(left, right, how='inner', left_index=True, right_index=True, suffixes=['_boy', '_girl'])
print(res)
# key_boy key1_boy C D key_girl key1_girl A B
# w k1 K11 C1 D1 k0 K00 A1 B1
# d k3 K33 C3 D3 k2 K22 A3 B3
导入
import numpy as np
import pandas as pd
import xlrd
import openpyxlclass_one = pd.read_excel(r'C:\Users\Book\Desktop\calss_one.xlsx')
print(class_one)
dao = int(input('学号：'))
# ---------------------------------------------------------------------------------------------------------------------
number = class_one['学号'][class_one['学号'] == dao] # 相当于我先选中了列的所有的值 然后选择了
# class_one['学号'] == 20170200334为真的一部分 返回这个值的所有属性x 是一维的series
print('--', number.index)
导出
import numpy as np
import pandas as pd
import xlrd
import openpyxltime_data = pd.date_range('20190101', periods=6) # ['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
# '2019-01-05', '2019-01-06']
column_time = ['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04','2019-01-05', '2019-01-06']
df = pd.DataFrame(np.NaN, columns=column_time)
print(df)df.to_excel(r'C:\Users\Book\Desktop\calss_one.xlsx')
这是我的一些经验
A B C D
2016-02-08 0 1 2 3
2016-02-09 4 5 6 7
2016-02-10 8 9 10 11
2016-02-11 12 13 14 15
2016-02-12 16 17 18 19
2016-02-13 20 21 22 23
1.似乎pandas的不支持列的范围查找， 只能每一行查找。
也就是说data[0] 或者data['A']是正确的，
而data[0: 3]就会查找到是第一行到第三行而不是列
data['A': 'C']就是错误的
2.貌似pandas的行选择查找不满足左闭右开
data[0:3]是第一行到第三行没错
data['2016-02-08': '2016-02-10'] 2016-02-10一行也显示了
data['2016-02-08'] 也是错误的
data[:'2016-02-08'] 才是正确的
data['2016-02-08']['A']是可以的
data['2016-02-08']['A', 'B']是错误的
也就是说每一行是有序的，但是每一列是独立的 直接所引列就是不能超过一个，直接索引行，就是不能单独一个
因为他把单个索引的给了列，把顺序索引给了行。
好了
