python—数据分析(一)_列表填充series-CSDN博客

本文链接：https://blog.csdn.net/ex_6450/article/details/125749915

pandas模块：

Pandas 的数据结构：Pandas 主要有Series（一维数组），DataFrame（二维数组），Panel（三维数组），Panel4D（四维数组），PanelND（更多维数组）等数据结构。其中 Series 和 DataFrame 应用的最为广泛。

Series 是一维带标签的数组，它可以包含任何数据类型。包括整数，字符串，浮点数，Python 对象等。所以Series 可以通过标签来定位。
DataFrame 是二维的带标签的数据结构。我们可以通过标签来定位数据。这是 NumPy 所没有的。

Pandas 中，Series 可以被看作由 1 列数据组成的数据集。Series语法为：
s = pd.Series(data, index=index)

# 从列表创建Series
arr = [8, 7, 2, 3, 4]
s1 = pd.Series(arr)  # 如果不指定索引，则默认从0开始到N-1
# print(s1)

import numpy as np
n = np.random.random(5)  # 创建一个随机数组n
index = ['a', 'b', 'c', 'd', 'e']
# print(pd.Series(n, index=index))  # n为索引对象，index=index指定索引
# 从字典创建Series
dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# print(pd.Series(dict))

1.Series的基本操作

修改Series的索引

import pandas as pd

s = [1, 5, 6, 8, 9]
index = ['a', 'b', 'c', 'd', 'e']
a = pd.Series(s, index=index)
print(a)
a.index = ['A', 'B', 'C', 'D', 'E']  # 索引通过赋值的方式修改索引值
print(a)

输出为
a 1
b 5
c 6
d 8
e 9
dtype: int64
A 1
B 5
C 6
D 8
E 9
dtype: int64

Series根据运算的索引标签自动对齐数据

import pandas as pd

a = [1, 2, 3, 4, 5]
dict = {'ab':55, 'hb':99, "ds":97, 'age':18}
dict1 = ['ab', 'hb', 'ds', 'year']
s1 = pd.Series(dict)
s2 = pd.Series(dict, index=dict1)
print(s1)
print(s2)
print(s1 + s2)
# print(s1.append(s2))  # 竖向连接(在某些版本的pandas中append方法已经弃用了）

输出为
ab 55
hb 99
ds 97
age 18
dtype: int64
ab 55.0
hb 99.0
ds 97.0
year NaN
dtype: float64
ab 110.0
age NaN
ds 194.0
hb 198.0
year NaN
dtype: float64

按指定索引删除元素

import pandas as pd

a = [1, 2, 3, 4, 5]
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(a, index=index)
print(s)
s1 = s.drop('e')  # 删除索引为 e 的值
print(s1)

输出为
a 1
b 2
c 3
d 4
e 5
dtype: int64
a 1
b 2
c 3
d 4
dtype: int64

修改指定索引元素

import pandas as pd

a = [1, 2, 3, 4, 5]
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(a, index=index)
print(s)
s['a'] = 77
print(s)

输出为
a 1
b 2
c 3
d 4
e 5
dtype: int64
a 77
b 2
c 3
d 4
e 5
dtype: int64

按照指定索引查找元素

import pandas as pd

a = [1, 2, 3, 4, 5]
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(a, index=index)
print(s)
print(s['b'])  # 通过索引的方式选取Series中单一值
print(s[['b', 'd', 'e']])  # 通过索引的方式选取Series中一组值
# 类似于numpy的运算（会根据bool型数组进行过滤、标量乘法，应用数学函数等）都会保留索引值
# print(s[s > 3])
# print(s*3)
# print(np.exp(s))

输出为
a 1
b 2
c 3
d 4
e 5
dtype: int64
2
b 2
d 4
e 5
dtype: int64

Series的切片操作

import pandas as pd

a = [1, 2, 3, 4, 5]
index = ['a', 'b', 'c', 'd', 'e']
s = pd.Series(a, index=index)
print(s)
print(s[:3])  # 对s的前3个数据访问(跟前面列表的切片操作一样)

