三.pandas基础

标签：df Series 基础 DataFrame pd print data pandas

目录

一：认识pandas

1.1 pandas的优势

1.2 下载安装

二：Series数据结构(一维)

2.1 创建Series

创建series对象(一维)

ndarray创建Series对象

“显式索引”的方法定义索引标签

dict创建Series对象(通过字典创建)

标量创建Series对象

2.2 访问Series

位置索引访问

索引标签访问

2.3 Series属性 xxx.xxx

2.4 Series方法xxx.() ->DataFrame也能用

三：DataFrame 数据结构(二维)

3.1 创建DataFrame对象

列表创建DataFame对象

字典 嵌套 列表创建

列表 嵌套 字典创建DataFrame对象

Series创建DataFrame对象

3.2 列索引--操作DataFrame

列索引--选取数据列

列索引---添加数据列

列索引删除数据列

3.3 行索引--操作DataFrame

标签索引选取

整数索引选取

切片 操作多行选取

添加---数据行

删除--数据行

3.4 DataFrame切片

四：常用属性和方法汇总

---

一：认识pandas

Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来，享有数据分析“三剑客之一”的盛名（NumPy、Matplotlib、Pandas）。Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具。

1.1 pandas的优势

与其它语言的数据分析包相比，Pandas 具有以下优势

• Pandas 的 DataFrame 和 Series 构建了适用于数据分析的存储结构；

• Pandas 简洁的 API 能够让你专注于代码的核心层面；

• Pandas 实现了与其他库的集成，比如 Scipy、scikit-learn 和 Matplotlib；

1.2 下载安装

pip install pandas==1.4.1 -i 源镜像

二：Series数据结构(一维)

数据结构	维度	说明
Series	1	该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述 数据值。Series 是一维数据结构，因此其维数不可以改变。
DataFrame	2	DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值。

• Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等；

• DataFrame 是一种表格型数据结构，它既有行标签，又有列标签。

2.1 创建Series

• 创建series对象(一维)

import pandas as pd     #取别名(as)    with as(上下文管理器)     
seriec_obj = pd.Series(data, index, dtype, copy)
(左边的值为右边值的索引---标签)
​
# data  输入的数据，可以是----列表、数组,字典,常量、ndarray等。
​
# index 索引值必须是惟一的，如果没有传递索引，则默认为 np.arrange(n)。(根据标签取值,不要重复欧~)
# dtype dtype表示数据类型，如果没有提供，则会自动判断得出。
# copy  表示对 data 进行拷贝，默认为 False。

• ndarray创建Series对象

import pandas as pd
import numpy as np
​
arr_str = np.array(['a', 'b', 'c', 'd'])
ser_obj = pd.Series(arr_str)
print(ser_obj)

ndarray 是 NumPy 中的数组类型，当 data 是 ndarry 时，传递的索引必须具有与数组相同的长度。假如没有给 index 参数传参，在默认情况下，索引值将使用是 range(n) 生成，其中 n 代表数组长度

上述示例中没有传递任何索引，所以索引默认从 0 开始分配 ，其索引范围为 0 到len(data)-1，即 0 到 3。这种设置方式被称为“隐式索引”。

----------自己定义索引叫法-------------index

-------字典的键直接充当标签.

• “显式索引”的方法定义索引标签

import numpy as np
​
arr_str = np.array(['张三', '李四', '王五', '赵六'])
# 自定义索引标签（即显示索引）
ser_obj = pd.Series(arr_str, index=[1, 2, 3, 4])
print(ser_obj)

• dict创建Series对象(通过字典创建)

import pandas as pd
​
data = {'a': 0., 'b': 1., 'c': 2.}
ser_data = pd.Series(data)
print(ser_data)

您可以把 dict 作为输入数据。如果没有传入索引时会按照字典的键来构造索引；反之，当传递了索引时需要将索引标签与字典中的值一一对应

import pandas as pd
​
data = {'a': 0., 'b': 1., 'c': 2.}
ser_data = pd.Series(data, index=['b', 'c', 'd', 'a'])
print(ser_data)

当传递的索引值无法找到与其对应的值时，使用 NaN（非数字）填充。

