Python基础数据类型：列表【增删改查】，元组。range
作者：互联网
1 知识大纲
- 列表的初识
- 列表的索引切片
- 列表的增删改查
- 列表的嵌套
- 元组的初识（了解）
- 元组的简单应用（了解）
- range
2 主要内容
1.列表的初识
why：
- 字符串： 存储少量的数据。字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。
- 字符串：无论切片还是对其进行任何操作，获取的内容全都是str类型。字符串存储的数据类型太单一，只能是字符串类型。
what：list
- 容器类数据类型：能承载多种数据类型。它可以存储大量的数据。列表list就属于容器类的数据类型。
- 列表相比于字符串，不仅可以储存不同的数据类型（承载任意数据类型），而且可以储存大量数据。l1 = [100, 'alex',True,[1, 2, 3]]
- 列表是有序的，需要存索引相关信息。有索引值，可切片（步长），方便取值。
Where:
你需要存储大量的数据，且需要这些数据有序的时候。
制定一些特殊的数据群体：按顺序，按规则，自定制设计数据。
2.索引，切片，步长
li = [100, '太白', True, [1, 2, 3]]
# 索引
列表索引，其在列表中是什么数据类型，取出来就是什么数据类型，如数字，字符串，列表...
print(li[0], type(li[0])) #100 <class 'int'>
print(li[1],type(li[1])) #太白 <class 'str'>
print(li[-1],type(li[-1])) #[1, 2, 3] <class 'list'>
# 切片 （顾头不顾腚）
列表切片，得到的都是列表类型的数据。
print（li[0:1]） #[100]
print(li[:2]) #[100, '太白']相关练习题：
li = [1, 3, 2, "a", 4, "b", 5,"c"]
通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l1 = li[0:3]
print(l1)
l2 = li[3:6]
print(l2)
l4 = li[1:6:2]
l4 = li[1:-2:2]
print(l4)
l6 = li[-3:0:-2]
print(l6)3.列表的增删改查 【重点，记住】
# 列表的创建
# 方式一
l1 = []#创建空列表
l1 = [1, 2, 'Alex',True,[1, 2, 3]] ###【填入的数据可以是int,bool,str,list类型】
# 方式二
l1 = list() #创建空列表
print(l1) # []
# l1 = list(iterable) # 可迭代对象
l1 = list('fhdsjkafhsdaf') ###【填入的数据必须是可迭代的，如str,list。不能是int：TypeError: 'int' object is not iterable，bool：TypeError: 'bool' object is not iterable】
print(l1) #['f', 'h', 'd', 's', 'j', 'k', 'a', 'f', 'h', 's', 'd', 'a', 'f']
# 方式三：列表推导式
l1 = [i for i in range(1,5)]
print(l1) # [1, 2, 3, 4]
# 增删改查
字符串的常用操作方法,不会对原字符串进行任何操作，都是产生一个新的字符串
s1 = 'aafsfjgk'
print(s1) #aafsfjgk
print(s1.upper()) #AAFSFJGK
print(s1) #aafsfjgk
列表的增删改查--->改变了原列表
l1 = ['hha','heihei','hehe']
print(l1) #['hha', 'heihei', 'hehe']
l1.append('hhh')
print(l1) #['hha', 'heihei', 'hehe', 'hhh']
# 增：
append
#追加，给列表的最后面追加一个元素
l1 = ['太白', '女神', 'xiao','吴老师', '闫龙']
l1.append('xx')
print(l1.append('xx')) # 不能打印它 #None
print(l1)
# 举例：
l1 = ['太白', '女神', '吴老师', 'xiao', '闫龙']
while 1:
name = input('请输入新员工姓名：(Q或者q退出程序)')
if name.upper() == 'Q': break
l1.append(name)
print(l1)
insert
#插入，在列表的任意位置插入元素 insert(index,object)
l1 = ['太白', '女神', 'xiao','吴老师', '闫龙']
l1.insert(2,'wusir')
print(l1) #['太白', '女神', 'wusir', 'xiao', '吴老师', '闫龙']
extend
#迭代着追加，在列表的最后面迭代着追加一组数据【把可迭代对象拆解为最小元素，如字符串'abcd'---->'a','b','c','d' 列表 ['alex', 1, 3] ---> 'alex', 1, 3 】
#extend后面括号里填入的数据必须是可迭代的，如str，list，不能是int，bool类型，会报错
l1 = ['太白', '女神', 'xiao', '吴老师', '闫龙']
l1.extend('abcd')
print(l1) #['太白', '女神', 'xiao', '吴老师', '闫龙', 'a', 'b', 'c', 'd']
l1 = ['太白', '女神', 'xiao', '吴老师', '闫龙']
l1.extend(['alex',])
print(l1)#['太白', '女神', 'xiao', '吴老师', '闫龙', 'alex']
l1 = ['太白', '女神', 'xiao', '吴老师', '闫龙']
l1.extend(['alex', 1, 3])
print(l1) #['太白', '女神', 'xiao', '吴老师', '闫龙', 'alex', 1, 3]
# 删
pop
#按照索引位置删除，通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
#pop(index)
l1 = ['太白', '女神', 'xiao', '吴老师', '闫龙']
l1.pop(-2) # 按照索引删除 （返回的是删除的元素）
print(l1.pop(-2)) # xiao
print(l1) #['太白', '女神', '闫龙']
l1 = ['太白', '女神', 'xiao', '吴老师', '闫龙']
l1.pop() # 默认删除最后一个
print(l1) #['太白', '女神', 'xiao', '吴老师']
remove
#指定元素删除,如果有重名元素，默认删除从左数第一个
#remove（object）
l1 = [ 'xiao','太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
l1.remove('xiao')
print(l1) #['太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
clear清空 (了解)
l1 = [ 'xiao','太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
l1.clear() #清空
print(l1) #[]
del
#按照索引删除该元素
l1 = [ 'xiao','太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
del l1[0] #['太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
print(l1)
# 按照切片删除该元素
l1 = [ 'xiao','太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
del l1[0:2]
# print(l1) #['女神', 'xiao', '吴老师', '闫龙', 'xiao']
#按照切片（步长）删除该元素
l1 = [ 'xiao','太白', '女神', 'xiao', '吴老师', '闫龙', 'xiao']
del l1[0:5:2]
print(l1) #['太白', 'xiao', '闫龙', 'xiao']
# 改
#按照索引改值
l1 = [ '太白', '女神', 'xiao', '吴老师', '闫龙']
l1[0] = '男神'
print(l1) #['男神', '女神', 'xiao', '吴老师', '闫龙']
l1 = [ '太白', '女神', 'xiao', '吴老师', '闫龙']
l1[2] = l1[2].upper()
print(l1) #['太白', '女神', 'XIAO', '吴老师', '闫龙']
#按照切片改（迭代着增加） 【了解】 按照切片改，迭代着增加【把可迭代对象分解为最小元素】。按理说删除几个，增加几个。但是此处可以增加多个，删除元素的个数不用和增加元素的个数对应。
l1 = [ '太白', '女神', 'xiao', '吴老师', '闫龙']
l1[3:] = 'amgnrih'
print(l1) #['太白', '女神', 'xiao', 'a', 'm', 'g', 'n', 'r', 'i', 'h']
#按照切片步长改（必须一一对应） 【了解】必须一 一对应，改几个位置，写几个元素，多了会报错。
l1 = [ '太白', '女神', 'xiao', '吴老师', '闫龙']
l1[::2] = 'amg'
print(l1) #['a', '女神', 'm', '吴老师', 'g']
#自
l1 = ['太白', '女神', 'xiao', '吴老师', '闫龙']
l1[::2] = [1,2,[3,4]]
print(l1) #[1, '女神', 2, '吴老师', [3, 4]]
l1 = [ '太白', '女神', 'xiao', '吴老师', '闫龙']
l1[::2] = 'abcd' #必须一一对应，改几个位置，写几个元素，多了会报错。
print(l1) #报错
# 查：切片去查，或者循环去查。 索引，切片（步长）
l1 = [ '太白', '女神', 'xiao', '吴老师', '闫龙']
for i in l1:
print(i)
循环列表，改变列表大小的问题
注意：在循环一个列表时的过程中，如果你要改变列表的大小（增加值，或者删除值），那么结果很可能会出错或者报错。因为某些元素的原索引值会改变
#应用实例：请把索引为奇数对应的元素删除 l1 = [11, 22, 33, 44, 55] l1可以为任意一个列表，元素个数不定
方法：直接删除 倒序删除 思维置换
#自己编写
#方法1：直接删除 按照切片步长删除
l1 = [11, 22, 33, 44, 55]
del l1[1::2]
print(l1)
#方法2：倒序删除
#从后往前倒着删除，不会改变前面元素的序号。分析知道：
# 如果列表中的元素个数为奇数n，要删除索引号为奇数（正奇数1,3,5,...）的元素，倒着删除，
# 每次删除一个元素，要从-2开始删除，删除后下一次要删除元素的索引号变为-3，再下一次变为-4，直到-(n+1)/2,这个数必须为整数int类型
# 因为range顾头不顾腚，所以其范围要多一位，即-(int((n+1)/2)+1)
# 如果列表中的元素个数为偶数n，要删除索引号为奇数（正奇数1,3,5,...）的元素，倒着删除，
# 每次删除一个元素，要从-1开始删除，删除后下一次要删除元素的索引号变为-2，再下一次变为-3，直到-n/2,这个数必须为整数int类型，
# 可以用-n//2,取一个负整数。因为range顾头不顾腚，所以其范围要多一位，即-(n//2+1)
l1 = [11, 22, 33, 44, 55]
if len(l1) % 2 == 1:
for i in range(-2,-(int((len(l1) + 1)/2)+1),-1):
l1.pop(i)
elif len(l1) % 2 == 0:
for i in range(-1,-((len(l1) // 2)+1),-1):
del l1[i] #同l1.pop(i)
print(l1)
#方法3：思维置换
l1 = [11, 22, 33, 44, 55]
for i in range(0,len(l1)):
if i % 2 == 1:
l1[i] = ' ' #将所有索引号为奇数的元素修改为同一个元素，如空格' '
num = l1.count(' ') #统计列表中空格的个数，决定了删除的次数
for i in range(0,num):
l1.remove(' ') #因为remove按指定元素删除,如果有重名元素，默认删除从左数第一个，所以要删除多次
print(l1) #[11, 33, 55]
#################################################################
补充操作方法：
count（数）
#（方法统计某个元素在列表中出现的次数）。
a = ["q","w","q","r","t","y"]
print(a.count("q"))
index 注意：是某个值‘第一个’匹配项的索引
#（方法用于从列表中找出某个值第一个匹配项的索引位置）
a = ["q","w","r","t","y"]
print(a.index("r"))
########################注意############
#####1.
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai "]
for i in li:
j = li.index(i) #从列表中找出某个值"第一个"匹配项的索引位,注意是第一个
print(j)
#结果：
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 0
#####2.
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai "]
for i in li:
j = li.index(i) #从列表中找出某个值"第一个"匹配项的索引位,注意是第一个
i = i.strip() #将i两边空白去掉，再赋值给i,此时列表内的对应的元素不会修改
li[j] = i #对比发现，按照索引修改列表值的时候，重复出现元素的索引位改变成7了，不是上边的0了。此时列表内对应的元素才会修改成功
print(j)
print（li） #['TaiBai', 'alexC', 'AbC', 'egon', 'riTiAn', 'WuSir', 'aqc', 'TaiBai']
# 结果：
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
###############继续测试---->
个人总结：单纯查看j = li.index(i)的值得时候，得到的是列表中某个值"第一个"匹配项的索引位。但是，通过索引修改列表内某个值，即li[j] ='要修改成的值'时，j的索引值就是其实际索引位。
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc",]
for i in li:
j = li.index(i) #从列表中找出某个值"第一个"匹配项的索引位,注意是第一个
print(j)# 0 1 2 3 4 5 6 0 1 2 3 4 5 6
print(li) #['TaiBai ', 'alexC', 'AbC ', 'egon', ' riTiAn', 'WuSir', ' aqc', 'TaiBai ', 'alexC', 'AbC ', 'egon', ' riTiAn', 'WuSir', ' aqc']
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc","TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc",]
for i in li:
j = li.index(i) #从列表中找出某个值"第一个"匹配项的索引位,注意是第一个
i = i.strip()
li[j] = i
print(j)# 0 1 2 3 4 5 6 7 1 9 3 11 5 13
print(li)#['TaiBai', 'alexC', 'AbC', 'egon', 'riTiAn', 'WuSir', 'aqc', 'TaiBai', 'alexC', 'AbC', 'egon', 'riTiAn', 'WuSir', 'aqc']
#########################
sort
#方法用于在原位置对列表进行排序。
a = [2,1,3,4,5]
a.sort()# 他没有返回值，所以只能打印a
print(a) #[1, 2, 3, 4, 5]
#测试1
a = ['b','d','c','a','z','w'] #列表中的元素全部为同一个类型的，如int或str，才可用sort
a.sort()
print(a)#['a', 'b', 'c', 'd', 'w', 'z']
#测试2
a = ['bc','d','cd','a','zr','w','bd']
a.sort()
print(a)#['a', 'bc', 'bd', 'cd', 'd', 'w', 'zr'] #按照字符串首字母排序，首字母相同按第二个字母排序
reverse
#
p;将列表中的元素反向存放。
a = [2,1,3,4,5]
a.reverse()#没有返回值，所以只能打印a
print(a) #[5, 4, 3, 1, 2]
# 列表也可以相加与整数相乘
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]
print(l1*3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
4.列表的嵌套【必须会，重中之重】
l1 = [1, 2, 'taibai', [1, 'alex', 3,]]
# 1, 将l1中的'taibai'变成大写并放回原处。
l1[2] = l1[2].upper()
# 2，给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。
l1[-1].append('老男孩教育')
# 3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'
l1[-1][1] = l1[-1][1] + 'sb'
l1[-1][1] += 'sb'
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 将列表lis中的"tt"变成大写（用两种方式）。
lis[3][2][1][0] = lis[3][2][1][0].upper()
lis[3][2][1][0] = 'TT'
# 将列表中的数字3变成字符串"100"（用两种方式）。
lis[3][2][1][1] = '100'
lis[3][2][1][1] = str(lis[3][2][1][1] + 97)
# 将列表中的字符串"1"变成数字101（用两种方式）。
lis[3][2][1][2] = 101
lis[3][2][1][2] = int('10' + lis[3][2][1][2] )
print(lis)
5.元组(了解)
Why:对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元组。
what:这个容器型数据类型就是元组。
元组:俗称不可变的列表,又被成为只读列表,元组也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.
Where:(用在哪里)
1，就是将一些非常重要的不可让人改动的数据放在元组中，只供查看。
2，常用于元组的拆包
只读列表。存大量的数据，可以索引，切片（步长）
#元组的索引切片 tu1 = ('a', 'b', '太白', 3, 666) print(tu1[0]) # 'a' print(tu1[-1]) # 666 print(tu1[1:3]) # ('b', '太白') print(tu1[:-1]) # ('a', 'b', '太白', 3) print(tu1[::2]) # ('a', '太白', 666) print(tu1[::-1]) # (666, 3, '太白', 'b', 'a') tu = (100, '太白', True, [1, 2, 3]) print(tu[0]) #100 print(tu[:3]) #(100, '太白', True) #元组内嵌套的列表内的元素可更改，但是不能删除。 tu = (100, '太白', True, [1, 2, 3]) tu[-1].append(597) #可以更改列表中的数据 print(tu) #(100, '太白', True, [1, 2, 3, 597]) tu = (100, '太白', True, [1, 2, 3]) del tu[2] #不能删除，此时会报错 print(tu) 应用： # 重要数据，用户名，密码，个人信息，不想让别人改动的一些数据，存在元组中。 元组的拆包。分别赋值。 a, b = (1, 2) # 多一个少一个都不行 print(a,b) # 1 2 c = (1,2) a,b = c print(a,b) #1 2 # 可以利用for循环查询，查看 tu1 = ('a', 'b', '太白', 3, 666,True, [1, 2, 3]) for i in tu1: print(i) #index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。 tu = ('太白', [1, 2, 3, ], 'WuSir', '女神') print(tu.index('太白')) # 0 #count: 获取某元素在列表中出现的次数 tu = ('太白', '太白', 'WuSir', '吴超') print(tu.count('太白')) # 2 #len tu1 = (1,2,3,4,84,5,2,8,2,11,88,2) print(len(tu1)) 结果: 12 #python中元组有一个特性，元组中如果只含有一个元素且没有逗号，则该元组不是元组，与该元素数据类型一致，如果有逗号，那么它是元组。 tu = (1) print(tu,type(tu)) # 1 <class 'int'> tu1 = ('alex') print(tu1,type(tu1)) # 'alex' <class 'str'> tu2 = ([1, 2, 3]) print(tu2,type(tu2)) # [1, 2, 3] <class 'list'> tu = (1,) print(tu,type(tu)) # (1,) <class 'tuple'> tu1 = ('alex',) print(tu1,type(tu1)) # ('alex',) <class 'tuple'> tu2 = ([1, 2, 3],) print(tu2,type(tu2)) # ([1, 2, 3],) <class 'tuple'>
6.range：
类似于列表，可以自定制数字范围的数字列表。 只能是数字
range与for循环结合。
#range：指定范围，生成指定数字。
# 顾头不顾腚
r = range(10) #相当于range(0, 10) 只有一个参数时，默认从0开始，步长为1
print(r)
for i in r:
print(i) #打印出0-9
#例子
for i in range(1,101):
print(i) #打印1-100
for i in range(2,101,2):
print(i) #打印100以内所有偶数
for i in range(1,101,2): #步长
print(i) #打印100以内所有奇数
for i in range(100,0,-1): #反向步长
print(i) #逆序打印从100到1
#求1-100的和
sum = 0
for i in range(1, 101):
sum += i
print(sum)
#利用len和range打印列表的索引：利用for循环，利用range将l1列表的所有索引依次打印出来
l1 = [1, 2, 3, 'alex', '太白']
for i in range(len(l1)):
print(i)
# 索引（了解）
r = range(10)
print(r[1]) #1
for i in range(3):
pass
print(i) #2 循环结束后i从0变为2标签：太白,Python,数据类型,改查,xiao,列表,l1,print,li 来源： https://www.cnblogs.com/xiaomage666/p/10809312.html