Pandas使用

安装

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/

pandas内置数据结构

Series

Series 是 Pandas 中的一种一维数据结构，类似于数组但带有索引。它由一组数据（各种 Numpy 数据类型）以及一组与之相关的数据标签（即索引）组成。

DataFrame

DataFrame 是 Pandas 中的一种二维表格型数据结构，包含多种类型的列。它既有行索引也有列索引，可以被视为一个共享相同索引的 Series 的字典。或者看作是一个关系型数据库的一张标，或者当作一个EXCLE表格。可根据行列索引或标签进行操作。

Series

Series是一列或者一行数据的一维数据，相当于一个数组，只是可以通过其他的索引进行操作。

创建函数：

pandas.Series(data,index,dtype)

参数说明

• data

  • 类型：可以是列表、数组、字典等多种形式。

  • 描述：这是创建 Series 对象时必须提供的一个参数，用于指定 Series 中的数据内容。

• index

  • 类型：字符串或数值，长度必须与数据的长度相同。

  • 描述：这是一个可选参数，用于指定 Series 的索引。如果没有指定，默认情况下，索引会从 0 开始自动递增。如果传递了索引，则索引必须唯一且散列，且与数据的长度相同

• dtype

  • 类型：数据类型，用于指定 Series 中数据的类型。

  • 描述：这也是一个可选参数，如果没有指定，Pandas 会根据数据的实际内容自动推断数据类型

• copy

  • 类型：布尔值，默认为 False。

  • 描述：当设置为 True 时，表示创建 Series 时会复制数据，而不是仅仅引用原始数据。这在某些情况下可以避免后续操作对原始数据的影响

创建Series对象

使用有序一元容器对象创建

可使用列表，元组,集合进行创建或者None创建空的Series

• 空值创建

  • import pandas as pd
    import numpy as np
    s = pd.Series()
    print(s)
    

  • Series([], dtype: object)
    

• 列表创建

  • s = pd.Series([1, 2, 3], dtype=np.int32)
    print(s)
    

  • 0    1
    1    2
    2    3
    dtype: int32
    

• 元组创建

  • s = pd.Series((1, 2, 3))
    print(s)
    

  • 0    1
    1    2
    2    3
    dtype: int64
    

  ndarray对象创建

  可使用一维ndarray对象进行创建

  import pandas as pd
  import numpy as np
  arr =  np.array([1,2,3])
  s = pd.Series(arr)
  print(s)
  

  0    1
  1    2
  2    3
  dtype: int32
  

字典对象创建

可传入字典对象，会以key为series的索引(index),value为值进行创建

#通过字典创建 key为index，value为值
map = {'a': 1, 'b': 2, 'c': 3}
s = pd.Series(map)
print(s)
s['a'] = 100
print(s)

a    1
b    2
c    3
dtype: int64
a    100
b      2
c      3
dtype: int64

标量创建

• 不指定index时，只会创建一个元素

  • # 标量创建
    s =pd.Series(5)
    print(s) # 结果只有一行
    

    0    5
    

• 指定index时，创建个数与index个数相同。会将标量广播到index一致，数据时同一份。

  • class Persion:
        def __init__(self, name):
            self.name = name
    
    p1 = Persion('John')
    s1 = pd.Series(p1,index=['a','b','c'])
    print(s1)# 保持与index一致,value广播，浅拷贝
    
    p1.name = 'John1'
    print(s1['b'].name)
    

    a    <__main__.Persion object at 0x0000020E00022040>
    b    <__main__.Persion object at 0x0000020E00022040>
    c    <__main__.Persion object at 0x0000020E00022040>
    dtype: object
    John1
    

    可以看到，每个persion的地址相同，修改数据也会跟着修改

Series 常用属性

名称	属性
axes	以列表的形式返回所有行索引标签
dtype	返回对象的数据类型
empty	返回一个布尔值，用于判断数据对象是否为空
ndim	返回输入数据的维数
size	返回输入数据的元素数量
values	以 ndarray 的形式返回 Series 对象
index	返回一个RangeIndex对象，用来描述索引的取值范围

s = pd.Series([10,20,30],index=['a','b','c'])

print(s)
print("___________")
#返回行标签列表
print("axes")
print(s.axes)
print("___________")
print("dtype")
print(s.dtype)
print("___________")
print("empty")
print(s.empty)
print("___________")
print("size")
print(s.size)
print("___________")
print("values")
print(s.values)
print("___________")
print("index")
print(s.index)

a    10
b    20
c    30
dtype: int64
___________
axes
[Index(['a', 'b', 'c'], dtype='object')]
___________
dtype
int64
___________
empty
False
___________
size
3
___________
values
[10 20 30]
___________
index
Index(['a', 'b', 'c'], dtype='object')

Series 常用方法

head() 和 tail()

查看 Series 的某一部分数据，使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行

案例：

s = pd.Series([1,2,3,4,5,6,7,8],
              ['a','b','c','d','e','f','g','h'])

# 获取前三行 默认5
print(s.head(3))

#获取后三行 默认5
print(s.tail(3))

a    1
b    2
c    3
dtype: int64
f    6
g    7
h    8
dtype: int64

isnull() 和 notnull()

isnull() 和 notnull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少

• isnull()：如果为值不存在或者缺失，则返回 True
• notnull()：如果值不存在或者缺失，则返回 False

案例：

import pandas as pd
s1 = pd.Series([1,2,None,'c'])
#判断Series对象中元素是否为空，为空为True
print(s1.isnull())
print("___________")
#和上面相反
print(s1.notnull())
print("___________")
#是否非数字
print(s1.isna())

1    False
2     True
3    False
dtype: bool
___________
0     True
1     True
2    False
3     True
dtype: bool
___________
0    False
1    False
2     True
3    False
dtype: bool

DataFarme

DataFarme是Pandas 中一种二维的、大小可变的、带标签的数据结构，类似于 Excel 的数据表或 SQL 中的表格。

pd.DataFrame(data, index, columns, dtype, copy)

• data: 用于填充 DataFrame的数据。可以是多种数据类型。
  • ndarray：二维的 Numpy 数组。例如一个 m x n 的数组，会被转换为一个有 m 行 n 列的 DataFrame。
  • dict：字典类型，键（key）表示列名，值（value）可以是列表、数组或 Series 对象，这些值会作为列的数据。
  • Series：一维的 Pandas Series 对象，会被转换为只有一列的 DataFrame。
  • list：列表嵌套列表的形式可表示二维数据，类似于二维数组。
  • 等等
