Python学习：列表和元组

Python 中有一种名为容器的数据结构。
容器基本上是包含其他对象的任意对象。
序列（例如列表和元祖）和映射（例如字典）是两类主要的容器。
序列中的每个元素都有自己的编号，而映射中的每个原色则有一个名字（也称为键）
两种相同类型的序列才能进行连接操作

a = [1,2,3,4]
b = "Hello"
c = "Jack"

a + b
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list

b + c
'HelloJack'

一、 列表

1. 创建列表

test = []	#可以是空列表
test = [1,'a','汉字',[2,3,4]]	#也可是混杂列表
1
2

1. 向列表中添加元素

number = [1,2,3]
#末尾添加一个元素
number.append(4)
#末尾添加多个元素
number.extend([5,6])
#指定位置添加元素
number.insert(0,0)
number = [0,1,2,3,4,5,6]
1
2
3
4
5
6
7
8

3. 从列表中获取元素

#通过元素的索引值（index）
number[3]
1
2

4. 从列表中删除元素

#number = ['小明’，1,2,3,4,5]
#remove 按照元素名字删除
number.remove(‘小明’)
#del 是一个语句，按索引值删除元素，还可以删除整个列表如：del number
del number[1]
# 按索引值从列表中取出元素并返回，pop()默认弹出最后一个元素
number.pop(2)
1
2
3
4
5
6
7

5. 列表分片

# number = ['小明',1,2,3,'小寒']
#使用冒号隔开两个索引值，左边是开始位置，右边是结束位置（结束位置上的元素不包括）
number[:2]
# ['小明', 1]
# 还可以接受第三个参数，表示步长，默认为1
number[1:4:2]
# [1, 3]
# 步长设置为-1，相当于复制一个翻转的列表
number[::-1]
# ['小寒', 3, 2, 1, '小明']
1
2
3
4
5
6
7
8
9
10

6. 常用操作符

list1 = [1,2,3]
list2 =list1 *2
#list2 = [1, 2, 3, 1, 2, 3]
list3 = list1 + list2
# list3 = [1, 2, 3, 1, 2, 3, 1, 2, 3]
list4 = [1,2,3,'list4',[4,5]]
'list4' in list4
# True
# in 和 not in 只能判断一个层次的成员关系  
4 in list4
# False
list4[4][1]			#访问二维数组方法
# 5
13

7. 其他方法

# number = [1,2,3,4,2,3,1]
number.count(2)	#统计元素在列表中出现的个数
number.index(2)	#返回元素在列表中的位置，默认返回第一次出现的位置
# 返回第二次出现的位置的方法
start = number.index(2) + 1
stop = len(number)
number.index(2,start,stop)	# 返回元素2，在start 和stop区间内的第一次出现的位置
number.reverse()	# 将整个列表翻转
# number = [1, 3, 2, 4, 3, 2, 1]
number.sort()	# 对列表进行排序，默认由小到大
# number = [1, 1, 2, 2, 3, 3, 4]
# 利用sort进行由大到小进行排序
number.sort(reverse = True)
# number = [4, 3, 3, 2, 2, 1, 1]
13
14

8. 分片‘拷贝’概念

使用索引来访问单个元素，分片操作用来访问一定范围内的元素

分片操作提供两个索引作为边界，第一个索引包含在分片内，第2 个则不包含在分片内

a = [1,2,3,4]
a[0:2]
[1, 2]
1
2
3

# list1 = [4,3,2,1]
# 真正的拷贝是要使用分片的方法
list2 = list1[:]
# 为一个列表 指定另一个名字的做法，只是向一个列表增加一个新的标签
list3 = list1
list1.sort()
# list1 = [1, 2, 3, 4]
# list2 = [4, 3, 2, 1]
# list3 = [1, 2, 3, 4]
1
2
3
4
5
6
7
8
9

分片赋值可以在不需要替换任何原有元素的情况下插入新的元素

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

这里“替换”了一个空的分片，因此实际的操作是插入了一个序列
9. 序列可以通过索引获取元素，使用负数索引时，Python会从右边，也就是从最后一个元素开始计数。

a = "Hello"
a[0]
'H'
a[-1]
'o'
a[-2]
'l'
1
2
3
4
5
6
7

二、元组

元组和列表最大的区别是，列表可以任意修改列表中的元素，但是元组不可变。创建元组大部分使用小括号。
字符串也是不可变得

# tuple1 = (1,2,3,4,5)
type(tuple1)
# <class 'tuple'>
# 若创建的元组只有一个元素时，需要在它后边加上一个逗号
temp = (1,)
type(temp)
# <class 'tuple'>
1
2
3
4
5
6
7

三、补充

1. None、空列表和初始化
   空列表可以简单地通过两个中括号进行表示 [ ]
   None 是一个 Python 的内建值，确切含义是 “什么也没有”

使用 None 初始化一个长度为 10 的列表

sequence = [None] * 10
sequence
[None, None, None, None, None, None, None, None, None, None]
1
2
3

1. list 函数：实现创建列表的操作

words = "Hello world !"
list_words = list(words)
list_words
['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', ' ', '!']
1
2
3
4

3. pop 方法和 append 方法实现入栈和出栈
   Python 没有入栈方法，但可以用 append 方法来代替。（实现后进先出）
   pop 方法和 append 方法的恰好相反

# append 方法用于在列表末尾追加新的对象
# pop 方法用于移除列表中的一个元素（默认是最后一个），并且返回该元素的值
x = [1,2,3]
x.append(4)
x
[1, 2, 3, 4]
x.pop()
4
1
2
3
4
5
6
7
8

4. 实现先进先出的队列

插入可以使用 insert(m,x) 或者 append 方法
但是必须用 pop(0) 来代替 pop()

x = [1,2,3]
x.append(5)
x.insert(4,6)
# x = [1, 2, 3, 5, 6]
x.pop(0)
1
# x = [2, 3, 5, 6]
1
2
3
4
5
6
7

5. 关于 sort 方法的知识点

x = [4,6,2,9]
y = x.sort()
# y = None
# x = [2, 4, 6, 9]
1
2
3
4

这里 sort 方法修改了 x ，但是 y 确返回来了空值
正确的赋值应该是

y = x[:]
y.sort 
1
2

实现根据元素的长度进行排序

x = ['address','make','add','be']
x.sort(key=len)
# x = ['be', 'add', 'make', 'address']
1
2
3

6. tuple 函数
   tuple 函数的功能与 list 函数基本是一样的：以一个序列作为参数并把它转换为元祖，如果参数就是元祖，那么该参数会被原样返回

tuple([1,2,3])
# (1, 2, 3)
tuple('abc')
# ('a', 'b', 'c')
tuple((1,2,3)) # 如果参数就是元祖，那么该参数会被原样返回
# (1, 2, 3)
1
2
3
4
5
6

7. 当两个变量同时引用一个列表的时候，它们的确是同时引用一个列表，如果想让这两个列表独立，需要使用切片