Python常用数据结构-列表 ——1.3 列表的使用：切片

切片[start:stop:step]
　　　　start值：指示开始索引值，如果没有指定，则默认值为0；
　　　　stop值：指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值
　　　　step值：步长值指示每一步大小，如果没有指定，则默认值步长为1。
三个值都是可选的，非必填。【注意事项】第一个冒号不可以省略，第二个冒号在步长被省略的时候可以省略。

 

1.切片操作是什么？
切片操作是访问序列中元素的一种方法，可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。在Python中，序列类型包括字符串、列表、元组、集合和字典，但是集合和字典不支持切片操作。

切片基本用法：

li = ["h","o","g","w","a","r","t","s"]
print(li[0:5:2])  # 打印['h', 'g', 'a']
print(li[2:4])    # 省略了step，['g', 'w']
print(li[:4])     # 省略了start和step，打印['h', 'o', 'g', 'w']
print(li[2:])     # 省略了stop和step，打印['g', 'w', 'a', 'r', 't', 's']
print(li[::2])    # 省略了start和stop，打印['h', 'g', 'a', 't']
print(li[::-1])   # 特殊的切片写法：逆序打印['s', 't', 'r', 'a', 'w', 'g', 'o', 'h']

 

字符串

栗子1：

# 正向范围取值 - 字符串
strs ="https://www.baidu.com/"

# 从第 0 个下标开始取值，到第 1 个下标结束，但不会取第 1 个下标的元素，最终取的是 0 下标的值
print(strs[0:1])

# 从第 0 个下标开始取值，到第 10 个下标结束，但不会取第 10 个下标的元素，最终取的是 1,2,3,4,5,6,7,8,9 下标的值
print(strs[0:10])

# 从第 5 个下标开始取值，到第 10 个下标结束，但不会取第 10 个下标的元素，最终取的是 5,6,7,8,9 下标的值
print(strs[5:10])

# 从第 5 个下标开始取值，到第 100 个下标结束，但因为字符串最长就 30 个字符，所以会取到最后一个结束就结束了
print(strs[5:100])

# 相同数字返回空
print(strs[5:5])

# 第二个数字比第一个数字小，返回空
print(strs[5:4])

# 从第 0 个下班开始取值，取后面所有元素
print(strs[0:])

# 取前面 10 个元素
print(strs[:10])

打印：

 栗子2

# 字符串的截取 字符串[开始索引:结束索引:步长]
num_str = "0123456789"
print(num_str[2:6]) # 2345 包含起始索引,不包含结束索引。 步长默认是1
print(num_str[2:])  # 23456789 默认截取到末尾
print(num_str[2:-1]) # 2345678 -1表示最后的索引。 不包含结束索引。
print(num_str[-2:]) # 89   截取末尾两个字符
print(num_str[0:6]) # 012345
print(num_str[:6])  # 012345 默认从起始开始截取
print(num_str[:])  # 0123456789
print(num_str[::2])  # 02468 步长(每隔步长个字符截取一个字符)
print(num

返回：

列表：

"""
使用模式: [start:end:step]
    其中start表示切片开始的位置,默认是0
    end表示切片截止的位置(不包含),默认是列表长度
    step表示切片的步长,默认是1
    当start是0时,可以省略;当end是列表的长度时,可以省略.
    当step是1时,也可以省略,并且省略步长时可以同时省略最后一个冒号.
    此外,当step为负数时,表示反向切片,这时start值应该比end值大.
    注意:切片操作创建了一个新的列表.
"""

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(alist[::])  # 返回包含原列表所有元素的新列表
print(alist[::-1])  # 返回原列表的一个逆序列表
print(alist[::2])  # [1, 3, 5, 7, 9] .取列表下标偶数位元素
print(alist[1::2])  # [2, 4, 6, 8]  取列表下标奇数位元素
print(alist[3:6])  # [4, 5, 6]  #取列表中下标3到6的值,步长是1
print(alist[3:6:2])  # [4, 6] #取列表中下标3到6的值,步长是2

print(alist[:10])  # [1, 2, 3, 4, 5, 6, 7, 8, 9]  . end大于列表长度时,取列表中所有元素,省略了步长1.
print(alist[10:]) # []  . 表示从列表的第10位开始取,一直取到列表结果,步长是1.

alist[len(alist):] = [10]  # 在列表的未尾添加一个元素
print(alist) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

alist[:0] = [-1,0]  # 在列表的头部插入元素. alist[:0] 相当于 alist[0:0] 再相当于 alist[0:0:1]
print(alist) #[-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

alist[5:5] = [-6]  # 把列表的第6个位置替换成-6. 相当于alist[5:5:1] = [-6]
print(alist) #[-1, 0, 1, 2, 3, -6, 4, 5, 6, 7, 8, 9, 10]

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9]
alist[:3] = ['A','B','C','D']  # 把alist的前3个元素换成['A','B','C','D']
print(alist)  #['A', 'B', 'C', 'D', 4, 5, 6, 7, 8, 9]

