大话Python切片，助你彻底掌控切片小妖精

切片语义

　　生活中切黄瓜、切萝卜、一本书的每一页等等都是符合切片的语义

　　切片的语义是从某个东西中通过某种手段拿到某个整体的一部分

　　切片是拿来主义，建立在已经有的序列上，有黄瓜才能切黄瓜

 

 列表 -> python中最典型的序列类型

　　形式 [vaule, ...]

nums = [17, 71, 93, 69, 79, 14, 33, 7, 64, 58, 77, 75, 98, 61, 39, 50, 1, 69, 60, 20]
names = ["北门吹雪", "小一", "王五", "李四", "张三", "王二"]

 那如何对其切片呢？

　　[start:end:step]

　　切片是建立在已有的列表上通过索引手段取得列表的一部分，计算机语言叫读取

 　　索引是下标访问，下标是一个整数，一个从0开始的递增的数，如 0 1 2 3 4 5 6 7 8 ...

def see_seq(iterable):
    """通过索引遍历序列，遍历序列的语义是依次读取序列中的每一个元素"""
    # 序列开始的下标为 0，也就是索引为 0
    # 序列第一个元素的下标是0，也就是第n个元素的下标为 n-1
    # index 就是下标，从 0 到 序列最后一个元素索引 len(iterable) - 1
    index = 0
    while True:
        # 通过索引读完索引对应的值 -> [i]
        print(iterable[index])

        # 每次读取完，则读取下一个，索引在原来基础上加一
        index += 1

        # 判断边界条件，也就是序列是否读完，读完则推出循环
        # 序列的元素个数为 n = len(iterable), 那么最后一个元素的下标为 n-1
        if len(iterable) - 1 == index:
            break

    # 懂python的都知道for循环，for循环专用于序列的遍历
    # 但for循环建立的基础语义有 迭代器 临时变量 可迭代对象 计数器，复杂难以理解
    # 但for循环语句简洁
    pass


if __name__ == "__main__":
    # 初始列表
    nums = [17, 71, 93, 69, 79, 14, 33, 7, 64, 58, 77, 75, 98, 61, 39, 50, 1, 69, 60, 20]
    names = ["北门吹雪", "小一", "王五", "李四", "张三", "王二"]

    # 调用函数，通过索引方式遍历序列
    see_seq(nums)
    see_seq(names)

　　切片是建立在索引之上，通过从开始索引取到结束索引但不包括结束索引

　　

[start:end:step]

　　切片最重要的计算公式  -end < (start + 0... * step)  < end

　　1. start 开始索引，省略则为0， start = 0

　　2. end 结束索引，省略则为列表长度(列表中元素的个数), end = len(seqence)

　　3. step 为步长，索引之间的间隔，等差数列

def get_slice(_list, start=None, end=None, step=None,):
    """模拟实现切片语义"""
    # 省略开始值则为 0
    if start is None:
        start = 0
    # 省略结束值则为其长度 len(_list)
    if end is None:
        end = len(_list)
    # 省略步长，则步长为 1，阻止小朋友传入0步长
    if step is None or step == 0:
        step = 1

    # 切片实现总要公式-end < (start + 0... * step)  < end
    # 保存结果列表
    result = []
    # 核心计数count，始终是从0开始自增1
    count = 0
    while True:
        # 核心计算公式
        list_index = start + count * step
        # 通过核心公式计算出索引对列表取值
        elem = _list[list_index]

        # 处理步长为正数情况，list_index 的值为 正数
        if step > 0 and not (list_index < end):
            break

        # 处理步长为负数情况, list_index 的值为 负数
        if step < 0 and not(list_index > end):
            break

        result.append(elem)
        # 计数器自增1
        count += 1

    # 返回结果
    return result


if __name__ == "__main__":
    # 初始列表
    names = ["北门吹雪", "小一", "王五", "李四", "张三", "王二", "小明", "小爱", "小溪"]

    # python内置切片
    slice_one = names[-1:-5:-1]
    # 自定义切片语义的实现
    slice_two = get_slice(names, -1, -5, -1)

    # 对比发现一致
    print(slice_one)
    print(slice_two)

 亲，切片不难

附带for循环遍历序列的方式

 for 循环的原理是

　　1. 把序列变成一个迭代器，然后保存在一个内部临时变量中 temp_var = iter(iterable)
　　2. 通过内置函数next()调用迭代器中的 __next__方法获取下一个数据  item = next(temp_var)
　　3. 到了边界，迭代器会触发一个迭代器耗尽异常，for循环会自动捕获，终止for循环

def see_seq(iterable):
    """通过for循环遍历序列，遍历序列的语义是依次读取序列中的每一个元素"""
    # 序列开始的下标为 0，也就是索引为 0
    # 序列第一个元素的下标是0，也就是第n个元素的下标为 len(iterable) - 1

    # for 循环自动处理索引、索引边界
    # 自动依次取出 0 到 len(iterable)-1 索引对应的值
    # 是不是很简洁？
    for item in iterable:
        print(item)

    # 打印分隔符
    print("等价for语句".center(20, "-"))
    # for 循环的原理是
    # 1. 把序列变成一个迭代器，然后保存在一个内部临时变量中 temp_var = iter(iterable)
    # 2. 通过内置函数next()调用迭代器中的 __next__方法获取下一个数据  item = next(temp_var)
    # 3. 到了边界，迭代器会触发一个迭代器耗尽异常，for循环会自动捕获，终止for循环

    # 等价语句
    temp_var = iter(iterable)                   # 把序列变成一个迭代器
    while True:
        try:
            item = next(temp_var)               # next()调用迭代器
        except StopIteration:                   # 迭代器耗尽异常，推出循环
            break

        # 以上是for循环自动完成，这一行才是循环体
        print(item)


if __name__ == "__main__":
    # 初始列表
    nums = [17, 71, 93, 69, 79, 14, 33, 7, 64, 58, 77, 75, 98, 61, 39, 50, 1, 69, 60, 20]
    names = ["北门吹雪", "小一", "王五", "李四", "张三", "王二"]

    # 调用函数，通过索引方式遍历序列
    see_seq(nums)
    see_seq(names)