Pandas(一)[快速入门]

最新推荐文章于 2024-06-17 17:35:06 发布
最新推荐文章于 2024-06-17 17:35:06 发布
阅读量1k 收藏
点赞数
分类专栏： Pandas 文章标签： python 开发语言 后端 pandas 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cyyxbdmrrc/article/details/121613171
版权

目录

1.Series

import numpy as np
import pandas as pd

# Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
# data: 类似数组、可迭代、字典或标量值。包含存储在系列中的数据。如果数据是字典，则保持参数顺序
# index: 值必须是可散列的并且与数据具有相同的长度。允许非唯一索引值。
#        如果未提供，将默认为 RangeIndex (0, 1, 2, ..., n)。
#        如果没有提供。如果 data 是 dict-like 并且 index 是 None，则数据中的键用作索引。
#        如果索引不是 None，则使用索引值重新索引生成的系列。
# dtype: 输出系列的数据类型。如果没有指定，这将从数据中推断出来。
# name: 给系列起的名字
# copy: 复制输入数据。仅影响系列或一维 ndarray 输入。默认：False
# s = pd.Series([1,3,6,np.nan,44,1])

# 从指定索引的字典构建系列
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d, index=['a', 'b', 'c'])
print(ser)
# 字典的键与索引值匹配，因此索引值不起作用
# ser
# a   1
# b   2
# c   3
# dtype: int64
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
# 请注意，索引首先使用字典中的键构建。
# 在此之后，系列使用给定的索引值重新索引，因此我们得到所有 NaN 作为结果。
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d, index=['x', 'y', 'z'])
print(ser)
# ser
# x   NaN
# y   NaN
# z   NaN
# dtype: float64
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')

# 给定一个一维数组
x = [1, 2]
# 将系列的copy设为False，但是由于数据类型，系列有x数组的副本
ser = pd.Series(x, copy = False)
#修改副本中的索引值为0的value
# iloc: 纯粹基于整数位置的索引，用于按位置选择
ser.iloc[0] = 999
# 从输出可以看出只改变了副本,x本身并未改变
print(x)
print(ser)
# [1, 2]
# 0    999
# 1      2
# dtype: int64
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')

# 如果arr为多维数组将会报错
arr = np.array([1, 2])
ser = pd.Series(arr, copy = False)
# 由于输入数据类型，系列对原始数据有一个视图，因此数据也发生了变化。
ser.iloc[0] = 999
print(arr)
print(ser)
# [999   2]
# 0    999
# 1      2
# dtype: int32
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
arr = np.array([1, 2, 3])
ser = pd.Series(arr)
# T: 返回转置，根据定义，它是 self。
# 只针对一维数组，否则报错
print(ser.T)
# 0    1
# 1    2
# 2    3
# dtype: int32
# array: 支持此系列或索引的数据的 ExtensionArray。
# print(pd.Series([1, 2, 3]).array)
# The ExtensionArray of the data backing this Series or Index.
# at: 访问 rowcolumn 标签对的单个值。
# attrs: 此数据集的全局属性字典。
# axes: 返回行轴标签列表。
# dtype: 返回底层数据的 dtype 对象。
# dtypes: 返回底层数据的 dtype 对象。
# flags: 获取与此 Pandas 对象关联的属性。
# hasnans:如果我有任何nans，请返回；启用各种性能加速。
# iat: 按整数位置访问行列对的单个值。
# iloc: 用于按位置选择的纯整数位置索引
# index: 系列的索引（轴标签）。
# is_monotonic: 如果对象中的值是 monotonic_increasing，则返回布尔值。
# is_monotonic_decreasing: 如果对象中的值是 monotonic_decresing，则返回布尔值。
# is_monotonic_increasing: is_monotonic 的别名。
# is_unique: 如果对象中的值是唯一的，则返回布尔值。
# loc: 通过标签或布尔数组访问一组行和列。
# name: 返回系列的名称。
# nbytes: 返回底层数据中的字节数。
# ndim: 基础数据的维数，根据定义 1。
# shape: 返回基础数据形状的元组。
# size: 返回基础数据中的元素数。
# values: 根据 dtype 将系列作为 ndarray 或 ndarray-like 返回。

