总结pandas

最新推荐文章于 2025-01-15 01:00:00 发布
原创 最新推荐文章于 2025-01-15 01:00:00 发布 · 185 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍Pandas库在数据处理中的应用，包括数据查看、选择、空值处理及统计操作。涵盖数据切片、筛选、填充及转换技巧，适合数据分析初学者及进阶者。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

总结pandas

一、查看数据

  1. 查看frame中头部和尾部的行：
    具体可以查看 pandas 0.25.0 documentation
    data1 = data.head(6)  # 取前六行数据
data2 = data.tail(6)  # 取后六行数据
print(data1)
print('----'*50)
print(data2)

	   Rank       City            State Population Date of census/estimate
0     1  London[2]   United Kingdom  8,615,246                1-Jun-14
1     2     Berlin          Germany  3,437,916               31-May-14
2     3     Madrid            Spain  3,165,235                1-Jan-14
3     4       Rome            Italy  2,872,086               30-Sep-14
4     5      Paris           France  2,273,305                1-Jan-13
5     6  Bucharest          Romania  1,883,425               20-Oct-11

---------------------------------------------------------------------------

     Rank        City            State Population Date of census/estimate
99    100  Valladolid            Spain    311,501                1-Jan-12
100   101        Bonn          Germany    309,869               31-Dec-12
101   102       Malm枚           Sweden    309,105               31-Mar-13
102   103  Nottingham   United Kingdom    308,735               30-Jun-12
103   104    Katowice           Poland    308,269               30-Jun-12
104   105      Kaunas        Lithuania    306,888                1-Jan-13
  2. 显示索引、列和底层的numpy数据：
    print(data.index)
print('--'*40)
print(data.columns)
print('--'*40)
print(data.values)

RangeIndex(start=0, stop=105, step=1)
--------------------------------------------------------------------------------
Index(['Rank', 'City', 'State', 'Population', 'Date of census/estimate'], dtype='object')
--------------------------------------------------------------------------------
[[1 'London[2]' ' United Kingdom' '8,615,246' '1-Jun-14']
 [2 'Berlin' ' Germany' '3,437,916' '31-May-14']
 [3 'Madrid' ' Spain' '3,165,235' '1-Jan-14']
 [4 'Rome' ' Italy' '2,872,086' '30-Sep-14']
 [5 'Paris' ' France' '2,273,305' '1-Jan-13']
...
 [101 'Bonn' ' Germany' '309,869' '31-Dec-12']
 [102 'Malm枚' ' Sweden' '309,105' '31-Mar-13']
 [103 'Nottingham' ' United Kingdom' '308,735' '30-Jun-12']
 [104 'Katowice' ' Poland' '308,269' '30-Jun-12']
 [105 'Kaunas' ' Lithuania' '306,888' '1-Jan-13']]
  3. describe()函数对于数据的快速统计汇总:
    print(data.describe())

             Rank
count  105.000000
mean    53.057143
std     30.428298
min      1.000000
25%     27.000000
50%     53.000000
75%     79.000000
max    105.000000
  4. 对数据的转置(行列位置互换)：
    print(data)
print('--'*40)
print(data.T)

     Rank        City            State Population Date of census/estimate
0       1   London[2]   United Kingdom  8,615,246                1-Jun-14
1       2      Berlin          Germany  3,437,916               31-May-14
2       3      Madrid            Spain  3,165,235                1-Jan-14
3       4        Rome            Italy  2,872,086               30-Sep-14
4       5       Paris           France  2,273,305                1-Jan-13
..    ...         ...              ...        ...                     ...
100   101        Bonn          Germany    309,869               31-Dec-12
101   102       Malm枚           Sweden    309,105               31-Mar-13
102   103  Nottingham   United Kingdom    308,735               30-Jun-12
103   104    Katowice           Poland    308,269               30-Jun-12
104   105      Kaunas        Lithuania    306,888                1-Jan-13

[105 rows x 5 columns]
--------------------------------------------------------------------------------
                                     0          1    ...        103         104
Rank                                   1          2  ...        104         105
City                           London[2]     Berlin  ...   Katowice      Kaunas
State                     United Kingdom    Germany  ...     Poland   Lithuania
Population                     8,615,246  3,437,916  ...    308,269     306,888
Date of census/estimate         1-Jun-14  31-May-14  ...  30-Jun-12    1-Jan-13

