Python_Day03_列表和元祖

接day02

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

>>> import io
>>> s = "hello,nihao"
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x1074feee0>
>>> sio.getvalue()
'hello,nihao'
>>> sio.seek(7)
7
>>> sio.write("g")
1
>>> sio.getvalue()
'hello,nghao'  # 这里第七位就由i变成了g

此时字符串就可以随意的修改。

基本运算符:

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

>>> sio.getvalue()
'hello,nghao'

2. 位操作

>>> a = 0b1101
>>> b = 0b0100
>>> c = a|b
>>> bin(c) # bin()可以将数字转为二进制表示
'0b1101'
>>> a
13
>>> b
4
>>> c
13
>>> bin(a&b)
'0b100'
>>> d = bin(a&b)
>>> d
'0b100'
>>> d = a&b
>>> d
4

异或

就是将两个先写成二进制的形式,位位对应。
a = 0 b 1 1 0 0 1
b = 0 b 0 1 0 0 0
异或运算_____
c = 0 b 1 0 0 0 1

>>> a = 0b11001
>>> b = 0b01000
>>> a
25
>>> b
8
>>> c = a^b
>>> c
17
>>> bin(c)
'0b10001'

左移右移:

>>> a = 3
>>> a<<2 # 左移1位相当于乘以2，左移两位的话，相当于乘以4
12
>>> a = 8
>>> a >> 2 # 同样的，如果右移的话则是除法，比如右移两位的话就是除以4
2

复合赋值运算符:

sum += n 相当于 sum = sum + n
*注意:*Python不支持自增(++)自减(–)

运算符优先级问题:

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

1. 乘除优先加减
2. 位运算和算数运算>比较运算>赋值运算

序列:

序列是一种数据储存方式，用来储存一系列的数据。在内存中，序列就是一块用来存放多个值得连续的内存空间。比如说一个整数的序列[10,20,30,40]。我们可以看出序列储存的是整数对象的地址，而不是整数对象的值。Python中常见的序列结构有:

1. 字符串 字符序列
2. 列表
3. 元祖
4. 字典
5. 集合

一个对象具有三个属性: 1.地址id,2.Type,3.value。
序列中储存的是整数对象的地址，而不是整数对象的值。

列表:

创建和增加列表元素:

列表是内置的可变序列，是包含多个元素的有续联系的内存空间。列表的定义是标准的语法格式: a = [10,20,30,40]
其中10,20,30,40被称为列表a的元素。
列表的元素可以是各不相同，可以是任意类型。比如: a = [10,20,30,"hello",True]
Python的列表大小可变，根据需要随时增加或缩小。
把可迭代的数据转化成列表。
创建列表:

>>> a = [10,20,30,40] # 1
>>> a
[10, 20, 30, 40]
>>> a = list(range(10)) # 2 数字序列转化成列表序列
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = list("ancdefg") # 3 字符串序列转为列表序列
>>> a
['a', 'n', 'c', 'd', 'e', 'f', 'g']
>>> type(a)
<class 'list'>

range()创建整数列表

range()可以帮我们非常方便的创建整数列表，语法为: range([start,]end[,step]) # []的意思是可选则的 不写也可 默认是0

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

推导式生成列表

使用列表推导式可以非常方便的创建列表。

>>> a = [x*2 for x in range(5)] # 循环创建多个元素
>>> a
[0, 2, 4, 6, 8]
>>> b = [x*2 for x in range(100) if x%9 == 0] # 也可以加if条件语句进行过滤
>>> b
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
>>> 

append()列表元素的增加和删除

append()方法:原地修改列表对象，是真正的列表尾部添加到新的元素，速度越快，推荐使用。
我们一般只要在列表的尾部添加元素和删除元素，这将大大的提高列表的操作效率。
只要涉及到中间添加元素，后面的都将重新复制创建，大大减少列表的效率。

>>> a = [1,2,3,4]
>>> a.append(80)
>>> a
[1, 2, 3, 4, 80]

+加法运算

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

>>> a = [20,40]
>>> id(a)
4362401472
>>> a = a + [50]
>>> id(a)
4424956160 # 不一样
>>> a # 这个a和第一个a是不一样的对象
[20, 40, 50]

extend()方法:

也是将目标列表的元素添加到本列表的尾部，不创建新的列表。

>>> a = [20,40]
>>> a
[20, 40]
>>> id(a)
4362401472
>>> a.extend([56,89])
>>> a
[20, 40, 56, 89]
>>> id(a)
4362401472
>>> 

insert()插入元素

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

>>> a = [1,2,3,4,6]
>>> a.insert(4,5) # 4是位置，5是插入的元素。
>>> a
[1, 2, 3, 4, 5, 6]
>>> 

乘法扩展

