Python基础——day03

一.可变字符串_io.StringIO

ptyhon中字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能常见新的字符串对象，可以使用io.StringIO( )

>>> a="answer"
>>> s=io.StringIO(a)
>>> s.getvalue()
'answer'
>>> s.write('q')
1
>>> s.getvalue()
'qnswer'
>>> s.seek(3)
3
>>> s.write('x')
1
>>> s.getvalue()
'qnsxer'

二.运算符总结_位操作符_优先级问题

>>> a=5
>>> 3<a<10
True

>>> a=5
>>> 3<a<10
True
>>> a=0b1101
>>> b=0b1001
>>> c=a|b
>>> c
13
>>> bin(c)
'0b1101'
>>> bin(c^b)
'0b100'
>>> bin(a^b)
'0b100'
>>> a=2
>>> a<<1
4
>>> a>>1
1
>>> a
2
>>> a>>2
0
>>> a<<2
8
>>>

三.复合赋值运算符

注意：与C 和JAVA不一样，Python不支持自增(++)和自减(- -)
四.运算符优先级问题
实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。
1.乘除优先加减
2.位运算和算术运算>比较运算符>赋值运算符>逻辑运算符
五(第3章 序列)列表_特点_内存分析
1.序列
序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放 多个值的连续的内存空间；python 中常用的序列结构有： 字符串、列表、元组、字典、集合。
2.内存分析:
对象的id放在序列中(序列存储的是地址不是数据)，最后序列的第一个id给变量a

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

字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。
六.创建列表的4种方式_推导式创建列表
1.创建列表
基本语法创建

>>> a=[10,'aas','True',True]
>>> a
[10, 'aas', 'True', True]

2.list()创建

>>> a=list()
>>> a
[]
>>> b=[]#相当于b=list()
>>> b
[]
>>> a=list(range(5))
>>> a
[0, 1, 2, 3, 4]
>>> a=list("QQ,small")
>>> a
['Q', 'Q', ',', 's', 'm', 'a', 'l', 'l']
>>>

3.range()创建整数列表
（1）语法格式为： range([start,] end [,step])
start 参数：可选，表示起始数字。默认是 0
end参数：必选，表示结尾数字。
step参数：可选，表示步长，默认为1
（2）包头不包尾
（3）range()返回的是一个range 对象，而不是列表。我们需要通过list()方法将其转换成列表对象。

>>> range(0,5)
range(0, 5)
>>> list(range(0,5))
[0, 1, 2, 3, 4]
>>> list(range(3,6,2))
[3, 5]
>>> list(range(3,-10,-1))
[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(20,1,-1))
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]
>>>

（4）推导式生成列表

>>> a=[x*2 for x in range(5)]#默认从0开始
>>> a
[0, 2, 4, 6, 8]

七.列表_元素的5种添加方式_效率问题
1.列表元素的增加
当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。
(1)append()方法
原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用

>>> a.append(80)
>>> a
[20, 0, 80]

（2）+运算符操作
创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

>>> a=[20,0]
>>> id(a)
1555876370184
>>> a+[80]
[20, 0, 80]
>>> id(a)
1555876370184

(3)extend()方法
将目标列表的所有元素加到本列表的尾部，不创建新的列表对象；

>>> id(a)
1555876370184
>>> a.extend([20])
>>> a
[20, 0, 20]
>>> id(a)
1555876370184

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

>>> a=[20,2]
>>> a.insert(1,3)
>>> a
[20, 3, 2]
>>>

（5）乘法扩展

生成一个新列表，新列表元素是原列表元素的多次重复

>>> a
[20, 3, 2]
>>> a*3
[20, 3, 2, 20, 3, 2, 20, 3, 2]

*八.列表_元素删除的三种方式_删除本质是数组元素拷贝
1.del()
删除列表指定位置的元素。
2.pop()
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素
3.remove()
删除首次出现的指定元素，若不存在该元素抛出异常。

>>> a=[20,30,40,50,45,0]
>>> del(a[2])
>>> a
[20, 30, 50, 45, 0]
>>> a.pop()
0
>>> a
[20, 30, 50, 45]
>>> a.pop(2)
50
>>> a
[20, 30, 45]
>>> a.remove(30)
>>> a
[20, 45]
>>> a.remove(1)
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> a
[20, 45]
>>>

九.列表_元素的访问_元素出现次数统计_成员资格判断
1.索引直接访问元素
索引的区间在[0, 列表长度-1]这个范围。超过这个范围则会抛出异常。
2.index()获得指定元素在列表中首次出现的索引
语法是： index(value,[start,[end]])。其中， start 和end指定了搜索的范围。

