2020.3.15 python笔记

运算符

基本运算符

>>> 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)  #a与b一样的位置得1，不一样得0
'0b1000'
>>> bin(a^b)#按位异或：一样的位置是0，不一样的位置是1
'0b10001'
>>> a = 3
>>> a<<2  #左移2相当于乘2的2次方
12
>>> a = 8
>>> a>>2#右移2相当于除以2的2次方
2

左移和右移比乘法快，笔试题可能会考到

>>> #乘法操作
>>> 3*2
6
>>> "sxt"*2
'sxtsxt'
>>> [10,20,30]*2
[10, 20, 30, 10, 20, 30]

复合赋值运算符

记住等价的

运算符优先级问题

1. 乘除优先于加减
2. 位运算符和算术运算》比较》赋值》逻辑运算符
   
   (5+10x)/5-13(y-1)(a+b)/x+9(5/x+(12+x)/y)

序列

1.序列是一种数据存储方式，用来存储一系列的数据。
2.序列结构：字符串，列表，元组，字典，集合。
3.定义一个列表a = [10,20,30,40],序列中存储的是整数对象的地址，而不是整数对象的值。

列表简介

列表：用于存储任意数目、任意类型的数据集合。
可以放任意类型，比如a = [10,20,“hj”,True]

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

1. 列表大小可变，可以根据需要随时增加或缩小。
2. 字符串和列表都是序列类型，前面很多字符串的方法，在列表中也有类似的方法。

列表的创建

基本语法[]创建

>>> a = [10,20,'hj','sxt']
>>> a[1]
20
>>> a[0]
10
>>> a = []
>>> a.append(20)#加东西
>>> a
[20]

list()创建

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

>>> a = list()
>>> a
[]
>>> a = list("hj")#转成列表
>>> a
['h', 'j']
>>> 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]

range()创建整数列表

用的非常多！

1. start参数：可选，起始数字，默认是0
2. end参数：必选，结尾数字
3. step参数：可选，步长，默认为1

>>> list(range(0,10,1))
[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(3,10,2))
[3, 5, 7, 9]
>>> list(range(20,3,-1))#步长为-1，就是从后向前数
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]

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

>>> a = [x*2 for x in range(5)]#循环创建多个元素，依次乘2
>>> a
[0, 2, 4, 6, 8]
>>> a = [x*2 for x in range(100) if x%9==0] #通过if过滤元素，依次乘2之后，只要9的倍数
>>> a
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表元素的增加和删除

增加或删除都会对列表的内存进行修改，一般只在列表的尾部增加或删除，会提高效率，尽量不要在中间增加或删除。

append()

速度最快

+运算符

是创建新的对象，不建议使用

extend()

不创建新的对象，只是扩展，效率高。

>>> a = [20,40]
>>> a.append(100)  #在尾部加100
>>> a
[20, 40, 100]
>>> id(a)
36810920
>>> a = a
>>> a=a+[50]
>>> a
[20, 40, 100, 50]  #用+运算符就会改掉地址，相当于创建新的对象
>>> id(a)
14166456
>>> a.extend([50,60])  #extend不创建新对象
>>> id(a)
14166456

insert()插入元素

将指定元素插入到列表对象的任意位置。

>>> a = [10,20,30]
>>> a.insert(2,100) #在原始的2位置插入100
>>> a
[10, 20, 100, 30]

乘法扩展

>>> a = [20,30]
>>> a*3
[20, 30, 20, 30, 20, 30]

列表元素的删除

del删除

>>> a = [10,20,30]
>>> del a[1] #删掉位置1的元素
>>> a
[10, 30]

本质上是数组的拷贝，相当于位置2的元素拷贝到位置1，以此类推，依次拷贝。

pop()

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

>>> a = [10,20,30,40,50]
>>> b= a.pop() #b是被抛出的最后一个元素
>>> b
50
>>> a#a被抛出最后一个元素
[10, 20, 30, 40]
>>> c = a.pop(1)#被抛出的位置为1的元素
>>> c
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]
>>> a.remove(100)
Traceback (most recent call last):
  File "<pyshell#78>", line 1, in <module>
    a.remove(100)
ValueError: list.remove(x): x not in list

列表元素访问和计数

通过索引直接访问元素

列表的索引范围是[0，列表长度-1]
比如a[2]

index()获得指定元素在列表中首次出现的索引

index(value,[start,[end]])

>>> a=[10,20,30,40,50,20,30,20,30]
>>> a.index(20)
1
>>> a.index(20,3)#从3位置开始搜20
5

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

a.count(20) #20出现了几次

len()返回列表长度

列表中包含元素的个数

成员资格的判断

20 in a #元素20在不在列表a中，在则返回True，不在为False.
或者20 not in a
通常用in，效率高，不用count。

切片操作

切片slice。
和字符串切片相当于一模一样。
格式：[起始偏移量start：终止偏移量end：[步长step]]
典型操作：