输出为
a 1
b 2
c 3
d 4
e 5
dtype: int64
a 1
b 2
c 3
dtype: int64

从字典创建Series

import pandas as pd
from pandas import DataFrame, Series

dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(pd.Series(dict))
# Series可以看成一个定长的有序字典，所查询的索引值是到数据值的一个映射
print('b' in s)  # 输出值为bool值
# 传入新排好序列字典的key从而改变原先字典的顺序,若传入的某些健key与原先的字典无相匹配，无值就输出NaN(非数字（not a number))
dict1 = ['b', 'e', 'a', 'd', 'f']  # 原字典中c不在新排的序列dict1中，输出新Serise被删除
print(pd.Series(dict, index=dict1))
# pandas中isnull（对应False不缺失）和notnull（对应是True不缺失）函数可用于检测数据的缺失
print(pd.isnull(pd.Series(dict, index=dict1)))  # 等价于用Series.isull()即print(pd.Series(dict, index=dict1).isnull())
#print(pd.notnull(pd.Series(dict, index=dict1)))

输出为：
a 1
b 2
c 3
d 4
e 5
dtype: int64
True
b 2.0
e 5.0
a 1.0
d 4.0
f NaN
dtype: float64
b False
e False
a False
d False
f True
dtype: bool

Series运算

import pandas as pd
from pandas import DataFrame, Series
d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}  # 定义示例字典
d2 = {'1': 5, '2': 2, 'c': 10, 'd': 14}
s1 = pd.Series(d1)
s2 = pd.Series(d2)
# 加法运算(对应健key的值相加）
print(s2.add(s1))  # Series 的加法运算是按照索引计算，如果索引不同则填充为 NaN（空值）
# 减法运算(对应健key的值相减）
print(s2.sub(s1))  # 索引不同则填充为 NaN（空值）
# 乘法运算(对应健key的值相乘）
print(s2.mul(s1))  # 索引不同则填充为 NaN（空值）
# 除法运算（对应健key的值相除）
print(s2.div(s1))  # 索引不同则填充为 NaN（空值）
# 求中位数
print(s1.median())  # 输出为3.0
# 求和
print(s1.sum())  # 输出为15
# 求最大值
print(s1.max())  # 输出为5
# 求最小值
print(s1.min())  # 输出为1

2.DateFrame

DataFrame是一个表格型的数据结构，含有一组有序的列，每列的值类型可以不同（数值、char、bool等）。不仅有行索引还有列索引，可以看作由Series组成地字典。数据是由一个或多个二维块存放的，不是列表、字典或别的一维数据结构。
语法格式： pd.DataFrame( data, index, columns, dtype, copy)
date表示传入的数据
index和columns 行索引和列索引（格式为[‘x1’,‘x2’]）
dtype为列的类型
copy是从input输入中拷贝数据（默认是false，不拷贝）。

通过numpy数组创建DateFrame

import pandas as pd
import numpy as np
from pandas import DataFrame
# 通过NUmpy数组创建DataFrame
# dates = pd.date_range('today', periods=6)  # 定义时间序列作为 index
dates = ['range1', 'range2', 'range3', 'range4', 'range5', 'range6']
date = np.random.randn(6, 4)  # 传入 numpy 随机数组6行4列
index = ['A', 'B', 'C', 'D']  # 将列表作为列名
frame = pd.DataFrame(date, index=dates, columns=index)
print(frame)

输出为

	A	B	C	D
range1	1.348870	-1.819609	-0.967384	-0.074994
range2	0.125211	-0.223506	-1.410466	-1.301604
range3	0.364305	1.049024	1.633363	1.651079
range4	-0.188807	0.425193	0.087638	0.074730
range5	-1.507986	-0.301548	0.950423	0.296719
range6	-0.636797	-0.490917	-0.486411	0.462784

通过字典数组创建 DataFrame

