Python基础篇（05）：高级变量类型（列表、元组、字符串、字典、集合）

xw5643516

已于 2023-10-20 22:41:57 修改

阅读量152

点赞数

文章标签： python windows 开发语言

于 2023-08-19 14:31:47 首次发布

本文链接：https://blog.csdn.net/qq_23440467/article/details/132378466

版权

一. 列表

1、定义列表

info_list = []  #定义一个空列表，列表索引从0开始

2、列表的常用操作

分类	关键字/函数/方法	说明
增加	列表.insert(索引,数据)	在指定位置插入数据
	列表.append(数据)	在末尾追加数据
	列表.extend(列表2)	将列表2的数据追加到列表
修改	列表[索引]=数据	修改指定索引的数据
删除	del 列表[索引]	删除指定索引的数据
	列表.remove(数据)	删除第一次出现的指定数据
	列表.pop()	删除末尾数据
	列表.pop(索引)	删除指定索引数据
	列表.clear	清空列表
统计	len(列表)	计算列表长度
	列表.count(数据)	计算数据在列表中出现的次数
排序	列表.sort()	升序排序
	列表.sort(reverse=True)	降序排序
	列表.reverse()	反转列表

# 定义一个列表
name_list = ["zhangsan", "lisi", "wangmazi"]
# 输出指定索引位置的数据
print(name_list[0])  # zhangsan

# 在指定位置插入数据
name_list.insert(0, "xialuo")
print(name_list)
name_list.insert(2, "顾安")
print(name_list)

# 在列表末尾添加一条数据
name_list.append("xiaotian")
print(name_list)

# 修改指定索引处的数据
name_list[1] = "momo"
print(name_list)

# del删除指定索引的数据
del name_list[2]
print(name_list)

# 删除第一次出现的指定数据
name_list.append("lisi")  
print(name_list)
name_list.remove("lisi")
print(name_list)

# 删除末尾数据
name_list.pop()
print(name_list)

# pop删除指定索引数据
name_list.pop(1)
print(name_list)

# 统计列表长度
print(len(name_list))

# 统计数据在列表中出现的次数
name_list.append("xialuo")
print(name_list)
print(name_list.count("xialuo"))

# 列表升序排序
num_list = [3, 1, 2, 5, 4, 7]
num_list.sort()
print(num_list)

# 列表降序排序
numbers_list = [3, 1, 2, 5, 4, 7]
numbers_list.sort(reverse=True)
print(numbers_list)

# 反转列表
numbers_list.reverse()
print(numbers_list)

# numbers_list的数据追加到name_list
name_list.extend(numbers_list)
print(name_list)

二. 元组

1、定义元组

info_tuple = ()   #定义一个空元组，元组索引从0开始

2、元组的常用操作

# 定义一个元组
info_data = (1, "张三", 1.21)

# 如果元组中只有一个元组，必选在后面加逗号
info_data1 = (1,)

# 统计元组中元素出现的个数
info_data2 = (1, 1, 2, 1, 3, 11)
print(info_data2.count(1))

# 查找元组中元素的第一次出现的索引
print(info_data2.index(3))

# 列表和元组之间类型可以相互转化
print(type(info_data2))
info_data3 = list(info_data2)
print(type(info_data3))
info_data4 = tuple(info_data3)
print(type(info_data4))

# 将info_data元组和info_data2元组合并成一个新元组
print(info_data)
print(info_data2)
t = info_data + info_data2
print(t)

3、列表和元组区别

数据结构	定义符号	是否可变	存储空间	能否作为字典的键
列表（list）	方号 [ ]	可变，动态	内存较大	不能
元组（tuple）	圆括号 ( )	不可变，静态	内存较小	能

4、列表的pop()和remove()、del区别

remove()方法传入的参数是列表中元素值，用于移除列表中某个值的第一个匹配项，返回值是None

name_list = ["11", "11", "wangmazi"]

new_name_list = name_list.remove("11")

