序列类型的方法

1. 字符串

1. 增

# 赋值
num_1 = "hello"
num_2 = "world"

# join 连接任意数量的字符串
num = '+'.join([num_1, num_2])

# 打印结果
# hello+world
print(num)

2. 删

# 赋值
num = "  hello world  "

# 删除空格 ' ' != ''
# helloworld
print(num.replace(' ', ''))

# 把空格替换为0
# 00hello0world00
print(num.replace(' ', '0'))

# 删除字符o
#   hell wrld
print(num.replace('o', ''))

# 连续删除
# hellwrld
print(num.replace('o', '').replace(' ', ''))

3. 改

# 赋值
num = "hello world"

# upper 把所有的字母转换为大写
# HELLO WORLD
print(num.upper())


# 赋值
num_1 = "HELLO WORLD"

# lower 把所有的字母转换为小写
# hello world
print(num_1.lower())


# 赋值
num_2 = "  hello world  "

# strip 除去开头和结尾的空格
# hello world
print(num_2.strip())

# 赋值
num_3 = "  hello world"

# lstrip 除去开头的空格
# hello world
print(num_3.lstrip())

# 赋值
num_4 = "hello world  "

# rstrip 除去结尾的空格
# hello world
print(num_4.rstrip())


# 赋值
num_5 = "hello world"

# capitalize 首字母大写
# Hello world
print(num_5.capitalize())

# 赋值
num_6 = "hello world"

# title 每个单词的首字母大写
# Hello World
print(num_6.title())


# 赋值
num_7 = "hello world"

# split 切割
# 括号里为空时，按空格切割
# ['hello', 'world']
print(num_7.split())

# 括号里为字符时，按字符切割
# ['hell', ' w', 'rld']
print(num_7.split('o'))

# 赋值
num_8 = "  hello world  "

# 括号里为空时，按空格切割
# ['hello', 'world']
print(num_8.split())

4. 查

# 赋值
num = "hello world"

# find 如果查找的字符在字符串中，就返回找到的第一个元素的索引值，没有找到返回-1
# 2
print(num.find('l'))

# index 返回字符所对应的索引值，没有找到该字符就报错
# 4
print(num.index('o'))


# isdigit 判断一个字符串里的数据是不是全部都是数字
# False
print(num.isdigit())

# 赋值
num_1 = "helloworld"

# isalpha 判断一个字符串里的数据是不是全部都是字母
# True
print(num_1.isalpha())

# islower 判断字符串中的值是否全部是小写
# True
print(num_1.islower())

# isupper 判断字符串中的值是否全部是大写
# False
print(num_1.isupper())


# endswith 比较结尾的元素是否相同
# True
print(num.endswith('ld'))

# startswith 比较开头的元素是否相同
# False
print(num.startswith('ne'))

其它方法

# 赋值
num = "hello world"

# dir() 查看字符串类型的方法名
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
print(dir(num))

2. 列表

1. 增

# 赋值
li = ['h', 'e', 'l']

# append 将一个元素追加到末尾
# 不能添加多个

# 添加数据
li.append("qi")

# 打印
# ['h', 'e', 'l', 'qi']
print(li)

# 添加数据
li.append("九")

# 打印
# ['h', 'e', 'l', 'qi', '九']
print(li)


# 赋值
li_1 = ['h', 'e', 'l', 'l']


# insert 添加到指定位置
# 通过索引添加 不能添加多个

# 添加数据
li_1.insert(0, "hello")

# 打印
# ['hello', 'h', 'e', 'l', 'l']
print(li_1)


# 赋值
li_2 = ['h', 'e', 'l', 'l', 'o']

# extend 将序列中的每个元素追加到末尾
# 不能添加多个

# 添加数据
li_2.extend([1, 2, 3])

# 打印
# ['h', 'e', 'l', 'l', 'o', 1, 2, 3]
print(li_2)


# 赋值
num_1 = [1, 2, 3]
num_2 = [4, 5, 6]

# 拼接列表
# [1, 2, 3, 4, 5, 6]
print(num_1 + num_2)

2. 删

# 赋值
li = ['h', 'e', 'l', 'l', 'o']

# pop用法一

# 删除数据 括号里为空，默认删除最后一个元素
li.pop()

# 打印
# ['h', 'e', 'l', 'l']
print(li)

# pop用法二

# 赋值
li_1 = ['p', 'y', 't', 'h', 'o', 'n']

# 删除数据 括号里有索引参数，删除索引值所对应的元素
li_1.pop(1)

# 打印
# ['p', 't', 'h', 'o', 'n']
print(li_1)

# pop用法三

# 赋值
li_2 = ['w', 'o', 'r', 'l', 'd']

# 删除数据 直接用print,用完再删
# d
print(li_2.pop())

# 打印
# ['w', 'o', 'r', 'l']
print(li_2)