print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
# date_range(start=None, end=None, periods=None, freq=None, tz=None,
#                normalize=False, name=None, closed=None, **kwargs)
# periods: 要生成的周期数
dates = pd.date_range('2021-11-28', periods=6)
print(dates)
# DatetimeIndex(['2021-11-28', '2021-11-29', '2021-11-30', '2021-12-01',
#                '2021-12-02', '2021-12-03'],
#               dtype='datetime64[ns]', freq='D')
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
'''
numpy.random.randn(d0, d1, …, dn)是从标准正态分布中返回一个或多个样本值。
numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。
(6,4)表示6行4列数据
'''
arr = np.random.randn(6, 4)
print(arr)
# 二维的、大小可变的、潜在的异构表格数据。
# DataFrame([data, index, columns, dtype, copy])
# data: 传入数据
# index: 行索引（行头）
# columns: 列索引（列头）
# copy: 默认为False

2.DataFrame

print('未指定行标签和列标签的数据')
# 默认0,1,2,3,4......为表头
df1 = pd.DataFrame(np.arange(12).reshape(3,4))
print(df1)
#    0  1   2   3
# 0  0  1   2   3
# 1  4  5   6   7
# 2  8  9  10  11
print('指定行标签和列标签的数据:')
arr = np.random.randn(6, 4)
dates = pd.date_range('2021-11-28', periods=6)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
print("整个DateForm:")
print(df)
# 整个DateForm:
#                    a         b         c         d
# 2021-11-28  0.925212 -0.032742 -0.397622 -0.685095
# 2021-11-29 -1.127364  1.058101  0.871153 -0.541429
# 2021-11-30 -0.459550  2.011948  0.264811  2.138359
# 2021-12-01 -0.434759  0.605623 -0.403327 -0.917852
# 2021-12-02  0.763358 -1.655734 -1.995348 -0.275367
# 2021-12-03 -0.474699  1.052355 -0.807073 -1.188520
print("整个DateForm的‘b’列")
print(df['b'])
# 整个DateForm的‘b’列
# 2021-11-28   -0.032742
# 2021-11-29    1.058101
# 2021-11-30    2.011948
# 2021-12-01    0.605623
# 2021-12-02   -1.655734
# 2021-12-03    1.052355
# Freq: D, Name: b, dtype: float64
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')

# 另一种方式
df2 = pd.DataFrame({
    'A': [1,2,3,4],
    'B': pd.Timestamp('20211128'),
    'C': pd.Series([1,6,9,10],dtype='float32'),
    'D': np.array([3] * 4,dtype='int32'),
    'E': pd.Categorical(['test','train','test','train']),
    'F': 'foo'
})

#    A          B     C  D      E    F
# 0  1 2021-11-28   1.0  3   test  foo
# 1  2 2021-11-28   6.0  3  train  foo
# 2  3 2021-11-28   9.0  3   test  foo
# 3  4 2021-11-28  10.0  3  train  foo
print(df2)
#    A          B     C  D      E    F
# 0  1 2021-11-28   1.0  3   test  foo
# 1  2 2021-11-28   6.0  3  train  foo
# 2  3 2021-11-28   9.0  3   test  foo
# 3  4 2021-11-28  10.0  3  train  foo
print(df2.index)
# RangeIndex(start=0, stop=4, step=1)
print(df2.columns)
# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
print(df2.values)
# [[1 Timestamp('2021-11-28 00:00:00') 1.0 3 'test' 'foo']
#  [2 Timestamp('2021-11-28 00:00:00') 6.0 3 'train' 'foo']
#  [3 Timestamp('2021-11-28 00:00:00') 9.0 3 'test' 'foo']
#  [4 Timestamp('2021-11-28 00:00:00') 10.0 3 'train' 'foo']]
print(df2.describe())
#               A          C    D
# count  4.000000   4.000000  4.0
# mean   2.500000   6.500000  3.0
# std    1.290994   4.041452  0.0
# min    1.000000   1.000000  3.0
# 25%    1.750000   4.750000  3.0
# 50%    2.500000   7.500000  3.0
# 75%    3.250000   9.250000  3.0
# max    4.000000  10.000000  3.0