print(new_name_list)  # None
print(name_list)  # ['11', 'wangmazi']

pop()方法传入的参数是列表的索引，用于移除列表中的一个元素（不传索引值默认是最后一个元素），并且返回该元素的值

name_list = ["11", "11", "wangmazi"]

new_name_list = name_list.pop(2)

print(new_name_list)  # wangmazi
print(name_list)  # ['11', 'wangmazi']

del 删除列表中某位置的元素，无返回

name_list = ["11", "11", "wangmazi"]

del name_list[0]

print(name_list)  # ['11', 'wangmazi']

# del name_list 删除了name_list这个变量，之后无法访问name_list，但是name_list指向的对象[ "11", "wangmazi"]仍然存在，Python运行时，自带的垃圾回收系统会跟踪每个对象的引用，如果["11", "wangmazi"]除了name_list外，还在其他地方被引用，那就不会被回收

三. 字典

1、定义字典

d = {key1 : value1, key2 : value2, key3 : value3}

字典是可变数据类型
键必须是唯一的且不可变的，但值则不必
值可以取任何数据类型，由于键必须不可变，所以只能是字符、数字或元组

2、字典和列表的区别

列表是有序的对象集合
字典是无序的对象集合

3、字典内置函数&方法

内置函数	描述
len(dict)	计算字典元素个数，即键的总数。
str(dict)	输出字典，用可以打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。
内置方法	描述
dict.get(key, default=None)	返回指定键的值，如果键不在字典中返回 default 设置的默认值
dict.items()	返回一个列表，列表每个元素都是key和value组成的单独元组
dict.keys()	以列表形式返回字典的所有key
dict.values()	以列表形式返回字典的所有values

4、字典的常用操作

1、创建字典

# 创建一个空字典
emptyDict = {}
print(type(emptyDict))
print("字典的长度是：%s" % len(emptyDict))

# 创建一个不为空的字典
tinyDict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print("字典的长度是：%s" % len(tinyDict))

2、[ ]和get方法访问字典值的区别

tinyDict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 字典中存在键时访问值，两者结果相同
print("字典中Name的值是：", tinyDict["Name"])  # 字典中Name的值是： Runoob
print("字典中Name的值是：", tinyDict.get("Name"))  # 字典中Name的值是： Runoob

# 字典中不存在键时访问值，使用[]直接报错KeyError，使用get方法会返回None
# print("字典中address的值是：", tinyDict["address"])  # 报错KeyError
print("字典中不存在键时对应的值：", tinyDict.get("address"))  # 字典中不存在键时对应的值： None

3、修改字典中的值

# 修改字典键所对应的值
tinyDict["Age"] = 8
print(tinyDict)

4、字典中添加不存在的键值对

# 字典中添加不存在的键值对
tinyDict["school"] = "五中"
print(tinyDict)   # 由于字典是无需对象集合，所以只能往最后添加，不能往指定位置加

5、删除字典元素

# 删除字典中指定的键值对
del tinyDict["Name"]
print(tinyDict)
# 清空字典
tinyDict.clear()
print(tinyDict)

# 删除字典 key（键）所对应的值，返回被删除的值
print(tinyDict.pop("Name"))
print(tinyDict)  #此时字典中键值对都不存在了

6、for循环遍历字典所有键和值的三种方法

1. 使用items()方法遍历字典的“键-值”对

# dict.items() 返回一个元组列表，列表每个元素都是key和value组成的单独元组
my_dict = {'name': 'Tom', 'age': 18, 'sex': '男'}

print(my_dict.items())  # dict_items([('name', 'Tom'), ('age', 18), ('sex', '男')])

for k, v in my_dict.items():
    print(k, v)
"""
name Tom
age 18
sex 男
"""

2. 使用key()与values()方法遍历字典的键与值

my_dict = {'name': 'Tom', 'age': 18, 'sex': '男'}
for key in my_dict.keys():  # 遍历键
    print(key)
    """
    name
    age
    sex
    """

