Pandas 入门

Series 基本概念，创建

Series 一维数组

 1 import numpy as np
 2 import pandas as pd
 3 
 4 s = pd.Series(np.random.rand(5))
 5 print(s)
 6 print(type(s))
 7 # 是一个带有标签的一维数组，可以保存任何的数据类型（整数，字符串，浮点数，Python对象），轴标签，成为索引 index
 8 print(s.index)
 9 print(s.values, type(s.values))
10 # series相比Ndarry，就是自带了一个索引 一维数组 + 对应的索引
11 # series 更像一个有顺序的字典

0    0.283000
1    0.808397
2    0.939227
3    0.628341
4    0.636434
dtype: float64
<class 'pandas.core.series.Series'>
RangeIndex(start=0, stop=5, step=1)
[0.28299992 0.80839728 0.93922677 0.62834058 0.63643368] <class 'numpy.ndarray'>

1 # 创建Series
2 #  方法一 ，由字典创建，字典的key就是index， values就是values
3 dic = {'a':1, 'b': 2, 'c':'a'}
4 s = pd.Series(dic)
5 s.values

array([1, 2, 'a'], dtype=object)

1 # 方法二：由数组（一维数组）  列表
2 arr = np.random.randn(5)
3 s = pd.Series(arr)
4 s
5 # index 默认使用整数
6 s = pd.Series(arr, index=list('abcde'))
7 pd.Series([1,2,3,4,5], index=list('abcde'), dtype=np.float64)

a    1.0
b    2.0
c    3.0
d    4.0
e    5.0
dtype: float64

1 # 方法三：又标量创建
2 s = pd.Series(10, index=list('abcde'))
3 s
4 # 如果由标量创建，必须提供index，来匹配长度

a    10
b    10
c    10
d    10
e    10
dtype: int64

1 # 名称属性.name
2 print(s.name)
3 s = pd.Series(10, index=list('abcde'), name='ten')
4 s.name
5 s.rename

ten

<bound method Series.rename of a    10
b    10
c    10
d    10
e    10
Name: ten, dtype: int64>

索引
位置下标，标签索引，切片索引，布尔型索引

1 # 位置下标 跟序列差不多
2 s = pd.Series(np.random.rand(5))
3 print(s)
4 # s[0]
5 print(s[0], type(s[0]))
6 s[[1,4]]

0    0.531905
1    0.085882
2    0.433087
3    0.005318
4    0.917822
dtype: float64
0.5319054474777941 <class 'numpy.float64'

1    0.085882
4    0.917822
dtype: float64

1 # 标签索引 相当于字典
2 s = c
3 print(s)
4 print(s['a'], type(s['a']), s['a'].dtype)
5 # 选择多个[[]]  返回的是新的Series对象
6 s[['a', 'd']]

a    0.531258
b    0.309434
c    0.731206
d    0.673279
e    0.542303
dtype: float64
0.5312584537237046 <class 'numpy.float64'> float64

a    0.531258
d    0.673279
dtype: float64

1 # 切片
2 s1 = pd.Series(np.random.rand(5))
3 s2 = pd.Series(np.random.rand(5), index=list('abcde'))
4 print(s1[1:4])
5 print(s2['a':'c'])
6 # 注意：用标签索引切片，闭区间  字符串索引，
7 # 切片的写法和list一致
8 s2[::2]

1    0.3934752    0.126244

3    0.148689
dtype: float64
a    0.330030
b    0.351245
c    0.030589
dtype: float64a    0.330030

c    0.030589
e    0.949498
dtype: float64

1 # 布尔型索引
2 s = pd.Series(np.arange(10))
3 s[4] = None
4 bs1 = s>5
5 bs2 = s.isnull()
6 bs3 = s.notnull()
7 bs3
8 # 数组做判断之后，返回的是一个由布尔值组成的新的数组
9 s[bs3]