print(df2.T)
#                      0         ...                             3
# A                    1         ...                             4
# B  2021-11-28 00:00:00         ...           2021-11-28 00:00:00
# C                    1         ...                            10
# D                    3         ...                             3
# E                 test         ...                         train
# F                  foo         ...                           foo
#
# [6 rows x 4 columns]

# 按行升序排列
apd = df2.sort_index(axis=1, ascending=True)
print(apd)
#    A          B     C  D      E    F
# 0  1 2021-11-28   1.0  3   test  foo
# 1  2 2021-11-28   6.0  3  train  foo
# 2  3 2021-11-28   9.0  3   test  foo
# 3  4 2021-11-28  10.0  3  train  foo
# 按行降序排列
apd_1 = df2.sort_index(axis=1, ascending=False)
print(apd_1)
#      F      E  D     C          B  A
# 0  foo   test  3   1.0 2021-11-28  1
# 1  foo  train  3   6.0 2021-11-28  2
# 2  foo   test  3   9.0 2021-11-28  3
# 3  foo  train  3  10.0 2021-11-28  4

# 对对应列的值进行升降序排列
print(df2.sort_values(by='C', ascending=False))
#    A          B     C  D      E    F
# 3  4 2021-11-28  10.0  3  train  foo
# 2  3 2021-11-28   9.0  3   test  foo
# 1  2 2021-11-28   6.0  3  train  foo
# 0  1 2021-11-28   1.0  3   test  foo

print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')

3.pandas 选择数据

import pandas as pd
import numpy as np

dates = pd.date_range('20211129', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6, 4)), index = dates, columns=['A', 'B', 'C', 'D'])
print(df)
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
# 获取列数据的两种方法
print(df.A)
print(df['A'])
# 2021-11-29     0
# 2021-11-30     4
# 2021-12-01     8
# 2021-12-02    12
# 2021-12-03    16
# 2021-12-04    20
# Freq: D, Name: A, dtype: int32

# 选择跨越多行或多列
# 选取前3行
print(df[0:3])

print(df['2021-11-29' : '2021-12-01'])
#             A  B   C   D
# 2021-11-29  0  1   2   3
# 2021-11-30  4  5   6   7
# 2021-12-01  8  9  10  11

# 根据标签选择数据
# 获取特定行或列
# 指定行数据
print(df.loc['2021-12-02'])
# A    12
# B    13
# C    14
# D    15
# Name: 2021-12-02 00:00:00, dtype: int32

# 指定列
# 两种方式
# A->C之间的列，包头尾
print(df.loc[:, 'A' : 'C'])
#              A   B   C
# 2021-11-29   0   1   2
# 2021-11-30   4   5   6
# 2021-12-01   8   9  10
# 2021-12-02  12  13  14
# 2021-12-03  16  17  18
# 2021-12-04  20  21  22

# A,C两列
print(df.loc[:, ['A', 'C']])
#              A   C
# 2021-11-29   0   2
# 2021-11-30   4   6
# 2021-12-01   8  10
# 2021-12-02  12  14
# 2021-12-03  16  18
# 2021-12-04  20  22

# 行列同时检索
# '20211202'行的'A'和'B'列
print(df.loc['20211202', ['A', 'B']])
# A    12
# B    13
# Name: 2021-12-02 00:00:00, dtype: int32

# 根据序列iloc
# 获取特定位置的值
print(df.iloc[3:5, 1:3])
#              B   C
# 2021-12-02  13  14
# 2021-12-03  17  18

# 跨行操作
# 1, 3, 5行
# 1, 2列
print(df.iloc[[1, 3, 5], 1:3])
#              B   C
# 2021-11-30   5   6
# 2021-12-02  13  14
# 2021-12-04  21  22

# 混合选择
# 两个数组相同的结果，ix已禁用
# print(df.ix[:3, ['A', 'C']])
print(df.iloc[:3, [0, 2]])

