目录
1.可变字符串(由于字符串定义之后是不可变的,所以才需要想办法修改)
1.可变字符串(由于字符串定义之后是不可变的,所以才需要想办法修改)
当字符串修改比较频繁的时候,可以考虑用io模块
io.StringIO()
import io
s = "hell, sxt"
sio = io.StringIO(s)
print(sio)
#<_io.StringIO object at 0x000001B6005F0280>
#调用和修改sio,sio可修改
sio.seek(7) #定位
sio.write("g") #修改
print(sio.getvalue())
#hell, sgt ,getvalue()括号里不需要带东西
2.基本运算符
(1)比较运算符可以连用,并且含义跟我们日常使用完全一致
(2)位操作
按位与:两个同时为1时,为1;其他都为0
a = 0b11001
b = 0b01000
c = a & b
print(bin(c))
#0b1000
按位或:有一个1则为1
a = 0b11001
b = 0b01000
c = a | b #或用竖杠来表示“按位或”
print(bin(c)) #bin就是按照二位制进行编码
#0b11001
异或:相异则为1
a = 0b11001
b = 0b01000
c = a ^ b
print(bin(c))
#0b10001
(3)移位:
a = 3
b = a << 2 #左移1为相当于乘以2,左移两位相当于乘以4
print(b)
#12
a = 8
b = a >> 2 #右移1位相当于除以2,两位相当于除以4
print(b)
#2
(4)加法操作:
列表相加可以起到拼接的作用
a = [10, 20, 30] + [5, 10, 30]
print(a)
#[10, 20, 30, 5, 10, 30]
(5)乘法操作
*表复制三次
a = 3 * 2
b = "sxt" * 3
c = [10, 20, 30] * 3
print(a, b, c)
#6 sxtsxtsxt [10, 20, 30, 10, 20, 30, 10, 20, 30]
运算符的优先级问题:
复杂表达式一定要用小括号组织
1.乘除优先加减;
2.位运算和算数运算>比较运算符>赋值运算符
小练习
码出数学公式
#(5 + 10 * x) / 5 - 13 * (y - 1) * (a + b) / x + 9 * (5 / x + (12 + x) / y)
一.序列:
序列是一种数据存储的方式,序列结构有:字符串、列表、字典和集合
python中一切皆对象
序列就是一块用来存储多个值的连续的内存空间
对于列表[10,20,30,40]来说,a = [10,20,30,40]在内存中实际按照如下方式存储。通过变量的索引找到地址,再通过地址找到相关对象,然后读出对象的value值。
1.列表:用于储存任意数目、任意类型的数据集合;
(1)列表中常用的方法:
(2)列表的创建:
1)基本语法[]创建;
a = [] #创建空列表
a.append(20)
print(a)
#[20]
2)list()创建,跟空列表创建时一个道理
list()可以将任何可迭代的数据转化为列表,尤其是字符串
#字符串用list转化为列表
a = list("gaoyuxing")
print(a)
#['g', 'a', 'o', 'y', 'u', 'x', 'i', 'n', 'g']
3)通过range()创建整数列表
range()的基本语法格式为:range([start] end [step])
start参数:可选,表示期数数字,默认为0
end参数:必选,表示结尾数字;
step参数:可选,表示步长,默认为1
#range转换为列表
a = range(10) #左闭右开集合
b = list(a)
print(b)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a =list(range(0, 10, 1))
print(a)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = list(range(0, 10, 2))
print(a)
#[0, 2, 4, 6, 8]
a = list(range(20, 3, -1))
print(a)
#[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
a = list(range(20, 3, -3))
print(a)
#[20, 17, 14, 11, 8, 5]
4)推导式
a = [x * 2 for x in range(5)] #循环创建多个元素
print(a)
#[0, 2, 4, 6, 8]
a = [x * 2 for x in range(100) if x % 9 == 0] #通过if来过滤元素
print(a)
#[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
(3)列表元素的增加和删除
*元素增加
增加和删除都改变列表内存,在这个过程中会涉及 大量的拷贝(复制、粘贴)工作,所以我们一般都在列表末尾进行改动——提高性能
1)append()方法,速度最快,这是最推荐的方法;
a =[10, 20, 30]
a.append(100)
print(a) #[10, 20, 30, 100]
a.append(40)
print(a) #[10, 20, 30, 100, 40]
2)+运算符操作:创建了新的列表对象,会涉及大量的复制操作,当操作大量元素时,不建议使用
a = [10, 20, 30]
print(id(a))
#2277839655936
a = a + [50, 60, 70]
#[10, 20, 30, 50, 60, 70]
print(a)
print(id(a))
#2277839655808
测试:证明append 比 “+” 运算效率高
import time
time01 = time.time() #起始时间
a = ""
for i in range(1000000):
a += "sxt"
time02 = time.time() #终止时间
print(time01, time02)
print("运算时间:"+str(time02 - time01)) #0.42705464363098145
time03 = time.time()#开始时间
list = []
for i in range(1000000):
list.append("sxt")
a = "".join(list)
time04 = time.time() #终止时间
print("运算时间:"+str(time04 - time03)) #0.11100530624389648
3)extend()将目标列表元素添加到本列表尾部,属于原地操作,不创建新的列表对象。整合两个列表时,推荐这种方法
a = [20, 40]
print(id(a))
#3025577763776
a.extend([50, 60])
print(id(a))
#3025577763776
print(a)
#[20, 40, 50, 60]
4)insert()插入元素,将指定的元素插入到列表对象的任意位置,这样会让插入位置之后的元素产生移动,会影响操作速度
a = [10, 20, 30]
print(id(a))
#1966663259136
a.insert(2, 100)
print(a)
#[10, 20, 100, 30]
print(id(a))
#1536877122496
5)乘法扩展
a = ["sxt", 30]
b = a * 3
print(b)
#['sxt', 30, 'sxt', 30, 'sxt', 30]
·列表元素删除
1)del删除:本质上是复制粘贴
a = [10, 20, 30]
del a[1] #后面跟的是索引
print(a)
#[10, 30]
2)pop()方法:删除并返回指定位置元素,如果未指定位置则默认操作列表的最后一个元素
a = [10, 20, 30, 40]
a.pop()
print(a)
#[10, 20, 30]
3)remove()方法:删除首次出现的指定元素,若不存在该元素则抛出异常。注:这里的数字不是索引,而是数字本身;remove和pop后面都是都是数字
a = [1, 2, 3, 4, 5, 2, 1, 3]
a.remove(3)
print(a)
#[1, 2, 4, 5, 2, 1, 3]
注:·python中列表的大小可变,根据需要随时可以增加或缩小;·字符串和列表都是序列类型,一个字符串是一个字符序列,一个列表是任何元素的序列
(4)列表元素的访问和计数
·访问
1)通过索引直接访问元素
#列表元素的访问
a = [1, 2, 3, 4, 5, 6, 7]
print(a[3])
#4
2)index()获得指定元素在列表中首次出现的索引,这里的数字也是数字本身,打印出来的是索引值;
a = [10, 20, 30, 40, 20, 20, 50]
b = a.index(20)
print(b)
#1
index(value,[start] [end] ) 数字表示从start开始的索引范围
c = a.index(20, 3) #从第四个数开始遍历,找到第一个20的索引
print(c)
#4
(4)计数
count()获得指定元素在列表中 出现的次数
a = [10, 20, 30, 40, 20, 20, 50]
print(a.count(20)) #计算一下20这个数字出现了几次
#3
(5)列表长度
len()返回列表的长度
(6)成员资格判断
a = [10, 20, 30, 40, 20, 20, 50]
if 20 in a:
print(1)
else:
print(0)
#1
(7)切片操作
标准格式未[起始偏移量:终止偏移量:步长]
#切片
a = [10, 20, 30, 40, 50, 60]
print(a[:])
#[10, 20, 30, 40, 50, 60]
print(a[1:4:2])
#[20, 40]
print(a[-3:])
#[40, 50, 60]
print(a[::-1])
#从有向左边反向取所有值
#[60, 50, 40, 30, 20, 10]
(8)列表遍历
a = [10, 20, 30, 40, 50, 60]
for i in a:
print(i, end="\t")
#10 20 30 40 50 60
(9)列表排序:
1)修改源列表,不建新列表的排序
a = [20, 10, 30, 40]
a.sort()
print(a)
#[10, 20, 30, 40] 默认为升序
2)降序;
#降序
a.sort(reverse=True)
print(a)
#[40, 30, 20, 10]
3)随机序列
#随机
import random
random.shuffle(a) #重新洗牌,打乱顺序
print(a)
4)建新列表的排序sorted
a = [20, 10, 30, 40]
a = sorted(a)
print(a)
#[10, 20, 30, 40]
5)reversed()返回迭代器,用list列表的形式返回,但只能返回一次,以为指针的位置已经发生了改变。
a = [20, 10, 30, 40]
b = reversed(a)
print(b)
#<list_reverseiterator object at 0x000001C142811C10>
print(list(b))
#[40, 30, 10, 20]
(10)列表相关的其他内置函数汇总
max和min
sum:对于数值型列表求和,对于非数值型列表则会报错
a = [20, 10, 30, 40]
print(max(a))
#40
print(min(a))
#10
a = [20, 10, 30, 40]
print(sum(a))
#100
2.多维列表
列表的元素可以是列表,列表中包含列表则为多为列表;
·二维列表可以帮我们存储二位、表格的数据;
a = []
a = [
["高小一", 18, 30000, "北京"],
["高小二", 19, 20000, "深圳"],
["高小四", 20, 20000, "上海"]
]
print(a)
#[['高小一', 18, 30000, '北京'], ['高小二', 19, 20000, '深圳'], ['高小四', 20, 20000, '上海']]
内存结构图
嵌套循环:
print(a[0])
#['高小一', 18, 30000, '北京']
for m in range(3):
for n in range(4):
print(a[m][n], end="\t") #不换行打印
print()#打印完一个元素换行
'''
高小一 18 30000 北京
高小二 19 20000 深圳
高小四 20 20000 上海
'''
3.元组:
列表是可变元素,可以任意修改列表中的元素。元组属于不可变序列,不能修改元组中的元素。因此,元组没有增加元素、修改元素和删除元素的方法。
元组中可以支持以下操作:
(1)索引访问;
(2)切片操作;
(3)连续操作;
(4)成员关系操作;
(5)比较运算操作;
(6)计数:元组长度、最大值、最小值、求和等
1.元组的创建:
(1)通过()创建元组
a = (10, 20, 30)
print(type(a))
#<class 'tuple'>
a = (19,)
#元组中只有一个数的时候,一定要带逗号,否则系统默认为是整数
(2)通过tuple()来创建元组
b = tuple() #创建一个空元组对象
c = tuple("abc")
d = tuple(range(3))
e = tuple([1, 2, 3, 4])
总结:tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组
2.元组的元素访问和计数
(1)元组的元素不能修改
a = (10, 20, 20, 40)
print(a[1])
#20
'''
a[1] = 300
print(a)
#TypeError: 'tuple' object does not support item assignment
'''
(2)可以进行切片操作,操作方法与列表相仿;
a = tuple("abcdefghijklmn")
print(a)
#('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n')
#元组切片
b = a[3: 10]
print(b)
#('d', 'e', 'f', 'g', 'h', 'i', 'j')
(3)关于排序,在元组中只能使用sorted()函数来进行——生成新的元组对象
c = [10, 20, 30, 40]
c = sorted(c)
print(c)
#[10, 20, 30, 40]
3.zip语法:
zip(列表1,列表2···)将对各列表对应位置的元素组处理成压缩形式,再用list把zip表示出来
a = [10, 20, 30, 40]
b = [50, 60, 70, 80]
c = [90, 100, 110, 120]
d = zip(a, b, c) #将每个列表里的元素打包成元组,然后用列表的形式表示出来
print(zip(d))
#<zip object at 0x000002AB9140D240>
print(list(d))
#[(10, 50, 90), (20, 60, 100), (30, 70, 110), (40, 80, 120)]
4.生成器推导式创建元组
类似于列表推导式,生成器推导用小括号,生成器生成的不是列表,也不是元组,而是一个生成器对象。生成器只能用一次。
#生成器的使用
s = (i * 2 for i in range(5))
print(s)
#<generator object <genexpr> at 0x00000252742F07B0>
print(tuple(s))
#(0, 2, 4, 6, 8)
print(list(s))
#[]
s = (i * 2 for i in range(5))
print(s.__next__())
#0
print(s.__next__())
#2
print(s.__next__())
#4
print(s.__next__())
#6
print(s.__next__())
#8
'''
print(s.__next__())
#报错了
'''
5.元组总结:
(1)元组的核心特点是:不可变序列;
(2)元组的访问和处理速度比列表快;
(3)与整数和字符串一样,元组可以作为字典的键;列表则永远不可以作为字典的键来使用。
因为整数和字符串以及元组都具有不可变的特点。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表;