• index：定义 DataFrame 的行标签（索引）。它是一个可选参数，如果不提供，默认会使用从 0 开始的整数索引。可以是列表、数组或 Pandas 的 Index 对象。
• columns：定义 DataFrame 的列标签。同样是可选参数，如果 data 是字典，字典的键会作为列标签；如果没提供列标签，默认使用从 0 开始的整数作为列标签。
• dtype：指定 DataFrame 每列的数据类型。可以是 Numpy 的数据类型，如 np.int32 、np.float64 等。如果不指定，Pandas 会自动推断每列的数据类型。
• **copy **: 是否对数据进行复制，默认False

import pandas as pd 
 
data = [['Alice', 25], ['Bob', 30], ['Charlie', 35]] 
index = ['A', 'B', 'C'] 
columns = ['Name', 'Age'] 
df = pd.DataFrame(data=data, index=index, columns=columns, dtype=object) 
print(df) 

      Name Age
A    Alice  25
B      Bob  30
C  Charlie  35

创建DataFarmed对象

列表创建

• 将列表作为一列数据创建

  • data = ['小明','小红','小紫']
    column = ['name']
    result = pd.DataFrame(data=data,columns=column)
    print(result)
    

      name
    0   小明
    1   小红
    2   小紫
    

• 列表嵌套字典创建

  • 
    # 列表嵌套字典，key为列名
    data = [{'name':"zhangsan", 'age':23},{'name':"Lisi", 'age':18,'sex':'男'}]
    df = pd.DataFrame(data)
    print(df)
    
    print("_______________")
    # 可指定列名
    df = pd.DataFrame(data,columns=['name'])
    print(df)
    

           name  age  sex
    0  zhangsan   23  NaN
    1      Lisi   18    男
    _______________
           name
    0  zhangsan
    1      Lisi
    

字典创建

• 单值字典

df = pd.DataFrame({'name':"zhangsan", 'age':23},index=[1],columns=['name','age'])
print(df)

       name  age
1  zhangsan   23

• 字典嵌套列表,可以不指定列，指定列后，不存在则为NaN

import pandas as pd
import numpy as np

# 通过字典创建嵌套列表，key为列名
df = pd.DataFrame({'A':[1,2,3], 'B':[4,5,6]},columns=['B','C','A'],index=['a','b','c'])
print(df)

   B    C  A
a  4  NaN  1
b  5  NaN  2
c  6  NaN  3

Series创建

key为列，value可单独指定index,没有的index为NaN

data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'e', 'd'])}
result = pd.DataFrame(data=data)
print(result)

   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  NaN
d  NaN  4.0
e  NaN  3.0

列索引使用

获取数据

对于DataFarme对象可通过中括号 [] 获取对应列数据返回 Series

df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]})

#根据列名获取某列数据
#获取列
s = df['name']
print(s)
print(type(s))

0    zhangsan
1        lisi
Name: name, dtype: object

添加数据

• 通过不存在的索引复制，自动添加。列数需要保持一致

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]})
    # 添加列名
    df['sex'] = ['male','female'] # None 或 标量 可广播 
    print(df)
    

           name  age  id     sex
    0  zhangsan   18   1    male
    1      lisi   20   2  female
    

• assign 添加，并且可以链式调用，列数也需要保持一致

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]})
    # 添加列名
    # 返回的是副本
    dfa =  df.assign(address=["成都","宜宾"]).assign(pwd=["123","321"])
    df.loc[0,'name'] = "NAN"
    print(dfa)
    

           name  age  id address  pwd
    0  zhangsan   18   1      成都  123
    1      lisi   20   2      宜宾  321
    

• Series对象添加

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]})
    
    # 列数可以不一致，可以指定列索引，多的索引不进行添加，没有的索引为NaN
    df["pwd"] = pd.Series(["123","321","1111"],index=[1,3,2])
    print(df)
    

  •        name  age  id  pwd
    0  zhangsan   18   1  NaN
    1      lisi   20   2  123
    

• insert 添加

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]},index=[11,12])
    print(df)
    print("___________")
    
    # 列1前添加pwd列
    df.insert(1,"pwd",["123","321"])
    print(df)
    

            name  age  id
    11  zhangsan   18   1
    12      lisi   20   2
    ___________
            name  pwd  age  id
    11  zhangsan  123   18   1
    12      lisi  321   20   2
    

修改数据

• 通过标签访问修改

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]},index=[11,12])
    
    print("修改")
    df['age'] = [888,"666"]
    print(df)
    

    修改
            name  age  id
    11  zhangsan  888   1
    12      lisi  666   2
    

• 修改列名

  • coulms 属性直接修改

    • result.columns = ['A','B']
      

  • rename方法修改

    • df.rename(columns={'age':'AGE'})
      

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]})
    
    #修改列名
    df.columns = ['Name','age','id']
    print(df)
    
    # 通过rename方法修改列名
    df.rename(columns={'age':'AGE'})
    print(df)
    

           Name  age  id
    0  zhangsan   18   1
    1      lisi   20   2
           Name  age  id
    0  zhangsan   18   1
    1      lisi   20   2
    

• 修改dtype

  • df = pd.DataFrame({'name':["zhangsan","lisi"],'age':[18,20],'id':[1,2]})
    print(df['id'].dtype)
    df['id'] =  df['id'].astype(np.int32)
    print(df['id'].dtype)
    

    int64
    int32
    

