Pandas

已于 2023-11-05 14:14:48 修改
阅读量133 收藏 1
点赞数
分类专栏： 机器学习 文章标签： pandas python 人工智能
于 2023-11-04 16:59:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43606146/article/details/134220452
版权

Series

from pandas import Series

# 创建Series
x = Series(['a', 'b'])
print(x)
# 0    a
# 1    b
# dtype: object

x = Series(
    ['a', 'b'],
    index=['first', 'second']
)
print(x)
# first     a
# second    b
# dtype: object

根据索引访问某个数据

from pandas import Series
x = Series(
    ['a', 'b'],
    index=['first', 'second']
)
print(x)
# first     a
# second    b
# dtype: object

# 备注，哪怕是修改了索引，默认索引仍然是从0开始的数字，仍然可以通过默认索引（或者叫位置）进行访问

# 根据索引访问某个数据
print(x[0], type(x[0]))
print(x['first'], type(x['first']))
# a <class 'str'>

插入一行

from pandas import Series
x = Series(
    ['a', 'b'],
    index=['first', 'second']
)
print(x)
# first     a
# second    b
# dtype: object

# 备注，哪怕是修改了索引，默认索引仍然是从0开始的数字，仍然可以通过默认索引（或者叫位置）进行访问


x = x._append(Series(['2']))
print(x)
# first     a
# second    b
# 0         2
# dtype: object

判断是否有某数据

from pandas import Series
x = Series(
    ['a', 'b'],
    index=['first', 'second']
)
print(x)
# first     a
# second    b
# dtype: object

# 备注，哪怕是修改了索引，默认索引仍然是从0开始的数字，仍然可以通过默认索引（或者叫位置）进行访问

#判断值是否存在于系列中，要用Series.values
print('a' in x.values)  # True
print('c' in x.values)  # False

获取行数据

from pandas import Series
x = Series(
    ['a', 'b', 'c']
)
# print(x)
# first     a
# second    b
# dtype: object

# 备注，哪怕是修改了索引，默认索引仍然是从0开始的数字，仍然可以通过默认索引（或者叫位置）进行访问

print(x[0: 1])
# 0    a
# dtype: object


#定位获取，这个方法经常用于随机抽样
s = x[[0, 2]]
print(s, type(s))
# 0    a
# 2    c
# dtype: object <class 'pandas.core.series.Series'>

删除数据

from pandas import Series
x = Series(
    ['a', 'b', 'c'],
    index=['first', 'second', 'third']
)
# print(x)
# first     a
# second    b
# dtype: object

# 备注，哪怕是修改了索引，默认索引仍然是从0开始的数字，仍然可以通过默认索引（或者叫位置）进行访问

# 根据索引名称，删除某行
x.drop('first', inplace=True)
print(x)
# second    b
# third     c
# dtype: object

# 根据位置（默认索引）删除数据
x.drop(x.index[2], inplace=True)
print(x)
# first     a
# second    b
# dtype: object

# 根据值删除
x = x['b' != x.values]
print(x)  # 删除b
# first    a
# third    c
# dtype: object

DataFrame

创建DataFrame

from pandas import DataFrame

#创建数据框
# ① 默认索引
df = DataFrame({
    'age': [21, 22, 23],
    'name': ['KEN', 'John', 'JIMI']
})

# print(df)
#    age  name
# 0   21   KEN
# 1   22  John
# 2   23  JIMI

# ② 指定索引
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    },
    index=['first', 'second', 'third']
)

print(df)
#         age  name
# first    21   KEN
# second   22  John
# third    23  JIMI
# # 备注，哪怕是修改了索引，默认索引仍然是从0开始的数字，仍然可以通过默认索引进行访问

按列获取数据

from pandas import DataFrame

# 创建 DataFrame 指定索引
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    },
    index=['first', 'second', 'third']
)

print(df)  # 打印 DataFrame
#         age  name
# first    21   KEN
# second   22  John
# third    23  JIMI