0    0.0
1    1.0
2    2.0
3    3.0
5    5.0
6    6.0
7    7.0
8    8.0
9    9.0
dtype: float64series 常用操作

1 # 数据查看
2 s = pd.Series(np.random.rand(50))
3 # s.head(10)
4 # s.tail(10)

 1 # 重新索引
 2 s = pd.Series(np.random.rand(5), index=list('abcde'))
 3 s.reindex(['c', 'd', 'a', 'd', 'ab'])
 4 # .reindex 根据索引重新排序,如果索引不存在 ，引入缺失值
 5 # 返回新的序列
 6 # fill_value 填充缺失值
 7 print(s)
 8 print('********')
 9 print(s.reindex(['c', 'd', 'a','a', 'd', 'ab'], fill_value=0))
10 print('********')
11 print(s)

1 # 对齐
2 s1 = pd.Series(np.random.rand(3), index = ['Jack','Marry','Tom'])
3 s2 = pd.Series(np.random.rand(3), index = ['Wang','Jack','Marry'])
4 print(s1)
5 print(s2)
6 print(s1 + s2)
7 # 会根据index 自动对齐
8 # index顺序不影响
9 # NaN和任何值进行计算都是NaN

 1 #  删除
 2 s = pd.Series(np.random.rand(5), index=list('abcde'))
 3 
 4 s.drop('c')
 5 # drop 默认返回一个删除了指定数据的新的series
 6 s.drop(['a','c'])
 7 # s.drop('c', inplace=True)
 8 # s
 9 # inplace=True时，drop不会返回新的序列，会直接改变原数据
10 # inplace 默认等于False

1 # 添加
2 s = pd.Series(np.random.rand(5), index=list('abcde'))
3 s2 = pd.Series(np.random.rand(5))
4 s['f'] = 100
5 s2[5] = 100
6 s2
7 # .append方法，直接添加一个数组
8 s.append(s2)
9 # .append()返回一个新的series， 不改变原数据

1 # 修改
2 s = pd.Series(np.random.rand(5), index=list('abcde'))
3 print(s)
4 s['a'] = 100
5 print(s)
6 # 直接通过索引赋值，类似列表

DataFrame 基本概念和创建

 1 data = {'name':['Jack','Tom','Mary'],
 2         'age':[18,19,20],
 3        'gender':['m','m','w']}
 4 frame = pd.DataFrame(data)
 5 print(frame)
 6 # 二维数组，是一个表个型的数据结构，包含了有序的列，其列的值可以是字符串，数值，布尔值等
 7 # 带有标签的二维数组
 8 print(frame.index)
 9 print(frame.columns)
10 print(frame.values, type(frame.values))

name  age gender
0  Jack   18      m
1   Tom   19      m
2  Mary   20      w
RangeIndex(start=0, stop=3, step=1)
Index(['name', 'age', 'gender'], dtype='object')
[['Jack' 18 'm']
 ['Tom' 19 'm']
 ['Mary' 20 'w']] <class 'numpy.ndarray'>

 1 # 创建
 2 # 方法一，由数组/list组成的字典
 3 data = {'name':['Jack','Tom','Mary'],
 4         'age':[18,19,20],
 5        'gender':['m','m','w']}
 6 frame = pd.DataFrame(data,index=['Jack', 'Tom', 'Mary'], columns=['age', 'name', 'gender', 'height'])
 7 #  一个键值对 ，是一列,所以值的长度要一致
 8 print(frame)
 9 # 指定columns参数重新排序，格式list，如果没有该列，用NaN填充
10 #  指定index 重新定义行索引，格式list，长度一致

age  name gender height
Jack   18  Jack      m    NaN
Tom    19   Tom      m    NaN
Mary   20  Mary      w    NaN

 1 # 方法二，由Sereis组成的字典
 2 data1 = {'one':pd.Series(np.random.rand(2)),
 3         'two':pd.Series(np.random.rand(3))}  # 没有设置index的Series
 4 data2 = {'one':pd.Series(np.random.rand(2), index = ['a','b']),
 5         'two':pd.Series(np.random.rand(3),index = ['a','b','c'])}  # 设置了index的Series
 6 # print(data1)
 7 # print(data2)
 8 df1 = pd.DataFrame(data1)
 9 df2 = pd.DataFrame(data2)
