Python学习Day3列表与元组

参考教程：https://www.liaoxuefeng.com/wiki/1016959663602400
参考博客：刻意练习：Python基础 – Task02. 列表与元组（原创： LSGOGroup 老马的程序人生）

列表list

list是一种有序的集合，可以随时添加和删除其中的元素。`
list里面的元素的数据类型也可以不同
list元素也可以是另一个list

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

1、用索引来访问list中每一个位置的元素，记得索引是从0开始的：
2、当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。用len()函数可以获得list元素的个数
3、如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

list常用函数

列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

append(obj)

在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.append('Thursday')
print(week)  
#['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(week))  # 6

此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。

extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.extend(['Thursday', 'Sunday'])
print(week)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

insert(index, obj)

insert(index, obj) 在编号 index 位置前插入 obj。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.insert(0, 'Sunday')
print(week)  
# ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

remove(obj)

移除列表中某个值的第一个匹配项

pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
==remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个编号位置.

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
day = week.pop()
print(day)  # Friday
day = week.pop(0)
print(day)  # Monday
day = week.pop(-2)
print(day)  # Wednesday

del var1[, var2 ……]

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del week[0], week[1]
print(week)  # ['Tuesday', 'Thursday', 'Friday']

列表分片start : stop : step

• 情况 1 - “start :”
  以 step 为 1 (默认) 从编号 start 往列表尾部切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[3:])  # ['Thursday', 'Friday']
print(week[-3:])  # ['Wednesday', 'Thursday', 'Friday']

-情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3])  # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3])  # ['Monday', 'Tuesday']

注意[3:]与[:3]加起来为整个list

• 情况 3 - “start : stop”
  以 step 为 1 (默认) 从编号 start 往编号 stop 切片。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3])  # ['Tuesday', 'Wednesday']
print(week[-3:-1])  # ['Wednesday', 'Thursday']

• 情况 4 - “start : stop : step”
  以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])  
# ['Tuesday', 'Thursday']

print(week[:4:2])  
# ['Monday', 'Wednesday']

print(week[1::2])  
# ['Tuesday', 'Thursday']

print(week[::-1])  
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

拷贝

用等号即可

print(week[:])  
# week的拷贝 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

注意list2指向list1，而list3只是复制了list1的内容

列表的常用操作符

比较操作符
逻辑操作符
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
和元组拼接一样， 列表拼接也有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

list1 = [123, 456]
list2 = [234, 123]
print(list1 > list2)  # False

list3 = [123, 456]
print((list1 < list2) and (list1 == list3))  # True

list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 234, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。
将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

• 列表的其它方法

count(obj)

方法：统计某个元素在列表中出现的次数

list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

index(obj[, start[, end]])

方法：从列表中找出某个值第一个匹配项的索引位置。

list1 = [123, 456] * 5
print(list1.index(123))  # 0
print(list1.index(123, 1))  # 2
print(list1.index(123, 3, 7))  # 4

第三个存疑？？？

reverse()

方法：反向列表中元素

list1 = [123, 456, 789]
list1.reverse()
print(list1)  # [789, 456, 123]

sort(key=None, reverse=False)

方法：对原列表进行排序

list1 = [123, 456, 789, 213]
list1.sort()
print(list1)  # [123, 213, 456, 789]

list1.sort(reverse=True)
print(list1)  # [789, 456, 213, 123]

元组tuple

「元组」定义语法为：(元素1, 元素2, …, 元素n)

小括号把所有元素绑在一起
逗号将每个元素一一分开
与list区别Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
特别：元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

print(8 * (8))  # 64
print(8 * (8,))  # (8, 8, 8, 8, 8, 8, 8, 8)

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
即元组中有list的存在

• 二维元组

nested = (1, 10.31, 'python'), ('data', 11)
print(nested)
# ((1, 10.31, 'python'), ('data', 11))

元组中可以用整数来对它进行索引 (indexing) 和切片 (slicing)，不严谨的讲，前者是获取单个元素，后者是获取一组元素。接着上面二维元组的例子，先看看索引的代码：

print(nested[0])
# (1, 10.31, 'python')
print(nested[0][0], nested[0][1], nested[0][2])
# 1 10.31 python

再看看切片的代码

print(nested[0][0:2])
# (1, 10.31)

元组相关的操作符

比较操作符
逻辑操作符
连接操作符 +
重复操作符 *
成员关系操作符 in、not in

*元组拼接 (concatenate) 有两种方式，用「加号 +」和「乘号 」，前者首尾拼接，后者复制拼接。

t1 = (2, 3, 4, 5)
t2 = ('老马的程序人生', '小马的程序人生')
t3 = t1 + t2
print(t3)  # (2, 3, 4, 5, '老马的程序人生', '小马的程序人生')

t4 = t2 * 2
print(t4)  # ('老马的程序人生', '小马的程序人生', '老马的程序人生', '小马的程序人生')

内置方法

元组大小和内容都不可更改，因此只有 count 和 index 两种方法。
count(obj) 是记录在元组 t 中该元素出现几次，显然是 1 次
index(obj) 是找到该元素在元组 t 的索引

解压元组

• 解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

• 解压二维元组（按照元组里的元组结构来定义变量）

t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」，例子如下

a, b, *_ = t
print(a, b)  # 1 2

学习总结

前面介绍的 整型、浮点型和布尔型 都可以看成是单独数据，而这些数据都可以放在一个容器里得到一个「容器类型」的数据，比如：列表（list）、元组（tuple）、字典（dict）、集合（set）和字符串（str）。
加油！！
今天太忙了，还是要坚持呀
Todd