【学习笔记】Python 基础知识 - Day3

字符串

可变字符串

在 Python 中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用 io.StringIO 对象或 array 模块

序列

序列是一种数据存储方式，从下图中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值

Python 中常用的序列结构有：字符串，列表，元组，字典，集合

列表

列表用于存储任意数目、任意类型的数据集合，是内置可变序列，是包含多个元素的有序连续的内存空间。字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。

列表的常用方法

列表的创建

1.基本语法 [] 创建

2.list() 创建

3.range() 创建整数列表
语法格式为：range([start,] end [,step])

4.推导式生成列表

# 循环创建多个元素，通过if过滤元素
>>> a = [x*2 for x in range(100) if x%9==0]
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表元素的增加

尽量避免在列表中间插入/删除元素，因为会涉及大量元素的位置移动

1.append() 方法
原地修改列表对象，在列表尾部添加新的元素

2.+ 运算符操作
创建新的列表对象，将原列表的元素和新列表的元素依次复制到新的列表对象中，会涉及大量的复制操作，对于操作大量元素不建议使用

3.extend() 方法
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象

4.insert() 插入元素
（1）可以将指定的元素插入到列表对象的任意制定位置；
（2）会让插入位置后面所有的元素进行移动，影响处理速度，涉及大量元素时尽量避免使用；
（3）类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

5.乘法扩展
生成一个新列表，新列表元素是原列表元素的多次重复，适用于乘法操作的还有：字符串、元组

列表元素的删除

1.del 删除

>>> a = [100,200,888,300,400]
>>> del a[1]
>>> a
[100,200,300,400]

2.pop() 方法
删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素

>>> a = [10,20,30,40,50]
>>> a.pop()
50
>>> a
[10, 20, 30, 40]
>>> a.pop(1)
20
>>> a
[10, 30, 40]

3.remove() 方法
删除首次出现的指定元素，若不存在该元素抛出异常

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.remove(20)
>>> a
[10, 30, 40, 50, 20, 30, 20, 30]

列表元素访问和计数

1.通过索引直接访问元素
通过索引直接访问元素，索引的区间在 [0, 列表长度-1] 这个范围，超过这个范围则会抛出异常

2.index() 获得指定元素在列表中首次出现的索引
语法格式：index(value,[start,[end]])

# 从索引位置5到7这个区间，第一次出现30元素的位置
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(30,5,7) 
6

3.count() 获得指定元素在列表中出现的次数

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3

4.len() 返回列表长度

>>> a = [10,20,30]
>>> len(a)
3

5.成员资格判断

>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True

切片操作

标准格式为：[ 起始偏移量start : 终止偏移量end [:步长step] ]

# 取倒数3个
>>> [10,20,30,40,50,60,70][-3:]
[50,60,70]

起始偏移量和终止偏移量不在 [0,字符串长度-1] 这个范围，也不会报错。起始偏移量小于0 则会当做0，终止偏移量大于“长度-1”会被当成”长度-1”

复制列表所有的元素到新列表对象

# 如下 list1 和 list2 持有地址值是相同的
list1 = [30,40,50]
list2 = list1

# 如下可以实现列表元素内容的复制
list1 = [30,40,50]
list2 = [] + list1

列表排序

1.修改原列表的排序

>>> a = [10,20,30,40]
>>> a.sort(reverse=True)  # 降序排列
>>> a
[40, 30, 20, 10]

>>> import random
>>> random.shuffle(a)  # 打乱顺序
>>> a
[20, 40, 30, 10]

2.建新列表的排序

>>> a = [20,10,30,40]
>>> sorted(a)  # 默认升序，reverse = True 可以实现降序
[10, 20, 30, 40]

3.reversed() 返回迭代器

>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x0000000002BCCEB8>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
# 迭代对象在第一次时已经遍历结束了，第二次不能再使用

列表相关的其他内置函数汇总

>>> a = [3,10,20,15,9]
>>> max(a)
20
>>> min(a)
3
>>> sum(a)
57

多维列表

>>> a = [
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"],
]
>>> print(a[1][0],a[1][1],a[1][2])
高小二 19 20000

元组

元组属于不可变序列，不能修改元组中的元素

元组的创建

1.通过 () 创建元组，小括号可以省略，如果元组只有一个元素，则必须后面加逗号

2.通过 tuple() 创建元组，可以接收列表、字符串、其他序列类型、迭代器等生成元组

元组的元素访问和计数

1.元组的元素不能修改

2.元组的元素访问和列表一样，只不过返回的仍然是元组对象

3.列表关于排序的方法 list.sorted() 是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象

zip

zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象

>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

如果 a、b、c 长度不一致，则以最短的长度作为合并后的长度

生成器推导式创建元组

>>> s = (x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x0000000002BDEB48>
# 这里的s不是元组，而是生成器
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> tuple(s)
()
#只能访问一次元素，第二次就为空了，需要再生成一次

>>> s = (x*2 for x in range(5))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
# 元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象

元组总结

1.元组的核心特点是：不可变序列

2.元组的访问和处理速度比列表快

3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用