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]))