Python 数据分析：pandas 的 DataFrame，抽行、抽列、抽行列。df[] / df.loc[] / df.iloc[]，位置索引 / 标签索引，切片 / 不切片
目录
- 1 预备知识：Series
-
- 1.1 生成
- 1.2 抽提
-
- （1）单条
- （2）多条不连
- （3） 多条连
- 1.3 取值
- 2 正文：DataFrame
-
- 2.1 生成 df
- 2.2 抽提
-
- 2.2.1 抽列
-
- （1）单列
-
- df[]
- df.loc[]
- df.iloc[]
- （2）多列不连
-
- df[]
- df.loc[]
- df.iloc[]
- （3）多列连
-
- df[] ←不存在这种抽提法！
- df.loc[]
- df.iloc[]
- 2.2.2 抽行
-
- （1）单行
-
- df[]
- df.loc[]
- df.iloc[]
- （2）多行不连
-
- df[] ← 不存在这种抽提法！
- df.loc[]
- df.iloc[]
- （3）多行连
-
- df[]
- df.loc[]
- df.iloc[]
- 2.2.3 抽行列
-
-
- df.loc[]
- df.iloc[]
- df.iat[]
-
- 3 源码打包下载
- 4 欢迎纠错
- 5 免费爬虫
- ------
- 以下关于 Markdown 编辑器
-
- 新的改变
- 功能快捷键
- 合理的创建标题，有助于目录的生成
- 如何改变文本的样式
- 插入链接与图片
- 如何插入一段漂亮的代码片
- 生成一个适合你的列表
- 创建一个表格
-
- 设定内容居中、居左、居右
- SmartyPants
- 创建一个自定义列表
- 如何创建一个注脚
- 注释也是必不可少的
- KaTeX数学公式
- 新的甘特图功能，丰富你的文章
- UML 图表
- FLowchart流程图
- 导出与导入
-
- 导出
- 导入
1 预备知识：Series
Series 概要：
（１）语法
①生成：s = pd.Series(data, index=index)
②抽提：s1 = s[kw]
在 Series 系列命令中，解释较浅，可参考后续 DataFrame 示例。
（２）参
数据（data）和索引（index）。
索引又分：①标签索引（显式）；②位置索引（永远是连续整数，隐式）。生成与抽提时都分为此两类。
标签索引包头包尾，位置索引包头不包尾！
（3）传参
数据使用列表传入圆括号。
1.1 生成
直接上代码。
def series1():
"""
生成 series ：圆括号传列表，自动索引。
"""
s = pd.Series([88, 90, 32])
print(s)
"""
0 88
1 90
2 32
dtype: int64
"""
# ~ series1()
def series2():
"""
生成 series ：圆括号传列表，指定索引。
指定标签索引。
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
print(s)
"""
张三 88
李四 90
王五 32
dtype: int64
"""
"""
指定数字型标签索引。
容易混淆成位置索引。
位置索引永远使用连续型整数，以下示例显然不是。
"""
s = pd.Series([88, 90, 32], index=[4, 9, 37])
print(s)
"""
4 88
9 90
37 32
dtype: int64
"""
"""
测试此时取 88 可否使用 s[0]。
不可以，报错！键错误！
"""
# ~ print(s[0])
"""
KeyError: 0
"""
"""
原因：4 是标签索引，不是位置索引，s[0] 肯定报错。
试 s[4]，可以！当然可以。
使用 [] 直接访问：pandas 优先尝试按标签索引解释整数。
"""
print(s[4])
"""
88
"""
"""
推荐：使用 s.loc[4] 或 s.iloc[0] 更加突出 4 作为索引的意义。
后期维护代码也方便。
"""
print(s.loc[4])
print(s.iloc[0])
"""
88
88
"""
# ~ series2()
1.2 抽提
（1）单条
直接上代码。
# ~ series3()
def series4():
"""
抽提 series ：单条
按标签索引。
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
"""
1 条
"""
print(s["张三"])
"""
88
"""
# ~ series4()
（2）多条不连
直接上代码。
def series5():
"""
抽提 series ：多条不连
按位置索引。
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
"""
多条，还不连，多个离散型数值如何传参？列表。
"""
s1 = s[[0, 2]]
print(s1)
"""
张三 88
王五 32
dtype: int64
"""
# ~ series5()
def series6():
"""
抽提 series ：多条不连
按标签索引。
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
"""
多条，还不连，多个离散型数值如何传参？列表。
"""
s1 = s[["张三", "王五"]]
print(s1)
"""
张三 88
王五 32
dtype: int64
"""
# ~ series6()
（3） 多条连
直接上代码。
def series7():
"""
抽提 series ：多条连
按位置索引。
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
s1 = s[0:2]
print(s1)
print(type(s1))
"""
张三 88
李四 90
dtype: int64
"""
"""
如果传 [0:2] ？非法语法！
"""
# ~ s1 = s[[0:2]]
# ~ print(s1)
# ~ print(type(s1))
"""
s1 = s[[0:2]]
^
SyntaxError: invalid syntax
"""
# ~ series7()
def series8():
"""
抽提 series ：多条连
按标签索引。
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
s1 = s["张三":"王五"]
print(s1)
print(type(s1))
"""
张三 88
李四 90
王五 32
dtype: int64
"""
# ~ series8()
1.3 取值
直接上代码。
def series9():
"""
取值：获取 Series 对象的索引值
"""
s = pd.Series([88, 90, 32], index=["张三", "李四", "王五"])
print(s.index)
"""
取值：获取 Series 对象的具体值
"""
print(s.values)
"""
Index(['张三', '李四', '王五'], dtype='object')
[88 90 32]
"""
# ~ series9()
2 正文：DataFrame
DataFrame 概要：
（１）语法
①生成
df = pd.DataFrame(data=data, index=index, columns=columns)
# ------以下仅存档，不讲解
df = pd.DataFrame(data=data, index=index, columns=columns, dtype=dtype, copy=copy)
df = pd.read_excel()
df = pd.read_csv()
df = pd.read_html()
②抽提（三动词）
df1 = df[]
df1 = df.loc[]
df1 = df.iloc[]
返回值：Series 或 DataFrame（两返回）
（２）参
①数据
a）生成
列表data；字典data
b）抽提
标签索引值；位置索引值
②索引
行索引：index；列索引：columns
索引又分：a）标签索引；b）位置索引。生成与抽提时都分为此两类。（两参数）
标签索引包头包尾，位置索引包头不包尾！
（3）传参
①生成
数据使用列表或字典传入圆括号
②抽提
a）切片；b）不切片：单参；非连续列表类多参（两传参）
2.1 生成 df
直接上代码。
def dframe1():
# ------生成 df
# ------列表型 data
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
columns = ["A", "B", "C"]
df = pd.DataFrame(data=data, columns=columns)
print(df)
# ------还可以再写个 index= ，这里省略就是默认的：0，1，2，3，……
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ~ dframe1()
def dframe2():
# ------生成 df
# ------字典型 data
tdict = {"A": [1, 4, 7], "B": [2, 5, 8], "C": [3, 6, 9]}
df = pd.DataFrame(tdict)
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------同时指定行索引
df = pd.DataFrame(tdict, index=[4, 5, 6])
print(df)
"""
A B C
4 1 2 3
5 4 5 6
6 7 8 9
"""
# ~ dframe2()
def dframe3():
# ------行索引、列索引都可以后续再改
tdict = {"A": [1, 4, 7], "B": [2, 5, 8], "C": [3, 6, 9]}
df = pd.DataFrame(tdict, index=[4, 5, 6])
df.index = ["第一行", "第二行", "第三行"]
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
df.index = [0, 1, 2]
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
df.columns = ["第1列", "第2列", "第3列"]
print(df)
"""
第1列 第2列 第3列
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ~ dframe3()
读取 .xls/.xlsx/.csv/.txt/.html 此文不讨论，仅作如下提示：
*.xlsx，需要 openpyxl >= 3.0.10，读/写现代 Excel 文件。
*.xls，需要 xlrd (2.0+) == 2.0.1，只读旧版 Excel（<=2003）。
*.xls，需要 pyxlsb >= 1.0.0，读/写二进制 .xlsb 文件。
*.csv，无需额外模块（pandas内置），支持所有 CSV 操作。
2.2 抽提
抽提概要：
三动作：df[] / df.loc[] / df.iloc[]
两参数：标签索引 / 位置索引
两传参：切片 / 不切：单参/非连续列表类多参
两返回：Series：单行；单列 / DataFrame
2.2.1 抽列
抽提概要（再次强调）：
三动作：df[] / df.loc[] / df.iloc[]
两参数：标签索引 / 位置索引
两传参：切片 / 不切：单参/非连续列表类多参
两返回：Series：单行；单列 / DataFrame
（1）单列
直接上代码。
df[]
def dframe5():
"""
本函数段只示例：1）抽1列；2）使用 df[]
本函数段变换：1）两参数；2）两传参；3）两返回。共 2 × 2 × 2 = 8 种
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：标、不切、S
# ------抽1列
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：Series
df1 = df["A"]
print(df1)
"""
0 1
1 4
2 7
Name: A, dtype: int64
"""
# ------（2）成功：标、不切、D
# ------抽1列
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
df1 = df[["A"]]
print(df1)
"""
A
0 1
1 4
2 7
"""
# ------（3/4）失败：标、切、S/D
# ------抽1列
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：切片
# ------测试：df["A":"A"]。报错！这个表达其实给了抽行，后续再验证
# ~ df1 = df["A":"A"]
# ~ print(df1)
"""
TypeError: cannot do slice indexing on RangeIndex with these indexers [A] of type str
"""
# ------（5）改造后成功：位、不切、S
# ------抽1列
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：Series
# ------测试：df[0]。报错！键错误
# ~ df1 = df[0]
# ~ print(df1)
"""
KeyError: 0
"""
# ------改造 df 可以使 df[0]
df.columns = [0, "B", "C"]
df1 = df[0]
print(df1)
"""
0 1
1 4
2 7
Name: 0, dtype: int64
"""
# ------（6）改造后成功：位、不切、D
# ------抽1列
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------测试：df[[0]]
df1 = df[[0]]
print(df1)
"""
0
0 1
1 4
2 7
"""
# ------（7/8）失败：位、切、S/D
# ------抽1列
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：切片
df1 = df[0:1]
print(df1)
"""
0 B C
0 1 2 3
"""
"""
这不是成功了吗？怎么说失败呢？因为这样取回的是行，不是列。df[]直接传位置切片的便利给了行了。
有老师学习 df.loc[] 或 df.iloc[] 后知道还有个逗号的说法，好，再试试。
"""
# ~ df1 = df[:, 0:1]
# ~ print(df1)
"""
pandas.errors.InvalidIndexError: (slice(None, None, None), slice(0, 1, None))
还是不对！
参数改造成列表呢？
"""
# ~ df1 = df[:, [0:1]]
# ~ print(df1)
"""
df1 = df[:, [0:1]]
^
SyntaxError: invalid syntax
还是不对！
"""
# ~ dframe5()
df.loc[]
def dframe6():
"""
本函数段只示例：1）抽1列；2）使用 df.loc[]
本函数段变换：1）两参数；2）两传参；3）两返回。共 2 × 2 × 2 = 8 种
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：标、不切、S
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：Series
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
df1 = df.loc[:, "A"]
print(df1)
"""
0 1
1 4
2 7
Name: A, dtype: int64
"""
# ------（2）成功：标、不切、D
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
df1 = df.loc[:, ["A"]]
print(df1)
"""
A
0 1
1 4
2 7
"""
# ------（3）失败：标、切、S
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：切片
# ------两返回：Series
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
df1 = df.loc[:, "A":"A"]
print(df1)
"""
A
0 1
1 4
2 7
"""
"""
这不成功了吗？为什么说失败？返回的是 DataFrame 而非 Series 。"A":"A" ，虽然还是取 A 列，但这是切片来的，切片就有宽度，已经是二维，不是一维，不可能返回 Series
"""
# ------（4）成功：标、切、D（但没必要这么复杂）
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
df1 = df.loc[:, "A":"A"]
print(df1)
"""
A
0 1
1 4
2 7
"""
# ------（5）失败：位、不切、S
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：位置索引
# ------两传参：不切
# ------两返回：Series
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
# ~ df1 = df.loc[:, 0]
# ~ print(df1)
"""
KeyError: 0
"""
"""
怎么才对？稍候请看 df.iloc[]
"""
# ------（6）失败：位、不切、D
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：位置索引
# ------两传参：不切
# ------两返回：Series
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
# ~ df1 = df.loc[:, [0]]
# ~ print(df1)
"""
KeyError: "None of [Index([0], dtype='int32')] are in the [columns]"
"""
# ------（7）失败：位、切、S
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：位置索引
# ------两传参：切
# ------两返回：Series
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
"""
想都不用想，传参时给切片是不可能得到 Series 的，都不用实验
"""
# ------（8）败：位、切、D
# ------抽1列
# ------三动作：df.loc[]
# ------两参数：位置索引
# ------两传参：切
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
# ~ df1 = df.loc[:, 0:1]
# ~ print(df1)
"""
KeyError: "None of [Index([0], dtype='int32')] are in the [columns]"
"""
"""
稍候请看 df.iloc[]
"""
# ~ dframe6()
df.iloc[]
def dframe7():
"""
本函数段只示例：1）抽1列；2）使用 df.iloc[]
本函数段变换：1）两参数；2）两传参；3）两返回。共 2 × 2 × 2 = 8 种
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1/2/3/4）失败：标、切/不切、S/D
# ------抽1列
# ------三动作：df.iloc[]
# ------两参数：标签索引
# ------两传参：切片/不切片
# ------两返回：Series/DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1列等于抽全部行的某列
"""
df.iloc[] 中的“i”是“index”的缩写，就是针对位置索引的，不可能引用标签索引，想都不想用，失败
"""
# ------（5）成功：位、不切、S
# ------抽1列
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：Series
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1列等于抽全部行的某列
df1 = df.iloc[:, 0]
print(df1)
"""
0 1
1 4
2 7
Name: A, dtype: int64
"""
# ------（6）成功：位、不切、D
# ------抽1列
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1列等于抽全部行的某列
df1 = df.iloc[:, [0]]
print(df1)
"""
A
0 1
1 4
2 7
"""
# ------（7）失败：位、切、S
# ------抽1列
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：切片
# ------两返回：Series
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1列等于抽全部行的某列
"""
我们已经有了经验，切片是不可能拿出 Series 的，试都不用试
"""
# ------（8）成功：位、切、D
# ------抽1列
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1列等于抽全部行的某列
df1 = df.iloc[:, 0:1]
print(df1)
"""
A
0 1
1 4
2 7
"""
# ~ dframe7()
（2）多列不连
直接上代码。
df[]
def dframe8():
"""
本函数段只示例：1）抽多列不连续；2）使用 df[]
本函数段变换：1）两参数。共 2 种
为什么没有“两返回”了？多列啊，已经是二维，不可能再返回 Series ，只能是 DataFrame
为什么没有“两传参”了？不连续，不可能用切片
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：标签索引
# ------抽多列不连续
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df 后边跟的肯定是方括号，传参以列表形式，不能是元组
df1 = df[["A", "C"]]
print(df1)
"""
A C
0 1 3
1 4 6
2 7 9
"""
# ------（2）改造后成功：位置索引
# ------抽多列不连续
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df 后边跟的肯定是方括号，传参以列表形式，不能是元组
# ~ df1 = df[[0, 2]]
# ~ print(df1)
"""
KeyError: "None of [Index([0, 2], dtype='int32')] are in the [columns]"
"""
"""
这回有经验了，改造下会成功的！
"""
df.columns = [0, "B", 2]
print(df)
"""
0 B 2
0 1 2 3
1 4 5 6
2 7 8 9
"""
df1 = df[[0, 2]]
print(df1)
"""
0 2
0 1 3
1 4 6
2 7 9
"""
# ~ dframe8()
df.loc[]
def dframe9():
"""
本函数段只示例：1）抽多列不连续；2）使用 df.loc[]
本函数段变换：1）两参数。共 2 种
为什么没有“两返回”了？多列啊，已经是二维，不可能再返回 Series ，只能是 DataFrame
为什么没有“两传参”了？不连续，不可能用切片
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：标签索引
# ------抽多列不连续
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.loc 后边跟的肯定是方括号，传参以列表形式，不能是元组
# ------df.loc[] 的原型是 df.loc[, ]
df1 = df.loc[:, ["A", "C"]]
print(df1)
"""
A C
0 1 3
1 4 6
2 7 9
"""
# ------（2）改造后成功：位置索引
# ------抽多列不连续
# ------三动作：df.loc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.loc 后边跟的肯定是方括号，传参以列表形式，不能是元组
# ------df.loc[] 的原型是 df.loc[, ]
# ~ df1 = df.loc[:, [0, 2]]
# ~ print(df1)
"""
KeyError: "None of [Index([0, 2], dtype='int32')] are in the [columns]"
"""
"""
这回有经验了，改造下会成功的！
"""
df.columns = [0, "B", 2]
print(df)
"""
0 B 2
0 1 2 3
1 4 5 6
2 7 8 9
"""
df1 = df.loc[:, [0, 2]]
print(df1)
"""
0 2
0 1 3
1 4 6
2 7 9
"""
# ~ dframe9()
df.iloc[]
def dframe10():
"""
本函数段只示例：1）抽多列不连续；2）使用 df.iloc[]
本函数段变换：嗯，啥也不变换了。
为什么没有“两参数”了？根据上述经验，这个动作只处理位置索引，就 1 种
为什么没有“两返回”了？多列啊，已经是二维，不可能再返回 Series ，只能是 DataFrame
为什么没有“两传参”了？不连续，不可能用切片
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：位置索引
# ------抽多列不连续
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.iloc 后边跟的肯定是方括号，传参以列表形式，不能是元组
# ------df.iloc[] 的原型是 df.iloc[, ]
df1 = df.iloc[:, [0, 2]]
print(df1)
"""
A C
0 1 3
1 4 6
2 7 9
"""
# ~ dframe10()
（3）多列连
df[] ←不存在这种抽提法！
直接上代码。
def dframe11():
"""
本函数段只示例：1）抽多列连续；2）使用 df[]
本函数段变换：1）两参数。共 2 种
为什么没有“两传参”了？连续只能做切片。
为什么没有“两返回”了？多列只能是二维的 DataFrame 。
结论：df[] 如果出现切片，那肯定是针对行的！列如果想切片，就别用 df[] ！
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）失败：标、切、D
# ------抽多列连续
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：切片
# ------两返回：DataFrame
# ~ df1 = df["A":"C"]
# ~ print(df1)
"""
TypeError: cannot do slice indexing on RangeIndex with these indexers [A] of type str
"""
"""
这种便利写法其实是给了行了。
df[:, "A":"C"]？
"""
# ~ df1 = df[:, "A":"C"]
# ~ print(df1)
"""
pandas.errors.InvalidIndexError: (slice(None, None, None), slice('A', 'C', None))
"""
"""
看到了吧，df[]很纯粹，应该是不支持中间的半角逗号。
"""
# ------（2）失败：位、切、D
# ------抽多列连续
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：切片
# ------两返回：DataFrame
"""
以前改造 df 也能成功，这次再改造下试试？
"""
df.columns = [0, 1, 2]
print(df)
"""
0 1 2
0 1 2 3
1 4 5 6
2 7 8 9
"""
df1 = df[0:3]
print(df1)
"""
0 1 2
0 1 2 3
1 4 5 6
2 7 8 9
"""
"""
这不确实可以嘛！没报错！取回的也是想要的！
这个结果有迷惑性，咱们用 df[0:2] 再试试。
"""
df1 = df[0:2]
print(df1)
"""
0 1 2
0 1 2 3
1 4 5 6
"""
"""
这下清楚了吧？取回的其实是行，不是列！
行索引和列索引长一样，容易误会。
至此清楚了：df[] 如果出现切片，那肯定是针对行的！列如果想切片，就别用 df[] ！
"""
# ~ dframe11()
df.loc[]
def dframe12():
"""
本函数段只示例：1）抽多列连续；2）使用 df.loc[]
本函数段变换：1）两参数。共 2 种
至于为什么没有“两传参”（只能切片）和“两返回”（只能是二维 DataFrame）以后不再强调
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：标、切、D
# ------抽多列连续
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，只抽列意味着抽全部行
df1 = df.loc[:, "A":"B"]
print(df1)
"""
A B
0 1 2
1 4 5
2 7 8
"""
# ------（2）改造后成功：位、切、D
# ------抽多列连续
# ------三动作：df.loc[]
# ------两参数：位置索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，只抽列意味着抽全部行
df1 = df.loc[:, 0:2]
print(df1)
"""
TypeError: cannot do slice indexing on Index with these indexers [0] of type int
"""
"""
为什么报错，不用多说了吧？
怎么改造 df 才能让这个算法成立，也不用多说了吧？
但没必要改造，从以上经验看，直接用 df.iloc[] 就可以。
"""
# ~ dframe12()
df.iloc[]
def dframe13():
"""
本函数段只示例：1）抽多列连续；2）使用 df.iloc[]
本函数段变换：如前所述，啥也不变换了，因为只能是位置索引、切片、返回 DataFrame
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：位、切、D
# ------抽多列连续
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：切片
# ------注意位置索引切片遵守列表算法，包头不包尾
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，只抽列意味着抽全部行
df1 = df.iloc[:, 0:2]
print(df1)
"""
A B
0 1 2
1 4 5
2 7 8
"""
# ~ dframe13()
2.2.2 抽行
抽提概要（再次强调）：
三动作：df[] / df.loc[] / df.iloc[]
两参数：标签索引 / 位置索引
两传参：切片 / 不切：单参/非连续列表类多参
两返回：Series：单行；单列 / DataFrame
（1）单行
直接上代码。
df[]
def dframe14():
"""
本函数段只示例：1）抽1行；2）使用 df[]
本函数段变换：1）两参数；2）两传参；3）两返回。共 2 × 2 × 2 = 8 种
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）失败：标、不切、S
# ------抽1行
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：Series
"""
这题不用做，肯定失败。为啥？你 df 里都没标签索引，只有数字型索引（我们认为它就是位置索引），不失败才怪
这里可以直接用位置索引取行
为了示例我们给 df 改个标签索引，但不完全改，看效果
"""
df.index = ["第一行", 1, "第三行"]
# ~ df1 = df["第一行"]
# ~ print(df1)
"""
KeyError: '第一行'
"""
"""
明明有“第一行”，怎么还说“键错误”？
别忘了 df[] 传1个标签索引是专门给列用的。想不明白的话可以看“抽单列”之“df[]”
这里报错没有“第一行”，说的是列索引中没有“第一行”，因为列索引只有“A”“B”“C”
"""
# ~ df1 = df[1]
# ~ print(df1)
"""
KeyError: 1
"""
"""
和上边的错误原因是一样的
使用标签索引、不切片，用动作 df[] ，想得到 Series 类型返回值，做不到！
"""
# ------（2）失败：标、不切、D
# ------抽1行
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
"""
没法写
"""
# ------（3/4）成功一半：标、切、S/D
# ------抽1行
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：切片
df1 = df["第一行":"第一行"]
print(df1)
"""
A B C
第一行 1 2 3
"""
"""
成功！为什么说成功一半？因为这种方法只能得到 DataFrame ，得不到 Series
没改的那个数字型索引 1 ，能借这个劲成功吗？
以下是借这个机会继续探索，已经超出单行
"""
# ------以下借此机会继续探索，已超出单行
df1 = df[1:1]
print(df1)
"""
Empty DataFrame
Columns: [A, B, C]
Index: []
"""
"""
不报错报空？
“1:1”都是数字，按位置索引来的，按列表的算法包头不包尾，不包括最后的1，相当于啥也没取
那要写“1:"第二行"”呢？
"""
df1 = df[1:"第三行"]
print(df1)
"""
A B C
1 4 5 6
第三行 7 8 9
"""
"""
还真可以！也就是说，虽然没把原来的位置索引全改成标签索引，但因为 df.index 中有了字符型索引的出现，……
"""
# ~ df1 = df["1":"第三行"]
# ~ print(df1)
"""
不可！1 就是数字型，不是文本型
"""
# ~ df1 = df["1":"1"]
# ~ print(df)
"""
不可！1 是数字型！
"""
# ------（5）失败：位、不切、S
# ------抽1行
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：Series
# ~ df1 = df[0]
# ~ print(df1)
"""
KeyError: 0
"""
"""
是因为 df.index 里没有 0 吗？1 有，试试 1
"""
# ~ df1 = df[1]
# ~ print(df1)
"""
KeyError: 1
"""
"""
这里强调多次了，df[1] 是针对列的！
"""
# ------（6）失败：位、不切、D
# ------抽1行
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
"""
我写不出来！
"""
# ------（7/8）成功一半：位、切、S/D
# ------抽1行
# ------三动作：df[]
# ------两参数：位置索引
# ------两传参：切片
"""
得先改成位置索引
可以用 df.index = [0, 1, 2]
"""
print(df)
"""
A B C
第一行 1 2 3
1 4 5 6
第三行 7 8 9
"""
df.index = [0, 1, 2]
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
df1 = df[0:1]
print(df1)
"""
A B C
0 1 2 3
"""
"""
这不是成功了吗？怎么说成功一半呢？因为搞切片了，就只能取回二维 DataFrame ，取不回 Series
"""
# ~ dframe14()
df.loc[]
def dframe15():
"""
本函数段只示例：1）抽1行；2）使用 df.loc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试位置索引，两参数变成一参数
本函数段变换：1）两传参；2）两返回。共 2 × 2 = 4 种
"""
# ------生成 df 时直接设置标签索引
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）成功：标、不切、S
# ------抽1行
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：Series
# ------df.loc[] 的原型是 df.loc[, ]，抽1行意味着抽全部列
df1 = df.loc["第一行"]
print(df1)
"""
A 1
B 2
C 3
Name: 第一行, dtype: int64
"""
"""
取第一行，没指定列，那就是取回第一行所有列数据，成功
"""
# ------（2）成功：标、不切、D
# ------抽1行
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
df1 = df.loc[["第一行"]]
print(df1)
"""
A B C
第一行 1 2 3
"""
# ------（3）失败：标、切、S
"""
不多解释了，切片不可能产生 Series
"""
# ------（4）成功：标、切、D
# ------抽1行
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽1列等于抽全部行的某列
df1 = df.loc["第一行":"第一行"]
# ------等同于 df["第一行":"第一行"]
print(df1)
"""
A B C
第一行 1 2 3
"""
# ------等同于 df.loc["第一行":"第一行"]
df1 = df["第一行":"第一行"]
print(df1)
"""
A B C
第一行 1 2 3
"""
# ~ dframe15()
df.iloc[]
def dframe16():
"""
本函数段只示例：1）抽1行；2）使用 df.iloc[]
不再试标签索引，只试位置索引。
本函数段变换：1）两传参；2）两返回。共 2 × 2 = 4 种
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"])
print(df)
"""
A B C
0 1 2 3
1 4 5 6
2 7 8 9
"""
# ------（1）成功：位、不切、S
# ------抽1行
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：Series
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1行意味着抽全部列
"""
df.iloc[] 中的“i”是“index”的缩写，就是针对位置索引的，不可能引用标签索引，想都不想用，失败
"""
df1 = df.iloc[1]
print(df1)
"""
A 4
B 5
C 6
Name: 1, dtype: int64
"""
"""
如果 df.index 用的是文本型的标签索引，还可以用 df.iloc[] 吗？肯定可以
"""
df.index = ["行首", "行中", "行尾"]
print(df)
"""
A B C
行首 1 2 3
行中 4 5 6
行尾 7 8 9
"""
df1 = df.iloc[2]
print(df1)
"""
A 7
B 8
C 9
Name: 行尾, dtype: int64
"""
# ------（2）成功：位、不切、D
# ------抽1行
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1行意味着抽全部列
df1 = df.iloc[[2]]
print(df1)
"""
A B C
行尾 7 8 9
"""
# ------（3）失败：位、切、S
"""
写不出来。你懂的。
"""
# ------（4）成功：位、切、D
# ------抽1行
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1行意味着抽全部列
df1 = df.iloc[0:1]
print(df1)
"""
A B C
行首 7 8 9
"""
# ~ dframe16()
（2）多行不连
直接上代码。
df[] ← 不存在这种抽提法！
def dframe17():
"""
本函数段只示例：1）抽多行不连续；2）使用 df[]
多行只能是二维，返回只能是 DataFrame
位置索引我们还是考虑用 iloc ，两参数只考虑标签索引
不连续，而且多行，我们不考虑切片
本函数段变换：啥也不变换了，其实就是：不切片、标签索引、取 DataFrame
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）失败：标签索引
# ------抽多行不连续
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df 后边跟的肯定是方括号，传参以列表形式，不能是元组
"""
想半天写不出来。
你发现没，写出来就是操作列！
"""
# ~ dframe17()
df.loc[]
def dframe18():
"""
本函数段只示例：1）抽多行不连续；2）使用 df.loc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试位置索引，两参数变成一参数
不连续，所以不做切片
多行，所以结果是二维的不存在 Series
本函数段变换：那就不变换了，就只有：不做切片、标签索引、返回 DataFrame
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）成功：标、不切、D
# ------抽多行不连续
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽1行意味着抽全部列
# ~ df1 = df.loc["第一行", "第三行"]
# ~ print(df1)
"""
KeyError: '第三行'
"""
"""
有“第三行”啊，怎么还报“键错误”？
df.loc[] 的原型是 df.loc[, ]，“,”后边的键名被认为是列标签索引中的键，肯定没有啊
我们之前强调过，不连续的、零散的标签要放到列表中
"""
df1 = df.loc[["第一行", "第三行"]]
print(df1)
"""
A B C
第一行 1 2 3
第三行 7 8 9
"""
# ~ dframe18()
df.iloc[]
def dframe19():
"""
本函数段只示例：1）抽多行不连续；2）使用 df.iloc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试标签索引（也没法测试，除非改造 df），两参数变成一参数
不连续，所以不做切片
多行，所以结果是二维的不存在 Series
本函数段变换：那就不变换了，就只有：不做切片、位置索引、返回 DataFrame
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）：位、不切、D
# ------抽多行不连续
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽1行意味着抽全部列
df1 = df.iloc[[0, 2]]
print(df1)
"""
A B C
第一行 1 2 3
第三行 7 8 9
"""
# ~ dframe19()
（3）多行连
直接上代码。
df[]
def dframe20():
"""
本函数段只示例：1）抽多行连续；2）使用 df[]
1）两参数。位置索引和标签索引，我们不考虑位置索引了，只看标签索引
2）两传参。切片，不切片实现不了
3）两返回。不存在 Series ，只能返回 DataFrame
本函数段变换：如前所述，啥也不变换了，因为只能是标签索引、切片、返回 DataFrame
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）功：标、切、D
# ------抽多行连续
# ------三动作：df[]
# ------两参数：标签索引
# ------两传参：切片
# ------注意位置索引切片遵守列表算法，包头不包尾
# ------两返回：DataFrame
df1 = df["第一行":"第三行"]
print(df1)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------如前文所述，等同于：df.loc["第一行":"第三行"]
df1 = df.loc["第一行":"第三行"]
print(df1)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ~ dframe20()
df.loc[]
def dframe21():
"""
本函数段只示例：1）抽多行连续；2）使用 df.loc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试位置索引，两参数变成一参数
连续，肯定要做切片，“两传参”变成一传参：切片
返回肯定是 DataFrame 。
本函数段变换：就不变换了，只能是：标签索引、切片、返回 DataFrame 。
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）成功：标、切、D
# ------抽多行连续
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.loc[] 的原型是 df.loc[, ]，抽多行连续不提列的事儿意味着抽全部列
df1 = df.loc["第一行":"第二行"]
print(df1)
"""
A B C
第一行 1 2 3
第二行 4 5 6
"""
# ~ dframe21()
df.iloc[]
def dframe22():
"""
本函数段只示例：1）抽多行连续；2）使用 df.iloc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试标签索引（也测试不了），两参数变成一参数
连续，肯定要做切片，“两传参”变成一传参：切片
返回肯定是 DataFrame 。
本函数段变换：就不变换了，只能是：位置索引、切片、返回 DataFrame 。
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）成功：位、切、D
# ------抽多行连续
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：切片
# ------两返回：DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]，抽多行连续不提列的事儿意味着抽全部列
df1 = df.iloc[0:2]
print(df1)
"""
A B C
第一行 1 2 3
第二行 4 5 6
"""
# ~ dframe22()
2.2.3 抽行列
抽提概要（再次强调）：
三动作：df[] / df.loc[] / df.iloc[]
两参数：标签索引 / 位置索引
两传参：切片 / 不切：单参/非连续列表类多参
两返回：Series：单行；单列 / DataFrame
直接上代码。
df.loc[]
def dframe23():
"""
抽行列。三动作中 df[] 实现不了，只能用 df.loc[] 或 df.iloc[]
本函数段只示例：1）抽行列；2）使用 df.loc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试位置索引，“两参数”变成一参数
保留“两传参”。切片或不切片，不切片又分单独参数和离散列表参数。这其实是 3 种情况。之前没分这么细是因为从大类上（连续或不连续）分开了所以没再细分。
返回可以是 DataFrame ，也可以是交叉点的某具体值，2 种情况。
之前说“两返回”是 Series 和 DataFrame ，此处新增一种返回值，即具体数值，用得不多，我们也不说“三返回”了。
本函数段变换：两传参的 3 种情况，及，两返回的 2 种情况，又因为参数可以传给行或列，所以共 3 × 2 × 2 = 12 种。
切片其实还可以再分全切或部分切，按排列组合“不重不漏”法则有更多种。
示例就不把这些种全写了，仅给出部分示例。
其实在抽行、抽列时已说清楚，此处只是行、列同时出现的综合情况。
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）某行与某列交叉具体值
# ------抽行列
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：不切片
# ------两返回：某具体值
# ------df.loc[] 的原型是 df.loc[, ]
df1 = df.loc["第一行", "B"]
print(df1)
print(type(df1))
"""
2
"""
# ------（2）
# ------单行/多行不连续/多行连续
# ------单列/多列不连续/多列连续
# ------以上情况的各种排列组合
# ------抽行列
# ------三动作：df.loc[]
# ------两参数：标签索引
# ------两传参：切片/不切片
# ------两返回：某具体值或 DataFrame
# ------df.loc[] 的原型是 df.loc[, ]
# ------随便写了，也不提供返回值了
# ------原则一样：散点进列表；标签切片包头包尾；位置切片包头不包尾
df1 = df.loc["第一行", "B"]
df1 = df.loc[:, ["B", "C"]]
df1 = df.loc["第一行":"第二行", "A":"C"]
df1 = df.loc[["第一行", "第三行"], "A":"B"]
# ... ...
"""
到这里可以总结了，其实哪有那么多类型，又是“单行/多行不连续/多行连续”又是“单列/多列不连续/多列连续”的，
其实只要是标签索引，直接给一个 df.loc[, ] 就可以了！
不管对方来什么拳，我只给他一个“亢龙有悔”。
"""
# ~ dframe23()
df.iloc[]
def dframe24():
"""
抽行列。三动作中 df[] 实现不了，只能用 df.loc[] 或 df.iloc[]
本函数段只示例：1）抽行列；2）使用 df.iloc[]
我们已经知道 iloc 专门用来做位置索引，所以我们不再费力去测试标签索引，“两参数”变成一参数
保留“两传参”。切片或不切片，不切片又分单独参数和离散列表参数。这其实是 3 种情况。之前没分这么细是因为从大类上（连续或不连续）分开了所以没再细分。
返回可以是 DataFrame ，也可以是交叉点的某具体值，2 种情况。
之前说“两返回”是 Series 和 DataFrame ，此处新增一种返回值，即具体数值，用得不多，我们也不说“三返回”了。
本函数段变换：两传参的 3 种情况，及，两返回的 2 种情况，又因为参数可以传给行或列，所以共 3 × 2 × 2 = 12 种。
切片其实还可以再分全切或部分切，按排列组合“不重不漏”法则有更多种。
示例就不把这些种全写了，仅给出部分示例。
其实在抽行、抽列时已说清楚，此处只是行、列同时出现的综合情况。
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
# ------（1）某行与某列交叉具体值
# ------抽行列
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：不切片
# ------两返回：某具体值
# ------df.iloc[] 的原型是 df.iloc[, ]
df1 = df.iloc[0, 1]
print(df1)
print(type(df1))
"""
2
"""
# ------（2）
# ------单行/多行不连续/多行连续
# ------单列/多列不连续/多列连续
# ------以上情况的各种排列组合
# ------抽行列
# ------三动作：df.iloc[]
# ------两参数：位置索引
# ------两传参：切片/不切片
# ------两返回：某具体值或 DataFrame
# ------df.iloc[] 的原型是 df.iloc[, ]
# ------随便写了，也不提供返回值了
# ------原则一样：散点进列表；标签切片包头包尾；位置切片包头不包尾
df1 = df.iloc[0, 1]
df1 = df.iloc[:, [1, 2]]
df1 = df.iloc[0:2, 0:3]
df1 = df.iloc[[0, 2], 0:2]
# ... ...
"""
到这里可以总结了，其实哪有那么多类型，又是“单行/多行不连续/多行连续”又是“单列/多列不连续/多列连续”的，
其实只要是位置索引，直接给一个 df.iloc[, ] 就可以了！
不管对方来什么拳，我只给他一个“亢龙有悔”。
"""
# ~ dframe24()
df.iat[]
def dframe25():
"""
取某单行和某单列交叉点的具体值有一个简便写法。
"""
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data=data, columns=["A", "B", "C"], index=["第一行", "第二行", "第三行"])
print(df)
"""
A B C
第一行 1 2 3
第二行 4 5 6
第三行 7 8 9
"""
df1 = df.iloc[0, 1]
print(df1)
print(type(df1))
"""
2
"""
df1 = df.iat[0, 1]
print(df1)
print(type(df1))
"""
2
"""
# ~ dframe25()
3 源码打包下载
所有源码已无偿全部贴出，可以全选复制组合成一个完整的 .py 文件供运行测试或修改调整。
如嫌麻烦，想直接拥有一个完整的 .py 文件，可联系。
4 欢迎纠错
欢迎纠错，随时更新。
联系方式：评论、私信，或 企鹅 ：1790042182 。
5 免费爬虫
https://affiliate.bazhuayu.com/M8lKUC
------
以下关于 Markdown 编辑器
你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。
新的改变
我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：
- 全新的界面设计 ，将会带来全新的写作体验；
- 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
- 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
- 全新的 KaTeX数学公式 语法；
- 增加了支持甘特图的mermaid语法1 功能；
- 增加了 多屏幕编辑 Markdown文章功能；
- 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
- 增加了 检查列表 功能。
功能快捷键
撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G
合理的创建标题，有助于目录的生成
直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。
如何改变文本的样式
强调文本 强调文本
加粗文本 加粗文本
标记文本
删除文本
引用文本
H2O is是液体。
210 运算结果是 1024.
插入链接与图片
链接: link.
图片: 
带尺寸的图片:
居中的图片: 
居中并且带尺寸的图片:
当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。
如何插入一段漂亮的代码片
去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.
// An highlighted block
var foo = 'bar';
生成一个适合你的列表
- 项目
- 项目
- 项目
- 项目
- 项目1
- 项目2
- 项目3
- 计划任务
- 完成任务
创建一个表格
一个简单的表格是这么创建的：
| 项目 | Value |
|---|---|
| 电脑 | $1600 |
| 手机 | $12 |
| 导管 | $1 |
设定内容居中、居左、居右
使用:---------:居中
使用:----------居左
使用----------:居右
| 第一列 | 第二列 | 第三列 |
|---|---|---|
| 第一列文本居中 | 第二列文本居右 | 第三列文本居左 |
SmartyPants
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：
| TYPE | ASCII | HTML |
|---|---|---|
| Single backticks | 'Isn't this fun?' |
‘Isn’t this fun?’ |
| Quotes | "Isn't this fun?" |
“Isn’t this fun?” |
| Dashes | -- is en-dash, --- is em-dash |
– is en-dash, — is em-dash |
创建一个自定义列表
-
Markdown
- Text-to- HTML conversion tool Authors
- John
- Luke
如何创建一个注脚
一个具有注脚的文本。2
注释也是必不可少的
Markdown将文本转换为 HTML。
KaTeX数学公式
您可以使用渲染LaTeX数学表达式 KaTeX:
Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通过欧拉积分
Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.
你可以找到更多关于的信息 LaTeX 数学表达式here.
新的甘特图功能，丰富你的文章
2014-01-07 2014-01-09 2014-01-11 2014-01-13 2014-01-15 2014-01-17 2014-01-19 2014-01-21 已完成 进行中 计划一 计划二 现有任务 Adding GANTT diagram functionality to mermaid
- 关于 甘特图 语法，参考 这儿,
UML 图表
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：
张三 李四 王五 你好！李四, 最近怎么样? 你最近怎么样，王五？ 我很好，谢谢! 我很好，谢谢! 李四想了很长时间, 文字太长了 不适合放在一行. 打量着王五... 很好... 王五, 你怎么样? 张三 李四 王五
这将产生一个流程图。:
链接
长方形
圆
圆角长方形
菱形
- 关于 Mermaid 语法，参考 这儿,
FLowchart流程图
我们依旧会支持flowchart的流程图：
Created with Raphaël 2.3.0 开始 我的操作 确认？ 结束 yes no
- 关于 Flowchart流程图 语法，参考 这儿.
导出与导入
导出
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。
导入
如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。
mermaid语法说明 ↩︎
注脚的解释 ↩︎