2.Pandas

最新推荐文章于 2022-12-23 23:41:48 发布
最新推荐文章于 2022-12-23 23:41:48 发布
阅读量250 收藏
点赞数
文章标签： 数据结构 列表 python java 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/only_tokimeki/article/details/109298363
版权

Pandas

什么是Pandas？

基于 NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。

与Numpy的区别？

  • Pandas是专门为处理表格和混杂数据设计的

  • NumPy更适合处理统一的数值数组数据

数据结构

Pandas中的主要数据结构有两个：Series和DataFrame

  • Series是一种类似于一维数组（Python中的list）的对象，由一组数据和一组索引（下标）两部分组成。Series可以保存任何数据类型。
  • DataFrame是一个二维的表格型数据结构，可以把它想象成是一个Excel表格来理解，既有行索引，也有列索引。其中每列可以是不同的值类型。
  • Index也是比较常见的数据结构，虽然没有前两者那么重要，但也是必不可少的。

创建数据结构对象

Series
初步
  • 由相同元素类型构成的一维数据结构
  • 具有列表和字典的特点

In [1]:

import numpy as np
import pandas as pd
from pandas import Series
from pandas import DataFrame

In [2]:

data = [i for i in range(1,6)]
index = ['a','b','c','d','f']
s = Series(data,index=index)
s

Out[2]:

a    1
b    2
c    3
d    4
f    5
dtype: int64

In [3]:

s.index

Out[3]:

Index(['a', 'b', 'c', 'd', 'f'], dtype='object')

In [4]:

s.name

In [5]:

s.values

Out[5]:

array([1, 2, 3, 4, 5], dtype=int64)

In [6]:

s.shape

Out[6]:

(5,)
创建
Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
无索引创建
  • data为ndarray或list，则其缺少Series需要索引信息
  • 提供index，必须与data长度相同
  • 若不提供，则Series会自动生成默认数值索引range(0,data.shape[0])

In [7]:

data1 = [1,2,3]
data2 = np.array([1,2,3])
index = ['a','b','c']

s1 = Series(data1,index=index)
s2 = Series(data2,index=index)
s3 = Series(data1)

In [8]:

s1

Out[8]:

a    1
b    2
c    3
dtype: int64

In [9]:

s2

Out[9]:

a    1
b    2
c    3
dtype: int32

In [10]:

s3

Out[10]:

0    1
1    2
2    3
dtype: int64
有索引创建
  • 如果 data 为 Series 或 dict ，那么其已经提供了 Series 需要的索引信息，所以 index 项是不需要提供的
  • 如果额外提供了 index 项，那么其将对当前构建的Series进行覆盖

In [11]:

data = {
    'a':1,
    'b':2,
    'c':3,
}
index = ['e','f','g']

s1 = Series(data=data)

In [12]:

s1

Out[12]:

a    1
b    2
c    3
dtype: int64

In [13]:

s1.index = index

In [14]:

s1

Out[14]:

e    1
f    2
g    3
dtype: int64
DataFrame
初步
  • 具有共同索引的Series按排列构成（二维矩阵）
  • 类似于Excel表格

In [15]:

data = [
    [1,2,3],
    [4,5,6]
]
index = ['a','b']
columns = ['A','B','C']
df = DataFrame(data=data,index=index,columns=columns)
df

Out[15]:

ABC
a123
b456

In [16]:

df.index # 行索引

Out[16]:

Index(['a', 'b'], dtype='object')

In [17]:

df.columns # 列索引

Out[17]:

Index(['A', 'B', 'C'], dtype='object')

In [18]:

df.values

Out[18]:

array([[1, 2, 3],
       [4, 5, 6]], dtype=int64)

In [19]:

df.shape

Out[19]:

(2, 3)

In [20]:

df.dtypes # 数据类型

Out[20]:

A    int64
B    int64
C    int64
dtype: object
创建
DataFrame(data=None, index=None, columns=None)

函数由多个参数，主要参数：data,index和columns