for value in my_dict.values():  # 遍历值
    print(value)
    """
    Tom
    18
    男
    """

3. 使用enumerate()函数遍历键和值，并返回它们的索引

my_dict = {'name': 'Tom', 'age': 18, 'sex': '男'}
for index, (key, value) in enumerate(my_dict.items()):  # 使用items()方法，将字典转换为“键-值”对列表
    print(index, key, value)
    """
    0 name Tom
    1 age 18
    2 sex 男 
    """

5、交换字典键值对的方法

1、使用zip函数

zip() 函数来可以把 2 个或多个列表合并，并创建一个元组对的列表，元组对的数量以合并列表的最短长度为准
python 3中 zip 方法合并列表后生成的是 zip 对象，使用 list 方法可以将其变成列表，使用 dict 方法可以将其变成字典

dic = {"A": 1, "B": 2, "C": 3}
print(dic.values())  # dict_values([1, 2, 3])
print(dic.keys())  # dict_keys(['A', 'B', 'C'])
data = zip(dic.values(), dic.keys())
print(data)  # 返回的是zip对象  <zip object at 0x000000000243EF00>
print(dict(data))  # {1: 'A', 2: 'B', 3: 'C'}

2、使用字典推导式

dic = {"A": 1, "B": 2, "C": 3}


def test():
    print("我要开始做实验了")
    # 返回一个字典推导式
    return {dic[k]: k for k in dic}


print(test())
"""
输出内容：
我要开始做实验了
{1: 'A', 2: 'B', 3: 'C'}
"""

3、使用 for 循环

dic = {"A": 1, "B": 2, "C": 3}
# dict.items() 返回一个列表，列表每个元素都是key和value组成的单独元组
print(dic.items())  # dict_items([('A', 1), ('B', 2), ('C', 3)])
new_dic = {}

for key, val in dic.items():
    new_dic[val] = key  # 参考（字典中添加不存在的键值对）
print(new_dic)  # {1: 'A', 2: 'B', 3: 'C'}

四、字符串

1、字符串的常用操作

字符串索引从0开始

# 定义一个字符串
string = "hello python"

# 打印字符串的每个元素
for i in string:
    print(i)

# 通过索引取字符串的值
print(string[2])

# 切片
print(string[1:])  #结束位是空
print(string[2:8])  #取索引为2~7的值

2、字符串的方法

1、字符串大小写操作

# 定义一个字符串
string = "hello python"

# 使用capitalize方法获得字符串首字母大写后的字符串
print(string.capitalize())

# 使用title方法获得字符串每个单词首字母大写后的方法
print(string.title())

# 使用upper方法获得字符串大写后的字符串
print(string.upper())

# 使用lower方法获得字符串小写后的字符串
print(string.lower())

2、字符串查找操作

# 定义一个字符串
string = "hello python"

# find方法从字符串中查找另一个字符串第一次出现的位置，并返回另一个字符串首字符的索引
print(string.find("o"))
# find找不到返回-1
print(string.find("q"))
# index方法从字符串中查找另一个字符串所在的位置，并返回另一个字符串首字符的索引
print(string.index("th"))
# index找不到抛异常ValueError: substring not found
# print(string.index("q"))

# 从指定位置开始查找字符出现的位置
print(string.find("o", 1, 7))
print(string.find("o", 6))

# 从后向前找指定字符出现的位置（相当于最后一次出现的位置）
print(string.rfind("o"))

3、字符串性质判断

通过字符串的startswith、endswith判断字符串是否以某个字符串开头和结尾，返回布尔值

s = "hello world"
print(s.startswith("H1"))  #False
print(s.startswith("he"))  #True
print(s.endswith("d"))

# isdigit检查字符串是否以数字构成
print(s.isdigit())   #False

# isalpha检查字符串是否全部以字母构成
print(s.isalpha())

4、字符串格式化

