pandas怎么查看数据,索引设置_pandas查看列名和索引

pandas怎么查看数据,索引设置_pandas查看列名和索引

       大家好，今天我想和大家分享一下我在“pandas怎么查看数据,索引设置”方面的经验。为了让大家更好地理解这个问题，我将相关资料进行了整理，现在就让我们一起来学习吧。

1.Python其实很简单 第十九章 Pandas之Series与DataFrame

2.pandas索引取数

3.Pandas介绍

4.pandas将某一行设置为列索引（python）

5.Pandas选取行，列总结

Python其实很简单 第十九章 Pandas之Series与DataFrame

        19.1安装Anaconda

        Anaconda是Python的一个开源发行版本，它预装了丰富的第三方库，而且主要面向科学计算和数据分析，使用起来要比原版的Python更省时省力。

        Anaconda官方下载网址为：https://www.continuum.io/downloads。下载和安装的方法很简单，若有问题可以在网上搜索相关内容学习解决。

        安装Anaconda之后，就会发现在Anaconda目录下同时安装了Jupyter Notebook、Spyder等工具，我们接下来主要使用Spyder进行开发。关于Spyder的使用方法非常简单，大家也可以去网上搜索学习。

        虽然Anaconda已经预装了很多常用的包，但有时我们也需要自己安装一些包。可以在开始菜单中选择“Anaconda Anaconda Prompt”命令，在命令行输入conda install （ 代表包名）即可安装，也可以输入pip install 。

        19.2数据分析包Pandas

        Pandas是Python的一个数据分析包，Anaconda安装时已经附带安装了Pandas包。

        Pandas数据结构有三种：Series（一维数组）、DataFrame（二维数组）和Panel（三维数组），其中最常用的是前两种数据结构。

        19.2.1 Series

        Series（序列）用于存储一行或一列数据，以及与之相关的索引的集合。

        语法格式如下：

        Series([数据1，数据2，......], index=[索引1,索引2,......])

        例：

        from pandas import Series

        s=Series(['张三','李四','王五'],index=[1,2,3])

        print(s)

        输出结果如下：

        1 张三

        2 李四

        3 王五

        dtype: object

        上面建立序列时指定了索引，若不指定，则默认的索引值从0开始。如下：

        s=Series(['张三','李四','王五'])

        输出结果为:

        0 张三

        1 李四

        2 王五

        dtype: object

        索引值也可以为字符串。如下：

        from pandas import Series

        s=Series(['张三','李四','王五'],index=['A','B','C'])

        print(s)

        输出结果为：

        A 张三

        B 李四

        C 王五

        dtype: object

        1、访问序列

        （1）可以通过索引访问序列，如：

        from pandas import Series

        s=Series(['张三','李四','王五'])

        print(s)

        print(s[0])

        print(s[1:])

        运行结果如下：

        0 张三

        1 李四

        2 王五

        dtype: object #print(s)输出

        张三 #print(s[0])输出

        1 李四

        2 王五

        dtype: object #print(s[1:])输出

        （2）通过值获取索引值

        from pandas import Series

        s=Series(['张三','李四','王五'],index=['A','B','C'])

        print(s.index[s.values=='李四'])

        运行结果：

        Index(['B'], dtype='object')

        （3）判断值是否存在

        from pandas import Series

        s=Series(['张三','李四','王五'],index=['A','B','C'])

        f='李四' in s.values

        print(f)

        运行结果：

        True

        （4）定位获取

        from pandas import Series

        s=Series(['张三','李四','王五','孙六'],index=['A','B','C','D'])

        print(s[[0,2,1]])

        运行结果：

        A 张三

        C 王五

        B 李四

        dtype: object

        2、修改序列

        （1）追加序列，如：

        from pandas import Series

        s=Series(['张三','李四','王五'],index=['A','B','C'])

        s1=Series(['孙六'],index=['D'])

        s=s.append(s1)

        print(s)

        运行结果：

        A 张三

        B 李四

        C 王五

        D 孙六

        dtype: object

        （2）修改序列的值

        from pandas import Series

        s=Series(['张三','李四','王五','孙六'],index=['A','B','C','D'])

        s[1]='李飞'

        print(s)

        运行结果：

        A 张三

        B 李飞

        C 王五

        D 孙六

        dtype: object

        不知道索引，仅知道要修改的值，也可通过值查找到索引后，再修改序列的值。如：

        s[s.index[s.values=='李四']]='李飞'

        这样也可以将“李四”修改为“李飞。

        （3）修改索引

        from pandas import Series

        s=Series(['张三','李四','王五','孙六'],index=['A','B','C','D'])

        s.index=[0,1,2,3]

        print(s)

        运行结果：

        0 张三

        1 李四

        2 王五

        3 孙六

        dtype: object

        （4）删除元素

        from pandas import Series

        s=Series(['张三','李四','王五','孙六'],index=['A','B','C','D'])

        s=s.drop('A')

        print(s)

        运行结果：

        B 李四

        C 王五

        D 孙六

        dtype: object

        （5）重新排序

        可以按照索引排序，使用sort_index(ascending=True)方法对index进行排序操作。

        from pandas import Series

        s=Series(['张三','李四','王五','孙六'],index=['A','B','C','D'])

        s=s.sort_index(ascending=False) # ascending=False表示按降序排列

        print(s)

        运行结果：

        D 孙六

        C 王五

        B 李四

        A 张三

        dtype: object

        （6）重置索引

        重置索引可以使用reindex()。如果index列表中的元素多于序列的值，可用fill_value=0这样的语句填充。

        s=s.reindex(['D','C','B','A'])

        如果index列表中的元素多于序列的值，可用fill_value=0这样的语句填充。

        s=s.reindex(['D','C','B','A'], fill_value=0)

        19.2.2 DataFrame

        DataFrame（数据框架）用于存储多行和多列的数据集合。它是Series的容器，类似于Excel中二维表格。

        定义一个DataFrame的语法格式如下：

        df=DataFrame({列名1 : 序列1，列名2 : 序列2，.......列名n : 序列n}, index=序列 )

        例如，有如下二维表：

        姓名

        性别

        年龄

        张三

        男

        18

        李四

        女

        19

        王五

        男

        17

        保存到DataFrame中可以用如下方法：

        from pandas import Series

        from pandas import DataFrame

        name=Series(['张三','李四','王五'])

        sex=Series(['男','女','男'])

        age=Series([18,19,17])

        df=DataFrame({'姓名':name,'性别':sex,'年龄':age})

        print(df)

        运行结果：

        姓名 性别 年龄

        0 张三 男 18

        1 李四 女 19

        2 王五 男 17

        从上例可以看出，虽然我们省缺了索引，但系统自动添加了从0开始的索引值。

        19.3 DataFrame的基本操作

        1、访问方式

        （1）获取行

        print(df[1:2]) # 获取第1行的值

        输出结果：

        姓名 性别 年龄

        1 李四 女 19

        print(df[1:3]) #获取第1行到第2行的值

        输出结果：

        姓名 性别 年龄

        1 李四 女 19

        2 王五 男 17

        （2）获取列

        print(df['姓名']) #获取“姓名”列的值

        输出结果：

        0 张三

        1 李四

        2 王五

        Name: 姓名, dtype: object

        另一种方法：

        print(df[df.columns[0:1]]) #先按照索引号获取列名，再按照列名读取

        输出结果和上面的方法完全一致。

        还有一种情况，是获取唯一值，即将列内的重复值中多余的删除，仅留下互不相同的值。所用的到方法是unique()。

        sex1=Series(df['性别'].unique())

        print(sex1)

        输出结果：

        0 男

        1 女

        dtype: object

        （3）获取指定位置的值

        print(df.at[1,'姓名']) # 格式为变量名.at[行号，列名]

        输出结果：

        李四

        （4）获取块的值

        print(df.iloc[0:2,1:3]) # 格式为变量名.iloc[行号1:行号2, 列号1:列号2]

        输出结果：

        性别 年龄

        0 男 18

        1 女 19

        print(df.iloc[:,1:2]) #获取“性别”列的值

        运行结果：

        性别

        0 男

        1 女

        2 男

        2、修改、删除、增加行和列

        （1）修改列名

        print(df.columns)

        df.columns=['name','sex','age']

        print(df.columns)

        输出结果：

        Index(['姓名', '性别', '年龄'], dtype='object')

        Index(['name', 'sex', 'age'], dtype='object')

        可见，列名已经由“姓名、性别、年龄”修改为“age、sex、age”了。但这种修改必须把全部列名都一一列举，不能有遗漏，否则就会出错。如：

        df.columns=['name','sex']

        此时会报错：ValueError: Length mismatch: Expected axis has 3 elements, new values have 2 elements。

        （2）修改行索引

        df.index=[1,2,3]

        （3）删除行

        df.drop(1,axis=0) # axis=0表示行轴，也可以省略

        （4）删除列

        df.drop(‘性别’,axis=1) # axis=0表示列轴

        也可以使用另一种方法：

        del df['性别']

        （5）增加列

        df['电话']=['1111111','2222222','3333333']

        print(df)

        运行结果：

        姓名 性别 年龄 电话

        0 张三 男 18 1111111

        1 李四 女 19 2222222

        2 王五 男 17 3333333

        （6）增加行

        df.loc[len(df)]=['孙六','男','20']

        （7）追加

        from pandas import Series

        from pandas import DataFrame

        name=Series(['张三','李四','王五'])

        sex=Series(['男','女','男'])

        age=Series([18,19,17])

        df=DataFrame({'姓名':name,'性别':sex,'年龄':age}) # 建立DataFrame，变量名为df

        name1=Series(['孙六','候七'])

        sex1=Series(['男','女'])

        age1=Series([19,17])

        df1=DataFrame({'姓名':name1,'性别':sex1,'年龄':age1})

        # 建立DataFrame，变量名为df1

        df=df.append(df1,ignore_index=True)

        # 将对df1追加到df后面，参数ignore_index=True表示重新索引

        print(df)

        运行结果：

        姓名 性别 年龄

        0 张三 男 18

        1 李四 女 19

        2 王五 男 17

        3 孙六 男 19

        4 候七 女 17