data无行索引、无列索引
  • 如果 data 为 ndarray(2D) or list(2D)，那么其缺少 DataFrame 需要的行、列索引信息
  • 如果提供 index 或 columns 项，其必须和data的行 或 列长度相同
  • 如果不提供 index 或 columns 项，那么其将默认生成数值索引range(0, data.shape[0])) 或 range(0, data.shape[1])。

In [21]:

data = np.array([
    [1,2,3],
    [4,5,6]
])
index = ['a','b']
columns = ['A','B','C']
df = DataFrame(data,index=index,columns=columns)
df

Out[21]:

ABC
a123
b456
data无 行索引，有 列索引
  • 如果data为 dict of ndarray(1D) or list(1D)，所有ndarray或list的长度必须相同。且dict的key为DataFrame提供了需要的columns信息，缺失index
  • 如果提供 index 项，必须和list的长度相同
  • 如果不提供 index，那么其将默认生成数值索引range(0, data.shape[0]))
  • 如果还额外提供了columns项，那么其将对当前构建的DataFrame进行 列重索引

In [22]:

data = {'A':[1,4],'V':[4,5],'C':[6,7]}
index = ['a','b']
columns = ['A','B','C']
df = DataFrame(data,)
df

Out[22]:

AVC
0146
1457

In [23]:

df.columns = columns
df

Out[23]:

ABC
0146
1457
data有 行索引，有 列索引
  • 如果data为 dict of Series or dict，那么其已经提供了DataFrame需要的所有信息
  • 如果多个Series或dict间的索引不一致，那么取并操作（pandas不会试图丢掉信息），缺失的数据填充NaN
  • 如果提供了index项或columns项，那么其将对当前构建的DataFrame进行 重索引（reindex，pandas内部调用接口）

In [24]:

data1 = {'A':pd.Series([1,4],index=['a','b']),'V':pd.Series([4,5],index=['a','b']),'C':pd.Series([6,7],index=['a','c'])}
df1 = pd.DataFrame(data1)
df1

Out[24]:

AVC
a1.04.06.0
b4.05.0NaN
cNaNNaN7.0

In [25]:

data2 = {'A':{'a':1,'b':2},'V':{'a':4,'b':5},'C':{'a':7,'':8}}
df2 = pd.DataFrame(data2)
df2

Out[25]:

AVC
a1.04.07.0
b2.05.0NaN
NaNNaN8.0
读取文件
CSV文件
pd.read_csv(filepath_or_buffer, sep=',', header='infer', names=None, index_col=None, encoding=None )
  • filepath_or_buffer：路径和文件名不要带中文，带中文容易报错
  • sep: csv文件数据的分隔符，默认是','，根据实际情况修改
  • header：如果有列名，那么这一项不用改
  • names：如果没有列名，那么必须设置header = None， names为列名的列表，不设置默认生成数值索引
  • index_col：int型，选取这一列作为索引
  • encoding：根据你的文档编码来确定，如果有中文读取报错，试试encoding = 'gbk'

这里采用手动创建数据

import pandas as pd

# 初始数据集: 婴儿名字和出生率
names = ['Bob','Jessica','Mary','John','Mel']
births = [968, 155, 77, 578, 973]

BabyDataSet = list(zip(names, births))

df = pd.DataFrame(data = BabyDataSet, columns=['Names', 'Births'])
df

Out[1]:

NamesBirths
0Bob968
1Jessica155
2Mary77
3John578
4Mel973
导出数据为csv格式
df.to_csv(filename, index, header)

将这两个参数设置为 False 将会防止索引(index)和列名(header names)被导出到文件中

In [2]:

df.to_csv('birthday.csv', index=False, header=False) # 将数据转化为csv文件
导入csv数据

In [3]:

df = pd.read_csv('./birthday.csv') 
df

Out[3]:

Bob968
0Jessica155
1Mary77
2John578
3Mel973

