python 基础课程第三天

python 基础课程第三天

字符串

可变字符串

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

>>> s="hello,sxt"
>>> import io
>>> sio=io.StringIO(s)
>>> sio
<_io.StringIO object at 0x00000191A0869EE8>
>>> sio.getvalue()
'hello,sxt'
>>> sio.getvalue()
'hello,sxt'
>>> sio.seek(7)
7
>>> sio.write("g")
1
>>> sio.getvalue()
'hello,sgt'
>>> sio.seek(1)
1
>>> sio.write("a")
1
>>> sio.getvalue()
'hallo,sgt'
>>> 

基本运算符

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

>>> a=4
>>> 3<a<10
True
>>> a=0b11001
>>> b=0b01000
>>> a
25
>>> b
8
>>> c=a|b
>>> c
25
>>> bin(c)
'0b11001'
>>> bin(a&b)
'0b1000'
>>> bin(a^b)
'0b10001'
>>> a=3
>>> a<<1
6
>>> aa<<2
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    aa<<2
NameError: name 'aa' is not defined
>>> a<<2
12
>>> b=8
>>> b>>1
4
>>> b>>2
2
>>> b>>3
1
>>> b>>4
0
>>> 3+2
5

复合赋值运算符

复合赋值可以让程序更加精炼，提高效率。

注：与C 和JAVA 不一样，Python 不支持自增(++)和自减(–)

运算符优先级

如下优先级，从高到低。

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

【操作】使用 python 表示数学式：

>>> (5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)

序列

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

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

从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。python中常用的序列结构有：字符串、列表、元组、字典、集合

我们上一章学习的字符串就是一种序列

列表简介

列表：用于存储任意数目、任意类型的数据集合。
列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：a = [10,20,30,40]
其中，10,20,30,40 这些称为：列表a 的元素。
列表中的元素可以各不相同，可以是任意类型。比如：a = [10,20,‘abc’,True]

列表对象的常用方法汇总如下：

Python 的列表大小可变，根据需要随时增加或缩小。
字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。我们前面学习的很多字符串的方法，在列表中也有类似的用法，几乎一模一样。

列表的创建

基本语法[]创建

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()方法将其转换成列表对象。

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

使用列表推导式可以非常方便的创建列表，在开发中经常使用。但是，由于涉及到for 循环和if 语句。在此，仅做基本介绍。在我们控制语句后面，会详细讲解更多列表推导式的细节。

>>> a=[20,30,40,"gaoqi"]
>>> a[0]
20
>>> a[3]
'gaoqi'
>>> a=[]
>>> a.append(20)
>>> a
[20]
>>> a=list()
>>> a
[]
>>> a=list("gaoqi")
>>> a
['g', 'a', 'o', 'q', 'i']
>>> range(10)
range(0, 10)
>>> a=range(10)
>>> type(a)
<class 'range'>
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,10,1))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(3,20,2))
[3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> list(range(20,3,-1))
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
>>> list(range(-10,-33,-1))
[-10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, -32]
>>> a=[x*2 for x in range(10)]
>>> a
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> a=[x*2 for x in range(100)]
>>> a
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198]
>>> a=[x*2 for x in range(100) if x%9==0]
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
>>> 

列表元素的增加

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

append()方法

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

>>> a=[20,40]
>>> a.append(100)
>>> a
[20, 40, 100]
>>> a.append(200)
>>> a
[20, 40, 100, 200]

+运算符操作

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

>>> id(a)
2301963635080
>>> a=a+[50]
>>> a
[20, 40, 100, 200, 50]
>>> id(a)
2301994994568

通过如上测试，我们发现变量a 的地址发生了变化。也就是创建了新的列表对象。

extend()方法

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

>>> a=[20,40]
>>> id(a)
2301963634504
>>> a.extend([100,200])
>>> a
[20, 40, 100, 200]
>>> id(a)
2301963634504

insert()插入元素

使用insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

>>> a=[10,20,30,40]
>>> a.insert(2,100)
>>> a
[10, 20, 100, 30, 40]

乘法扩展

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

>>> a="sxt"*3
>>> a
'sxtsxtsxt'
>>> a=[20,30]
>>> a
[20, 30]
>>> a*3
[20, 30, 20, 30, 20, 30]
>>> 

列表元素的删除

del 删除

删除列表指定位置的元素。

>>> A=[100,200,888,300,400]
>>> del A[2]
>>> A
[100, 200, 300, 400]

pop()方法

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

>>> a=[10,20,30,40,50]
>>> b=a.pop()
>>> 
>>> b
50
>>> a
[10, 20, 30, 40]
>>> c=a.pop(1)
>>> c
20
>>> a
[10, 30, 40]

remove()方法

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

>>> a=["aa","bb","gao","cc","dd","gao"]
>>> a
['aa', 'bb', 'gao', 'cc', 'dd', 'gao']
>>> a.remove("gao")
>>> a
['aa', 'bb', 'cc', 'dd', 'gao']
>>> a.remove("asdasf")
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    a.remove("asdasf")
ValueError: list.remove(x): x not in list
>>> 

列表元素访问和计数

通过索引直接访问元素

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

>>> a=[10,20,30,40,50,20,30,20,30]
>>> a[2]
30
>>> a[10]
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    a[10]
IndexError: list index out of range
>>> 

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(30,5,7)
6
>>> 

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

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

>>> a=[100,200,100,300]
>>> a.count(100)
2

len()返回列表长度

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

>>> a=[10,20,30]
>>> len(a)
3
>>> 

