Python学习（二）数据类型

数据容器

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

列表

定义列表

变量名称 = [元素一, 元素二, .....]

定义空列表：

变量名称 = []或 变量名称 = list()

注意：列表可以存储不同的数据类型，且可以嵌套

列表方法

列表的常用操作(方法)
列表除了可以:

• 定义
• 使用下标索引获取值

以外，列表也提供了一系列功能:

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

等等功能，这些功能我们都称之为:列表的方法

# 取出指定下标索引的元素
my_list = ["张三", "李四", "王五"]
name1 = my_list[0]
print(name1)
# 取出最后一个元素，取出倒数第二个元素-2，依次类推
final_name = my_list[-1]
print(final_name)
# 查找元素在列表的下标索引
index = my_list.index("李四")
print(index)
# 修改元素的值
my_list[0] = "赵四"
print(my_list)
# 在指定位置插入元素，insert
my_list.insert(1, "酒桶")
print(my_list)
# 追加元素
my_list.append("劫")
print(my_list)
# 追加一批元素
my_list2 = [1, 2, 3]
my_list.extend(my_list2)
print(my_list)
# 删除元素del或者pop方法
del my_list[1]
print(my_list)
# pop方法还能把删除的值返回回来
hero = my_list.pop(3)
print(hero)
print(my_list)
# 通过元素内容删除元素，只删除第一个匹配到的，从左到右
my_list.remove(1)
print(my_list)
# 清空列表，clear
my_list.clear()
print(my_list)
# 统计列表内某元素的数量
my_list = ["张三", "李四", "王五", "张三"]
count = my_list.count("张三")
print(count)
# 统计列表内元素的数量
count = len(my_list)
print(count)
# 输出第二个元素的第二项，即5
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

列表方法总览

经过上述对列表的学习，可以总结出列表有如下特点:

• 可以容纳多个元素(上限为2**63-1、9223372036854775807个)
• 可以容纳不同类型的元素(混装)
• 数据是有序存储的(有下标序号)
• 允许重复数据存在
• 可以修改(增加或删除元素等)

列表遍历

1.什么是遍历?
将容器内的元素依次取出，并处理，称之为遍历操作
2.如何遍历列表的元素?
可以使用while或for循环
3.for循环的语法：
for 临时变量 in 数据容器
   对临时变量进行处理
4.for循环和while对比

• for循环更简单，while更灵活
• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

while循环和for循环，都是循环语句，但细节不同:

• 在循环控制上:
•      while循环可以自定循环条件，并自行控制
•      for循环不可以自定循环条件，只可以一个个从容器内取出数据
• 在无限循环上:
•     while循环可以通过条件控制做到无限循环
•     for循环理论上不可以，因为被遍历的容器容量不是无限的
• 在使用场景上:
•     while循环适用于任何想要循环的场景
•     for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

练习：找出列表中所有的偶数并添加到一个新的列表中

元组

基础概念

元组同列表一样，可以封装多个、不同类型的元素，不同的是，元组一旦定义完成，不可修改。

定义元组

my_tuple = (1, "hello", True)

空元组定义：

my_tuple = ()或

my_tuple = tuple()

定义单个元素的元组：

t1 = ("hello", )

后面的逗号必须加，否则不是元组，而是str

元组的嵌套：

t1 = ( (1, 2, 3), (4, 5, 6) )

通过下标索引取出6：num = t1[1][2]

常用方法

这里不再演示了，和列表操作方法一样。

注意：

元组虽然不可修改，但如果元组内有列表可修改列表内容：

经过上述对元组的学习，可以总结出列表有如下特点:

• 可以容纳多个数据
• 可以容纳不同类型的数据(混装)
• 数据是有序存储的(下标索引)
• 允许重复数据存在
• 不可以修改(增加或删除元素等)
• 支持for循环

多数特性和list一致，不同点在于不可修改的特性。

字符串

str = "张无忌喜欢赵敏"
print(str[0])
print(str[-1])
# 字符串替换，字符串本身不能修改，所以用一个新的变量接收新的字符串
new_str = str.replace("赵敏", "周芷若")
print(str)
print(new_str)
# index方法
num = str.index("喜欢")
print(num)
# split方法，按照指定分隔符分割，生成一个数组
str = "张无忌 喜欢 赵敏"
my_list = str.split(" ")
print(my_list)
# 去掉前后空格，或者去掉前后指定字符
str = "   张无忌 喜欢 赵敏     "
new_str = str.strip()
print(new_str)
str = "12张无忌 喜欢 小昭21"
new_str = str.strip("21")
#从首尾开始检查，只要包含1或2就删除，跟21或12顺序无关
print(new_str)

