panadas提供两个常用的数据类型：Series、Dataframe

一、Series

pandas的数据类型，有index和value
Series类型类似于Numpy的一维数组对象，可以将该类型看做事一组数据与数据相关的标签（索引）联合而构成（带有标签的一维数组对象）。

# 通过列表创建
# Series使用类似字典的方式，进行存储，其中，标签就是字典的key，数据就是字典的value
s1 = pd.Series([1,2,3,4])
0    1
1    2
2    3
3    4
dtype: int64

s1.values
array([1, 2, 3, 4], dtype=int64)

s1.index
RangeIndex(start=0, stop=4, step=1)

s2 = pd.Series(np.arange(10))

# 通过字典的形式创建
s3 = pd.Series({'1':1, '2':2, '3':3})
s3.values
array([1, 2, 3], dtype=int64)
# index就是字典的key
s3.index
Index(['1', '2', '3'], dtype='object')

# 可以指定index，如果index数大于value，value会广播，没有指定，自动生成0，1，2
s4 = pd.Series([1,2,3,4], index=['A','B','C','D'])
A    1
B    2
C    3
D    4
dtype: int64
s4['A'] # 1

s4.to_dict() # 转换为字典
s4[s4>2]
C    3
D    4
dtype: int64

# 也可以创建一个Index对象，传入给index参数（创建Series时）
# 当多个series需要相同的index时，就是用这种方式
index_1 = ['A','B','C','D','E']
s6 = pd.Series(s4, index=index_1)
A    1.0
B    2.0
C    3.0
D    4.0
E    NaN
dtype: float64

# values类似于字典的values方法（这里是属性）返回series中的相关数据
s.values    # 值
s.shape    # 数据形状
s.size     # 数据个数
s.dtype

ones = pd,Series([1,2,3,float("NaN"), None, np,nan])
pd.isnull(s6)
0    False
1    False
2    False
3    True
4    True
5    True
dtype: bool
pd.notnull(s6)

# Series的name属性可以通过创建Series时，指定name的参数来设置
# name是Series的属性，其作用不仅仅体现在输出中
s=pd.Seriex([1,2,3], index=[5,7,7], name='Seriex的name属性的名字')
my_index = pd.Index([1,2,3], name='Index的name属性的名字')
s6.name = 'demo' # 给Series取名字
s6.index.name = 'demo index' # 给Series index取名字

# head与tail
# 最多显示前n/后n个数据，如果没有给定参数，则参数值迷人为5.
s.head()
s.tail()

# Series只支持一维的数据结构
# ndarry与Series都可以通过索引来访问元素，但是二者是有区别的，对于ndarry类型与裂变的形式，是基于位置进行的访问，在创建对象后，每个元素的位置固定了，我们不能自行去改变元素的索引。
# 对于Series，类似于字典的形式，是基于key值进行访问元素的，我们可以自行去改变（指定）key值。

# Series也能进行标量或矢量化运算，但是Sreies的规则与ndarry是不太相同的。
#对于ndarry，时进行对位的计算（根据元素的位置进行计算），对于Series会根据索引进行对齐计算，如果索引无法进行匹配，则会产生空值（NaN）	
s + s2
# 同时，Series提供了用于计算的方法，例如add，multiply等，方法没有运算符简便，但是，方法可以提供更多的行为，可以指定fill_value参数，当索引无法匹配时，使用fill_value进行填充。
s.add(s2, fill_value=100)

# ndarry提供的统计函数，rum,mean等，也适用于Sreies类型。
# ndarry数组与Series在计算时，对控制的处理不太相同，对于ndarry数组会产生空值，对于Serise,会忽略空值。
s = pd.Series([1,2,3,4,np.NaN])
a = np.array([1,2,3,4,np.NaN])
print(np.sum(a))    # 10
print(np.sum(s))    # NaN

# Series也支持切片操作
s[0:2]
#根据标签数组与布尔数组提取元素。
s[[True, False, True]]

• 支持广播与矢量化运算
• 支持索引与切片
• 支持整数数组与布尔数组提取元素

标签索引与位置索引

通过index指定的标签就是标签索引，除此之外，每个元素在创建时，都有相应的位置，该位置的顺序就是位置索引。

当Series标签时数值类型时，位置索引会失效，不是时，通过Series对象（索引）访问元素，索引既可以是标签索引，也可以是位置索引，这会在一定程度上造成混淆，因此，不建议使用Series对象（索引）的方式访问元素。