# 按照列获取数据
print(df['age'])  # 访问单列
# first     21
# second    22
# third     23
# Name: age, dtype: int64

print(df[['age', 'name']])  # 访问多列
#         age  name
# first    21   KEN
# second   22  John
# third    23  JIMI

# DataFrame 的列就是Series
print(type(df['name']))
# <class 'pandas.core.series.Series'>

按行获取数据

from pandas import DataFrame
# 创建 DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    },
    index=['first', 'second', 'third']
)

# 获取单行数据，以下3种方法结果一样
print(df[1:2])  # 切片
print(df.loc[['second']])  # .loc是按照索引名称，如果是默认索引，则和iloc方法一样
print(df.iloc[[1]])  # i.loc是按照行数，首行是第0行，不管索引名称，参数就是数字
#         age  name
# second   22  John


# 获取非连续多行数据
print(df.loc[['first', 'third']])
print(df.iloc[[0, 2]])
#        age  name
# first   21   KEN
# third   23  JIMI

# 获取连续多行数据
print(df[1:3])
print(df.iloc[1:3])
#         age  name
# second   22  John
# third    23  JIMI

# 特例
df2 = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    }
)
# 如果是默认索引(从0开始的数字)，则可以用loc切片来获取连续行数，但是冒号右边的值对应的行是可以取到的
print(df2.loc[0:2])
#    age  name
# 0   21   KEN
# 1   22  John
# 2   23  JIMI

获取某个字段值

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    },
    index=['first', 'second', 'third']
)

# 获取指定字段数据
s = df.iloc[0:1, 1:2]
print(s, type(s))
#       name
# first  KEN <class 'pandas.core.frame.DataFrame'>

s2 = df.at['first', 'name']
print(s2, type(s2))
# KEN <class 'str'>

修改列名

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    }
)

# 修改列名
df.columns = ['a', 'b']
print(df)
#     a     b
# 0  21   KEN
# 1  22  John
# 2  23  JIMI

修改行索引名称

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    }
)

# 修改行索引
df.index = ['a', 'b', 'c']
print(df)
#    age  name
# a   21   KEN
# b   22  John
# c   23  JIMI

根据行索引删除某行

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    },
    index=['first', 'second', 'third']
)

# 删除行，根据行索引名称删除
# 默认参数axis=0, 即按行处理
df.drop('first', axis=0, inplace=True)
print(df)
#         age  name
# second   22  John
# third    23  JIMI

删除列

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    }
)
# 删除列
df.drop('age', axis=1, inplace=True)
print(df)
#    name
# 0   KEN
# 1  John
# 2  JIMI

增加行

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22],
        'name': ['Ken', 'John']
    }
)

# 增加行，注意，这种方法，效率非常低
# 不应该用于遍历中
df.loc[len(df)] = [20, "Tom"]
print(df)
#    age  name
# 0   21   Ken
# 1   22  John
# 2   20   Tom

增加列

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['KEN', 'John', 'JIMI']
    }
)

df['class'] = [2, 4, 6]
print(df)
#    age  name  class
# 0   21   KEN      2
# 1   22  John      4
# 2   23  JIMI      6

查看前n行数据

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['Ken', 'John', 'Jim']
    }
)
# 打印前n行数据, head(n)
print(df.head(2))
#    age  name
# 0   21   Ken
# 1   22  John

获取行数和列数

from pandas import DataFrame
df = DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['Ken', 'John', 'Jim']
    }
)
# 打印行数和列数，以元组形式返回
s = df.shape
print(s, type(s))
# (3, 2) <class 'tuple'>

查看是否有空值

import numpy as np
import pandas as pd

df = pd.DataFrame(
    data={
        'age': [21, 22, 23],
        'name': ['Ken', 'John', np.NaN],
        'class': [1, 2, 3]
    }
)
print(df)
#    age  name  class
# 0   21   Ken      1
# 1   22  John      2
# 2   23   NaN      3

