Python 第三天（运算符，重点：列表、元组）

基本运算符

a = 0b11001
b = 0b01000
# 按位或|：01得1,00得0,11得1
print(bin(a | b))     # bin（）用于转十进制为二进制
# 按位与&：01得0,00得0,11得1
print(bin(a & b))
# 按位异或^：相同的得0，不同的得1
print(bin(a^b))
a = 3
print(a<<2)     # 左移两位，相当于乘以4

加法操作

• 数字相加：3+2→5
• 字符串相加：“3”+“2"→"32”
• 列表元素等合并：[10,20,30]+[5,10,100]→[10,20,30,50,10,100]

乘法操作

• 数字相乘：3*2→6
• 字符串复制：“sxt”*3→"sxtsxtsxt"
• 列表元素等合并：[10,20,30]*3→[10,20,30,10,20,30,10,20,30]

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

python不支持自加和自减

位操作和算术运算>比较操作符>赋值运算符>逻辑判断

序列

序列是一种数据存储方式，用来存储一系列的数据，在内存中，数据就是一块用来存放多个值的连续的内存空间

在序列中，我们存放的是对象的地址，而不是整数对象的值

列表

列表是用于存储任意数目，任意类型的数据集合。


python中的列表大小可变，根据需要随时增大和减小。
字符串是字符序列，而列表是任何元素的序列。在字符串的方法，在列表中也可以使用

列表的创建
基本语法[]创建：a = [] #创建一个空的列表对象
list创建（将任何迭代数据转为列表）：a = list() #创建一个空的列表对象
range()创建整数列表：range([start,]end[,step])
start:可选，表示起始数字，默认为0
end:必选，表示结尾数字
step:可选，表示步长，默认为1

a = [18, 50, "school", "sxt"]
print(a[2])       #school
print(a[0])		  #18

b = list(range(1, 5))
print(b)
c = list("school")              # 分解为各个子字符
print(c)

d = range(1, 5, 2)
print(d)
# 因为e是列表，要用[]表示，所有表达语句都在[]中
# 注意要写for i in range(100) if
e = [i*2 for i in range(100) if i % 9 == 0]
print(e)

列表元素的增加和删除
一般我们只在列表的尾部添加或删除元素

• append()：推荐使用，在一个序列中加入新的字符或数字，不改变地址，不涉及新的对象创建（不用写b = a.append()）
• +运算符操作：不推荐，会改变地址，需要重新定义一个新的对象
• extend()：合并两个序列，不改变地址，不涉及新的对象创建（不用写b = a.extend()）
• insert()：可以将指定元素插入列表对象的任意指定位置

a = [1,2]
a.append(3)         # append()中可以加入字符或数字，不改变地址因此不用给新字符赋值
print(a)
b = [1,2]
b.extend([3,4,5])         # extend()中可以加入序列，不改变地址因此不用给新字符赋值
print(b)
c = [1, 2, 3, 4, 5]
c.insert(2,100)           # 在第二个位置后面插入100
print(c)

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

列表元素的删除
删除和增加的本质是元素数组的拷贝

• del删除：删除列表指定位置的元素
• pop()方法：删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素
• remove()方法：删除首次出现的指定元素，若不存在该元素则抛出异常

a = [10, 20, 30, 40, 50]
del a[2]            
# 并不需要对一个新的对象进行赋值，删除"30",不会给出被删除的值
print(a)
b = a.pop(3)         
# 并不需要对一个新的对象进行赋值，只是会给出被删除的对象"50"
print(a)
print(b)
a.remove(10)           
# 并不需要对一个新的对象进行赋值，直接删除序列第一次出现的指定对象，不会给出被删除的值
print(a)

列表元素的访问和计数
通过索引直接访问元素：
-index()获得指定元素在列表中首次出现的索引
index(value,[start,[end]])
-count()获得指定元素在列表中出现的次数
-len()获得列表的长度，即列表中包含的元素个数

成员资格判断：判断列表中是否有指定的元素
可以用count()，返回0则代表不存在；但一般会用更简洁的in来判断，直接返回True or False

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

典型操作（三个量为正数的前提下）：

其它操作（三个量为负数的前提下）

起始偏移量和终止偏移量即使不在范围内也不会报错

列表的遍历

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

列表的排序
修改原列表不创建新列表的排序
顺序排列：a.sort()
倒序排列：a.sort(reverse=True)
打乱顺序（需要先import）：random.shuffle(a)

a = [1, 6, 4, 3, 7, 2, 5]
a.sort()
print(a)
a.sort(reverse=True)
# 倒序排列
print(a)
import random
# 引入random后，打乱顺序
random.shuffle(a)         
print(a)

建新列表的排序：
我们也可以通过内置函数sorted进行排序，这个函数生成新列表，不对原有列表进行修改
sorted(a):升序排列
sorted(a,reverse=True):降序排列

reversed()返回迭代器

c = reversed(a)
print(list(c))      #只能迭代一次，再要用list进行迭代则会显示[]

列表相关的其它内置函数汇总
max():取最大值
min():取最小值
sum():取总和

多维列表

列表套列表[[],[],[],[]]

用python制作表格

# 二维列表中，每个[]后都要加上,
a = [["name", "age", "salary", "province"],
     ["Tom   ", 21, 8000, "ON"],
     ["Mike", 30, 9000, "BC"],
     ["David", 23, 6000, "MB"],
     ["Paul", 40, 7000, "QC"]]
for m in range(5):					#共有5行
    for n in range(4):				#共有4列
        print(a[m][n], end="\t")
    print()   # 每打完一行之后必须要换行

元组tuple

列表属于可变序列，元祖属于不可变序列，元组没有没有增加、修改、删除元素相关的方法。
元组支持如下操作：

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

元组的创建

通过()创建元组，小括号可以省略，如果只有一个数，比如要加逗号
a = (20,)
通过tuple()创建
b = tuple()
b = tuple(“abc”) 和list()用法一样
b = tuple(range(3))
b = tuple([1,2,3])
删除：del b

总结：
tuple()可以接受列表，字符串，其它序列类型，迭代器等生成元素
list()可以接受元组，字符串，其它序列类型，迭代器等生成元素

元组的元素访问和计数
元组的元素不能修改
元组的访问和列表一样
元组的排序方法只能使用sorted(tuple)

a = tuple("abedcfgh")
print(a)
print(a[1:10])          # 生成tuple
print(a[3])             # 生成字符
print(sorted(a))        # 生成列表

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

b = [2, 3, 5]
c = [6, 7, 8]
d = [9, 10, 11]
e = list(zip(b, c, d))
print(e)

最后形成：[(2, 6, 9), (3, 7, 10), (5, 8, 11)]

生成器推导式创建元组
生成器推导式生成的不是列表也不是元组，而是一个生成器对象

【操作：生成器】

f = (s*2 for s in range(5))  # 取0到4的整数
g = tuple(f)
print(g)
print(list(f))      # 得到[]，只能访问一次第二次就空了
f.__next__()

#不能和上面的模块连在一起，要再生成一次元组
f = (s*2 for s in range(5))  # 取0到4的整数
#注意next左右各有两个下划线
print(f.__next__())         # 0
print(f.__next__())         # 2
print(f.__next__())         # 4
print(f.__next__())         # 6
print(f.__next__())         # 8

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