• 删除数据

  DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')
  

  • labels: 要删除的标签，可以是单个标签或标签列表。默认情况下，labels=None 表示删除所有行或列。

  • axis: 指定删除操作的轴。axis=0 表示删除行，axis=1 表示删除列。

  • index: 直接指定要删除的行标签。

  • columns: 直接指定要删除的列标签。

  • level: 针对具有多重索引的数据框，指定要删除的层级。

  • inplace: 布尔值，表示是否在原数据上进行操作。inplace=False 表示返回一个新的 DataFrame，而 inplace=True 表示直接在原数据上进行修改。

  • errors=‘raise’: 错误处理方式，默认为 ‘raise’，表示在遇到错误时抛出异常。

  • import pandas as pd 
    #删除行
    
    # 创建一个示例 DataFrame 
    data = {'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]} 
    df = pd.DataFrame(data) 
    print("原始 DataFrame:") 
    print(df) 
     
    # 删除索引为 1 的行 
    df_drop_row = df.drop(index=1)  
    print("删除索引为 1 的行后的 DataFrame:") 
    print(df_drop_row) 
    

    原始 DataFrame:
       A  B
    0  1  5
    1  2  6
    2  3  7
    3  4  8
    删除索引为 1 的行后的 DataFrame:
       A  B
    0  1  5
    2  3  7
    3  4  8
    

  • import pandas as pd 
    
    #删除列
    # 创建一个示例 DataFrame 
    data = {'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]} 
    df = pd.DataFrame(data) 
    print("原始 DataFrame:") 
    print(df) 
     
    # 删除列 'A' 
    df_drop_col = df.drop(columns='A')  
    print("删除列 'A' 后的 DataFrame:") 
    print(df_drop_col) 
    

    原始 DataFrame:
       A  B
    0  1  5
    1  2  6
    2  3  7
    3  4  8
    删除列 'A' 后的 DataFrame:
       B
    0  5
    1  6
    2  7
    3  8
    

  • 删除多行或多列

    import pandas as pd 
     
    # 创建一个示例 DataFrame 
    data = {'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8]} 
    df = pd.DataFrame(data) 
    print("原始 DataFrame:") 
    print(df) 
     
    # 删除索引为 1 和 3 的行 
    df_drop_rows = df.drop(index=[1,  3]) 
    print("删除索引为 1 和 3 的行后的 DataFrame:") 
    print(df_drop_rows) 
     
    # 删除列 'A' 和 'B' 
    df_drop_cols = df.drop(columns=['A',  'B']) 
    print("删除列 'A' 和 'B' 后的 DataFrame:") 
    print(df_drop_cols) 
    

    0  1  5
    1  2  6
    2  3  7
    3  4  8
    删除索引为 1 和 3 的行后的 DataFrame:
       A  B
    0  1  5
    2  3  7
    删除列 'A' 和 'B' 后的 DataFrame:
    Empty DataFrame
    Columns: []
    Index: [0, 1, 2, 3]
    

行索引操作

loc方法

使用loc可对DataFrame进行行和列的访问。传入行索引和列索引进行选择。

根据选择结果条数返回不同的数据

• 选中多行或者多列则返回DataFrame
• 选中单行和单列则返回Series

DataFrame.loc[row_indexer, column_indexer]

参数说明

• row_indexer：行标签或布尔数组。
• column_indexer：列标签或布尔数组。
• 行列索引根据传入值

注意：选中多少行根实际选中的数目无关，传入索引为范围即表示选中多行即使是向 1:2 这样的范围只有一个也是认为多行。选中单行只有是传入单个索引值

例如：

data = {
    "A":[1,2,3,4],
    "B":[5,6,7,8],
    "C":[9,10,11,12],
}

df = pd.DataFrame(data,index = ['a','b','c','d'])
res = df.loc[['a'],['A']]
print(type(res))
print(res)

   A
a  1

获取单行

import pandas as pd
import numpy as np
data = {
    "A":[1,2,3,4],
    "B":[5,6,7,8],
    "C":[9,10,11,12],
}

df = pd.DataFrame(data,index = ['a','b','c','d'])

#获取单行,返回行的Series,标签为列索引
ra =  df.loc['a'] # 结果是视图
ra['A'] = 99
print(ra)
# 结果为单行，返回Series
print(type(ra))
print("____________")
print(df)

A    99
B     5
C     9
Name: a, dtype: int64

____________
    A  B   C
a  99  5   9
b   2  6  10
c   3  7  11
d   4  8  12

获取多行

data = {
    "A":[1,2,3,4],
    "B":[5,6,7,8],
    "C":[9,10,11,12],
}

df = pd.DataFrame(data,index = ['a','b','c','d'])
#获取多行, a到c均含边界
#
rs = df.loc['a':'b']
print(rs)
# 结果为多行，返回DataFrame
print(type(rs))

   A  B   C
a  1  5   9
b  2  6  10

获取单个值

#获取值，返回标量
res =  df.loc['a','B']
print(res) 
# 5

同时获取行和列

#其他
res1 = df.loc['a':'c','B']
print(res1)
print(type(res1))

print("_______________")
res1 = df.loc[['a','b'],['A','B']]
print(res1)

a    5
b    6
c    7
Name: B, dtype: int64

_______________
   A  B
a  1  5
b  2  6

Bool索引获取

#Bool索引 获取 B列大于6的行
res = df.loc[df['B']>6,[True,False,True]]
print(res)

   A   C
c  3  11
d  4  12

iloc方法

传入行索引和列索引进行选择。但是传入的值是从 0~len-1的位置数字索引。其他方法通iloc

DataFrame.loc[row_indexer, column_indexer]

切片

切片方法与列表相同，但是可以根据指定的行索引进行切片

DataFrame[start:stop:stape]

import pandas as pd
import numpy as np

data = {
    "A": [1, 2, 3, 4],
    "B": [5, 6, 7, 8],
    "C": [9, 10, 11, 12],
}
df = pd.DataFrame(data,index=['a', 'b', 'c','d'])

# 切面全是按照行进行切片，不能使用单标签或单下标获取

# 通过行索引，通过位置切片，即使指定index为数字也是
res = df[0:2]# 不包含两端
print(res)

print("_____________")
res = df['a':'c']# 通过index切片，包含两端
print(res)

   A  B   C
a  1  5   9
b  2  6  10
_____________
   A  B   C
a  1  5   9
b  2  6  10
c  3  7  11

添加行

• loc方法 进行添加

  • data = {
        "A":[1,2,3,4],
        "B":[5,6,7,8],
        "C":[9,10,11,12],
    }
    
    df = pd.DataFrame(data,index = ['a','b','c','d'])
    #使用新的索引添加
    df.loc['g'] = [21,22,23]
    print(df)
    

• pd.concat()添加

  • pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)
    

    参数：

    objs: 要连接的 DataFrame 或 Series 对象的列表或字典。

    axis: 指定连接的轴，0 或 ‘index’ 表示按行连接，1 或 ‘columns’ 表示按列连接。

    join: 指定连接方式，‘outer’ 表示并集（默认），‘inner’ 表示交集。

    ignore_index: 如果为 True，则忽略原始索引并生成新的索引。

    keys: 用于在连接结果中创建层次化索引。

    levels: 指定层次化索引的级别。

    names: 指定层次化索引的名称。

    verify_integrity: 如果为 True，则在连接时检查是否有重复索引。

    sort: 如果为 True，则在连接时对列进行排序。

    copy: 如果为 True，则复制数据。

  • 例

    data = {
        "A":[1,2,3,4],
        "B":[5,6,7,8],
        "C":[9,10,11,12],
    }
    data1 = {
        "A":[1,2,3],
        "B":[6,7,8],
        "D":[9,11,12],
    }
    
    df = pd.DataFrame(data,index = ['a','b','c','d'])
    df1 = pd.DataFrame(data1,index=['a','b','e'])
    res = pd.concat([df,df1],axis=1,join='outer')
    print(res)
    print("______________")
    res = pd.concat([df,df1],axis=1,join='inner')
    print(res)
    
    

         A    B     C    A    B     D
    a  1.0  5.0   9.0  1.0  6.0   9.0
    b  2.0  6.0  10.0  2.0  7.0  11.0
    c  3.0  7.0  11.0  NaN  NaN   NaN
    d  4.0  8.0  12.0  NaN  NaN   NaN
    e  NaN  NaN   NaN  3.0  8.0  12.0
    ______________
       0  1   2  3  4   5
    a  1  5   9  1  6   9
    b  2  6  10  2  7  11
    

  • DataFrame 和 Series 连接，将Series的name属性作为DataFrame的列标签。Name为空则为0.

    # 创建一个示例 DataFrame
    df = pd.DataFrame({
        'A': [1, 2, 3],
        'B': [4, 5, 6]
    })
    
    # 创建一个示例 Series
    series = pd.Series([7, 8, 9],name="C")
    
    # 按行连接 DataFrame 和 Series
    result_row = pd.concat([df, series], axis=0)
    
    # 按列连接 DataFrame 和 Series
    result_col = pd.concat([df, series], axis=1)
    # 
    print("按行连接结果:")
    print(result_row)
    print("\n按列连接结果:")
    print(result_col)
    

    按行连接结果:
         A    B    C
    0  1.0  4.0  NaN
    1  2.0  5.0  NaN
    2  3.0  6.0  NaN
    0  NaN  NaN  7.0
    1  NaN  NaN  8.0
    2  NaN  NaN  9.0
    
    按列连接结果:
       A  B  C
    0  1  4  7
    1  2  5  8
    2  3  6  9
    

DataFrame属性和方法

常用属性和方法

​ DataFrame 的属性和方法，与 Series 基本相同

名称	属性和方法描述
T	行和列转置。
axes	返回一个仅以行轴标签和列轴标签为成员的列表。
dtypes	返回每列数据的数据类型。
empty	DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。
ndim	轴的数量，也指数组的维数。
shape	返回一个元组，表示了 DataFrame 维度。
size	DataFrame中的元素数量。
values	使用 numpy 数组表示 DataFrame 中的元素值。
head()	返回前 n 行数据。
tail()	返回后 n 行数据。

import pandas as pd
import numpy as np

data = {
    "A": [1, 'b', 3, 4],
    "B": [5, 6, 7, 8],
    "C": [9, 10, 11, 12],
}

df = pd.DataFrame(data, index=['a', 'b', 'c','d'])

print(df)
print("__________")
print("转置")
print(df.T)
print("__________")
print("axes")
print(df.axes)

print("__________")
print("dtype")
print(df.dtypes)

print("__________")
print("empty")
print(df.empty)

print("__________")
print("ndim")
print(df.ndim)

print("___________")
print("shape")
print(df.shape)

print("__________")
print("size")
print(df.size)

print("__________")
#返回numpy表示DataFrame 的值
print("values")
print(df.values)

   A  B   C
a  1  5   9
b  b  6  10
c  3  7  11
d  4  8  12
__________
转置
   a   b   c   d
A  1   b   3   4
B  5   6   7   8
C  9  10  11  12
__________
axes
[Index(['a', 'b', 'c', 'd'], dtype='object'), Index(['A', 'B', 'C'], dtype='object')]
__________
dtype
A    object
B     int64
C     int64
dtype: object
__________
empty
False
__________
ndim
2
___________
shape
(4, 3)
__________
size
12
__________
values
[[1 5 9]
 ['b' 6 10]
 [3 7 11]
 [4 8 12]]

函数

常用的统计学函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积

重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

reindex

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)

• labels：

  • 类型：数组或列表，默认为 None。
  • 描述：新的索引标签。

• index：

  • 类型：数组或列表，默认为 None。
  • 描述：新的行索引标签。

• columns：

  • 类型：数组或列表，默认为 None。
  • 描述：新的列索引标签。

• axis：

  • 类型：整数或字符串，默认为 None。
  • 描述：指定重新索引的轴。0 或 ‘index’ 表示行，1 或 ‘columns’ 表示列。

• method：

  • 类型：字符串，默认为 None。
  • 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。

• copy：

  • 类型：布尔值，默认为 True。
  • 描述：是否返回新的 DataFrame 或 Series。

• level：

  • 类型：整数或级别名称，默认为 None。
  • 描述：用于多级索引（MultiIndex），指定要重新索引的级别。

• fill_value：

  • 类型：标量，默认为 np.nan。
  • 描述：用于填充缺失值的值。

• limit：

  • 类型：整数，默认为 None。
  • 描述：指定连续填充的最大数量。

• tolerance：

  • 类型：标量或字典，默认为 None。
  • 描述：指定重新索引时的容差。

labels 和 axis 配合可重置索引

1. 直接使用index 或者 columns可重置索引。 此时labels将失效。默认axis = 0

import pandas as pd
import numpy as np

data = {
    "A": [1, 2, 3, 4],
    "B": [5, 6, 7, 8],
    "C": [9, 10, 11, 12],
}


df = pd.DataFrame(data,index=["a", "b", "c",'d'])

print(df)
#修改行索引,原来没有的索引将默认为NaN
print("____________")
res =  df.reindex(index=['c','a','b','d','e'])
print(res)

A  B   C
a  1  5   9
b  2  6  10
c  3  7  11
d  4  8  12
____________
     A    B     C
c  3.0  7.0  11.0
a  1.0  5.0   9.0
b  2.0  6.0  10.0
d  4.0  8.0  12.0
e  NaN  NaN   NaN

#修改行索引,原来没有的索引将默认为NaN
print("____________")#Literal["backfill", "bfill", "ffill", "pad"]
res =  df.reindex(index=['c','a','b','d','E']).ffill()
print(res)

print("____________")
# 只用指定值填充
res = df.reindex(index=['c','a','b','d','E'],fill_value = 0)
print(res)

print("____________")
# 只用指定值填充，同时指定method 和 fill_value,先以非NaN为准再以method为准
res = df.reindex(index=['c','e','a','b','d']).bfill()
print(res)

____________
     A    B     C
c  3.0  7.0  11.0
a  1.0  5.0   9.0
b  2.0  6.0  10.0
d  4.0  8.0  12.0
E  4.0  8.0  12.0
____________
   A  B   C
c  3  7  11
a  1  5   9
b  2  6  10
d  4  8  12
E  0  0   0
____________
     A    B     C
c  3.0  7.0  11.0
e  1.0  5.0   9.0
a  1.0  5.0   9.0
b  2.0  6.0  10.0
d  4.0  8.0  12.0

reindex_like

reindex_like 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 DataFrame 或 Series 的索引相匹配。如果在重新索引的过程中，新的索引与原始索引不完全匹配，那么不匹配的位置将会被填充为 NaN 值。

DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

遍历

Series遍历

items()

import pandas as pd
import numpy as np

data = {
    "A": [1, 2, 3, 4],
    "B": [5, 6, 7, 8],
    "C": [9, 10, 11,12]
}

df = pd.DataFrame(data, index=['a', 'b', 'c','d'])

ps =  pd.Series([1,2,3,4,5])
for index,value in ps.items():
    print(index,value)

0 1
1 2
2 3
3 4
4 5

index

print("_____________")
for i in ps.index:
    print(i,ps[i])

_____________
0 1
1 2
2 3
3 4
4 5

values

print("_____________")
for i in ps.values:
    print(i)

print("_____________")
for i in ps:
    print(i)

_____________
1
2
3
4
5
_____________
1
2
3
4
5

DataFrame遍历

直接遍历

使用for 返回的是列标签

data = {
    "A": [1, 2, 3, 4],
    "B": [5, 6, 7, 8],
    "C": [9, 10, 11,12]
}

df = pd.DataFrame(data, index=['a', 'b', 'c','d'])
# 直接for 返回列标签
for i in df:
    print(i)

A
B
C

遍历行

使用 iterrows() 函数，返回索引和行

# 遍历行
for index,row in df.iterrows():
    print("_____________")
    print(index)
    print(row)

_____________
a
A    1
B    5
C    9
Name: a, dtype: int64
_____________
b
A     2
B     6
C    10
Name: b, dtype: int64
_____________
c
A     3
B     7
C    11
Name: c, dtype: int64
_____________
d
A     4
B     8
C    12
Name: d, dtype: int64

遍历列

• 使用items 遍历

# 返回每一列
for index,value in df.items():
    print("_____________")
    print(index)
    print(value)

_____________
A
a    1
b    2
c    3
d    4
Name: A, dtype: int64
_____________
B
a    5
b    6
c    7

• 使用 itertuples 遍历（推荐），性能更好。

  • df.itertuples(index=False)
    

    index 参数，接收bool 值，True会返回每行索引，False不反回

  • #遍历行，返回一个命名元组对象,默认Pandas
    # index为False,不返回index
    # index 默认True
    for i in df.itertuples(index=False):
        print(i)
        print(i[0])
    

    Pandas(A=1, B=5, C=9)
    1
    Pandas(A=2, B=6, C=10)
    2
    Pandas(A=3, B=7, C=11)
    3
    Pandas(A=4, B=8, C=12)
    4
    

  • for i in df.itertuples(name="Pandas"):
        print("_____________")
        print(i)
        print(i[0])
        print(i.A)
    

    _____________
    my_Pandas(Index='a', A=1, B=5, C=9)
    a
    1
    _____________
    my_Pandas(Index='b', A=2, B=6, C=10)
    b
    2
    _____________
    my_Pandas(Index='c', A=3, B=7, C=11)
    c
    3
    _____________
    my_Pandas(Index='d', A=4, B=8, C=12)
    d
    4
    

  • 通过 index 和 columns 属性遍历

    
    #使用 index 和 columns 属性访问
    for index in df.index:
        for colum in df.columns:
            print(df.loc[index,colum],end=" ")
        print()
    

    1 5 9 
    2 6 10 
    3 7 11 
    4 8 12
    

排序

sort_index

可通过sort_index() 函数根据索引进行排序。

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

sort_values

按照指定的列或索引进行升序或降序排序，并且支持多种排序策略和缺失值的处理。

DataFrame.sort_values(by=None,  axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last') 

• by：指定列名（axis=0或'index'）或索引值（axis=1或'columns'）。如果不指定，默认按照第一列进行排序。
• axis：指定排序的方向，axis=0表示按列排序，axis=1表示按行排序。默认值为axis=0。
• ascending：布尔值或列表，用于指定是否升序排列。默认为True，即升序排列。
• inplace：布尔值，表示是否在原DataFrame上进行排序，还是返回一个新的排序后的DataFrame。默认为False，即不替换原数据。
• kind：排序算法，可选值为{'quicksort', 'mergesort', 'heapsort'}。默认值为quicksort。
• na_position：指定缺失值的显示位置，可选值为'first'或'last'。默认值为'last'，即缺失值排在最后面

data = {
    "B": [5, 2, 1, 4],
    "A": [1, 6, 3, 8],
    "C": [5, 1, 11,9]
}

df = pd.DataFrame(data,index=['b','a','c','d'])
print(df)
print("________________")
# 按照A列降序
res =  df.sort_values(by=['A'],axis=0, ascending=False,inplace=False,kind='mergesort') # quick heap  stable
print(res)

   B  A   C
b  5  1   5
a  2  6   1
c  1  3  11
d  4  8   9
________________
   B  A   C
d  4  8   9
a  2  6   1
c  1  3  11
b  5  1   5

去重

drop_duplicates() 方法对元素去重

DataFrame

DataFrame.drop_duplicates(subset=None,  keep='first', inplace=False) 

• 参数说明

  • subset：可选参数，默认为 None。用于指定要考虑的列名列表，如果不指定，将考虑所有列。只有这些列中的值完全相同的行才会被视为重复项。

  • keep: 可选参数，默认为'first'

    指定如何保留重复项，有以下三个取值：

    • 'first'：保留第一次出现的重复项，删除后续的重复项。
    • 'last'：保留最后一次出现的重复项，删除前面的重复项。
    • False：删除所有重复项，即不保留任何重复的行。

  • inplace：可选参数，默认为 False。如果为 True，则直接在原 DataFrame 上进行修改，不返回新的 DataFrame；如果为 False，则返回一个移除了重复项的新 DataFrame。

  import pandas as pd
  
  # 创建一个示例 DataFrame
  data = {
      'A': [1, 2, 2, 1],
      'B': [4, 5, 5, 6],
      'C': [2, 8, 8, 2]
  }
  df = pd.DataFrame(data)
  print(df)
  print("______________")
  # 删除所有列的重复行，默认保留第一个出现的重复项
  df_unique = df.drop_duplicates()
  print(df_unique)
  
  print("______________")
  # 删除重复行，保留最后一个出现的重复项
  df_unique = df.drop_duplicates(keep='last')
  print(df_unique)
  
  print("______________")
  # keep = first 保留第一项，False不保留 
  dfu = df.drop_duplicates(['A', 'C'], keep='first')
  print(dfu)
  

Series

同DataFrame一样，只是无subset参数，全部进行去重。

Series.drop_duplicates(keep='first',  inplace=False) 

分组

DataFrame.groupby() 用于执行数据的分组和聚合操作,基于一个或多个列的值对DataFrame进行分组，并对每个组进行各种计算。

df.groupby(by=None,  axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs) 

参数说明

• by：指定用于分组的列或列名列表。
• axis：指定分组的方向，默认为0（按行分组），也可以为1（按列分组）。
• level：指定分组的级别，适用于多层次索引的情况。
• as_index：决定是否将分组标签作为结果的一部分，默认为True。
• sort：是否对分组结果进行排序，默认为True。
• group_keys：是否将分组键作为结果的一部分，默认为True。
• squeeze：是否去除结果中的单级索引，默认为False。

import pandas as pd
import numpy as np
# 创建一个示例 DataFrame
data = {
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': [1, 2, 3, 4, 5, 6, 7, 8],
    'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)

# 按列 'A' 分组
grouped = df.groupby('A')

# 查看分组结果
for name, group in grouped:
    print(f"Group: {name}")
    print(group)
    print()

Group: bar
     A      B  C   D
1  bar    one  2  20
3  bar  three  4  40
5  bar    two  6  60

Group: foo
     A      B  C   D
0  foo    one  1  10
2  foo    two  3  30
4  foo    two  5  50
6  foo    one  7  70
7  foo  three  8  80

# 对每组C列求平均值，D列求标准差
mean = df.groupby(['A']).agg({'C': 'mean', 'D': 'std'}).reset_index()
print(mean)

     A    C          D
0  bar  4.0  20.000000
1  foo  4.8  28.635642

对分组内每个数据进行操作

data = {
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': [1, 2, 3, 4, 5, 6, 7, 8],
    'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)

# 按列 'A' 分组
grouped = df.groupby('A')

# 在分组内根据C列求平均值
# transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
# mean = grouped['C'].transform(lambda x: x.mean())
mean = grouped['C'].transform(lambda x: x.mean())

df['C_mean'] = mean
print(df)

# 在分组内根据C列求标准差
std = grouped['C'].transform('std')
df['C_std'] = std
print(df)

# 在分组内根据C列进行正太分布标准化
norm = grouped['C'].transform(lambda x: (x - x.mean()) / x.std())
df['C_normal'] = norm
print(df)

     A      B  C   D  C_mean
0  foo    one  1  10     4.8
1  bar    one  2  20     4.0
2  foo    two  3  30     4.8
3  bar  three  4  40     4.0
4  foo    two  5  50     4.8
5  bar    two  6  60     4.0
6  foo    one  7  70     4.8
7  foo  three  8  80     4.8
     A      B  C   D  C_mean     C_std
0  foo    one  1  10     4.8  2.863564
1  bar    one  2  20     4.0  2.000000
2  foo    two  3  30     4.8  2.863564
3  bar  three  4  40     4.0  2.000000
4  foo    two  5  50     4.8  2.863564
5  bar    two  6  60     4.0  2.000000
6  foo    one  7  70     4.8  2.863564
7  foo  three  8  80     4.8  2.863564
     A      B  C   D  C_mean     C_std  C_normal
0  foo    one  1  10     4.8  2.863564 -1.327018
1  bar    one  2  20     4.0  2.000000 -1.000000
2  foo    two  3  30     4.8  2.863564 -0.628587
3  bar  three  4  40     4.0  2.000000  0.000000
4  foo    two  5  50     4.8  2.863564  0.069843
5  bar    two  6  60     4.0  2.000000  1.000000
6  foo    one  7  70     4.8  2.863564  0.768273
7  foo  three  8  80     4.8  2.863564  1.117488

过滤

filter 对元素过滤

import pandas as pd

# 创建一个示例 DataFrame
data = {
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': [1, 2, 3, 4, 5, 6, 7, 8],
    'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)

mean = df.groupby('A')['C'].transform('mean')
res = df.assign(mean=mean)
print(res)
print("__________")
# 按列 'A' 分组，并过滤掉列 'C' 的平均值小于等于4 的组
filtered = df.groupby('A').filter(lambda x: x['C'].mean() >4)

print(filtered)

     A      B  C   D  mean
0  foo    one  1  10   4.8
1  bar    one  2  20   4.0
2  foo    two  3  30   4.8
3  bar  three  4  40   4.0
4  foo    two  5  50   4.8
5  bar    two  6  60   4.0
6  foo    one  7  70   4.8
7  foo  three  8  80   4.8
__________
     A      B  C   D
0  foo    one  1  10
2  foo    two  3  30
4  foo    two  5  50
6  foo    one  7  70
7  foo  three  8  80

聚合

使用 agg() 方法，对分组后的数据，对每一个分组聚合为单个值。

import pandas as pd
import numpy as np
data = {
    'Category': ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B'],
    'Value1': [10, 20, 30, 40, 50, 60, 70, 80],
    'Value2': [15, 25, 35, 45, 55, 65, 75, 85]
}
df = pd.DataFrame(data)

gdf = df.groupby(['Category'])
# key表示聚合名称，传入元组对每组内的列进行聚合操作
res = gdf.agg(value1=('Value1', 'std'), value2=('Value2', 'std')).reset_index()
# res = gdf.std().reset_index()
# res = gdf.agg({'Value1':['mean','std'],'Value2':['mean','std']}).reset_index()
print(res)

import pandas as pd
import numpy as np
data = {
    'Category': ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B'],
    'Value1': [10, 20, 30, 40, 50, 60, 70, 80],
    'Value2': [15, 25, 35, 45, 55, 65, 75, 85]
}
df = pd.DataFrame(data)

gdf = df.groupby(['Category'])

# res = gdf.agg(value1=('Value1', 'std'), value2=('Value2', 'std')).reset_index()
# res = gdf.std().reset_index()

res = gdf.agg({'Value1':['mean','std'],'Value2':['mean','std']})
res.columns = ['_'.join(c) for c in res.columns]

print(res)

          Value1_mean  Value1_std  Value2_mean  Value2_std
Category                                                  
A                40.0   25.819889         45.0   25.819889
B                50.0   25.819889         55.0   25.819889

合并

使用 pd.merge()函数对两个DataFrame数据进行合并，可以向Mysql数据表一样对数据进行连接等操作。

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

参数说明：

• left：左侧的 DataFrame 对象。

• right：右侧的 DataFrame 对象。

• how：合并方式，可以是 ‘inner’、‘outer’、‘left’ 或 ‘right’。默认为 ‘inner’。

  • ‘inner’：内连接，返回两个 DataFrame 共有的键。
  • ‘outer’：外连接，返回两个 DataFrame 的所有键。
  • ‘left’：左连接，返回左侧 DataFrame 的所有键，以及右侧 DataFrame 匹配的键。
  • ‘right’：右连接，返回右侧 DataFrame 的所有键，以及左侧 DataFrame 匹配的键。

• on：用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。

• left_on 和 right_on：分别指定左侧和右侧 DataFrame 的连接列名。

• left_index 和 right_index：布尔值，指定是否使用索引作为连接键。

• sort：布尔值，指定是否在合并后对结果进行排序。

• suffixes：一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。

• copy：布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。

• indicator：布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。

• validate：验证合并是否符合特定的模式。

import pandas as pd
import numpy as np

import pandas as pd

# 创建两个示例 DataFrame
left = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K3'],
    'A': ['0', '1', '2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})

right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['0', '1', '2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3'],
    'r_key': ['K3', 'K1', 'K0', 'K2']
})

res =  pd.merge(left, right, left_on='A',right_on='C', how='left', suffixes=('_l', '_r'),indicator=True)

print(res)

res = pd.merge(left, right,left_index=True, right_index=True,how='left', suffixes=('_l', '_r'))
print(res)

  key_l   A   B key_r    C    D r_key     _merge
0    K0   0  B0    K0    0   D0    K3       both
1    K1   1  B1    K1    1   D1    K1       both
2    K2   2  B2    K2    2   D2    K0       both
3    K3  A3  B3   NaN  NaN  NaN   NaN  left_only
  key_l   A   B key_r   C   D r_key
0    K0   0  B0    K0   0  D0    K3
1    K1   1  B1    K1   1  D1    K1
2    K2   2  B2    K2   2  D2    K0
3    K3  A3  B3    K4  C3  D3    K2

时间

Timestamp

pandas中的时间类

创建

# 可传入多种形式进行创建
pd.Timestamp(datetime.now())
pd.Timestamp(datetime.now().timestamp())
pd.Timestamp("2024-05-19 16:45:30")
pd.Timestamp(year=2024, month=5, day=19, hour=16, minute=59, second=59,unit='ms', tz='Asia/Shanghai')

解析

使用pd.to_datetime() 对时间进行解析

da = pd.to_datetime("2024/05/19 16:45:30")
print(da)
# 自定义解析格式
da = pd.to_datetime("2024/05/19 16:45:30",format="%Y/%m/%d %H:%M:%S")
print(da)
#不全的部分，以最开始时间自动补充
da = pd.to_datetime("2024/10")
print(da)

2024-05-19 16:45:30
2024-05-19 16:45:30
2024-10-01 00:00:00

date_range

date_range() 函数用于生成一个固定频率的日期时间索引（DatetimeIndex）。这个函数非常灵活，可以用于生成各种时间序列数据。

pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)

参数解释

• start：str 或 datetime-like，可选参数。表示日期范围的开始时间。默认值为 None。
• end：str 或 datetime-like，可选参数。表示日期范围的结束时间。默认值为 None。
• periods：int，可选参数。表示生成的日期时间索引的长度，即要生成的日期数量。如果 start 和 end 都已知，则可以不指定该参数；若 start 或 end 有一个未知，则需要指定该参数。默认值为 None。
• freq：str 或 DateOffset，可选参数。表示日期的频率，例如 'D' 表示每天，'M' 表示每月最后一天，'MS' 表示每月第一天等。默认值为 'D'。
• tz：str 或 tzinfo，可选参数。表示时区，例如 'Asia/Shanghai'。默认值为 None。
• normalize：bool，可选参数。若为 True，则会将 start 和 end 时间标准化为午夜（00:00:00）。默认值为 False。
• name：str，可选参数。表示生成的日期时间索引的名称。默认值为 None。
• closed：str，可选参数。指定区间的开闭方式，可以取值为 'left'（左闭右开）、'right'（左开右闭） 或 None（两边都闭）。默认值为 None。

pd.date_range("2024-03-19 16:45:30",end="2024-04-12 16:45:30",freq='D',normalize=True)

DatetimeIndex(['2024-03-19', '2024-03-20', '2024-03-21', '2024-03-22',
               '2024-03-23', '2024-03-24', '2024-03-25', '2024-03-26',
               '2024-03-27', '2024-03-28', '2024-03-29', '2024-03-30',
               '2024-03-31', '2024-04-01', '2024-04-02', '2024-04-03',
               '2024-04-04', '2024-04-05', '2024-04-06', '2024-04-07',
               '2024-04-08', '2024-04-09', '2024-04-10', '2024-04-11',
               '2024-04-12'],
              dtype='datetime64[ns]', freq='D')

时间差

可通过时间差Timedelta 对时间进行加或减时操作

pt =  pd.Timedelta(days=1,hours=1,minutes=1,seconds=1)

t = pd.Timestamp("2024-03-19 16:45:30")
# t = datetime.now()

print(t)
print(t+pt)

#数量加单位进行创建
pt = pd.Timedelta(12,unit='h')
print(t+pt)

2024-03-19 16:45:30
2024-03-20 17:46:31
2024-03-20 04:45:30

格式化时间

strftime 将时间转换为str ,strptime 将时间字符串转换成时间

now = pd.Timestamp("2024-03-19 16:45:30")
print(now)

# 时间格式化 datatime 对象也可以
print(now.strftime("%Y年%m月%d日 %H:%M:%S"))

# datetime 中 将字符串按照指定格式解析为对象
# 类似pd.to_datetime("2024/05/19 16:45:30")
print( datetime.strptime("2024-11-12 11:11:11", "%Y-%m-%d %H:%M:%S"))

2024-03-19 16:45:30
2024年03月19日 16:45:30
2024-11-12 11:11:11

随机取样

用于从 DataFrame 对象中随机抽取一些行或列，并返回一个新的 DataFrame 或 Series 对象，其中包含这些随机抽取的项目。这个方法主要用于简单随机抽样。

DataFrame.sample(n=None,  frac=None, replace=False, weights=None, random_state=None, axis=0) 

• n (int 或 None): 指定要抽取的样本数量。如果指定了 n，则 frac 应设置为 None。
• frac (float 或 None): 指定要抽取的样本占原数据框的比例。如果同时指定了 n 和 frac，将使用 frac 参数。
• replace (bool, 默认为 False): 控制是否允许重复抽样。
• weights (str 或数组型, 默认为 None): 指定每个样本的权重。可以是列名，指示样本权重的列，也可以是权重数组。
• random_state (int 或 RandomState 实例或 None, 默认为 None): 用于指定随机数生成器的种子，以实现可重复抽样。
• axis ({0 或 ‘index’, 1 或 ‘columns’}, 默认为 0): 指定抽样的轴。如果为 0 或 ‘index’，则在行上进行抽样；如果为 1 或 ‘columns’，则在列上进行抽样。

例

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "company": ['百度', '阿里', '腾讯'],
    "salary": [43000, 24000, 40000],
    "age": [25, 35, 49]
})
print('随机选择两行：')
print(df.sample(n=2, axis=0).copy(deep=True))
print('随机选择一列：')
print(df.sample(n=1, axis=1))
print('总体的50%：')
print(df.sample(axis='index', frac=0.5))

随机选择两行：
  company  salary  age
1      阿里   24000   35
0      百度   43000   25
随机选择一列：
   salary
0   43000
1   24000
2   40000
总体的50%：
  company  salary  age
0      百度   43000   25
2      腾讯   40000   49

空值处理

• 检查空值

  • df.isnull()# 判断为空
    df.notnull()# 判断不为空
    

    返回bool数组

  • import pandas as pd
    import numpy as np
    
    # 创建一个包含空值的示例 DataFrame
    data = {
        'A': [1, 2, np.nan, 4],
        'B': [5, np.nan, np.nan, 8],
        'C': [9, 10, 11, 12]
    }
    df = pd.DataFrame(data)
    
    # 检测空值
    is_null = df.isnull()
    print(is_null)
    
    # 检测非空值
    not_null = df.notnull()
    print(not_null)
    

           A      B      C
    0  False  False  False
    1  False   True  False
    2   True   True  False
    3  False  False  False
           A      B     C
    0   True   True  True
    1   True  False  True
    2  False  False  True
    3   True   True  True
    

• 空值填充

  • df.fillna(value)# 用value 填充空值 
    

    # 创建一个包含空值的示例 DataFrame
    data = {
        'A': [1, 2, np.nan, 4],
        'B': [5, np.nan, np.nan, 8],
        'C': [9, 10, 11, 12]
    }
    df = pd.DataFrame(data)
    
    # 用 0 填充空值
    df_filled = df.fillna(1)
    print(df_filled)
    

         A    B   C
    0  1.0  5.0   9
    1  2.0  1.0  10
    2  1.0  1.0  11
    3  4.0  8.0  12
    

• 空值删除

  • df.dropna(axis=0, how='any')
    

    
    # 创建一个包含空值的示例 DataFrame
    data = {
        'A': [1, 2, np.nan, 4],
        'B': [5, np.nan, np.nan, 8],
        'C': [9, 10, 11, 12]
    }
    df = pd.DataFrame(data)
    
    #df
    print(df)
    print("___________")
    df.dropna(axis=0, how='any', inplace=True)
    print(df)
    

         A    B   C
    0  1.0  5.0   9
    1  2.0  NaN  10
    2  NaN  NaN  11
    3  4.0  8.0  12
    ___________
         A    B   C
    0  1.0  5.0   9
    3  4.0  8.0  12
    

读取CSV文件

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

1. to_csv()

to_csv() 方法将 DataFrame 存储为 CSV 文件。

例：

import pandas as pd

# 创建一个简单的 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

# 将 DataFrame 导出为 CSV 文件，不保存索引
df.to_csv('output.csv', index=False)

2. read_csv()

read_csv() 方法用于从 CSV 文件中读取数据，并创建 DataFrame 对象。

例：

import pandas as pd
import os
# 将 DataFrame 导出为 CSV 文件
cwd = os.getcwd()

csv = pd.read_csv("data/data.csv")
print(csv)

      Name  Age         City
0    Alice   25     New York
1      Bob   30  Los Angeles
2  Charlie   35      Chicago

绘图

pandas 中可直接对DataFrame对象数据进行绘图，调用plot函数即可，并传入对应绘图方式即可

例

import pandas as pd
import matplotlib.pyplot as plt

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 25, 30, 40]
}
df = pd.DataFrame(data)

# 绘制折线图
df.plot(kind='line')
# 显示图表
plt.show()

# 绘制柱状图,可知道x 和 y 轴。不指定默认x 从0-n,其他都是y
df.plot(kind='bar',x='A', y='B')
# 显示图表
plt.show()

# 绘制散点图
df.plot(kind='scatter', x='A', y='B')
# 显示图表
plt.show()



# 创建一个示例 Series
data = {
    'A': 10,
    'B': 20,
    'C': 30,
    'D': 40
}
series = pd.Series(data)
# 绘制饼图
series.plot(kind='pie', autopct='%1.1f%%')
# 显示图表
plt.show()