#             A   C
# 2021-11-29  0   2
# 2021-11-30  4   6
# 2021-12-01  8  10

# 通过判断的筛选
# 筛选掉A列小
print(df.loc[df.A > 8])
#              A   B   C   D
# 2021-12-02  12  13  14  15
# 2021-12-03  16  17  18  19
# 2021-12-04  20  21  22  23


print(df.loc['20211202','A':'B'])
# A    12
# B    13
# Name: 2021-12-02 00:00:00, dtype: int32
print(df.iloc[0,0:2])
# A    0
# B    1
# Name: 2021-11-29 00:00:00, dtype: int32

4.Pandas 设置值

print('~~~~~~~~~~~~~创建数据~~~~~~~~~~~~~~')
dates = pd.date_range('20180820',periods=6)
pdf = pd.DataFrame(np.arange(24).reshape(6,4), index=dates, columns=['A','B','C','D'])
print(pdf)
# ~~~~~~~~~~~~~创建数据~~~~~~~~~~~~~~
#              A   B   C   D
# 2018-08-20   0   1   2   3
# 2018-08-21   4   5   6   7
# 2018-08-22   8   9  10  11
# 2018-08-23  12  13  14  15
# 2018-08-24  16  17  18  19
# 2018-08-25  20  21  22  23
print('~~~~~~~~~~~~~iloc通过坐标值修改数据~~~~~~~~~~~~~~')
pdf.iloc[2,2] = 1111
print(pdf)
# iloc不能用index索引来修改，会报错
# pdf.iloc['20180823', 'B'] = 2222
#              A   B     C   D
# 2018-08-20   0   1     2   3
# 2018-08-21   4   5     6   7
# 2018-08-22   8   9  1111  11
# 2018-08-23  12  13    14  15
# 2018-08-24  16  17    18  19
# 2018-08-25  20  21    22  23
print('~~~~~~~~~~~~~loc通过index修改数据~~~~~~~~~~~~~~')
pdf.loc['20180824', 'B'] = 3333
print(pdf)
# ~~~~~~~~~~~~~iloc通过坐标值修改数据~~~~~~~~~~~~~~
#              A     B     C   D
# 2018-08-20   0     1     2   3
# 2018-08-21   4     5     6   7
# 2018-08-22   8     9  1111  11
# 2018-08-23  12    13    14  15
# 2018-08-24  16  3333    18  19
# 2018-08-25  20    21    22  23
print('~~~~~~~~~~~~~按列修改数据~~~~~~~~~~~~~~')
print('①方法')
pdf.B.loc[pdf.A > 4] = 0
print(pdf)
# ①方法
#              A  B     C   D
# 2018-08-20   0  1     2   3
# 2018-08-21   4  5     6   7
# 2018-08-22   8  0  1111  11
# 2018-08-23  12  0    14  15
# 2018-08-24  16  0    18  19
# 2018-08-25  20  0    22  23
print('②方法')
pdf.B[pdf.A > 4] = 1
print(pdf)
# ②方法
#              A  B     C   D
# 2018-08-20   0  1     2   3
# 2018-08-21   4  5     6   7
# 2018-08-22   8  1  1111  11
# 2018-08-23  12  1    14  15
# 2018-08-24  16  1    18  19
# 2018-08-25  20  1    22  23

print('~~~~~~~~~~~~~添加列~~~~~~~~~~~~~~')
# 通过Series添加列时必须在长度上对齐
pdf['E'] = pd.Series([1, 2, 3, 4, 5, 6], index = dates)
print(pdf)
#              A  B     C   D   F  E
# 2018-08-20   0  1     2   3 NaN  1
# 2018-08-21   4  5     6   7 NaN  2
# 2018-08-22   8  1  1111  11 NaN  3
# 2018-08-23  12  1    14  15 NaN  4
# 2018-08-24  16  1    18  19 NaN  5
# 2018-08-25  20  1    22  23 NaN  6

