python基础学习day4list

1. 列表的初识

• why：int bool str

  • str： 存储少量的数据。
  • str：切片还是对其进行任何操作，获取的内容全都是str类型。存储的数据单一。

• what：list

  • list = [66, 'im',True,[1, 2, ‘False’]] 承载任意数据类型，存储大量的数据。
  • python常用的容器型数据类型。list 列表，其他语言：Java: 数组。
  • 列表是有序的，可索引，切片（步长）。

  1. 列表可以储存python中的任何对象：整数、浮点数、字符串、函数、布尔值、列表、元祖、字典等；

  2. 列表中的元素是有序且可变的；

2. 索引，切片，步长。**

li = [100, '我和你', True, [1, 2, 3]]# 索引
print(li[0], type(li[0]))
print(li[1],type(li[1]))
print(li[-1])
print(li[:2])# 切片 （顾头不顾尾）
>>>100 <class 'int'>
我和你 <class 'str'>
[1, 2, 3]
[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]

1. 列表的增删改查

   \1. 在列表末尾增加一个数据项（list.append()方法），没有返回值，与list.pop()对比。

   list1 = ['a','b',1,2]
   print(list1.append('c'))
   >>>None
   list1.append('c')
   print(list1)
   >>>['a','b',1,2,'c']
   
   #注意变量只是指向某种数据
   list1 = ['a','b',1,2]
   li1 = list1.append('c')  #li1只是一个方法动作
   li2 = list1
   print(li2)
   print(li1)
   list1.append(11)   
   print(li2)
   >>>
   ['a', 'b', 1, 2, 'c']
   None
   ['a', 'b', 1, 2, 'c', 11]    #li2指向的数据增加了元素11
   #两者对比。变量只是指向某种数据，并不是数据本身。
   a = 1
   b = a
   a = 2
   print(b)
   >>>1
   

   \2. 在列表末尾增加一个数据项集合（ 添加多个元素的方法,迭代追加）（list.extend()方法）；

   l1 = [1,2]
   l1.extend('abcd')
   print(l1)
   >>>[1, 2, 'a', 'b', 'c', 'd']
   l2 = [1,2]
   l2.extend(['asd',1,2])
   print(l2)
   >>>[1, 2, 'asd', 1, 2]
   

   \3. 列表的特殊插入法，；在特定位置增加一个数据项（list.insert()方法）：

   a=['b','c','d']
   a.insert(0,'a')
   a[0:1]
   >>>['a']
   

   \4. 从列表末尾删除数据,按照索引删除（list.pop()方法），若果没有给出索引值则默认删除最后列表的一个元素,有返回值，返回删除的元素，与list.append()对比；

   l1 = [1,2,3,4]
   l1.pop()
   print(l1)
   >>>[1,2,3]
   print(l1.pop(0))
   >>>1
   

   \5 . 在列表中删除一个特定项（list.remove()方法）；如果有重复的则默认删除第一个元素（从左开始）

   l1 = [1,2,3,3]
   l1.remove(3)
   print(l1)
   >>>[1, 2, 3]
   

   \6. list.clear()清空列表的方法，del 按照索引删除,也可以按照切片删除(可加步长)，无返回值

   l1 = [1,2,3,4,5,6]
   del l1[0]
   print(l1)
   >>>[2.3.4,5,6]
   del l1[0:4:2]
   print(l1)
   >>>[3,5,6]
   l1.clear()
   print(l1)
   >>>[]
   

   \7. 按照索引改元素；按照切片更改元素（迭代增加）,也可按照切片加步长更改，但必须一 一 对应。

   l1 = [1,2,3,4]
   l1[0] = 0
   print(l1)
   >>>[0,2,3,4]
   l1[1:] = 'abcd'
   print(l1)
   >>>[0, 'a', 'b', 'c', 'd']
   l1[::2]='123'
   print(l1)
   >>>['1', 'a', '2', 'c', '3']
   

   \8. b=sorted(a,reverse=True) 函数按照长短、大小、英文字母的顺序给列表中的元素进行排序，但不会改变列表本身

   l1 = ['c','b','a']
   l2 = sorted(l1)
   print(l2)
   >>>['a', 'b', 'c']
   print(l1)
   >>>['c', 'b', 'a']
   print(sorted(l1,reverse=False))
   >>>['a', 'b', 'c']
   

   \9. 在整理列表时，如果需要两个列表，可用zip函数：

   for a , b in zip(list1,list2)

   l1 = [1,2,3]
   l2 =['a','b']
   for x,y in zip(l1,l2):
       print(x,y)
   >>>1 a
   2 b
   

   \10. 推导式（列表的解析式：不仅方便，并且在执行的效率上更好）

   有许多元素要装进列表中：list = [i for i in range(1,11)] ，(range()： 类似于列表，自定制数字范围的数字列表，可索引，也可切片)，List = [item1 for item2 in iterable]

   l1 = [i for i in range(1,11,1)]   #步长可正可负，步长为1时可省略即为range(1，11)
   #若从0开始,步长为1则可写为range(11)
   print(l1)
   >>>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   

   \11. 列表是有序的，可以用enumerate()函数在索引的时候得到每个元素的具体位置：

   for num , str in enumerate(list):

   l1 = ['a','b','c']
   for num,int in enumerate(l1):
   	print(num,int)
   >>>0 a
   1 b
   2 c
   

2. 列表的嵌套

   l1 = [1, 2, 'woiyou', [1,'woi',2]]
   # 1, 将l1中的'woiyou'变成大写并放回原处。
   l1[2] = l1[2].upper()
   # 2，给小列表[1,'woheyou',3,]追加一个元素,'山就在那儿'。
   l1[-1].append('山就在那儿')
   # 3，将列表中的'wohe'通过字符串拼接的方式在列表中变成'you'
   l1[-1][1] += 'you'    #l1[-1][1] = l1[-1][1] + 'you'
   

3. 元组

   • 只读列表。存大量的数据，可以索引，切片（步长），不可更改，但元祖中列表里的元素可以按照列表更改，示例： (1, True, [1, 2, 3])。

   • 元祖的拆包：分别赋值,必须一 一对应。（列表也可以拆包，但一般不用）

     a,b = (1,2)
     print(a,b)
     >>>1 2
     a,b = [1,2]
     print(a,b)
     >>>1 2