Python 基础教程【3】:字符串、列表、元组

在这里插入图片描述

本文已收录于专栏
《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 成员运算

字符串使用 innot in 运算符判断一个字符串是否属于另一个字符串,

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

返回值为 TrueFalse

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 查找元素的下标

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

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

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

你可能感兴趣的:(Python,基础,python,开发语言)