series重置索引 series修改指定索引元素

转载

网猴儿 2024-06-25 07:16:20

文章标签 series重置索引 Python pandas 数据数据结构 文章分类 架构后端开发

____tz_zs笔记

pandas（Python Data Analysis Library）是基于 NumPy 的一个强大的分析结构化数据的工具集，用于数据挖掘，数据分析等任务。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

一、pandas.Series

pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

官方文档

data: 数组，字典或标量值
index: 数组或一维索引，必须与数据有相同长度。默认为从0开始的序列。
dtype: numpy.dtype或None。数据的类型。
copy: 是否复制输入数据(默认为False, 对它的改动会直接反映到data上)

pandas.Series 是带轴标签（索引）的一维 ndarray。支持基于整数和标签的索引，并提供了许多涉及索引的操作。Series覆盖了ndarray的统计方法，能自动排除缺省数据（NaN）。Series之间的加减乘除不要求其索引长度对齐，得到的结果是他们索引的并集。

series 是类似一维数组的对象，与 Numpy 中的一维 array 类似。二者与 Python 基本的数据结构 List 也很相近，其区别是：List 中的元素可以是不同的数据类型，而 Array 和 Series 中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。

结构如图：

series重置索引 series修改指定索引元素_Python

（一）创建 Series 对象

1、使用 list 创建

使用 list 构建 Series 对象。index 缺省时为 [0,1,2,3...]，也可指定 index，但要注意 index 与 data 的长度应一致。

# -*- coding: utf-8 -*-
"""
@author: tz_zs
"""

import numpy as np
import pandas as pd


# 通过list构建Series对象
s = pd.Series(['aa', 'bb', 'cc', 'dd', 'ee'])
print(s)
"""
0    aa
1    bb
2    cc
3    dd
4    ee
dtype: object
"""

# 可以指定索引，但程度必须与 data 一致
s2 = pd.Series(['aa', 'bb', 'cc', 'dd', 'ee'], index=['a', 'b', 'c', 'd', 'e'])
print(s2)
"""
a    aa
b    bb
c    cc
d    dd
e    ee
dtype: object
"""

2、使用 dict 创建

通过 dict 构建对象，index 默认为字典中的 key 值。如果在创建时指定 index，那么 value 将会与新建的 index 对应，如果 index 值在字典的 key 值中不存在，那么 value 将会被初始化为 NaN。注意：NaN不是一个值，在pandas中代表缺省值。

# -*- coding: utf-8 -*-
"""
@author: tz_zs
"""

import numpy as np
import pandas as pd


dict = {'a': 'aa', 'b': 'bb', 'c': 'cc', 'd': 'dd', 'e': 'ee'}
s = pd.Series(dict)
print(s)
"""
a    aa
b    bb
c    cc
d    dd
e    ee
dtype: object
"""
# 在用字典生成Series的时候，也可以指定索引，当索引中值对应的字典中的值不存在的时候，则此索引的值标记为 NaN
s1 = pd.Series(dict, index=['b', 'c', 'd', 'd', 'f'])
print(s1)
"""
dtype: object
b     bb
c     cc
d     dd
d     dd
f    NaN
dtype: object
"""
# 可以通过函数 pandas.isnull 或者 pandas.notnull 来判断哪些索引对应的值是缺省的
print(pd.isnull(s1))
"""
b    False
c    False
d    False
d    False
f     True
dtype: bool
"""
print(pd.notnull(s1))
"""
dtype: bool
b     True
c     True
d     True
d     True
f    False
"""

（二）Series 的属性

#!/usr/bin/python2.7
# -*- coding:utf-8 -*-

"""
@author:    tz_zs
"""

import pandas as pd


s = pd.Series(data=[11, 7, 15, 13], index=['a', 'b', 'c', 'd'])
print(s)
"""
a    11
b     7
c    15
d    13
dtype: int64
"""

# shape 返回数据维度的元组
# size 返回元素数量
# dtype 返回数据的dtype对象
# dtypes 返回数据的dtype对象
print(s.shape)  # (4,)
print(s.size)  # 4
print(s.dtype)  # int64
print(s.dtypes)  # int64

print(s.head(2))
"""
a    11
b     7
dtype: int64
"""

# 访问索引为"a"的元素
print(s['a'])  # 11
# 访问索引为"b","c"的元素
print(s[['b', 'c']])
"""
b     7
c    15
dtype: int64
"""

# values 以ndarray格式返回Series的值。
# axes 返回行轴标签的列表
# index Series的索引（轴标签）
print(s.values)  # [11  7 15 13]
print(s.axes)  # [Index([u'a', u'b', u'c', u'd'], dtype='object')]
print(s.index)  # Index([u'a', u'b', u'c', u'd'], dtype='object')

