可变字符串+基本运算符+列表+元组

最新推荐文章于 2022-08-08 15:38:28 发布

斯外戈的小白

最新推荐文章于 2022-08-08 15:38:28 发布

阅读量862

点赞数 1

文章标签： python 列表元组

本文链接：https://blog.csdn.net/weixin_51589123/article/details/114119817

版权

1.可变字符串（由于字符串定义之后是不可变的，所以才需要想办法修改）

2.基本运算符

（1）比较运算符可以连用，并且含义跟我们日常使用完全一致

1.列表：用于储存任意数目、任意类型的数据集合；

（1）列表中常用的方法：

（2）列表的创建：

1）基本语法[]创建；

2）list（）创建，跟空列表创建时一个道理

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（）可以接收元组、字符串、其他序列类型、迭代器等生成列表；

斯外戈的小白

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
可变字符串+基本运算符+列表+元组

1.可变字符串（由于字符串定义之后是不可变的，所以才需要想办法修改）当字符串修改比较频繁的时候，可以考虑用io模块io.StringIO()import ios = "hell, sxt"sio = io.StringIO(s)print(sio)#<_io.StringIO object at 0x000001B6005F0280>#调用和修改sio，sio可修改sio.seek(7) #定位sio.write("g") #修改p...
复制链接

扫一扫