# 为了能够没有歧义的访问元素，推荐使用loc与iloc进行访问元素
# loc专门针对标签索引进行访问。
# ilo专门针对位置索引进行访问。
s = pd.Series([1,2,3], index=['a','b','c '])
s.loc["a"]
s.loc[1] # 错误，loc不能通过位置访问元素
s.iloc(1)
s.iloc('a') # 错误，iloc不能通过位置索引访问元素
# 不建议，老版本中，会使用ix访问元素，它会先通过标签索引寻找元素，如果不存在，再通过位置索引寻找元素。
s.ix["a"]

切片

# 不建议使用Sreies对象（切片）的形式提取元素
# 建议使用loc与iloc的方式进行切片
a = np.array([1,2,3,4])
a[0:2] # array([1,2])
#Series切片，标签索引与位置索引时存在区别的
# 位置索引切片，包含起始点不包含终止点
# 标签索引切片，包含起始点和终止点
s = pd.Series([1,2,3,4], index=["a","b","c","d"])
s.iloc[0:2]   [1,2]
s.loc["a":"c"]   [1,2,3]

Series的CRUD

# 因为Series内部也是基于Mapping映射的形式，因此，其与字典的特征类似

s = pd.Series([1,2,3], index=list("abc"))
# 获取值
s.loc["a"]
# index存在修改，不存在添加
s.loc["a"] = 100
s.loc["e"] = 200
# 删除值,是创建一个新的对象并没有修改原有的Series对象
s = s.drop(["b"])
# 删除多个值
s = s.drop(["a", "b", "c"])
# 如果需要就地修改对象，而不是创建一个新的对象，可以将inplace参数设置为True。（默认为False）
# 所有API种，只要含有inplace， 该参数的默认值一律为False。
# 如果方法（函数）含有inplace，并且，我们将inplace参数指定为True，则该方法（函数）返回值为None
s.drop("a", inplace=True)

二、Dataframe

pandas的另一种数据类型，类似于Excel表格有多列组成，每个列的类型可以不同。

创建Dataframe
我i们可以通过（常用）：

• 二维数组结构（列表，ndarry数组，DataFrame等）类型
• 字典类型，key为列名，value为一维数组结构（列表，ndarry数组，Series等）。
  说明：
• 如果没有显示指定行与列，则会自动生虫从0开始的整数值索引，可以在创建DataFrame时，通过index和columns参数指定。
• 可以通过head/tail访问前/后N行记录（数据）。

import numpy as np
import pandas as pd
from pandas import Series, DataFrame
# 通过列表创建
df = pd.DataFrame([11,21,31],[41,51,61])
print(dy)isplay(dy)
# display与print类似，在jupyter noteboook部分类型输出会有梅花的效果，
# display时IPython所扩展的函数，Python种事没有的。
# display方法输出的结果与直接对对象进行求指，展示在交互式控制台上的结果事相同的（Out中展示的内容），但是直接求值得方式，只能显示最后一个结果。

# 通过字典创建,字典的每组键值对表示一个列，键值对得key用来指定列索引，键值对得value用来指定该列的值。
df = pd.DataFrame(["A":[10,20,30],"B":[2.5,3.5,1.5],"C":["a","b","c"],"D":8])
display(df)

# head/tail
df = pd.DataFrame(np.random.random((20,10)))
df.head()
# 随便显示N条记录。
# np.random.randint()
# sample方法实现随机抽样，可以指定抽样得记录条数，默认为1
# sample默认为不放回抽样（此时抽样得数量不能大于样本得数量），我们可以通过将replace参数设置为True（放回抽样）。
df.sample(25，raplace=True)
# 我们可以设置random_state参数，来重现（复制）抽样得序列（该参数就是设置随机种子）。
df.sample(5, random_state=20)

相关属性

• index
• columns
• values
• shape
• ndim # 维度
• dtype # 与二维数组不同，ndarry会根据数组中所元素得类型来决定一种兼容得类型，对于DataFrame类似于数据库中得二维表，每一列都有单独的类型，列于列之间不受干扰。 dtypes返回每一列得类型。
  df.dtypes.loc[“A”]

# 设置行索引与列索引
df.index.name = "行索引名称"
df.columns.name = "列索引名称"

DataFrame相关操作

列操作

• 获取列
  • df[列索引]
  • df.列索引
• 增加（修改）列：df[列索引] = 列数据
• 删除列
  • del df[列索引]
  • df.pop(列索引)
  • df.drop(列索引或数组)

行操作

• 获取列
  • df.loc
  • df.iloc
  • df.ix