会发现列名不正确，是错误的，需要进行调整，将header设置为None即可，想要设置自定义列名，需要通过names参数进行设置

In [4]:

df = pd.read_csv('./birthday.csv',header=None)
df

Out[4]:

01
0Bob968
1Jessica155
2Mary77
3John578
4Mel973

In [5]:

df = pd.read_csv('./birthday.csv',header=None, names=['Names', 'Births'])
df

Out[5]:

NamesBirths
0Bob968
1Jessica155
2Mary77
3John578
4Mel973
Excel文件
pd.read_excel(io, sheetname=0, header=0, index_col=None, names=None)
  • io：文件地址
  • sheetname：表格的sheet窗口名称
  • header：如果有列名，那么这一项不用改；
  • names：如果没有列名，那么必须设置header = None， names为列名的列表，不设置默认生成数值索引；
  • index_col：int型，选取这一列作为索引。
导出数据为xls格式
  • 用法与to_csv类似

注意运用index，header参数去掉索引和列名

In [6]:

df.to_excel('birthday.xls', index=False)
导入excel数据

In [7]:

df = pd.read_excel('birthday.xls')
df

Out[7]:

NamesBirths
0Bob968
1Jessica155
2Mary77
3John578
4Mel973

增删查改

Series

In[1]:

import numpy as np
import pandas as pd

s = pd.Series(data=[1,2,3],index=['a','b','c'])
s

Out[1]:

a    1
b    2
c    3
dtype: int64
通过索引与切片进行查询

In [2]:

s['a'] # 通过索引返回目标值

Out[2]:

1

In [3]:

s[0:2] # 范围，左闭右开

Out[3]:

a    1
b    2
dtype: int64

In [4]:

s['a':'c'] # 注意与上不同，左右均为闭区间

Out[4]:

a    1
b    2
c    3
dtype: int64

In [5]:

s[[0,2]] # 通过列表，返回多个值

Out[5]:

a    1
c    3
dtype: int64

In [6]:

s[['a','c']] # 通过自定义索引，进行查询，返回多个值

Out[6]:

a    1
c    3
dtype: int64

In [7]:

s[[True,False,True]] # 类似于列表，返回该列表为真的相同下标的值

Out[7]:

a    1
c    3
dtype: int64
通过iloc与loc进行查询
  • loc查询方式与上述相同
  • iloc查询无视索引，只根据位置定位
基于索引--loc

In [8]:

s.loc['b'] # <==> s['b']，返回索引位置的目标值

Out[8]:

2

In [9]:

s.loc['a':'c'] # <==> s['a':'c']

Out[9]:

a    1
b    2
c    3
dtype: int64

In [10]:

s.loc[['a','c']] # <==> s[['a','c']]

Out[10]:

a    1
c    3
dtype: int64

In [11]:

s.loc[[True,False,True]] # s[[True,False,True]]

Out[11]:

a    1
c    3
dtype: int64
基于位置--iloc

In [12]:

s

Out[12]:

a    1
b    2
c    3
dtype: int64

In [13]:

s.iloc[1] #　根据下标位置进行查询 <==> s[1]

Out[13]:

2

In [14]:

s.iloc[0:2] # 切片 <==> s[0:2]

Out[14]:

a    1
b    2
dtype: int64

In [15]:

s.iloc[[0,2]] # 切片 <==> 列表,s[[0,2]]

Out[15]:

a    1
c    3
dtype: int64

In [16]:

s.iloc[[False, True, False]] # 切片 <==> 列表,s[[False, True, False]]

Out[16]:

b    2
dtype: int64
修改数值
  • 直接赋值

In[1]:

import pandas as pd
import numpy as np

s = pd.Series(data=np.array([1,2,3,4]),index=['a','b','c','d'])
s

Out[1]:

a    1
b    2
c    3
d    4
dtype: int32

In [2]:

s1 = s.copy()
s1['a'] = 1000
s1

Out[2]:

a    1000
b       2
c       3
d       4
dtype: int32

In [3]:

s1[0:2] = 10
s1

Out[3]:

a    10
b    10
c     3
d     4
dtype: int32
  • 通过replace函数修改
Series.replace(to_replace=None, value=None, inplace=False)
  • to_replace：要修改的值，可以为列表
  • value：改为的值，可以为列表，与to_repalce要匹配
  • inplace：是否在原地修改

In [5]:

s2 = s1.replace(to_replace=10,value=1000)
s2

Out[5]:

a    1000
b    1000
c       3
d       4
dtype: int32

In [6]:

s2 = s1.replace(to_replace=[10,3],value=1000)
s2

Out[6]:

a    1000
b    1000
c    1000
d       4
dtype: int32
修改索引
  • 通过index进行修改

In [7]:

s1.index = ['q','w','e','r']
s1

Out[7]:

q    10
w    10
e     3
r     4
dtype: int32
  • 通过rename函数修改
Series.rename(index=None, level = None, inplace = False)
  • index：list or dict，list时必须和已有索引长度相同，dict可以部分修改
  • level：多重索引时，可以指定修改哪一重，从0开始递增
  • inplace：是否原地修改

In [9]:

s1.rename(index={'q':'f'},inplace=False)

Out[9]:

f    10
w    10
e     3
r     4
dtype: int32
添加数据
  • 增加一行

In [10]:

s2 = s.copy()
s2['e'] = 5
s2

Out[10]:

a    1
b    2
c    3
d    4
e    5
dtype: int64
  • 增加多行
Series.append(to_append, ignore_index=False, verify_integrity=False)
  • to_append: 另一个series或多个Series构成的列表；
  • ignore_index：False-保留原有索引，True-清除所有索引，生成默认数值索引；
  • verify_integrity：True的情况下，如果to_append索引与当前索引有重复，则报错。

In [11]:

s3 = pd.Series(data=[25,26],index=['h','j'])
s2.append(s3,ignore_index=False)

Out[11]:

a     1
b     2
c     3
d     4
e     5
h    25
j    26
dtype: int64
删除数据
  • 删除一行数据

In [14]:

s = pd.Series(np.arange(4),index=['a','b','c','d'])
s2 = s.drop('a')
s2

Out[14]:

b    1
c    2
d    3
dtype: int32
  • 删除多行数据
Series.drop(labels, level=None, inplace=False)
  • labels：索引，单索引或索引的列表；
  • level：多重索引需要设置；
  • inplace：是否本地修改。

In [15]:

s.drop(['b','c'])

Out[15]:

a    0
d    3
dtype: int32
DataFrame

In[1]:

import pandas as pd
import numpy as np

data = np.array([
    [1,2,3],
    [4,5,6]
])
index = ['a','b']
columns = ['A','B','C']
df = pd.DataFrame(data=data,index=index,columns=columns)
df

Out[1]:

ABC
a123
b456

#####　通过索引与切片进行查询

  • 通过列索引--查询单个值

In [2]:

df['A']

Out[2]:

a    1
b    4
Name: A, dtype: int32
  • 通过列索引--查询多个值

In [3]:

df[['A','C']]

Out[3]:

AC
a13
b46
  • 查询第几行--行范围

In [4]:

df[:1]

Out[4]:

ABC
a123
  • 通过布尔值，返回需要的行

In [5]:

df[[False,True]]

Out[5]:

ABC
b456
  • 通过行索引查询

In [6]:

df['a':'b']

Out[6]:

ABC
a123
b456
  • 通过条件筛选查询

In [7]:

df[df>4]

Out[7]:

ABC
aNaNNaNNaN
bNaN5.06.0
基于索引查询--loc
  • 查询单值

In [9]:

df.loc['b','B']

Out[9]:

5
  • 查询多值，通过行索引以及列索引筛选需要的值

In [10]:

df.loc['a':'b','A']

Out[10]:

a    1
b    4
Name: A, dtype: int32

In [11]:

df.loc['a','A':'B']