# 查看哪行有空值，空值行返回True
print(df.isnull().any(axis=1))
# 索引2行有空值
# 0    False
# 1    False
# 2     True
# dtype: bool

# 查看哪行非空，非空行返回True
print(df.notnull().all(axis=1))
# 0     True
# 1     True
# 2    False
# dtype: bool


# 查看哪列是否有空值，有空值的列返回True
print(df.isnull().any(axis=0))
# name列有空值
# age      False
# name      True
# class    False
# dtype: bool


# 查看哪列没空值，没空值的列返回True
print(df.notnull().all(axis=0))
# age       True
# name     False
# class     True
# dtype: bool

# 查看每个字段数据的是否为空值，数据量大时没啥用
print(df.isnull())
#      age   name  class
# 0  False  False  False
# 1  False  False  False
# 2  False   True  False

# 查看每个字段数据是否不为空值，数据量大时没啥用
print(df.notnull())
#     age   name  class
# 0  True   True   True
# 1  True   True   True
# 2  True  False   True

某列含有特定值的所有记录

import numpy as np
import pandas as pd

df = pd.DataFrame(
    data={
        'age': [21, 22, 22],
        'name': ['Ken', 'John', 'Tom'],
    }
)
# 查找年龄是22岁的记录
print(df[df['age'] == 22])
#    age  name
# 1   22  John
# 2   22   Tom

向量化运算

向量化计算是一种特殊的并行计算方式，它可以在同一时间执行多次操作，通常是对不同的数据执行同样一个或一批指令，或者说把指令应用于一个数组/向量。当对系列或者数据框执行操作时，会对每个元素进行操作，然后返回系列或数据框。

#生成一个小数的等差序列的数组
import numpy
r = numpy.arange(1, 6, 1)
print(r)  # [1 2 3 4 5]

# 向量化计算，四则运算，数组中每个元素都进行了运算
print(r + r)  # [ 2  4  6  8 10]
print(r - r)  # [0 0 0 0 0]
print(r * r)  # [ 1  4  9 16 25]
print(r / r)  # [1. 1. 1. 1. 1.]

# 函数式的向量化计算
# 求r的5次方
print(numpy.power(r, 5))  # [   1   32  243 1024 3125]

# 向量化运算，比较运算
print(r > 3)  # [False False False  True  True]

# 结合过滤进行使用
print(r[r > 3] )  # [4 5]

# 矩阵运算
# #行6列乘以6行1列
print(numpy.dot(r, r.T))   # 55
print(sum(r*r))  # 55


import numpy as np
import pandas as pd
df = pd.DataFrame({
    'a': [1,2,3],
    'b': [6,7,8]
})

# print(df)
#    a  b
# 0  1  6
# 1  2  7
# 2  3  8

# 每列最小值
ret = df.apply(min)
print(ret)
# a    1
# b    6
# dtype: int64
print(type(ret))
# <class 'pandas.core.series.Series'>

# 每行最小值
ret = df.apply(min, axis=1)
print(ret)
# 0    1
# 1    2
# 2    3
# dtype: int64
print(type(ret))
# <class 'pandas.core.series.Series'>


#判断每列，值是否都大于2
ret = df.apply(lambda x: np.all(x>2))
print(ret)
# a    False
# b     True
# dtype: bool
print(type(ret))
# <class 'pandas.core.series.Series'>


#判断每行，值是否都大于0
ret = df.apply(lambda x: np.all(x>2), axis=1)
print(ret)
# 0    False
# 1    False
# 2     True
# dtype: bool
print(type(ret))
# <class 'pandas.core.series.Series'>

#判断每行，值是否都大于0，如果是则输出该记录
ret = df[df.apply(lambda x: np.all(x>2), axis=1)]
print(ret)
#    a  b
# 2  3  8
print(type(ret))
# <class 'pandas.core.frame.DataFrame'>

导入导出文件

# 导入EXCEL
import os
import pandas as pd