# loc 通过标签或布尔数组访问一组行和列。
# iloc 基于整数位置的索引访问。
print(s.loc["b"])  # 7
print(s.loc[[False, True, False, False]])
"""
b    7
dtype: int64
"""
print(s.iloc[1])  # 7

# Series 对象本身，以及索引都有一个 name 属性
s.name = "s_name"
s.index.name = "ind_name"
print(s)
"""
a    11
b     7
c    15
d    13
Name: s_name, dtype: int64
"""

二、DataFrame

pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

官方文档

DataFrame 具有行和列的二维数据结构，可以被认为是 Series 的字典格式的容器。是pandas的主要数据结构。DataFrame 类似多维数组/表格数据(如，excel, R中的data.frame)，每列数据可以是不同的类型，索引包括列索引和行索引。

结构如图：

series重置索引 series修改指定索引元素_series重置索引_02

（一）创建 DataFrame 对象

1、使用 ndarray 创建

# -*- coding: utf-8 -*-
"""
@author: tz_zs
"""

import numpy as np
import pandas as pd


""" 使用 ndarray 构建 DataFrame 对象 """
df = pd.DataFrame(np.random.randint(low=0, high=10, size=(4, 5)), columns=['a', 'b', 'c', 'd', 'e'])
print(df)
"""
a  b  c  d  e
0  6  3  7  2  5
1  8  3  1  9  6
2  0  5  5  2  3
3  7  6  8  4  6
"""

2、使用 dict 创建

"""使用 dict 创建 DataFrame 对象"""

# pd.DataFrame(data=)
dict1 = {'col1': [11, 12], 'col2': [21, 22]}
df = pd.DataFrame(data=dict1)
print(df)
"""
   col1  col2
0    11    21
1    12    22
"""

# pd.DataFrame().from_dict(data=, orient=)
dict2 = {'in1': [111, 11], 'in2': [222, 22]}
df1 = pd.DataFrame().from_dict(data=dict2, orient="index")  # 将key作为行名
print(df1)
"""
       0   1
in1  111  11
in2  222  22
"""
df1.columns = ["a", "b"]
print(df1)
"""
       a   b
in1  111  11
in2  222  22
"""

df2 = pd.DataFrame().from_dict(data=dict2, orient="columns")  # 默认是orient="columns"，将key作为列
print(df2)
"""
   in1  in2
0  111  222
1   11   22
"""
df2.index = ["i1", "i2"]
print(df2)
"""
    in1  in2
i1  111  222
i2   11   22
"""

# pd.Series(data=).to_frame(name=)
dict3 = {'in1': 111, 'in2': 222}
df3 = pd.Series(data=dict3).to_frame(name="a")
print(df3)
"""
       a
in1  111
in2  222
"""

3、自动生成行名列名然后再指定

#!/usr/bin/python2.7
# -*- coding:utf-8 -*-

"""
@author:    tz_zs

1、直接在创建df时就指定 index 和 columns。
2、可以先创建然后再指定 index、columns。如果没有指定 index、columns，默认为从0开始的自增数字。
"""

import numpy as np
import pandas as pd

list_l = [[11, 12, 13, 14, 15], [21, 22, 23, 24, 25], [31, 32, 33, 34, 35]]
date_range = pd.date_range(start="20180701", periods=3)
df = pd.DataFrame(list_l, index=date_range, columns=['a', 'b', 'c', 'd', 'e'])
print(df)

“”“
             a   b   c   d   e
2018-07-01  11  12  13  14  15
2018-07-02  21  22  23  24  25
2018-07-03  31  32  33  34  35
”“”

df2 = pd.DataFrame(list_l)
print(df2)

“”“
    0   1   2   3   4
0  11  12  13  14  15
1  21  22  23  24  25
2  31  32  33  34  35
”“”

df2.index = pd.date_range(start="20180601", periods=3)
df2.columns = ['aa', 'ba', 'cc', 'dd', 'ee']
print(df2)

"""
            aa  ba  cc  dd  ee
2018-06-01  11  12  13  14  15
2018-06-02  21  22  23  24  25
2018-06-03  31  32  33  34  35
"""

4、创建空 DataFrame 对象

# -*- coding: utf-8 -*-
"""
@author: tz_zs

先创建对象，再往 DataFrame 中添加列数据
"""

import numpy as np
import pandas as pd

x_date = pd.date_range(start="20170601", end="20170605")
y1 = np.random.randint(20, 60, size=5)
y2 = np.random.randint(30, 70, size=5)
y3 = np.random.randint(50, 90, size=5)

df = pd.DataFrame(data=[y1, y2, y3], index=["y1_index", "y2_index", "y3_index"], columns=x_date, dtype=None,
                  copy=False)