Out[11]:

A    1
B    2
Name: a, dtype: int32

In [12]:

df.loc[['a','b'],'B']

Out[12]:

a    2
b    5
Name: B, dtype: int32

In [13]:

df.loc[[True,True,],'B']

Out[13]:

a    2
b    5
Name: B, dtype: int32
基于位置查询--iloc
  • 查询单个值

In [14]:

df

Out[14]:

ABC
a123
b456

In [15]:

df.iloc[1,1]

Out[15]:

5

In [16]:

df.iloc[0,0]

Out[16]:

1
  • 查询多个值：第一个参数为行，第二个参数为列，均可为列表

In [20]:

df.iloc[[0,1],[1,2]]

Out[20]:

BC
a23
b56
修改数值
  • 直接修改

In [18]:

df1 = df.copy()
df1.loc['a','A'] = 1000
df1

Out[18]:

ABC
a100023
b456

  • 通过replace修改

    DataFrame.replace(to_replace=None, value=None, inplace=False)
    • to_replace：要修改的值，可以为列表
    • value：改为的值，可以为列表，与to_repalce要匹配
    • inplace：是否在原地修改

    In [19]:

    df1.replace(to_replace=1000,value=5555,inplace=False)

    Out[19]:

    ABC
    a555523
    b456

  • 交换行列

In [20]:

df1[['A','B']] = df1[['B','A']]
df1

Out[20]:

ABC
a210003
b546
修改索引
  • 直接修改行索引index，列索引columns

In [21]:

df1 = df.copy()
df1

Out[21]:

ABC
a123
b456

In [22]:

df1.index = ['c','d']
df1.columns = ['C','D','E']
df1

Out[22]:

CDE
c123
d456
  • 通过rename函数进行修改

In [24]:

df1.rename(index={'c':'t'},columns={'C':'H'},inplace=False)

Out[24]:

HDE
t123
d456
添加行数据
  • 添加一行数据

In [25]:

df1 = df.copy()
df1.loc['j'] = ['7','8','9']
df1

Out[25]:

ABC
a123
b456
j789
  • 添加多行数据
pd.concat(objs, axis=0)

确保 列索引 相同，行增加。 （其实这个函数并不要求列索引相同，它可以选择出相同的列。而我写这个教程遵循了python的宣言—明确：做好一件事有一种最好的方法，精确控制每一步，可以少犯错。）

  • objs: list of DataFrame；
  • axis: 取0，进行行增加操作。

In [26]:

df1 = pd.DataFrame(
    data=[
        [1,2,3,],
        [4,5,6],
    ],
    index=['a','b'],
    columns=['A','B','C'],
)
df2 = pd.DataFrame(
    data=[
        [7,8,9]
    ],
    index=['c','d'],
    columns=['A','B','C'],
)
pd.concat([df1,df2],axis=0)

Out[26]:

ABC
a123
b456
c789
d789
添加列数据
  • 添加一列数据

In [27]:

df1 = df.copy()
df1

Out[27]:

ABC
a123
b456

In [28]:

df1['D'] = [4,7]
df1

Out[28]:

ABCD
a1234
b4567
  • 添加多列数据

In [29]:

df2 = pd.DataFrame(
    data=[
        [11,12],
        [14,15]
    ],
    index=['a','b'],
    columns=['E','F']
)
pd.concat([df1,df2],axis=1)

Out[29]:

ABCDEF
a12341112
b45671415
删除数据

  • 删除多行数据

    DataFrame.drop(labels, axis = 0,  level=None, inplace=False)
    • labels：索引，单索引或索引的列表；
    • axis：0-删行；
    • level：多重索引需要指定；
    • inplace：是否本地修改。

In[30]:

df = pd.DataFrame(
    data = [
        [1,2,3],
        [4,5,6]
    ],
    index=['a','b'],
    columns=['A','B','C']
)
df

Out[30]:

ABC
a123
b456

In [33]:

df2 = df.copy()
df2.drop(['a'],axis=0)

