一.Dataframe简介

DataFrame 的每一行或列数据都可以看成一个Series结构，只不过，DataFrame 为这些行中每个数据值增加了一个列或行标签。

同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签。

二.创建Dataframe对象

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

• data：一组数据（ndarray、series, map, lists, dict 等类型）

• index：索引值，或者可以称为行标签

• columns：列标签，默认为RangeIndex （0, 1, 2, …, n）

• dtype：数据类型
  copy：默认为 False，表示复制数据 data

2.1 空Dataframe

import pandas as pd
 
df = pd.DataFrame()
print(df)

结果：

Empty DataFrame
Columns: []
Index: []

2.2 列表嵌套字典创建

data = [
    {'name': 'John', 'age': 25, 'city': 'New York'},
    {'name': 'Alice', 'age': 30, 'city': 'London'},
    {'name': 'Bob', 'age': 28, 'city': 'Paris'}
]
df = pd.DataFrame(data)
print(df)

结果：

name  age      city
0   John   25  New York
1  Alice   30    London
2    Bob   28     Paris

这个方法创建就是把每个字典当作一整条数据传入Dataframe，分别用key来当作列标签，然后用默认标签来依次取行下标。

那我两个字典长度不一样怎么办？

# 有些字段一样，几个不同
data1 = [
    # 不传值，会默认为NaN
    {'name': 'John', 'age': 25},
    {'name': 'Alice', 'age': None,'city':'Paris'},
    # 传入空值，猜猜会显示啥
    {'name': 'Bob', 'age': 28, 'city': None}
    
]
df = pd.DataFrame(data1)
print(df)

结果：

name   age   city
0   John  25.0    NaN
1  Alice   NaN  Paris
2    Bob  28.0   None

可以看到，其将多出来的标签下，没有传这个标签的其他行变为Not a number即缺失值（会被存储为浮点数）,如果传入一个None值，分两种情况：如果是数值类型，就会变成NaN;若所在列都是字符串类型，就会显示为None（也算一种值）。

其实本质上None和NaN是同一种表达，都表示这个地方没有正常值，但是一般来说还是缺失值用的多，毕竟None也是一种值。

2.3 字典嵌套列表创建

dic = {'name':['张三','李四'],'age':[10,18]}
 
df = pd.DataFrame(dic)
print(df)

结果：

name  age
0   张三   10
1   李四   18

这个方法创建就是把字典中每个key作为列标签，每个value对应传入一个列表，当作列标签下的数据。

多说一句，这里要是各个标签下的数据长度不一致的话，会报错。

dic = {'name':['张三','李四'],'age':[10,18,19]}
 
df = pd.DataFrame(dic)
print(df)

结果：

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)

~~~~~~

~~~~
~~~~（此处省略）

2.4 字典嵌套series创建

 
dic = {'name':pd.Series(['clocky','Miko'],index=['a','b']),
 # 这里试试给行标签多加了一行，会报错吗？
 'age':pd.Series([20,21,22],index=['a','b','c'])}
 
df = pd.DataFrame(dic)
print(df)

结果：

name  age
a  clocky   20
b    Miko   21
c     NaN   22

答案是不会报错，这个创建方式也就是升级版的字典嵌套列表创建。但是可以自定义标签值。

三.列索引操作

3.1 获取数据

3.3.1 下标获取

import pandas as pd
 
df = pd.DataFrame({'name':['clocky','tom'],'age':[18,20]})
# 获取一列，返回Series
print(df['name'])
 
# 获取多列，返回DataFrame
# 获取多列时需要多加一个[]
print(df[['name','age']])

结果：

0    clocky
1       tom
Name: name, dtype: object
     name  age
0  clocky   18
1     tom   20

3.1.2 布尔索引值

import pandas as pd
 
df = pd.DataFrame({'name':['clocky','tom'],'age':[18,20]})
 
# 返回满足条件的值所在的一整行
# 这里的布尔索引是针对一个列的，所以表达式里的对象要是df[列名]
print(df[df['age']>19])

结果：

name  age
1  tom   20

3.2 添加列

3.2.1 添加空列

import pandas as pd
df = pd.DataFrame({'name':['clocky','tom'],'age':[18,20]})
 
# 添加一个不存在的标签，其为全空
df['sex'] = None
print(df)

结果：

name  age   sex
0  clocky   18  None
1     tom   20  None

3.2.2 通过列表添加实际的数据

import pandas as pd
df = pd.DataFrame({'name':['clocky','Susie'],'age':[18,20]})
 
# 使用列表添加
df['sex'] = ['male','female']
print(df)

结果：

name  age     sex
0  clocky   18    male
1   Susie   20  female

3.2.3 assign 方法

• 可以链式调用,就是可以连续调用比如 a.assign(b=1).assign(c=2)

• 方法返回的数据类型是数据本身，这就是链式编程；重复调用这个方法就是链式调用

import pandas as pd
df = pd.DataFrame({'name':['clocky','Susie'],'age':[18,20]})
 
# 这里新加的标签就不用加''了，且连续调用仔细看看
df1 = df.assign(sex = ['male','famale']).assign(address = ['beijing','shanghai'])
print(df1)

结果：

name  age     sex   address
0  clocky   18    male   beijing
1   Susie   20  famale  shanghai

3.2.4 insert指定位置插入列

参数：

• loc: 插入位置的列索引

• column: 新列的名称

• value: 要插入的 Series（可迭代对象）

import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# 在索引1的位置插入一列
df.insert(1,'sex',['male','famle'])
print(df)

结果：

name    sex  age
0  clocky   male   18
1   Susie  famle   20

3.3 修改列数据

3.3.1 直接覆盖

import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# 直接用索引赋值
df['age'] += 100
print(df)

结果：

name  age
0  clocky  118
1   Susie  120

3.3.2 修改列名

# columns 属性修改
import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# 其实也是直接覆盖
df.columns = ['n','a']
print(df)

结果：

n   a
0  clocky  18
1   Susie  20

# rename方法，返回一个新的DataFrame，原数据不变
import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# rename方法，用columns传入一个字典，key为原列名，value为修改后的列名
pdf = df.rename(columns={'name':'姓名','age':'年龄'})
 
print(pdf)

结果：

姓名  年龄
0  clocky  18
1   Susie  20

3.3.3 .astype()修改列的数据类型

import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# 修改第二列
df['age'] = df['age'].astype(float)
print(df)

结果：

name   age
0  clocky  18.0
1   Susie  20.0

3.3.4 删除列数据

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

1. labels：

   • 类型：单个标签或列表。

2. axis：

   • 描述：指定删除的方向。axis = 0 或 axis = ‘index’ 表示删除行，axis=1 或 axis = ‘columns’ 表示删除列。

3. index：

   • 描述：要删除的行的标签。如果指定，则忽略 labels 参数。

4. columns：

   • 描述：要删除的列的标签。如果指定，则忽略 labels 参数。

5. level：

   • 类型：整数或级别名称，默认为 None。

   • 描述：用于多级索引（MultiIndex），指定要删除的级别。

6. inplace：

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

   • 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。

7. errors：

   • 类型：字符串，默认为 raise。

   • 描述：指定如何处理不存在的标签。raise 表示抛出错误，ignore 表示忽略错误。

import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# 删除列
df.drop(columns = 'age',inplace = True)
print(df)

结果：

name
0  clocky
1   Susie

import pandas as pd
df = pd.DataFrame(
    {'name':['clocky','Susie'],
     'age':[18,20]})
 
# 删除行(这里不写axis也一样)
df.drop(0,axis = 0,inplace = True)
print(df)

结果：

name  age
1  Susie   20