pandas索引取数

        导入 Pandas：

        查看 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)，可以通过多种方式进行创建，以下介绍了 3 个常用方法。

从列表创建 Series：

        从 Ndarray 创建 Series：

        从字典创建 Series：

        修改 Series 索引：

        Series 纵向拼接：

        Series 按指定索引删除元素：

        Series 修改指定索引元素：

        Series 按指定索引查找元素：

        Series 切片操作：

        Series 加法运算：

        Series 的加法运算是按照索引计算，如果索引不同则填充为 NaN（空值）。

        Series 减法运算：

        Series的减法运算是按照索引对应计算，如果不同则填充为 NaN（空值）。

        Series 乘法运算：

        Series 的乘法运算是按照索引对应计算，如果索引不同则填充为 NaN（空值）。

        Series 除法运算：

        Series 的除法运算是按照索引对应计算，如果索引不同则填充为 NaN（空值）。

        Series 求中位数

        Series 求和：

        Series 求最大值：

        Series 求最小值：

        与 Sereis 不同，DataFrame 可以存在多列数据。一般情况下，DataFrame 也更加常用。

通过 NumPy 数组创建 DataFrame：

        通过字典数组创建 DataFrame：

        查看 DataFrame 的数据类型：

        预览 DataFrame 的前 5 行数据：

        查看 DataFrame 的后 3 行数据：

        查看 DataFrame 的索引：

        查看 DataFrame 的列名：

        查看 DataFrame 的数值：

        查看 DataFrame 的统计数据：

        DataFrame 转置操作：

        对 DataFrame 进行按列排序：

        对 DataFrame 数据切片：

        对 DataFrame 通过标签查询（单列）：

        对 DataFrame 通过标签查询（多列）：

        对 DataFrame 通过位置查询：

        DataFrame 副本拷贝：

        判断 DataFrame 元素是否为空：

        添加列数据：

        根据 DataFrame 的下标值进行更改。：

        根据 DataFrame 的标签对数据进行修改：

        DataFrame 求平均值操作：

        对 DataFrame 中任意列做求和操作：

        将字符串转化为小写字母：

        将字符串转化为大写字母：

        对缺失值进行填充：

        删除存在缺失值的行：

        DataFrame 按指定列对齐：

        CSV 文件写入：

        CSV 文件读取：

        Excel 写入操作：

        Excel 读取操作：

        建立一个以 2018 年每一天为索引，值为随机数的 Series：

        统计s 中每一个周三对应值的和：

        统计s中每个月值的平均值：

        将 Series 中的时间进行转换（秒转分钟）：

        UTC 世界时间标准：

        转换为上海所在时区：

        不同时间表示方式的转换：

        创建多重索引 Series：

        构建一个 letters = ['A', 'B', 'C'] 和 numbers = list(range(10))为索引，值为随机数的多重索引 Series。

        多重索引 Series 查询：

        多重索引 Series 切片：

        根据多重索引创建 DataFrame：

        创建一个以 letters = ['A', 'B'] 和 numbers = list(range(6))为索引，值为随机数据的多重索引 DataFrame。

        多重索引设置列名称：

        DataFrame 多重索引分组求和：

        DataFrame 行列名称转换：

        DataFrame 索引转换：

        DataFrame 条件查找：

        查找 age 大于 3 的全部信息

        ** 根据行列索引切片：**

        DataFrame 多重条件查询：

        查找 age<3 且为 cat 的全部数据。

        DataFrame 按关键字查询：

        DataFrame 按标签及列名查询。：

        DataFrame 多条件排序：

        按照 age 降序，visits 升序排列

        DataFrame 多值替换：

        将 priority 列的 yes 值替换为 True，no 值替换为 False。

        DataFrame 分组求和：

        使用列表拼接多个 DataFrame：

        找出 DataFrame 表中和最小的列：

        DataFrame 中每个元素减去每一行的平均值：

        DataFrame 分组，并得到每一组中最大三个数之和：

        当分析庞大的数据时，为了更好的发掘数据特征之间的关系，且不破坏原数据，就可以利用透视表 pivot_table 进行操作。