[5 rows x 105 columns]
  5. 按轴进行排序：
    print(data.sort_index(axis=0, ascending=False))  # 当 axis=1 按照纵轴排序, ascending：升序

     Rank        City            State Population Date of census/estimate
104   105      Kaunas        Lithuania    306,888                1-Jan-13
103   104    Katowice           Poland    308,269               30-Jun-12
102   103  Nottingham   United Kingdom    308,735               30-Jun-12
101   102       Malm枚           Sweden    309,105               31-Mar-13
100   101        Bonn          Germany    309,869               31-Dec-12
..    ...         ...              ...        ...                     ...
4       5       Paris           France  2,273,305                1-Jan-13
3       4        Rome            Italy  2,872,086               30-Sep-14
2       3      Madrid            Spain  3,165,235                1-Jan-14
1       2      Berlin          Germany  3,437,916               31-May-14
0       1   London[2]   United Kingdom  8,615,246                1-Jun-14
  6. 按值进行排序：
    print(data.sort_values(['City']))

    Rank       City         State Population Date of census/estimate
91    92     Aarhus       Denmark    326,676                1-Oct-14
85    86   Alicante         Spain    334,678                1-Jan-12
22    23  Amsterdam   Netherlands    813,562               31-May-14
58    59    Antwerp       Belgium    510,610                1-Jan-14
33    34     Athens        Greece    664,046               24-May-11
..   ...        ...           ...        ...                     ...
34    35    Wroc艂aw        Poland    632,432               31-Mar-14
82    83  Wuppertal       Germany    342,885               31-Dec-12
23    24     Zagreb       Croatia    790,017               31-Mar-11
32    33   Zaragoza         Spain    666,058                1-Jan-14
27    28       艁贸d藕        Poland    709,757               31-Mar-14

二、选择

  • 获取
  1. 选择一个单独的列，这将返回一个Series, 等同于data.State
    print(data['State'])

0       United Kingdom
1              Germany
2                Spain
3                Italy
4               France
            ...       
100            Germany
101             Sweden
102     United Kingdom
103             Poland
104          Lithuania
Name: State, Length: 105, dtype: object
  2. 通过[]进行选择，这将会进行切片
    print(data[:5])

	   Rank       City            State Population Date of census/estimate
0     1  London[2]   United Kingdom  8,615,246                1-Jun-14
1     2     Berlin          Germany  3,437,916               31-May-14
2     3     Madrid            Spain  3,165,235                1-Jan-14
3     4       Rome            Italy  2,872,086               30-Sep-14
4     5      Paris           France  2,273,305                1-Jan-13
  • 通过标签选择
  1. 使用标签来获取一个交叉的区域
    print(data.loc[data.index[0]])

Rank                                     1
City                             London[2]
State                       United Kingdom
Population                       8,615,246
Date of census/estimate           1-Jun-14
Name: 0, dtype: object
  2. 通过标签在多个轴上进行选择
    print(data.loc[:, ['State', 'Population']])

               State Population
0     United Kingdom  8,615,246
1            Germany  3,437,916
2              Spain  3,165,235
3              Italy  2,872,086
4             France  2,273,305
..               ...        ...
100          Germany    309,869
101           Sweden    309,105
102   United Kingdom    308,735
103           Poland    308,269
104        Lithuania    306,888

[105 rows x 2 columns]
  3. 标签切片
    print(data.loc[1: 4, ['State', 'Population']])
print(data.loc[1: 4, 'Rank':'Population'])
print(data.loc[[1, 3], 'City':'Population'])
# loc方法里，可以用切片的方法也可以用标签单独取值，这里说的切片和你想的不一样
# 其实二维数组就是张表了，有字段，有值就是一个表结构，由横纵两个轴构建。横：axis=0, 纵：axis=1
# 横纵轴用于定位元素的（因为在科学统计时我们往往需要批量的操作数据），批量操作数据就需要在宏观上
# 定义数据，定义的方式是把它们都放在列表里，通过下标来取值，而它们每个字段又是横纵方向的键，那值
# 当然是跟在屁股后面的整段数据。这或许就是二维数组的本质：将表格的每行每列按照 '键'='值' 它就是
# Series， Series交织起来的结构叫 DataFrame
# 属于个人理解(不喜勿喷)
    这张表的结构就是：DataFrame
    typeindexSeriesSeriesSeries
    --RankStatePopulation
    Series01AA
    Series12BB
  4. 对于返回的对象进行维度缩减
    print(data.loc[1, ['State', 'Population']])  # 说的挺高级，就是定位数据，返回<class 'pandas.core.series.Series'>