Out[33]:

ABC
b456
  • 删除一列删除

In [32]:

df1 = df.copy()
del df1['A']
df1

Out[32]:

BC
a23
b56

  • 删除多列数据

    DataFrame.drop(labels, axis = 1,  level=None, inplace=False)
    • labels：索引，单索引或索引的列表；
    • axis：1-删列；
    • level：多重索引需要指定；
    • inplace：是否本地修改。

In [33]:

df3 = df.copy()
df3.drop(['A','C'],axis=1)

Out[33]:

B
a2
b5

In [34]:

df4 = df.copy()
df4.drop(columns=['A','C'],)

Out[34]:

B
a2
b5

合并数据

merge()
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort = False)

concat函数本质上是在所有索引上同时进行对齐合并，而如果想在任意列上对齐合并，则需要merge函数，其在sql应用很多。

  • left,right： 两个要对齐合并的DataFrame；
  • how： 先做笛卡尔积操作，然后按照要求，保留需要的，缺失的数据填充NaN；
    • left: 以左DataFrame为基准，即左侧DataFrame的数据全部保留（不代表完全一致、可能会存在复制），保持原序
    • right: 以右DataFrame为基准，保持原序
    • inner: 交，保留左右DataFrame在on上完全一致的行，保持左DataFrame顺序
    • outer: 并，按照字典顺序重新排序
  • on：列索引或列索引列表，如果要在DataFrame相同的列索引做对齐，用这个参数；
  • left_on, right_on, left_index, right_index：
    • on对应普通的列索引或列索引列表，对齐不同列名的DataFrame，用这俩参数；
    • index对应要使用的index，建议不要使用这俩参数，因为可以用concat方法代替。
  • sort: True or False，是否按字典序重新排序。
1.初步

In [1]:

import numpy as np
import pandas as pd

df1 = pd.DataFrame(
    data=np.array([
        [1,2],
        [3,4]
    ]),
    index = ['a','b'],
    columns = ['A','B']
)

df2 = pd.DataFrame(
    data=np.array([
        [1,3],
        [4,7]
    ]),
    index = ['b','d'],
    columns = ['B','C']
)

In [2]:

df1

Out[2]:

AB
a12
b34

In [3]:

df2

Out[3]:

BC
b13
d47
  1. 如果单纯的按照index对齐，不如用concat方法，所以一般不建议使用left_index, right_index

In [4]:

pd.merge(left = df1, right = df2, left_on='A', right_on='B')

Out[4]:

AB_xB_yC
01213
小区别是concat对重复列没有重命名，但是重名的情况不多，而且重名了说明之前设计就不大合理。

In [5]:

pd.concat([df1,df2],join='inner',axis=1)

Out[5]:

ABBC
b3413
2.on用法
  • 设置how='inner'

In [6]:

# 对于'B'列，df1的b行以及df2的d行，是相同的，其他都不相同
pd.merge(left=df1,right=df2,how='inner',on=['B'])

Out[6]:

ABC
0347

In [7]:

# 对于'A'列'b'行，df2的'C‘列d行是相同的，其他都不相同
# 其他列如果同名会进行重命名
pd.merge(left=df1,right=df2,how='inner',left_on=['A'],right_on=['C'])

Out[7]:

AB_xB_yC
03413
3.how用法

In [8]:

# 保持左侧的不便，用右侧的来进行对齐，对不齐的填NaN
pd.merge(left=df1,right=df2,how='left',on=['B'])

Out[8]:

ABC
012NaN
1347.0

In [9]:

# 保持右侧的不便，用左侧的来进行对齐，对不齐的填NaN
pd.merge(left=df1,right=df2,how='right',on=['B'])

Out[9]:

ABC
03.047
1NaN13
  • 对齐的列存在重复值

In [10]:

df1.loc['a','B']=4
df1

Out[10]:

AB
a14
b34

In [11]:

df2

Out[11]:

BC
b13
d47

