pandas库基础笔记

基础概念

DataFrame，相当于一个数据表，存储了所有的数据，包含行和命名的列
Series，相当于一个列，一个DataFrame有一个或者多个Series

简单地建立一个Series：

pd.Series(['San Francisco', 'San Jose', 'Sacramento'])

DataFrame可以通过字典的方式，来映射列的名和列的编号，比如：

city_names = pd.Series(['San Francisco', 'San Jose', 'Sacramento'])
population = pd.Series([852469, 1015785, 485199])

test = pd.DataFrame({ 'City name': city_names, 'Population': population })

print(test)

得到如下输出：

       City name  Population
0  San Francisco      852469
1       San Jose     1015785
2     Sacramento      485199

如果我们只是想输出数据集的前几行，可以使用head属性，默认输出前五行。

print(test.head(1))

输出：

       City name  Population
0  San Francisco      852469

字典数据可以进行pandas化，那么反过来，pandas数据也可以进行字典化，一上面的数据为例子：

import pandas as pd

city_names = pd.Series(['San Francisco', 'San Jose', 'Sacramento'])
population = pd.Series([852469, 1015785, 485199])

my_data = pd.DataFrame({'City name': city_names, 'Population': population})

my_dic = dict(my_data)
print(my_dic)

输出结果：

{'City name': 0    San Francisco
1         San Jose
2       Sacramento
Name: City name, dtype: object, 'Population': 0     852469
1    1015785
2     485199
Name: Population, dtype: int64}

总结一下，pandas可以看成一个高阶的字典类型的数据（可能不是十分恰当）

获取数据

可以通过字典的方式引用列，支持索引和切片操作。
比如：

print(test['City name'])
print(test['City name'][1])
print(test['City name'][0:2])

输出结果

0    San Francisco
1         San Jose
2       Sacramento
Name: City name, dtype: object
San Jose
0    San Francisco
1         San Jose
Name: City name, dtype: object

使用describe输出详细信息：

print(test.describe())

输出：

count    3.000000e+00
mean     7.844843e+05
std      2.717477e+05
min      4.851990e+05
25%      6.688340e+05
50%      8.524690e+05
75%      9.341270e+05
max      1.015785e+06
dtype: float64

操作数据

