Python 基础入门笔记———— 字符串列表元组集合字典

Posted 2022-11-14 Xiu Yan

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python 基础入门笔记———— 字符串列表元组集合字典相关的知识，希望对你有一定的参考价值。

文章目录

一、字符串
二、列表
三、元组
四、集合
五、字典
六、可变类型与不可变类型总结

一、字符串

注意：函数中涉及开始位置与结束位置的函数区间，都为左闭右开。

1.1 字符串的创建

一对引号字符串：如：name1 = 'Tom'
三引号字符串
```
name3 = ''' Tom '''
name4 = """ Rose """
str1 = ''' i am Tom,
    nice to meet you! '''
print(str1)

str2 = """ i am Rose,
    nice to meet you! """
print(str2)
```
注意： 三引号形式的字符串支持换行。

此外，字符串若含有 单引号' 或者双引号"使得引号无法正常显示，则可以用斜杠\\ 进行转义，即可正常显示。字符串是不可变数据类型。

1.2 字符串切片

切片是指对操作的对象截取其中一部分的操作，字符串、列表、元组都支持切片操作。

语法：序列[开始位置下标：结束位置下标：步长]

注意：步长是选取间隔，正负整数均可，默认步长为1，字符串索引下标从 0 开始。

示例：

str1 = '012345678'
print(str1[2:5:1])  # 234
print(str1[2:5:2])  # 24
print(str1[2:5])  # 234
print(str1[:5])  # 01234 -- 如果不写开始，默认从 0 开始选取
print(str1[2:])  # 2345678  -- 如果不写结束，表示选取到最后
print(str1[:])  # 012345678  -- 如果不写开始和结束，表示选取所有

# 负数测试
print(str1[::-1])  # 876543210 -- 如果步长为负数，表示倒叙选取
print(str1[-4:-1])  # 567  -- 下标-1表示最后一个数据，依次向前类推

# 终极测试
print(str1[-4:-1:1])  # 567
print(str1[-4:-1:-1])  # 不能选取数据：从-4开始到-1结束，选取方向从左到右，但是步长为-1表示从右到左选取
# 原因如果选取方向(下标开始到结束的方向) 和 步长的方向冲突，则无法选取数据
print(str1[-1:-4:-1])  # 876

1.3 字符串常用操作

字符串的常用操作方法有查找、修改和判断三大类。

1.3.1 查找

find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则返回 -1。

语法：字符串序列.find(子串，开始位置下标，结束位置下标)，其中开始和结束位置下标可以省略略，表示在整个字符串序列中查找。

示例：
```
my_str= "hello world and python and test"

print(my_str.find('and'))  # 12
print(my_str.find('and', 15, 30))  # 23
print(my_str.find('ands'))  # -1
```
index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则报异常。

语法： 字符串序列.index(子串，开始位置下标，结束位置下标)，其中开始和结束位置下标可以省略略，表示在整个字符串序列中查找。

示例：
```
my_str= "hello world and python and test"

print(my_str.index('and'))  # 12
print(my_str.index('and', 15, 30))  # 23
print(my_str.index('ands'))  # 如果index 查找子串不存在，报错
```
rfind()：和 find() 功能相同，但查找方向为右侧开始。
rindex()：和 index() 功能相同，但查找方向为右侧开始。
count()：返回某个子串在字符串中出现的次数

1.3.2 修改

replace()：替换，有返回值，并且返回值是修改后的字符串。

语法： 字符串序列.replace(旧子串,新子串,替换次数)，其中替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

示例：

my_str = "hello world and python and test"

new_str = my_str.replace('and', 'he')
print(new_str)  # hello world he python he test
new_str = my_str.replace('and', 'he', 1)
print(new_str)  # hello world he python and test
# 替换次数如果超出字串出现的次数，表示替换所有这个子串
new_str = my_str.replace('and', 'he', 10)
print(new_str)  # hello world he python he test

split()：分割，返回一个列表，去掉分割字符。

语法：字符串序列.split(分割字符，num)，其中 num 表示的是分割字符出现的次数，即将来返回数据个数为 num+1 个。

示例：

my_str = "hello world and python and test"

list1 = my_str.split('and')
print(list1)  # ['hello world ', ' python ', ' test']
list1 = my_str.split('and', 1)
print(list1)  # ['hello world ', ' python and test']
list1 = my_str.split()  # 默认根据空格分割
print(list1)  # ['hello', 'world', 'and', 'python', 'and', 'test']

join()：将多个字符串合并为一个新的字符串。

语法： 字符或子串.join(多字符串组成的序列)

示例：

list1 = ['11', '22', '33']
tuple1 = ('aa', 'bb', 'cc')
# 3. join() 合并列表里面的字符串
print("...".join(list1))  # 11...22...33
print("...".join(tuple1))  # aa...bb...cc