--------通过字典对象创建,不能设置 index .(因为字典有标签名了,index不是修改啦.--index是指定标签.)

---当标签是原始的01234.....时,可以通过index指定标签.

• 标量创建Series对象

import pandas as pd
​
ser_data = pd.Series(5, index=[0, 1, 2, 3])
print(ser_data)

2.2 访问Series

访问 Series 序列中元素，分为两种方式，一种是位置索引访问；另一种是索引标签访问。

--------------原始的标签(索引)访问时-->左闭右开, index定义后,--->都是闭合,都拿到.

• 位置索引访问

import pandas as pd
​
ser_data = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(ser_data)
print(ser_data[0])  # 位置下标
print(ser_data['a'])  # 标签下标

这种访问方式与 ndarray 和 list 相同，使用元素自身的下标进行访问。我们知道数组的索引计数从 0 开始，这表示第一个元素存储在第 0 个索引位置上，以此类推，就可以获得 Series 序列中的每个元素

通过切片的方式访问 Series 序列中的数据

import pandas as pd
ser_data = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(ser_data[:3])

• 索引标签访问

Series 类似于固定大小的 dict，把 index 中的索引标签当做 key，而把 Series 序列中的元素值当做 value，然后通过 index 索引标签来访问或者修改元素值。

import pandas as pd
​
ser_data = pd.Series([6, 7, 8, 9, 10], index=['a', 'b', 'c', 'd', 'e'])
print(ser_data[['a', 'c', 'd']])

2.3 Series属性 xxx.xxx

名称	属性
axes	以列表的形式返回所有行索引标签。
dtype	返回对象的数据类型。
empty	返回一个空的 Series 对象。 ----爬虫多线程,队列
ndim	返回输入数据的维数。
size	返回输入数据的元素数量。
values	以 ndarray 的形式返回 Series 对象。
index	返回一个RangeIndex对象，用来描述索引的取值范围。--直接把标签显示出来.

import pandas as pd
import numpy as np
ser_data = pd.Series(np.array([10, 20, 30, 40, 50]))
print(ser_data)
​
print(ser_data.axes)
print(ser_data.dtype)
print(ser_data.empty)
print(ser_data.ndim)
print(ser_data.size)
print(ser_data.values)
print(ser_data.index)

2.4 Series方法xxx.() ->DataFrame也能用

• 如果想要查看 Series 的某一部分数据，可以使用 head() 或者 tail() 方法

import numpy as np
​
ser_data = pd.Series(np.random.randn(5))        <--#######
print(ser_data)
# 返回前三行数据
print(ser_data.head(3))

head() 返回前 n 行数据，默认显示前 5 行数据

import pandas as pd
import numpy as np
​
ser_data = pd.Series(np.array([1, 2, 3, 4, 5, 6, 7]))
print(ser_data.tail)
# 返回后三行数据
print(ser_data.tail(3))

tail() 返回的是后 n 行数据，默认为后 5 行

• isnull() 和 notnull() 用于检测 Series 中的缺失值(不存在的数据)。所谓缺失值，顾名思义就是值不存在、丢失、缺少。

• 在实际的数据分析任物中，数据的收集往往要经历一个繁琐的过程。在这个过程中难免会因为一些不可抗力，或者人为因素导致数据丢失的现象。这时，我们可以使用相应的方法对缺失值进行处理，比如数据补齐等方法。

import pandas as pd
​
# None代表缺失数据
ser_data = pd.Series([1, 2, 5, None])
print(pd.isnull(ser_data))  # 是空值返回True

isnull()：如果为值不存在或者缺失，则返回 True。

import pandas as pd
​
# None代表缺失数据
ser_data = pd.Series([1, 2, 5, None])
print(pd.notnull(ser_data))  # 空值返回False

notnull()：如果值不存在或者缺失，则返回 False。

三：DataFrame 数据结构(二维)

• DataFrame 是 Pandas 的重要数据结构之一，也是在使用 Pandas 进行数据分析过程中最常用的结构之一，可以这么说，掌握了 DataFrame 的用法，你就拥有了学习数据分析的基本能力。

• DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。

• DataFrame 结构类似于 Execl 的表格型，表格中列标签的含义如下所示：