State           Germany
Population    3,437,916
Name: 1, dtype: object
  5. 获取一个标量
    print(data.loc[1, 'Population'])  # 确实像一颗洋葱，如果你愿意一层一层的拨开我的心，你会发现，你会压抑，最深处的秘密。

3,437,916
<class 'str'>
  6. 快速访问一个标量(与上一个方法等价)
    print(data.at[1, 'Population'])  # 与5是等价的

3,437,916
<class 'str'>
  • 通过位置选择
  1. 通过传递数值进行位置选择(选择的是行)
    print(data.iloc[1])

Rank                               2
City                          Berlin
State                        Germany
Population                 3,437,916
Date of census/estimate    31-May-14
Name: 1, dtype: object
  2. 通过数值进行切片
    data.iloc[1:3, 0: 4]

   Rank    City     State Population
1     2  Berlin   Germany  3,437,916
2     3  Madrid     Spain  3,165,235
  3. 通过指定一个位置的列表
    data.iloc[[1, 3, 5], [0, 1, 2]]

   Rank       City     State
1     2     Berlin   Germany
3     4       Rome     Italy
5     6  Bucharest   Romania
  4. 对行进行切片
    print(data.iloc[1:3, :])

   Rank    City     State Population Date of census/estimate
1     2  Berlin   Germany  3,437,916               31-May-14
2     3  Madrid     Spain  3,165,235                1-Jan-14
  5. 对列进行切片
    print(data.iloc[:, 0:3])

     Rank        City            State
0       1   London[2]   United Kingdom
1       2      Berlin          Germany
2       3      Madrid            Spain
3       4        Rome            Italy
4       5       Paris           France
..    ...         ...              ...
100   101        Bonn          Germany
101   102       Malm枚           Sweden
102   103  Nottingham   United Kingdom
103   104    Katowice           Poland
104   105      Kaunas        Lithuania

[105 rows x 3 columns]
  6. 获取特定的值
    print(data.iloc[1, 1])
print(data.at[1,1])

Berlin
Berlin
  • 布尔索引
  1. 使用一个单独列的值来选择数据
    data.Population = data.Population.apply(lambda x: int(x.replace(',', '')))  
# 相当于获取到Population下的所有数据然后利用匿名函数 修改 数据结构 然后重新赋值给 
# Population 这个字段
print(data[data.Population > 1000000])

    Rank          City            State  Population Date of census/estimate
0      1     London[2]   United Kingdom     8615246                1-Jun-14
1      2        Berlin          Germany     3437916               31-May-14
2      3        Madrid            Spain     3165235                1-Jan-14
3      4          Rome            Italy     2872086               30-Sep-14
4      5         Paris           France     2273305                1-Jan-13
5      6     Bucharest          Romania     1883425               20-Oct-11
6      7        Vienna          Austria     1794770                1-Jan-15
7      8   Hamburg[10]          Germany     1746342               30-Dec-13
8      9      Budapest          Hungary     1744665                1-Jan-14
9     10        Warsaw           Poland     1729119               31-Mar-14
10    11     Barcelona            Spain     1602386                1-Jan-14
11    12        Munich          Germany     1407836               31-Dec-13
12    13         Milan            Italy     1332516               30-Sep-14
13    14         Sofia         Bulgaria     1291895               14-Dec-14
14    15        Prague   Czech Republic     1246780                1-Jan-13
15    16  Brussels[17]          Belgium     1175831                1-Jan-14
16    17    Birmingham   United Kingdom     1092330               30-Jun-13
17    18       Cologne          Germany     1034175               31-Dec-13
  2. 使用where操作来选择数据：
    print(data[data > 0])
  3. 使用isin()方法来过滤
    a = [x for x in range(len(data.index))]