• 增加行: append【多次使用append增加行会比链接计算量更大，可考虑使用pd.concat来代替】
• 删除行
  • df.drop(行索引或数据)

# 获取列
df = pd.DataFrame(["A":[10,20,30],"B":[2.5,3.5,1.5],"C":["a","b","c"],"&":[1,2,3]])
# 建议使用第一种方式，第二种方式，要求标签名必须是Python中合法的标识符才可以
df["&"]
df.&   # 报错

# 增加列
df["D"] = [10,20,30]
# 修改一列
df["A"] = [10,20,30]

# 通常，我们不会人为得去指定数据增加或修改，而是通过现有的数据计算产生的
df = pd.DataFrame(["苹果":[1,2,3],"香蕉":[4,5,6],"葡萄":[7,8,9],index=["1月","2月"]])
df["总和"] = df["苹果"] + df["香蕉"] + df["葡萄"]
df["年龄"] = df["年龄"] + 1

#删除列
del df["苹果"]
df.pop("苹果")
df.drop(["苹果","香蕉"], axis=1, inplace=True)

# 获取行
df.loc["1月"]
df.iloc[1]
df.ix[] # 不建议使用

# append加入Series时，Series对象需要具有name属性
row = pd.Series([50,60,70],name='4月',index=["苹果","葡萄","香蕉"])
df.append(row)
#指定ignore_index为True，则会重新生成从0开始，依次增1的索引（默认形式的索引），此时，Series可以没有name属性。
df.append(row, ignore_index=True)

# append加入另外一个DataFrame(加多行)
df.append(rows, ignore_index=True)

# 再增加多行的时候，建议使用concat，性能方面比append好些。
pd.concat((df1, df2),axis=0,ignore_index=True)
pd.concat((df1, df2),axis=1,ignore_index=True)

# 删除行
df.drop("1月",axis=0,inplace=True)
# 删除多行
df.drop(["1月","2月"]，inplace=True)

行列混合操作

# 先获取行，在获取列
df.loc["1月"].loc["苹果"]
# 先获取列，后获取行
df["苹果"].loc["1月"]

df[["苹果","葡萄"]].loc[["1月","2月"]]

#注意获取行列时，数据的返回类型。当我们单独提取一行（一列）的时候，返回Sreies类型，当我们使用切片提取元素时，返回的是DataFrame类型，即使切片只提取一行（一列）的数据，也是如此。
display(type(df.iloc[0])) # Series
display(type(df.iloc[0:1]))  # DataFrame

# df[索引]永远访问的是某列，并且，索引只支持标签索引，不支持位置索引，因此，这样访问方式不会产生歧义。
df[0]
# df[切片]是对行进行的操作，而且切片即支持标签索引，也支持位置索引。故这样的方式，行为容易混淆，不建议使用
# 建议使用df.loc或df.iloc[切片]
df[0:2]

#通过变迁数组提取元素。可以访问（返回）多个列。
df[["苹果","葡萄"]]
# 通过布尔数组提取元素，可以访问（返回）多个行
df[[True,Fales,True]]

DataFrame结构

DataFrame的一行或一列，都是Series类型的对象，对于行来说，Series对象的name属性值就是行索引名称，其内部元素的值，就是对应的列表索引名称，对于列表来说，Series对象的name属性值就是列索引名称，其内部元素的值，就是对应的行索引名称。

df = pd.DataFrame(["苹果":[1,2,3],"香蕉":[4,5,6],"葡萄":[7,8,9],index=["1月","2月"]])

DataFrame运算

DataFrame的一行或一列都是Series类型的对象,因此，DataFrame可以近似看做是多行或多列的Series构成的，Series对象支持的很对操作，对于DataFrame对象也同样使用，我们可以参考Series对象的操作。

df = pd.DataFrame(np.arange(12).reshape(3,4))
# 实现矩阵的转置
# df.T
df2 = pd.DataFrame(np.arange(12,24).reshape(3,4))
# 在DataFrame运算时，会根据行与列两个索引进行对其运算，如果无法匹配，则会产生空值NaN.
df + df2
df.add(df2, fill_value=0)

s = pd.Series([100,200,300], index=[0,1,2])
# 如果使用DataFrame与Series进行计算，默认情况下，Series的标签匹配DataFrame的列表前。
df + s
# 吐过需要匹配DataFrame的行标签，可以使用方法进行计算，同时指定axis的值为index或0
df.add(s, axis='index/0')

排序

索引排序

