每日笔记打卡：从0开始学python_day3_序列

每日笔记打卡：从0开始学python_day3_序列

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

>>> import io
>>> s = "hello, sxt"
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x02F462B0> >>> sio.getvalue()
'hello, sxt'
>>> sio.seek(7)
7
>>> sio.write("g")
1
>>> sio.getvalue()
'hello, gxt'

按位与运算符（&）

参加运算的两个数，按二进制位进行“与”运算。

运算规则：只有两个数的二进制同时为1，结果才为1，否则为0。（负数按补码形式参加按位与运算）

即 0 & 0= 0 ，0 & 1= 0，1 & 0= 0， 1 & 1= 1。

例：3 &5 即 00000011 & 00000101 = 00000001 ，所以 3 & 5的值为1。

按位或运算符（|）

参加运算的两个数，按二进制位进行“或”运算。

运算规则：参加运算的两个数只要两个数中的一个为1，结果就为1。

即 0 | 0= 0 , 1 | 0= 1 ， 0 | 1= 1 , 1 | 1= 1 。

例：2 | 4 即 00000010 | 00000100 = 00000110 ，所以2 | 4的值为 6 。

异或运算符（^）

参加运算的两个数，按二进制位进行“异或”运算。

运算规则：参加运算的两个数，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。

即 0 ^ 0=0 ， 0 ^ 1= 1 ， 1 ^ 0= 1 ， 1 ^ 1= 0 。

例： 2 ^ 4 即 00000010 ^ 00000100 =00000110 ，所以 2 ^ 4 的值为6 。

第三章：序列

1. 列表简介
   列表:用于存储任意数目、任意类型的数据集合。
   列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式: a = [10,20,30,40]
   其中，10,20,30,40 这些称为:列表 a 的元素。 列表中的元素可以各不相同，可以是任意类型。比如:
   a = [10,20,‘abc’,True]
2. 列表的创建：
   (1)基本语法[]创建

a=[10,20,'gaoqi','sxt']
a.append(20)
print(a)
#[10, 20, 'gaoqi', 'sxt', 20]

3. list()创建

a=list()
a=list(range(10))
print(a)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

a=list('gaoqi')
print(a)
#['g', 'a', 'o', 'q', 'i']

range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为: range([start,] end [,step])
start 参数:可选，表示起始数字。默认是 0
end 参数:必选，表示结尾数字。
step 参数:可选，表示步长，默认为 1
python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其 转换成列表对象。

a=list(range(0,10,1))
print(a)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3. 推导式生成列表(简介一下，重点在 for 循环后讲)

a=[x*2 for x in range(5)]
print(a)
#[0, 2, 4, 6, 8]

4. 列表元素的增加
   （1）append（）方法

a=[10,20,30]
a.append(50)
print(a)

(2)+运算符操作:并不是真正的尾部添加元素，而是创建新的列表对象。

a=[10,20,30]
a=a+[500]
print(a)

（3）extend（）方法：将目标列表的所以元素添加到本列表的尾部，属于原地操作，不创建新的列表。

a=[10,20,30]
a.extend([40])
print(a)
#[10, 20, 30, 40]

(4)insert（）插入元素：指定的元素插入到列表对象的任意位置。

a=[10,20,30]
a.insert(1,40)
print(a)
#[10, 40, 20, 30]

(5)乘法扩展：使用乘法扩展列表，生成一个新列表

a=['sxt',100]
n=a*3
print(n)
#['sxt', 100, 'sxt', 100, 'sxt', 100]

5. 列表元素的删除
   （1）del()

a=[100,200,888,300,400]
del a[1]
print(a)
#[100, 888, 300, 400]

(2)pop()方法：默认弹出最后一个元素

a=[100,200,888,300,400]
b=a.pop()
print(b)
#400

a=[100,200,888,300,400]
b=a.pop(1)
print(b)
#200

(3)remove():删除首次出现的指定元素，若元素不存在抛出异常。

a=[100,200,888,300,400,100]
a.remove(100)
print(a)
#[200, 888, 300, 400, 100]

6. 列表元素的访问与计数
   （1）通过索引直接访问

a=[100,200,888,300,400,100]
a=a[2]
print(a)
#888

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

a=[100,200,888,300,400,100]
b=a.index(200)
print(b)
#1

(3)指定范围搜索索引

a=[100,200,888,300,400,100]
b=a.index(100,3)
print(b)
#5

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

a=[100,200,888,300,400,100,100]
b=a.count(100)
print(b)
#3

(5)len()返回列表长度

a=[100,200,888,300,400,100,100]
b=len(a)
print(b)
#7

7. 成员资格判断

a=[10,20,30,40,50,60,70,10,20,]
b=20 in a
print(b)
#True

8. 切片操作
   
   
9. 列表排序
   (1)升序排序

a=[20,10,30,40]
a.sort()
print(a)

（2）降序排序

a=[20,10,30,40]
a.sort(reverse=True)
print(a)

(3)乱序排序

import random
a=[20,10,30,40]
random.shuffle(a)
print(a)

10. 建新列表的排序

a=[20,10,30,40]
a=sorted(a)
print(a)
#[10, 20, 30, 40]

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

a = [20,10,30,40]
c = reversed(a)
c

12. 最大最小值

a=[20,10,30,40]
b=max(a)
print(b)
#40

求和

a=[20,10,30,40]
b=sum(a)
print(b)
#100

13. 多维列表

a=[["高小一",18,30000,"北京"], ["高小二",19,20000,"上海"], ["高小一",20,10000,"深圳"],]
print(a[0])
#['高小一', 18, 30000, '北京']

a=[["高小一",18,30000,"北京"], ["高小二",19,20000,"上海"], ["高小一",20,10000,"深圳"],]
print(a[0][3])
#北京

多维列表和嵌套循环

a=[
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"], 
["高小一",20,10000,"深圳"], ]
for m in range(3):
    for n in range(4):
        print(a[m][n],end="\t")
    print() #打印完一行，换行

高小一 18 30000 北京
高小二 19 20000 上海
高小一 20 10000 深圳

元组tuple
列表属于可变序列，可以任意修改列表中的元素，元组属于不可变序列，不能修改元组中的元素。

a=(20,)
print(type(a))
<class 'tuple'>

通过tuple()创建元组

b=tuple('abc')
print(b)
#('a', 'b', 'c')

元组的元素访问和计数：元组的元素不能修改。

a=tuple('abcdefg')
b=a[1:10]
print(b)
#('b', 'c', 'd', 'e', 'f', 'g')

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

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
n=list(d)
print(n)
#[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

生成器推导式创建元组

s=(x*2 for x in range(5))
print(tuple(s))
#(0, 2, 4, 6, 8)

只能生成一次