透视表的创建：

        新建表将 A, B, C 列作为索引进行聚合。

        透视表按指定行进行聚合：

        将该 DataFrame 的 D 列聚合，按照 A,B 列为索引进行聚合，聚合的方式为默认求均值。

        透视表聚合方式定义：

        上一题中 D 列聚合时，采用默认求均值的方法，若想使用更多的方式可以在 aggfunc 中实现。

        透视表利用额外列进行辅助分割：

        D 列按照 A,B 列进行聚合时，若关心 C 列对 D 列的影响，可以加入 columns 值进行分析。

        透视表的缺省值处理：

        在透视表中由于不同的聚合方式，相应缺少的组合将为缺省值，可以加入 fill_value 对缺省值处理。

        在数据的形式上主要包括数量型和性质型，数量型表示着数据可数范围可变，而性质型表示范围已经确定不可改变，绝对型数据就是性质型数据的一种。

绝对型数据定义：

        对绝对型数据重命名：

        重新排列绝对型数据并补充相应的缺省值：

        对绝对型数据进行排序：

        对绝对型数据进行分组：

        缺失值拟合：

        在FilghtNumber中有数值缺失，其中数值为按 10 增长，补充相应的缺省值使得数据完整，并让数据为 int 类型。

        数据列拆分：

        其中From_to应该为两独立的两列From和To，将From_to依照_拆分为独立两列建立为一个新表。

        字符标准化：

        地点的名字都不规范（如：londON应该为London）需要对数据进行标准化处理。

        删除坏数据加入整理好的数据：

        将最开始的 From_to 列删除，加入整理好的 From 和 to 列。

        去除多余字符：

        如同 airline 列中许多数据有许多其他字符，会对后期的数据分析有较大影响，需要对这类数据进行修正。

        格式规范：

        在 RecentDelays 中记录的方式为列表类型，由于其长度不一，这会为后期数据分析造成很大麻烦。这里将 RecentDelays 的列表拆开，取出列表中的相同位置元素作为一列，若为空值即用 NaN 代替。

        信息区间划分：

        班级一部分同学的数学成绩表，如下图所示

        但我们更加关心的是该同学是否及格，将该数学成绩按照是否>60来进行划分。

        数据去重：

        一个列为A的 DataFrame 数据，如下图所示

        尝试将 A 列中连续重复的数据清除。

        数据归一化：

        有时候，DataFrame 中不同列之间的数据差距太大，需要对其进行归一化处理。

        其中，Max-Min 归一化是简单而常见的一种方式，公式如下:

        Series 可视化：

        DataFrame 折线图

        DataFrame 散点图

        DataFrame 柱形图

