Pandas学习总结

已于 2022-08-08 22:12:25 修改
阅读量3.4k 收藏 10
点赞数 1
分类专栏： 机器学习 文章标签： pandas 学习 python
于 2022-08-08 13:08:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45190143/article/details/126225543
版权

文章目录

Pandas学习总结

pandas提供了快速便捷处理结构化数据的大量数据结构和函数。

一、pandas数据结构介绍

Series和DataFrame
个人理解Series类似一个字典，而DataFrame类似多个字典的组合

Series

pd.Series(data=None, index=None, dtype=None)

  • data：传入的数据，可以是ndarray、list等
  • index：索引，必须是唯一的，且与数据的长度相等。如果没有传入索引参数，则默认会自动创建一个从0-N的整数索引
  • dtype：数据的类型
(1)Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
arr=[6,7,-5,9]
obj=pd.Series(arr)
obj
#左边是数据标签(索引),右边是数据

0    6
1    7
2   -5
3    9
dtype: int64

#索引
obj.index

RangeIndex(start=0, stop=4, step=1)

#值
obj.values

array([ 6,  7, -5,  9], dtype=int64)
(2)你可以自定义索引index==>(类似字典map)
obj2=pd.Series([1,-2,3,4],index=['a','b','c','d'])
obj2

a    1
b   -2
c    3
d    4
dtype: int64
(3)索引&根据索引修改值
obj2['a']

1

#根据索引index修改值value
obj2['b']=-6

#查询子串
obj2[['b','c','d']]

b   -6
c    3
d    4
dtype: int64

#根据值value来筛选
obj2[obj2>0]

a    1
c    3
d    4
dtype: int64
(4)运算
obj2*2

a     2
b   -12
c     6
d     8
dtype: int64

#取指数
np.exp(obj2)

a     2.718282
b     0.002479
c    20.085537
d    54.598150
dtype: float64

#判断index是否在Series内
'b' in obj2

