Python3——列表：Python主力

2. 列表：Python主力

list是类型，而不是函数。（tuple和str亦是如此）

2.1 函数list

list("hello,")
>>['h', 'e', 'l', 'l', 'o', ',']

将字符列表转换为字符串，可使用''.join().

A=list("hello,")
print(A)
''.join(A)
>>['h', 'e', 'l', 'l', 'o', ',']
  'hello,'

2.2. 基本的列表操作

1. 修改列表:给元素赋值

x=[1,1,1]
x[1]=2
x
>>[1, 2, 1]

3. 删除元素 del

names=['1','2','3']
print(names)
del names[1]
print(names)
>>['1', '2', '3']
  ['1', '3']

4. 给切片赋值

name=list('perl')
name[2:]='ar'
name
>>['p', 'e', 'a', 'r']

name=list('perl')
name[2:]='ar'
name=''.join(name)
print(name)
>>pear

不同长度的赋值

name=list('perl')
name[1:]='ython'
name=''.join(name)
print(name)

不改变原有元素的情况下、插入新元素：

numbers=[1,5]
numbers[1:1]=[2,3,4]
numbers
>>[1, 2, 3, 4, 5]

采取相反的操作实现删除切片：

numbers=[1,2,3,4,5]
numbers[1:4]=[]
numbers
>>[1, 5]

与del numbers[1:4] 等效。

3. 列表的方法

调用方法：objext.method(arguments)

1. append()  #将一个对象附加到列表末尾
2. clear()  #清空列表内容
3. copy()   #复制列表。常规复制至少是将另一个名称关联到列表
4. count()  #计算指定的元素在列表中出现了多少次。
5. extend() #能同时将多个值附加到列表末尾
6. index()  #在列表中查找指定值第一次出现的索引。
7. insert() #将一个对象插入列表
8. pop()   #从列表中删除一个元素（末尾为最后一个元素），并返回该（被删除）元素。
9. remove() #删除第一个指定的元素。
10. reverse() #按相反的顺序排列列表中的元素
11. sort()  #用于对列表就地排序。
12. 高级排序 #方法sort接受两个可选参数：key 和 reverse

1.append() #将一个对象附加到列表末尾

lst=[1,2,3]
lst.append(4)
lst
>>[1, 2, 3, 4]

2.clear() #清空列表内容

lst=[1, 2, 3, 4]
lst.clear()
lst
>>[]

3.copy() #复制列表。
常规复制只是将另一个名称关联到列表：

a=[1,2,3]
b=a
b[1]=4
a
>>[1, 4, 3]

此时b 和a指向的是同一个列表。
要想a和b指向不同的列表，就必须将b关联到a的副本。

a=[1,2,3]
b=a.copy()
b[1]=4
print('a is:{}'.format(a))
print('b is:{}'.format(b))
>>a is:[1, 2, 3]
  b is:[1, 4, 3]

4.count() #计算指定的元素在列表中出现了多少次。

x=[1,[1,2,3],2,4,5,[1,5]]
x.count(1)
>>1

5.extend() #能同时将多个值附加到列表末尾为此可以将这些值组成的序列作为参数提供给方法extend. 换言之，可以使用一个列表来扩展另一个列表。

a=[1,2,3]
b=[4,5,6]
a.extend(b)
a
>>[1, 2, 3, 4, 5, 6]

6.index() #在列表中查找指定值第一次出现的索引。

x=[1,[1,2,3],2,4,5,[1,5]]
x.index([1,5])
>>5

7.insert() #将一个对象插入列表
与切片赋值相比，insert（）可读性更高。

x=[1,[1,2,3],2,4,5,[1,5]]
x.insert(3,'four')
x
>>[1, [1, 2, 3], 2, 'four', 4, 5, [1, 5]]

8.pop() #从列表中删除一个元素（末尾为最后一个元素），并返回该（被删除）元素。
pop()是唯一一个既修改列表，又返回非None值的列表方法。
可以实现一种常见的数据结构——栈（stack）.
栈（stack）：后进先出（LIFO）。

