python之 《pandas》
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 openpyxl class_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 openpyxl time_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']是错误的
也就是说每一行是有序的，但是每一列是独立的 直接所引列就是不能超过一个，直接索引行，就是不能单独一个
因为他把单个索引的给了列，把顺序索引给了行。
好了
