序列

列表

创建

•  I = [365, 'everyday', 0.618, True] 即可。可以是不同类型数据的混合，

元素的增/删/切片

除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。中间插入或者前面添加元素，那么要变动新增元素后面所有元素的物理地址(存疑)，这样程序不友好。

• 添加：添加元素 l.append(1024)添加单个元素，或I.extend(b)添加b这个list到I。
  原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。
  
• 修改：l[0] = 123
• 删除：
   del a[0]    #删除列表a的第一个元素
   a.remove("tt")     #删除列表a中的第一个"tt"元素，没有这个元素就报错
   a.pop(0)    #删除列表a中的第一个元素，并将这个元素作为返回值。
   a.clear()     #清空列表中的元素，得到一个空列表
  
• 切片： l[1:3]  
  如果不指定第一个数，切片就从列表第一个元素开始。 如果不指定第二个数，就一直到最后一个元素结束。 都不指定，则返回整个列表；
  
• insert(不推荐)：a.insert(2,100)    #2对应位置编号，将100添加到list a作为第2个(实际是第3个)元素。

元素的访问和计数

遍历/排序/复制新(列表)对象

• 遍历：for i in l: 然后print(i)即可遍历l中所有的元素；
• 排序
• 复制：
  • • 相同物理地址：
      a = [20, 30]
      b = a
      print(id(a))
      print(id(b))
      两次输出结果一样，说明b只是复制了a中的地址来引用[20, 30]所在的物理位置。也就是栈中的两个元素a和b都对应堆中的同一个对象。
    • 不同物理地址
      a = [20, 30]
      b = [] +a
      两个变量分别对应两个对象，只是这两个对象数值和类型上相同，但是ID(物理地址)不同。

内置函数/多维列表

print(list(range(1,10)))输入结果为[1, 2, 3, 4, 5, 6, 7, 8, 9]
l = [365, 'everyday', 0.618, True]可以是不同类型数据的混合，
(1)  for i in l:然后  print(i)即可遍历l中所有的元素;
(2)  print (l[1])输出'everyday'
(3)  修改元素l[0] = 123，原list变为[123, 'everyday', 0.618, True]；
(4)  添加元素 l.append(1024)，原list变为 [123, 'everyday', 0.618, True, 1024]；
如果在中间插入或者前面添加元素，那么要变动新增元素后面所有元素的物理地址(存疑)，这样程序不友好，因此append方法原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。
对列表a=a+[50]，这样生成的a不是原地扩展，得到的是一个新的物理地址的列表a。
(5)  删除元素del l[0]，原list变为 ['everyday', 0.618, True, 1024]；
(6)  负索引(index)，l[-3]表示倒数第3个元素；
(7)  切片(slice)，l[1:3]得到的结果是['everyday', 0.618]，如果不指定第一个数，切片就从列表第一个元素开始。 如果不指定第二个数，就一直到最后一个元素结束。 都不指定，则返回整个列表；
(8)  extend()操作，这个和append很类似，也是原地尾部操作，不同之处append是添加单个元素，extend是添加多个元素组成的list。
a=[20, 30] b=[10, 40] a.extend(b)
print(a)
得到的结果是：[20, 30, 10, 40] (9) insert的用法(不推荐)
>>> a = [10,20,30] >>> a.insert(2,100)    #2对应位置编号
>>> a
[10, 20, 100, 30] (10)  列表元素的删除，前面只讲了del操作，其实还有pop()，remove()上图是del操作示意图，会出现元素的拷贝，所以效率不高。
pop()删除并返回指定位置元素（比如 a.pop(1) ），如果未指定位置则默认操作列表最后一个元素。
a.remove(20) 表示删除list   a中首次出现的20这个元素，若想要删除的元素不存在，则抛出异常。

汇总一下：
del a[0]   #删除列表a的第一个元素
a.remove("tt")   #删除列表a中的第一个"tt"元素，没有这个元素就报错
a.pop(0)  #删除列表a中的第一个元素，并将这个元素作为返回值。
a.clear()   #清空列表中的元素，得到一个空列表

(11)  列表的遍历
for obj in listObj:
print(obj)
(12)  列表的复制
a=[20, 30]
b=a
print(id(a))
print(id(b))
输出两个相同的物理地址，说明b只是复制了a中的地址来引用[20, 30]所在的物理位置。也就是栈中的两个元素a和b都对应堆中的同一个对象。
a=[20, 30]
b=[]+a
print(id(a))
print(id(b))
修改之后就是两个变量分别对应两个对象，只是这两个对象数值和类型上相同，但是ID(物理地址)不同。
(13)  a.sort()原地排序， a.sort(reverse=True) 也是原地排序(降序)，random.shuffle(a)原地打乱顺序。注意这些都是有返回值的，所以不能写类似b=a.sort()。
a = sorted(a)或者c = sorted(a,reverse=True) 则是新建了一个列表，开拓了一个新的内存空间。

对于列表a=[10, 20, 30, 40]来说，list里面的物理地址是连续的。

例子：
a=[1,2,3]
print(id(a[0]))
print(id(a[1]))

输出结果：
1688590512
1688590528   #12+16   每个unicode是16位。

list(字符串)得到将字符串转变为list。
list(range(10))将range的type变为list。

24.  字符串的分割split()
(1)  sentence = 'I am an English sentence'
a=sentence.split()   （默认按照空格/换行/制表符分割）
(2)  指定分隔符'.'，
section = 'Hi. I am the one. Bye.'
a=section.split('.')
得到['Hi', ' I am the one', ' Bye', '']

25. 用join函数连接list中的元素
(1) a=';'.join(['apple', 'pear', 'orange'])
print(a)得到apple;pear;orange
(2)  s = ';'
li = ['apple', 'pear', 'orange']
fruit = s.join(li)
print (fruit)同样得到apple;pear;orange
(3) a=''.join(['hello', 'world'])
print (a)得到helloworld

26. 字符串的遍历/索引/切片/连接
这个个list里面的用法很类似
(1)  遍历
word = 'helloworld'
for c in word:
print(c)
(2)  索引(与list不同的是，字符串不能通过索引访问去更改其中的字符)
print (word[0])
print (word[-2])
(3)  切片
print (word[5:7])
print (word[:-5])
print (word[:])
(4)  连接
a = ','.join('word')
print(a)得到w,o,r,d