>>> a = ["你好",1234]
>>> a
['你好', 1234]
>>> b = a * 3
>>> b
['你好', 1234, '你好', 1234, '你好', 1234]
>>> 

列表元素的删除:

del删除

删除列表指定的位置的元素,看起来是删除，其实是数组元素的拷贝。后面的往前去拷贝。

>>> a = [1,2,3,4]
>>> del a[0]
>>> a
[2, 3, 4]
>>> 

pop()方法

pop()删除并返回指定位置元素，如果

>>> b = [2,3,4,5]
>>> b.pop()
5
>>> b
[2, 3, 4]
>>> a = [1,2,3,4]
>>> a.pop(0)
1
>>> a
[2, 3, 4]

remove()

可以直接操作删除首次出现的元素，若不存在该元素则抛出异常。
可以删除

>>> a = [1,2,3,4]
>>> a
[1, 2, 3, 4]
>>> a.remove(3) # 可以直接对元素进行操作
>>> a
[1, 2, 4]
>>> a = [1,2,3,4,3]
>>> a.remove(3) # 只会移除第一个3的元素
>>> a
[1, 2, 4, 3] 
>>> 

列表元素的访问和计数:

通过索引直接访问元素，索引区间在[0,列表长度-1]这个范围。超过这个范围则会抛出异常。
index()获得指定元素在列表中首次出现的索引，也可以在指定范围内找元素位置: index(value,[start,[end]])

>>> a = [10,20,30,40,50,40,30,20,30]
>>> a[4]
50
>>> a.index(20)
1
>>> a.index(40)
3
>>> a.index(20,3)
7
>>> 

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

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

>>> a = [10,20,30,40,50,40,30,20,30]
>>> a[4]
50
>>> a.index(20)
1
>>> a.index(40)
3
>>> a.index(20,3)
7
>>> a.count(12)
0
>>> a.count(20)
2
>>> 

len()返回列表的长度

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

>>> a = [10,20,30,40,50,40,30,20,30]
>>> len(a)
9

成员资格的判断

>>> a = [10,20,30,40,50,40,30,20,30]
>>> a
[10, 20, 30, 40, 50, 40, 30, 20, 30]
>>> 50 in a # 判断是否存在于列表之中
True
>>> 89 not in a
True
>>>> a
[10, 20, 30, 40, 50, 40, 30, 20, 30]
>>> a.count(10)>0  # 如果总数大于0也可以判断出存在
True

slice切片操作

跟为了截取子字符串差不多。
这个方法也可以用于列表 元祖 字符串等Python序列。
切片slice操作可以让我们快速提取子列表或修改。
都是包头不包尾

>>> a
[10, 20, 30, 40, 50, 40, 30, 20, 30]
>>> a[:] # 截取全部
[10, 20, 30, 40, 50, 40, 30, 20, 30]
>>> a[1:] # 从第二个元素开始截取
[20, 30, 40, 50, 40, 30, 20, 30]
>>> a[:2] # 截取到a[1]
[10, 20]
>>> a[1:3] # 截取a[1] - a[2] 
[20, 30]
>>> a[1:6:2] # a[1] - a[5] 步长是2 步长是1的话等于不写
[20, 40, 40]
>>> a[-3:] # 从倒数第三个截取到最后
[30, 20, 30]
>>> a[-5:-3] # 从倒数第五个截取到倒数第4个
[50, 40]
>>> a[::-1] # 倒着截取 相当于把字符串反过来
[30, 20, 30, 40, 50, 40, 30, 20, 10]
>>> 

列表的遍历

>>> for i in a:
	print(i)

10
20
30
40
50
40
30
20
30
>>> 

列表排序

>>> a = [20,10,40,30]
>>> a
[20, 10, 40, 30]
>>> id(a)
4362401280
>>> a.sort()
>>> a
[10, 20, 30, 40] # 升序排列
>>> id(a)
4362401280
>>> a
[10, 20, 30, 40]
>>> a.sort(reverse = True) # 降序排列 是否翻转: 是
>>> a
[40, 30, 20, 10]
>>> 

使序列随机排序:

>>> import random
>>> random.shuffle(a) # 把a列表打乱
>>> a
[20, 40, 30, 10]
>>> 

建新列表的排序

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

>>> a
[20, 40, 30, 10]
>>> id(a)
4362401280
>>> a = sorted(a) # 默认升序排列 这里是内置函数
>>> a
[10, 20, 30, 40]
>>> id(a)
4424957440 # id可以看到不一样了 生成了新的列表
>>> 

返回一个逆序的排列:
内置函数reversed()支持逆序排列，与列表对象reverse()方法不同的是也是生成了一个新的对象，不对原有的对象进行修改，只是返回了一个逆序排列的迭代器对象。当然可以用a[::-1]的方式进行逆序排列。

