Python核心编程 --- 高级数据类型

Python核心编程 — 高级数据类型

• 字符串

• 列表

• 元组

• 字典

1.序列

序列：一组按顺序排列的数据集合。

在Python中存在三种内置的序列类型：字符串、列表、元组

优点：可支持索引和切片操作

特点：第一个正索引为0，指向是左端，第一个索引是负数时，指向是右端。

1.1 切片

作用：可根据下标来获取序列对象的任意部分数据。

语法结构：序列[起始下标:结束下标:步长]

说明：从序列中，从指定位置开始，依次取出元素，到指定位置时结束，得到一个新序列。

• 起始下标表示的是从哪开始，可以留空，留空视为从头开始

• 结束下标表示从哪结束，可以留空，留空视为到结尾结束

• 步长表示，依次取出元素的间隔，如步长1表示一个个取出元素，步长2表示每次跳过一个元素取，步长为负数时，反向取元素。

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret1 = num_list[1:5]   # 步长可省略不写，默认为1
print(f"结果1为{ret1}")

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
ret2 = num_list[:]
print(f"结果2为{ret2}")

num_str = "12345678910"
ret3 = num_list[::2]
print(f"结果3为{ret3}")

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret4 = num_list[::-1]   # 步长可省略不写，默认为1
print(f"结果4为{ret4}")

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
ret5 = num_list[3:1:-1]
print(f"结果5为{ret5}")

num_str = "12345678910"
ret6 = num_str[::-2]
print(f"结果6为{ret6}")

补充：下标会越界，切片不会。

2.字符串及常用方法

2.1 下标索引

• 从前向后，下标从0开始

• 从后向前，下标从-1开始

2.2 查找特定字符串的下标索引值

语法结构：字符串.index(字符串)

names_str = "Hello"
print(names_str.index("o")) # 4

2.3 字符串的替换

语法结构：字符串.replace(字符串1, 字符串2)

作用：字符串1替换字符串2，字符串内的全部。

my_str = "Hello"
print(my_str.replace("He", "haha")) # hahallo

2.4 字符串的分割

作用：按指定的分隔符字符串，划分为多个字符串存入列表对象中。

my_str = "He ll o wo rl d"
print(my_str.split(" ")) # ['He', 'll', 'o', 'wo', 'rl', 'd']

2.5 字符串的规整操作

• 去前后空格

语法结构：字符串.strip()

name_str = " he l l o  "
print(name_str.strip()) # "he l l o"

• 去前后指定字符串

语法结构：字符串.strip(字符串)

name_str = "hellooeh"
print(name_str.strip('he')) # "llo"

注意：传入的是”he“,其实"h"和"e"都会被移除，按照单个字符。

2.6 统计字符串的字符个数

语法结构：len(字符串)

num = len(name_str)
print(f"字符串{name_str}的长度是：{num}") # 字符串hello的长度是：5

2.7 总结

1	字符串[下标]	据下标索引取出特定位置的字符
2	字符串.index(字符串)	查找特定字符串的下标索引值
3	字符串.replace(字符串1, 字符串2)	字符串1替换字符串2，字符串内的全部。
4	字符串.split(分隔符字符串)	按指定的分隔符字符串，划分为多个字符串存入列表对象中。
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格或指定字符串
6	字符串.count(字符串)	统计某字符串中某字符串出现的次数
7	len(字符串)	统计字符串的字符个数

2.8 字符串的遍历 - while循环

str = "hello"
index = 0
while index < len(str):
    print(str[index])
    index += 1

2.9 字符串的遍历 - for循环

str = "hello"
index = 0
for i in str:
    print(i)

2.10 特点

• 只可存储字符串

• 长度任意

• 支持下标索引

• 允许重复字符串存在

• 不可修改

• 支持for循环

3.列表及常用操作

功能：

• 插入元素

• 删除元素

• 修改元素

• 统计元素个数

• 清空列表

3.1 查找指定某元素的下标

语法结构：列表.index(元素)

name_list = ["he", "ll", "o"]
index = name_list.index("ll")
print(f"ll在列表中的下标索引值为：{index}")
# 输出：ll在列表中的下标索引值为：1

3.2 修改指定位置的元素值

语法结构：列表[下标] = 值

name_list = ["he", "ll", "o"]
name_list[1] = "he"
print(f"列表中的下标1的值被改后，结果是：{name_list}")
# 输出：列表中的下标1的值被改后，结果是：['he', 'he', 'o']

3.3 插入元素

说明：在指定的位置，插入指定的元素。

语法结构：列表.insert(下标, 元素)

