03 python：字符串；元组和列表相关操作

python基础语法

可变字符串

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

>>>import io #要想使用io.StringIO方法，需要先导入io模块
>>>s='hello'
>>>sio=io.StringIO(s)#生成一个可变对象
>>>sio.write('abc')
>>>sio.wrtie(' ')
>>>sio.wrtie('python')
>>>sio.seek(7)#指针指向需要修改的字符的索引
>>>sio.write('q')
>>>print(sio.getvalue())#获取sio中的值

基本运算符

除了“+”，“-”，“*”，“/”，“//”，“%”，“**”还有以下运算符：

运算符	说明
and、or、not	布尔与、布尔或、布尔非
is、is not	同一性判断，判断是否为同一个对象
<,<=,>,>=,!=,==	比较值是否相等，可以连用
｜、 ^、&	按位或、按位异或、按位与
<<，>>	移位
~	按位翻转

1.比较运算符可以连用，并且含义和我们日常使用完全一致。

>>>a=4
>>>3<a<10

2.位操作（0b为二进制）

>>>a=0b11001
>>>b=0b01000
>>>c=a|b#按位或
>>>bin(c)#bin()可以将数字转换成二进制表示
>>>bin(c&b)#按位与
>>>bin(c^b)#按位异或

3.用位操作进行乘除法效率快很多

>>>a=3
>>>a<<2#左移一位相当于乘以2.左移两位，相当于乘以4
>>>a=8
>>>a>>1#右移一位，相当于除以2

4.加法操作

• 数字相加
• 字符串拼接
• 列表、元组等合并

>>>3+2
>>>'3'+'2'
>>>[10,20,30]+[40,50,60]

5.乘法操作

• 数字相乘
• 字符串复制
• 列表、元组等复制

>>>3*2
>>>'str'*3
>>>[10,20,30]*3

乘法本质上就是复制。
复合赋值可以让程序更加精炼，提高效率。

注：python中不支持自增（++）和自减（–）

运算符优先级问题

运算优先级如下，从高到低

实际使用中，记住如下规则：

• 复杂的表达式一定要使用小括号组织。
• 乘除优先加减
• 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40],可以表示为：

由于python3中一切皆对象，在内存中实际是按照如下方式存储的：a=[10,20,30,40]

由图示，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。列表可以存任意序列。在字符串中有的操作，在列表中也有，当执行a=[10,20,30,40]首先是创造对象，4个对象的地址依次存到变量a映射的空间。
python中常用的序列结构有：字符串、列表、元组、字典、集合。

列表简介

列表：用于存储任意数目、任意类型的数据集合。

• 列表是内置可变序列，是包含多个元素的有序连续的内存空间。
• 列表标准语法格式：a=[10,20,30,40]，其中10，20，30，40成为称为列表a的元素。
• 列表中的元素可以各不相同，可以是任意类型，比如： a=[10,20,‘abc’,True]
  列表对象的常用方法如下：

方法	要点	描述
list.append(x)	增加元素	将元素x增加到列表list尾部
list.extend(aList)	增加元素	将列表aList所有元素加到list尾部
list.insert(index,x)	增加元素	在列表list指定位置index处插入元素x
list.remove(x)	删除元素	在列表list中删除首次出现的指定元素x
list.pop([index])	删除元素	删除并返回列表list指定为止index处的元素，默认是最后一个元素
list.clear()	删除所有元素	删除列表所有元素，并不是删除列表对象
list.index(x)	访问元素	返回第一个x的索引位置，若不存在x元素则报错
list.count(x)	计数	返回指定元素x在列表list中出现的次数
len(list)	列表长度	返回列表中包含元素的个数
list.reverse()	翻转列表	所有元素原地翻转
list.sort()	排序	所有元素原地排序
list.copy()	浅拷贝	返回列表对象的浅拷贝

python的列表大小可变，根据需要随时增加或缩小。
字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。

列表的创建

1.基本语法[]创建

>>>a=[10,20,'poppy','box']
>>>a=[]#创建一个空的列表对象

2.list()创建
使用list（）可以将任何可迭代的数据转换成列表。

>>>a=list()#创建一个空的列表对象
>>>a=list(range(10))#创建一个包含10个元素的列表对象

3.range()创建整数列表
range（）可以很方便的创建整数列表，语法格式：
range([start,] end [,step])
start参数：可选，表示起始数字，默认是0；
end参数：必选，表示结尾数字；
step参数：可选，表示步长，默认为1.
python3中range（）返回的是一个range对象，而不是列表，我们需要通过list（）方法将其转换成列表对象。

>>>a=range(1,10,1)#range建立的是一个range对象
>>>list(range(1,10,1))

当步长为负数时，即使逆序排列。

4.推导式生成列表
使用列表推导式可以非常方便的创建列表。

>>>a=[x*2 for x in range(5)]#in range（5）是生成[0,1,2,3,4]这个列表，推导式通常与for循环一起使用
>>>a=[x*2 for x in range(100)ifx%9==0]

列表元素的增加和删除

当列表增加和删除元素时，列表会自动进行内存管理。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们通常只在列表的尾部添加元素或删除元素，这样会提高列表操作的效率。
1.append（）方法
原地修改列表对象，是真正的列表尾部添加新元素。速度最快。

>>>a=[10,20]
>>>a.append(30)

2.+运算符操作
不是真正的尾部添加元素，而是创建新的列表对象。将原列表的元素和新列表的元素依次复制到新的列表对象汇总。这样，会涉及到大量的复制操作，不适用于操作大量元素。

通过以上测试，我们发现变量a的地址发生了变化，也就是创建了新的列表对象。
3.extend（）方法
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

