Python基础知识-pycharm版 第三节

1396-常同学

发表文章数:4

首页 » Python » 正文
可变字符串
字符串属于不可变对象,不支持原地修改。需要原地修改字符串,可以使用 io.StringIO对象或 array 模块。
>>> import io
>>> s = "hello, sxt"
>>> sio = io.StringIO(s)
>>> sio.getvalue()
'hello, sxt'
>>> sio.seek(7)
7
>>> sio.write("g")
1
>>> sio.getvalue()
'hello, gxt'
 
基本语法[]创建
>>> 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([start,] end [,step])
start 参数:可选,表示起始数字。默认是 0
end 参数:必选,表示结尾数字。
step 参数:可选,表示步长,默认为 1
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]
>>> list(range(3,-10,-1))
[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
 
 
列表元素的增加和删除
我们一般只在列表的尾部添加元素或删除元素,提高列表的操作效率。
 
append()方法
原地修改列表对象,列表尾部添加新的元素。
>>> a = [20,40]
>>> a.append(80)
>>> a
[20, 40, 80]
 
+运算符操作
创建新的列表对象;将原列表的元素和新列表的元素依次复制到新的列表对象中。
>>> a = [20,40]
>>> id(a)
46016072
>>> a = a+[50]
>>> id(a)
46015432
变量 a 的地址发生了变化。也就是创建了新的列表对象。
 
extend()方法
将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。
>>> a = [20,40]
>>> id(a)
46016072
>>> a.extend([50,60])
>>> id(a)
46016072
 
insert()插入元素
将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动,会影响处理速度。
>>> a = [10,20,30]
>>> a.insert(2,100)
>>> a
[10, 20, 100, 30]
 
乘法扩展
使用乘法扩展列表,生成一个新列表,新列表元素时原列表元素的多次重复。
>>> a = ['sxt',100]
>>> b = a*3
>>> a
['sxt', 100]
>>> b
['sxt', 100, 'sxt', 100, 'sxt', 100]
 
del 删除
删除列表指定位置的元素。
>>> a = [100,200,888,300,400]
>>> del a[1]
>>> a
[100,200,300,400]
 
pop()方法
pop()删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素。
>>> a = [10,20,30,40,50]
>>> a.pop()
50
>>> a
[10, 20, 30, 40]
>>> a.pop(1)
20
>>> a
[10, 30, 40]
 
remove()方法
删除首次出现的指定元素,若不存在该元素抛出异常。
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.remove(20)
>>> a
[10, 30, 40, 50, 20, 30, 20, 30]
 
通过索引直接访问元素
我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则
会抛出异常。
>>> a = [10,20,30,40,50,20,30,20,30]
>>> a[2]
30
 
index()获得指定元素在列表中首次出现的索引
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)
5
>>> a.index(20,3)  #从索引位置 3 开始往后搜索的第一个 20
5
>>> a.index(30,5,7)  #从索引位置 5 到 7 这个区间,第一次出现 30 元素的位置
6
 
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]]
注:当步长省略时顺便可以省略第二个冒号
 

复制列表所有的元素到新列表对象
list1 = [30,40,50]
list2 = list1
只是将 list2 也指向了列表对象,也就是说 list1和 list2 持有地址值是相同的,列表对象本身的元素并没有复制。
我们可以通过如下简单方式,实现列表元素内容的复制:
list1 = [30,40,50]
list2 = [] + list1
 
修改原列表,不建新列表的排序
>>> a = [20,10,30,40]
>>> id(a)
46017416
>>> a.sort()  #默认是升序排列
>>> a
[10, 20, 30, 40]
>>> a = [10,20,30,40]
>>> a.sort(reverse=True)  #降序排列
>>> a
[40, 30, 20, 10]
>>> import random
>>> random.shuffle(a)  #打乱顺序
>>> a
[20, 40, 30, 10]
 
建新列表的排序
内置函数 sorted()进行排序,这个方法返回新列表,不对原列表做修改。
>>> a = [20,10,30,40]
>>> id(a)
46016008
>>> a = sorted(a) #默认升序
>>> a
[10, 20, 30, 40]
>>> id(a)
45907848
>>> a = [20,10,30,40]
>>> id(a)
45840584
>>> b = sorted(a)
>>> b
[10, 20, 30, 40]
>>> id(a)
45840584
>>> id(b)
46016072
>>> c = sorted(a,reverse=True) #降序
>>> c
[40, 30, 20, 10]
 
reversed()返回迭代器
reversed()不对原列表做任何修改,返回一个逆序排列的迭代器对象。
>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x0000000002BCCEB8>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
 
max 和 min
用于返回列表中最大和最小值。
[40, 30, 20, 10]
>>> a = [3,10,20,15,9]
>>> max(a)
20
>>> min(a)
3
 
sum
对数值型列表的所有元素进行求和操作。
>>> a = [3,10,20,15,9]
>>> sum(a)
57
 
二维列表
a = [
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"],
]
>>> print(a[1][0],a[1][1],a[1][2])
高小二 19 20000
 

元组 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. 元组的元素不能修改
>>> a = (20,10,30,9,8)
>>> a[3]=33
Traceback (most recent call last):
File "<pyshell#313>", line 1, in <module>
a[3]=33
TypeError: 'tuple' object does not support item assignment
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 对象。
>>> 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)]
 
生成器推导式创建元组
生成器推导式使用小括号。列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象。
我们可以通过生成器对象,转化成列表或者元组。也可以使用生成器对象的__next__() 方法进行遍历,或者直接作为迭代器对象来使用。
不管什么方式使用,元素访问结束后,如果需要重新访问其中的元素,必须重新创建该生成器对象。
 
元组总结
1. 元组的核心特点是:不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样,元组可以作为字典的键,列表则永远不能作为字典的键使用。

未经允许不得转载:作者:1396-常同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《Python基础知识-pycharm版 第三节》 发布于2020-11-15

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录