Python基础知识-pycharm版第三节笔记

可变字符串

在 Python 环境中，默认情况下字符串被视为不可变类型（immutable type），因此无法直接对原有内容进行就地更改操作（in-place modification）。然而，在实际应用中我们经常需要对字符串内容进行直接修改（direct modification），为此提供了一种解决方案：可以通过将原始字符串转换为可变类型的 StringIO 对象（或使用 array 模块）来进行操作

    **#实 操 作 业****#1.从控制台输入用户的月薪，进行运算计算出年薪。打印输出用户的年薪****#2.使用字符串复制，用计算机打印出“爱你一百遍”，打印 100 次****#3.将”sxtsxtsxtsxtsxt”字符串中所有的 s 输出**

序列

列表简介

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

列表是一种内置的可变序列用于存储顺序排列的多个元素 在Python中使用列表时遵循的标准定义方式： a = [10 20 30 40]

列表中的元素可以各不相同，可以是任意类型。比如：
a = [10,20,'abc',True]

列表的创建

基本语法[]创建

a = [10,20,'gaoqi','sxt']
a = [] #创建一个空的列表对象
list()创建
使用 list()可以将任何可迭代的数据转化成列表。
a = list() #创建一个空的列表对象
a = list(range(10))
a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = list("gaoqi,sxt")
a
['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']
range()创建整数列表
range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：
range([start,] end [,step])
start 参数：可选，表示起始数字。默认是 0
end 参数：必选，表示结尾数字。
step 参数：可选，表示步长，默认为 1
python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其
转换成列表对象。
典型示例如下：
list(range(3,15,2))
[3, 5, 7, 9, 11, 13]
list(range(15,3,-1))
[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]

推导式生成列表 借助列表推导式能够轻松地生成所需的序列或集合，在编程中被广泛应用。 在Python环境中，默认情况下会按照指定的范围和规则自动计算出结果集并赋值给变量名a。 具体实现方式如下： >>>a=[x2 for x in range(4)] # 利用循环结构生成所需元素 >>>a # 输出结果为[0, 2, 4, 6] >>>a = [x3 for x in range(4) if x %9 ==0] # 进一步利用条件过滤 >>>a # 输出结果为[3,6,9] 如何在列表中增删元素

append()方法 直接操作列表对象，在追加新元素方面表现最佳，并且强烈建议采用。

a=[20,30,40]
a.append(60)
a
[20, 30, 40, 60]

extend()方法
通过将目标列表的所有元素追加到最后位置来实现功能，在内存中直接进行操作，并无需生成新的对象以避免额外资源消耗。

a
[20, 30, 40, 60, 80]
id(a)
2474489120200
a.extend([100,120])
a
[20, 30, 40, 60, 80, 100, 120]
id(a)
2474489120200

insertion操作用于向列表中添加元素。
通过调用insert()方法可以在列表中的任意指定位置添加所需元素。
此操作会使得后续所有位于插入位置后的元素被移位。
当处理大量数据时建议避免使用此操作以提升效率。
与之相似的操作还有remove()、pop()和del()等函数，在删除非末尾项时也会导致后续所有项被移位。

a
[20, 30, 40, 60, 80, 100, 120, 60, 90]
a.insert(4,90) #插在制定序号之前
a

乘法扩展

a=[30,50]
a*3
[30, 50, 30, 50, 30, 50]

列表元素的删除
del 删除

b=[100,200,666,300,400]
del b[2]
b
[100, 200, 300, 400]

pop()方法
此函数用于从列表中移除并返回指定索引处的元素；当未指定索引时，默认从末尾移除该列表的最后一项。

b
[100, 200, 300, 400]
c=b.pop()
c
400
b
[100, 200, 300]
c=b.pop(2)
c
300
b
[100, 200]

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

a=[35,20,88,66,00,66,22,66]
a.remove(66)
a
[35, 20, 88, 0, 66, 22, 66]

列表元素访问和计数
通过索引直接访问元素
我们能够使用索引进行直接的元素访问。 取值范围限定为[0, 列表长度减一]这一区间范围内时操作有效；超出该范围将导致异常出现

a = [10,20,30,40,50,20,30,20,30]
a[2]
30

index()用于查找指定元素在列表中的起始位置
该函数能够返回指定元素首次出现的位置信息。 其语法为： index(value,[start,[end]])。 其中,
start和end参数指定了搜索范围.

a
[35, 20, 88, 0, 66, 22, 66]
a.index(66,1,6)
4

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

a = [10,20,30,40,50,20,30,20,30]
a.count(20)
3
len()返回列表长度
len()返回列表长度，即列表中包含元素的个数。
a = [10,20,30]
len(a)
3

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

a = [10,20,30,40,50,20,30,20,30]
20 in a
True
100 not in a
True
30 not in a
False
切片操作
适用于列表、元组、字符串等等。切片的格式如下：
切片 slice 操作可以让我们快速提取子列表或修改。标准格式为：
[起始偏移量 start:终止偏移量 end[:步长 step]]（取头不取尾）

