Python基础（3）_在python中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,只能重新

可变字符串

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

import io
s = 'Hello World!'
sio = io.StringIO(s)

print(sio)
print(sio.getvalue())
print(sio.seek(4))
print(sio.write('*'))
print(sio.getvalue())


#结果为：
<_io.StringIO object at 0x000002B28A6ACC18>
Hello World!
4
1
Hell* World!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

基本运算符

1、乘除优先加减
2、位运算和算术运算>比较运算>赋值运算>逻辑运算
如下优先级从高到低：

列表

列表的内存分析

序列是一种数据存储方式，用来存储一系列数据。
在内存中，序列就是一块用来存放多个值的连续的内存空间。
a = [10,20,30,40]，如下图所示：

如上图所示，右边的红色块为对象，每一个红色块都有id、type、value，中间的白色块为内存空间，储存的是每一个对象的id。

创建列表的方式

方法一： 基本语法[]创建

a = ['kk',23,'hgf','姓名']
1
'
运行
运行

方法二： list()创建

a = list()  # 创建一个空列表
a = list(range(10))
print(a)

#结果为：
[0,1,2,3,4,5,6,7,8,9]
1
2
3
4
5
6
'
运行
运行

方法三： range()创建整数列表
range(start,end,step)

print(list(range(3,15,2)))

#结果为：
[3,5,7,9,11,13]
1
2
3
4
'
运行
运行

方法四： 推导式生成列表

a = [x*2 for x in range(5)]
print(a)

#结果为：
[0,2,4,6,8]
1
2
3
4
5
'
运行
运行

列表元素的增加与删除

增加

append()： 原地修改列表对象，在列表尾部添加新元素。速度最快，推荐使用。

+运算符操作： 并非原地修改添加元素，而是创建新的列表对象，将原列表的元素和 新列表的元素复制到新的列表对象中。涉及大量复制操作，不建议使用。

extend()： 将目标列表的所有元素添加进本列表尾部，属于原地操作，不创建新的列表对象。

insert(位置，插入元素)： 插入，将指定元素插入到列表对象的任意位置，插入位置后的元素进行移动，会影响处理速度。尽量避免使用，类似发生这种移动的函数还有：remove()、pop()、del()。

乘法扩展： 生成一个新列表，新列表元素是原列表元素的多次重复。

删除

del： 删除列表指定位置的元素，后面的元素拷贝后往前挪，但还是同一个对象。

>>>a = [1,4,7]
>>>del a[1]
>>>a
[1,7]
1
2
3
4

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

a = [1,4,6,8,9]
print(a.pop(2))

#结果为：
6
1
2
3
4
5
'
运行
运行

remove(指定元素)： 删除首次出现的指定元素，若不存在则抛出异常

列表元素的计数和成员资格判断

计数

index(value,[start,[end]])： 可以获得指定元素首次出现的索引位置

count(value)： 返回指定元素在列表中出现次数

len()： 返回列表长度

成员资格判断

方法一：通过count()来判断，返回为0则不存在
方法二：用in来判断，存在返回True，不存在返回False

列表切片操作

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

与上一节字符串的切片操作一样！

三个量为正数情况下：

三个量为负数情况下：

列表排序

不创建新列表：
sort()： 排序，默认升序
sort(reverse=True)： 降序排序
random.shuffle()： 打乱顺序

a = [1,9,4,2]
a.sort()
print(a)

#结果为：
[1, 2, 4, 9]
1
2
3
4
5
6
'
运行
运行

创建新列表：
sorted()： 返回排好序的新列表，与原对象不是同一对象

a = [1,8,3,2]
a = sorted(a)
print(a)

#结果为：
[1,2,3,8]
1
2
3
4
5
6
'
运行
运行

列表相关其他内置函数

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

a = [1,9,4,2]
c = reversed(a)
print(c)
print(list(c))

#结果为：
<list_reverseiterator object at 0x000001701CE5B080>
[2, 4, 9, 1]
1
2
3
4
5
6
7
8

max(list)： 返回列表中最大值
min(list)： 返回列表中最小值
sum(list)： 对数值型列表的所有元素进行求和，非数值型列表会报错

二维列表

a = [['kkk',25,'北京'],
      ['zzz',24,'天津'],
      ['xxx',23,'上海']]
print(a)
print(a[1][2])

#结果为：
[['kkk', 25, '北京'], ['zzz', 24, '天津'], ['xxx', 23, '上海']]
天津
1
2
3
4
5
6
7
8
9

元组

元组的特点和创建

特点

列表属于可变序列，元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加元素、修改元素、删除元素相关方法。

创建

1、可以用（）创建，也可以不加（），如果元组中只有一个元素，元素后要加逗号，如果不加逗号默认为一个数（int型）

a = (1,5,6)
print(type(a))
b = 1,3,6
print(type(b))
c = (2,)
print(type(c))

#结果为：
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11

2、通过tuple()创建元组

a = tuple()
print(type(a))
b = tuple('fdf')
print(type(b))
c = tuple([1,6,3])
print(type(c))

#结果为：
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11

元素的访问和计数

均与列表一样

生成器推导式创建元组

a = (x*2 for x in range(3))
print(tuple(a))

#结果为：
(0, 2, 4)
1
2
3
4
5
'
运行
运行

其他函数

zip()： 将同一列压缩在同一个元组里

a= [1,3]
b = [1,6]
c = [2,5]
d = zip(a,b,c)
print(list(d))

#结果为：
[(1, 1, 2), (3, 6, 5)]
1
2
3
4
5
6
7
8
'
运行
运行