filename = 'tmp.xlsx'
df = pd.read_excel(os.getcwd() + os.sep + filename,
                   sheet_name='老师', # sheet的索引，从0开始 或者 sheet的名字
                   names=['第1列', '第2列', '第3列'],  # 给列命名，如果文件第一行没有列名，则可以用该参数命名列名，默认文件中第一行作为列名
                   na_values=['a', 'b']  # na_values：将某些特定的值识别为空值，例子中是将字符a和b识别为空值
                   )
print(df)

# 导入txt
import os
import pandas as pd
filename = 'tmp.txt'
df = pd.read_table(os.getcwd() + os.sep + filename,
                   sep=' '  # sep：为文本文件中的分隔符
                   )
print(df)

# 导入csv
# pd.read_csv  # 导入csv文件

# 导出csv/xlsx
retname = 'ret.csv'
df.to_csv(os.getcwd() + os.sep + retname, sep=',', index=False, header=True)

retname = 'ret.xlsx'
df.to_excel(os.getcwd() + os.sep + retname, index=False, header=True)

# filepath：路径
# sep：分隔符，默认逗号
# index：是否保留索引，True保留，False不保留
# header：是否保留列名，True保留，False不保留
Rock在学习
关注
专栏目录
Pandas常用函数——索引取值
渣娃攻城狮的博客
03-28 8767
索引取值 1、df[]取值 df[: 5] # 输入index，按行取值(0~4)，同列表切片 df["date"] # 按列取值 df[df["date"] > "2020-01-01"] # 传入bool值，进行简单数据选择 2、df.loc[行标签, 列标签] 主要基于标签，但也可以与布尔数组一起使用。 单个标签。（注意，数字5被解释为标签） 列表或标签数组。['a', 'b', 'c'] 带标签的切片对象'a':'f'（注意，不同于Python列表，切片包括端点'a','f'） 布尔
（16）pandas多层级索引的访问
2301_79149013的博客
07-26 211
想要得到多个值时，只需要将loc的第一个传入参数设置为列表(由目标索引组成的元组)即可，可以显式索引，也可以隐式索引。在对Series数组进行多层级索引操作时，和一维索引操作的不同之处在loc的传入参数。当传入参数是元组时，元组中元素的等级依次减小，每一个元素，代表着该层级的索引位置。单曲去除df_things数组中的“语文”列，就可以得到一个Series数组。
Pandas Series详解
不忘初欣丶的博客
04-12 4542
pandas Series详解
Python 教学 | Pandas 数据索引与数据选取
weixin_55633225的博客
05-23 4589
上一期文章已经向大家详细介绍了 Pandas 如何导入导出数据，那么接下来的技术文章我们将会把重点指向如何分析处理数据。
pandas索引
CarveStone的博客
01-14 3439
通过分层索引，我们可以像处理二维数据一样，处理三维及以上的数据。分层索引（Multiple Index）是 Pandas 中非常重要的索引类型，它指的是在一个轴上拥有多个（即两个以上）索引层数，这使得我们可以用低维度的结构来处理更高维的数据。下面介绍几种创建分层索引的方式。索引（index）是 Pandas 的重要工具，通过索引可以从 DataFame 中选择特定的行数和列数，这种选择数据的方式称为“子集选择”。索引可以加快数据访问的速度，它就好比数据的书签，通过它可以实现数据的快速查找。
Pandas版本1
08-04
"Pandas版本1" Pandas是一个基于Python的数据分析库，提供了高效、灵活的数据结构和数据分析工具。下面是Pandas版本1的知识点总结： 1. 数据结构：Pandas提供了两种基本的数据结构：Series（一维数据）和DataFrame...
Pandas手册.pdf
02-03
Pandas 手册 Pandas 是 Python 中的一个开源库，提供了高效的数据处理和分析工具。该手册概括了 Pandas 的主要特性和方法，涵盖了数据帧、reshaping 数据、数据排序、索引、重命名、数据合并、逻辑运算、正则表达式...
pandas1.4.3官方文档
06-25
pandas 1.4.3官方文档 pandas是一个功能强大且流行的Python数据分析工具箱，提供了高效、灵活和可扩展的数据处理和分析解决方案。下面是根据官方文档生成的相关知识点： 安装 pandas可以通过pip进行安装，命令...
pandas
01-20
**Pandas库详解** Pandas是Python编程语言中用于数据分析的核心库，它的名称来源于"Panel Data"的缩写。这个库提供了大量使数据分析工作变得简单、高效的数据结构和数据分析工具。Pandas的主要特点是其易用性和高...
对pandas的层次索引与取值的新方法详解
12-25
1、层次索引 1.1 定义 在某一个方向拥有多个（两个及两个以上）索引级别，就叫做层次索引。 通过层次化索引，pandas能够以较低维度形式处理高纬度的数据 通过层次化索引，可以按照层次统计数据 层次索引包括Series层次索引和DataFrame层次索引 1.2 Series的层次索引 import numpy as np import pandas as pd s1 = pd.Series(data=[99, 80, 76, 80, 99], index=[['2017', '2017', '2018', '2018', '2018'], ['张伊曼', '张巧玲', '张诗诗'
python pandas Series的索引操作
你必须十分努力，才能看起来毫不费力！
03-20 3143
# 构建一个Series对象，接下来的操作基于这个对象 ser_obj = pd.Series(range(5), index=['a', 'b', 'c', 'd', 'e']) 行索引 使用标签名称 ser_obj.loc['b'] 使用索引位置 ser_obj.iloc[1] 切片索引 使用标签名称切片包含头和尾的元素，使用索引名称，包含开头但是不包含结尾。 使用标签名称 ser_obj.loc['c': 'e'] 使用索引位置 ser_obj.iloc[2:4] 不连续索引 使用
Pandas索引操作
前景
07-20 7990
Pandas索引操作
Pandas如何实现单层索引访问数据？
最新发布
zy1992As的博客
11-06 184
pandas中提供了多种使用单层索引访问Series类对象和DataFrame类对象的方式，包括[]、loe、iloc、at和iat，关于这几种方式的介绍如下。
pandas根据索引取数据，举例说明
weixin_42588555的博客
02-17 956
Pandas是一个Python数据分析库，它可以容易地读取和处理数据。使用Pandas可以按照索引取数据，比如，假设我们有一个名为dataframe的数据框，其中有3列，分别为'Name'，'Age'和'Score'，则我们可以根据索引取出某一行的数据，例如，如果我们想取出第二行的数据，则可以使用dataframe.iloc[1]，来取出第二行的数据。 ...
pandas中访问使用多个索引的Series
hooyying的博客
04-05 1241
data = pd.Series(np.random.randn(9),\ index=[['a','a','a','b','b','b','c','c','c'], [1,2,3,1,2,3,1,2,3]]) data a 1 -0.901880 2 0.083255 3 1.002014 b 1 2.033284 2 -1.063635 3 -0.415264 c
pandas 行列索引及值的获取
bethsuki的博客
04-26 2万+
参考https://www.cnblogs.com/liulangmao/p/9248930.html 1.在dataframe结构中，index与column分别代表行、列索引。 2.获取值 4.获取第一列命名值df.index;获取值df.values ...
pandas dataframe series根据值获取标签（索引），根据索引获取值
热门推荐
Hello Word!
03-25 6万+
如何得到series：https://blog.csdn.net/qxqxqzzz/article/details/101296187 # 根据值获取索引 series1[series1.values == 1].index # 根据索引获取值 series1['a']
pandas通过索引数组，获取对应值数组
weixin_45426939的博客
10-21 2377
前言： 已有一个pandas类型的data，通过np.where()操作data，返回一个<class 'tuple'>的select_data，元组的第一或第二个元素是我们想要的索引数组，假设索引数组(select_data[0] or select_data[1])命名为y，y的类型是<class 'numpy.ndarray'> 目的：直接取出索引数组对应的值 方法：     情况1：若data的类型是<class 'pandas.core.se
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值