第四章-数据容器

五种数据容器分别为列表、元组、字符串、集合、字典 

数据容器

定义

列表	一批可修改可重复的数据
元组	一批不可修改可重复的数据
字符串	一串字符串
集合	一批不可重复的数据
字典	一批可用key值检索value的数据

比较

	是否支持下标索引	是否支持重复元素	是否可以修改
列表	是	是	是
元组	是	是	否
字符串	是	是	否
集合	否	否	是
字典	否	key不可，value可以	key不可，value可以

可以简单的理解为列表、元组、字符串这样的序列类型支持下标索引，支持重复元素。而集合、字典这样的非序列类型不支持下标索引和重复元素

通用操作

五种数据容器都支持for遍历，其中的列表，元组，字符串还支持while遍历。

len(容器)	元素个数
max(容器)	最大元素
min(容器)	最小元素
list(容器)	转换为列表
str(容器)	转换为字符串
tuple(容器)	转换为元组
set(容器)	转换为集合

# 字典转列表、元组、集合只保留Key
# 字典转字符串保留key和value
dict1 = {"fhl": 99, "lij": 98, "zxl": 95}
print(f"{set(dict1)}")
# 进行容器的排序 sorted(容器,reverse=True)
mylist = [3, 1, 2, 5, 4]
print(f"列表排序结果是：{sorted(mylist)}")
# 无论什么类型，排序后都会变成列表对象
# 字典排序后丢失value
print(f"反向排序是：{sorted(mylist,reverse=True)}")

列表list[]

定义

在目前的学习中，老wolf是直接把列表当作C语言里的数组了

list 列表
字面量 [元素1, 元素2, 元素3, 元素4]
定义变量 变量名称 = [元素1, 元素2, 元素3, 元素4]
定义空列表 变量名称 = []     变量名称 = list()

 列表中可以存放字符串、数值、布尔值、列表

list1 = ["fhl", "zby", "zxl"]
print(list1)
print(type(list1))

list2 = ["fhl", 666, True]
print(list2)
print(type(list2))

list3 = [ [1, 2, 3], [4, 5, 6] ]
print(list3)
print(type(list3))

a = [(i, i ** 2) for i in range(10)]
print(a)

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

常用操作

# 将函数定义为类class的成员，这些函数会被称为方法
# 函数的使用 num = add(1, 2)
class Student:
    def add(self, x, y):
        return x + y
# 方法的使用 student = Student()
# num = student.add(1, 2)

# 查询某元素下标
mylist = ["it", "fang", "fhl"]
index = mylist.index("it")
print(f"it的下标索引值是{index}")
# index2 = mylist.index("hello")
# print(f"hello的下标索引值是{index2}")

# 修改特定下标索引的值
mylist[0] = "good"
print(f"列表被修改后结果是{mylist}")

# 元素的插入
mylist.insert(1, "best")
print(f"插入后结果是{mylist}")

# 元素的追加
mylist.append(["1"])
print(f"append追加的结果是{mylist}")

# 元素的追加2，追加一批
mylist.extend(["2"])
print(f"extend追加的结果是{mylist}")

# 元素的删除
del mylist[4]
print(f"删除的结果是{mylist}")

# 元素的删除2
element = mylist.pop(4)
print(f"删除的结果是{mylist}，删除的元素是{element}")

# 元素的删除，第一个匹配项
list2 = [10, 20, 30, 20, 30, 30]
list2.remove(20)
print(f"删除的结果是{list2}")

# 清空列表
mylist.clear()
print(f"列表被清空了，结果是{mylist}")

# 统计列表内某元素数量
count = list2.count(30)
print(f"列表中30的数量是{count}")

# 列表内元素数量总数
count = len(mylist)
print(f"列表中共有{count}个元素")

# 一般不用记下太多方法，要查阅相关文档
#  列表上限2的63次方-1个元素

遍历

for i in list:
    print(f"列表的元素有：{i}")

列表小结

列表名 = []	定义空列表
列表名 = list()	定义空列表
列表名.index(某元素)	查询某元素下标
列表名[下标] = 300	将下标处的元素值修改为300
列表名.insert(下标,值)	将值插入到下标处
列表名.append(某元素)	将某元素原样追加到列表后
列表名.extend([某])	追加一批某
del 列表名[下标]	删除元素
列表名.pop(下标)	删除元素并将被删除的元素记录下来
列表名.remove(某元素)	删除列表中出现的第一个某元素
列表名.clear()	清空列表
列表名.count(某元素)	统计列表内某元素数量
len(列表名)	列表中元素数量总数
for i in 列表名:	遍历列表，i为列表元素

元组tuple()

