本文已收录于专栏 🌻 《Python 基础》

文章目录

• 🌕1、字符串
• • 🥝1.1 字符串基本操作
  • • 🍊1.1.1 字符串创建
    • 🍊1.1.2 字符串元素读取
    • 🍊1.1.3 字符串分片
    • 🍊1.1.4 连接和重复
    • 🍊1.1.5 关系运算
    • 🍊1.1.6 成员运算
  • 🥝1.2 字符串的常用方法
• 🌕2、列表和元组
• • 🥝2.1 列表
  • • 🍊2.1.1 列表的创建和下标访问
    • 🍊2.1.2 列表的切片操作
    • 🍊2.1.3 列表的遍历操作
    • 🍊2.1.4 列表的插入操作
    • 🍊2.1.5 列表的查找与删除
    • 🍊2.1.6 列表的拼接
  • 🥝2.2 元组

🌕1、字符串

Python 中的字符串是一个有序的字符集合，用于存储或表示基于文本的信息，它不仅能保存文本，而且能保存非打印字符或二进制数据

重点：

• 双引号或者单引号中的数据，就是字符串
• 如果使用一对引号来定义字符串，当出现符号冲突时可以使用转义字符
• 使用三个单引号、双引号定义的字符串可以包裹任意文本

🥝1.1 字符串基本操作

🍊1.1.1 字符串创建

使用赋值运算符 = 将一个字符串赋值给变量即可创建字符串对象

🍊1.1.2 字符串元素读取

使用索引可以直接访问字符串中的元素，方法为：字符串名称[索引]

🍊1.1.3 字符串分片

采取 字符串名称[开始索引;结束索引;步长] 的方法，从字符串中分离出部分字符

🍊1.1.4 连接和重复

连接： 可以使用运算符 + ，将两个字符串对象连接起来，得到一个新的字符串对象
重复： 使用运算符 * ，构建一个由字符串自身重复连接而成的字符串对象

比如： "hi"*3 输出的是 'hihihi'

🍊1.1.5 关系运算

单字符字符串的比较： 单个字符字符串是按照字符的 ASCII 码值大小进行比较的

多字符字符串的比较： 本质也是按照字符的 ASCII 码值大小进行比较的，先并行地检查两个字符串位于同一个位置的字符，如果这个同一位置的字符的 ASCII 码值大小相等，就向前推进，直到找到两个不同的字符为止

🍊1.1.6 成员运算

字符串使用 in 或 not in 运算符判断一个字符串是否属于另一个字符串，

一般形式为 字符串1 [not] in 字符串2

返回值为 True 或 False

🥝1.2 字符串的常用方法

str.find(substr,start,end)

在主串中查找子串，如果找到则返回子串在主串中的位置，找不到则返回 -1
substr 是要查找的子串，start 和 end 是可选项，分别表示查找的开始位置和结束位置

str.replace(old,new)

用字符串 new 替代 str 中的 old

str.split(sep)

以 sep 为分隔符，把 str 分离成一个列表

str.strip()

去掉 str 中两端空格

str.lower()

把 str 中所有大写字母转换为小写

str.upper

把 str 中所有小写字母转换为大写

🌕2、列表和元组

一个变量来表示很多个数据，类似于其他编程语言中的 “数组”

列表和元组，大部分的功能是差不多的，但是有一个功能是非常明显的 区别：

列表是可变的：创建好了之后，随时能改
元组是不可变的：创建好了之后，改不了，要想改，只能丢弃旧的，搞个新的

🥝2.1 列表

🍊2.1.1 列表的创建和下标访问

# 1.直接使用字面值来创建
#  [] 就表示一个 空的列表
a = []
print(type(a))  # 打印类型

# 2.使用 list() 来创建
b = list()
print(type(b))  # 打印类型

# 3. 可以在创建列表的时候，在 [] 中指定列表的初始值
#   元素之间使用 , 来分割
a = [1, 2, 3, 4]
print(a)

C++/Java 里面要求一个数组里只能存相同类型的变量，Python 里的 列表则无限制，放啥类型都可以

下标从 0 开始计数

🍊2.1.2 列表的切片操作

# 1.切片操作的基本使用
a = [1, 2, 3, 4]
print(a[1:3])   # 输出 [2, 3]

切片操作里，[] 里面有两个数字，表示了一段区间，

1:3
取到下标为 1 一直到 下标为 3 的元素
(包含1，不包含3)
[1,3)