index	student_id	student_name	student_num
0	1001	James	82.6
1	1002	Pitter	76.5
2	1003	Jack	92.3
3	1004	Alice	88.5

同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应。上述表格的行标签从 0 到 3，共记录了 4 条数据（图中将行标签省略）。当然你也可以用“显式索引”的方式来设置行标签。

下面对 DataFrame 数据结构的特点做简单地总结，如下所示：

• DataFrame 每一列的标签值允许使用不同的数据类型；

• DataFrame 是表格型的数据结构，具有行和列；

• DataFrame 中的每个数据值都可以被修改。

• DataFrame 结构的行数、列数允许增加或者删除；

• DataFrame 有两个方向的标签轴，分别是行标签和列标签；

• DataFrame 可以对行和列执行算术运算。

3.1 创建DataFrame对象

• 使用下列方式创建一个空的 DataFrame，这是 DataFrame 最基本的创建方法

import pandas as pd
df = pd.DataFrame()
print(df)

• 列表创建DataFame对象

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print(df)
​
​
​
​
​

通过二维数组创建:

---
a=pd.DataFrame(np.random.randint(30,40,size(3,5)))  --->random创建二维数组

使用嵌套列表(二维数组)创建 DataFrame 对象 :

import pandas as pd
​
data = [['Alex', 10], ['Bob', 12], ['Clarke', 13]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)   
​
-----------columns指定列标签,index指定行标签.
​

• 字典 嵌套 列表创建

---字典当中的键就是列表的列标签.

import pandas as pd
​
data = {'Name': ['Tom', 'Jack', 'Steve', 'Ricky'], 'Age': [28, 34, 29, 42]}
df = pd.DataFrame(data)
print(df)
​

data 字典中，键对应的值的元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引将是 range(n)，其中 n 代表数组长度。

添加自定义的行标签

import pandas as pd
​
data = {'Name': ['Tom', 'Jack', 'Steve', 'Ricky'], 'Age': [28, 34, 29, 42]}
df = pd.DataFrame(data, index=['rank1', 'rank2', 'rank3', 'rank4'])
print(df)
​

• 列表 嵌套 字典创建DataFrame对象