成员资格判断

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

>>> "a" in "abc"
True
>>> 10 in [10,20,30,10]
True
>>> 10 in [1,2,3,4,5]
False
>>> a=[100,200,100,300]
>>> a.count(100)
2

切片操作

我们在前面学习字符串时，学习过字符串的切片操作，对于列表的切片操作和字符串类似。
切片是Python 序列及其重要的操作，适用于列表、元组、字符串等等。切片的格式如下：
切片slice 操作可以让我们快速提取子列表或修改。标准格式为：
[起始偏移量start:终止偏移量end[:步长step]]
注：当步长省略时顺便可以省略第二个冒号

典型操作(三个量为正数的情况)如下：

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

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

>>> a=[10,20,30,40,50,60]
>>> a[:]
[10, 20, 30, 40, 50, 60]
>>> a[1:3:1]
[20, 30]
>>> a[1::2]
[20, 40, 60]
>>> a[1:]
[20, 30, 40, 50, 60]
>>> a[:2:]
[10, 20]
>>> a
[10, 20, 30, 40, 50, 60]
>>> a[-3:]
[40, 50, 60]
>>> a[-3:-2]
[40]
>>> a[::-1]
[60, 50, 40, 30, 20, 10]
>>> 

列表的遍历

for obj in listObj:
print(obj)

>>> a=[10,20,30,40,50,60]
>>> for x in a:
	print(x)

	
10
20
30
40
50
60
>>> for x in a:
	print(x,end="#")

	
10#20#30#40#50#60#
>>> 

列表排序

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

>>> a=[20,10,30,40]
>>> id(a)
2254789019720
>>> a.sort()
>>> a
[10, 20, 30, 40]
>>> id(a)
2254789019720
>>> a.sort(reverse=True)
>>> a
[40, 30, 20, 10]
>>> import random
>>> random.shuffle(a)
>>> a
[20, 10, 30, 40]
>>> random.shuffle(a)
>>> a
[40, 30, 20, 10]
>>> 

建新列表的排序

我们也可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。

>>> a=[20,10,30,40]
>>> id(a)
2254793598792
>>> a=sorted(a)
>>> a
[10, 20, 30, 40]
>>> id(a)
2254789019720
>>> a=[20,10,30,40]
>>> id(a)
2254793598408
>>> b=sorted(a)
>>> b
[10, 20, 30, 40]
>>> id(a)
2254793598408
>>> id(b)
2254788814856
>>> c=sorted(a,reverse=True)
>>> c
[40, 30, 20, 10]
>>> id(c)
2254793599048
>>> 

通过上面操作，我们可以看出，生成的列表对象b 和c 都是完全新的列表对象。

reversed()返回迭代器

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

>>> a=[20,10,30,40]
>>> c=reversed(a)
>>> c
<list_reverseiterator object at 0x0000020CFBE7CB08>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
>>> 

我们打印输出c 发现提示是：list_reverseiterator。也就是一个迭代对象。同时，我们使用list©进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。

注：关于迭代对象的使用，后续章节会进行详细讲解。

列表相关的其他内置函数汇总

max 和min

用于返回列表中最大和最小值。

>>> 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,"深圳"]
	]
>>> a
[['高小一', 18, 30000, '北京'], ['高小二', 19, 20000, '上海'], ['高小五', 20, 10000, '深圳']]
>>> a[0]
['高小一', 18, 30000, '北京']
>>> a[0][3]
'北京'

内存结构图：

元组tuple

列表属于可变序列，可以任意修改列表中的元素。
元组属于不可变序列，不能修改元组中的元素。因此，元组没有增加素、修改元素、删除元素相关的方法。因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。
元组支持如下操作：

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

元组的创建

1. 通过()创建元组。小括号可以省略
   如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数1，(1,)解释为元组。
2. 通过tuple()创建元组
   tuple(可迭代的对象)

>>> a=(10,20,30)
>>> type(a)
<class 'tuple'>
>>> a=10,20,30
>>> type(a)
<class 'tuple'>
>>> b=(20)
>>> type(b)
<class 'int'>
>>> b=(20,)
>>> type(b)
<class 'tuple'>
>>> b=20,
>>> type(b)
<class 'tuple'>
>>> b=tuple("abcd")
>>> b
('a', 'b', 'c', 'd')
>>> b=list("abcd")
>>> b
['a', 'b', 'c', 'd']
>>> b=tuple(range(3))
>>> b
(0, 1, 2)
>>> b=tuple([30,40,50])
>>> b
(30, 40, 50)
>>> del b
>>> b
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    b
NameError: name 'b' is not defined
>>> 

总结：
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

元组的元素访问和计数

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

>>> a=[20,30,40]
>>> a[1]
30
>>> a[1]=100
>>> a
[20, 100, 40]
>>> a=(20,30,40)
>>> a[1]
30
>>> a[1]=100
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    a[1]=100
TypeError: 'tuple' object does not support item assignment

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

>>> b=(30,20,40)
>>> sorted(b)
[20, 30, 40]

zip

zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip 对象。

>>> a=[10,20,30]
>>> b=[40,50,60]
>>> c=[70,80,90]
>>> d=zip(a,b,c)
>>> d
<zip object at 0x00000226699C1508>
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]
>>> 

生成器推导式创建元组

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

【操作】生成器的使用测试

>>> s=(x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x000001D1137B5248>
>>> 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
>>> s.__next__()
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    s.__next__()
StopIteration
>>> 

元组总结

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