通过以上测试，我们发现，变量a的地址没有发生变化。
4.insert（）插入元素
使用insert（）方法可以将指定元素插入到列表对象的任意指定位置。这样会让插入位置后面所有元素进行移动，影响处理速度。不适用于大量元素的情况。类似这样的移动函数还有remove(),pop(),del(),他们在删除非尾部元素时，都会发生操作位置后面元素的移动。
5.乘法扩展
使用乘法扩展列表，生成一个新列表，新列表元素是原列表元素的多次重复。

适用于乘法操作的还有：字符串、元组。

列表元素的删除

1.del（）删除
删除列表指定位置的元素。

>>>a=[10,20,30]
>>>del a[1]

删除实际上也是数组的拷贝，被删除元素后面的数组向前拷贝。元素插入也是数组的拷贝，插入元素位置后面的数组向后拷贝。因此要尽量避免在数组中间插入或删除。
2.pop（）方法
pop（）删除并返回指定位置元素，如果位置定位置则默认操作列表做后一个元素。
pop（）在使用时，默认删除最后一个元素，并且将其删除的元素赋值给变量进行使用

3.remove（）方法
删除首次出现的指定元素，若不存在该元素报错。

del(),pop()都操作的是偏移量（索引），而remove()操作的是指定元素（值）

列表元素的访问和计数

1.通过索引直接访问元素
直接通过索引访问元素，索引区间在[0，列表长度-1]这个范围，超出这个范围会报错。

2.index()获得指定元素在列表中首次出现的索引
index（）可以获取指定元素首次出现的索引位置。语法：index(value,[start,[end]]).其中start和end指定了搜索范围。

3.count()获得指定元素在列表中出现的次数
count（）可以返回指定元素在列表中出现的次数。

4.len()返回列表长度
len()返回列表长度，即列表中包含元素的个数。

5.成员资格判断
判断列表中是否存在指定的元素，我们可以用count（）方法，返回0则表示不存在，返回大于0则表示存在。但是一般我们可以用in关键字来判断，直接返回True或False。

切片操作

之前学习了字符串的切片操作，对于列表的切片操作和字符串类似。
切片是python序列及其重要的操作，适用于列表、元组、字符串等。切片格式：[起始偏移量start:终止偏移量end[:步长step]]
注：当步长省略时顺便可以省略第二个冒号
典型操作（三个量为正数的情况）：

其他操作（三个量为负数的情况）


注：切片操作时，起始偏移量和终止偏移量不在[0，字符串长度-1]这范围，也不会报错。起始偏移量小于0 ，则会当作0，终止偏移量大于“长度-1”会被当成“长度-1”。

列表的遍历

语法：

>>>for obj in listObj:
>>>print(obj)

列表排序

1.修改原列表，不建新列表的排序

>>>a=[20,10,30,40]
>>>id(a)
>>>a.sort()#默认是升序排序
>>>a.sort(reverse=True)#降序排序

因为id没变，说明对象没有变化，还是原列表对象。
加入random模块，使用random.shuffle(a),实现随机排序。
2.建立新列表的排序
使用内置函数sorted()进行排序，这个方法返回新列表（调用sorted（）时会产生新对象），不对原列表做修改。

3.reversed()返回迭代器
内置函数reversed（）也支持逆序排序，与列表对象reverse（）方法不同的是，内置函数reversed（）不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

注：迭代器只能用一次，其中包含一个指针，从后面往前面指，再次使用迭代器就只能返回空。

列表相关的其他内置函数

1.max和min用于返回列表中最大值和最小值

2.sum.对数值型列表的所有元素进行求和操作，对非数值型列表运算会报错。

二维列表

一维列表可以帮助存储一维、线性的数据。
二维列表可以帮助存储二维、表格的数据。列表本身也是对象，列表套列表就是多维列表。



遍历二维列表

注意：for循环后的“：”，二维列表中每个子列表后的“，”不要漏掉。

元组tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素删除元素的相关方法。
元组支持的操作：

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度len(),最大值max(),最小值min(),求和sum()等。

元组的创建

1.通过()创建元组，小括号可以省略。
a=(10,20,30)或a=10,20,30。如果元组只有一个元素，则必须后面加逗号，这是因为解释器会把（1）解释成为整数1，(1,)解释成为元组。

2.通过tuple（）创建元组
tuple（可迭代的对象）

b=tuple()#创建一个空元组对象
b=tuple("abc")
b=tuple(range(3))#创建有三个元素的元组
b=tuple([2,3,4])

总结：

• tuple（）可以接收列表、字符串、其他序列类型、迭代器等生成元组。
• list（）可以接收元组、字符串、其他序列类型、迭代器等生成列表。
• 通常通过tuple（）把其他序列转换成元组。
• 元组对象的删除是del b。

元组的元素访问和计数

1.元组的元素不能修改
通过a[0]来访问元组指定元素，但不能修改。
2.元组的元素访问和列表一样，只是返回的仍是元组对象

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

注：不管是什么对象，使用内置函数，生成的都是列表。
4.zip
zip（列表1，列表2，…）将多个列表对应未知的元素组合成为元组，并返回这个zip对象。

使用zip压缩后，生成的是zip对象，一般我们将其放入一个list方便使用。

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号，列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
1.通过生成器对象，转换成列表或者元组。
2.使用生成器对象的__next_()方法进行遍历。
3.直接作为迭代器对象来使用。
不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

生成器中有一个指针指向对应的元素，循环结束后，指针再往下移动已经没有内容，返回空。

通过__next_使生成器中的指针去遍历整个内容。
元组总结
1.元组的核心特点是：不可变序列。
2.元组的访问和处理速度比列表快。
3.与整数和字符串一样，元组可以作为字典的键，列表也不能作为字典的键使用。（因为整数、字符串和元组不可变，二列表可变）