四、容器：字符串、列表、元组、字典

千里之行起于足下

已于 2023-11-12 13:32:38 修改

阅读量105

点赞数

分类专栏： python 文章标签： python 开发语言

于 2023-10-31 15:46:08 首次发布

本文链接：https://blog.csdn.net/u011249837/article/details/134142098

版权

python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

1.字符串

1）介绍字符串

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。

a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))

注意：控制台显示结果为<class 'str'>，即数据类型为str(字符串)。

2）字符串特征

一对引号字符串

name1 = 'Tom'
name2 = "Rose"

三引号字符串

name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom, 
        nice to meet you! '''

b = """ i am Rose, 
        nice to meet you! """

注意：三引号形式的字符串支持换行。

#创建一个字符串`I'm Tom`?
c = "I'm Tom"
d = 'I\'m Tom'

双引号或者单引号中的数据，就是字符串

3）格式化操作符输出

    name = '小明'
    position = '程序员'
    address = '北京市'

    print('--------------------------------------------------')
    print("姓名：%s" % name)
    print("职位：%s" % position)
    print("公司地址：%s" % address)
    print('--------------------------------------------------')

4）f-strings

f-strings 提供一种简洁易读的方式, 可以在字符串中包含 Python 表达式. f-strings 以字母 ‘f’ 或 ‘F’ 为前缀, 格式化字符串使用一对单引号、双引号、三单引号、三双引号. 格式化字符串中

name = '小明'
age = 33
format_string1 = f'我的名字是 {name}, 我的年龄是 {age}'
format_string2 = f"我的名字是 {name}, 我的年龄是 {age}"
format_string3 = F'''我的名字是 {name}, 我的年龄是 {age}'''
format_string4 = F"""我的名字是 {name}, 我的年龄是 {age}"""
format_string5 = f'3 + 5 = {3 + 5}'
a = 10
b = 20
format_string6 = f'3 + 5 = {a + b}'
# 两个花括号会被替换为一个花括号, 注意{{}} 不表示表达式
format_string7 = F'我的名字是 {{name}}, 我的年龄是 {{age}}'

print(format_string1)
print(format_string2)
print(format_string3)
print(format_string4)
print(format_string5)
print(format_string6)
print(format_string7)

运行结果：

1.我的名字是小明, 我的年龄是 33
2.我的名字是小明, 我的年龄是 33
3.我的名字是小明, 我的年龄是 33
4.我的名字是小明, 我的年龄是 33
5.3 + 5 = 8
6.3 + 5 = 30
7.我的名字是 {name}, 我的年龄是 {age}

5）字符串输入

input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存

    userName = input('请输入用户名:')
    print("用户名为：%s" % userName)

    password = input('请输入密码:')
    print("密码为：%s" % password)

6）下标

所谓下标就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间

字符串实际上就是字符的数组，所以也支持下标索引。

如果想取出部分字符，那么可以通过下标，python中下标从 0 开始

   name = 'abcdef'

   print(name[0])
   print(name[1])
   print(name[2])

7）切片

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

切片的语法：[起始:结束:步长]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

如果取出一部分，则可以在中括号[]中，使用:

     name = 'abcdef'
     print(name[0:3]) # 取 下标0~2 的字符
     print(name[0:5]) # 取 下标为0~4 的字符
     print(name[3:5]) # 取 下标为3、4 的字符
     print(name[2:]) # 取 下标为2开始到最后的字符
     print(name[1:-1]) # 取 下标为1开始 到 最后第2个  之间的字符

#有字符串str = “chuanzhibokehuanyingni!”,请用切片切出'huanyingni'
str = 'chuanzhibokehuanyingni!'
# 切出'huanyingni'
print(str[-11:-1])

# 索引是通过下标取某一个元素
# 切片是通过下标去某一段元素
s = 'Hello World!'
print(s[4])
print(s)
print(s[:]) # 取出所有元素（没有起始位和结束位之分），默认步长为1
print(s[1:]) # 从下标为1开始，取出 后面所有的元素（没有结束位）

print(s[:5])  # 从起始位置开始，取到 下标为5的前一个元素（不包括结束位本身）
print(s[:-1]) # 从起始位置开始，取到 倒数第一个元素（不包括结束位本身）
print(s[-4:-1]) # 从倒数第4个元素开始，取到 倒数第1个元素（不包括结束位本身）
print(s[1:5:2]) # 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）
# python 字符串快速逆置
print(s[::-1])  # 从后向前，按步长为1进行取值

2.字符串常见操作

如有字符串mystr = ‘hello world it and it cpp’，以下是常见的操作

1）find

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

语法

字符串序列.find(子串, 开始位置下标, 结束位置下标)

示例

mystr = 'hello world it and it cpp'
pos=mystr.find('it', 0, len(mystr))
print(pos)

2）index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.

语法

字符串序列.index(子串, 开始位置下标, 结束位置下标)

示例

mystr.index(str, start=0, end=len(mystr))

#有字符串str = “chuan zhi bo ke huan ying ni!”, 判断“chuan zhi”是否在str中，如果存在求出起始下标 
str = 'chuan zhi bo ke huan ying ni!'
# 判断“chuan zhi”是否在str中
index = str.find('chuan zhi')
if index!=-1:
    print(f'在str中,下标为:{index}')
else:
    print('不在str中')

3）count

返回 str在start和end之间在 mystr里面出现的次数。

字符串序列.count(子串, 开始位置下标, 结束位置下标)

mystr = 'hello world itcast and itcastcpp'
print(mystr.count('d', 0,len(mystr)))
print(mystr.count('world'))

4）replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

语法

字符串序列.replace(旧子串, 新子串, 替换次数)

示例

mystr = 'hello world it and it cpp'
str=mystr.replace('it', 'python',  mystr.count('it'))
print(str)

5）split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

语法

字符串序列.split(分割字符, num)

示例

mystr = 'hello world it and it cpp'
str=mystr.split(" ", 2)
print(str)

运行结果：

[‘hello’, ‘world’, ‘it and it cpp’]

6）join

mystr 中每个元素后面插入str,构造出一个新的字符串

语法

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

示例

list1 = ['a','b','c','d']
list2 = '—'.join(list1)
print(list2)

运行结果：

a—b—c—d

7）capitalize

把字符串的第一个字符大写

mystr = 'hello world it and it cpp'
mystr.capitalize()

运行结果：

hello world it and it cpp
Hello world it and it cpp

8）title

把字符串的每个单词首字母大写

mystr = 'hello world it and it cpp'
str=mystr.title()
print(str)

运行结果：

Hello World It And It Cpp

9）lower

转换 mystr 中所有大写字符为小写

mystr.lower()

10）upper

转换 mystr 中的小写字母为大写

mystr.upper()

str1 = 'ren sheng ku DUAN,  Wo yong pYthon!'
# capitalize 结果:Ren sheng ku duan,  wo yong python!
print(str1.capitalize())
# title 结果:Ren Sheng Ku Duan,  Wo Yong Python!
print(str1.title())
# lower 结果:ren sheng ku duan,  wo yong python!
print(str1.lower())
# upper 结果:REN SHENG KU DUAN,  WO YONG PYTHON!
print(str1.upper())

11）lstrip

删除 mystr 左边的空白字符

mystr.lstrip()

12）rstrip

删除 mystr 字符串末尾的空白字符

mystr.rstrip()

13）strip

删除mystr字符串两端的空白字符

a = "\t python \t\n"
print(a)
b=a.strip()
print(b)
print(a)

运行结果：

	 python 	

python
	 python

以下等价

str1 = '  hello python  '
# 第一种
print(str1.lstrip().rstrip())
# 第二种
print(str1.strip())

14）ljust

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

语法mystr.ljust(width)

mytr='hello'
str=mytr.ljust(10)

15）rjust

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

mystr.rjust(width)

mytr='hello'
str=mytr.rjust(10)

16）center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

mystr.center(width)

17）startswith

检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False

语法

字符串序列.startswith(子串, 开始位置下标, 结束位置下标)

2.示例

mystr = 'hello world it and it cpp'
b=mystr.startswith('hello')
print(b)

18）endswith

检查字符串是否以obj结束，如果是返回True,否则返回 False.

mystr.endswith(obj)

19）isalpha

如果 mystr 所有字符都是字母则返回 True,否则返回 False

mystr.isalpha()

20）isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

mystr.isdigit()

21）isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

mystr.isalnum()

22）isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

mystr.isspace()

23）rfind

类似于 find()函数，不过是从右边开始查找.

mystr.rfind(str, start=0,end=len(mystr) )

24）rindex

类似于 index()，不过是从右边开始.

mystr.rindex( str, start=0,end=len(mystr))

25）partition

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

26）rpartition

类似于 partition()函数,不过是从右边开始.

mystr.rpartition(str)

27）splitlines

按照行分隔，返回一个包含各行作为元素的列表

mystr = 'hello world\nit and it cpp'
str=mystr.splitlines()
print(str)

运行结果：

[‘hello world’, ‘it and it cpp’]

28）用户名和密码格式校验程序

'''用户名和密码格式校验程序
要求从键盘输入用户名和密码，校验格式是否符合规则，如果不符合，打印出不符合的原因，并提示重新输入
用户名长度6-20，用户名必须以字母开头
密码长度至少6位，不能为纯数字，不能有空格
'''
# 校验
while True:
    # 输入
    name = input('请输入用户名')
    pwd = input('请输入密码')
    # 校验用户名
    if not(len(name)>=6 and len(name)<=20):
        print('用户名必须在6到20位')
        continue
    if not name[0].isalpha():
        print('用户名必须以字母开头')
        continue
    # 校验密码
    if len(pwd)<6:
        print('密码至少6位')
        continue
    if pwd.isdigit():
        print('密码不能为纯数字')
        continue
    if pwd.find('')!=-1:
        print('密码中不能有空格')
        continue
    break
print('开始登陆')

3.列表

1）列表的格式

变量A的类型为列表

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

    testList = [1, 'a']

2）打印列表

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']
    print(namesList[0])
    print(namesList[1])
    print(namesList[2])

3）下标

和字符串一样,列表也可以通过下标(索引)访问元素,下标也是从0开始

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose

4）查找函数

index()：返回指定数据所在位置的下标。

列表序列.index(数据, 开始位置下标, 结束位置下标)

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1

注意：如果查找的数据不存在则报错。

5）统计次数

count()：统计指定数据在当前列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1

6）列表长度

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

name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3

#定义一个列表list1，列表中的元素有“chao”、“ji”、“ma”、“li”，判断list1中含有多少个元素，并判断“li”的下标是多少，出现了几次，代码如下
list1 = ['chao','ji','ma','li']
# list1中含有多少个元素
print(len(list1))
# li的下标是多少
print(list1.index('li'))
# li出现了几次
print(list1.count('li'))

7）判断是否存在

in：判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)

需求：查找⽤户输⼊的名字是否已经存在。

name_list = ['Tom', 'Lily', 'Rose']
name = input('请输⼊您要搜索的名字：')
if name in name_list:
 print(f'您输⼊的名字是{name}, 名字已经存在')
else:
 print(f'您输⼊的名字是{name}, 名字不存在')

#定义一个列表list1，列表中的元素有“chao”、“ji”、“ma”、“li”，判断是否存在“li”这个元素，出现了几次，代码如下
list1 = ['chao','ji','ma','li']
# 是否存在li这个元素
if 'li' in list1:
    c = list1.count('li')
    print(f'存在li这个元素,出现了{c}次')
else:
    print('不存在li这个元素')

8）案例：判断用户登陆是否成功

users = ['root','westos']
passwd = ['123','456']

while True:
    # 输入
    name = input('请输入用户名')
    pwd = input('请输入密码')
    # 用户名是否存在
    if name not in users:
        print('用户名不存在,请重新登陆')
        continue
    # 用户名存在
    # 密码是否正确
    i = users.index(name)
    p = passwd[i]
    if pwd!=p:
        print('密码不正确,重新登陆')
        continue
    # 登陆成功
    print('登陆成功')
    break

9）添加元素(append, extend, insert)

append

通过append可以向列表添加元素

    #定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----添加之前，列表A的数据-----")
    for tempName in A:
        print(tempName)

    #提示、并添加元素
    temp = input('请输入要添加的学生姓名:')
    A.append(temp)

    print("-----添加之后，列表A的数据-----")
    for tempName in A:
        print(tempName)

列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。

注意点

如果append()追加的数据是一个序列，则追加整个序列到列表

name_list = ['Tom', 'Lily', 'Rose']

name_list.append(['xiaoming', 'xiaohong'])

# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)

#定义一个列表alist = [1,2,3]，blist = [3,4,5]，将blist当做一个元素添加到列表alist的末尾
alist = [1,2,3]
blist = [3,4,5]
# 将blist当做一个元素添加到列表alist的末尾
alist.append(blist)

extend

通过extend可以将另一个集合中的元素逐一添加到列表中

name_list = ['TOM', 'Lily', 'ROSE']

# name_list.extend('xiaoming')
name_list.extend(['xiaoming', 'xiaohong'])

print(name_list)

# extend() 追加数据是一个序列，把数据序列里面的数据拆开然后逐一追加到列表的结尾

insert

insert(index, object) 在指定位置index前插入元素object

name_list = ['TOM', 'Lily', 'ROSE']

# name_list.insert(下标, 数据)
name_list.insert(1, 'aaa')
print(name_list)

7）删除元素("删"del, pop, remove)

列表元素的常用删除方法有：

del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除

del

 
    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

    print('------删除之前------')
    for tempName in movieName:
        print(tempName)

    del movieName[2] #删除指定数据
    # del movieName  #删除列表
    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

pop

列表序列.pop(下标)

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

    print('------删除之前------')
    for tempName in movieName:
        print(tempName)
#弹出最后一个
    movieName.pop()

    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

remove

列表序列.remove(数据)

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

    print('------删除之前------')
    for tempName in movieName:
        print(tempName)

    movieName.remove('指环王')

    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

8） clear 清空列表

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
movieName.clear()
print(movieName)

9）列表修改数据(sort, reverse)

修改指定下标数据

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)

逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)

排序：sort()

语法
```
列表序列.sort( key=None, reverse=False)
```
注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

快速体验

num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)

10）复制(copy)

函数：copy()

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
movieName2 = movieName.copy()
print(movieName2)

11）列表遍历

while

name_list = ['Tom', 'Lily', 'Rose'] 
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

for

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
    print(i)

12）for循环遍历删除的问题

#1.用for循环对alist进行遍历。
#2.在for循环中，每循环到一个数据就将其删除，循环结束之后查看列表。删除元素之后,后面会向前补齐下次就会删除下一个元素,当前位置的元素就不能删除

alist = [10,15,13,14,16]
# 用for循环对alist进行遍历
#for ele in alist:
#    print(ele)
# 在for循环中，每循环到一个数据就将其删除，循环结束之后查看列表，会存在什么问题？
for ele in alist:
    alist.remove(ele)
print(alist)# [15, 14]

删除元素之后,后面会向前补齐下次就会删除下一个元素,当前位置的元素就不能删除

13）列表嵌套

所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表。

name_list = [['TOM', 'Lily', 'Rose'], ['张三', '李四', '王五'], ['xiaohong', 'xiaoming', 'xiaolv']]
print(name_list)
# 列表嵌套的时候的数据查询
print(name_list[0])
print(name_list[0][1])

运行结果：

[[‘TOM’, ‘Lily’, ‘Rose’], [‘张三’, ‘李四’, ‘王五’], [‘xiaohong’, ‘xiaoming’, ‘xiaolv’]]
[‘TOM’, ‘Lily’, ‘Rose’]
Lily

#三级嵌套
alist = [10,15,13,14, ['a', 'b', 'c', ['a1', 'b1', 'c1']]]
# 通过下标取值的方法取到'a1'这个元素
ele = alist[4][3][0]
print(ele)

14）练习：随机分配工位

#一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
import random
# 定义一个列表用来保存3个办公室
offices = [[],[],[]]
# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']
i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

15）练习：小球放入不同的盒子里

# 将6个小球放入3个不同的盒子里，并且每个盒子中至少有一个球 

import random
balls = ['球1','球2','球3','球4','球5','球6']
boxes = [[],[],[]]
# 先把每一个盒子放一个球
for box in boxes:
    # 随机获取一个球
    ball = balls[random.randint(0,len(balls)-1)]
    # 放入盒子中
    box.append(ball)
    # 将球移除
    balls.remove(ball)
# 剩下的球随机分配到每一个盒子中
for ball in balls:
    # 随机获取一个盒子
    box = boxes[random.randint(0,len(boxes)-1)]
    # 放入球
    box.append(ball)

4.元组

1）定义

⼀个元组可以存储多个数据，元组内的数据是不能修改的。

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

# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)

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

t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str

python中不允许修改元组的数据，包括不能删除其中的元素。

2）操作元祖

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

按下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) #输出 aa

index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。
```
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
```

count()：统计某个数据在当前元组出现的次数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2

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

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4

元组内的数据如果直接修改则⽴即报错

tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'

但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的，故⾃觉很重要。

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)

3）应用场景

自动组包

t = (10,20,30)
a,b,c = t # a 10 b 20 c 30

自动解包
```
t = 10,20,30 # t是元组类型
```

格式化输出

t = ('bill',30)
print('姓名是:%s,年纪是:%d'%t) #元组元素1占用姓名  元素2占用年纪

让列表不可被修改,保护数据安全

l = [10,20,30]
# 将列表变成元组 元素就不可变了
t = tuple(l)

5.字典

字典，字典⾥⾯的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不⽀持下标，

后期⽆论数据如何变化，只需要按照对应的键的名字查找数据即可。

1）创建字典的语法

字典特点：

符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤逗号隔开

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()

⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。

2）增

写法：字典序列[key] = 值

如果key存在则修改这个key对应的值；如果key不存在则新增此键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

字典为可变类型。

3）删

del() / del：删除字典或删除字典中指定键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)

clear()：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) # {}

4）改

写法：字典序列[key] = 值

如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

5）查

key值查找

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错

如果当前查找的key存在，则返回对应的值；否则则报错。

get()

字典序列.get(key, 默认值)

如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None

keys()

获取字典所有的键

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])

values()

获取字典所有的值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])

items()

获取字典所有的条目

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])

6）字典的循环遍历

#遍历字典的key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():    
    print(key)

# 遍历字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

#遍历字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

#遍历字典的键值对
#xx.items(): 返回可迭代对象，内部是元组，元组有2个数据
# 元组数据1是字典的key，元组数据2是字典的value

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

6.集合

1）创建集合

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

s1 = {10, 20, 30, 40, 50}
print(s1)

s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)

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

s4 = set()
print(type(s4))  # set

s5 = {}
print(type(s5))  # dict

特点：

集合可以去掉重复数据；
集合数据是无序的，故不支持下标
{}代表的是空字典，不是空集合，创建空集合，需要set()

2）增加数据

add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)  # {100, 10, 20}

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

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

s1 = {10, 20}
# s1.update(100)  # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)

3）删除数据

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

s1 = {10, 20}

s1.remove(10)
print(s1)

s1.remove(10)  # 报错
print(s1)

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

s1 = {10, 20}

s1.discard(10)
print(s1)

s1.discard(10)
print(s1)

pop()，随机删除集合中的某个数据，并返回这个数据。

s1 = {10, 20, 30, 40, 50}

del_num = s1.pop()
print(del_num)
print(s1)

4）查找数据

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

s1 = {10, 20, 30, 40, 50}

print(10 in s1)
print(10 not in s1)

7.公共方法

1）运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

+运算

# 1. 字符串 
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)  # aabb


# 2. 列表 
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3)  # [1, 2, 10, 20]

# 3. 元组 
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3)  # (1, 2, 10, 20)

#4.字典
# print(dict1 + dict2)  # 报错：字典不支持合并运算

*运算

# 1. 字符串
print('-' * 10)  # ----------

# 2. 列表
list1 = ['hello']
print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']

# 3. 元组
t1 = ('world',)
print(t1 * 4)  # ('world', 'world', 'world', 'world')

in或not in运算

# 1. 字符串
print('a' in 'abcd')  # True
print('a' not in 'abcd')  # False

# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1)  # True
print('a' not in list1)  # False

# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1)  # False
print('aa' not in t1)  # True

2）公共方法

函数	描述
len()	计算容器中元素个数
del 或 del()	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start, end, step)	生成从start到end的数字，步长为 step，供for循环使用
enumerate()	函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

#len()
# 1. 字符串
str1 = 'abcdefg'
print(len(str1))  # 7

# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1))  # 4

# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1))  # 5

# 4. 集合
s1 = {10, 20, 30}
print(len(s1))  # 3

# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1))  # 2

#del()
# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)

# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1)  # [20, 30, 40]

# max()
# 1. 字符串
str1 = 'abcdefg'
print(max(str1))  # g

# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1))  # 40

# min()
# 1. 字符串
str1 = 'abcdefg'
print(min(str1))  # a

# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1))  # 10

# range()
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
    print(i)

# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)

# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
    print(i)

range()生成的序列不包含end数字。

enumerate()

标序号，本质是长度2的元组

语法

enumerate(可遍历对象, start=0)

注意：start参数用来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']

for i in enumerate(list1):
    print(i)

for index, char in enumerate(list1, start=1):
    print(f'下标是{index}, 对应的字符是{char}')

3）容器类型转换

 #  tuple()
#作用：将某个序列转换成元组
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}

print(tuple(list1))
print(tuple(s1))

# list()

#作用：将某个序列转换成列表
t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}

print(list(t1))
print(list(s1))

#  set()
#作用：将某个序列转换成集合
list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')

print(set(list1))
print(set(t1))

注意：

集合可以快速完成列表去重
集合不支持下标

8.推导式

1）列表推导式

作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。

列表推导式又叫列表生成式。

需求：创建一个0-10的列表。

while循环实现

# 1. 准备一个空列表
list1 = []

# 2. 书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
    list1.append(i)
    i += 1

print(list1)

for循环实现

list1 = []
for i in range(10):
    list1.append(i)

print(list1)

列表推导式实现

list1 = [i for i in range(10)]
print(list1)

2）带if的列表推导式

需求：创建0-10的偶数列表

方法一：range()步长实现

list1 = [i for i in range(0, 10, 2)]
print(list1)

方法二：if实现

list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

3）多个for循环实现列表推导式

需求：创建列表如下：

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

代码如下：

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

4）实现分组一个 list 里面的元素

# 构建1到100的列表
l = [ele for ele in range(1,101)]
# 分割
new_l = [l[i:i+3] for i in range(len(l)) if i%3==0]
print(new_l)

运行结果：

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18], [19, 20, 21], [22, 23, 24], [25, 26, 27], [28, 29, 30], [31, 32, 33], [34, 35, 36], [37, 38, 39], [40, 41, 42], [43, 44, 45], [46, 47, 48], [49, 50, 51], [52, 53, 54], [55, 56, 57], [58, 59, 60], [61, 62, 63], [64, 65, 66], [67, 68, 69], [70, 71, 72], [73, 74, 75], [76, 77, 78], [79, 80, 81], [82, 83, 84], [85, 86, 87], [88, 89, 90], [91, 92, 93], [94, 95, 96], [97, 98, 99], [100]]

5）创建一个字典推导式

字典推导式作用：快速合并列表为字典或提取字典中目标数据。

#创建一个字典：字典key是1-5数字，value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16}

运行结果：

{1: 1, 2: 4, 3: 9, 4: 16}

#将两个列表合并为一个字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']

dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)

运行结果：

{‘name’: ‘Tom’, ‘age’: 20, ‘gender’: ‘man’}

#提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}

# 需求：提取上述电脑数量大于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)  # {'MBP': 268, 'DELL': 201}

运行结果：

{‘MBP’: 268, ‘DELL’: 201}

6）集合推导式

#创建一个集合，数据为列表的2次方。
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1)  # {1, 4}

运行结果：

{1, 4}

集合有数据去重功能。

7）字符串的逆序以及统计

# 1. while True
while True:
    # 2.输入字符串
    msg = input('请输入字符串')
    # 3.判断长度是否小于31
    if len(msg) >= 31:
        print('请重新输入')
        continue
    # 4.如果不是纯字母 重新输入
    if not msg.isalpha():
        print('输入字符串必须全是字母')
        continue
    # 4.您输入的字符串: ...
    print('您输入的字符串:{}'.format(msg))
    # 5.长度: ... len
    print('长度:{}'.format(len(msg)))
    # 6.逆序后为: ... abc->cba 切片
    reverseMsg = msg[::-1]
    print('逆序后为:{}'.format(reverseMsg))
    # 7.字符统计结果: ...(afsfdsf)  a:1  f:3 s:2 d:1
    # 统计字符串中出现的元素
    # adadf a:1
    d = {}
    # 统计
    for ele in msg:
        # 判断是否在字典中
        if ele not in d:
            # 增加一条数据
            d[ele] = 1
        else:
            # 已经存在  修改个数+1
            # d[ele] = d[ele]+1
            d[ele] += 1
    print('统计结果:{}'.format(d))

运行结果：

请输入字符串342
输入字符串必须全是字母
请输入字符串gas
您输入的字符串:gas
长度:3
逆序后为:sag
统计结果:{‘g’: 1, ‘a’: 1, ‘s’: 1}
请输入字符串fjdkalshg
您输入的字符串:fjdkalshg
长度:9
逆序后为:ghslakdjf
统计结果:{‘f’: 1, ‘j’: 1, ‘d’: 1, ‘k’: 1, ‘a’: 1, ‘l’: 1, ‘s’: 1, ‘h’: 1, ‘g’: 1}
请输入字符串

千里之行起于足下

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
四、容器：字符串、列表、元组、字典

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。注意：控制台显示结果为，即数据类型为str(字符串)。⼀个元组可以存储多个数据，元组内的数据是不能修改的。元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型。# 多个数据元组# 单个数据元组t2 = (10,)如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型t2 = (10,)t3 = (20)
复制链接

扫一扫