Python 数据分析：DataFrame，抽行、抽列、抽行列。df[] / df.loc[] / df.iloc[]，位置索引 / 标签索引，切片 / 不切片。听故事学知识点怎么这么容易？

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
    <class 'pandas.core.series.Series'>
    """
    """
    如果传 [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
    <class 'pandas.core.series.Series'>
    """
# ~ 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
    """
    """
    注意这里 4 5 6 是数字，长得像位置索引，但不是。
    是标签索引。
    位置索引永远是连续型整数，从 0 开始。
    """
# ~ 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
    """
    """
    成功了啊？为何说失败？
    不报错不代表成功。
    此处 0 是标签索引，不是位置索引！
    """
    """
    （6）失败：位、不切、D
    抽1列
    三动作：df[]
    两参数：位置索引
    两传参：不切片
    两返回：DataFrame
    测试：df[[0]]
    """
    df1 = df[[0]]
    print(df1)
    """
       0
    0  1
    1  4
    2  7
    """
    """
    同 5 ，不报错不代表成功。
    此处 0 是标签索引，不是位置索引！
    """
    """
    （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
    """
    """
    成功了啊，为何说失败？
    0 与 2 都是标签索引，不是位置索引！
    """
# ~ 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
    """
    """
    成功了啊，为何说“失败”？
    0 2 是标签索引，不是位置索引。
    """
# ~ 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.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.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, "第三行"]
    """
    注意：此处 1 看似保留了原索引 1 ，但有本质区别。
    原来的 1 是自动生成的位置索引，当前 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 是标签索引，不是位置索引了！
    Pandas的索引可以是任意类型（字符串、整数、混合类型等），此处索引包含字符串和整数，整体会被识别为object类型（非纯整数索引）。
    这意味着所有操作（包括切片）默认基于标签（label-based）而非位置（position-based）。
    此处索引是混合类型（字符串和整数），1 可能无法与字符串标签直接比较顺序，导致切片无效！
    所以不推荐这么混合着写 df.index 。
    那要写“1:"第三行"”呢？
    """
    df1 = df[1:"第三行"]
    print(df1)
    """
            A  B  C
    1       4  5  6
    第三行  7  8  9
    """
    """
    可以！因为 1 和 “第三行”都是标签索引。
    """
    # ~ 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]
    """
    这样设置并不是位置索引，仍然是标签索引，但不影响下述代码。
    可以使用 reindex 。
    """
    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
    """
    """
    如果新设置的 df.index = [0, 1, 2] 是标签索引，那应该包头包尾啊，为何只返回一行？
    切片 df[0:1] ​直接作用于行位置​（非索引标签），因此结果不受标签值影响。
    何必给自己找这许多麻烦？
    如果想指定位置，直接写 df.iloc[0:1] ，省得有歧义！
    这不是成功了吗？怎么说成功一半呢？因为搞切片了，就只能取回二维 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行意味着抽全部列
    """
    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
    <class 'numpy.int64'>
    """
    """
    （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
    <class 'numpy.int64'>
    """
    """
    （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
    <class 'numpy.int64'>
    """
    df1 = df.iat[0, 1]
    print(df1)
    print(type(df1))
    """
    2
    <class 'numpy.int64'>
    """
# ~ dframe25()

3 欢迎纠错

  欢迎纠错，随时更新。
  联系方式：评论、私信，或 企鹅 ：1790042182 。

4 论文写作/Python 学习智能体

https://chatglm.cn/share/WF2C5ree

------

以下关于 Markdown 编辑器

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

1. 全新的界面设计 ，将会带来全新的写作体验；
2. 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
3. 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
4. 全新的 KaTeX数学公式 语法；
5. 增加了支持甘特图的mermaid语法¹ 功能；
6. 增加了 多屏幕编辑 Markdown文章功能；
7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
8. 增加了 检查列表 功能。

功能快捷键

撤销：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语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

删除文本

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片:

带尺寸的图片:

居中的图片:

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

• 项目
  • 项目
    • 项目

1. 项目1
2. 项目2
3. 项目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

如何创建一个注脚

一个具有注脚的文本。²

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma (n)=(n-1)!\forall n\in \mathbb{N}$ 是通过欧拉积分

$$\Gamma (z)={\int }_0^{\infty }{t}^{z-1}{e}^{-t}dt.$$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

• 关于 甘特图 语法，参考 这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

• 关于 Mermaid 语法，参考 这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

• 关于 Flowchart流程图 语法，参考 这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

---

1. mermaid语法说明 ↩︎

2. 注脚的解释 ↩︎