a = pd.Series(a, index=data.index)  # 这列数据的索引必须和原数据一致
data1 = data.copy()
data1['E'] = a
print(data1[data1['E'].isin(['2', '4'])])

   Rank    City    State  Population Date of census/estimate  E
2     3  Madrid    Spain     3165235                1-Jan-14  2
4     5   Paris   France     2273305                1-Jan-13  4
  • 设置
  1. 设置一个新的列：
    #上篇已经插入了
  2. 通过标签设置新的值：
    data1.at[data.index[0], 'f'] = 1
print(data1)

     Rank        City            State  Population Date of census/estimate    f
0       1   London[2]   United Kingdom     8615246                1-Jun-14    1
1       2      Berlin          Germany     3437916               31-May-14    1
2       3      Madrid            Spain     3165235                1-Jan-14    2
3       4        Rome            Italy     2872086               30-Sep-14    3
4       5       Paris           France     2273305                1-Jan-13    4
..    ...         ...              ...         ...                     ...  ...
100   101        Bonn          Germany      309869               31-Dec-12  100
101   102       Malm枚           Sweden      309105               31-Mar-13  101
102   103  Nottingham   United Kingdom      308735               30-Jun-12  102
103   104    Katowice           Poland      308269               30-Jun-12  103
104   105      Kaunas        Lithuania      306888                1-Jan-13  104

[105 rows x 6 columns]
  3. 通过位置设置新的值：
    data1.iat[1,2] = 0
print(data1)

     Rank        City            State  Population Date of census/estimate    f
0       1   London[2]   United Kingdom     8615246                1-Jun-14    0
1       2      Berlin                0     3437916               31-May-14    1
2       3      Madrid            Spain     3165235                1-Jan-14    2
3       4        Rome            Italy     2872086               30-Sep-14    3
4       5       Paris           France     2273305                1-Jan-13    4
..    ...         ...              ...         ...                     ...  ...
100   101        Bonn          Germany      309869               31-Dec-12  100
101   102       Malm枚           Sweden      309105               31-Mar-13  101
102   103  Nottingham   United Kingdom      308735               30-Jun-12  102
103   104    Katowice           Poland      308269               30-Jun-12  103
104   105      Kaunas        Lithuania      306888                1-Jan-13  104

[105 rows x 6 columns]
  4. 通过一个numpy数组设置一组新值
    data1.loc[:, 'D'] = np.array([5] * len(data1))
print(data1)

     Rank        City            State  ...  Date of census/estimate    f  D
0       1   London[2]   United Kingdom  ...                 1-Jun-14    0  5
1       2      Berlin          Germany  ...                31-May-14    1  5
2       3      Madrid            Spain  ...                 1-Jan-14    2  5
3       4        Rome            Italy  ...                30-Sep-14    3  5
4       5       Paris           France  ...                 1-Jan-13    4  5
..    ...         ...              ...  ...                      ...  ... ..
100   101        Bonn          Germany  ...                31-Dec-12  100  5
101   102       Malm枚           Sweden  ...                31-Mar-13  101  5
102   103  Nottingham   United Kingdom  ...                30-Jun-12  102  5
103   104    Katowice           Poland  ...                30-Jun-12  103  5
104   105      Kaunas        Lithuania  ...                 1-Jan-13  104  5

[105 rows x 7 columns]
  5. 通过where操作来设置新的值：
    data2.f[data2.f > 0] = -data2.f
print(data2)

     Rank        City            State  Population Date of census/estimate    f
0       1   London[2]   United Kingdom     8615246                1-Jun-14    0
1       2      Berlin          Germany     3437916               31-May-14   -1
2       3      Madrid            Spain     3165235                1-Jan-14   -2
3       4        Rome            Italy     2872086               30-Sep-14   -3
4       5       Paris           France     2273305                1-Jan-13   -4
..    ...         ...              ...         ...                     ...  ...
100   101        Bonn          Germany      309869               31-Dec-12 -100
101   102       Malm枚           Sweden      309105               31-Mar-13 -101
102   103  Nottingham   United Kingdom      308735               30-Jun-12 -102
103   104    Katowice           Poland      308269               30-Jun-12 -103
104   105      Kaunas        Lithuania      306888                1-Jan-13 -104

[105 rows x 6 columns]

三、空值处理