name_list = ["he", "ll", "o"]
name_list.insert(1, "ha")
print(f"列表中的下标1的位置被插入指定元素后，结果是：{name_list}")
# 输出：列表中的下标1的位置被插入指定元素后，结果是：['he', 'ha', 'll', 'o']

3.4 追加元素方式1

说明：将指定元素，追加到列表的尾部。

语法结构：列表.append(元素)

name_list = ["he", "ll", "o"]
name_list.append("hehe")
print(f"列表追加了元素后，结果是：{name_list}")
# 输出：列表追加了元素后，结果是：['he', 'll', 'o', 'hehe']

3.5 追加元素方式2

说明：将其他数据容器的内容取出，依次追加到列表尾部。

语法结构：列表.extend(其他数据类型)

name_list = ["he", "ll", "o"]
name_list.extend(["wo", "r", "ld"])
print(f"列表追加了元素后，结果是：{name_list}")
# 输出：列表追加了元素后，结果是：['he', 'll', 'o', 'wo', 'r', 'ld']

3.6 删除元素

语法结构1：del 列表[下标]

语法结构2：列表.pop(下标)

# 方法1
name_list = ["he", "ll", "o"]
del name_list[1]
print(f"列表被删除元素后，结果是：{name_list}")
# 输出：列表被删除元素后，结果是：['he', 'o']

# 方法2
name_list = ["he", "ll", "o"]
name_list.pop(1)
print(f"列表被删除元素后，结果是：{name_list}")
# 输出：列表被删除元素后，结果是：['he', 'o']

3.7 删除某元素在列表中的第一个匹配项

语法结构：列表.remove(元素)

name_list = ["he", "ll", "o", "he"]
name_list.remove("he")
print(f"列表被移除元素后，结果是：{name_list}")
# 输出：列表被移除元素后，结果是：['ll', 'o', 'he']

3.8 清空列表

语法结构：列表.clear()

name_list = ["he", "ll", "o", "he"]
name_list.clear()
print(f"列表被清空后，结果是：{name_list}")
# 输出：列表被清空后，结果是：[]

3.9 统计某元素在列表中的数量

语法结构：列表.count(元素)

name_list = ["he", "ll", "o", "he"]
print(f"列表中he的数量是：{name_list.count("he")}")
# 输出：列表中he的数量是：2

3.10 统计列表元素个数

语法结构：len(列表)

name_list = ["he", "ll", "o", "he"]
print(f"列表中的元素个数有：{len(name_list)}")
# 输出：列表中的元素个数有：4

3.11 总结：

编号	使用方法	作用
1	列表.append(元素)	在列表中追加一个元素到尾部
2	列表.extend(容器)	其他数据容器内容取出，依次追加到列表尾部。
3	列表.insert(下标, 元素)	在指定的位置，插入指定的元素。
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	删除某元素在列表中的第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计某元素在列表中的数量
9	列表.index(元素)	查找指定某元素的下标
10	len(列表)	统计列表元素个数

3.12 列表的特点

• 可容纳多个元素

• 可容纳不同类型的元素

• 有序存储数据

• 允许重复数据

• 可修改

3.13 列表的遍历 — while循环

语法结构：

index = 0
while index < len(列表):
    元素 = 列表[index]
    元素的处理
    index += 1

name_list = ["he", "l", "l", "0", "!"]
index = 0
while index < len(name_list):
    element = name_list[index]
    print(f"列表下标为{index}的元素是{element}")
    index += 1

3.14 列表的遍历 — for循环

语法结构：

for 临时变量 in 数据容器:
    临时变量的处理

name_list = ["he", "l", "l", "0", "!"]
index = 0
for element in name_list:
    print(f"列表元素有{element}")

4.元组及常用操作

• 查找方法：index

• 统计方法：count

• 统计元组元素数量：len

# 查找方法
t1 = ("he", "l", "l", "0", "!")
index = t1.index("0")
print(f"t1元组中的元素o的下标是：{index}")

# 统计方法
t2 = ("he", "l", "l", "l", "o", "!")
num = t2.count("l")
print(f"t2元组中的元素l的数量有：{num}")

# 统计元组元素数量
t3 = ("he", "l", "l", "o", "!")
num = len(t3)
print(f"t3元组的元素的数量有：{num}")

4.1 总结：

1	index(元素)	查找某个数据对应的下标，不存在就报错
2	count(元素)	统计某个数据在当前元组所出现的次数
3	len(元组)	统计元组内元素的数量

4.2 元组的遍历 — while循环

t1 = ("he", "l", "l", "0", "!")
index = 0
while index < len(t1):
    element = t1[index]
    print(f"元组t1的元素有：{element}")
    index += 1