In [12]:

# 根据B列，两个DataFrame之间不同行，有相同数据，则重新组成一行，并保持右侧# 不变
pd.merge(left=df1,right=df2,how='right',on=['B'])

Out[12]:

ABC
01.047
13.047
2NaN13
concat()详解
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=None, copy=True)
1.初步

In [13]:

s1 = pd.Series(
    data=np.array([1,2,3]),
    index=['a','b','c']
)
s2 = pd.Series(
    data=np.array([4,5,6]),
    index=['e','f','g']
)
s3 = pd.Series(
    data=np.array([7,8,9]),
    index=['h','i','j']
)

In [14]:

pd.concat([s1,s2,s3])

Out[14]:

a    1
b    2
c    3
e    4
f    5
g    6
h    7
i    8
j    9
dtype: int32

In [15]:

pd.concat([s1,s2,s3],axis=1,sort=False)

Out[15]:

012
a1.0NaNNaN
b2.0NaNNaN
c3.0NaNNaN
eNaN4.0NaN
fNaN5.0NaN
gNaN6.0NaN
hNaNNaN7.0
iNaNNaN8.0
jNaNNaN9.0

普通列和行index的相互转化

字符串处理

查看信息

info
DataFrame.info(verbose=None, memory_usage=True, null_counts=True)
  • verbose：True or False，字面意思是冗长的，也就说如果DataFrame有很多列，是否显示所有列的信息，如果为否，那么会省略一部分；
  • memory_usage：True or False，默认为True，是否查看DataFrame的内存使用情况；
  • null_counts：True or False，默认为True，是否统计NaN值的个数。
ndim、shape、size

查看维数，形状，元素个数

head、tail

默认分别查看头5行和后5行。

Series/DataFrame.head(n=5)
Series/DataFrame.tail(n=5)
memory_usage
Series/DataFrame.memory_usage(index=True, deep=False)
  • index：是否显示索引占用的内存，毫无疑问索引也占用内存；
  • deep：是否显示object类型的列消耗的系统资源，由于pandas中object元素只是一个引用，我估计这个deep是指显示真实的内存占用。
describe

快速查看每一列的统计信息，默认排除所有NaN元素

DataFrame.describe( include= [np.number])
  • include：'all'或者[np.number 或 np.object]。numberic只对元素属性为数值的列做数值统计，object只对元素属性为object的列做类字符串统计。

数值运算

与数据库进行交互

