- 前言
- 一、可变字符串
- 二、列表
- 1、特点
- 2、内存分析
- 3、列表的创建
- (1)、[] 创建
- (2)、list() 创建
- (3)、range() 创建整数列表
- (4)、推导式生成列表
- 4、元素的添加
- (1)、.append()
- (2)、+ 运算符
- (3)、.extend()
- (4)、.insert() 插入元素
- (5)、乘法扩展
- 5、元素的删除
- (1)、del 删除
- (2)、pop()
- (3)、remove()
- 6、元素的访问
- (1)、通过索引直接访问元素
- (2)、.index()
- (3)、.count()
- (4)、len()
- (5)、成员资格判断
- (6)、列表的遍历
- 7、slice 切片
- 8、复制
- 9、排序
- (1)、修改原列表，不建新列表的排序
- (2)、建新列表的排序
- (3)、reversed() 返回迭代器
- 10、二维列表
- 三、元组
- 1、特点
- 2、元组的创建
- (1)、通过 () 创建
- (2)、通过 tuple() 创建
- (3)、zip 函数
- (4)、生成器推导式创建元组
- 3、元素的访问
- 4、元组的排序
前言
本文为6月28日Python基础学习笔记，分为三个章节：
- 可变字符串：使用 io.StringIO 原地修改字符串；
- 列表：特点、存储方式、4种创建列表的方式、元素的添加、删除、访问、slice 切片、排序以及二维列表的嵌套循环打印；
- 元组：特点、4种创建元组的方式、元组中元素的访问、排序，需注意的是生成器推导式创建的元组是一个生成器对象。
一、可变字符串
Python 中，字符串属于不可变对象，不支持原地修改。但可以使用 io.StringIO 原地修改字符串。
s = "good morning, tunwu."
sio = io.StringIO(s)
sio
>>> <_io.StringIO object at 0x000002132A1337F0>
sio.getvalue()
>>> 'good morning, tunwu.'
sio.seek(14)
>>> 14
sio.write("T")
>>>1
sio.getvalue()
>>> 'good morning, Tunwu.'
二、列表
用于存储任意数目、任意类型的数据集合 称为列表，如：
a = [10, 20, 30, 40]
其中，10,20,30,40 称为列表 a 的元素。 列表中的元素可以各不相同，可以是任意类型。
列表常用的修改方法如下：
| 语法 | 类型 | 描述 |
|---|---|---|
| .append(x) | 增加元素 | 增加元素 x 到列表尾部 |
| .extend(aList) | 增加元素 | 将列表 alist 所有元素加到原列表尾部 |
| .insert(index,x) | 增加元素 | 在原列表指定位置 index 处插入元素 x |
| .remove(x) | 删除元素 | 在原列表中删除首次出现的指定元素 x |
| .pop([index]) | 删除元素 | 删除并返回原列表指定为止 index 处的元素，默认是最后一个元素 |
| .clear() | 删除所有元素 | 删除列表所有元素，并不是删除列表对象 |
| .index(x) | 访问元素 | 返回第一个 x 的索引位置，若不存在，抛出异常 |
| .count(x) | 计数 | 返回指定元素 x 在列表中出现的次数 |
| len(list) | 列表长度 | 返回列表中包含元素的个数 |
| .reverse() | 翻转列表 | 所有元素原地翻转 |
| .sort() | 排序 | 所有元素原地排序 |
| .copy() | 浅拷贝 | 返回列表对象的浅拷贝 |
- 大小可变，根据需要随时增加或缩小；
在内存中，按照如下方式存储。序列中存储的是整数对象的地址，而不是整数对象的值。常用的序列结构有：
- 字符串；
- 列表；
- 元组；
- 字典；
- 集合。
a = [10,20,'tunwu', 'LI'] a = [] # 空列表(2)、list() 创建
使用 list()可以将任何可迭代的数据。
a = list() # 空列表
a = list(range(5))
a
>>> [0, 1, 2, 3, 4]
a = list("Tunwu LI")
a
>>> ['T', 'u', 'n', 'w', 'u', ' ', 'L', 'I']
(3)、range() 创建整数列表
语法格式为：
range([start,] end [,step])
- start 参数：可选，表示起始数字。默认是 0；
- end 参数：必选，表示结尾数字；
- step 参数：可选，表示步长，默认为 1。
range() 返回的是一个 ** range 对象** 而不是列表。 我们需要通过 list()方法将其转换成列表对象。如：
list(range(3,15,2)) >>> [3, 5, 7, 9, 11, 13](4)、推导式生成列表
a = [x*2 for x in range(5)] a >>> [0, 2, 4, 6, 8] a = [x*2 for x in range(18) if x%3 == 0] a >>> [0, 6, 12, 18, 24, 30]4、元素的添加
除非必要，一般只在列表的尾部添加元素或删除元素， 这会大大提高列表的操作效率。
(1)、.append()原地修改列表对象，是真正的列表尾部添加新的元素，速度最快， 推荐使用。
a = [1, 2] a.append(3) a >>> [1, 2, 3](2)、+ 运算符
创建新的列表对象， 将原列表的元素和新列表的元素依次复制到新的列表对象中。 对于操作大量元素不建议使用。
a = [1, 2] id(a) 2281332683200 a = a + [3] a >>> [1, 2, 3] id(a) 2281333727168
==变量 a 的地址发生了变化。==也就是创建了新的列表对象。
(3)、.extend()将目标列表的所有元素添加到本列表的尾部，属于原地操作。
a = [1, 2] a.extend([3, 4]) a >>> [1, 2, 3, 4](4)、.insert() 插入元素
使用 insert() 将指定的元素插入到列表对象的指定位置。这样会让插入位置后面的所有元素移动， 会影响处理速度。涉及大量元素时，尽量避免使用。
a = [1, 2, 3] a.insert(1, 10) a >>> [1, 10, 2, 3](5)、乘法扩展
生成一个新列表， 原列表元素的多次重复。
a = ['hello', 666] b = a*5 b >>> ['hello', 666, 'hello', 666, 'hello', 666, 'hello', 666, 'hello', 666]5、元素的删除 (1)、del 删除
删除列表指定位置的元素。
a = [1, 2, 3, 4] del a[1] a >>> [1, 3, 4](2)、pop()
删除并返回指定位置元素， 如果未指定位置则默认操作列表最后一个元素。
a = [1, 2, 3, 4, 5] a.pop() >>> 5 a >>> [1, 2, 3, 4] a.pop(0) >>> 1 a >>> [2, 3, 4](3)、remove()
删除首次出现的指定元素， 若不存在该元素抛出异常。
a = [10,20,30,40,50,20,30,20,30] a.remove(20) a >>> [10, 30, 40, 50, 20, 30, 20, 30]6、元素的访问 (1)、通过索引直接访问元素
a = [10,20,30,40,50,20] a[4] >>> 50(2)、.index()
获得指定元素在列表中首次出现的索引。
语法：
index(value, [start, [end]])
其中，start 和 end 指定了搜索的范围。
a = [10,20,30,40,50,20,30,20,30] a.index(20) >>> 1 a.index(20, 3) # 从索引位置 3 开始往后搜索的第一个 20 >>> 5 a.index(20, 4, 8) #从索引位置 4 到 8 这个区间出现的第一个 20 >>> 5(3)、.count()
返回指定元素在列表中出现的次数。
a = [10,20,30,40,50,20,30,20,30] a.count(20) >>> 3(4)、len()
返回列表长度，即列表中包含元素的个数。
a = [10,20,30,40,50,20,30,20,30] len(a) >>> 9(5)、成员资格判断
- 可以使用 count() 方法，返回 0 则表示不存在，返回大于 0 则表示存在。
a = [10,20,30,40,50,20,30,20,30] 30 in a >>> True 200 in a >>> False(6)、列表的遍历
for obj in listObj: print(obj)7、slice 切片
语法格式：
[起始偏移量 start : 终止偏移量 end[ : 步长 step])
a = [10,20,30,40,50,20,30,20,30] a[1:6:2] >>> [20, 40, 20] a[-3::] >>> [30, 20, 30] # 倒数3个 a[::-1] >>> [30, 20, 30, 20, 50, 40, 30, 20, 10] # 逆序8、复制
list1 = [30, 40, 50] list2 = list1
只是将 list2 也指向了列表对象，即 list2 和 list2 持有相同地址，列表对象本身的元素并没有复制。
实现列表元素内容的复制如下：
list1 = [30, 40, 50] list2 = [] + list19、排序 (1)、修改原列表，不建新列表的排序
a = [10,20,30,40,50,20,30,20,30] a.sort() # 升序（默认） a >>> [10, 20, 20, 20, 30, 30, 30, 40, 50] a.sort(reverse=True) a >>> [50, 40, 30, 30, 30, 20, 20, 20, 10] # 降序 import random random.shuffle(a) a >>> [30, 20, 30, 30, 50, 20, 10, 20, 40] #乱序(2)、建新列表的排序
通过内置函数 sorted() 进行排序，返回新列表，不对原列表做修改。
a = [10,20,30,40,50,20,30,20,30] a = sorted(a) # 升序（默认） a >>> [10, 20, 20, 20, 30, 30, 30, 40, 50] b = sorted(a, reverse=True) # 降序 b >>> [50, 40, 30, 30, 30, 20, 20, 20, 10](3)、reversed() 返回迭代器
内置函数 reversed() 不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
a = [10,20,30,40,50,20,30,20,30] c = reversed(a) c >>>list(c) >>> [30, 20, 30, 20, 50, 40, 30, 20, 10] list(c) >>> []
c 是：list_reverseiterator，即迭代对象。
再次使用 list© 进行输出，发现只能使用一次。第一次输出了元素，第二次为空。
| 姓名 | 年龄 | 薪资 | 城市 |
|---|---|---|---|
| 高小一 | 18 | 30000 | 北京 |
| 高小二 | 19 | 20000 | 上海 |
| 高小五 | 20 | 10000 | 深圳 |
a= [ ["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"]]
print(a[1][0],a[1][1],a[1][2])
>>> 高小二 19 20000
# 嵌套循环打印二维列表所有的数据
for m in range(3):
for n in range(4):
print(a[m][n], end='t')
print()
>>> 高小一 18 30000 北京
>>> 高小二 19 20000 上海
>>> 高小一 20 10000 深圳
三、元组 1、特点
与列表不同，元组属于不可变序列，不能修改元组中的元素。 因此，元组没有增加元素、修改元素、删除元素相关的方法。
2、元组的创建 (1)、通过 () 创建a = (10, 20, 30) a = 10, 20, 30 a = 1, type(a) >>>(2)、通过 tuple() 创建
b = tuple() # 空元组
b = tuple("abc")
b
>>> ('a', 'b', 'c')
b = tuple([2,3,4])
b
>>> (2, 3, 4)
(3)、zip 函数
zip(列表 1，列表 2，…) 将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。
a = [10,20,30] b = [40,50,60] c = [70,80,90] d = zip(a, b, c) d >>>(4)、生成器推导式创建元组list(d) >>> [(10, 40, 70), (20, 50, 80), (30, 60, 90)]
- 生成器推导式生成的 不是列表也不是元组，而是一个生成器对象。
- 可以通过生成器对象，转化成列表或者元组。 也可以使用生成器对象的 **__next__() **方法进行遍历，或者直接作为迭代器对象来使用。
- 元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。
s = (x*2 for x in range(5)) s >>>3、元素的访问at 0x000002132A0D7760> tuple(s) > (0, 2, 4, 6, 8) tuple(s) >>> () # 只能访问一次，第二次为空，需重新生成
与列表一样，只不过返回的仍然是元组对象。
a = (20,10,30,9,8) a[:3] >>> (20, 10, 30)4、元组的排序
对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。语法如下：
sorted(tupleObj)
a = (20,10,30,9,8) sorted(a) >>> [8, 9, 10, 20, 30]