True
(5)你可以传入字典map构建Series
#map字典
sdata={'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
#利用字典构建Series
obj3=pd.Series(sdata)
obj3

Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64

#传入字典，然后自己定义index
states=['Wuhan','Texas','Oregon','Utah']
obj4=pd.Series(sdata,index=states)
obj4
#可以发现Wuhan找不到对应的value

Wuhan         NaN
Texas     71000.0
Oregon    16000.0
Utah       5000.0
dtype: float64

#判断value是否为空
#obj4.isnull()同理
pd.isnull(obj4)
#pd.notnull()正好相反

Wuhan      True
Texas     False
Oregon    False
Utah      False
dtype: bool

#Series可以做运算，它会自动对齐（有的则做运算，没有的则NaN）
obj3+obj4

Ohio           NaN
Oregon     32000.0
Texas     142000.0
Utah       10000.0
Wuhan          NaN
dtype: float64

#可以为Series表格取名字，并对index列取名字
obj4.name='这个是表格名'
obj4.index.name='index_name'
obj4
#注意values没有name属性

index_name
Wuhan         NaN
Texas     71000.0
Oregon    16000.0
Utah       5000.0
Name: 这个是表格名, dtype: float64

DataFrame

pd.DataFrame(data=None, index=None, columns=None)

  • index：行标签。如果没有传入索引参数，则默认会自动创建一个从0-N的整数索引。
  • columns：列标签。如果没有传入索引参数，则默认会自动创建一个从0-N的整数索引

  DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。虽然DataFrame是以二维结构保存数据的，但你仍然可以轻松地将其表示为更高维度的数据。

DataFrame的属性:

  • shape:返回行和列的元组
  • index:DataFrame的行索引列表
  • columns:DataFrame的列索引列表
  • values:直接获取其中array的值
  • T:转置
  • head(5)：显示前5行内容
  • tail(5):显示后5行内容
(1)通过字典创建DataFrame
data={'state':['Ohio','Ohio','Ohio','Nevada','Nevada','Nevada'],
     'year':[2000,2001,2002,2001,2002,2003],
     'pop':[1.5,1.7,3.6,2.4,2.9,3.2]}
frame=pd.DataFrame(data)
frame
#没有指定index,所以index是默认从0开始的
stateyearpop
0Ohio20001.5
1Ohio20011.7
2Ohio20023.6
3Nevada20012.4
4Nevada20022.9
5Nevada20033.2
#head函数默认输出前5行
frame.head()
stateyearpop
0Ohio20001.5
1Ohio20011.7
2Ohio20023.6
3Nevada20012.4
4Nevada20022.9
#可以自定义列标题顺序
pd.DataFrame(data,columns=['year','pop','state'])
yearpopstate
020001.5Ohio
120011.7Ohio
220023.6Ohio
320012.4Nevada
420022.9Nevada
520033.2Nevada
#自定义index
frame2=pd.DataFrame(data,index=['A','B','C','D','E','F'])
frame2
stateyearpop
AOhio20001.5
BOhio20011.7
COhio20023.6
DNevada20012.4
ENevada20022.9
FNevada20033.2
(2)通过列名获取一列Series
frame2['state']

A      Ohio
B      Ohio
C      Ohio
D    Nevada
E    Nevada
F    Nevada
Name: state, dtype: object

frame2.year

A    2000
B    2001
C    2002
D    2001
E    2002
F    2003
Name: year, dtype: int64
(3)通过index获取一行Series
frame2.loc['A']

state    Ohio
year     2000
pop       1.5
Name: A, dtype: object
(4)删除一列
#首先先创造一列
frame2['eastern']=frame2.state=='Ohio'
frame2
stateyearpopeastern
AOhio20001.5True
BOhio20011.7True
COhio20023.6True
DNevada20012.4False
ENevada20022.9False
FNevada20033.2False
#通过列名删除
del frame2['eastern']
frame2.columns

Index(['state', 'year', 'pop'], dtype='object')
(5)DataFrame也可以做转置
frame2.T
ABCDEF
stateOhioOhioOhioNevadaNevadaNevada
year200020012002200120022003
pop1.51.73.62.42.93.2
frame2.values

array([['Ohio', 2000, 1.5],
       ['Ohio', 2001, 1.7],
       ['Ohio', 2002, 3.6],
       ['Nevada', 2001, 2.4],
       ['Nevada', 2002, 2.9],
       ['Nevada', 2003, 3.2]], dtype=object)

二、基本功能

重新索引

obj=pd.Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])
obj

d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

#重新索引，没有的index默认为NaN
obj2=obj.reindex(['a','b','c','d','e'])
obj2

a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

#不同的步长
obj3=pd.Series(['blue','purple','yellow'],index=[0,2,4])
obj3
obj3.reindex(range(6),method='ffill') #ffill forward-fills the values 向前填充

0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

#重新索引列名
#创建dataFrame
frame=pd.DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],
                  columns=['A','B','C'])
frame
ABC
a012
b345
c678
#列可以用columns关键字重新索引
states=['Wuhan','Putian','C']
frame.reindex(columns=states)
WuhanPutianC
aNaNNaN2
bNaNNaN5
cNaNNaN8

删除某个轴上的项

#删除Series上的某个项(因为只有一个轴，故不用选轴)
obj=pd.Series(np.arange(5.),index=['a','b','c','d','e'])
obj

a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
dtype: float64

#删除index为c的项
new_obj=obj.drop('c')
new_obj

a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64

#也可以一次删除多个
obj.drop(['d','c'])

a    0.0
b    1.0
e    4.0
dtype: float64

#删除DataFrame上某个轴的某个项
df=pd.DataFrame(np.arange(16).reshape((4,4)),
               index=['Ohio','Colorado','Utah','New York'],
               columns=['A','B','C','D'])
