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

好了