# 列表可以修改，元组一旦定义完成，就不可以修改
kong = tuple()
kong2 = ()
t1 = (1, "fhl", True)
print(f"t1的类型是：{type(t1)}")
print(f"kong的类型是：{type(kong)}")
print(f"kong2的类型是：{type(kong2)}")

t2 = (1, )
t3 = ("tuple", )
t4 = ("str")
print(f"t3的类型是{type(t3)}")
print(f"t4的类型是{type(t4)}")

t5 = ( (1, 2, 3), (4, 5, 6))
num = t5[1][2]
print(f"{num}")

t6 = ("乐", "哈哈哈哈")
index = t6.index("乐")
print(f"f6中乐的下标是{index}")

t7 = ("asdf", "hahaha", "good" ,"hahaha")
num = t7.count("hahaha")
print(f"f7中hahaha的数量为{num}个")

t8 = ("asdf", "hahaha", "good" ,"hahaha")
num = len(t8)
print(f"t8元组中的元素有{num}个")

# 元组的遍历while
index = 0
while index < len(t8):
    print(f"元组的元素有{t8[index]}")
    index += 1

# 元组的遍历for
for i in t8:
    print(f"2元组的元素有{i}")

# 元组是只读的，不可修改的。但可以修改元组内List的内容
t9 = (1, 2, ["fhl", "handsome"])
print(f"t9的内容是{t9}")
t9[2][0] = "帅哥"
t9[2][1] = "乐"
print(f"t9的内容是{t9}")

元组小结

如果元组中只有一个元素，那么它应该被写作

元组名 = (元素,)

如果写作

元组名 = (元素)

则不会被判定为元组

元组无法被修改，但元组中的列表可以被修改

index方法、count方法、len方法在元组中也能使用

字符串str""

# 字符串是字符的容器
mystr = "fanghanlin da shuaige"
# 通过下标取索引值
value = mystr[2]
value2 = mystr[-2]
print(f"从字符串{mystr}取下标为2的元素值为{value}，下标为-2的元素值为{value2}")
# 字符串无法修改
# index方法
value = mystr.index("da")
print(f"在字符串{mystr}中查找da,起始下标为{value}")
# 字符串的替换，replace不是修改字符串本身，而是得到了一个新字符串
newstr = mystr.replace("da", "is")
print(f"将字符串{mystr}，进行替换后得到{newstr}")
# 字符串的分割,split,字符串本身不变，而是得到了一个列表对象
mystr = "hello python fanghanlin"
mystrlist = mystr.split(" ")
print(f"将字符串{mystr}进行split切分后得到：{mystrlist},类型是{type(mystrlist)}")
# strip无参去除首尾空格和换行符
newmystr = mystr.strip()
print(f"字符串{mystr}被strip后，结果{newmystr}")
# strip有参去除
mystr = "12fanghanlin21"
newmystr = mystr.strip('12')  # 满足1或2就给去除了
print(f"字符串{mystr}被strip('12')后，结果{newmystr}")
# 统计字符串中某字符串的出现次数，count
mystr = "fanghanlin and fangfang"
count = mystr.count("fang")
print(f"字符串{mystr}中fang出现的次数是{count}")
#统计字符串的长度，len()
num = len(mystr)
print(f"字符串{mystr}的长度是{num}")

字符串的比较

本质上比的是ascii码

# 比较ASCII码
str2 = "viper"
str3 = "ziper"
str4 = "zipe"

if str2 > str3:
    print("str2>str3")
else:
    print("str2<str3")
if str3 > str4:
    print("str3>str4")
else:
    print("str3<str4")

字符串小结

字符串名[下标]	找到对应下标，可为负数，为负数时从后往前
字符串.index("子串")	查找字串并输出起始下标
字符串.replace("子串1","子串2")	将字符串中的字串1替换为字串2
字符串.split("某符号")	将字符串按某符号切割
字符串.strip('参数')	有参去除
字符串.count('子串')	数子串出现的次数
len(字符串)	字符串长度

集合set{}

# 定义集合
myset = {"good", "fang", "hanlin", "good", "fang", "hanlin", "good", "fang", "hanlin"}
mysetempty = set()
print(f"{myset}类型是{type(myset)}")
print(f"{mysetempty}类型是{mysetempty}")
# 集合是无序的，所以不支持下标索引访问，且不支持重复，但重复不会报错
# 集合和列表一样允许修改
# 添加新元素
myset.add("233")
print(myset)
# 移除元素
myset.remove("233")
print(myset)
# 随机取出元素
element = myset.pop()
print(f"被取出元素是{element}，取出后集合为{myset}")
# 清空集合
myset.clear()
print(f"集合被清空了，集合为{myset}")
# 取两个集合的差集，之后两个原来的集合不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"差集为{set3}")
# 取差集后消除差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后集合1{set1}")
print(f"消除差集后集合2{set2}")
# 合并
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"两个集合合并结果{set3}")
# 统计集合元素数量（集合是去重的）
set1 = {1,2,3,4,5,6}
num = len(set1)
print(f"集合内有{num}个元素")
# 集合的遍历
# 集合不支持下标索引，不用while
# 可以用for
for element in set1:
    print(f"集合中元素有{element}")