Pandas介绍

       注：《利用python进行数据分析》的学习笔记-pandas

        import pandas as pd

        import numpy as np

        一维数组，包含一个数组对象，一个索引对象，索引对象默认为0开始的递增数字，可通过index=[idx1, idx2, ...]参数指定

        可通过索引选取/修改相应的数据，选取：data=series[idx], 修改：series[[idxm, idxn, ...]]=[dm, dn, ...]

        series可看成定长有序字典，索引到数据的映射，series可用于字典参数的函数中。idxn in series返回True/False

        多个series做算术操作，会自动对齐不同索引的数据，无此数据自动填充NaN

        可看作多个series组成的表单，dataframe有两种索引，与series相同的index行索引，还有columns列索引

        选取/修改一行数据dataframe.loc['index']

        选取/修改一列数据dataframe['column'], dataframe.column

        obj.reindex(newIndex) #适用于series与dataframe

        obj.reindex(index=newIndex, columns=newcolumns) #dataframe需对行索引列索引都重新索引时

        obj.reindex(index=newindex, columns=newcolumns, fill_value=100) #指定填充值，不指定时填充NaN

        obj.reindex(index=newindex, columns=newcolumns, fill_value=100, method='ffill') ? #指定填充方法ffill/pad(前向填充),bfill/backfill(后向填充)

        obj=obj.drop(index, axis=0)

        obj=obj.drop([col1, col2, ...], axis=1)

        axis默认为0，删除列数据时指定axis为1

        series

        obj = pd.Series(range(5), index=list('abcde'))

        取单数obj[2]， ? obj['c']

        切片取数 obj[2:5]，obj['a':'c']

        不连续取数obj[1,3]，obj['a','c','d']

        过滤 obj[obj>2],

        修改 obj[3]=0,

        注：series切片不用于python数据结构的切片，series的切片包含末端，即python:[start, end), series:[start, end]

        dataframe

        obj = pd.DataFrame(np.arange(15).reshape((3,5)),

        index = ['one', 'two', 'three'],

        columns = list('abcde') )

        取单列 ?obj.loc[:, 'c'], ?obj.iloc[:, 2], obj.xs('c', axis=1), obj['c']，?

        取单行 ?obj.loc['one'], obj.iloc[1],obj.xs('one', axis=0),?

        取连续行 ?obj.loc['one':'three'], ? obj.iloc[1:3], obj[:2],?

        取连续列 ?obj.loc[:, 'b':'d'], ?obj.iloc[:, 2:4],

        取不连续行 ?obj.loc[['one','three']] ?obj.iloc[[0,2]],

        取不连续列 ?obj.loc[:, ['b', 'e']] obj.iloc[:, [1,4]],

        取单行单列 ?obj.loc['two', 'd'] ?obj.iloc[2, 4]

        取连续行列 ?obj.loc['one':'three', 'b':'d'] ? obj.iloc[:2, 2:4]

        取不连续行列? obj.loc[['one','three'], ['b':'d']] ?obj.iloc[[0,2], [1,4]]

        根据列值过滤行 ? obj.loc[obj['c']%2==0, :] ?

       ******此处吐个槽，这个切片方法一会儿只能取单列，一会儿只能取连续行，一会儿包含终止项，一会儿不包含，我人都傻了...

        ******loc/iloc方法接收两个参数，第一个是行，第二个是列，都可切片，也都可指定索引，列参数可以不写，默认取所有列数据

        ******下面总结下这个花哨的切片！

       dataframe有两种索引，行索引/列索引。每种索引包含两类用法，索引名称(对应df.loc)/索引下标对应(df.iloc)

        ① df[columnName] ?取单列数据，只能用列名，不能使用列下标，不能用于取单行

        ② df[lineName1: lineName2] ? 取连续行数据，使用行名时，包含末尾项，即[start，end]

        ③ df[lineIndex1: lineIndex2] 取连续行数据，使用行下标时，不包含末尾项?，即[start，end)

        ④ df.loc['line2':'line4']?取连续行数据，使用行名时，包含末尾项，即[start，end]?

        ⑤ df.iloc[2:4]取连续行数据，使用行下标时，不包含末尾项?，即[start，end)?

        ⑥df.loc[:,?columnName1:columnName2] ? 取连续列，使用列名时，包含末尾项，即[start，end]

        ⑦ df.iloc[:, columnIndex1:columnIndex2] 取连续列，使用列下标时，不包含末尾项，即[start，end)

        ⑧ df.loc[[lineName1, ...], [columnName1, ...]] 使用行名/列名取不连续行列

        ⑨ df.iloc[[lineIndex1, ...], [columnIndex1, ...]] ?使用行下标/列下标取不连续行列

       以前用的时候总觉得奇奇怪怪的，花了一下午时间一个一个尝试终于捋顺了，欧耶！ (〃￣︶￣) 人 (￣︶￣〃)

       DataFrame直接切片，即df[args]，可用于指定列名取单列数据，可用于指定行名/行下标取连续多行数据

        取单行数据不可直接切片，需使用loc/iloc方法

        DataFrame.loc(line, column) 用于按索引名称取行/列数据，此时，首尾项都会被取出

        ?参数line指定行索引名称，参数2指定列索引名称（可省略，默认选取所有列）。

        DataFrame.iloc(line, column) 用于按索引下标取行/列数据，此时，尾项数据不会被取出

        ? 参数line指定行索引下标，参数2指定列索引下标（可省略，默认选取所有列）。