支持一般的python数值计算
支持numpy库函数的计算
支持类似于python的map操作，需要使用apply方法：
`python print(population.apply(lambda x: x > 1000000))

把子列转化成新的Dataframe数据

把一列数据转换成新的Dataframe类型 :

import pandas as pd

c1 = pd.Series(['a', 'b', 'c', 'd'])
c2 = pd.Series([1, 2, 3, 4])
c3 = pd.Series(['A', 'B', 'C', 'D'])
data = pd.DataFrame({'c1': c1, 'c2': c2, 'c3': c3})

print(data)
print(type(data))

tmp = data['c1']  # 仅仅使用一个中括号
print(tmp)
print(type(tmp))

tmp1 = data[['c1']]  # 使用两层中括号
print(tmp1)
print(type(tmp1))

tmp2 = data[['c1', 'c2']]
print(tmp2)
print(type(tmp2))

结果

  c1  c2 c3
0  a   1  A
1  b   2  B
2  c   3  C
3  d   4  D
<class 'pandas.core.frame.DataFrame'>
0    a
1    b
2    c
3    d
Name: c1, dtype: object
<class 'pandas.core.series.Series'>
  c1
0  a
1  b
2  c
3  d
<class 'pandas.core.frame.DataFrame'>
  c1  c2
0  a   1
1  b   2
2  c   3
3  d   4
<class 'pandas.core.frame.DataFrame'>

读取数据和存储数据

从网络或者本地文件中读取csv数据，或者把已有的数据存到csv文件中。一般和os配合使用

import os
import pandas as pd

my_data = None
#  先判断是否存在文件，不存在直接从网络下载，存在的话直接读取
if os.path.exists('data.csv'):
    my_data = pd.read_csv('data.csv', sep=",")
else:
    my_data = pd.read_csv(
        "https://storage.googleapis.com/mledu-datasets/california_housing_train.csv",
        sep=",")
    my_data.to_csv('data.csv')

另一种从文件中读取数据的方式：

import os
import pandas as pd
import numpy as np

N = 2

if os.path.exists('my_data.csv'):
    my_data = pd.read_csv('my_data.csv')
else:
    c1 = 20 * np.ones(N) + np.random.randn(N) * 2.0  # 20-25的正太分布
    c2 = 3 * np.ones(N) + np.random.randn(N)  # 3-4的正太分布
    c3 = -7 * np.ones(N) + np.random.randn(N)  # -6~-7正太
    res = c1 + c2 + c3
    c1 = pd.Series(c1)
    c2 = pd.Series(c2)
    c3 = pd.Series(c3)
    res = pd.Series(res)
    my_data = pd.DataFrame({"res": res, "c1": c1, "c2": c2, "c3": c3})
    my_data.to_csv('my_data.csv')
# 自定义命名列，从第0行开始读取
tmp = pd.read_csv(filepath_or_buffer='my_data.csv', names=['c1', 'c2', 'c3', 'res'], header=0)
print(tmp)

注意，上述方法中，如果新命名的数据列与原来的数据列不一致，那么会以新命名的数据列为准！！

插入和删除列(行)

pop弹出一列

弹出制定的列，并返回。

import pandas as pd

c1 = pd.Series(['a', 'b', 'c', 'd'])
c2 = pd.Series([1, 2, 3, 4])
c3 = pd.Series(['A', 'B', 'C', 'D'])
data = pd.DataFrame({'c1': c1, 'c2': c2, 'c3': c3})

tmp = data.pop('c1')  # Series类型

print(tmp)
print(type(tmp))

print(data)

输出结果：

0    a
1    b
2    c
3    d
Name: c1, dtype: object
<class 'pandas.core.series.Series'>
   c2 c3
0   1  A
1   2  B
2   3  C
3   4  D

insert插入数据

在制定的位置插入一列数据

import pandas as pd

c1 = pd.Series(['a', 'b', 'c', 'd'])
c2 = pd.Series([1, 2, 3, 4])
c3 = pd.Series(['A', 'B', 'C', 'D'])
data = pd.DataFrame({'c1': c1, 'c2': c2, 'c3': c3})
data.pop('c1')  # 删除第一列
data.insert(loc=0, column='c1', value=c1)  # 重新插入到第一列
print(data)

drop删除数据

import pandas as pd

c1 = pd.Series(['a', 'b', 'c', 'd'])
c2 = pd.Series([1, 2, 3, 4])
c3 = pd.Series(['A', 'B', 'C', 'D'])
data = pd.DataFrame({'c1': c1, 'c2': c2, 'c3': c3})

# 列的名称，axis=1表示对列进行删除，axis=0表示删除行，需要添加行的索引；inplace=True表示在原数据上操作
data.drop(columns='c1', axis=1, inplace=True) 
print(data)

输出：

分位点和分位数

根据给定的分位数，计算出分位点，函数pd.Datafrane.quantile()

import pandas as pd
import numpy as np

df4 = pd.DataFrame(np.arange(100).reshape(20, 5),
                   columns=list('abcde'))
print(df4)

for i in np.arange(0, 1, 0.2):
    print(df4.quantile(i))

输出每一列的分位点：

a   b   c   d   e
0    0   1   2   3   4
1    5   6   7   8   9
2   10  11  12  13  14
3   15  16  17  18  19
4   20  21  22  23  24
5   25  26  27  28  29
6   30  31  32  33  34
7   35  36  37  38  39
8   40  41  42  43  44
9   45  46  47  48  49
10  50  51  52  53  54
11  55  56  57  58  59
12  60  61  62  63  64
13  65  66  67  68  69
14  70  71  72  73  74
15  75  76  77  78  79
16  80  81  82  83  84
17  85  86  87  88  89
18  90  91  92  93  94
19  95  96  97  98  99
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
Name: 0.0, dtype: float64
a    19.0
b    20.0
c    21.0
d    22.0
e    23.0
Name: 0.2, dtype: float64
a    38.0
b    39.0
c    40.0
d    41.0
e    42.0
Name: 0.4, dtype: float64
a    57.0
b    58.0
c    59.0
d    60.0
e    61.0
Name: 0.6000000000000001, dtype: float64
a    76.0
b    77.0
c    78.0
d    79.0
e    80.0
Name: 0.8, dtype: float64

还可以求解多个分位点，用np.array传入数据：

import numpy as np
import pandas as pd

num_buckets = 10
df = pd.DataFrame(np.arange(100).reshape(10, 10))
boundaries = np.arange(1.0, num_buckets) / num_buckets
print(boundaries)
print(df)
quantitles = df.quantile(boundaries)
print(quantitles)

输出结果：

[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
    0   1   2   3   4   5   6   7   8   9
0   0   1   2   3   4   5   6   7   8   9
1  10  11  12  13  14  15  16  17  18  19
2  20  21  22  23  24  25  26  27  28  29
3  30  31  32  33  34  35  36  37  38  39
4  40  41  42  43  44  45  46  47  48  49
5  50  51  52  53  54  55  56  57  58  59
6  60  61  62  63  64  65  66  67  68  69
7  70  71  72  73  74  75  76  77  78  79
8  80  81  82  83  84  85  86  87  88  89
9  90  91  92  93  94  95  96  97  98  99
        0     1     2     3     4     5     6     7     8     9
0.1   9.0  10.0  11.0  12.0  13.0  14.0  15.0  16.0  17.0  18.0
0.2  18.0  19.0  20.0  21.0  22.0  23.0  24.0  25.0  26.0  27.0
0.3  27.0  28.0  29.0  30.0  31.0  32.0  33.0  34.0  35.0  36.0
0.4  36.0  37.0  38.0  39.0  40.0  41.0  42.0  43.0  44.0  45.0
0.5  45.0  46.0  47.0  48.0  49.0  50.0  51.0  52.0  53.0  54.0
0.6  54.0  55.0  56.0  57.0  58.0  59.0  60.0  61.0  62.0  63.0
0.7  63.0  64.0  65.0  66.0  67.0  68.0  69.0  70.0  71.0  72.0
0.8  72.0  73.0  74.0  75.0  76.0  77.0  78.0  79.0  80.0  81.0
0.9  81.0  82.0  83.0  84.0  85.0  86.0  87.0  88.0  89.0  90.0

显示了每一个列的，的对应的分位点。

基础概念

获取数据

操作数据

把子列转化成新的Dataframe数据

读取数据和存储数据

插入和删除列(行)

pop弹出一列

insert插入数据

drop删除数据

分位点和分位数

猜你喜欢