>>> a = [10,20,30,40,50,60]
>>> a[:]#提取所有元素
[10, 20, 30, 40, 50, 60]
>>> a[1:3:1]#完整写法，从1开始提取到3，包头不包尾，步长为1
[20, 30]
>>> a[1::2]# 从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]

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

>>> a = [10,20,30,40,50,60]
>>> a[1:100]
[20, 30, 40, 50, 60]

列表的遍历

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

	
10
20
30
40
50
60

列表排序

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

>>> a = [20,10,30,40]
>>> id(a)
36315048
>>> a.sort()#升序排列
>>> a
[10, 20, 30, 40]
>>> id(a)#不改变id
36315048
>>> a.sort(reverse=True)#降序排列
>>> a
[40, 30, 20, 10]
>>> id(a)
36315048
>>> import random#引入random函数
>>> random.shuffle(a)#随机排列
>>> a
[30, 10, 20, 40]
>>> random.shuffle(a)
>>> a
[20, 40, 10, 30]

建新列表的排序

内置函数sorted()

>>> a = [20,10,30,40]
>>> id(a)
36813320
>>> a = sorted(a)#升序
>>> a
[10, 20, 30, 40]
>>> id(a)
36810920

reversed()返回迭代器

逆序排列

>>> a = [20,10,30,40]
>>> a[::-1]
[40, 30, 10, 20]
>>> a
[20, 10, 30, 40]
>>> c = reversed(a)
>>> c#只是个迭代器
<list_reverseiterator object at 0x02130EB0>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)#迭代器只能用一次
[]

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

max和min

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

>>> a = [3,24,32,4]
>>> max(a)
32

sum

对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。

>>> a = [1,34,2,53]
>>> sum(a)
90

多维列表

二维列表

一维列表存储一维线性的数据。比如[1,2,3]
工作一般用二维列表，比如表格。
二维列表可以理解为一维列表的每个元素都是列表。

>>> a = [
	 ["hj",14,"北京"],
	 ["sk",15,"上海"],
	 ["ffe",16,"杭州"]
	 ]
>>> a
[['hj', 14, '北京'], ['sk', 15, '上海'], ['ffe', 16, '杭州']]
>>> a[0]#也可引用，引用位置为0的子列表
['hj', 14, '北京']
>>> a[0][1]#引用位置为0的子列表的位置为1的元素
14

元组tuple

列表属于可变序列，元组是不可变序列，不能修改元素。
无增加、修改、删除。
元组支持：（和列表一样）

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

元组的创建

1. 通过()来创建.小括号可以省略。

>>> a = (10,20,30)
>>> type(a)
<class 'tuple'>
>>> a = 10,20,30
>>> type(a)
<class 'tuple'>
>>> b=(20)
>>> type(b)
<class 'int'>
>>> b=(10,)#加逗号才表示元组
>>> type(b)
<class 'tuple'>

2. 通过tuple()创建元组

>>> c=tuple()
>>> c
()
>>> #把其他序列转为元组
>>> b=tuple("abcd")#和list一样
>>> b
('a', 'b', 'c', 'd')
>>> b=list("abcd")
>>> b
['a', 'b', 'c', 'd']
>>> b=tuple(range(3))
>>> b
(0, 1, 2)
>>> b=tuple([10,20,30])#把列表转换成元组
>>> b
(10, 20, 30)

元组的元素访问和计数

1.元组的元素不能修改

>>> a = (10,20,30)
>>> a[0]
10
>>> a[1]=40#tuple对象不能修改
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    a[1]=40#tuple对象不能修改
TypeError: 'tuple' object does not support item assignment

>>> a=tuple("aasdfg")
>>> a
('a', 'a', 's', 'd', 'f', 'g')
>>> a[1:10]#可以切片
('a', 's', 'd', 'f', 'g')

3.排序
使用内置函数sorted(),生成新的列表对象。

>>> b=(14,24,45)
>>> sorted(b)
[14, 24, 45]

zip

将多个列表对应位置的元素组合成元组，并返回这个zip对象。

>>> a=[1,2]
>>> b=[3,4]
>>> c=[5,6]
>>> d=zip(a,b,c)
>>> list(d)
[(1, 3, 5), (2, 4, 6)]

生成器推导式创建元组

与列表推导式类似，只是生成器推导式用小括号。
生成器推导式生成的不是列表也不是元组，而是一个生成器对象，再转化成列表或元组。

>>> s=(x*2 for x in range(5))
>>> s #s是一个生成器
<generator object <genexpr> at 0x022A6EF0>
>>> tuple(s)#通过tuple变成元组
(0, 2, 4, 6, 8)
>>> list(s)#再调就没有了，只能访问一次元素，第二次就为空，需要再生成一次
[]
>>> s
<generator object <genexpr> at 0x022A6EF0>

>>> 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__()#没有内容了，不能再调了

元组总结

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