pandas将某一行设置为列索引（python）

        首先，需要先安装numpy和pandas环境，参考： https://pandas.pydata.org/

        。以下语句检查并确认安装成功。

        Pandas 有三种基本数据结构：Series、DataFrame 和 Index。

        Pandas 的 Series 对象是一个带索引数据构成的一维数组。Series 对象将一组数据和一组索引绑定在一起，我们可以通过 values 属性和 index 属性获取数据。values 属性返回的结果与 NumPy 数组类似；index 属性返回的结果是一个类型为 pd.Index 的类数组对象。

        可以像访问Numpy那样来访问Series（序号也是从0开始计数的）。

        Pandas 的 Series 对象比Numpy更加灵活、通用。

        两者的主要区别是：NumPy 数组通过隐式定义 的整数索引获取数值，而 Pandas 的 Series 对象用一种显式定义 的索引与数值关联。也就是说，Numpy的索引是系统自分配的无法更改，但是Series对象是可以手工指定的。

        Series是特殊的字典 ，Series 对象其实是一种将类型键映射到一组类型值的数据结构，Pandas Series 的类型信息使得它在某些操作上比 Python 的字典更高效。用字典创建 Series 对象时，其索引默认按照顺序排列 。

        DataFrame类似于RDBMS中的Table。DataFrame就可以看作是一种既有灵活的行索引，又有灵活列名的二维数组。

        DataFrame有2个常用属性，分别是index 属性 和columns 属性 。前者可以获取索引标签（行标签）；后者是是存放列标签的Index 对象。DataFrame 是特殊的字典，一列映射一个Series 的数据。

        DataFrame可以通过以下几种方式来创建：（1）通过单个 Series 对象创建。（2）通过字典列表创建。（3）通过 Series 对象字典创建。（4）通过NumPy 二维数组创建。（5）通过 NumPy 结构化数组创建。

        可以将Index视为一个不可变数组或有序集合。当作为不可变数组时，一般数组的访问方式（例如切片等）对Index适用，与数组的最大区别是Index对象不可更改 。当作为集合时，Index也可以做交集、并集等常规操作。

        Series的访问既可以作为字典，也可以作为一维数组。数据访问的方法，可以参考Numpy的访问方式，这里不赘述。

        如果Series的显式索引是整数，那么在访问时，很容易混淆。例如下边的例子：

        从上边的例子总结得出，python的默认规则是：在单个访问时，使用的显式索引，而在切片时，使用的是隐式索引，很容易混淆！python提供了loc、iloc和ix三种索引器。

        loc表示：表示取值和切片都是显式的。iloc 属性，表示取值和切片都是隐式索引。ix是loc和iloc的混合形式，应用于dataFrame（使用例子在3.3节）。

        dataframe可以通过对列名进行字典形式（dictionary-style）的取值获取数据。可以把 DataFrame 看成是一个增强版的二维数组，用 values 属性按行查看数组数据。ix 索引器对于整数索引的处理和之前在 Series 对象中介绍的一样，都容易让人混淆。

        对于一元运算（像函数与三角函数），这些通用函数将在输出结果中保留索引和列标签（很简单，所有元素做相应运算并返回）；而对于二元运算（如加法和乘法），Pandas 在传递通用函数时会自动对齐索引 进行计算。

        当在两个 Series 或 DataFrame 对象上进行二元计算时，Pandas 会在计算过程中对齐两个对象的索引。如果想给缺失数值指定一个默认值，需要使用add来替代+，并指定fill_value：

        两个对象的行列索引可以是不同顺序的，结果的索引会自动按顺序排列。

        DataFrame 和 Series 的运算规则，与NumPy 中二维数组与一维数组的运算规则是一样的。需要使用广播原则，那么默认地，会按行计算。如果想要按列运算，需要使用参数axis = 0 。

        注意：DataFrame访问行可以使用loc，但是访问列，只能是df['col']这种形式了。

        缺失值有三种形式：null、NaN 或 NA。

        处理缺失值，一般有两种方法：一种方法是通过一个覆盖全局的掩码表示缺失值，另一种方法是用一个标签值（sentinel value）表示缺失值。

        掩码是利用一个跟原来一样大小的矩阵，用0或者1表示某个元素缺失。标签值是利用一个特殊字符例如NaN表示缺失。

        Pandas 选择用标签方法表示缺失值，包括两种 Python 原有的缺失值：浮点数据类型（包括整型） 的 NaN 值，以及 Python的 None对象 。

        使用None时，表示一个空的python对象，所以numpy的dtype=object，因为是对象所以在进行大批量计算时，效率会比标量低。使用np.nan时表示标量，效率会高很多。

        对于缺失值，pandas提供了几个有用的API方法，分别是：isnull()，notnull()，dropna()，fillna()。其中，对于dataframe，dropna()方法默认会将包含NaN的整行都drop掉，如果想按照整列drop，增加axis=1参数。

        pandas的MultiIndex提供了多级索引的功能，用元组表示是多级索引的基础。

        下面例子，使用元组索引生成Series。筛选2019的索引，非常繁琐。

        Pandas 的 MultiIndex 类型提供多种实现方法，下边例子使用元组表示实现。

        unstack() 方法可以快速将一个多级索引的 Series 转化为普通索引的DataFrame。stack() 方法实现相反的效果。

        总结一下，创建多级索引的方法包括：

        (1)通过一个有不同等级的若干简单数组组成的列表来构建 MultiIndex：pd.MultiIndex.from_arrays。

        (2) 多个索引值的元组构成的列表创建 MultiIndex：pd.MultiIndex.from_tuples。

        (3)用两个索引的笛卡尔积创建MultiIndex：pd.MultiIndex.from_product。

        (4)直接提供 levels和labels创建 MultiIndex（lablels是指每个级别的整数指定每个位置）：

        上边的例子中，不管是Series还是DataFrame都是按照行来进行多级索引，其实，也可以按列索引，而且非常简单，下边是一个例子（几个学生在2018和2019两次考试的不同科目成绩）：

        需要对多级索引做显示切片操作时，可以使用pd.IndexSlice对象来切，不同级别的维度，拿逗号分割，例如下边例子中的df_sd_003.loc[idx_sd[2018,:],idx_sd['Alice',:]]。其他切片和取值操作与Numpy很类似。

        如果 MultiIndex 不是有序的索引，那么大多数切片操作都会失败。

        如果Series或者DataFrame的索引是未排序的，可以简单地通过sort_index方法来快速排序。

        层级数据维度转换的另一种方法是行列标签转换，可以通过reset_index 方法实现

        通过pd.concat()实现pandas对象合并，pd.cancat的所有参数（下面列举的是这些参数的默认值）：

        pd.concat() 可以简单地合并一维的 Series 或 DataFrame 对象，与

        np.concatenate() 合并数组一样。

        DataFrame 的合并默认都是逐行进行的（axis=0）；pd.concat在合并时会保留索引，即使索引是重复的！如果设置 verify_integrity=True，那么生成重复索引时，会触发异常！有时索引无关紧要，那么合并时就可以忽略它们，可以通过设置 ignore_index 参数来实现。默认的合并方式是对所有输入列进行并集合并（join='outer'），当然也可以用 join='inner' 实现对输入列的交集合并。下面是一个实现合并的例子：

        Pandas 的基本特性之一就是高性能的内存式数据连接（join）与合并（merge）操作。

        pd.merge() 实现的功能基于关系代数（relational algebra）的一部分。 pd.merge() 函数实现了三种数据连接的类型：一对一、多对一和多对多。pd.merge()会自动识别2个dataframe共有的列，并以这个列进行关联。

        上边的例子中，关联的两个dataframe具有相同名称的列，pandas会直接按同名列合并，由于两个输入要合并的列通常都不是同名的，因此 pd.merge() 提供了一些参数处理这个问题。

        1.最简单的方法就是直接将参数 on 设置为一个列名字符串或者一个包含多列名称的列表，这个参数只能在两个 DataFrame 有共同列名的时候才可以使用。

