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 
#将列表中的元素反向存放。
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，就是将一些非常重要的不可让人改动的数据放在元组中，只供查看。

  扫描二维码关注公众号，回复： 6116605 查看本文章

  ​ 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