a=[10,20,30,40,50,60]
a[:]
[10, 20, 30, 40, 50, 60]
a[1:5:2]
[20, 40]
a[2:]
[30, 40, 50, 60]
a[:2]
[10, 20]
a[-3:]
[40, 50, 60]
a[-4:-6]
[]
a[-4:-5]
[]
a[-4:-2]
[30, 40]
a[::-1]
[60, 50, 40, 30, 20, 10]
a[1:1000]
[20, 30, 40, 50, 60]

列表的遍历
for obj in listObj:
print(obj)
复制列表所有的元素到新列表对象
list1 = [30,40,50]
list2 = list1
只是将 list2 也指向了列表对象，也就是说 list2 和 list2 持有地址值是相同的，列表对象本
身的元素并没有复制。
可以通过如下简单方式，实现列表元素内容的复制：
list1 = [30,40,50]
list2 = [] + list1

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

a=[20,60,10,30]
a.sort() #默认是升序排列
a
[10, 20, 30, 60]
a.sort(reverse=True) #降序排列
a
[60, 30, 20, 10]
import random
random.shuffle(a) #打乱顺序
a
[20, 10, 60, 30]

我们也可以通过内置函数 sorted() 进行排序 创建新的有序序列 该方法返回一个新的列表 并不会修改原始列表

a=[20, 10, 60, 30]
id(a)
2192760163080
a=sorted(a)
id(a)
2192760162888

reversed() 返回逆序迭代器
内置函数 reversed 也可实现逆序遍历功能。与 list 的 reverse 方法相比，则内置函数 reversed 会生成一个逆序迭代器对象而不修改原始列表数据。

a[::-1]
[60, 30, 20, 10]
c=reversed(a)
c
<list_reverseiterator object at 0x000001FE8A446FC8>

list(c)
[60, 30, 20, 10]

采用 list(c) 进行输出操作后发现 仅能执行一次操作 。第一次成功获取了一个元素 ，下一次调用则返回空值 。这是因为迭代对象 在首次循环结束后已无剩余数据可取 ，无法进行后续操作。

多维列表
二维列表

a=[
["林一",19,200,"北京"],
["林一",19,200,"北京"],
["林一",19,200,"北京"],
]

a[0][3]
'北京'

嵌套循环打印二维列表所有的数据

运行结果：

高小一 18 30000 北京
高小二 20 40000 上海
高小六 21 60000 厦门

元组 tuple
列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列 ，不能修改元组中的
元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。
元组支持如下操作：
1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。
元组的创建
1. 通过()创建元组。小括号可以省略。
a = (10,20,30) 或者 a = 10,20,30
如果元组只有一个元素， 则必须后面加逗号。 这是因为解释器会把(1)解释为整数 1， (1,)
解释为元组。

a = (1)
type(a)
<class 'int'>
a = (1,) #或者 a = 1,
type(a)
<class 'tuple'>
2. 通过 tuple()创建元组
tuple(可迭代的对象)
例如：
b = tuple() #创建一个空元组对象
b = tuple("abc")
b = tuple(range(3))
b = tuple([2,3,4])
总结：
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

元组的元素访问和计数
1. 元组的元素不能修改

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

a = (20,10,30,9,8)
a[1]
10
a[1:3]
(10, 30)
a[:4]
(20, 10, 30, 9)
3. 列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排
序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。
a = (20,10,30,9,8)
sorted(a)
[8, 9, 10, 20, 30]

zip zip(列表 1, 列表 2, ...)把多个列表对应位置的元素以元组的形式结合在一起，并会返回这个 zip 对象。

c=zip(a,b)
c
<zip object at 0x0000020E95FF67C8>
list(c)
[(10, 30), (20, 12)]

基于表达式的元组创建 从结构上看 生成器表达式的构造方式与列表表达式的相似之处在于二者均采用了类似的语法构造方式 只是前者使用圆括号符号 而后者则采用方括号符号 在编程语言中 列表表达式可以直接用于构建具体的列表数据类型 而生成器表达式的执行结果则并非直接构建一个完整的数据容器 而是一个等待被遍历的对象 这种特殊的数据处理机制使得我们可以根据实际需求灵活地选择是否将其转换为具体的序列类型 或者直接作为迭代操作来进行数据处理 如果在操作过程中已经完成了一次完整的遍历操作 并且其中包含了一些复杂的数据访问逻辑 那么就需要考虑是否需要对这一迭代过程的结果进行进一步的操作 这种情况下的数据访问会受到前面已经完成操作的影响 因此在后续的操作中 如果需要再次访问其中的具体数据项 则必须回到原始的数据源 进行相应的重建工作

s=(x2 for x in range(7))
s
<generator object at 0x0000020E95FE7748>
tuple(s)
(0, 2, 4, 6, 8, 10, 12)
tuple(s) #只能访问一次元素。第二次就为空了。需要再生成一次
()
s=(x2 for x in range(7))
s
<generator object at 0x0000020E9605A448>
s.next()
0

s.next()
2
s.next()
4
s.next()
6
s.next()
8

元组总结
1. 元组的本质特征在于其不可变性。
2. 相对于列表而言，元组在访问与处理方面表现出更高的效率。
3. 整数、字符串以及元组均可作为字典的有效键类型；然而，在字典定义中列表被明确禁止使用。