Pandas选取行，列总结

       b[b.['state']=='ohio'].index

       In [36]: list(df['state']).index('ohio')

       Out[36]: 0

In [37]: list(df['state']).index('nevada')

       Out[37]: 1

       访问某一列可以通过b['state']和b.state这两种方法进行，但是输出的pandas里面的Series这种数据类型，因此b['state'].index()返回Index([0,1], dtype=object)。

       因为数据分析知某个值并不是非常重要，所以没有直接输出索引值的函数，可以通过query()函数，b.query('state == "obio"')，输出含有ohio的行自然也就知道索引。

扩展资料：

       索引是为了加速对表中数据行的检索而创建的一种分散的存储结构。索引是针对表而建立的，它是由数据页面以外的索引页面组成的，每个索引页面中的行都会含有逻辑指针，以便加速检索物理数据。

       在数据库关系图中，可以在选定表的“索引/键”属性页中创建、编辑或删除每个索引类型。当保存索引所附加到的表，或保存该表所在的关系图时，索引将保存在数据库中。

       在数据库系统中建立索引主要有以下作用：

       （1）快速取数据；

       （2）保证数据记录的唯一性；

       （3）实现表与表之间的参照完整性；

       （4）在使用ORDER by、group by子句进行数据检索时，利用索引可以减少排序和分组的时间。

       百度百科-索引

        pandas 数据索引与选取

        我们对 DataFrame 进行选择，大抵从这三个层次考虑：行列、区域、单元格。

        其对应使用的方法如下：

        一. 行，列 --> df[]

        二. 区域 --> df.loc[], df.iloc[], df.ix[]

        三. 单元格 --> df.at[], df.iat[]

        下面开始练习：

        行维度：

        整数索引

        列维度：

        整数索引

        选取某一列

        选取某一行

        删除某一列

        删除某两行

        采用drop方法，有下面三种等价的表达式：

        注意 ：凡是会对原数组作出修改并返回一个新数组的，往往都有一个 inplace可选参数。如果手动设定为True（默认为False），那么原数组直接就被替换。也就是说，采用inplace=True之后，原数组名（如2和3情况所示）对应的内存值直接改变；而采用inplace=False之后，原数组名对应的内存值并不改变，需要将新的结果赋给一个新的数组或者覆盖原数组的内存位置（如1情况所示）

        合并两个dataframe

        插入一列

        插入在第1列（起始为0列，列名为e，列的内容为df['a']）

        dataframe 选取Nan 或者not Nan

       今天关于“pandas怎么查看数据,索引设置”的讲解就到这里了。希望大家能够更深入地了解这个主题，并从我的回答中找到需要的信息。如果您有任何问题或需要进一步的信息，请随时告诉我。