>>> a = [20,10,30,40]
>>> a
[20, 10, 30, 40]
>>> c = reversed(a)
>>> c # 返回的c是一个翻转迭代器 并不是直接返回一个c列表
<list_reverseiterator object at 0x107c0b220>
>>> list(c)
[40, 30, 10, 20]
>>> list(c) # 第二次返回空列表 指针已经走了
[]

返回最大最小值and求和:

>>> a = [20,10,30,40]
>>> a
[20, 10, 30, 40]
>>> max(a) # 求最大值
40
>>> min(a) # 求最小值
10
>>> sum(a) # 求和 只针对数字的list
100

多维列表

二维列表:
二维可以帮助我们储存二维数组 表格的数据。

a = []
a = [
    ["张三",23,'北京'],
    ["李四",34,'天津'],
    ["王五",24,"南京"]
]
print(a[0])
print(a[1])
print(a[2])
print(a[0][0])

输出结果:

['张三', 23, '北京']
['李四', 34, '天津']
['王五', 24, '南京']
张三

嵌套循环输出二维数组:

for m in range(3):
    for n in range(3):
        print(a[m][n],end="\t")
    print() # 打印完一行 换行

输出:

张三	23	北京	
李四	34	天津	
王五	24	南京

元祖 tuple

列表属于可变序列,可以任意的修改列表中的元素。元祖属于不可变的序列，不能修改元祖中的元素。因此，元祖序列中，没有增加元素，修改元素，删除元素相关的方法。
因此，我们只需要学习元祖的创建和删除(整体)，元祖中元素的访问和计数即可。

元祖的创建

>>> a =() # 通过()可以创建
>>> a
()
>>> type(a)
<class 'tuple'>
>>> a = (1) # 这样创建的是int型的a
>>> a 
1
>>> type(a)
<class 'int'>
>>> a = (1,)
>>> type(a)
<class 'tuple'>
>>> a = 1,
>>> type(a)
<class 'tuple'>
>>> a = 10,20,30 # 不带括号也可以创建
>>> type(a)
<class 'tuple'>

我们还可以通过tuple()创建元祖:tuple(可迭代的对象)

>>> b = tuple()
>>> b
()
>>> b = tuple("abc") # ()内必须是可迭代的对象
>>> b
('a', 'b', 'c')
>>> b = tuple(range(3))
>>> b
(0, 1, 2)
>>> b = tuple([2,3,4])
>>> b
(2, 3, 4)
>>> 

总结:

1. tuple()可以接收列表,字符串,其他序列类型,迭代器等生成元素。
2. list()可以接收元祖,字符串,其他序列类型,迭代器等生成列表。

删除元祖

>>> b
(2, 3, 4)
>>> del b
>>> b
Traceback (most recent call last):
  File "<pyshell#163>", line 1, in <module>
    b
NameError: name 'b' is not defined
>>> 

元祖的元素访问和计数

• 元祖的元素不能修改但是可以访问，还可以使用切片来访问。

>>> a = (20,10,30,9,8)
>>> a
(20, 10, 30, 9, 8)
>>> a[1]
10
>>> a[0]
20
>>> a[1:3]
(10, 30)
>>> a[:4]
(20, 10, 30, 9)
>>> a[::-1]
(8, 9, 30, 10, 20)
>>> 

列表关于排序方法list.sort()是修改原列表对象，元祖中是没有该方法的。如果要是对元祖排序，只能够用内置函数sorted(元祖)，并可以生成新的对象。因为sort()这个函数用过之后就会改变list内的排序，但是元祖是不可改变的，所以不可以用该函数。

>>> a
[1, 2, 3]
>>> a = [2,3,1]
>>> id(a)
4362409664
>>> a.sort()
>>> a
[1, 2, 3]
>>> id(a)
4362409664

我们可以看到用内置函数sorted(元祖)生成的是一个列表:

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

元祖相加:

>>> a = 18,20
>>> b = 30,20
>>> a + b
(18, 20, 30, 20)
>>> a
(18, 20)  # 但是a并没有变化
>>> b
(30, 20) # 同样的 b也没有任何变化
>>> len(a)
2
>>> min(b)  # 同样list很多方法在此处可以用
20
>>> max(a)
20
>>> sum(a)
38
>>>  

zip

>>> a
(1, 2, 3)
>>> b
(4, 5, 6)
>>> c
(7, 8, 9)
>>> d = zip(a,b,c)
>>> d
<zip object at 0x107bfe480>
>>> list(d)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> 

生成器推导式创建元祖:

>>> s = (x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x107bb85f0> # 这是个生成器对象 可以对他进行遍历取值
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s) # 只能访问一次元素,第二次就为空了,需要再生成一次才能使用.
[]
>>> s = (x*2 for x in range(5))
>>> s.__next__() # 可以用这个方法移动指针来访问元素 前后都是两个下划线__next__
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
8

元祖总结:

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