4.3 元组的遍历 — for循环

t1 = ("he", "l", "l", "0", "!")
index = 0
for element in t1:
    print(f"元组t1的元素有：{element}")

4.4 元组的特点

• 可容纳多个数据

• 可容纳不同类型的数据

• 数据有序存储

• 允许重复数据存在

• 不可修改

• 支持for循环

5.字典及常用操作

5.1 定义

作用：可通过Key，取到对应的Value。

语法结构：

# 定义字典字面量
{key: value, key: value, .......,key: value}
# 定义字典常量
my_dict = {key: value, key: value, ......, key: value}
# 定义空字典
my_dict = {}
my_dict = dict()

my_dict1 = {"小明": 18, "小红": 19, "小王": 20}
my_dict2 = {}
my_dict3 = dict()
print(f"mydict1字典的内容是{my_dict1},类型是{type(my_dict1)}")
print(f"mydict2字典的内容是{my_dict2},类型是{type(my_dict2)}")
print(f"mydict3字典的内容是{my_dict3},类型是{type(my_dict3)}")

# 重复Key的字典
my_dict4 = {"小明": 18, "小明": 20, "小红": 19}
print(f"重复Key的my_dict4的内容是{my_dict4}")

5.2 数据的获取

语法结构：字典[Key]

my_dict = {"小明": 18, "小红": 19, "小王": 20}
print(my_dict["小明"]) # 18
print(my_dict["小红"]) # 19
print(my_dict["小王"]) # 20

5.3 嵌套

字典中的Key和Value可以是任意数据类型，Key不可为字典。

score_dict = {"小明": {"语文": 80, "数学": 90, "英语": 81},
             "小红": {"语文": 85, "数学": 88, "英语": 83},
             "小王": {"语文": 87, "数学": 80, "英语": 87}}
print(f"考试信息是：{score_dict}")
Xiaohong_English_score = score_dict["小红"]["英语"]
print(f"小红的英语成绩是{Xiaohong_English_score}")

5.4 新增元素

语法结构：字典[Key] = Value

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score["小李"] = 84
print(student_score) # {'小明': 80, '小红': 90, '小王': 88, '小李': 84}

5.5 更新元素

语法结构：字典[Key] = Value

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score["小明"] = 84
print(student_score) # {'小明': 84, '小红': 90, '小王': 88}

5.6 删除元素

语法结构：字典.pop(Key)

student_score = {"小明": 80, "小红": 90, "小王": 88}
delete_score = student_score.pop("小明")
print(delete_score)  # 80
print(student_score) # {'小红': 90, '小王': 88}

5.7 清空字典

语法结构：字典.clear()

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score.clear()
print(student_score) # {}

5.8 获取全部的Key

语法结构：字典.Keys()

student_score = {"小明": 80, "小红": 90, "小王": 88}
obtain_value = student_score.keys()
print(obtain_value) # dict_keys(['小明', '小红', '小王'])

5.9 字典的遍历

student_score = {"小明": 80, "小红": 90, "小王": 88}
obtain_value = student_score.keys()
for key in obtain_value:
    print(f"Key：{key}")
    print(f"Value：{student_score[key]}")
# Key：小明
# Value：80
# Key：小红
# Value：90
# Key：小王
# Value：88

5.10 统计字典内的元素数量

语法结构：len(字典)

student_score = {"小明": 80, "小红": 90, "小王": 88}
num = len(student_score )
print(num) # 3

5.11 总结：

编号	操作	说明
1	字典[Key] = Value	新增元素
2	字典[Key] = Value	更新元素
3	字典.pop(Key)	删除元素
4	字典.clear()	清空字典
5	字典.Keys()	获取字典内全部的Key
6	len(字典)	统计字典内的元素数量

5.12 特点

• 可容纳多个数据

• 可容纳多个不同类型的数据

• 每份数据是Key与Value值对应

• 可通过Key去获取Value，Key不可重复

• 不支持下标索引

• 可修改

• 支持for循环

6.公用操作

6.1 合并操作+

适用于字符串，列表，元组

功能：两个对象相加操作，合并两个对象

语法结构：对象+对象

str1 = "hello"
str2 = "python"
print(str1+str2) # hellopython

6.2 *复制

适用于字符串，列表，元组

功能：对象自身按指定次数进行+操作

语法结构：对象*次数

str1 = "hello"
print(str1*3) # hellohellohello

6.3 in 判断元素是否存在

适用于字符串，列表，元组，字典

返回结果是一个bool值

功能：判断指定元素是否存在于对象中

语法结构：字符 in 对象

str1 = "hello"
lo"
print("e" in str1) # True