# 赋值
li_3 = ['a', 'b', 'c', 'e', 'f']


# remove 直接删除元素  有相同的元素时，优先删除索引值靠前的元素
li_3.remove("c")

# 打印
# ['a', 'b', 'e', 'f']
print(li_3)


# 赋值
li_4 = ['a', 'b', 'c', 'e', 'f', 'g', 'h']

# clear 清空列表中所有的元素
li_4.clear()

# 打印
# []
print(li_4)


# 赋值
li_5 = ['a', 'b', 'c', 'e', 'f', 'g']

# del 通过索引值删除所对应的元素
del li_5[2]

# 打印
# ['a', 'b', 'e', 'f', 'g']
print(li_5)

3. 改

# 赋值
li = ['a', 'b', 'c', 'e', 'd', 'f']

# 方法一

# 修改数据 修改索引值所对应的元素
li[1] = "hello"

# 打印
# ['a', 'hello', 'c', 'e', 'c', 'f']
print(li)

# 方法二

# 赋值
li_1 = ['a', 'b', 'c', 'e', 'd']

# 修改数据 先查找到元素对应的索引值，再修改索引值所对应的元素
li_1[li_1.index('e')] = "hello"

# 打印
# ['a', 'b', 'c', 'hello', 'd']
print(li_1)

4. 查

# 赋值
li = ['a', 'b', 'c', 'e', 'c', 'f']

# index 通过元素查找所对应的索引值 没有元素会报错
# 有相同的元素时，优先查找元素靠前的索引值
# 2
print(li.index('c'))


# 赋值
li_1 = ['a', 'b', 'c', 'e', 'c', 'f', 'c']

# count 计算列表中指定元素出现的次数 没有元素为0
# 3
print(li_1.count('c'))

其它方法

# 赋值
li = ['a', 'b', 'c', 'e', 'c', 'f']

# dir() 查看列表类型的方法名
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
print(dir(li))

# reverse 对列表中的元素进行反向排列
li.reverse()

# 打印
# ['f', 'c', 'e', 'c', 'b', 'a']
print(li)


# 赋值
li_1 = [1, 52, 3, 5, 4, 9, 23]

# sort 对列表中的元素进行从小到大的排列
# 一般针对于数值使用 字母是根据ASCII表排列
li_1.sort()  # 或 li_1.sort(reverse=False)

# 打印
# [1, 3, 4, 5, 9, 23, 52]
print(li_1)

# 赋值
li_2 = [1, 52, 35, 5, 47, 9, 23]

# sort 对列表中的元素进行从大到小的排列
li_2.sort(reverse=True)

# 打印
# [52, 47, 35, 23, 9, 5, 1]
print(li_2)

列表推导式

"""

列表推导式

[执行语句 条件语句]

[执行语句 条件语句 判断语句]

"""


# 普通版

# 定义一个列表
li_1 = []

# 遍历循环
for j in range(10):

    # 添加数据到列表中
    li_1.append(j ** 2)

# 打印
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(li_1)


# 列表推导式

# 赋值
li_2 = [i ** 2 for i in range(10)]

# 打印
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(li_2)


# 案例

# 将两个列表中不相等的元素组合起来(普通版)

# 赋值
li_3 = [1, 2, 3]
li_4 = [3, 1, 4]

# for循环
for x in li_3:

    # for循环
    for y in li_4:

        # 判断是否相等
        if x != y:

            # 打印
            print((x, y))


# 列表推导式


# 赋值
num = [(x_1, y_1) for x_1 in li_3 for y_1 in li_4 if x_1 != y_1]

# 打印
print(num)

3. 元组

查

# 赋值
li = ('a', 'b', 'd', 'c', 'e', 'c', 'f')

# dir() 查看元组类型的方法名
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
print(dir(li))

# count 查找元素的数量
# 2
print(li.count('c'))

# index 有相同的元素时，查找第一个元素的索引值
# 3
print(li.index("c"))

深浅赋值

# 只可用于可变类型(列表和字典)中

# 浅复制  内置一部分数据 短的字符串和数值已经被设定了内存地址，不管调不调用，一直都存在

# 赋值
li_1 = [1, 2, 3, 4, 5, 6, 7, [1, 2, 3, 4, 5]]

# 打印内存地址
# 1664098092608
print(id(li_1[-1]))

# 复制
li_2 = li_1.copy()

# 打印内存地址
# 1664098092608
print(id(li_2[-1]))


# 深复制  改变了其内存地址

# 导入模块
import copy

# 赋值
li_3 = [1, 2, 3, 4, 5, 6, 7, [1, 2, 3, 4, 5]]

# 打印内存地址
# 1664098092864
print(id(li_3[-1]))

# 复制
li_4 = copy.deepcopy(li_3)

# 打印内存地址
# 1664098093440
print(id(li_4[-1]))