print(df)
"""
          2017-06-01  2017-06-02  2017-06-03  2017-06-04  2017-06-05
y1_index          25          24          45          52          21
y2_index          39          43          33          64          68
y3_index          80          82          74          85          73
"""

# 先创建对象，再往 DataFrame 中添加行数据
df1 = pd.DataFrame(columns=x_date)
df1.loc["y1_index"] = y1
df1.loc["y2_index"] = y2
df1.loc["y3_index"] = y3
print(df1)
"""
         2017-06-01 2017-06-02 2017-06-03 2017-06-04 2017-06-05
y1_index         25         24         45         52         21
y2_index         39         43         33         64         68
y3_index         80         82         74         85         73
"""

# 先创建对象，再往 DataFrame 中添加列数据
df2 = pd.DataFrame()
df2["y1_columns"] = y1
df2["y2_columns"] = y2
df2["y3_columns"] = y3
df2.index = x_date
print(df2)
"""
            y1_columns  y2_columns  y3_columns
2017-06-01          25          39          80
2017-06-02          24          43          82
2017-06-03          45          33          74
2017-06-04          52          64          85
2017-06-05          21          68          73
"""

三、获取 DataFrame 的列名、行名

获取行名：

index = df.index.values.tolist()

获取列名：

columns = df.columns.values.tolist()

或

columns = df.keys()

index = df.index.values.tolist()
print(index)  # ['2018-07-02', '2018-07-03', '2018-07-04']
columns = df.columns.values.tolist()
print(columns)  # ['a', 'b', 'c', 'd']

# 分步解析
index_obj1 = df.index  # Index对象。Index(['2018-07-02', '2018-07-03', '2018-07-04'], dtype='object')
ndarray_1 = index_obj1.values  # ndarray格式。['2018-07-02' '2018-07-03' '2018-07-04']
tolist1 = ndarray_1.tolist()  # list格式。<class 'list'>: ['2018-07-02', '2018-07-03', '2018-07-04']

index_obj2 = df.columns  # Index对象。Index(['a', 'b', 'c', 'd'], dtype='object')
ndarray2 = index_obj2.values  # ndarray格式。['a' 'b' 'c' 'd']
tolist2 = ndarray2.tolist()  # list格式。<class 'list'>: ['a', 'b', 'c', 'd']

四、获取 DataFrame 行数据，列数据，添加/删除列，根据指定列排序等

获取列数据：

df[列名] 获取一列，返回的是Series类型
df[[列名]] 获取一列，返回的是DataFrame类型
df[[列名1，列名2]] 获取多列，返回的是DataFrame类型

获取行数据 ：

pandas.DataFrame.loc

获取一行: df.loc[“index名称”] (得到Series格式的返回值)
获取多行数据 : df.loc[[index名称1，index名称2]] （得到DataFrame格式的返回值）
获取连续多行数据 : 可使用 index 序号切片：df.iloc[1: 2]
获取连续多行数据 : 可使用 index 名称切片，如下：

获取多行的某列数据：df.loc[index名称：index名称2，列名]
获取某行某列的数据：df.loc[index名称，列名]

删除列 ：

del df[列名]
df.pop(列名) # Return item and drop from frame. Raise KeyError if not found.

根据指定列排序 ： df.sort_values(by=列名)

示例代码如下：

# -*- coding: utf-8 -*-
"""
@author: tz_zs
"""

import numpy as np
import pandas as pd

if __name__ == '__main__':
    dict1 = {'col1': [11, 12, 13], 'col2': [21, 22, 23], 'col3': [31, 32, 33]}
    df = pd.DataFrame(data=dict1)
    print(df)

    # 通过列索引获取列数据（Series类型）
    print(df['col1'])
    """
    0    11
    1    12
    2    13
    Name: col1, dtype: int64
    """
    print(df.col1)
    """
    0    11
    1    12
    2    13
    Name: col1, dtype: int64
    """
    print(df[['col1', 'col3']])
    """
       col1  col3
    0    11    31
    1    12    32
    2    13    33
    """

    # 增加列数据，类似dict添加key-value
    df['col4'] = [41, 42, 43]
    print(df)
    """
     col1  col2  col3  col4
    0    11    21    31    41
    1    12    22    32    42
    2    13    23    33    43
    """

    # 删除列
    del df['col3']
    print(df)
    """
       col1  col2  col4
    0    11    21    41
    1    12    22    42
    2    13    23    43
    """

    # 排序
    dict2 = {'col1': [9, 8, 7], 'col2': [4, 6, 5], 'col3': [1, 2, 3]}
    df2 = pd.DataFrame(data=dict2, index=[3, 2, 1])
    print(df2)
    """
       col1  col2  col3
    3     9     4     1
    2     8     6     2
    1     7     5     3
    """
    df2 = df2.sort_values(by='col2')
    print(df2)
    """
       col1  col2  col3
    3     9     4     1
    1     7     5     3
    2     8     6     2
    """