不常用字符串处理函数
capitalize()：将字符串第一个字符转换成大写。
title()：将字符串每个单词首字母转换成大写。
lower()：将字符串中大写转小写。
upper()：将字符串中小写转大写。
lstrip()：删除字符串左侧空白字符。
rstrip()：删除字符串右侧空白字符。
strip()：删除字符串两侧空白字符。
ljust()：返回一个原字符串左对齐，并使用指定字符(默认空格)填充至对应长度的新字符串。语法： 字符串序列.ljust(长度，填充字符)
rjust()：返回一个原字符串右对齐，并使用指定字符(默认空格)填充至对应长度的新字符串，语法和 ljust() 相同。
center()：返回一个原字符串居中对齐，并使用指定字符(默认空格)填充至对应长度的新字符串，语法和 ljust() 相同。

1.3.3 判断

startswith()：检查字符串是否是以指定子串串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

语法： 字符串序列.startswith(子串，开始位置下标，结束位置下标)

示例：
```
my_str = "hello world and python and test"

# 1. startswith() 判断字符串是否以某个子串开头
print(my_str.startswith('hel'))  # True
print(my_str.startswith('hels'))  # False
print(my_str.startswith('hel', 0, 3))  # True
```
endswith()：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查。

语法： 字符串序列.endswith(子串，开始位置下标，结束位置下标)
isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False。
isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。

二、列表

2.1 列表的创建

格式： [数据1, 数据2, 数据3, 数据4......]

列表为可变数据类型，支持增加。

2.2 列表常用操作

列表的常用操作方法有查找、判断、增加、删除、修改与复制。

2.2.1 查找

利用下标： 通过下标查找列表，注意索引从 0 开始。
index()：返回指定数据所在位置的下标。

语法： 列表序列.index(数据,开始位置下标,结束位置下标)，如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。

len()：访问列表长度，即列表中数据的个数。

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']
# 1. 下标
print(list1[0])  # Kevin
# 2. 函数
print(list1.index('Rose'))  # 3
print(list1.count('Tom'))  # 1
print(len('Tom'))  # 3

2.2.2 判断

in：判断指定数据在某个列表序列，如果在返回 True，否则返回 False
not in：判断指定数据不在某个列表序列，如果不在返回 True，否则返回 False
```
list1 = ['Kevin', 'Tom', 'Mark', 'Rose']
print('Tom' in list1)  # True
```

2.2.3 增加

append()：列表结尾追加数据。

语法：列表序列.append(数据)，如果 append() 追加的数据是一个序列，则追加整个序列到列表。

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

list1.append('xiaoming')
print(list1)  # ['Kevin', 'Tom', 'Mark', 'Rose', 'xiaoming']

list1.append(['aa', 'bb']) 
print(list1)  # ['Kevin', 'Tom', 'Mark', 'Rose', ['aa', 'bb']]

extend()：列表结尾追加数据。

语法：列表序列.extend(数据)，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

list1.extend('xiaoming')
print(list1)  # ['Kevin', 'Tom', 'Mark', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']

list1.extend(['aa', 'bb'])
print(list1)  # ['Kevin', 'Tom', 'Mark', 'Rose', 'aa', 'bb']

insert()：指定位置新增数据。

语法： 列表序列.insert(位置下标，数据)

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

list1.insert(0,'aa')
print(list1)  # ['aa', 'Kevin', 'Tom', 'Mark', 'Rose']
list1.insert(10,'bb') # 超出索引，加至表尾
print(list1)  # ['aa', 'Kevin', 'Tom', 'Mark', 'Rose', 'bb']

2.2.4 删除

del

语法： del 目标

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

# 删除列表
# del list1  # 删除列表
# print(list1)  # 报错
# 删除指定下标的数据
del list1[0]
print(list1)  # ['Tom', 'Mark', 'Rose']

pop()：删除指定下标的数据（默认为最后一个），并返回该数据。

语法： 列表序列.pop(下标)

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

del_list = list1.pop()
print(del_list)  # Rose
del_list = list1.pop(1)
print(del_list) # Tom

remove()：移除列表中某个数据的第一个匹配项。

语法： 列表序列.remove(数据)

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

list1.remove('Tom')
print(list1)  # ['Kevin', 'Mark', 'Rose']

clear()：清空列表

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

list1.clear()
print(list1)  # []

2.2.5 修改

下标修改
逆置：reverse()

排序：sort()

语法： 列表序列.sort( key=None，reverse=False)，