df
ABCD
Ohio0123
Colorado4567
Utah891011
New York12131415
#删除行
df.drop(['Colorado','Utah'])
ABCD
Ohio0123
New York12131415
#删除列
df.drop('A',axis=1) #这里要指定删除列，否则会报错==>axis='columns'可替换axis=1
BCD
Ohio123
Colorado567
Utah91011
New York131415

索引、选取和过滤

(1)Series索引
#Series索引
obj=pd.Series(np.arange(4.),index=['a','b','c','d'])
obj

a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64

#类似字典的索引（通过index索引）
obj['b']

1.0

#类似数组的索引
obj[1]

1.0

#切片的方式索引
obj[2:4]

c    2.0
d    3.0
dtype: float64
(2)DataFrame索引
#DataFrame索引
df=pd.DataFrame(np.arange(16).reshape((4,4)),
               index=['Ohio','Colorado','Utah','New York'],
               columns=['A','B','C','D'])
df
ABCD
Ohio0123
Colorado4567
Utah891011
New York12131415
#用一个值或序列对DataFrame进行索引其实就是获取一个或多个列
df['B']

Ohio         1
Colorado     5
Utah         9
New York    13
Name: B, dtype: int32

df[['A','C']]
AC
Ohio02
Colorado46
Utah810
New York1214
#切片
df[:2]
ABCD
Ohio0123
Colorado4567
#过滤
df[df['A']>0]
ABCD
Colorado4567
Utah891011
New York12131415

用loc和iloc进行选取(行的选取)

  对于DataFrame的行的标签索引，我引入了特殊的标签运算符loc和iloc。它们可以让你用类似NumPy的标记，使用轴标签（loc）或整数索引（iloc），从DataFrame选择行和列的子集。

#loc(使用轴标签)
df.loc['Ohio',['A','B']]

A    0
B    1
Name: Ohio, dtype: int32

#iloc(整数索引)
df.iloc[0:3,0:2]
AB
Ohio01
Colorado45
Utah89
#表示第2行（从0行开始）
df.iloc[2]

A     8
B     9
C    10
D    11
Name: Utah, dtype: int32

算术运算和数据对齐

(1)Series
s1=pd.Series([7.3,-2.5,3.4,1.5],index=['a','b','c','d'])
s2=pd.Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g'])

s1

a    7.3
b   -2.5
c    3.4
d    1.5
dtype: float64

s2

a   -2.1
c    3.6
e   -1.5
f    4.0
g    3.1
dtype: float64

#自动对齐
s1+s2

a    5.2
b    NaN
c    7.0
d    NaN
e    NaN
f    NaN
g    NaN
dtype: float64
(2)DataFrame
df1=pd.DataFrame(np.arange(9.).reshape((3,3)),
                 columns=list('bcd'),
                 index=['Ohio','Texas','Colorado'])
df2=pd.DataFrame(np.arange(12.).reshape((4,3)),
                 columns=list('bde'),
                 index=['Utah','Ohio','Texas','Oregon'])

df1
bcd
Ohio0.01.02.0
Texas3.04.05.0
Colorado6.07.08.0
df2
bde
Utah0.01.02.0
Ohio3.04.05.0
Texas6.07.08.0
Oregon9.010.011.0
#自动对齐
df1+df2
bcde
ColoradoNaNNaNNaNNaN
Ohio3.0NaN6.0NaN
OregonNaNNaNNaNNaN
Texas9.0NaN12.0NaN
UtahNaNNaNNaNNaN

算术运算中的填值

在对不同索引的对象进行算术运算时，你可能希望当一个对象中某个轴标签在另一个对象中找不到时填充一个特殊值（比如0）。

df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),columns=list('abcd'))
df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),columns=list('abcde'))
df1+df2
abcde
00.02.04.06.0NaN
19.011.013.015.0NaN
218.020.022.024.0NaN
3NaNNaNNaNNaNNaN
df1.add(df2,fill_value=0)
abcde
00.02.04.06.04.0
19.011.013.015.09.0
218.020.022.024.014.0
315.016.017.018.019.0