# -*- coding: utf-8 -*-
"""
@author: tz_zs

取数据、添加数据、排序
"""

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(low=0, high=10, size=(5, 6)), columns=['a', 'b', 'c', 'd', 'e', 'f'])
print(df)
'''
   a  b  c  d  e  f
0  6  3  8  1  1  0
1  0  2  7  2  2  3
2  8  8  3  9  4  5
3  9  1  8  0  8  3
4  1  1  8  0  3  8
'''

print(df.columns)  # 列名
# Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')

print(df.columns.tolist())  # 列名，用list格式表示
# ['a', 'b', 'c', 'd', 'e', 'f']

print(df.shape)  # shape
(5, 6)

print(df.head(3))  # 前3行
'''
   a  b  c  d  e  f
0  6  3  8  1  1  0
1  0  2  7  2  2  3
2  8  8  3  9  4  5
'''

print(df.tail(2))  # 倒数2行
'''
   a  b  c  d  e  f
3  9  1  8  0  8  3
4  1  1  8  0  3  8
'''

print('-' * 20, '对行的一些操作')
print(df.loc[0])  # 取出指定行，第0行
'''
a    6
b    3
c    8
d    1
e    1
f    0
Name: 0, dtype: int32
'''

print(df.loc[1:3])  # 取出1到3行
'''
   a  b  c  d  e  f
1  0  2  7  2  2  3
2  8  8  3  9  4  5
3  9  1  8  0  8  3
'''

print(df.loc[[1, 2, 4]])  # 取1,2,4行
'''
   a  b  c  d  e  f
1  0  2  7  2  2  3
2  8  8  3  9  4  5
4  1  1  8  0  3  8
'''

print('-' * 20, '对列的一些操作')
print(df['b'])  # 根据列名取出对应列
'''
0    3
1    2
2    8
3    1
4    1
Name: b, dtype: int32
'''

print(df[['c', 'e']])  # 根据列名取出对应列，用list表示要提取的列名
'''
   c  e
0  8  1
1  7  2
2  3  4
3  8  8
4  8  3
'''

# 某一列中的最大、最小、平均值
print(df['a'].max())  # 9
print(df['a'].min())  # 0
print(df['a'].mean())  # 4.8

# 添加一列，维度要相同
df['z'] = [11, 12, 13, 14, 15]
print(df.shape)  # (5, 7)
print(df)
'''
   a  b  c  d  e  f   z
0  6  3  8  1  1  0  11
1  0  2  7  2  2  3  12
2  8  8  3  9  4  5  13
3  9  1  8  0  8  3  14
4  1  1  8  0  3  8  15
'''

# 排序
print('-' * 20, '排序')
df_sort_values = df.sort_values('a')  # 根据指定列排序，默认为升序，返回新的DataFrame对象
print(df_sort_values)
'''
   a  b  c  d  e  f   z
1  0  2  7  2  2  3  12
4  1  1  8  0  3  8  15
0  6  3  8  1  1  0  11
2  8  8  3  9  4  5  13
3  9  1  8  0  8  3  14
'''

df.sort_values('a', inplace=True, ascending=False)  # inplace为True则在原DataFrame上排序，ascending为False表示为降序
print(df)
'''
   a  b  c  d  e  f   z
3  9  1  8  0  8  3  14
2  8  8  3  9  4  5  13
0  6  3  8  1  1  0  11
4  1  1  8  0  3  8  15
1  0  2  7  2  2  3  12
'''

通过条件筛选的 df 中的值

# -*- coding: utf-8 -*-
"""
@author: tz_zs
去掉过大的值
"""
import pandas as pd
import matplotlib.pyplot as plt

dict1 = {'X': [11, 12, 13, 11, 15, 14, 9, 10, 12, 16], 'Y': [13, 14, 11, 15, 11, 10, 12, 14, 12, 50]}
df = pd.DataFrame(data=dict1)
print(df)
plt.scatter(df["X"], df["Y"])
plt.show()
'''
    X   Y
0  11  13
1  12  14
2  13  11
3  11  15
4  15  11
5  14  10
6   9  12
7  10  14
8  12  12
9  16  50
'''

df = df[abs(df['Y']) < 20]
print(df)
plt.scatter(df["X"], df["Y"])
plt.show()
'''
    X   Y
0  11  13
1  12  14
2  13  11
3  11  15
4  15  11
5  14  10
6   9  12
7  10  14
8  12  12
'''

series重置索引 series修改指定索引元素_Python_03