alist[3:] = ['E','F','G']  # 把列表第3个元素之后的元素替换成['E','F','G']
print(alist) # ['A', 'B', 'C', 'E', 'F', 'G']

alist = [1, 2, 3, 4, 5, 6]
alist[::2] = [0]*3 # 替换列表下标是偶数的前三个元素,注意使用该方法时,列表下标是偶数的元素个数必须与后面替换的元素个数相等,否则报错
print(alist) #[0, 2, 0, 4, 0, 6]

alist[::2] = ['a','b','c'] # 跟上面一样的道理,只是替换的内容不一样
print(alist) # ['a', 2, 'b', 4, 'c', 6]

alist = [1, 2, 3, 4, 5, 6]
alist[:3] = [] # 删除列表中前3个元素
print(alist) # [4, 5, 6]


alist = [1, 2, 3, 4, 5, 6]
del alist[:3]  # 使用del关键字删除列表前3个元素
print(alist) #[4, 5, 6]

alist = [1, 2, 3, 4, 5, 6]
del alist[::2]  # 删除列表元素,下标是偶数位的元素
print(alist) #[2, 4, 6]

打印：

元组

1.元组（tuple）的定义
Python的元组与列表类似，元组使用小括号，列表使用方括号。
元组创建很简单：只需要在括号中添加元素并使用逗号隔开
元组的格式：元组名 = （元素1，元素2，…）
元组（tuple）：不可改变数据类型
元组可以储存任何数据类型

t = (1,2,3,True,'westos')  创建元组
print(t)
print(type(t))  查看信息

打印结果
(1, 2, 3, True, 'westos')
<class 'tuple'>  tuple为元组



t = ([1,1.1,'westos'],True,False,3.14)元组的元素也可以是列表
print(t)
print(type(t))

打印结果
([1, 1.1, 'westos'], True, False, 3.14)
<class 'tuple'>



python元组里面添加元素
t = ([1,1.1,'westos'],True,False,3.14)
t[0].append(4)
print(t)

打印结果：因元组的而第一个元素为列表，所有4就被添加到了列表里面
([1, 1.1, 'westos', 4], True, False, 3.14)



创建只有一个元素的元组：错误方法如下
t = ('westos')
print(t)
print(type(t))

打印结果：字符串类型
westos
<class 'str'>



t = ('westos',)  创建元组时只有一个元素后面必须加逗号
print(t)
print(type(t))

打印结果
('westos',)
<class 'tuple'>

特性（其他可迭代对象也可以，这里元组举例子）

5.1.索引和切片

users = ('root','westos','redhat')
passwds = ('123','456','789')
print(users[0])
print(users[-1])
print(users[:-1])
print(users[1:])
print(users[::-1])

打印：

 5.2 重复

users = ('root','westos','redhat')
passwds = ('123','456','789')
print(users * 3)

打印结果：

 5.2 连接

users = ('root','westos','redhat')
passwds = ('123','456','789')
print(passwds + users+('321','654'))

打印结果：

5.3 成员操作

users = ('root','westos','redhat')
passwds = ('123','456','789')
print('redhat' in users)
print('redhat' not in users)
print('redhat' not in passwds)

打印返回：

 5.4 迭代

users = ('root','westos','redhat')
passwds = ('123','456','789')
for index,user in enumerate(users):
    print('第%d个用户: %s' %(index+1,user))

打印结果
第1个用户: root
第2个用户: westos
第3个用户: redhat



users = ('root','westos','redhat')
passwds = ('123','456','789')
for user,passwd in zip(users,passwds):
    print(user,':', passwd)

打印结果
root : 123
westos : 456
redhat : 789