集合小结

remove、pop、clear、len、遍历用法与列表相同

集合名.add()	添加元素
集合1.difference(集合2)	取差集
集合1.difference_update(集合2)	取差集后消除差集
集合1.union(集合2)	集合合并

字典dict{key:value}

# python中的字典是通过key找到对应的value
# mydict = {key1:value1,key2:value2}
# 定义字典
dict1 = {"fhl": 99, "lij": 98, "zxl": 95}
dict1["zxl"] = 100
print(dict1)
# 定义空字典
dict2 = {}
dict3 = dict()
print(f"字典1的内容是{dict1},类型{type(dict1)}")
print(f"字典2的内容是{dict2},类型{type(dict2)}")
print(f"字典3的内容是{dict3},类型{type(dict3)}")

# 字典不允许key重复，会覆盖
# 字典没有下标索引，只能通过key找value
score = dict1["fhl"]
print(f"fhl的考试分数是{score}")
# 字典的key和value可以是任意数据类型，Key不可以是字典，所以字典可以嵌套
# 定义嵌套字典
stu_score_dict = {
    "fhl":{
        "语文": 90,
        "数学": 88,
        "英语": 82
    },
    "lij":{
        "语文": 80,
        "数学": 90,
        "英语": 85
    },
    "zxl":{
        "语文": 95,
        "数学": 92,
        "英语": 86
    }
}
print(f"学生考试信息{stu_score_dict}")
# 从嵌套字典获取数据
# 看一下lij的语文信息
score = stu_score_dict["lij"]["语文"]
print(score)

stu_score = {
    "fhl": 100,
    "lij": 98,
    "zxl": 95
}
# 新增元素
stu_score["lzl"] = 90
print(f"字典经过新增元素后，结果：{stu_score}")
# 更新元素
stu_score["fhl"] = 92
print(f"字典经过修改，{stu_score}")
# 删除元素
score = stu_score.pop("zxl")
print(f"删除了后结果为{stu_score},删除的是{score}")
# 清空元素
stu_score.clear()
print(f"字典被清空了，内容是：{stu_score}")
# 获取全部的key
mydict = {"fhl": 98, "lij": 96, "zxl": 95}
keys = mydict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1 通过获取到全部的Key来完成遍历
for key in keys:
    print(f"字典的key是{key}")
    print(f"字典的value是{mydict[key]}")
# 方式2 直接对字典进行for循环,每一次循环都是直接得到Key
for key in mydict:
    print(f"2字典的key是{key}")
    print(f"2字典的value是{mydict[key]}")
# 字典没有下标，不用while
# 统计字典内元素数量
num = len(mydict)
print(f"字典中元素数量{num}个")
# 操作注意，新增和更新的语法一致，若Key不存在则新增，如果key存在即更新

经典作业题——判断一个字符串是否回文字符串

以下是五种方法

首先对输入的字符串进行预处理

str = input("请输入回文字符串")
str = str.translate(str.maketrans('', '', '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'))
str = str.strip().upper()

1.字符串逆序切片方法[::-1]

if str[::1] == str[::-1]:
    print(f"方法1：{str}是回文字符串")
else:
    print(f"方法1：{str}不是回文字符串")

2.for循环遍历并逐字符比较

digit = 0
for i in range(len(str)):
    if str[i] == str[len(str)-i-1]:
        digit += 1
if digit == len(str):
    print(f"方法2：{str}是回文字符串")
else:
    print(f"方法2：{str}不是回文字符串")

3.将字符串转换为list后利用列表的reverse()函数处理

def equ(a, b):
    for i in range(len(a)):
        if a[i] != b[i]:
            return False
    return True
a = list(str)
b = list(str)
a.reverse()
if equ(a, b):
    print(f"方法3：{str}是回文字符串")
else:
    print(f"方法3：{str}不是回文字符串")

4.使用reversed()函数将字符串反序

str2 = list(str)
reverse_str = list(reversed(str))
if equ(str2, reverse_str):
    print(f"方法4：{str}是回文字符串")
else:
    print(f"方法4：{str}不是回文字符串")

5.递归

def cut(str):
    if len(str) == 0 or len(str) == 1:
        return True
    if str[0] == str[-1]:
        return cut(str[1:-1])
    else:
        return False
if cut(str):
    print(f"方法5：{str}是回文字符串")
else:
    print(f"方法5：{str}不是回文字符串")