方法：
add,radd:加法(+)；
sub,rsub:减法(-)；
div,rdiv:除法(/)；
floordiv,rfloordiv:用于底除(//)；
mul,rmul:用于乘法(*)；
pow,rpow:用于指数(**)；

DataFrame和Series之间的运算

跟不同维度的NumPy数组一样，DataFrame和Series之间算术运算也是有明确规定的。==>广播

#计算一个二维数组与其第一行之间的差
arr=np.arange(12.).reshape((3,4))
arr

array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.]])

arr-arr[0]

array([[0., 0., 0., 0.],
       [4., 4., 4., 4.],
       [8., 8., 8., 8.]])

#同理，用DataFrame减去Series
frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                    columns=list('bde'),
                    index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series=frame.iloc[0]
frame
bde
Utah0.01.02.0
Ohio3.04.05.0
Texas6.07.08.0
Oregon9.010.011.0
frame-series
bde
Utah0.00.00.0
Ohio3.03.03.0
Texas6.06.06.0
Oregon9.09.09.0

函数应用和映射

NumPy的ufuncs（元素级数组方法）也可用于操作pandas对象。

frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
frame
bde
Utah-0.0430221.7227341.805661
Ohio-0.8334971.5367400.214056
Texas0.207997-0.356338-0.814931
Oregon-0.4502120.4228571.699617
#取绝对值函数abs()
np.abs(frame)
bde
Utah0.0430221.7227341.805661
Ohio0.8334971.5367400.214056
Texas0.2079970.3563380.814931
Oregon0.4502120.4228571.699617
#自定义函数
f=lambda x: x.max()-x.min() 
frame.apply(f)#这里的x默认为一个Series，也就是一列

b    1.041494
d    2.079072
e    2.620592
dtype: float64

#也可以设定为一行
frame.apply(f,axis='columns')

Utah      1.848683
Ohio      2.370237
Texas     1.022928
Oregon    2.149829
dtype: float64

#传递到apply的函数不是必须返回一个标量，还可以返回由多个值组成的Series
def f(x):
    return pd.Series([x.min(),x.max()],index=['min','max'])
frame.apply(f)
bde
min-0.833497-0.356338-0.814931
max0.2079971.7227341.805661

排序和排名

  根据条件对数据集排序（sorting）也是一种重要的内置运算。要对行或列索引进行排序（按字典顺序），可使用sort_index方法，它将返回一个已排序的新对象。

(1)Series
1)sort_index()
obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
#对index进行排序
obj.sort_index()

a    1
b    2
c    3
d    0
dtype: int64
2)sort_values()
#对值排序
obj2=pd.Series([4,7,-3,2])
obj2.sort_values()

2   -3
3    2
0    4
1    7
dtype: int64

#注意，若有缺失值NaN，都会被放到Series末尾
obj3= pd.Series([4, np.nan, 7, np.nan, -3, 2])
obj3.sort_values()

4   -3.0
5    2.0
0    4.0
2    7.0
1    NaN
3    NaN
dtype: float64
3)rank()
#rank是通过“为各组分配一个平均排名”的方式破坏平级关系的
obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
obj.rank()
#说明：这里表示-5的排名是第一名，然后若有相同的数的话则加权平均(例如有两个7，则他的排序都是第6.5名)

0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

#若不想相同的数加权平均，也可运用出现的顺序来排相同的数
obj.rank(method='first')

0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64

#降序进行排名
obj.rank(ascending=False, method='max')

0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64
(2)DataFrame
frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
                     index=['B', 'A'],
                     columns=['d', 'a', 'b', 'c'])