10 print(df1)
11 print(df2)
12 # 由Seris组成的字典 创建Dataframe，columns为字典key，index为Series的标签（如果Series没有指定标签，则是默认数字标签）
13 # Series可以长度不一样，生成的Dataframe会出现NaN值

one       two
0  0.882326  0.390277
1  0.841204  0.480986
2       NaN  0.511883
        one       two
a  0.550635  0.024447
b  0.719084  0.996299
c       NaN  0.451199

1 # 方法三通过二维数组直接创建
2 ar = np.random.rand(9).reshape(3,3)
3 print(ar)
4 df1 = pd.DataFrame(ar)
5 df2 = pd.DataFrame(ar, index = ['a', 'b', 'c'], columns = ['one','two','three'])  # 可以尝试一下index或columns长度不等于已有数组的情况
6 print(df1)
7 print(df2)
8 # 通过二维数组直接创建Dataframe，得到一样形状的结果数据，如果不指定index和columns，两者均返回默认数字格式
9 # index和colunms指定长度与原数组保持一致

[[0.53802022 0.06578215 0.16962002]
 [0.63139847 0.20339092 0.44883402]
 [0.41483237 0.47160531 0.81983217]]
          0         1         2
0  0.538020  0.065782  0.169620
1  0.631398  0.203391  0.448834
2  0.414832  0.471605  0.819832
        one       two     three
a  0.538020  0.065782  0.169620
b  0.631398  0.203391  0.448834
c  0.414832  0.471605  0.819832

# Dataframe 创建方法四：由字典组成的列表

data = [{'one': 1, 'two': 2}, {'one': 5, 'two': 10, 'three': 20}]
print(data)
df1 = pd.DataFrame(data)
df2 = pd.DataFrame(data, index = ['a','b'])
df3 = pd.DataFrame(data, columns = ['one','two'])
print(df1)
print(df2)
print(df3)
# 由字典组成的列表创建Dataframe，columns为字典的key，index不做指定则为默认数组标签
# colunms和index参数分别重新指定相应列及行标签

[{'one': 1, 'two': 2}, {'one': 5, 'two': 10, 'three': 20}]
   one  two  three
0    1    2    NaN
1    5   10   20.0
   one  two  three
a    1    2    NaN
b    5   10   20.0
   one  two
0    1    2
1    5   10

 1 # Dataframe 创建方法五：由字典组成的字典
 2 
 3 data = {'Jack':{'math':90,'english':89,'art':78},
 4        'Marry':{'math':82,'english':95,'art':92},
 5        'Tom':{'math':78,'english':67}}
 6 df1 = pd.DataFrame(data)
 7 print(df1)
 8 # 由字典组成的字典创建Dataframe，columns为字典的key，index为子字典的key
 9 
10 df2 = pd.DataFrame(data, columns = ['Jack','Tom','Bob'])
11 df3 = pd.DataFrame(data, index = ['a','b','c'])
12 print(df2)
13 print(df3)
14 # columns参数可以增加和减少现有列，如出现新的列，值为NaN
15 # index在这里和之前不同，并不能改变原有index，如果指向新的标签，值为NaN （非常重要！）

  Jack  Marry   Tom
math       90     82  78.0
english    89     95  67.0
art        78     92   NaN
         Jack   Tom  Bob
math       90  78.0  NaN
english    89  67.0  NaN
art        78   NaN  NaN
   Jack  Marry  Tom
a   NaN    NaN  NaN
b   NaN    NaN  NaN
c   NaN    NaN  NaN

来源：https://www.cnblogs.com/LWH999/p/11723645.html