>>> a=[1,2,3,4,5,6,7,8,9]
>>> a.index(3)
2
>>> a.index(9,1,5)
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: 9 is not in list
>>> a.index(2,0,5)
1

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

>>> a.count(1)
1

4.len()返回列表的长度

>>> len(a)
9

4.成员资格判断
in关键字来判断是否含有指定元素，返回的是True或者False

>>> a=[2,3,4,5,6,70]
>>> 2 in a
True
>>> 10 in a
False

十.列表_切片slice操作
切片 slice 操作可以让我们快速提取子列表或修改。标准格式为： [起始偏移量start:终止偏移量end[:步长 step]]


切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会当做 0，终止偏移量大于“长度-1”会被当成”长度-1”
**十一.列表_排序_reversed逆序_max_min_sum
1.修改原列表，不建新列表的排序

>>> a=[20,12,43,23]
>>> a.sort()
>>> a
[12, 20, 23, 43]

2.创建新列表的排序
内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。

>>> a=[90,87,65,23,12]
>>> b=sorted(a)
>>> b
[12, 23, 65, 87, 90]
>>> id(a)
1555876312968
>>> id(b)
1555876463368

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

>>> c=reversed(a)
>>> list(c)
[12, 23, 65, 87, 90]
>>> c
<list_reverseiterator object at 0x0000016A417822E8>
>>> list(c)#我们使用 list（c）进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。
[]

4.列表相关的其他内置函数
（1）max(),min(),返回最大值，最小值
（2）sum(),计算数值型列表的总和

十一.列表_二维列表_表格数据的存储和读取
1.二维列表
一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：

>>> a=[
... ['A','3000','Shanghai'],
... ['B','3000','Beijing'],
... ['C','20000','Shanghai'],
... ]
>>> a
[['A', '3000', 'Shanghai'], ['B', '3000', 'Beijing'], ['C', '20000', 'Shang
hai']]

内部结构图

十二.元组_特点_创建的两种方式_tuple()要点
1.元组tuple
元组是不可变序列，不能修改元组中的元素，只有创建和删除，访问和计数的操作
元组支持如下操作：
(1) 索引访问
(2) 切片操作
(3) 连接操作
(4) 成员关系操作
(5) 比较运算操作
(6) 计数：元组长度len()、最大值 max()、最小值 min()、求和sum()等。
2.元组的创建
（），（）可省略

>>> a=(20,30,34)
>>> a
(20, 30, 34)
>>> a=20,30,50
>>> a
(20, 30, 50)

如果元组只有一个元素，则后面必须加逗号，否则解释器会把（1）解释为1，（1,）解释为元组

>>> a=(1)
>>> a
1
>>> a=(1,)
>>> a
(1,)

2.通过tuple()创建元组
tuple(可迭代对象)

>>> a=tuple()
>>> a
()
>>> a=tuple("abc")
>>> a
('a', 'b', 'c')
>>> a=tuple([a,b,c])
>>> a
(('a', 'b', 'c'), [12, 23, 65, 87, 90], <list_reverseiterator object at 0x0
000016A417822E8>)
>>> a=tuple(range(5))
>>> a
(0, 1, 2, 3, 4)
>>>

十三.元组_元素访问_计数方法_切片操作_成员资格判断_zip()
1.元组的元素不可更改
2.对元组的排序只能使用内置函数sorted(tupleObj)，生成的是新的列表对象；

>>> a=(9,7,6,5,4)
>>> a
(9, 7, 6, 5, 4)
>>> sorted(a)
[4, 5, 6, 7, 9]

3.zip()
将多个列表对应位置的元素组合成为元组，并返回这个zip对象
多个列表对象zip，返回的列表元素是元组

>>> a=[10,20,30]
>>> b=[12,13,14]
>>> c=[23,24,25]
>>> zip(a,b,c)
<zip object at 0x0000016A41741BC8>
>>> list(zip(a,b,c))
[(10, 12, 23), (20, 13, 24), (30, 14, 25)]

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

>>> a=(x*2 for x in range(5))
>>> a
<generator object <genexpr> at 0x0000016A4171D318>
>>> tuple(a)
(0, 2, 4, 6, 8)
>>> tuple(a)
()
>>> a=(x*2 for x in range(5))
>>> a
<generator object <genexpr> at 0x0000016A4171D408>
>>> a.__next__()#指针指向下一个，读取
0
>>> a.__next__()#注意是两个'_'
2
>>> a.__next__()
4
>>> a.__next__()
6
>>> a.__next__()
8
>>> a.__next__()
Traceback (most recent call last):
  File "", line 1, in <module>
StopIteration
>>>

元组是不可变序列
元组的访问和处理速度比列表快
因为元组是不可变序列，可以作为字典的建；而列表不能；