count、len方法不再演示，和list相同。

作为数据容器，字符串有如下特点:

• 只可以存储字符串
• 长度任意(取决于内存大小)
• 支持下标索引
• 允许重复字符串存在
• 不可以修改(增加或删除元素等)
• 支持for循环

序列

概念

序列是指:内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可以可以视为序列。

序列的切片

语法:序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
•        步长1表示，一个个取元素
•        步长2表示，每次跳过1个元素取
•        步长N表示，每次跳过N-1个元素取
•        步长为负数表示，反向取(注意，起始下标和结束下标也要反向标

练习：

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]   #步长默认是1，所以可以省略不写
print(f"结果1:{result1}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple=(0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2:{result2}")
#对str进行切片，从头开始，到最后结束，步长2
str = "012345678"
result3 = str[::2]
print(result3)
# 对str进行切片，从头开始，到最后结束，步长-1
result4 = str[::-1]
print(result4)
# 对列表进行切片，从3开始，到1结束，步长-1
result5 = my_list[3:1:-1]
print(result5)
# 对元组进行切片，从头开始，到尾结束:步长-2
result6 = my_tuple[::-2]
print(result6)

集合

目标：

1.集合定义

2.集合特点

3.集合常见操作

定义

my_set = {"apple", "orange", "banana"}

定义空集合my_set = set()

特点

不能重复且无序，因为集合无序，所以不支持下标访问，也不支持while循环

所以集合不属于序列，但集合是可以修改的。

常见操作

添加元素

my_set.add("lemon")

移除元素

my_set.remove("orange")

随机取出一个元素

fruit = my_set.pop()   #并且可以返回取出的元素

清空集合

my_set.clear()

取差集

取出集合1有而集合2没有的

set1.difference(set2)

结果：得到一个新集合，集合1、2不变。

消除两个集合的差集

在集合1内删除和集合2相同的元素

set1.difference_update(set2)

结果：集合1被修改，集合2不变

合并

统计集合元素数量

len(my_set)

集合常用功能总结：

练习：

字典

定义

my_dict = {key: value, key: value, key: value}

或my_dict = {}    或  my_dict=dict()

字典同集合一样，不可使用下标索引，但可以通过key获取对应的value(代码演示见下图)。

字典的嵌套

字典的key和value可以是任意类型的数据（key不能为字典）

而且key不允许重复，如果重复，后面的会覆盖前面的

新增元素（原字典没有就新增）：

my_dict["赵六"] = 25

更新元素（原字典有就更新）：

my_dict["张三"] = 20

删除元素：

my_dict.pop(key)

清空字典

clear()

获取全部的key：

获取所有key可以用来遍历，但直接for循环也可以做到。

练习（级别为1的员工升1级，薪资加1000）：

my_dict = {"王立红": {
              "部门": "科技部",
              "工资": 3000,
              "级别": 1
            },
           "周杰轮": {
              "部门": "市场部",
              "工资": 5000,
              "级别": 2
           },
           "张学油": {
              "部门": "科技部",
              "工资": 4000,
              "级别": 1
           }
           }
print("全体员工当前信息如下：")
print(my_dict)
for element in my_dict:
    in_key = my_dict[element]
    if in_key["级别"] == 1:
        in_key["级别"] += 1
        in_key["工资"] += 1000
print("级别为1的员工加薪后：")
print(my_dict)

总结：

都支持遍历操作

• 5类数据容器都支持for循环
• 列表、字符串、元组支持while循环，集合字典不支持（无法下标索引）

除了遍历，还有以下的共同操作：

len(容器)：统计容器的元素个数

max(容器)：统计容器的元素个数

min(容器)：统计容器的元素个数

对于字典比较的是key的大小，不是value

容器的通用转换

list(容器)：将给定容器转换为列表

str(容器)：将给定容器转换为字符串

tuple(容器)：将给定容器转换为元组

set(容器)：将给定容器转换为集合

字典转换为list后，只剩key，舍弃value了

字典转换为字符串，会保留value，而且列表、元组转换为字符串输出（print）时看上去没什么变化，但其实是字符串，也就是"[1, 2, 3]"

容器通用排序功能

sorted(容器,[reverse=True])

将给定容器进行排序

sorted会将排序结果放到一个列表中，所以排序后的结果是列表，同时字典的value丢失

字符串比较