python夯实基础日记-序列、列表、元组

32、可变字符串

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

33、基本运算符

我们在前面讲解了"+″、"-"、 "*"、"〃"、"/″、"%″等运算符，这里我们继续讲解一些其他运算符，并进行学习和测试

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

>>>a=4

>>>3<a<10#关系运算符可以连用

True

2.位操作

>>>a=0b11001

>>>b=0b01000

>>>c= a|b #一者为1则返回1

bin（c） #bin()可以将数字转成二进制表示

'ob11001'

bin（c&b）#两者都为1则返回1

'0b1000'

bin（c^b）#两者不同，且一者为1则返回1

'ob10001′

>>>a=3

>>>a<<2#左移1位相当于乘以2左移2位，相当于乘以4

12

>>>a=8

>>>a>>1

#右移1位相当于除以2.

3.加法操作

（1）数字相加  3 + 2 ==> 5

（2）字符串拼接  "3"+"2"==> "32″

（3）列表、元组等合并 [10,20,30]+[5,10,100]==>[10,20,30,5,10,100]

4.乘法操作

（1）数字相乘  3 * 2 ==> 6

（2）字符串复制"sxt" * 3==> sxtsxtsxt

（3）列表、元组等复制[10,20,30]*3==>[10,20,30,10,20,30,10,20,30]

34、序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放

多个值的连续的内存空间。比如一个整数序列【10,20,30,40】，可以这样示意表示

由于 Python3中一切皆对象，在内存中实际是按照如下方式存储的：

a=[10,20,30,40]

从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。 python

中常用的序列结构有:

字符串、列表、元组、字典、集合

列表简介

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

列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式

a=[10,20,30,40]

Python的列表大小可变，根据需要随时增加或缩小。

字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。我们前面学习的很多字符串的方法，在列表中也有类似的用法，几乎一模一样。

35、列表的创建

基本语法[ ]创建

>>>a=[10,20,"gaoqi","sxt"]

>>>a=[ ]#创建一个空的列表对象

Ist()创建

使用lst()可以将任何可迭代的数据转化成列表。

>>>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参数：可选，表示步长

python3中 range()返回的是一个 range对象，而不是列表。我们需要通过lst0方法将其转换成列表对象

典型示例如下

>>>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]

推导式生成列表简介一下，重点在for循环后讲

使用列表推导式可以非常方便的创建列表，在开发中经常使用。

36、列表元素的增加和删除

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低除非要，我们一般只在列表的尾部添加元素

或删除元素，这会大大提高列表的操作效率。

append方法

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用

>>>a=[2040]

>>>a.append（80）

>>>a

[20,40,80]

+运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中，这样，会涉及大量的复制操作，对于操作大量元素不建议使用

>>>a=[20,40]

>>>id（a）

46016072

>>>a=a+[50]

>>>id（a）

46015432

extends方法

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

>>>a=[20,40]

>>>id（a）

46016072

>>>a, extend([50,60]）

>>>id（a）

46016072

Insert()插入元素

使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后

面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种

移动的函数还有； remove()、pop()、de()，它们在删除非尾部元素时也会发生操作位置后

面元素的移动。

>>>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]

37、列表元素的删除

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

remove()方法

删除首次出现的指定元素，弱不存在该元素，抛出异常。

>>>a=[10,20,30,40,50,20,30,20,30]
>>>a.remove(20)
[10.30.40,50,20,30,20,30]
>>> a.remove(100)
Traceback（most recent call last）：
    File"<pyshell#208>"， line 1， in <module>
    a.remove(100)
ValueError:list.remove(x)：x not in list

38、列表元素访问和计数

通过索引直接访问元素

我们可以通过索引直接访问元素。索引的区间在[O，列表长度-1]这个范围。超过这个范围则会抛出异常。

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

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

len()返回列表长度

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

39、列表切片操作

我们在前面学习字符串时，学习过字符串的切片操作，对于列表的切片操作和字符串类似切片是 Python序列及其重要的操作，适用于列表、元组、字符串等等。切片的格式如下

切片slice作可以让我们快速提取子列表或修改，标准格式为
[起始偏移量start:终止偏移量end[:步长step]]
注：当步长省略时顺便可以省略第二个冒号
切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起偏移量小于0则会当做0，终止偏移量大于“长度-1″会被当成-1。

40、列表排序

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

>>>a=[20,10,30,40]
>>>id（a）
47335544
>>> a.sort()#默认为升序排列
>>>a
[10,20.30.40]
>>>id（a）
47335544
>>>a.sort(reverse=lrue)#降序排列
>>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

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

41、多维列表

多维列表
二维列表
维列表可以帮助我们存储一维、线性的数据。[20,30,40]
二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：

>>>a=[
    ['阿大',18,30000,'北京'],
    ['阿二',19,20000,'上海'],
    ['阿三',20,10000,'深圳']
    ]
>>>a[0][3]
'北京'

使用列表的循环，打印每一项 

a=[
    ['阿大',18,30000,'北京'],
    ['阿二',19,20000,'上海'],
    ['阿三',20,10000,'深圳']
    ]
for i in range(3):
    for j in range(4):
        print(a[i][j],end='\t')
    print()#打印完一行，换行

'''阿大	18	30000	北京	
阿二	19	20000	上海	
阿三	20	10000	深圳'''

 42、元组tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的

元素。因此，元组没有增加元蘩、修改元素、删除元素相关的方法。

因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。元组支持如

1.索引访问

2.切片操作

3.连接操作

4.成员关系操作

5.比较运算操作

6.计数：元组长度len()、最大值max()、最小值min()、求和sum()等

元组的创建

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

2.通过 tuple()创建元组

tuple(可迭代的对象）

元组的删除

使用del函数

43、元组的元素访问和计数

1.元组的元素不能修改

2.通过切片和索引访问元组元素，返回的仍然是元组对象

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

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

44、生成器推导式创建元组

从形式上看，生成推导式与表推导式似，只是生成器推导式使用小话号列表推导式直接生成列表对系

生成器推导或生成的不是列表也不是元组，而是一个生成器对象。

我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__()方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。 

>>>s=(x*2 for x in range(5))
>>>s
<generator ob ject <genexpr> at 0x02C4D060>
>>>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
>>>s.__next__()
6
>>>s.__next__()
8

 元组总结
1.元组的核心特点是：不可变序列
2.元组的访问和处理速度比列表快
3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。