pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy，主要包含一维的数据列series与二维的数据表DataFrame。
安装：
pip install pandas
引用：
import pandas
或者：
import pandas as pd
series是一个一维的数据列，它类似python的列表或者numpy的一维数组，但是不同的是它的每个元素都有一个索引键值。
我们可以使用python列表或者numpy一维数组创建它。
import pandas as pd
# 默认index索引是0，1，2...
s = pd.Series(['A', 'B', 'C'])
print(s)
# 0 A
# 1 B
# 2 C
# dtype: object
# 可以修改索引index索引为任意，这里是x，y，z
t = pd.Series(['A', 'B', 'C'], index=['x', 'y', 'z'])
print(t)
# x A
# y B
# z C
# dtype: object
（1）下标定位
一般一个列表例如a=[‘A’, ‘B’, ‘C’]通过元素的下标定位元素，例如a[0]是元素’A’,a[1]是元素’B’
（2）键值定位
s == pd.Series([‘A’, ‘B’, ‘C’], index=[‘x’, ‘y’, ‘z’])，不但可以通过元素下标定位，更加重要的是可以通过index键值定位，例如s[0]、s[‘x’]都是元素’A’。
import pandas as pd
s = pd.Series(['A', 'B', 'C'], index=[1, 0, 2])
print(s)
# iloc代表的是下标，loc代表的是键值，自己定义的
print(s.iloc[0], ",", s.loc[0])
print(s.iloc[1], ",", s.loc[1])
print(s.iloc[2], ",", s.loc[2])
如果s是一个Series对象，那么使用s.index来获取或者设置它的index值，注意要保证index的长度与s的数据长度一致，index可以是任意的整数，字符串等有虚数据。
import pandas as pd
s = pd.Series(['A', 'B', 'C'])
print(s.index)
# RangeIndex(start=0, stop=3, step=1)
t = pd.Series(['A', 'B', 'C'], index=['x', 'y', 'z'])
print(t.index)
# Index(['x', 'y', 'z'], dtype='object')
改变series的index
import pandas as pd
import numpy as np
# 改变series的index
s = pd.Series(['A', 'B', 'C'])
# s = pd.Series(np.array(['A', 'B', 'C']))
# print(s)
# s = pd.Series(np.array(['A', 'B', 'C']), index=['x', 'y', 'z'])
print(s)
print(s.index)
s.index = ['x', 'y', 'z']
print(s.index)
# print(list(s.index))
# Index(['x', 'y', 'z'], dtype='object')
import pandas as pd
import numpy as np
s = pd.Series(np.array(['A', 'B', 'C']), index=['x', 'y', 'z'])
print(s)
# iloc[i], i=0,1,2...
for i in range(len(s)):
print(i, s.iloc[i])
# loc[id], id=index
for id in s.index:
print(id, s.loc[id])
如果s是一个series, key是一个没有在s.index中出现过的键值，那么通过：
s.loc[key] = value
则可以增加一个index为key的元素，元素值为value。如果key已经在s.index中出现过，那么就修改原来的值。
如果s是一个series, key是一个在s.index中出现过的键值,那么通过
s.drop(key, inplace=True)
则可以删除index为key的元素
import pandas as pd
s = pd.Series(['A', 'B', 'C'], index=['x', 'y', 'z'])
print(s)
s.loc['p'] = 'D'
print(s)
s.drop('y', inplace=True)
print("s=", s)
# inplace对删除的影响
# inplace=False对s不产生影响
# inplace=True对s产生影响
t = s.drop('z', inplace=False)
print("s=", s)
print("t=", t)
下标切片
使用下标切片的规则是
s.iloc[slice]
其中slice是一个切片，通常的格式是start: end:step, 并且start、end、step中部分可以省略，规则与range(start, end, step)类似
import pandas as pd
# 下标切片
# 使用下标切片的规则是
# s.iloc[slice]
# 其中slice是一个切片，通常的格式是start:end:step, 并且start、end、step中部分可以省略，规则与range(start, end, step)类似
s = pd.Series(['A', 'B', 'C', 'D', 'E'], index=list('abcde'))
print(s.iloc[:])
# a A
# b B
# c C
# d D
# e E
# dtype: object
print(s.iloc[1:])
# b B
# c C
# d D
# e E
# dtype: object
print(s.iloc[:4])
# a A
# b B
# c C
# d D
# dtype: object
print(s.iloc[1:4])
# b B
# c C
# d D
# dtype: object
print(s.iloc[1:4:2])
# b B
# d D
# dtype: object
print(s.iloc[0, 2, 3])
Series四则混合运算
import pandas as pd
import numpy as np
s = pd.Series([1, 2, 3], index=["a", "b", "c"])
t = pd.Series([-1, 4, 2], index=["a", "b", "c"])
print(s)
print(t)
# Series四则混合运算
# 如果s,t是两个有相同index的Series, 那么可以进行s与t的四则混合运算，结果是对应的元素进行四则混合运算。
print("s+t=", s + t)
print("s-t=", s - t)
print("s*t=", s * t)
print("s/t=", s / t)
# Series比较运算，
# 如果s,t是两个有相同index的Series, 那么可以进行s与t的比较运算，结果是对应的元素进行比较，得到一个bool类型的Series。
DataFrame是一张二维的数据表，非常类似数据库中的数据表，有很多行，每行有很多列，每列有一个名称column，每行一个序号或者index。
import pandas as pd
# DataFrame是一张二维的数据表，非常类似数据库中的数据表，有很多行，每行有很多列，每列有一个名称column，每行一个序号或者index。
# 行数据创建
d = pd.DataFrame([{"Name": "A", "Sex": "M", "Age": 20},
{"Name": "B", "Sex": "F", "Age": 21},
{"Name": "C", "Sex": "F", "Age": 22},
{"Name": "D", "Sex": "F", "Age": 23}])
print(d)
# 列创建
d = pd.DataFrame({"Name": ["A", "B", "C", "D"],
"Sex": ["M", "F", "F", "M"],
"Age": [20, 21, 22, 23]})
print(d)
创建并设置index
import pandas as pd
# 创建并设置index
d = pd.DataFrame([{"Name": "A", "Sex": "M", "Age": 20},
{"Name": "B", "Sex": "F", "Age": 21},
{"Name": "C", "Sex": "F", "Age": 22},
{"Name": "D", "Sex": "F", "Age": 23}], index = ['a', 'b', 'c', 'd'])
print(d)
print(d.index)
创建并设置columns
import pandas as pd
# 默认columns是0、1、2....
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]])
print(d)
print(d.columns)
# 提供确定的columns
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"])
print(d)
print(d.columns)
# 提供确定的columns和index
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
print(d)
print(d.columns)
DataFrame的行与列
import pandas as pd
# 实际上为DateFrame设置index与columns是为了方便定义元素，
# 如果d是一个DateFrame，那么一般使用
# d.loc[index, column]
# 定义一个元素，其中index、column是d.index和d.column的一个值
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
for c in d.columns:
# "%5s"控制格式
print("%5s"%c, end=" ")
print()
for i in d.index:
for j in d.columns:
print("%5s"%d.loc[i, j], end=" ")
print()
# 除了使用index与column值定位元素外，也可以使用元素的下标位置定位元素。
# 如果d是一个DataFrame，那么一般使用
# d.iloc[i, j]
# 定位一个元素，其中i，j是行列的下标序号。
for i in range(4):
for j in range(3):
print(d.iloc[i, j], end=" ")
print()
# 获取整行整列
# d.loc[index, :]
# 获取index键值的一行
# d.iloc[i, :]
# 获取下标序号为i的一行
print(d.loc['a', :])
print(d.iloc[0, :])
# 输出确定行列的某个元素
print()
print(d.loc["b", "Name"])
print(d.loc[:, "Name"].index)
print(d.iloc[1, 0])
DataFrame增加删除某行某列
import pandas as pd
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
# 如果要增加一行可以使用
# d.loc[newlndex, :] = value
# 其中newlndex是一个新的index值，value是这行的数据列表，如果newIndex已经存在，就修改原来的行。
d.loc["e", :] = ["E", "M", 24]
print(d)
# 如果要增加一列
# d.loc[:, newColumn] = value
# 或者d[newColumn] = value
# 其中newColumn是一个新的column值，value是这列的数据列表，如果newColumn已经存在，就修改原来的列。
d.loc[:, "Tel"] = ["110", "119", "120", "520", "111"]
print(d)
# DataFrame对象d的数据是活动的，可以增加也可以删除，使用
# d.drop(index=value, inplace=True)
# 删除键值为inde=value的一行
d.drop(index="e", inplace=True)
print(d)
# 使用
# d.drop(columns=value, inplace=True)
# 删除columns=value的一列。
d.drop(columns="Tel", inplace=True)
print(d)
DataFrame切片操作
import pandas as pd
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
# DataFrame键值行列切片
# 使用
# d.loc[indexSlice, columnslice]
# 进行行列切片，其中indexSlice是一个index的切片，它的基本结构是startIndex:endIndex。
# （1）index是一个列表
# （2）startIndex与endIndex可以省略一个两个，开始到末尾行，"endIndex"从开始到endIndex行。
print(d.loc["a":"c", :])
print(d.loc[:"c", :])
print(d.loc[["a", "c"], :])
print(d.loc["c":, :])
# columnslice的结构类似。
print(d.loc[:, "Name":"Sex"])
print(d.loc[:, :"Sex"])
print(d.loc[:, "Sex":])
print(d.loc[:, ["Name", "Age"]])
# DataFrame下标行列切片
# 使用
# d.iloc[iSlice, jslice]
# 进行行列切片，其中iSlice是一个行下标的切片，它的基本结构是start:end:step或者是行序号的一个列表，
# start:end:step的规则与range(start, end, step)的类似。
# jslice的结构类似
print()
print(d.iloc[0:2, 1:2])
print(d.iloc[3:, 1:2])
print(d.iloc[:3, [0, 2]])
print(d.iloc[[0, 3], [1, 2]])
DataFrame数据操作
import pandas as pd
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", "F", 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
# DataFrame 数据操作
v = d.values
print(type(v))
# <class 'numpy.ndarray'>
print(v)
# numpy数组创建DataFrame
import numpy as np
a = pd.DataFrame(np.arange(12).reshape(4, 3))
print(a)
b = pd.DataFrame(np.arange(12).reshape(4, 3),
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd']
)
print(b)
# DataFrame 数据排序
# 一般DataFrame的数据可以按index或者columns的大小进行排序，规则是：
# （1）d.sort_index(axis=0),数据行按index进行排序；
# （2）d.sort_index(axis=1),数据列按columns进行排序；
d = pd.DataFrame(np.random.randint(0, 5, (3, 4), dtype=np.int_),
columns=["B", "A", "C", "D"],
index=['a', 'c', 'b']
)
print("原始数据")
print(d)
print("按index排序")
print(d.sort_index(axis=0))
print("按columns排序")
print(d.sort_index(axis=1))
print("按index、columns排序")
print(d.sort_index(axis=1).sort_index(axis=0))
# DataFrame的数据还可以按照数据的大小进行排序，规则是：
# （1）d.sort_values(by=column, axis=0),数据行按column列排序；
# （2）d.sort_values(by=column, axis=1),数据列按index行进行排序；
print("原始数据")
print(d)
print("按column=A列排序")
print(d.sort_values(by="A", axis=0))
print("按index=a行排序")
print(d.sort_values(by="a", axis=1))
DataFrame查找空，求平均值
import pandas as pd
d = pd.DataFrame([["A", "M", 20],
["B", "F", 21],
["C", None, 22],
["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
print(d)
print(pd.isna(d))
# 平均值
print(d.Age.mean())
DataFrame简单的查询
import pandas as pd
# 数据查询
# （1）NaN值是一种空值，在DataFrame中数据元素为None或者numpy.nan时都被看出NaN值，注意空字符串不是NaN。
# 如果d是一个Dataframe，那么使用
# d.isna()
# 或者pd.isna(d)
# 函数检测NaN值，它返回一个bool类型的DataFrame，NaN值的地方是True，不然是False。
# （2）DataFrame中query查询
# DataFrame的query查询是一个功能很强大的查询函数，他类似SQL中的select语句，一般规则是
# query(exp)
# 其中exp是一个由列名称组成的逻辑表达式，在多个条件时可以使用"and"、"or"、"not"完成and、or、not的复杂运算
d = pd.DataFrame([["A", "M", 20], ["B", "F", None], ["C", "F", 22], ["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
print(d)
# 查询Sex是"M"的学生
print(d.query("Sex=='M'"))
# 查询年龄小于25
print(d.query("Age < 25"))
# 年龄是20 或者23 岁的学生
print(d.query("(Age == 20) or (Age == 23)"))
# Age中空值用Age的平均值代题
x = d.query("Age.isna()")#查找Age是NaN值的记录
# d.loc[x.index, "Age"] = d.Age.mean()
d.loc[x.index, "Age"] = d.loc[:, "Age"].mean()
print(d)
DataFrame数据的四则运算
import pandas as pd
import numpy as np
a = pd.DataFrame(np.random.randint(0, 10, (2, 3), dtype=np.int_),
columns=["B", "A", "C"],
index=['a', 'b'])
b = pd.DataFrame(np.random.randint(1, 10, (2, 3), dtype=np.int_),
columns=["B", "A", "C"],
index=['a', 'b'])
print("a=\n", a)
print("b=\n", b)
print("a+b=\n", a+b)
print("a-b=\n", a-b)
print("a*b=\n", a*b)
print("a/b=\n", a/b)
# 如果a、b是两个有相同index与columns的DataFrame数据表，那么在保证它们的数据可以进行比较的前提下，
# 可以把a和b进行比较运算，结果是一个相同结构的bool类型的DataFrame
print("a>b=\n", a>b)
# 统计运算
# 类似numpy一样可以进行DataFrame对象d的统计运算，我们以sum函数为例：
# （1）d.sum()或者d.sum(axis=0)是固定每个列，对所有行数据进行累加运算；
# （2）d.sum(axis=1)是固定各个行，对所有列数据进行累加运算；
# 其他统计函数mean、max、min的规则类似。
print(a)
print("sum(axis=0)")
print(a.sum(axis=0))
print("sum(axis=1)")
print(a.sum(axis=1))
print("max(axis=0)")
print(a.max(axis=0))
print("max(axis=1)")
print(a.max(axis=1))
DataFrame数据的存储
import pandas as pd
# 数据存储
# （1）保存
# d.to_csv("data.csv", index=False)
# 把数据写到文件中
# （2）读取
# d = pd.read_csv("data.csv")
# 把数据读出到d
# （1）DataFrame无index保存 index=False
d = pd.DataFrame([["A", "M", 20], ["B", "F", 21], ["C", "F", 22], ["D", "M", 23]],
columns=["Name", "Sex", "Age"],
index=['a', 'b', 'c', 'd'])
d.to_csv("data.csv", index=False)
e = pd.read_csv("data.csv")
print(e)
# （2）DataFrame有index保存 index=True
d.to_csv("data.csv", index=True, index_label="ID")
e = pd.read_csv("data.csv", index_col="ID")
print(e)
# Name Sex Age
# ID
# a A M 20
# b B F 21
# c C F 22
# d D M 23
1882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
