2. 位操作、

  >>> a=0b11001

  >>> b=0b01000

  >>> c =a|b

  >>> bin(c)

‘0b11001’

>>>bin(c&b)

 ‘ 0b1000 ’

 >>> bin(c^b)

 ‘0b10001’

>>> a = 3

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

   >>> a >> 1 #右移1位相当于除以2

3、加法操作

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

(2)  字符串拼接  “3” + “2” ==> “32”

(3)  列表、元组等合并  [10,20,30] + [10,20,30,5,10,100]

4、乘法操作

   （1）数字相乘  3*2 

复合赋值运算符

运算符优先级问题

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

序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列是一块用来存储多个值的连续的内存空间。比如一个整数序列[10,20,30,40]

可以展示为

将数据（id、type、value）中的id储存

列表创建的四种格式：

基本语法[]创建

>>>a = [10,20,’rui’,’qing’]

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

list()创建

使用list()可以将任何数据或字符串转化为列表

>>> a = list() #创建一个空的列表对象

>>> a = list(range(10))

>>> a

[0,1,2,3,4,5,6,7,8,9]

>>> a = list(“ruiqing”)

range()创建

可以非常方便的帮我们创建整数列表

其格式为：

range([start] end [,step])

start参数：可选，表示起始数字。默认是0

end 参数：必选，表示结尾数字。

step 参数：可选，表示步长，默认为1

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

例如：

• list(range(3,15,2))

[3,5,7,9,11,13]

推导式生成列表

使用推导式生成列表可以非常方便的创建列表，需借用for循环与if语句。

• a = [x*2 for x in range(5)]
• a

[0,2,4,6,8]

• a = [x*2 for x in range(100) if x%9 == 0] #通过if过滤元素
• a

[0,18,36,54,72,90,108,126,144,162,180,198]

列表元素的增加和删除

增加的方法

append()方法

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

• a =[20,40]
• a.append(80)
• a

[20,40,80]

+运算符操作

• a = [20,40]
• id(a)
• a = a+[50]
• id(a)

+运算符操作

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

• a = [20,40]
• id (a)
• a = a +[50]
• id (a)

a的id发生改变

extend()方法（两个接口合二为一时推荐使用）

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

insert()插入元素

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

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

[10,20,100,30]

列表元素的删除

del 删除

删除列表制定位置的元素

>> a = [10,20,30]

>>del a[1]

pop()方法（调用列表中的某一元素）

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

>> a =[10,20,30,40,50]

>> a.pop()     50

del 其实是移位

remove()方法

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

>>> a = [10,20,30,40,50,20,30,20,30]

>>> a.remove(20)

>>> a

[10,30,40,50,20,30,20,30]

列表元素访问和计数

通过索引直接访问元素

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

>>> a = [10,20,30,40,50,20,30,20,30]

>>> a[2]  30

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

index()可以获取指定元素首次出现的索引位置。表达式是：index（value,[start,[end]]）。其中，start和end指定了搜素范围

>>> a = [10,20,30,40,50,20,30,20,30]

>>> a.index(20)

1

count()获得指定元素在列表中出现的次数（数据集a）

1. count(20)  20在a中出现几次

len()返回列表长度

len（）返回列表长度，即列表中包含元素的个数

>>> a = [10,20,30]

>>>len(a)

3

成员资格判断

判断一个元素在不在一个列表中，可以通过count()方法，返回0则表示不在，返回大于0则表示存在

最简单的方式是

20 in a 返回即是布尔值

切片操作  

切片slice操作可以让我们快速提取子列表或修改。标准格式为：

  [起始偏移量start:终止偏移量end[:步长 step]]

注：当步长省略时顺便可以省略第二个冒号

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

列表的遍历(循环)

for obj in listObj:

    print(obj)

列表排序

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

>>> a =[20,10,30,40]

>>> id(a)

1. sort()  #默认是升序排列

a

1. sort(reverse = True)  #降序排列

打乱顺序

>>> import random

>>> random.shuffle(a) #打乱顺序

建立新列表的排序

调用内置函数sorted()进行排序，这种方法返回新列表，id改变

reversed()返回迭代器

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

可以通过切片操作

如 a = [20,10,30,40]

   a = [ :: -1]可以进行逆序排列

也可以用

   c = reversed(a)

   c就成了有关于a的文本迭代器（只能用一次）

   可以将c打印出来

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

max和min

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

[40,30,20,10]

>>> a = [3,10,20,15,9]

>>> max(a)  min(a)

sum求和

多维列表

二维列表

[10,20,30[40,50]]

源码：

a = [

[“高小一”，18,30000，“北京”]，

[“高小二”，19,20000，”上海”]，

[“高小五”，20,10000，“深圳”]，

]

 >>>print(a[1][0],a[1][1],a[1][2])

元组tuple

列表属于可变序列，可以任意修改列表中的元素。元素属于不可变序列，不能修改元组中的元素。因此，元素没有增加元素、修改元素、删除元素相关的方法。

元组支持如下操作：

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

元组的创建

1. 通过（）创建元组。小括号可以省略

a = (10,20,30)  或者 a = 10,20,30

如果元组只有一个元素，则必须后面加括号。这是因为解释器会把（1）解释为整数1，（1，）

解释为元组。

     >>> a = (1)

     >>> type(a)

     >>> a = (1,)   #或者 a = 1.

     >>> type(a)

1. 通过tuple()创建元组

tuple(可迭代的对象)

例如：

b = tuple()   #创建一个空元祖对象

b = tuple(“abc”)

b = tuple(range(3))

b = tuple([2,3,4])

元组的元素访问和计数

1. 元组的元素不能更改
2. 其他功能一样可以访问，也可以用切片操作
3. 对元组进行排序，只能使用内置函数sorted(tupleObj)并生成新的列表对象

>>> a = (20,10,30,9,8)

>>> sorted(a)

[8,9,10,20,30]

zip

list(d)

>>> a =[10,20,30]

>>> b =[40,50,60]

>>> c = [70,80,90]

>>> d = zip[a,b,c]

>>> list(d)

[(10,40,70),(20,50,80),(30,60,90)]

生成器推导式创建元组

   生成器推导式与列表推导式类型，只是生成器推导式使用小括号，列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的_next_()方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后。

>>> s =(x*2 for x in range(5))

>>> s

at 0x0000000002BDEB48>

>>> tuple(s)

(0,2,4,6,8)

>>> list(s)        #只能访问一次元素。第二次就空了。需要再生成一次

>>> s

at 0x0000000002BDEB48>

元组总结

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

分享到：

赞(0) 打赏