pdf['F'] = np.nan
print(pdf)
# ③方法
#              A  B     C   D   F
# 2018-08-20   0  1     2   3 NaN
# 2018-08-21   4  5     6   7 NaN
# 2018-08-22   8  1  1111  11 NaN
# 2018-08-23  12  1    14  15 NaN
# 2018-08-24  16  1    18  19 NaN
# 2018-08-25  20  1    22  23 NaN

print('~~~~~~~~~~~~~修改特定位置的值~~~~~~~~~~~~~~')
# 通过loc设定某行某列为特定值
pdf.loc['20180820', 'A'] = 56
print(pdf)
#              A  B     C   D  E   F
# 2018-08-20  56  1     2   3  1 NaN
# 2018-08-21   4  5     6   7  2 NaN
# 2018-08-22   8  1  1111  11  3 NaN
# 2018-08-23  12  1    14  15  4 NaN
# 2018-08-24  16  1    18  19  5 NaN
# 2018-08-25  20  1    22  23  6 NaN

# 通过iloc设定行列的特定值
pdf.iloc[1,1] = 76
print(pdf)
#              A   B     C   D  E   F
# 2018-08-20  56   1     2   3  1 NaN
# 2018-08-21   4  76     6   7  2 NaN
# 2018-08-22   8   1  1111  11  3 NaN
# 2018-08-23  12   1    14  15  4 NaN
# 2018-08-24  16   1    18  19  5 NaN
# 2018-08-25  20   1    22  23  6 NaN

print('~~~~~~~~~~~~~修改特定行的值~~~~~~~~~~~~~~')
# 通过loc调用行头来修改行值
pdf.loc['20180820'] = np.nan
print(pdf)
#                A     B       C     D    E   F
# 2018-08-20   NaN   NaN     NaN   NaN  NaN NaN
# 2018-08-21   4.0  76.0     6.0   7.0  2.0 NaN
# 2018-08-22   8.0   1.0  1111.0  11.0  3.0 NaN
# 2018-08-23  12.0   1.0    14.0  15.0  4.0 NaN
# 2018-08-24  16.0   1.0    18.0  19.0  5.0 NaN
# 2018-08-25  20.0   1.0    22.0  23.0  6.0 NaN

# 通过iloc调用位置数组修改行
# pdf.iloc[1, :] = np.nan
pdf.iloc[1] = np.nan
print(pdf)
#                A    B       C     D    E   F
# 2018-08-20  56.0  1.0     2.0   3.0  1.0 NaN
# 2018-08-21   NaN  NaN     NaN   NaN  NaN NaN
# 2018-08-22   8.0  1.0  1111.0  11.0  3.0 NaN
# 2018-08-23  12.0  1.0    14.0  15.0  4.0 NaN
# 2018-08-24  16.0  1.0    18.0  19.0  5.0 NaN
# 2018-08-25  20.0  1.0    22.0  23.0  6.0 NaN

5.Pandas 处理丢失数据

dates = pd.date_range('20211201', periods=6)
pdf = pd.DataFrame(np.arange(24).reshape((6, 4)), index=dates, columns=['A', 'B', 'C', 'D'])
print('创建矩阵：')
print(pdf)
# 创建矩阵：
#              A   B   C   D
# 2021-12-01   0   1   2   3
# 2021-12-02   4   5   6   7
# 2021-12-03   8   9  10  11
# 2021-12-04  12  13  14  15
# 2021-12-05  16  17  18  19
# 2021-12-06  20  21  22  23

pdf.iloc[0, 1] = np.nan
pdf.iloc[1, 2] = np.nan
print('将ilco位置的数值改为nan：')
print(pdf)
# 将ilco位置的数值改为nan：
#              A     B     C   D
# 2021-12-01   0   NaN   2.0   3
# 2021-12-02   4   5.0   NaN   7
# 2021-12-03   8   9.0  10.0  11
# 2021-12-04  12  13.0  14.0  15
# 2021-12-05  16  17.0  18.0  19
# 2021-12-06  20  21.0  22.0  23

