Python学习笔记0001：字符串切片问题解释

(1)（http://www.pythontab.com/html/2013/pythonjichu_0128/182.html）

先从原理上分析切片运算：  

list的切片，内部是调用__getitem__，__setitem__,__delitem__和slice函数。而slice函数又是和range()函数相关的。

给切片传递的键是一个特殊的slice对象。该对象拥有可描述所请求切片方位的属性，例如：

1 2 3 4

a = [  1 ,  2 ,  3 ,  4 ,  5 ,  6  ] x = a [  1  :  5  ] #  x = a.__getitem__( slice (  1 ,  5 , None ) ) a [  1  :  3  ] = [ 10 ,  11 ,  12  ]#  a.__setitem__( slice (  1 ,  3 , None ), [  10 ,  11 ,  12  ] ) del a [  1  :  4  ]#  a.__delitem__( slice (  1 ,  4 , None ) )

Python 的切片功能实际上比很多程序员认为的更强大。

1	a  =  m [  0  :  100  :  10  ]   #  带步进的切片（步进值=10）

注意：步进值为step

当step > 0 时

切片从 start(含start)处开始，到end（不含end）处结束，**从左往右**，每隔（step-1）（索引之间的差仍为step，但相隔的元素是step-1个）个元素进行一次截取。

这时，start 指向的位置应该在end指向的位置的左边，否则返回值为空

当step < 0 时

切片从 start(含start)处开始，到end（不含end）处结束，**从右往左**，每隔（step-1）（索引之间的差仍为step，但相隔的元素是step-1个）个元素进行一次截取。

这时，start 指向的位置应该在end指向的位置的右边，否则返回值为空

有一个经典应用是：翻转字符串

比如：

1 2	>>>  str = 'pythontab.com' >>>  str [:: - 1 ]

结果为：

'moc.batnohtyp'

切片边界问题

实例：

1 2 3 4 5 6

s = [ 1 , 2 , 3 , 4 ]        # S 上界为 0 下界为 4 s[ - 100 : 100 ]        #返回 [1,2,3,4] -100超出了上界，100超出了下界：等价于 s[0:4] s[ - 100 : - 200 ]       #返回 [] -100,-200均超出了上界，自动取上界：等价于s[0:0] s[ 100 : 200 ]         #返回 [] 100,200均超出了下界，自动取下界值：等价于s[4:4] s[: 100 ]            #返回 [1,2,3,4] 开始值省略表示从第0个开始 s[ 0 :]              #返回 [1,2,3,4] 结束值为空表示到最后一个结束

注意：我使用的python版本为python2.7，python的切片存在版本兼容问题。在python3中有更加高级的功能和用法，在使用时一定要注意自己的python版本。

(1)http://www.cnblogs.com/weidiao/p/6428681.html

关于list的insert函数

list#insert(ind,value)在ind元素前面插入value首先对ind进行预处理：如果ind<0，则ind+=len(a)，这样一来ind就变成了正数下标预处理之后，当ind<0时，ind=0，相当于头部插入当ind>len(a)时，ind=len(a)，相当于尾部插入

切片实例

Python中的列表切片非常灵活，要根据表象来分析它的内在机理，这样用起来才能溜。下标可以为负数有利有弊，好处是使用起来更简便，坏处是当我下表越界了我也不知道反倒发生奇奇怪怪的错误。

print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取

可见，列表的下标有三个参数：beg（起始下标），end（终止下标），delta（变化量）
当delta小于0时，beg默认为len（array）-1，end默认为开头之前。
当delta大于0时，beg默认为0，end默认为最末之后。
当delta未给出时：delta默认为1
这个代码示例演示了大概原理，学习一件事物，先学习它的表象，然后分析它的内在实现，最后查看源代码仔细推敲它到底是怎么实现的。

需要注意的是，列表切片产生的是列表的副本，与原列表不是同一份空间。

x=[1,2,3]
y=x[:]
x[0]=-1
print(y) #输出[1,2,3]

列表切片写操作

接下来探究切片的写操作

>>> x=[1,2,3,4,5]
>>> x[2:0]=100     #在2后面插入若干个元素，应该用列表
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
>>> x[2:0]=[100]
>>> x
[1, 2, 100, 3, 4, 5]
>>> del x[2:3]     #删除切片
>>> x
[1, 2, 3, 4, 5]
>>> x[2:1]=[100]   #对于切片x[from:to]，会进行预处理to=max(from+1,to)
>>> x
[1, 2, 100, 3, 4, 5]
>>> del x[2:0]     #对于切片del操作，如果from>to,不执行任何操作
>>> x
[1, 2, 100, 3, 4, 5]
>>> del x[2:1]
>>> x
[1, 2, 100, 3, 4, 5]
>>> del x[2:3]
>>> x
[1, 2, 3, 4, 5]
>>> x[2:4]=None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
>>> x[2:4]=[None]
>>> x
[1, 2, None, 5]

对列表切片进行深入理解：

def between(beg, end, mid):
    # 判断mid是否位于begin和end之间
    return end > mid >= beg or end < mid <= beg


def get_slice(a, beg, end, delta=1):
    # 数组切片get方式
    if delta == 0: raise ValueError("slice step cannot be 0")
    # 将负数下标转化一下
    if beg < 0: beg += len(a)
    if end < 0: end += len(a)
    # 如果转化完成之后依然不在合法范围内，则返回空列表
    if beg < 0 and end < 0 or beg >= len(a) and end >= len(a): return []
    # 如果方向不同，则返回空列表
    if (end - beg) * delta <= 0: return []
    # 将越界的部分进行裁剪
    beg = max(0, min(beg, len(a) - 1))
    end = max(-1, min(end, len(a)))
    ans = []
    i = beg
    while between(beg, end, i):
        ans.append(a[i])
        i += delta
    return ans


def set_slice(a, li, beg, end, delta=1):
    if delta == 0: raise ValueError("slice step cannot be 0")
    if delta == 1:
        # 如果delta==1，那么li的长度可以随意
        if beg < 0: beg += len(a)
        if end < 0: end += len(a)
        beg = max(0, min(beg, len(a) - 1))
        end = max(-1, min(end, len(a)))
        for i in range(beg, end):
            del a[beg]
        for i in reversed(li):
            a.insert(beg, i)
    else:
        # delta!=1,相当于替换
        if len(get_slice(a, beg, end, delta)) != len(li): raise ValueError("array don't match")
        if len(li) == 0: return
        if beg < 0: beg += len(a)
        if end < 0: end += len(a)
        beg = max(0, min(beg, len(a) - 1))
        # 用li中的全部元素逐一替换
        for ind, value in enumerate(li):
            a[ind * delta + beg] = value


def test_getSlice():
    a = list(range(10))
    import random
    for i in range(10):
        beg = random.randint(-15, 15)
        end = random.randint(-15, 15)
        delta = 0
        while delta == 0: delta = random.randint(-15, 15)
        print(len(get_slice(a, beg, end, delta)) == len(a[beg:end:delta]), beg, end, delta)


def test_setSlice():
    import random
    for i in range(10):
        a = list(range(10))
        beg = random.randint(-15, 15)
        end = random.randint(-15, 15)
        delta = 0
        while delta == 0: delta = random.randint(-5, 5)
        sz = len(a[beg:end:delta])
        if delta == 1: sz = random.randint(0, 4)
        li = [random.randint(0, 100) for i in range(sz)]
        set_slice(a, li, beg, end, delta)
        mine = a
        a = list(range(10))
        a[beg:end:delta] = li
        print(a == mine)


test_setSlice()