date =  {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(date)  # 未定义索引，索引从0到N-1排序
print(frame)

输出为

	state	year	pop
0	Ohio	2000	1.5
1	Ohio	2001	1.7
2	Ohio	2002	3.6
3	Nevada	2001	2.4
4	Nevada	2002	2.9
5	Nevada	2003	3.2

如果嵌套字典传给DataFrame，pandas就会被解释为：外层字典的键作为列，内层键则作为行索引：

pop = {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame = pd.DataFrame(pop)
print(frame)

输出为

	Nevada	Ohio
2001	2.4	1.7
2002	2.9	3.6
2000	NaN	1.5

DataFrame的基本操作

部分代码	功能说明
DataFrame()	创建一个DataFrame对象
frame.values	返回ndarray类型的对象
frame.iloc[ 行序,列序 ]	按序值返回元素
frame.loc[ 行索引,列索引 ]	按索引返回元素
frame.index	获取行索引
frame.columns	获取列索引
frame.axes	获取行及列索引
frame.T	行与列对换
frame. info()	打印DataFrame对象的信息
frame.head(i)	显示前 i 行数据
frame.tail(i)	显示后 i 行数据
frame.describe()	查看数据按列的统计信息
del frame[‘xx’]	关键字删除某xx列项

import pandas as pd
import numpy as np
from pandas import DataFrame
#  通过字典数组创建 DataFrame
date =  {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(date)  # 未定义索引，索引从0到N-1排序
print(frame)

 1. # 预览 DataFrame 的前 5 行数据

# print(frame.head())

 2. # 如果指定序列则按照指定顺序进行排序

# print(pd.DataFrame(date, columns=['year', 'state', 'pop']))  # columns对应是列名

 3. # 查看 DataFrame 的后 3 行数据

# print(frame.tail(3))  # 查看后面第几行数据用tail(n)函数

 4. # 查看DataFrame的索引

# print(frame.index)

5. # 查看DataFrame的列名

# print(frame.columns)

 6. # 查看 DataFrame的数值(跟Series一样，values属性也会以二维ndarray的形式返回DataFrame中的数据)

# print(frame.values)

7. # 查看DataFrame的统计数据

# print(frame.describe())  # 可以看到frame中count数量、mean、std、min、25%、50%、75%、max对应的数值

 8. # DataFrame转置操作

# print(frame.T)  # 相当于线性代数的转置，把列变成行，行变成列

 9. # 对DataFrame进行按照列排序

# print(frame.sort_values(by='pop'))  # 按照by='XX'升序排列

10. # 对DataFrame数据切片

# print(frame[1:3])  # 取1<frame<3的数据

 11. # 对DataFrame通过位置查询

# print(frame.iloc[1:3])  # 查询2，3行

 12. # 对DataFrame通过标签进行查询（单列）从而获取一个Series

# print(frame['year'])  # 输出是查询某列名的数据，另外可以写成frame.year(只适用于一个合理的python变量名才适用)

 13. # 通过位置或者是名称方式进行获取

# print(frame.loc('0'))

 14. # 对DataFrame进行多列标签查询

# print(frame[['year', 'pop']])  # 传入一个列名组成的列表

 15.# 生成 DataFrame 副本，方便数据集被多个不同流程使用(副本拷贝copy)

# print(frame.copy())

 16. # 判断DataFrame是否为空

# print(frame.isnull())  # 如果为空则返回为 True,notnull()函数为空返回False

 17. # 添加列数据（用Series一维数组添加进去DataFrame的列数据）

num = pd.Series([44,11,22,33,44,'NaN'], index=frame.index)  # 添加列数据的索引还是用frame的索引,若有值为空的都被填上缺失值NaN
frame['number'] = num  # 添加以 'number' 为列名的新数据列
# print(frame)

 18. # 新传入的列若找不到数据匹配，则将以NaN值输出

# frame2 = pd.DataFrame(date, index=['one', 'two', 'three', 'four', 'five', 'six'],
#                        colums=['year', 'state', 'pop', 'debt'])
# print(frame2）

 19. # 对DataFrame进行求平均值

# print(frame.mean())  # 只对为数值的列进行求平均值

 20. # 对DataFrame任意列进行求和操作

# print(frame['year'].sum())

 21. # 关键字del用于删除列

# del frame['number']  # 删除number列
# print(frame)

 22. # 打印DataFrame对象的信息

# print(frame.info())