Python学习（三）：字符串切片&分割&合并&驻留机制&字符串方法&可变字符串&基本运算符&序列&切片操作&列表

Python学习今日分享：

字符串切片&分割&合并&驻留机制&字符串方法&可变字符串&基本运算符&序列&切片操作&列表

让我们先了解一下方法：

案例代码：

# 字符串切片slice操作(截取字符串)
a = "abcdef"
#打印的结果为：bcde，数组下标从0开始
#格式：[起始偏移量start：终止偏移量end：步长step]
print(a[1:5])
print(a[:3])
#步长为1时正常
print(a[1:5:1])
#步长为2时为每两个字符打印一个字符
print(a[1:5:2])
#反向提取
print(a[::-1])


# split()分割和join合并
# 使用join拼接比使用“+”拼接效率高
a = "w am x"
# 打印结果：['w', 'am', 'x']
print(a.split())

b = a.split()
# 打印结果：w*am*x
print("*".join(b))

# 字符串驻留机制和字符串比较
# 字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。Python支持字符串驻留机制，
# 对于符合标识符规则的字符串（仅包含下划线（_），字母和数字）会启用字符串驻留机制
a = "aba_3"
b = "aba_3"
print(a is b)
c = "dd#?"
d = "dd#?"
print(c is d)

# 成员操作符
# in/ not in 关键字，判断某个字符（子字符串）是否存在于子字符串中
a = "abc"
b = "a"
# 打印结果为true
print(b in a)


# 字符串常用方法汇总
a = "我的测试文档as"
# 字符串长度
print(len(a))
# 以指定字符串开头
print(a.startswith("我"))
# 以指定字符串结尾
print(a.endswith("文档"))
# 第一次出现指定字符串的位置
print(a.find("的"))
# 最后一次出现指定字符串的位置
print(a.rfind("的"))
# 指定字符串出现了几次
print(a.count("我"))
# 所有字符全是字母或数字
print(a.isalnum())
# 字母全大写
print(a.upper())
# 字母全小写
print(a.lower())
# 去除首尾的空格
print("  sex  ".strip())
# 去除左边的*
print("*sex*".lstrip("*"))
# 去除右边的*
print("*sex*".rstrip("*"))

# 格式排版
a = "sex"
# 居中 打印结果为：***sex****
print(a.center(10, "*"))
# 居右 打印结果为： *******sex
print(a.rjust(10, "*"))
# 居左 打印结果为：sex*******
print(a.ljust(10, "*"))

# 字符串 format格式化
a = "name={0},age={1}"
print(a.format("大脚", 11))


# ^ . < . > 分别是居中，左对齐，右对齐
print("我是。。。，我喜欢数字{0:*^8}".format("666"))

# 可变字符串
# 导入模块
import io
s = "hekko"
sio = io.StringIO(s)
# 拿值
print(sio.getvalue())
sio.seek(2)
sio.write("厉")
# 打印的结果为： he厉ko
print(sio.getvalue())


# 基本运算符
a = 3
# 打印的结果为24 1  小乘大除
print(a << 3)
print(a >> 1)

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

# python 的列表大小可变，根据需要随时增加或缩小

# 列表的创建
# 基本语法[]创建
a = [100, 200, "细节"]
# 创建一个空的列表对象
b = []
b.append(200)
print(b)


# list()创建
a = list()
a = list(range(10))
# 打印的结果为[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a)
a = list("w")
# 打印的结果为： ['w']
print(a)


# 通过range（）创建整数列表
# range(起始数字，结尾数字，步长)
print(list(range(0, 5, 1)))

# 推导式生成列表

a = [x*2 for x in range(5)]
# 打印结果为：[0, 2, 4, 6, 8]
print(a)
# 通过if 过滤元素
print([x*2 for x in range(100) if x%9 == 0])

# 列表元素的增加和删除
# 当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低,除非必要，
# 我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率

# append()方法
# 原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用
a.append(20)
# 打印结果为： [0, 2, 4, 6, 8, 20]
print(a)

# +运算符操作
# 并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中，这样会涉及大量的复制操作，对于操作大量元素不建议使用.
# 2184225837376
# 2184225745152
# 地址发生变化，也就是创建了新的对象
print(id(a))
a = a+[10]
print(id(a))

# extend() 方法
# 将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象
# 1368885487872
# 1368885487872
# 地址未发生改变
print(id(a))
a.extend([10])
print(id(a))


# insert()插入元素
# 使用insert方法可以将制定元素插入到列表的任意制定位置。这样会插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。
# 类似发生这种移动的函数还有：remove（）,pop(),del(),他们在删除非尾部元素时也会发生操作位置后面元素的移动
a.insert(0, 100)
# 打印结果为：[100, 0, 2, 4, 6, 8, 20, 10, 10]
print(a)


# 乘法扩展
# 使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复
print(a*3)


# 列表元素的删除
# del 删除
a = [10, 10, 20]
print(a)
del a[2]
print(a)


# pop()方法
# pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素
a = [10, 20]
a.pop(0)
print(a)


# remove（）方法
# 删除首次出现的指定元素，若不存在该元素抛出异常
a = [10, 20, 30, 20]
a.remove(20)
# 打印结果为 ：[10, 30, 20]
print(a)


# 列表元素的访问和计数

# 通过索引直接访问元素
a = [10, 20, 10, 30]
print(a[2])

# index()获得指定元素在列表中首次出现的索引
print(a.index(10))
# 从a[1]开始找
print(a.index(10, 1))

# count()获得指定元素在列表中出现的次数
# 打印的结果为2
print(a.count(10))

# len()返回列表长度
# 打印结果：4
print(len(a))


# 成员资格判断
# 判断列表中是否存在指定的元素，我们可以使用count（）方法，返回0则表示不存在，返回大于0则存在.但是，我们一般会使用更加简洁的in关键字来判断，直接返回true或false
print(220 in a)

# 切片操作
# 切片是Python序列及其重要的操作，适用于列表，元组，字符串等等
# 包头不包尾
a = [10, 20, 30, 40, 50]
# 打印结果为：[20, 30]
print(a[1:3:1])
# 打印的结果为： [40, 50]
print(a[-2:])
# 打印的结果为：[50, 40, 30, 20, 10]
print(a[::-1])

# 列表的遍历
for obj in a:
    print(obj)

# 列表排序
# 修改原列表，不建新列表的排序
a = [20, 10, 30]
a.sort()
# 打印结果：[10, 20, 30]
print(a)

a.sort(reverse=True)
# 降序 打印结果为：[30, 20, 10]
print(a)

import random

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


# 建新列表的排序
# 我们也可以通过内置对象函数sorted()进行排序，这个方法返回新列表，不对原列表做修改

a = [20, 30, 10, 50]
# 默认升序
a = sorted(a)
print(a)

a = sorted(a, reverse=True)
print(a)

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

a = [20, 10, 30]
b = reversed(a)
print(b)
print(list(b))

# 列表相关的其他内置函数汇总
# max 和 min
# 最大值
print(max(a))
# 最小值
print(min(a))
# 和 有非数字则会报错
print(sum(a))

今天的分享就到这里啦！