key 用于列表中字典根据 key 排序。
如：students = [ 'name': 'TOM', 'age': 20, 'name': 'ROSE', 'age': 19, 'name': 'Jack', 'age': 22 根据年龄排序。
reverse 表示排序规则，reverse = True 降序，reverse = False升序(默认)

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

# 1. 修改指定下标数据
list1[2] = 'Lily'
print(list1)  # ['Kevin', 'Tom', 'Lily', 'Rose']

list1 = [1, 3, 2, 6, 5]
# 2. reverse() 倒置
list1.reverse()
print(list1)  # [5, 6, 2, 3, 1]

# 3. sort() 排序
list1.sort()
print(list1)  # [6, 5, 3, 2, 1]
list1.sort(reverse=True)
print(list1)  # [6, 5, 3, 2, 1]

2.2.6 复制

函数：copy()

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

new_list = list1.copy()
print(new_list)  # ['Kevin', 'Tom', 'Mark', 'Rose']

2.3 列表的循环遍历

list1 = ['Kevin', 'Tom', 'Mark', 'Rose']

i = 0
while i < len(list1):
    print(list1[i])
    i += 1

for i in list1:
    print(i)

2.4 列表嵌套

列表嵌套指的就是一个列表里面包含了其他的子列表，如：

name_list = [['小明', '小红', '小绿'], ['Kevin', 'Tom', 'Mark'], ['张三', '李四', '王五']]

应用随机分配办公室，需求：有三个办公室，8位师，8位老师随机分配到3个办公室。代码如下：

import random
# 1. 准备数据
teachers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
offices = [[], [], []]

# 2. 分配
for name in teachers:
    num = random.randint(0, 2)  # 取编号
    offices[num].append(name)  # 加到办公室

# 3. 验证数据
i = 1
for office in offices:
    print(f'办公室i的人数是len(office), 老师分别是：', end=" ")
    # 打印名字
    for name in office:
        print(name, end="  ")
    print()
    i += 1

结果（不唯一）如下：

三、元组

3.1 元组的创建

元组为不可变数据类型。
元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。

元组的定义：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型。

# 1. 多个数据元组
t1 = (1, 2, 3)
print(type(t1))  # <class 'tuple'>

# 2. 单个数据元组
t2 = (1,)
print(type(t2))  # <class 'tuple'>

# 3. 如果单个数据的元组不加逗号
t3 = (10)
print(type(t3))  # <class 'int'>

t4 = ('xiu')
print(type(t4))  # <class 'str'>

t5 = ('xiu',)
print(type(t5))  # <class 'tuple'>

3.2 元组常用操作

元组数据不支持修改，只支持查找，具体如下:

3.2.1 查找

按下标查找
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index () 方法相同。
count()：统计某个数据在当前元组出现的次数。

len()：统计元组中数据的个数。

t1 = ('aa', 'bb', 'cc', 'dd')

print(t1[2])  # cc

print(t1.index('bb'))  # 1

print(t1.count('bb'))  # 1

print(len(t1))  # 4

3.2.2 修改元组中的列表

元组不支持直接修改，但可以修改元组里面的列表。

t2 = ('aa', 'bb', ['cc', 'dd'])
print(t2[2][1])  # dd 
t2[2][1] = 'dddddd'
print(t2)  # ('aa', 'bb', ['cc', 'dddddd'])

四、集合

4.1 集合的创建

创建集合使用或 set()，但是如果要创建空集合只能使用 set()，因为用来创建空字典。

# 1. 创建空的数据集合
s1 = 10, 20, 30, 40, 50
print(s1)  # 50, 20, 40, 10, 30 无顺序

s2 = 10, 30, 20, 20, 30, 10
print(s2)  # 10, 20, 30 无顺序

s3 = set('abcdefg')
print(s3)

# 2. 创建空的集合，只能用：set()
s4 = set()
print(s4)  # set()
print(type(s4))  # <class 'set'>

s5 = 
print(s5)  # 
print(type(s5))  # <class 'dict'>

特点：

集合可以去掉重复数据。
集合数据是无序的，故不支持下标。

4.2 集合常用操作

4.2.1 查找

in：判断数据在集合序列

not in：判断数据不在集合序列

s1 = 10, 20, 30, 40, 50

print( 30 in s1)  # True
print( 80 in s1)  # False

4.2.2 增加

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

add()

update()：追加的数据是序列列。

s1 = 10, 20

# add()：增加的数据
s1.add(100)
s1.add(100)  # 集合有去重功能
print(s1)  # 100, 10, 20
# s1.add([100, 300])  # 不可追加序列，报错

# update()：增加的数据是序列
s1.update([100, 300])
print(s1)  # 100, 10, 20, 300
# s1.update(100)  # 不可追加数据，报错

4.2.3 删除

remove()：删除集合中的指定数据，如果数据不存在会报错。

s1 = 10, 20, 30, 40, 50

s1.remove(10)
print(s1)  # 50, 20, 40, 30

s1.remove以上是关于Python 基础入门笔记———— 字符串列表元组集合字典的主要内容，如果未能解决你的问题，请参考以下文章 
 《python基础教程》第2章列表和元组 读书笔记
 读书笔记--《Python基础教程第二版》--第2章列表和元组
 Python零基础入门-------tuple 元组
 Python入门基础学习四
 Python基础入门—元组tuple
 python3 基础 笔记记录-2