frame
dabc
B0123
A4567
1)sort_index()
#对index进行排序
frame.sort_index()
dabc
A4567
B0123
#对columns进行排序
frame.sort_index(axis=1)
abcd
B1230
A5674
#数据默认是按升序排序的，但也可以降序排序
frame.sort_index(axis=1,ascending=False)
dcba
B0321
A4765
2)sort_values()
#也可按值排序
frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
frame
ba
040
171
2-30
321
frame.sort_values(by='b')
ba
2-30
321
040
171
#也可对多个列的值进行排序
frame.sort_values(by=['a','b'])
ba
2-30
040
321
171
3）rank()
frame = pd.DataFrame({ 'a': [0, 1, 0, 1],'b': [4.3, 7, -3, 2],
                      'c': [-2, 5, 8, -2.5]})
frame
abc
004.3-2.0
117.05.0
20-3.08.0
312.0-2.5
frame.rank(axis='columns')
abc
02.03.01.0
11.03.02.0
22.01.03.0
32.03.01.0

带有重复标签的轴索引

(1)Series
#它的索引值不是唯一的
obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
obj['a']

a    0
a    1
dtype: int64
(2)DataFrame
df = pd.DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
df.loc['b']
012
b-1.5396880.8875870.177349
b-1.3964671.041014-0.638415

三、汇总和计算描述统计

pandas对象拥有一组常用的数学和统计方法。

df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=['a', 'b', 'c', 'd'],
                  columns=['one', 'two'])
df
onetwo
a1.40NaN
b7.10-4.5
cNaNNaN
d0.75-1.3

sum()

#默认是返回一个含有列的和的Series
df.sum()

one    9.25
two   -5.80
dtype: float64

#传入axis='columns'或axis=1将会按行进行求和运算
df.sum(axis=1)

a    1.40
b    2.60
c    0.00
d   -0.55
dtype: float64

#NA值会自动被排除，除非整个切片（这里指的是行或列）都是NA。通过skipna选项可以禁用该功能
df.sum(axis=1,skipna=False)

a     NaN
b    2.60
c     NaN
d   -0.55
dtype: float64

idxmin()和idxmax()

最大值或最小值的索引

df.idxmax()

one    b
two    d
dtype: object

cumsum()

累计

df.cumsum()
onetwo
a1.40NaN
b8.50-4.5
cNaNNaN
d9.25-5.8

describe()

于一次性产生多个汇总统计。

df.describe()
onetwo
count3.0000002.000000
mean3.083333-2.900000
std3.4936852.262742
min0.750000-4.500000
25%1.075000-3.700000
50%1.400000-2.900000
75%4.250000-2.100000
max7.100000-1.300000

方法统计及说明

(1)count:非NA值的数量；
(2)describe:针对Series和DataFrame列计算汇总统计；
(3)min、max:最小值和最大值；
(4)argmin、argmax:计算最小值和最大值索引(整数)；
(5)idxmin、idxmax:计算能获得到的最小值和最大值的索引；
(6)quantile:计算样本的分位数；
(7)sum:值的总和；
(8)mean:值的平均值；
(9)median:值的算术中位数(50%分位数)；
(10)mad:根据平均值计算平均绝对离差；
(11)var:样本值的方差；
(12)std:样本值的方差；
(13)skew:样本值的偏度(三阶矩)；
(14)kurt:样本值的峰度(四阶矩)；
(15)cumsum:样本值的累计和；
(16)cummin、cummax:样本值的累计最小值和最大值；
(17)cumprod:样本值的累计积；
(18)diff:计算一阶差分(对时间序列很有用)；
(19)pct_change:计算百分数变化；

相关系数和协方差

corr()

用于计算相关系数

cov()

用于计算协方差

唯一值、值计数以及成员资格

unique() ==》唯一值
#unique函数的作用是去重
obj=pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
uniques = obj.unique()
uniques
#需要的话，可以对结果再次进行排序（uniques.sort()）