print('删除所有NaN的行/列(默认为行)')
# print(pdf.dropna())
# pdf.dropna() == pdf.dropna(axis = 1, how = 'any' )
print(pdf.dropna(
    axis = 1, # 0对行进行操作；1对列进行操作
    how = 'any' # 'any':只要存在NaN就drop；'all':必须全部是NaN才drop
))
# axis=0
#              A     B     C   D
# 2021-12-03   8   9.0  10.0  11
# 2021-12-04  12  13.0  14.0  15
# 2021-12-05  16  17.0  18.0  19
# 2021-12-06  20  21.0  22.0  23
# axis=1
#              A   D
# 2021-12-01   0   3
# 2021-12-02   4   7
# 2021-12-03   8  11
# 2021-12-04  12  15
# 2021-12-05  16  19
# 2021-12-06  20  23

# 替换NaN值为0或者其他
print('将NaN位置替换为0：')
print(pdf.fillna(value=0))
#              A     B     C   D
# 2021-12-01   0   0.0   2.0   3
# 2021-12-02   4   5.0   0.0   7
# 2021-12-03   8   9.0  10.0  11
# 2021-12-04  12  13.0  14.0  15
# 2021-12-05  16  17.0  18.0  19
# 2021-12-06  20  21.0  22.0  23

# 是否有缺失数据NaN
# 是否为空
print('NaN为True：')
print(pdf.isnull())
#                 A      B      C      D
# 2021-12-01  False   True  False  False
# 2021-12-02  False  False   True  False
# 2021-12-03  False  False  False  False
# 2021-12-04  False  False  False  False
# 2021-12-05  False  False  False  False
# 2021-12-06  False  False  False  False

# 是否为NaN
print('NaN为True：')
print(pdf.isna())
# NaN为True：
#                 A      B      C      D
# 2021-12-01  False   True  False  False
# 2021-12-02  False  False   True  False
# 2021-12-03  False  False  False  False
# 2021-12-04  False  False  False  False
# 2021-12-05  False  False  False  False
# 2021-12-06  False  False  False  False