米津玄师的一枚粉丝
关注
Modin.pandas使用多核CPU加速pandas？Modin.pandas可以代替pandas？看看就知道了
qq_35869630的博客
05-05 4025
答案先写在开头，免得你们直接拉到下面看结果~ modin.pandas 确实能使得一部分函数使用多核cpu进行加速处理，但是现在有些功能还不完善，有些函数还是用的默认pandas处理… 具体哪些函数是可以加速的可以往下看看 主要测试了apply，groupby，read_csv 一、Modin.pandas 在讲modin之前，简单介绍一下pandas，pandas主要是python用来处理数据的...
2. Pandas介绍
weixin_44657010的博客
02-19 351
Introduction to Pandas You can think of pandas as an extremely powerful version of Excel, with a lot more features Series A Series is very similar to a Numpy array. What differentiate the Numpy array ...
【pandas】--DataFrame数据筛选（二）
panbaoran913的博客
12-17 1万+
dataframe的数据的选择和筛选
Pandas告警UserWarning: pandas only supports SQLAlchemy connectable
hubing_hust的专栏
12-23 3万+
解决Pandas告警UserWarning: pandas only supports SQLAlchemy connectable
python数据处理—pandas相关函数的使用(持续更新）
weixin_45768308的博客
09-10 2519
pandas相关函数处理，sort() , drop() , shape()
pandas中高频函数详细说明
miya的博客
12-14 2026
1. merge 合并两个matrix pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False) concat函数只能根据索引对齐，而如果想在任意列上对齐合并，则需要merge函数，其在sql应用很多。 left, right： 两个要对齐合并的DataFrame； how： 先做笛卡尔积操作，然后按照要求，保留需要的，
2.Pandas 安装 _ 菜鸟.pdf
01-16
Pandas 安装与基本使用 Pandas 是 Python 中的一款功能强大且广泛使用的数据分析库，安装和使用 Pandas 是数据分析和科学计算的基础。下面是对 Pandas 安装和基本使用的总结。 Pandas 安装 Pandas 的安装需要基础...
2.pandas应用 - 数据透视 测试数据
10-11
数据透视 测试数据
2.Pandas教程_df与Series基础-选择行与列.mp4
最新发布
08-10
youtube精品python pandas课程
1.Pandas 教程 _ 菜鸟.pdf
01-16
Pandas 官网：https://pandas.pydata.org/ Pandas 源代码：https://github.com/pandas-dev/pandas Pandas 是一个功能强大且灵活的数据分析工具，广泛应用在各个数据分析领域。如果你想学习 Pandas，可以阅读我们的...
在Pandas中更改列的数据类型【方法总结】
热门推荐
jinruoyanxu的博客
01-24 9万+
先看一个非常简单的例子： a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']] df = pd.DataFrame(a) 有什么方法可以将列转换为适当的类型？例如，上面的例子，如何将列2和3转为浮点数？有没有办法将数据转换为DataFrame格式时指定类型？或者是创建DataFrame，然后通过某种方法更改每列的类型？
pandas.to_numeric转化数据为数字型
weixin_34019144的博客
02-07 1万+
to_numeric(arg, errors='raise', downcast=None) Convert argument to a numeric type. Parameters ---------- arg : list, tuple, 1-d array, or Series errors :...
python基础-Pandas数据处理
s_unbo的博客
12-07 853
python基础-Pandas数据处理 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。 代码 import numpy as np #数据读取和显示 import pandas as pd food_info = pd.read_csv ("foo
pandas如何删除原来标签，重新从0-n设置index
tsq15的博客
10-31 2902
data.index=[i for i in range(data.shape[0])]
Pandas学习笔记（一）
qq_15846331的博客
04-08 449
Pandas 学习笔记Pandas环境Pandas数据结构创建series创建DataFrame由文件创建Pandas基本功能 Pandas环境 测试环境使用的是Anaconda。 Pandas数据结构 Pandas处理以下两个数据结构：（panel已弃用，将在以后的版本中删除。） 1、series 注释：Series是pandas中暴露给我们使用的基本对象，它是由相同元素类型构成的一维数据结构，...
categorical_data(类别型数据)预处理笔记：转化为数字
sublio的博客
08-01 3522
  1、用Python转化为标准格式。 import pandas as pd import numpy as np from pandas import Series, DataFrame from sklearn.preprocessing import LabelEncoder #一般操作 #读文件： #e:/cate_data/before/filename.txt #1将文件读入...
Caffe学习系列(14)：初识数据可视化
Leo的博客
01-01 3427
首先将caffe的根目录作为当前目录，然后加载caffe程序自带的小猫图片，并显示。 图片大小为360x480，三通道 In [1]: import numpy as np import matplotlib.pyplot as plt %matplotlib inline import caffe caffe_root='/home/xxx/caff
机器学习模型自我代码复现：回归
thorn_r的博客
03-26 2291
根据模型的数学原理进行简单的代码自我复现以及使用测试，仅作自我学习用。模型原理此处不作过多赘述，仅罗列自己将要使用到的部分公式。
pandas dataframe 取列名
Talk Is Cheap
07-17 1万+
DataFrame.columns.values.tolist()
tqdm.pandas
03-12
tqdm.pandas是一个Python库，它提供了一个用于在pandas中显示进度条的功能。它是基于tqdm库的扩展，可以方便地在处理大型数据集时显示进度条，以便用户可以实时了解任务的进展情况。 使用tqdm.pandas，你可以在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值