# rjust右对齐左填充
print(s.rjust(20, "-"))
# ljust左对齐右填充
print(s.ljust(20, "-"))

a = 123
b = 5
print("%d * %d = %d" % (a, b, a * b))
print("{0} * {1} = {2}".format(a, b, a * b))

5、字符串修剪操作

strip方法可以帮助我们获取字符串修剪掉左右两端空格后的字符串

s1 = "test_Strip \r\t\n"
print(s1.strip())

6、字符串替换操作

s = "hello world"
print(s.replace("o", "@", 1))  #1代表替换的个数，不写默认全部替换

7、字符串编码解码操作

s = "hello world"
# 编码
a = s.encode("utf-8")
print("a = ", a)
# 解码
b = a.decode("utf-8")
print("b = ", b)

五、集合

1、定义集合

set1 = set{}   #定义一个空集合

2、集合特征

无序性：集合中每个元素地位都相同，元素之间无序
互异性：元素在集合中只能出现一次
确定性：给定一个集合和一个任意元素，该元素要么属于集合要么不属于集合

3、创建集合

# 创建集合
set1 = {1, 2, 3}
print(set1)

# 使用构造器创建集合
set2 = set("1234")
print(set2)

# 将列表转换为集合，可以去除列表中重复元素
list1 = [1, 2, 3, 3, 2, 1, 4]
set3 = set(list1)
print(list(set3))

# 使用列表生成式创建集合
set4 = {num for num in range(1, 20)
        if num % 3 == 0 or num % 5 == 0
        }
print(set4)

4、集合的并交差运算

# 集合的运算
set1 = {1, 2, 3, 4, 5, 6, 7}
set2 = {2, 4, 6, 8, 10}
# 集合的交集
set3 = set1 & set2
print(set3)
print(set1.intersection(set2))
# 集合的并集
set4 = set1 | set2
print(set4)
print(set1.union(set2))
# 集合的差集
set5 = set1 - set2  #set1去掉set2中存在的
print(set5)
print(set1.difference(set2))

5、集合的方法

# 创建一个空集合
set1 = set()

# add 方法将需要添加的元素当做一个整体，添加到集合中去
set1.add(33)
set1.add(55)
print(set1)

# update 方法是把要传入的元素拆分，做为个体传入到集合中
set1.update({1, 10, 100, 100})
print(set1) #由于集合之间元素无序，所以更新后元素无序

# 通过discard删除指定元素，如果元素不存在不抛异常
set1.discard(12)
print(set1)
set1.discard(10)
print(set1)

# 通过remove方法删元素，元素不存在抛KeyError异常
# set1.remove(12)
# print(set1)

# pop方法随机删除一个元素并返回该元素
print(set1.pop())
print(set1)

# clear方法清空整个集合
set1.clear()
print(set1)

六、Python之推导式

1、列表推导式

列表推导式语法：

new_list = [expression(item) for item in iterable if condition]

翻译过来就是：

new_list = []
for item in iterable:
    if condition:
        new_list.append(expression(item))

列表推导式的作用：将一个可迭代对象转换为列表

举例：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
# 定义一个列表推导式
new_list = [i for row in matrix for i in row]
print(new_list)

# 对列表推导式展开
new_list = []
for row in matrix:
    for i in row:
        new_list.append(i)
print(new_list)

2、字典推导式

字典推导式为列表推导式思想的延续，语法差不多，只不过返回的是字典而已。

d = {'a': 1, 'b': 2, 'c': 3}
for k in d:
    print(k)  # a b c

print({d[k]: k for k in d})  # {1: 'a', 2: 'b', 3: 'c'}

3、集合推导式

集合推导式跟列表推导式非常相似，唯一区别在于用 { } 代替 [ ]

举例：

# 集合推导式
new_set = {x for x in range(10) if x % 2 == 0}
print(new_set)

# 集合推导式展开
new_set = set()
for x in range(10):
    if x % 2 == 0:
        new_set.add(x)
print(new_set)