# 检查某列是否有缺失数据NaN
print('检测列上是否有NaN：')
print(pdf.isna().any())
# 检测列上是否有NaN：
# A    False
# B     True
# C     True
# D    False
Cyyxbdmrrc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
pandas用法大全
liufang0001的博客
09-05 22万+
一、生成数据表 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
pandas快速入门官方资源
02-12
pandas快速入门官方资源 pandas是基于Python的数据分析库，提供了高效的数据结构和分析工具。本节将对pandas的基本概念和使用方法进行介绍。 系列（Series） Series是pandas中的基本数据结构之一，相当于一维数组...
python数据科学系列：pandas入门详细教程
python爬虫人工智能大数据
05-06 9414
导读前2篇分别系统性介绍了numpy和matplotlib的入门基本知识，今天本文自然是要对pandas进行入门详细介绍，通过本文你将系统性了解pandas为何会有数据分析界"瑞...
pandas用法详解
qq_36608036的博客
09-17 6573
一、生成数据表 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(‘name.xlsx’)) 3、用pandas创建数据表： df = pd.DataFrame({“id”:[1001,1002,1003,
Pandas基础知识
shi_jiaye的博客
02-09 547
安装 pandas：pip install pandas Pandas 中主要使用 Series 和 DataFrame 两种数据结构。 1. Series 1.1 Series 创建 Series 是一种类似于一维数组的对象，它由一组数据和一组与之相关的索引组成。Series 一般有四种创建方法。 （1）列表 （2）标量值 import pandas as pd a=pd.Series(25,index=['a','b','c']) print(a) 输出： a 25 b 25 c
Pandas十分钟快速入门
weixin_46626325的博客
11-22 216
Pandas十分钟快速入门
Pandas快速入门
weixin_36058228的博客
03-11 495
Pandas是Python中非常流行的数据处理库之一，它提供了一种简单而强大的方法来处理和分析数据。在本篇文章中，我将向你介绍Pandas的基础知识，以便你可以开始使用它来处理和分析数据。
numpy和 Pandas快速入门
weixin_44681349的博客
12-10 973
Numpy和 Pandas快速入门 一. Numpy 是一个开源的数据计算库 python 两者都可以处理多维数组 Numpy优点 1.减少编程量 2 .增加运算效率 3. 减少内存消耗 ndarray 数组 包括 数据指针 数据类型 维度 跨度。 1. 特殊数组的创建 Numpy.zeros 全1数组 numpy.ones 等间距数组1 numpy.arrange() 等间距数组2 numpy.linspace() array: [0,1,2, 3, 4, 5, 6, 7, 8, 9] 2. n
Spark上使用pandas API快速入门
zy345293721的博客
10-14 909
这是 Spark 上的 pandas API 的简短介绍，主要面向新用户。本笔记本向您展示 pandas 和 Spark 上的 pandas API 之间的一些关键区别。这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。通过传递可转换为类似系列的对象字典来创建 pandas-on-Spark DataFrame。从 Spark DataFrame 创建 pandas-on-Spark DataFrame。以下是如何显示下面框架中的顶行。
pandas快速入门指南
学而思(xiejava的blog)
02-23 1999
Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来，享有数据分析“三剑客之一”的盛名（NumPy、Matplotlib、Pandas）。是学习数据分析、AI机器学习必学组件之一。 Pandas 这个名字来源于面板数据（Panel Data）与数据分析（data analysis）这两个名词的组合。在经济学中，Panel Data 是一个关于多维数据集的术语。Pandas 对数据的处理是为数据的分析服务的，它所提供的各种数据处理方法、工具是基于数理.
Pandas简单快速入门教程
weixin_46863529的博客
06-10 773
在开始使用Pandas之前，您需要确保已经在您的计算机上安装了Pandas库。- `Series`是一维的数据结构，类似于Python的列表，但是它可以包含不同类型的数据，并且每个数据项都有一个索引。- `DataFrame`是二维的数据结构，类似于Excel表格，它可以包含多列数据，每列可以有不同的数据类型。以上是Pandas的一些基本用法，通过这些示例，您应该能够开始使用Pandas进行数据处理和分析。Pandas提供了两种主要的数据结构：`Series`和`DataFrame`。
python数据分析pandas快速入门教程.pdf
06-05
python数据分析pandas快速入门教程，电子版书籍，带你学习python使用pandas数据处理
政安晨：机器学习快速入门（一）{基于Python与Pandas}的示例数据包
02-05
政安晨：机器学习快速入门（一）{基于Python与Pandas}的示例数据包，用于在文章：政安晨：机器学习快速入门（一）{基于Python与Pandas}中给读者下载处理的示例数据
AI基础：Pandas简易入门.pdf
09-02
Pandas主要提供了两个数据结构：Series（一维数据）和DataFrame（二维数据），这两个数据结构可以帮助开发者快速处理和分析大量数据。 Pandas的主要特点包括： 1. 高效：Pandas提供了高效的数据处理和分析能力，...
（Pandas高级数据分析快速入门）数据源——加油日交易数据片段
08-27
博客：Pandas高级数据分析快速入门，系列文档的操作数据源
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1448
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
GLM+vLLM 部署调用
qq_38915354的博客
06-13 1121
vLLM 框架是一个高效的大型语言模型（LLM）推理和部署服务系统
2024 年最新基于 LLOneBot NT 框架搭建 QQ 机器人详细教程（更新中）
唤醒手腕的博客
06-14 571
llonebot（LLOneBot）是一个与OneBot（也称为CQHTTP）协议兼容的机器人框架，它允许开发者使用不同的编程语言（如Python、Go、JavaScript等）编写机器人应用，并与各种支持 OneBot 协议的聊天平台（如QQ、Telegram、Discord等）进行交互。onebot 11 背景。
第9章 类
最新发布
我走的每一步都算数
06-17 607
让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。class Car:class ElectricCar(Car): # 继承Carself.battery = 85 # 新属性mycar = ElectricCar(2024, 'Au', 'A7') # 创建实例mycar.prt_battery() # 新方法熟悉Python 提供的选项，这样才能确定哪种组织方式是最佳的，并能理解别人开发的项目。
pandas入门教程
07-28
- *3* [pandas 快速入门教程](https://blog.csdn.net/down_12345/article/details/105345429)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cyyxbdmrrc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值