x=[1,[1,2,3],2,4,5,[1,5]]
x.pop()
>>[1, 5]

x
>>[1, [1, 2, 3], 2, 4, 5]

push()和pop()是大家普遍接受的两种栈操作的名称。Python没有提供push() 操作，但可以通过append()来代替。

x=[1,[1,2,3],2,4,5,[1,5]]
x.append(x.pop())
x
>>[1, [1, 2, 3], 2, 4, 5, [1, 5]]

队列：先进先出（FIFO）
可以使用insert(0,...) 代替append().
另外，也可以继续使用append(), 但用pop(0)代替pop().
一种更佳的解决办法是，使用模块collections中的deque.——第10章。

9.remove() #删除第一个指定的元素。

x=['to','be',  'or','not' , 'to', 'be']
print('x is:{}'.format(x))
x.remove('to')
print('new x is:{}'.format(x))

运行结果：

x is:['to', 'be', 'or', 'not', 'to', 'be']
new x is:['be', 'or', 'not', 'to', 'be']

这里只删除了第一个出现的’to’.
10.reverse() #按相反的顺序排列列表中的元素
reverse修改列表，但不返回任何值。

x=[1,2,3]
print('x is:{}'.format(x))
x.reverse()
print('reverse x is:{}'.format(x))

运行结果为：

x is:[1, 2, 3]
reverse x is:[3, 2, 1]

11.sort() #用于对列表就地排序。
就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

x=[7,8,5,4,1,2,4]
x.sort()
print('sort x is:{}'.format(x))

运行结果：

sort x is:[1, 2, 4, 4, 5, 7, 8]

如果不想改变原来的列表，，可以使用如下方法：
(1)

x=[7,8,5,4,1,2,4]
y=x.copy()
y.sort()
print('x is:{}'.format(x))
print('y is:{}'.format(y))

运行结果：

x is:[7, 8, 5, 4, 1, 2, 4]
y is:[1, 2, 4, 4, 5, 7, 8]

(2)为获得排序后列表的副本，可以使用函数sorted()

x=[7,8,5,4,1,2,4]
y=sorted(x)
print('x is:{}'.format(x))
print('y is:{}'.format(y))

运行结果：

x is:[7, 8, 5, 4, 1, 2, 4]
y is:[1, 2, 4, 4, 5, 7, 8]

sorted（）函数可以用于任何序列，返回一个列表。

sorted('Python')
>>['P', 'h', 'n', 'o', 't', 'y']

如果要将元素按相反的顺序排列，可以先使用sort或者sorted,再调用方法reverse;
也可以使用参数reverse.

12.高级排序 #方法sort接受两个可选参数：key 和 reverse
参数key 类似于参数cmp: 你将其设置为一个用于排序的函数。

例如：如果根据长度对元素进行排序，可将参数key设置为函数len.

3. 元组

与列表一样，元组也是序列。唯一的差别就是元组不可修改。
元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。

1,2,3
>>(1, 2, 3)

也可以用圆括号括起来：

(1,2,3)
>>(1, 2, 3)

即便只有一个元素，逗号也不能省略。

42
>>42

42,
>>(42,)

1. 函数tuple()
   函数tuple()的原理与list很像：它将一个序列作为参数，并将其转换为元组。

tuple([1,2,3])
>>(1, 2, 3)

元组的切片也是元组，就像列表的切片也是切片一样。

4. 一些迭代工具

1. 并行迭代

内置函数zip():将两个序列“缝合”起来，并返回一个由元组组成的序列。
返回值是一个适合迭代的对象，要查看其内容，可以使用list将其转换成列表。

names=['anny','silly','stupid']
ages=[14,25,42]
list(zip(names,ages))
>>[('anny', 14), ('silly', 25), ('stupid', 42)]

“缝合”后，可在循环中将元组解包。

for name,age in zip(names,ages):
    print(name ,'is:',age,'years old')

运行结果：

anny is: 14 years old
silly is: 25 years old
stupid is: 42 years old

函数zip可以“缝合”任意数量的序列。当序列的长度不等时，函数zip将在最短的序列用完后停止“缝合”。

2. 迭代时获取索引