Series与DataFrame对象可以使用sort_index方法对索引进行排序。Dataframe对象在排序时，还可以通过asix参数来指定轴（行索引还是列索引）。也可以通过ascending参数指定升序还是降序。

值排序

Series与DataFrame对象可以使用sort_values方法对值进行排序。

df = pd.DataFrame([[1,-5,3],[-5,2,4],[9,6,-3]],index=[-2,1,-3],columns=[-2,1,-3])
# 对索引进行排序。通过axis指定对行标签（0）还是列标签（1）排序，默认值为0.
# 可以指定ascending。设置是否升序排列，默认为True（升序排列）
df.sort_index(axis=1，ascending=False)

# 对值进行排序,axis指定行标签还是列标签
# 如果需要就地修改，将inplace参数指定为True
df.sort_values(-2,axis=0,inplace=True)

索引对象

Series（DataFrame）的index或者DataFrame的columns就是一个索引对象。

• 索引对象可以像数组那样进行索引访问。
• 索引对象时不可修改的

统计相关方法

得到的不是一个标量，是对行或者列进行计算

• mean/sum/count
• max/min
• cumsum/cumprod
• argmax/argmin
• idxmax/idxmin
• var/std # 方差/标准差
• corr/cov #相关性/协方差

df.mean(axis=0)
df.madian()
s = pd.Ser ies([1,-5,3,4,0,4])
# s.argmax()与idxmax作用相同，在pandas中，argmax不建议使用，以用idxmax代替
s.argmax() # 最大元素的索引位置
s.idxmax()
df = pd.DataFrame(np.random.rand(10,5))
# 相关系数（正相关，负相关）
df.corr()

其他

• unique
• value_counts

s = pd.Series([1,10,-2,-5,20,10,-5])
# 去掉重复的元素，但是没有排序的功能（与numpy中ndarray数组的方法行为不太一样）
s.unique()
# 返回Series中每个值出现的次数。（默认降序排序）
s.value_counts()
# ascending参数来指定升序排列。
s.value_counts(ascending=True)

# 方法一：
import webbrowser
link = "https://www.tiobe.com/tiobe-index/"
webbrowser.open(link) # 通过webbrowser库打开一个网页
# 粘贴复制之后通过read_clipboard创建Dataframe
df = pd.read_clipboard()
type(df) # pandas.core.frame.DataFrame

df.columns # 显示Dataframe的index
# Index(['index1', 'index2', 'index3'],dtype='object')
df.index1  # 通过index显示指定列的数值


# 方法二
df_new = Dataframe(df, columns=['index1', 'index2'])  # 通过指定columns创建新的Dataframe
df['index1']  # 字典的形式显示指定列
type,-(df['index1'])  # 类型为Series
# pandas.core.series.Series

# 方法三
df_new = DataFrame(df, columns=['index1', 'index2', 'index3'])  # 添加新的列没有值自动填补NaN
df_new['index3'] = range(20) # 赋值
df_new['index3'] = pd.Series(np.arange(0, 20))
df_new['Sep 2018'] = pd.Series([100, 200], index=[1, 2])  # 指定行赋值

数据处理过程

1.明确自己的需求
2.获取数据

• 公司数据库
• 花钱买
• 爬虫
• 调查问卷

3.读取载入数据

• 数据的预处理
  • 数据清洗
    缺失值
    （丢弃、填充（平均值、中位数、邻近值）、搁置）
    异常值
    （丢弃、规整）
    重复值
    （去除）
  • 可视化（可选项）
    做报告图文并茂
• 数据建模

one-hot encoding
归一化（0~1）
（当前值-最小值）/（最大值-最小值）
标准化（在0上下浮动，0均值化）
（当前值-均值）/标准差
特征缩放

训练集

• 训练集（主要训练权重）
• 验证集（去验证模型）

测试集

三、深入理解Series和Dataframe

• 一个Dataframe可以看成多个Series组成

# 通过字典创建Series
data = {'Country': ['Belgium', 'India', 'Brzil'], 'Capital': ['Brussels', 'New Delhi', 'Brasilia'], 'Population':[11190846,130317035,207847528]}
s1 = pd.Series(data['Country'], index=['A','B','C'])  

df1 = pd.DataFrame(data)

最后

以上就是伶俐短靴为你收集整理的Pandas入门一、Series二、Dataframe数据处理过程三、深入理解Series和Dataframe的全部内容，希望文章能够帮你解决Pandas入门一、Series二、Dataframe数据处理过程三、深入理解Series和Dataframe所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。