import pandas as pd
​
data = [{'num': 1, 'result': 2}, {'num': 5, 'result': 10, 'number': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print(df)
​

如果其中某个元素值缺失，也就是字典的 key 无法找到对应的 value，将使用 NaN 代替。

使用字典嵌套列表以及行、列索引表创建一个 DataFrame 对象。

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print(df1)
print(df2)
​

• Series创建DataFrame对象

  传递一个字典形式的 Series，从而创建一个 DataFrame 对象，其输出结果的行索引是所有 index 的合集

import pandas as pd
​
dict_data = {
     'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
     'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
     }
df = pd.DataFrame(dict_data)
print(df)
----one two 为列标签.
​

3.2 列索引--操作DataFrame

DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作。

• 列索引--选取数据列

import pandas as pd
​
dict_data = {
     'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
     'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
     }
df = pd.DataFrame(dict_data)
print(df['one'])
​

• 列索引---添加数据列

import pandas as pd
​
dict_data = {
     'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
     'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
# 使用df['列']=值，-->插入新的数据列
df['three'] = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(df)
# 将已经存在的数据列做相加运算
df['four'] = df['one'] + df['three']
print(df)
​

除了使用df[]=value的方式外(插入到最后面)，您还可以使用 insert() 方法插入新的列

insert() --->第一个参数为插入列的位置;(插入到前面)

import pandas as pd
​
info = [['Jack', 18], ['Helen', 19], ['John', 17]]
df = pd.DataFrame(info, columns=['name', 'age'])
print(df)
# 注意是column参数
# 数值1代表插入到columns列表的索引位置
df.insert(1, column='score', value=[91, 90, 75])
print(df)
​
​

• 列索引删除数据列

  通过 del 和 pop() 都能够删除 DataFrame 中的数据列

  -------直接删除列. del xxx['column']

3.3 行索引--操作DataFrame

理解了上述的列索引操作后，行索引操作就变的简单。下面看一下，如何使用行索引来选取 DataFrame 中的数据。

• 标签索引选取

  可以将行标签传递给 loc 函数，来选取数据

----------第一个参数为行索引;第二个参数可限制范围(列索引)

import pandas as pd
 
dict_data = {
     'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
     'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
print(df)
print(df.loc['b', "one"])
​

• 整数索引选取

  通过将数据行所在的索引位置传递给 iloc 函数，也可以实现数据行选取

  ----iloc函数只能通过整数索引取值.

import pandas as pd
​
dict_data = {
     'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
     'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
     }
df = pd.DataFrame(dict_data)
print(df)
print(df.iloc[2])
​

• 切片 操作多行选取

  可以使用切片的方式同时选取多行

import pandas as pd
​
dict_data = {
     'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
     'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
# 左闭右开
print(df[2:4])
​

• 添加---数据行

  使用 append() 函数，可以将新的数据行添加到 DataFrame 中，该函数会在行末追加数据行

  -

import pandas as pd
​
df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['a', 'b'])
# 在行末追加新数据行
df = df.append(df2)
print(df)
​

• 删除--数据行

  drop('标签') 删除一行.

  使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除

import time
​
import pandas as pd
​
df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['a', 'b'])
df = df.append(df2)
​
print(df)
# 注意此处调用了drop()方法
​
df = df.drop(0)
print(df)
​

3.4 DataFrame切片

• 直接使用中括号时：

  • 索引优先对列进行操作

  • 切片优先对行进行操作

import pandas as pd
import numpy as np
​
​
dict_data = pd.DataFrame(
    data=np.random.randint(60,90, size=(5,6)),
    index=['张三', '李四', '王五', '赵六', '坤哥'],
    columns=["语文","数学","英语","地理","历史", "化学"]
)
​
print(dict_data)
​
# 行切片
print(dict_data[1:3])
print(dict_data["张三":"赵六"])
​
​
# 列切片   loc iloc
# 对列作切片，也必须先对行做切片
print(dict_data.iloc[:, 1:4])
print(dict_data.loc[:, "数学":"化学"])
​
# 对行和列作切片操作
print(dict_data.iloc[1:3, 1:4])
print(dict_data.loc["张三":"王五", "语文":"历史"])

四：常用属性和方法汇总

DataFrame 的属性和方法，与 Series 相差无几

名称	属性&方法描述
T	行和列转置。
axes	返回一个仅以行轴标签和列轴标签为成员的列表。
dtypes	返回每列数据的数据类型。
empty	DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。
ndim	轴的数量，也指数组的维数。
shape	返回一个元组，表示了 DataFrame 维度。
size	DataFrame中的元素数量。
values	使用 numpy 数组表示 DataFrame 中的元素值。
head()	返回前 n 行数据。
tail()	返回后 n 行数据。

import pandas as pd
​
dict_data = {
    'Name': pd.Series(['张三', '李四', "王五", '赵六', '坤哥', '凡凡', '峰峰']),
    'age': pd.Series([25, 26, 25, 28, 23, 29, 23]),
    'Height': pd.Series([174.23, 173.24, 173.98, 172.56, 183.20, 174.6, 183.8])
}
# 构建DataFrame
df = pd.DataFrame(dict_data)
# 输出series
print(df)
print("-*-" * 30)
# 输出DataFrame的转置,也就是把行和列进行交换
print(df.T)
​
print("-*-" * 30)
# 返回一个行标签、列标签组成的列表
print(df.axes)
​
print("-*-" * 30)
# 输出行、列标签类型
print(df.dtypes)
​
print("-*-" * 30)
# 判断输入数据是否为空，若为 True 表示对象为空
print(df.empty)
​
print("-*-" * 30)
# 返回数据对象的维数。DataFrame 是一个二维数据结构
print(df.ndim)
​
print("-*-" * 30)
# DataFrame的形状
print(df.shape)
​
print("-*-" * 30)
# DataFrame的中元素个数
print(df.size)
​
print("-*-" * 30)
# DataFrame的数据
print(df.values)
​
print("-*-" * 30)
# 获取前3行数据
print(df.head(3))
​
print("-*-" * 30)
# 获取后2行数据
print(df.tail(2))
​

标签：df,Series,基础,DataFrame,pd,print,data,pandas
From： https://blog.csdn.net/2303_80857229/article/details/136596200