python序列通用操作

python的序列类型

常用的python的序列类型有 列表，元组，字符串

空列表，空元组，空字符串的表示：[],tuple(),””

索引

索引分为正索引，和负索引

• 正索引：从左到右，下标值取 0到n-1 ，根据下标值的不同可以取到序列中所有的值
• 负索引：从右向左，下标值取 -1到-n , 根据下标值的不同可以取到序列中所有的值

切片

切片的操作不再是单一地取一个值了，而是取多个值，它需要起始索引和结束索引以及步长，同样它也支持正负索引，只不过使用时有些需要注意的地方（列表为例）

正向切片

结束索引<=开始索引将会获得一个空列表

a = [1,2,3,4,5,6]
b = a[0:]    #从开头到结尾
c = a[0:4]   #下标0，1，2，3
d = a[0:4:2] #步长为2，这样就是隔一个取一个了
print(a)  #a不变，代表切片返回的是副本
print(b)
print(c)
print(d)

'''
D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4]
[1, 3]
'''

反向切片

a = [1,2,3,4,5,6]
b = a[-1::-1]    #从结尾到开头取值
c = a[-1:-5:-1]   #下标-1，-2，-3，-4
d = a[-1:-5:-2] #步长为-2，这样就是从右向左隔一个取一个了
print(a)  #a不变，代表切片返回的是副本
print(b)
print(c)
print(d)

'''
D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]
[6, 5, 4, 3]
[6, 4]
'''

注意

从左到右无论是正索引还是负索引，都是逐渐变大的

 0  1  2  3  4  5  6  7  8
-9 -8 -7 -6 -5 -4 -3 -2 -1

步长的正负代表取值的方向，正数是从左到右取值(变大的方向)，负数是从右到左取值（变小的方向）

而开始位置 等于 结束位置一定是 得到空的序列（因为不包含结束位置）

开始位置 小于 结束位置 ，正步长可以得到结果，负步长还没走就结束了（空序列）

开始位置 大于 结束位置，正步长还没走就结束了（还），负步长可以得到非空

a = [1,2,3,4,5,6]
b = a[0:3:1]
c = a[0:3:-1]
d = a[2:2]
e = a[3:0:1]
f = a[3:0:-1]
# 负索引也是一样，关键是步长的正负，还有写位置的顺序
print(a)  #a不变，代表切片返回的是副本
print(b)
print(c)
print(d)
print(e)
print(f)
'''
D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[1, 2, 3, 4, 5, 6]
[1, 2, 3]
[]
[]
[]
[4, 3, 2]
'''

切片的逻辑的代码实现

a = [1,2,3,4,5,6]
def cut(start=0,end=len(a),step=1):
    #两种模式：
    b = []  #副本
    cout = start
    if(step>0): #此模式为+模式
        while(cout<end):
            b.append(a[cout])
            cout += step
    elif(step<0): #此模式为-
        while(cout>end):
            b.append(a[cout])
            cout += step
    else:
        return "error"
    return b
# 测试
list1 = cut(0)
tim1 = a[0:]
list2 = cut(1,5,2)
tim2 = a[1:5:2]
list3 = cut(-1,-5,-1)
tim3 = a[-1:-5:-1]
list4 = cut(5,0,1)
tim4 = a[5:0:1]
print(list1,tim1)
print(list2,tim2)
print(list3,tim3)
print(list4,tim4)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6]
[2, 4] [2, 4]
[6, 5, 4, 3] [6, 5, 4, 3]
[] []

序列相加和相乘

序列可以相加和相乘，结果是返回一次拼接和多次拼接的副本结果

相加

a = [1,2]
b = [1,2]
str_ = "112"
str1 = "110"
c = a+b
strx = str_+str1
print(c)
print(strx)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[1, 2, 1, 2]
112110

相乘

a = [1,2]
str_ = "112"
print(a*3)
print(str_*3)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[1, 2, 1, 2, 1, 2]
112112112

可变类型和不可变类型序列的+=

一句话来说，不可变类型序列对象不可以被改变，所以执行+=时变量只能绑定新的对象，而不会在原有序列对象上作拼接，所以它的+=和= +操作的结果是一致的；而可变类型的序列对象可以被改变，所以执行+=时就可以在自身上作拼接，而执行=+操作时，是绑定了新的对象。

不可变的元组

hen = 1
ha = hen  # hen,ha指向同一个对象
hen += 2
print("Integer:  hen:{},ha:{}".format(hen,ha))
# 类比不可变的整数
tu = (1,2)
gao = tu  # gao,tu指向了同一个对象
tu += (4,5) #指向另一个对象
print("Tuple:  tu:{},gao:{}".format(tu,gao))

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
Integer:  hen:3,ha:1
Tuple:  tu:(1, 2, 4, 5),gao:(1, 2)

可变的列表

hen = [1,2]
gao = hen  #指向同一个对象
hen += [5,6] #原对象拼接
print("List: hen:{} gao:{}".format(hen,gao))

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
List: hen:[1, 2, 5, 6] gao:[1, 2, 5, 6]

hen = [1,2]
gao = hen  #指向同一个对象
hen = hen + [5,6] #绑定了新的对象,可用id查看
print("List: hen:{} gao:{}".format(hen,gao))

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
List: hen:[1, 2, 5, 6] gao:[1, 2]

使用None创建有长度的空序列

a = 10*[None]
print(a)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
[None, None, None, None, None, None, None, None, None, None]

成员资格

使用in可以判断一个值是不是序列中的一个元素，返回布尔值

a = [1,2,3,4]
print(4 in a)
print(90 in a)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
True
False

序列长度，最大最小值

分别使用 len(),max(),min(), 比较大小时元素之间必须能够比较才行

a = [1,2,3,4]
print(len(a))
print(max(a))
print(min(a))
b = "str_"
print(len(b))
print(max(b))
print(min(b))

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
4
4
1
4
t
_

map()函数

#map() python2返回列表，python3返回迭代器
#实现了对序列中的所有元素的操作
#匿名函数的位置可以用一个自定义的函数的函数名代替，写上自己期望的操作
a = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
for i in range(5):
	print(next(a))

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
1
4
9
16
25

进程已结束,退出代码0

reduce()函数

# reduce(function, iterable[, initializer])
# 可以实现累加，累成或其他类似的操作
from functools import reduce
a = reduce(lambda x,y:x+y, (1,2,3,4))
print(a)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
10

进程已结束,退出代码0

带索引迭代 :enumerate()

L = ["aa","bb","kk"]
for index, name in enumerate(L):
    print (index, '-', name)

D:\Program_software_list\Anaconda3_5\python.exe C:/Users/asus/PycharmProjects/untitled/.idea/test.py
0 - aa
1 - bb
2 - kk

进程已结束,退出代码0