Pandas学习总结

已于 2022-08-08 22:12:25 修改
阅读量2.5k 收藏 10
点赞数 1
分类专栏： 机器学习 文章标签： pandas 学习 python
于 2022-08-08 13:08:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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
陈大愚
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Pandas编程作业实验报告
OUC-STU-LCX的博客
06-04 949
通过这个实验，我深入掌握了Pandas库中DataFrame的创建、数据处理技巧、索引操作、连接与合并、以及数据导出等关键功能。我学会了如何处理缺失值、筛选特定条件的数据、重置索引、导出到Excel，并理解了不同类型的数据连接操作。
Pandas案例学习总结
掌握情绪丶品味人生
05-31 692
目录 一必要库的导入 二 创建表格对象 三查看基础数据及类型 四 设置索引、排序函数、添加和删除列 五创建DataFrame以及表的拼接 六 查看统计值(求和,平均值,最大值,最小值,标准差,四分位数等等) 七 唯一值、缺失值和重复值 八特殊函数 一必要库的导入 #导入pandas库 import pandas as pd #导入numpy库 import numpy as np #导入seaborn库里面有很多设计模板可以直接使用 import seaborn ...
Pandas统计分析基础与数据预处理.docx
10-23
数据分析与挖掘实验报告 内含实验过程，源码，截图和实验小结
22 python Pandas 数据处理基础
bj_zhb的博客
04-18 941
文章目录Pandas 数据处理基础数据类型series基本操作数据选择基于索引数字选择基于标签名称的选择数据删减数据填充检测缺失值插值填充数据可视化 Pandas 数据处理基础 介绍 Pandas 是非常著名的开源数据处理库，我们可以通过它完成对数据集进行快速读取、转换、过滤、分析等一系列操作。除此之外，Pandas 拥有强大的缺失数据处理与数据透视功能，可谓是数据预处理中的必备利器。 知识点 ...
Numpy&Pandas学习总结
zhoujie1994的博客
07-10 694
文章目录Numpy基础numpy的array创建numpy属性numpy的基础运算numpy的索引numpy的array合并numpy的array分割numpy的拷贝与深拷贝 Numpy基础 numpy的array创建 import numpy as np a = np.array([1,2,3]) # [1, 2, 3] a = np.array([[1, 2], [3, 4]]) a = np.array([1, 2, 3], dtype = float) numpy属性 a
pandas库学习实验报告
weixin_42418315的博客
09-11 1345
首先是对于思路的分析，明确目标，需要使用的数据，对数据进行预处理，需要使用的到的函数，了解函数对应的参数，其次，在完成实验要求的基础上，保证代码简洁，适当添加注释进行说明，然后对于Python库的学习不能停留在简单的掌握，课下还需进行深入的自主学习，最后一点，就是多练习多敲代码，只有真正的将学到的知识，应用到实际中，完成数据分析，才能真正掌握。如上图，黄牌数的平均值为7，红牌数的平均值为0，进球数超过6的队伍有两支Germany和Spain，进球数分别为10和12。问题：对函数的应用不熟练；
Python数据分析：NumPy、Pandas和Matplotlib的使用和实践
baidu_38876334的博客
05-12 3128
本章将对前面的内容进行总结和回顾，同时展望未来的发展方向。我们将介绍如何深入学习这些库，以及如何使用它们来解决更加复杂的数据分析和可视化问题。本节将对前面的内容进行总结和回顾，包括NumPy、Pandas和Matplotlib的基本用法和实践，以及它们的组合使用来实现数据分析和可视化。
Pandas总结
G-无忧仙-LB——随笔
01-14 712
Pandas总结 一、pandas中的DataFrame函数以及对象 下面介绍 DataFrame 的基本功能：（其中，df 为任意 DataFrame） df.values： 返回 ndarray 类型的对象 df.index： 获取行索引 df.columns： 获取列索引 ...
Pandas学习总结——5. 合并（append与assign、combine与update、concat、merge与join）
12-21
内容概览1 append与...Pandas的合并操作可以概括为以下四类方法： append与assign combine与update concat方法 merge与join 1 append与assign 1.1append方法 append方法主要在行操作 用Series添加行，必须指定name
pandas库学习报告.docx
04-11
数据仓库~有关于pandas库的学习报告 小丸子帮大家总结到位了 希望可以帮助各位 点赞收藏哈！！！
Pandas学习笔记常用功能.pdf
11-16
在本篇Pandas学习笔记中，我们将探讨其常用的功能，包括安装与使用、Python 数据结构以及数据类型的操作。 一、Pandas 的安装和使用 安装Pandas可以通过常见的 Python 包管理器 pip，如 `pip install pandas`。值得...
Pandas学习笔记常用功能.docx
11-16
这篇学习笔记主要涵盖了Pandas的安装、使用，以及核心数据结构Series和DataFrame。 一、Pandas的安装和使用 安装Pandas通常采用pip工具，但在安装前需确保已经安装了NumPy库，因为Pandas依赖于它。如果在安装过程中...
pandas使用工作技能总结
最新发布
06-17
pandas中工作的一些使用总结，本文系统的总结了pandas的使用心得和学习心得，资料内容简单易读
pandas总结
weixin_46681128的博客
09-17 1404
pandas简介 pandas 与 numpy 的主要区别是： 从数据类型上看： numpy 的核心数据结构是 ndarray，支持任意维数的数组，但要求单个数组内所有数据是同质的，即类型必须相同； pandas 的核心数据结构是 series和dataframe，仅支持一维和二维数据，但数据内部可以是异构数据，仅要求同列数据类型一致即可； 1. 从索引上看： numpy 的数据结构仅支持数字索引 pandas 数据结构则同时支持数字索引，标签索引和布尔索引 2. 从功能定位上看： numpy 虽
Python：Pandas总结
qq_43042024的博客
02-27 661
一、生成数据表 1、首先导入pandas库，一般都会用到numpy库，所以我们先导入备用： import numpy as np  import pandas as pd 2、导入CSV或者xlsx文件： df = pd.DataFrame(pd.read_csv(‘name.csv’,header=1))  df = pd.DataFrame(pd.read_excel(‘n...
Pandas库实操心得
小冯要编程的博客
07-12 1490
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
numpy库学习实验报告
weixin_42418315的博客
09-11 2009
运行实验代码后，依次得出结果，包括收盘价的平均价格，成交量加权的平均价格，最高价中的最大值，最高价的最小值，最高价的极值，最低价的极值，收盘价的中位数、方差。loadtxt：数据的获取。构造CSV数据，将数据保存在本地data文件夹中，命名为stock_data.csv，上图可看到数据集的具体内容，其中本文用到的数据为第5-8列，分别对应股票的最高价，最低价，收盘价，成交量。构造数据案例（也可自行设计）：其中，第4-8列，即EXCEL表格中的D-H列，分别为股票的开盘价，最高价，最低价，收盘价，成交量。
python实验报告9 数据可视化操作——pandas
m0_69194031的博客
12-23 3634
（1）掌握数据表示与获取； （2）掌握pandas数值运算操作； （3）根据运算结果，使用Matplotlib绘制图表； （4）通过设计型实验的方式，掌握数据统计分析的方法和技术，理解数值计算和数据可视化在数据分析过程中的意义和作用，提高学生解决复杂数据统计分析问题的能力和素养。
pandas官方文档中文版1
08-04
总而言之，pandas官方文档中文版详细介绍了pandas的各种功能和方法，对于希望学习和掌握pandas的人来说，是一份非常有价值的参考资料。通过阅读官方文档，可以全面地了解pandas的特性和用法，提高数据处理和分析的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

陈大愚

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

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

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

打赏作者

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

抵扣说明：

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

余额充值