array(['c', 'a', 'd', 'b'], dtype=object)
value_counts() ==》值的计数

value_counts用于计算一个Series中各值出现的频率

obj.value_counts()
#结果Series是按值频率降序排列的

a    3
c    3
b    2
d    1
dtype: int64
isin() ==》成员资格
#用于判断矢量化集合的成员资格
mask=obj.isin(['b', 'c'])
mask

0     True
1    False
2    False
3    False
4    False
5     True
6     True
7     True
8     True
dtype: bool

obj

0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
dtype: object

四、分组聚合案例

数据获取

从文件中读取星巴克店铺数据

#导入星巴克店的数据 
starbucks = pd.read_csv("./data/directory.csv")
starbucks.head()
BrandStore NumberStore NameOwnership TypeStreet AddressCityState/ProvinceCountryPostcodePhone NumberTimezoneLongitudeLatitude
0Starbucks47370-257954Meritxell, 96LicensedAv. Meritxell, 96Andorra la Vella7ADAD500376818720GMT+1:00 Europe/Andorra1.5342.51
1Starbucks22331-212325Ajman Drive ThruLicensed1 Street 69, Al JarfAjmanAJAENaNNaNGMT+04:00 Asia/Dubai55.4725.42
2Starbucks47089-256771Dana MallLicensedSheikh Khalifa Bin Zayed St.AjmanAJAENaNNaNGMT+04:00 Asia/Dubai55.4725.39
3Starbucks22126-218024Twofour 54LicensedAl Salam StreetAbu DhabiAZAENaNNaNGMT+04:00 Asia/Dubai54.3824.48
4Starbucks17127-178586Al Ain TowerLicensedKhaldiya Area, Abu Dhabi IslandAbu DhabiAZAENaNNaNGMT+04:00 Asia/Dubai54.5424.51

进行分组聚合

#按照国家分组，求出每个国家的星巴克零售店数量
count=starbucks.groupby(['Country']).count()

#画图显示结果
count.head()
BrandStore NumberStore NameOwnership TypeStreet AddressCityState/ProvincePostcodePhone NumberTimezoneLongitudeLatitude
Country
AD111111111111
AE1441441441441441441442478144144144
AR10810810810810810810810029108108108
AT181818181818181817181818
AU22222222222222220222222
count['Brand'].plot(kind='bar',figsize=(20,8))
plt.show()

在这里插入图片描述

