Python数据容器：list + set + tuple + dict + str 简记 黑马课程
2024-04-16 10:01:39
# -*- coding:utf8 -*-
"""
# editor: hjjdreamer
# create-time: 2022/11/16-23:08
# Python-Script: chapter6-container.py
# describe: 数据容器课程代码简单记
2022新版黑马程序员python教程，8天python从入门到精通，学python看这套就够了
https://www.bilibili.com/video/BV1qW4y1a7fU?p=81&vd_source=19d68c51d074de183fd2e6b1b1cb0a9b
"""
# lesson1: list
"""
列表 = []标识符
逗号分割
每个数据称为元素
列表内的元素数据类型不受限制
"""
ls = ["das", 666, True, 12.987]
print(ls)
print(type(ls))# 列表间的嵌套
ls2 = [1, "dada", ["adad", 123], ["aqwe", True]]
print(ls2)
print(type(ls2))
print(ls2[2][1])"""
索引 + 下标
从 0 开始，依次增加 == 左到右
反向索引 == 从后向前 == 从 -1 开始
"""
ls3 = ["a", "b", "c"]
print(ls3)
print(ls3[0])
print(ls3[1])
print(ls3[2])
# print(ls3[3]) #IndexError: list index out of range
print("\n反向索引 == 从后向前 == 从 -1 开始")print(ls3[-1])
print(ls3[-2])
print(ls3[-3])# 列表嵌套取数
ls4 = [[1, "dada", 12.456], ["adad", 123], ["aqwe", True]]
print(ls4[0][2]) # 12.456
print(ls4[1][1]) # 123
print(ls4[2][0]) # aqwe# 列表常用操作
"""
在python中，若将函数定义为class的成员，那么函数称之为方法
方法和函数的功能一样，有传入参数，有返回值，只是格式不一样
"""class student:def add(self, x, y):return x + ystudent = student() # 获取类
num = student.add(3, 4) # 获取方法
print(num)# lesson2: index + list
"""
存在返回索引值 + 不存在则报错
"""
list1 = ["a", "b", "c", "d"]
index = list1.index("a")
print(f"a 在列表中的下标索引是 {index}")# 修改特定元素的索引值
"""
list[index] = value
"""
print(list1)
list1[0] = "abab"
print(f"edit list1 == {list1}")# insert
"""
insert(下标，索引)，指定位置，插入指定元素
"""
print(list1)
list1.insert(2, "cdcdc")
print(f"insert list1 == {list1}")# append
"""
追加元素在最后
"""
print(list1)
list1.append("zzzzzzz")
print(f"append list1 == {list1}")# extend
"""
追加一批元素
"""
list2 = [1, 2, 3, 4]
print(list2)
print(list)
list1.extend(list2)
print(f"extend list == {list1}")# del + pop
print(list1)
del list1[2]
print(f"del list1 == {list1}")element = list1.pop(0)
print(f"pop list1 == {list1} + element == {element}")# remove
"""
删除某元素在列表中的第一个匹配项目，只能删除一个
"""
print(list1)
list1.remove("zzzzzzz")
print(f"remove list1 == {list1}")# clear() 清空列表
print(list2)
list2.clear()
print(f"clear list2 == {list2}")# count
list3 = ["a", "a", "a", "a", "a", "ada", "dadq"]
print(list3)
count = list3.count("a")
print(f"list3 has {count} a")# len
print(list1)
count = len(list1)
print(f"count element == {count}")# while
"""
index = 0
while index < len(list1):element = list1[index]index += 1
"""def list_while():print(list1)index = 0while index < len(list1):element = list1[index]print(f"element == {element}")index += 1list_while()# for
"""
for tmc_var in container：jobs
"""
list4 = [1, 2, 3, 4, 5, 6, 7]def list_for():for num in list4:print(f"{num}")list_for()# lesson3: tuple
"""
元组的信息不能篡改
可以封装多个不同类型元素
小括号
逗号分隔
"""
t1 = (1, "hello", True)
t2 = ("adad",) # 必须带有逗号，否则不是元组类型
t3 = tuple()
print(f"t1 内容是 {t1}, 类型是{type(t1)}")
print(f"t2 内容是 {t2}, 类型是{type(t2)}")
print(f"t3 内容是 {t3}, 类型是{type(t3)}")# 元组的嵌套
t5 = ((1, 2, 3, 4), (5, 6, 7, 8, 9))
print(f"t5 内容是 {t5}, 类型是{type(t5)}")
# 下标索引
print(t5[1][1])# 基本操作
"""
index
count
len
"""
# index 查找
t4 = ("adad", "asas", "qwqw")
index = t4.index("adad")
print(f"在元组{t4}, 'adad'下标索引是{index}")# count + len 统计
t6 = ("adad", "asas", "qwqw", "adad", "asas", "qwqw")
num = t6.count("asas")
num1 = len(t6)
print(f"元组{t6} 一共有 {num1} elements, 'asas'一共有{num}")# while + for
index = 0 # 控制初始值
while index < len(t6):print(f"{t6} has {t6[index]}")index += 1
print("while done\n")for element in t6:print(f"{t6} has {element}")# 元组的修改
"""
不可以修改元组的元素
可以修改元组内的列表元素 == 列表的特征 == 增删改查
"""
t7 = (1, 2, ["a", "b", "c"])
print(f"t7 == {t7}")
t7[2][1] = "dadadad"
t7[2][0] = "12323123dadadad"
print(f"t7 == {t7}")"""
summar
可以容纳多个不同类型元素
支持下标索引
允许重复数据
不可以修改（增删改），可以修改元组内的列表元素
支持while + for
"""# lesson4: str
"""
字符串可以通过下标索引访问
字符串是一个无法修改的数据容器
如果进行修改，得到一个新的字符串
"""
str1 = "asdfghjk qweqrewrq ewrqwer"
print(str1[0])
print(str1[-1])# index
value = str1.index("q")
print(value)# replace
"""
str.replace(str1, str2)
字符串替换，得到一个新的字符串
"""
str2 = str1.replace("ewrqwer", "c")
print(f"str1 == {str1} + str2 == {str2}")
print(id(str2))
print(id(str1))# split
"""
str.split(分隔符)
按照分隔符对字符串进行分隔成多个字符串，并存入列表对象中
字符串本身不变，得到一个新的列表对象
"""
list1 = str1.split(" ")
print(list1)# strip
"""
str.strip() == 去除前后空格
str.strip(str) == 去除前后指定字符串
"""
str3 = " a b c d e "
str31 = str3.strip() # 去除首位空格
print(f"str3 == {str3} \nstr31 =={str31}")str4 = "12a b c d e12"
str41 = str4.strip("12")
print(f"str4 == {str4} \nstr41 =={str41}")# count
print(str1)
count = str1.count("qw")
print(f"{str1} has {count} qw")# len
num = len(str1)
print(f"str1 == {str1} + len == {num}")# while + for
str5 = "abcdefg"
index = 0
while index < len(str5):print(str5[index])index += 1for i in str5:print(i)"""
summary
只可以存储字符串
长度任意
支持下标索引
允许重复字符
不可以修改
支持循环
"""# test
# TODO 1:define
str6 = "itheima itcast boxuegu"
# TODO 2:COUNT(IT)
num = str6.count("it")
print(f"str6 = {str6} has {num} it")
# TODO 3:REPLACE
str61 = str6.replace(" ", "|")
print(f"str6 == {str6} + str61 == {str61}")
# TODO 4:SPLIT
str61_list = str61.split("|")
print(str61_list)# lesson5 序列
"""
序列 == 内容连续，有序，可以使用下标索引的一类数据容器
列表，元组，字符串都可以视为序列切片 == 从一个序列中取出一个子序列 == 序列(起始下标: 结束下标: 步长)
表示从序列中，指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
起始下标为空 == 从头开始，包含
结束下标为空 == 从尾开始，不包含
"""
list5 = [0, 1, 2, 4, 3, 5, 6]
list51 = list5[1:4]
print(list51)
list52 = list5[3:1:-1]
print(list52)tuple2 = (0, 1, 2, 3, 4, 5, 6)
tuple21 = tuple2[:]
print(tuple21)
tuple22 = tuple2[::-2]
print(tuple22)str7 = "01234567"
str71 = str7[::2]
print(str71)
str72 = str7[::-1]
print(str72)# lesson6 set
"""
去重
逗号分隔元素
没有顺序，不支持下标索引
支持修改回顾：
列表 []
元组 ()
字符 ""
集合 {}
"""
set1 = {"a", "b", "c", "d", "a", "b", "c", "d", "a", "b", "c", "d"}
set_empty = set()
print(f"set1 == {set1}, type = {type(set1)}")
print(f"set1 == {set_empty}, type = {type(set_empty)}")# add 添加新元素
set1.add("wq")
set1.add("43242")print(set1)# remove 移除新元素
set1.remove("a")
print(f"{set1}")# pop 随机取数
element1 = set1.pop()
print(f"{set1} get element = {element1}")# clear 清空集合
set1.clear()
print(f"{set1}")# 差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2) # 集合1有，集合2没有
set4 = set2.difference(set1) # 集合2有，集合1没有
print(set3) # {2, 3}
print(set4) # {5, 6}
print(set1) # {1, 2, 3}
print(set2) # {1, 5, 6}# 消除2个集合的差集
print("====difference_update====")
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1) # {2, 3}
print(set2) # {1, 5, 6}# union 合并组成新集合
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3) # {1, 2, 3, 5, 6}
print(set2) # {1, 5, 6}
print(set1) # {1, 2, 3}# len 统计
num = len(set3)
print(f"{num}")# 遍历
"""
集合不支持下标索引，不适用while循环
for循环适用
"""
for i in set3:print(f"{i}")# 案例
list6 = ["a", "b", "c", "d", "a", "e", "a", "b"]
set5 = set()
for element in list6:set5.add(element)print(f"{list6}")
print(f"{set5}")"""
可以容纳不同类型的多个数据
无序存储
不允许重复
可以修改
支持for循环
"""# lesson7: 字典
"""
key:value不可以使用下标索引
可以通过key取得value
"""
dict1 = {"a": 1, "b": 2, "c": 3}
# 定义空字典
dict2 = {}
dict3 = dict()print(f"dict1 == {dict1}, type == {type(dict1)}")
print(f"dict2 == {dict2}, type == {type(dict2)}")
print(f"dict3 == {dict3}, type == {type(dict3)}")# key value的覆盖，后面覆盖前面
dict2 = {"a": 1, "a": 2, "c": 3}
print(dict2)# 通过key 取得value
dict1 = {"a": 1, "b": 2, "c": 3}
num = dict1["b"]
print(f"{dict1}, b value == {num}")# 字典的嵌套
"""
字典的key 和 value 是任意数据类型，但是key不能为字典
"""
dict2 = {"a": {"chinese": 85, "maths": 85, "english": 85},"b": {"chinese": 75, "maths": 75, "english": 75},"c": {"chinese": 65, "maths": 65, "english": 65}
}
print(dict2)
score = dict2["b"]["maths"]
print(f"b + maths == {score}")
score1 = dict2["c"]["english"]
print(f"c + english == {score1}")# 新增或者修改
"""
dict[key] = value
字典key不可以重复：
对已存在的key执行就是更新key的value
对不存在的key执行就是新增
"""dict1 = {"a": 1, "b": 2, "c": 3}
dict1["a"] = 5
dict1["d"] = 4
print(dict1)# 删除元素
num = dict1.pop("a")
print(f"dict1 use pop update {dict1}, delete a, value == {num}")# 清空 clear
dict1.clear()
print(f"dict1 clear == {dict1}")# 获取所有的键 keys
keys = dict2.keys()
print(f"{dict2} has {keys}")# 遍历字典
"""
通过获取全部的key，执行for循环遍历
"""
for key in keys:print(f"dict2_key == {key}")print(f"dict2_value == {dict2[key]}")"""
直接对dict2的key 执行循环
"""
for key in dict2:print(f"dict2_key == {key}")print(f"dict2_value == {dict2[key]}")"""
利用多重赋值的技巧，利用循环结构将键或值分别赋给不同的变量
"""a = {'数学': 95, '语文': 89, '英语': 90}
for k in a.keys():print(k, end=' ')
print("\n---------------")
for v in a.values():print(v, end=' ')
print("\n---------------")
for k, v in a.items():print("key:", k, " value:", v)# len
num = len(dict2)
print(num)
print("===================")# example
info_dict = {"a": {"depart": "sci", "pay": 3000, "level": 1},"b": {"depart": "mark", "pay": 5000, "level": 2},"d": {"depart": "mark", "pay": 7000, "level": 3},"c": {"depart": "sci", "pay": 4000, "level": 1},"e": {"depart": "mark", "pay": 6000, "level": 2}
}
print(f"{info_dict}")
# 遍历
for name in info_dict:# if 条件判断if info_dict[name]["level"] == 1: # "1" == 报错# 获取信息empl_info_dict = info_dict[name]print(f"{empl_info_dict}")empl_info_dict["level"] = 2 # == 失败empl_info_dict["pay"] += 1000# 返回值info_dict[name] = empl_info_dictprint(f"{info_dict}\n")
"""
小结
容纳多个不同类型元素
每一份数据都是键值对模式
key不可重复，通过key获取value
不支持下标
可以修改
支持for循环
"""# lesson8: 总结
"""
支持索引？Y: list tuple str == 序列类型N: set dict == 非序列类型 支持重复元素？Y: list tuple str == 序列类型N: set dict == 非序列类型支持修改？Y: list set dictN: tuple str
""""""
数据容器 列表 元组 字符 集合 字典
元素数量 多个 多个 多个 多个 多个
元素类型 任意 任意 仅字符 任意 K:Y
下标索引 支持 支持 支持 不行 不行
重复元素 支持 支持 支持 不行 不行
可修改性 支持 不行 不行 支持 支持
数据有序 是的 是的 是的 没有 没有
""""""
数据容器的应用场景
list 一批数据 + 可修改 + 可重复
tuple 一批数据 + 不可修改 + 可重复
str 一串字符串
set 一批数据 + 可修改 + 不可重复
dict 一批数据 + Key:Value
""""""
通用操作
for 都支持
while list + tuple + str ==> set + dict 没有下标索引，所以不支持
pycharm 垂直选择多行,alt+鼠标左键选择
len() + max() + min()
"""list8 = [1, 2, 3, 4, 5]
tuple8 = (1, 2, 3, 4, 5)
str8 = "abcdefg"
set8 = {1, 2, 3, 4, 5}
dict8 = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
# len
print(f"list == len == {len(list8)} == {list8}")
print(f"tuple == len == {len(tuple8)} == {tuple8}")
print(f"str == len == {len(str8)} == {str8}")
print(f"set == len == {len(set8)} == {set8}")
print(f"dict == len == {len(dict8)} == {dict8}")# max
# pycharm 垂直选择多行,alt+鼠标左键选择
print(f"list == max == {max(list8)} == {list8}")
print(f"tuple == max == {max(tuple8)} == {tuple8}")
print(f"str == max == {max(str8)} == {str8}")
print(f"set == max == {max(set8)} == {set8}")
print(f"dict == max == {max(dict8)} == {dict8}")
# min
print(f"list == min == {min(list8)} == {list8}")
print(f"tuple == min == {min(tuple8)} == {tuple8}")
print(f"str == min == {min(str8)} == {str8}")
print(f"set == min == {min(set8)} == {set8}")
print(f"dict == min == {min(dict8)} == {dict8}")# 通用类型转换
# list()
print("\nlist()\n")
print(f"list =to= list == {list(list8)}")
print(f"tuple =to= list == {list(tuple8)}")
print(f"str =to= list == {list(str8)}")
print(f"set =to= list == {list(set8)}")
print(f"dict =to= list == {list(dict8)}")# str()
print("\nstr()\n")
print(f"list =to= str == {str(list8)}")
print(f"tuple =to= str == {str(tuple8)}")
print(f"str =to= str == {str(str8)}")
print(f"set =to= str == {str(set8)}")
print(f"dict =to= str == {str(dict8)}")# tuple()
print("\ntuple()\n")
print(f"list =to= tuple == {tuple(list8)}")
print(f"tuple =to= tuple == {tuple(tuple8)}")
print(f"str =to= tuple == {tuple(str8)}")
print(f"set =to= tuple == {tuple(set8)}")
print(f"dict =to= tuple == {tuple(dict8)}")# set()
print("\nset()\n")
print(f"list =to= set == {set(list8)}")
print(f"tuple =to= set == {set(tuple8)}")
print(f"str =to= set == {set(str8)}")
print(f"set =to= set == {set(set8)}")
print(f"dict =to= set == {set(dict8)}")# sorted()
list8 = [3,1,2,5,4]
tuple8 = (3,1,2,5,4)
str8 = "gacbefd"
set8 = {3,1,2,5,4}
dict8 = {"a": 1, "c": 2, "b": 3, "e": 4, "d": 5}print(f"list = sort == {sorted(list8)}")
print(f"tuple = sort == {sorted(tuple8)}")
print(f"str = sort == {sorted(str8)}")
print(f"set = sort == {sorted(set8)}")
print(f"dict = sort == {sorted(dict8)}")print("sorted + reverse")
print(f"list = sort == {sorted(list8, reverse=True)}")
print(f"tuple = sort == {sorted(tuple8, reverse=True)}")
print(f"str = sort == {sorted(str8, reverse=True)}")
print(f"set = sort == {sorted(set8, reverse=True)}")
print(f"dict = sort == {sorted(dict8, reverse=True)}")# TypeError: ‘list’ object is not callable
# callable()是python的内置函数，用来检查对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用，类似于iterable（）
# 在如上代码中，由于变量list和函数list重名了，所以函数在使用list函数时，发现list是一个定义好的列表，而列表是不能被调用的，因此抛出一个类型错误
Python数据容器：list + set + tuple + dict + str 简记 黑马课程相关推荐
- python入门(六)——python数据容器
系列文章目录 python入门(一)--你好python python入门(二)--python基础语法 python入门(三)--python判断语句 python入门(四)--python循环语句 ...
- Python数据容器、list列表、tuple元组、str字符串、数据容器（序列）切片、set集合、dict字典、字符串大小比较
数据来源 01 数据容器 为什么学习数据容器 数据容器 总结 02 列表 1)列表定义 为什么需要列表 列表的定义语法 列表的定义方式 演示 """ 演示数据容器之:li ...
- Python序列 数据类型 创建方式 Tuple元组 Str字符串 List列表 dict字典 Set集合 range,zip,map,enumerate
Python 序列分类 数据类型 详细介绍 Python 主要数据类型: 元组Tuple, 字符串Str,列表List,字典Dict,集合Set 对比 元组Tuple 字符串Str 列表List 字典 ...
- python数据容器专题
Python容器专题 [导读] 容器通常属于序列(如列表或元组)或映射(如字典),但也存在其他形式的容器.依据Python官方的说法,Python语言中标准内建容器包括 dict , list , s ...
- python数据容器之集合、字典
set集合 基本语法: # 定义集合字面量 (元素,元素,--元素) # 定义集合变量 变量名称 = (元素,元素,--元素) # 定义空集合 变量名称 = set() 列表使用 [] 元组使用 () ...
- 3. Python 数据容器（列表、元组、字符串、集合、字典）
1. 数据容器入门 数据容器:一种可以容纳多份数据的数据类型,容纳的每份数据称为一个元素. 每个元素,可以是任意类型数据,如:字符串.数字.布尔等. 数据容器根据特点的不同,如: 是否支持重复元素 是 ...
- Python数据容器(五)
python学习之旅(五) 学习汇总入口[Python]学习汇总(3万字+思维导图) 写作不易,如果您觉得写的不错,欢迎给博主来一波点赞.收藏~让博主更有动力吧! 一.数据容器 一种可以容纳多份数据的 ...
- 【Python基础】Python数据容器（元组）
文章目录 数据容器:tuple(元组) 元组的定义格式 元组的相关操作 元组的相关操作-注意事项 元组的特点 数据容器:tuple(元组) 元组的定义格式 元组定义:定义元组使用小括号,且使用逗号隔开 ...
- 【Python基础】Python数据容器（字典）
文章目录 数据容器:dict(字典.映射) 字典的定义 字典数据的获取 字典的嵌套 字典的注意事项 字典的常用操作 (1)新增元素 (2)更新元素 (3)删除元素 (4)清空字典 (5)获取全部key ...
最新文章
- 《互联网人求职图鉴》：这类人才“最吃香”，最高薪编程语言出炉！
- [CF1066C]Books Queries
- 为什么每个函数都要测试
- clion 带参数调试运行
- UA MATH523A 实分析1 集合论基础2 序关系与Zorn引理
- python加法怎么写_51NOD 大数加法以及python写法
- Python Django 多对多表设计批量插入方法示例
- boost::filesystem模块打印文件状态的测试程序
- 包概念与__init__注意事项
- 五大质量工具详解及运用案例_掌握质量管理五大工具，实现九段质量管理成长...
- 基于链表的两个集合的差集
- python判断线程结束_判断Threading.start新线程是否执行完毕的实例
- Microsoft.XMLHTTP“没有权限”的错误
- Selenium分布式运行：SeleniumGrid
- 为android开发安装ubuntu系统环境纪要
- excel文件修复工具_微软修复磁盘清理工具无法完全删除windows.old文件夹问题
- PLSQL下载与安装
- html2canvas黑背景,解决canvas转base64/jpeg时透明区域变成黑色背景的方法
- DPABI(用于脑成像的数据处理和分析的工具箱)的下载和安装步骤
- R语言dplyr包的select函数和everthing函数筛选dataframe中的所有数据列（all columns of the dataframe）