# 2. 使用切片的时候，省略边界
a = [1, 2, 3, 4]
# 省略后边界，意思是从开始位置，一直取到整个列表结束
print(a[1:])
# 省略前边界，意思是从列表的 0号元素开始，一直取到结束的后边界
print(a[:2])
# 此处切片中的下标也可以写成负数
print(a[:-1])  # 输出 [1, 2, 3] 打印到倒数第2个元素
# 还可以把开始边界和结束边界都省略掉！得到的是列表自身
print(a[:])

切片的操作是一个比较高效的操作， 进行切片的时候，只是取出了原有列表中的一个部分，并不涉及到 “数据的拷贝”，假如有一个很大的列表，进行切片，切片的范围很大，即使如此，切片操作仍然非常高效

# 3. 带有步长的切片操作
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::1])  # 输出[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::2])  # 输出[1, 3, 5, 7, 9]

切片操作，还可以指定 “步长”

步长的数值还可以是负数，当步长为负数的时候，意思是从后往前来取元素

当切片中的范围超出有效下标之后，不会出现异常！而是尽可能把符合要求的元素获取到

🍊2.1.3 列表的遍历操作

# 1.使用for循环来遍历列表
a = [1, 2, 3, 4, 5]
for elem in a:
    print(elem)
    
# 2.使用for循环遍历，通过下标的方式
a = [1, 2, 3, 4, 5]
for i in range(0, len(a)):
    a[i] = a[i] + 10
    print(a[i])
    
# 3.使用while循环，通过下标遍历
a = [1, 2, 3, 4, 5]
i = 0
while i < len(a):
    print(a[i])
    i += 1

第一种方法是把列表中的元素赋给elem，不能修改列表值，第二、三种可以利用下标修改列表值

🍊2.1.4 列表的插入操作

# 1.使用 append 往列表末尾新增一个元素
a = [1, 2, 3, 4, 5]
a.append(5)

# 2.使用 insert 方法，往列表的任意位置新增元素
a = [1, 2, 3, 4]
a.insert(1, 'hello')
a.insert(100, 'hello')  # 不会放在第101个位置，而是末尾

🍊2.1.5 列表的查找与删除

查找：

# 1.使用 in 来判定某个元素是否在列表中存在
a = [1, 2, 3, 4]
print(1 in a)   # in 在列表中打印 True
print(10 in a)  # in 不在列表中打印 False
print(1 not in a)
print(10 not in a)

# 2.使用 index 方法，来判定，当前元素在列表中的位置，得到一个下标 
a = [1, 2, 3, 4]
print(a.index(2))
print(a.index(10))   # 不存在,引发异常

删除：

# 1.使用 pop 删除列表中最末尾的元素
a = [1, 2, 3, 4]
a.pop()
print(a)

# 2.使用 pop 还能删除任意位置的元素，pop 的参数可以传一个下标过去
a = [1, 2, 3, 4]
a.pop(1)
print(a)

# 3.使用 remove 方法，可以按照值来进行删除
a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a)

🍊2.1.6 列表的拼接

# 1.使用 + 针对两个列表进行拼接
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = b + a
print(c)
print(a)
print(b)

# 2.使用 extend 来进行拼接
# 这个拼接是把后一个列表的内容拼接到前一个列表里头，即会修改前一个列表
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)  # extend没有返回值
print(a)
print(b)

# 3.使用 += 进行拼接
a = [1, 2, 3]
b = [4, 5, 6]
a += b  # 等价于 a = a + b
print(a)
print(b)

使用 + 进行拼接的时候，只是针对当前列表的内容生成了一个更大的新的列表，原有列表是不变的

🥝2.2 元组

创建元组

# 1.创建元组
a = ()
print(type(a))
b = tuple()
print(type(b))

# 2.创建元组的时候指定初始值
a = (1, 2, 3, 4)
print(a)

元组中的元素也可以是任意类型的

a = (1, 2, 3, 4)
print(a[1])
print(a[-1])

通过下标来访问元组中的元素，下标也是从 0 开始，到 len - 1 结束

a = (1, 2, 3, 4)
print(a[1:3])

通过切片来获取元组中的一个部分

也同样可以使用 for 循环等方式进行遍历元素

可以使用 in 来判定元素是否存在，使用 index 查找元素的下标

可以使用 + 来拼接两个元组

元组只支持 “读” 操作，不支持 “修改” 类操作

当进行多元赋值的时候，其实本质上是按照元组的方式来进行工作的