在pandas中，使用np.nan来替代空值，这些值将默认不包含在计算中。

  1. index()方法可以对指定轴上的索引进行改变/增加/删除操作，返回原始数据的拷贝。
    data3 = data2.reindex(index=data2.index, columns=list(data2.columns) + ['E'])
data3.loc[0:2, 'E'] = 1
print(data3)

     Rank        City            State  ...  Date of census/estimate    f    E
	0       1   London[2]   United Kingdom  ...                 1-Jun-14    0  1.0
	1       2      Berlin          Germany  ...                31-May-14    1  1.0
	2       3      Madrid            Spain  ...                 1-Jan-14    2  1.0
	3       4        Rome            Italy  ...                30-Sep-14    3  NaN
	4       5       Paris           France  ...                 1-Jan-13    4  NaN
	..    ...         ...              ...  ...                      ...  ...  ...
	100   101        Bonn          Germany  ...                31-Dec-12  100  NaN
	101   102       Malm枚           Sweden  ...                31-Mar-13  101  NaN
	102   103  Nottingham   United Kingdom  ...                30-Jun-12  102  NaN
	103   104    Katowice           Poland  ...                30-Jun-12  103  NaN
	104   105      Kaunas        Lithuania  ...                 1-Jan-13  104  NaN
	
	[105 rows x 7 columns]
	```
  2. 去掉包含缺失值的行：
    data4 = data3.dropna()
print(data4)

   Rank       City            State  Population Date of census/estimate  f    E
0     1  London[2]   United Kingdom     8615246                1-Jun-14  0  0.0
1     2     Berlin          Germany     3437916               31-May-14  1  1.0
2     3     Madrid            Spain     3165235                1-Jan-14  2  2.0
  3. 对缺失值进行填充：
    data2.loc[0, 'f'] = None
data3 = data2.fillna(value=5)
data3.f = data3.f.apply(lambda x: int(x))
print(data3)

	Rank        City            State  Population Date of census/estimate    f
0       1   London[2]   United Kingdom     8615246                1-Jun-14    5
1       2      Berlin          Germany     3437916               31-May-14    1
2       3      Madrid            Spain     3165235                1-Jan-14    2
3       4        Rome            Italy     2872086               30-Sep-14    3
4       5       Paris           France     2273305                1-Jan-13    4
..    ...         ...              ...         ...                     ...  ...
100   101        Bonn          Germany      309869               31-Dec-12  100
101   102       Malm枚           Sweden      309105               31-Mar-13  101
102   103  Nottingham   United Kingdom      308735               30-Jun-12  102
103   104    Katowice           Poland      308269               30-Jun-12  103
104   105      Kaunas        Lithuania      306888                1-Jan-13  104

[105 rows x 6 columns]
  4. 对数据进行布尔填充：
    data2.loc[0, 'f'] = None
data3 = pd.isnull(data2)
print(data3)

      Rank   City  State  Population  Date of census/estimate      f
0    False  False  False       False                    False   True
1    False  False  False       False                    False  False
2    False  False  False       False                    False  False
3    False  False  False       False                    False  False
4    False  False  False       False                    False  False
..     ...    ...    ...         ...                      ...    ...
100  False  False  False       False                    False  False
101  False  False  False       False                    False  False
102  False  False  False       False                    False  False
103  False  False  False       False                    False  False
104  False  False  False       False                    False  False

[105 rows x 6 columns]

四、相关操作

  • 统计（相关操作需要数据不包含空值）
  1. 执行描述性统计
    print(round(data2.mean(), 2))

Rank              53.06
Population    787679.09
f                 52.50
dtype: float64
  2. 在其他轴上进行相同的操作
    print(round(data2.mean(1), 2))  # 就是按照纵轴来取平均值，很少用

0      4307623.50
1      1145973.00
2      1055080.00
3       957364.33
4       757771.33
          ...    
100     103356.67
101     103102.67
102     102980.00
103     102825.33
104     102365.67
Length: 105, dtype: float64
  3. 对于拥有不同维度，需要对齐的对象进行操作。Pandas会自动的沿着指定的维度进行广播
  • Apply
  1. 对数据应用函数
    data.Population = data.Population.apply(lambda x: int(x.replace(',', '')))
  • 直方图
    具体请参照：Histogramming and Discretization
    s = pd.Series(np.random.randint(0, 7, size=10))
s.value_counts()

0    0
1    2
2    1
3    2
4    1
5    1
6    3
7    4
8    1
9    5
dtype: int32

1    4
2    2
5    1
4    1
3    1
0    1
dtype: int64
  • 字符串方法
    Series对象在其str属性中配备了一组字符串处理方法，可以很容易的应用到数组中的每个元素，如下段代码所示。更详细参考：Working with text data¶
    s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s.str.lower()

0       a
1       b
2       c
3    aaba
4    baca
5     NaN
6    caba
7     dog
8     cat
dtype: object
1001系列之案例0003如何对欧洲人口普查数据集整理挖掘
Data_lukyo的博客
05-26 619
一、欧洲人口普查数据分析 本案例重点在于对数据质量的清洗、转换，、可视化。 import os #导入需要的库 import numpy as np import pandas as pd import matplotlib.pyplot as plt import warnings warnings.filterwarnings("ignore") os.chdir(r"D:\Datalu\File") #指定工作目录 %matplotlib inline
Pandas库函数总结
zkx990121的博客
12-05 5157
Pandas库函数总结
Pandas学习总结
qq_45190143的博客
08-08 3556
pandas学习总结
pandas总结
wcc8848的博客
12-10 373
目前常分为Series和DataFrame两部分，且，Series是DataFrame的基础 首先了解其创建与使用 Series: Series能够保存任何类型的数据（整数，字符串，浮点数， # python对象）的一维标记数组，标签统称为索引 创建过程： import pandas as pd obj = pd.Series([4,7,-5,3]) obj 0 4 1 7 2 -5 3 3 dtype: int64 还可以自定义索引： obj2 = pd.Se
pandas用法总结
qq_41038797的博客
09-10 2441
ps：给定的 data2 是一个 Python 列表，其中的每个元素也是一个列表。每个内部列表代表一行，而每行的元素代表列的值。在这种情况下，data 可以被看作是一个4×2 的矩阵，有4行和2列。PS:print(s[[‘zs’,‘ls’,‘sl’]])与print(s[[0,1,3]])为什么有两个中括号，每一个括号代表的意义是什么。DataFrame是一个类似于表格（有行有列）的数据类型，可以理解为一个二维数组，索引有两个维度（行级索引，内层的中括号是用来创建一个整数位置或者标签列表的。
总结pandas 功能
weixin_35755823的博客
01-04 2222
pandas 是一个 Python 数据分析库，它提供了许多方便的函数和方法帮助我们处理数据。 pandas 的主要功能包括： 处理大量数据：pandas 的数据结构可以快速地处理大量数据。 数据清洗和准备：pandas 提供了很多函数帮助我们清洗数据，如缺失值的填补和处理。 数据转换：pandas 可以将数据转换为不同的格式，如从 CSV 文件中读取数据，并将数据写入到 Excel 文件中...
一文总结pandas基础及常用方法、函数
学习，是熵减的最有效途径。
07-25 1020
pandas 是基于NumPy 的一种工具，该工具是为解决数据分析任务而创建的，一文总结pandas基础及常用方法、函数
pandas 用法总结
Dear_learner的博客
06-04 2563
pandas 是基于numpy构建的，让以numpy为中心的应用变得更加简单。 一、pandas的两种数据结构 1、Series Series是一种类似于一维数组的对象，它是由一组数据（各种Numpy数据类型）以及与之相关的数据标签（即索引组成）。仅由一组数据即可产生最简单的Series。 Series的字符串表现形式为：索引在左边，值在右边。由于没有设定索引，会自动创建由0到N-1的整数型索引。可以通过Series的values和index属性来获取数组的表示形式和索引对象。 对Series的各个数据点设
Pandas 学习总结（一）
qq_64286820的博客
04-18 1359
Pandas 是一个流行的 Python 库，用于数据分析和数据操作。它提供了数据结构和函数，使得在 Python 中进行数据操作更加简单和高效。Pandas 最主要的数据结构是 Series 和 DataFrame。Series 是一维标记数组，可以包含任何数据类型。每个 Series 都有一个与之关联的索引，可以用于访问数据项。DataFrame 是一个二维的、大小可变的数据结构，类似于电子表格或 SQL 数据表。它由行和列组成，每列可以包含不同的数据类型。
结合实例总结pandas的部分常用函数
热门推荐
zhuzuwei的博客
12-14 1万+
1. df.head（n）: 显示数据前n行，不指定n，df.head则会显示所有的行 2. df.columns.values获取所有列索引的名称 3. df.column_name: 直接获取列column_name的数据 4. pd.unique(Series)获取Series中元素的唯一值（即去掉重复的） 注意和nunique的区别，nunique只
Pandas重点知识总结
07-08
在本重点知识总结中，我们将详细介绍Pandas库的核心内容。 首先，Pandas的核心数据结构是Series和DataFrame。Series是一维的标签数组，能够保存任意数据类型的数据，而DataFrame则是一个二维的标签数据结构，类似于...
基础Python教程之pandas使用总结.pdf
10-30
在Python的世界里，数据分析是一项核心任务，而Pandas库正是这个领域的王者。Pandas提供了高效的数据处理工具，使得数据清洗、分析和建模变得轻松。本文将深入探讨Pandas库的基础使用，包括其数据结构、读取与存储...
【Pandas】pandas Series round
weixin_39648905的博客
01-15 1186
`pandas.Series.round` 是 Pandas 库中 `Series` 对象的一个方法，用于对 `Series` 中的每个元素进行四舍五入操作。该方法可以指定小数点后的位数，默认情况下会四舍五入到最接近的整数。
溶液PH与EC调理电路设计：电路图、PCB及代码设计详解
最新发布
08-18
溶液PH值和EC值调理电路的设计与优化，涵盖了电路图、PCB布局以及相关代码设计。针对PH调理电路，重点讨论了高阻抗放大器的选择及其温度补偿机制；对于EC调理电路，则强调了交流激励法的应用，避免电极极化现象。此外，还分享了PCB布局的关键注意事项，如模拟部分铺铜接地、运放电源加磁珠隔离等，确保测量精度不受外界因素干扰。文中提供了具体的代码片段用于读取PH值和生成1kHz方波，同时提到了校准技巧和常见问题的解决方案。 适合人群：电子工程技术人员、从事溶液检测设备开发的研究人员和技术爱好者。 使用场景及目标：适用于需要设计和优化溶液PH与EC调理电路的技术人员，帮助他们掌握从电路设计到实际应用的全过程，提高测量精度和稳定性。 其他说明：调试过程中需要注意细节，如接地处理、布线方式等，以确保系统的稳定性和准确性。
rtl-433-23.11-1.20240826gitf0ba153.el8.tar.gz
08-18
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
基于Python+Django的大学生请假管理系统（完整项目源码+mysql+说明文档+LW+PPT）计算机毕业设计源码.zip
08-18
管理员拥有更全面的管理权限，可以进行以下操作： 系统首页：管理员的主界面，可能包含系统概览和快捷操作。 用户管理：管理平台用户，包括添加、删除、修改用户信息等。 个人中心：管理员的个人信息管理。 海洋数据：管理和查看海洋相关的气象数据。 预测信息：管理和查看气象预测信息。 管理员界面：管理员专用的操作界面，可能包含更多的管理功能。 数据界面：管理和查看所有数据的界面。 用户功能模块 用户的功能相对简单，主要集中在数据的查看和个人管理上： 系统首页：用户的主界面，展示推荐信息或快捷操作。 个人中心：用户可以管理个人信息。 海洋数据：用户可以查看海洋相关的气象数据。 预测信息：用户可以查看气象预测信息。 数据界面：用户可以查看数据的界面。 完整前后端源码，部署后可正常运行！ 环境说明 开发语言：python后端 python版本：3.7 数据库：mysql 5.7+ 数据库工具：Navicat11+ 开发软件：pycharm
基于VUE实现的太阳能热水器水位监测+源码（毕业设计&课程设计&项目开发）
08-18
基于VUE实现的太阳能热水器水位监测+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档 基于VUE实现的太阳能热水器水位监测+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档~ 基于VUE实现的太阳能热水器水位监测+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档 基于VUE实现的太阳能热水器水位监测+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档 基于VUE实现的太阳能热水器水位监测+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档 基于VUE实现的太阳能热水器水位监测+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值