#加入省市一起聚合
#设置多个索引，set_index()
starbucks.groupby(['Country','State/Province']).count().head(10)
#与前面的MultiIndex结构类似
BrandStore NumberStore NameOwnership TypeStreet AddressCityPostcodePhone NumberTimezoneLongitudeLatitude
CountryState/Province
AD711111111111
AEAJ22222200222
AZ484848484848720484848
DU8282828282821650828282
FU22222210222
RK33333303333
SH66666605666
UQ11111100111
ARB212121212121185212121
C7373737373737124737373
pandas总结
weixin_46681128的博客
09-17 1523
pandas简介 pandas 与 numpy 的主要区别是： 从数据类型上看： numpy 的核心数据结构是 ndarray，支持任意维数的数组，但要求单个数组内所有数据是同质的，即类型必须相同； pandas 的核心数据结构是 series和dataframe，仅支持一维和二维数据，但数据内部可以是异构数据，仅要求同列数据类型一致即可； 1. 从索引上看： numpy 的数据结构仅支持数字索引 pandas 数据结构则同时支持数字索引，标签索引和布尔索引 2. 从功能定位上看： numpy 虽
Python pandas学习总结
Alden_Wei的博客
04-02 2508
Python pandas学习总结 　　pandas是做数据分析非常重要的一个模块，它使得数据分析的工作变得更快更简单。由于现实世界中数据源的格式非常多，但是pandas也支持了不同数据格式的导入方法，所以学习pandas非常有必要。 要是想看所有的方法详解可以去官网，要想学习Pandas建议先看下面2个网站。 　　官网地址如下：https://pandas.pydata.org/ 　　官网教程如...
22 python Pandas 数据处理基础
bj_zhb的博客
04-18 1020
文章目录Pandas 数据处理基础数据类型series基本操作数据选择基于索引数字选择基于标签名称的选择数据删减数据填充检测缺失值插值填充数据可视化 Pandas 数据处理基础 介绍 Pandas 是非常著名的开源数据处理库，我们可以通过它完成对数据集进行快速读取、转换、过滤、分析等一系列操作。除此之外，Pandas 拥有强大的缺失数据处理与数据透视功能，可谓是数据预处理中的必备利器。 知识点 ...
Pandas完全指南：数据处理与分析从入门到实战
最新发布
xiaoyu❅的博客
03-19 870
Pandas是数据分析领域的瑞士军刀，本文涵盖了其80%的常用功能。建议通过以下方式精进：每天处理一个真实数据集掌握高效查询方法（.query().eval()深入理解分组聚合机制学习性能优化技巧（向量化操作）
pandas使用感想
qiuhuaizhi的专栏
09-19 3132
Pandas 是 python 的一个用于数据分析处理的库，用过 R 的同学看到里面的 DataFrame 会比较亲切，应该是从 R 那里有不少的借鉴。不过它立足于 python 这样一个全栈式的语言确实还是有着很大的优势。最近在看一个用 R 做机器学习的书籍，看了一些觉得 R 确实是一个让人捉急的语言，即便它看起来也足够简洁，但还是觉得像我这样不断的更换语言却没有一门精通的很是捉急（其实也没那么
《利用python进行数据分析》读书笔记--第五章 pandas入门
weixin_34090562的博客
11-30 318
pandas是本书后续内容的首选库。pandas可以满足以下需求： 具备按轴自动或显式数据对齐功能的数据结构。这可以防止许多由于数据未对齐以及来自不同数据源（索引方式不同）的数据而导致的常见错误。. 集成时间序列功能 既能处理时间序列数据也能处理非时间序列数据的数据结构 数学运算和简约（比如对某个轴求和）可以根据不同的元数据（轴编号）执行 灵活处理缺失数据 合并及其他出现在常见数据库...
pandas学习心得
zyf2695421695的博客
07-02 4531
Pandas是基于Numpy的专业数据分析工具，可以灵活高效地处理各种数据集，包含两种类型的数据结构：DataFrame（表）和Series（列） 。 pandas：字典+列表 df = pd.DataFrame({'姓名':['张三','李四'],'年龄':['11','22']},index = ['分类1','分类2']) 可以通过改变columns,index和values的值来控制数据。不指定索引时，从0开始的数字索引。 1.内容预览：df.head() 默认前5行 df.tail(...
python--pandas学习总结
数据挖掘+大数据研发+算法学习
02-21 1428
一、Series和DataFrame Pandas特别适合处理表格数据，如SQL表格、EXCEL表格。有序或无序的时间序列。具有行和列标签的任意矩阵数据。 打开Jupyter Notebook，导入numpy和pandas开始我们的教程： importnumpyasnp importpandasaspd 1. pandas.Series Series是带有索引的一维ndarray数组。索引值可不唯一，但必须是可哈希的。 pd.Series([1,3,5,np.nan,...
Pandas学习总结——2. 一文详述 Pandas索引
KF_Guan的博客
04-23 960
目录Pandas单级索引1. loc、iloc、[]操作符2. 布尔索引3 标量索引4 区间索引Pandas多级索引1 多层索引的创建2 多层索引切片3 多层索引的slice对象4 索引层交换索引设定常用索引型函数1 where()和mask()2 query()函数重复元素处理（duplicated和drop_duplicates）抽样函数(sample) 上篇文章介绍了Pan...
Pandas学习总结——6. 缺失数据处理
KF_Guan的博客
06-23 951
目录1 缺失值特性1.1 三种缺失值符号1.2 Nullable类型1.3 convert_dtypes方法2 缺失数据的运算规则2.1 普通运算2.2 groupby方法中的缺失值3 缺失数据的一些处理方法3.1 填充（fillna方法）3.2 剔除（dropna方法）3.3 插值（interpolation）3.3.1 线性插值3.3.2 高级插值方法3.3.3 interpolate中的参数 **内容简介：**本篇首先介绍Pandas中的三种缺失值符号，针对其弊端介绍Nullab
Pandas学习总结——4. Pandas变形 之 透视表 & 变形方法
KF_Guan的博客
04-28 880
文章目录1 透视表1.1 pivot与pivot_table1.2 交叉表（crosstab）2 其他变形方法2.1 melt2.2 压缩与展开（stack 和 unstack）3 哑变量与因子化3.1 Dummy Variable（哑变量）3.2 factorize方法4 问题与练习4.1 问题 1 透视表 1.1 pivot与pivot_table pivot函数可将某一列作为新的cols。...
pandas库学习报告.docx
04-11
数据仓库~有关于pandas库的学习报告 小丸子帮大家总结到位了 希望可以帮助各位 点赞收藏哈！！！
pandas 的一点心得
weixin_34174132的博客
12-25 305
groupby：1.对单行操作，例：data.groupby("someone_column1").size() 　　　　 2.对两行操作，例：data.groupby("someone_column1")."someone_column2".sum() 　　　　 返回series pivot_table(): 对三列，返回dataframe 转载于:https://www.cnblog...
Pandas 数据操作实践总结
liangbilin的博客
09-08 1454
Pandas 数据的选择 相比于Numpy的矩阵，Pandas的数据对象多了自定义的索引。因此，在对Pandas数据选择时，更推荐使用loc和iloc两种方法。 import numpy as np import pandas as pd 首先，读取一个用于测试的数据。 test = pd.read_excel("../table.xlsx", sheet_name="Sheet2", index_col=0) test sample1 sam
python学习日记（一）pandas的一些使用心得
vanartist1的博客
03-27 1089
python学习日记（一）pandas的一些使用心得 python pandas库提供了强大的读写功能，给工作带来了方便，无论是读取excel，csv，sql文件，几乎样样全能。 记录几个常用的方法。 1.读取excel或csv进行操作处理 import pandas as pd def File(file_path): # file_path是文件路径，encoding可以指定文件的编码格式...
Pandas初入门心得
shijiaoshan4828的博客
07-28 800
前两天刚刚开始学习使用python，记录一下学习使用的第一个Pandas包。 安装Anaconda的同时，pandas已经自动安装好了，只需要import即可。如果不是使用Anaconda，可以通过pip安装。 首先它处理文件数据的功能比我想象的强大很多，一开始很多函数不了解，但大部分自己希望实现的功能都能够通过合理的使用函数来实现，这篇文章主要说一下遇到的问题和使用心得。 最基本的入门官方...
Pandas1.5.2 学习心得
keny-大成的博客
12-17 1056
pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
pandas 数据分析总结
ml_1019的博客
04-02 639
part1:基础操作 dataframe 初始化（空/非空） dataframe 列名操作 数据拼接（行/列拼接，暴力拼接） # 1.dataframe 初始化 ## 空dataframe df_data = pd.DataFrame() df_data = pd.DataFrame(data_list,columns=columns_list) # 2.dataframe 列名操作 ##...
Pandas库实操心得
小冯要编程的博客
07-12 1602
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
机器学习实战：利用pandas处理CSV数据
总结：pandas作为一个强大的数据处理工具，在机器学习领域扮演着至关重要的角色。从数据预处理到特征工程，再到模型训练前的数据准备，pandas提供了丰富的方法来处理数据集。与机器学习的结合，使得数据分析变得更加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈大愚

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值