零、数据容器
概念：一种可以存储多个元素的Python数据类型
种类：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）
一、列表
特点
- 可以容纳多个元素（上限2^63-1个）
- 可以容纳不同类型的元素
- 数据是有序存储的
- 允许数据重复存在
- 可以修改、删除、增加元素等
基本语法
字面量：[元素1，元素2，元素3，...]
定义变量：变量名称 = [元素1，元素2，元素3，...]
定义空列表：变量名称 = []
变量名称 = list()
- list一次可以储存多个数据，且可以储存不同的数据类型 。
name_list = ["momo", "sana", "mina"]
print(name_list)
print(type(name_list))
my_list = ["coconut", 902, "singapore"]
print(my_list)
print(type(my_list))运行结果：
- 支持嵌套列表
mix_list =[[1, 2, 3], [4, 5, 6]]
print(mix_list)
print(type(mix_list))运行结果：
下标索引
语法：列表[标号]
- 正向索引
第一个元素下标为0
name_list = ["momo", "sana", "mina"]
print(name_list[0])
print(name_list[1])
print(name_list[2]) 
- 反向索引
最后一个元素下表为-1
name_list = ["momo", "sana", "mina"]
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
- 嵌套列表的下标索引
列表[外层标号][内层标号]
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][0])
常用操作
-
查找某元素的下标
列表.index(元素)
my_list = ["nayeon", "sana", "tzuyu"]
index = my_list.index("sana")
print(f" The index is {index}")
如果被查找的元素不存在，会报错。
- 修改特定位置的元素值
列表[下标] = 值
my_list = ["nayeon", "sana", "tzuyu"]
my_list[0] = "mina"
print(f"After modification:{my_list} ") 
- 插入元素
列表.insert（下标，元素）
在指定的下标位置，插入指定的元素
my_list.insert(1, "nayeon")
print(f"After insertion:{my_list} ") 
- 追加元素
列表.append（元素），将指定元素，追加到列表的尾部
my_list.append("dahyun")
print(f"After appending:{my_list} ")
列表.extend（其他数据容器）
将其他数据容器的内容取出，依次加入列表尾部。
your_list = {"momo", "jihyo"}
my_list.extend(your_list)
print(f"After extending:{my_list}")
- 删除元素
del 列表[下标]
列表.pop(下标)
del my_list[4]
my_list.pop(1)
print(f"After delete:{my_list}") 
- 删除某元素在列表中的第一个匹配项
列表.remove（元素）
my_list = ["mina", "sana", "tzuyu", "sana"]
my_list.remove("sana")
print(f"After removing:{my_list}")
- 清空列表
列表.clear（）
my_list.clear()
print(f"After clear:{my_list}")
- 统计某元素在列表内的数量
列表.count（元素）
my_list = ["momo", "mina", "sana", "momo", "tzuyu"]
count = my_list.count("momo")
print(f"The number of momo is {count}")
- 统计列表中总共有多少元素
len（列表）
my_list = ["momo", "mina", "sana", "momo", "tzuyu"]
count = len(my_list)
print(f"The number of elements in my_list is {count}")
遍历
while循环
my_list = ["momo", "mina", "sana", "momo", "tzuyu"]
index = 0
while index < len(my_list):
element = my_list[index]
print(f"{element}")
index += 1for循环
my_list = ["momo", "mina", "sana", "momo", "tzuyu"]
index = 0
for index in range(0,len(my_list)):
element = my_list[index]
print(f"{element}")二、元组
元组一旦定义完成，就不可被修改
基本语法
字面量：（元素，元素，......，元素）
定义变量：变量名=（元素，元素，......，元素）
定义空元组：变量名称 = （）
变量名称 = tuple（）
- 可以存储不同的数据类型
- 下标访问规则和list一样
- 定义单个元素的元组时，元素后面必须要加一个逗号
t1 = (2015, "twice", 1020)
t2 = ()
t3 = tuple()
t4 = ("once",)
print(f"{type(t1)},{t1}")
print(f"{type(t2)},{t2}")
print(f"{type(t3)},{t3}")
print(f"{type(t4)},{t4}")
元组嵌套
t5 = ((1, 2, 3), (4, 5, 6))
print(f"{type(t5)},{t5}")
print(f"{t5[1][2]}")
常用操作
- 查找某元素的下标
元组.index(元素)
- 统计某元素在列表内的数量
元组.count（元素）
- 统计列表中总共有多少元素
len（元组）
t1 = (9, 5, 7, 8, 4, 3, 66, 37, 49, 10, 8)
index = t1.index(66)
count = t1.count(8)
num = len(t1)
print(f"The index of 66 is {index}")
print(f"The number of 8 is {count}")
print(f"The number of elements is {num}")
遍历
while循环
i = 0
while i < len(t1):
print(f"{t1[i]}")
i += 1for循环
for x in range(0, len(t1)):
print(f"{t1[x]}")注意事项
- 不可以修改元组的内容，否则会报错
- 可以修改元组内list的内容
t1 = (9, 5, 7, 8, 4, ["twice", "jyp"])
t1[5][1] = "once"
print(f"{t1}")
三、字符串
字符串时字符的容器，一个字符串可以存放任意数量的字符
下标索引
从前向后，从0开始
从后向前，从-1开始
my_str = "one in a million"
value1 = my_str[2]
value2 = my_str[-7]
# value1 = e, value2 = m字符串不支持修改
常用操作
- 查找某元素的下标
字符串.index(字符串)
my_str = "one in a million"
value = my_str.index("in")
print(f"{value}")
# value = 4- 字符串的替换
字符串.replace(字符串1，字符串2)
注：将字符串全部的字符串1替换为字符串2，不是修改字符本身，而是得到了一个新的字符串
my_str = "one in a million"
new_my_str = my_str.replace("one", "ONE")
print(f"The new string is {new_my_str}")
- 字符串的分割
字符串.split（分隔符字符串）
注：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
字符串本身不变，而是得到了一个列表对象
my_str = "one in a million"
my_str_list = my_str.split(" ")
print(f"After splitting:{my_str_list},type is {type(my_str_list)}")
- 字符串的规整操作
去前后空格
字符串.strip（）
去前后指定字符串
字符串.strip（字符串）
my_str = " one in a million "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"{new_my_str}")
my_str = "12one in a million21"
new_my_str = my_str.strip("12")
print(f"{new_my_str}")
- 统计某元素在字符串内的数量
字符串.count（字符串）
- 统计列表中总共有多少元素
len（字符串）
遍历
支持while循环和for循环
四、序列
定义
序列是指内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串均可以视为序列
切片
从一个序列中，取出一个子序列
语法：序列[起始下标：结束下标：步长]
- 起始下标表示从何处开始，可以留空，留空视作从头开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示依次取元素的间隔
- 步长1表示一个个取元素
- 步长2表示每次跳过1个元素取
- 步长N表示每次跳过N-1个元素取
- 步长为负数表示反向取（起始下标和结束下标也要反向标记）
此操作不会影响序列本身，而是得到一个新的序列
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]
print(f"result1:{result1}")
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]
print(f"result2:{result2}")
my_str = "01234567"
result3 = my_str[::2]
print(f"result3:{result3}")
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转了
print(f"result4:{result4}")
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"result5:{result5}")
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"result6:{result6}")
五、集合
基本语法
字面量：{元素，元素，元素......,元素}
集合变量：变量名称={元素，元素，......,元素}
空集合：变量名称=set()
集合元素不能重复。
my_set = {"mina", "sana", "momo", "sana"}
print(f"{my_set}")
集合是无序的，不支持下标访问。
常用操作
- 添加新元素
集合.add（元素）
my_set = {"mina", "sana", "momo", "sana"}
print(f"{my_set}")
my_set.add("nayeon")
print(f"{my_set}")
my_set.add("momo") # 去重
print(f"{my_set}")
- 移除元素
集合.remove(元素)
my_set = {"mina", "sana", "momo", "sana"}
print(f"{my_set}")
my_set.remove("momo")
print(f"{my_set}")
- 随机取出一个元素
集合.pop()
my_set = {"mina", "sana", "momo"}
print(f"{my_set}")
element = my_set.pop()
print(f"element is {element}")
- 清空集合
集合.clear()
- 取两个集合的差集
集合1.difference(集合2)
取出集合1和集合2的差集
set1 = {1, 2, 3}
set2 = {2, 5, 6}
set3 = set1.difference(set2)
print(f"set3 is {set3}")
print(f"set1 and set2 remain stay:set1={set1}.set2={set2}")
- 消除2个集合的差集
集合1.difference_update(集合2)
在集合1内删除和集合2相同的元素，集合1被修改，集合2不变
set1 = {1, 2, 3}
set2 = {2, 5, 6}
set1.difference_update(set2)
print(f"set1 is {set1}")
print(f"set2 is {set2}")
- 2个集合合并
集合1.union(集合2)
产生一个新的集合，集合1和集合2不变
set1 = {1, 2, 3}
set2 = {2, 5, 6}
set3 = set1.union(set2)
print(f"set3 is {set3}")
- 统计元素数量
len(元素) #自动去重
- 集合的遍历
不支持下标索引，所以不支持while循环
可以用for循环
set1 = {1, 2, 3, 4, 5, 6}
for element in set1:
print(element)
六、字典
按【key】找出【value】
基本语法
存储的元素是一个个的键值对,key不可以重复
字面量：{key:value, key:value,......,key:value}
变量：my_dict={key:value, key:value,......,key:value}
空字典：my_dict={}
my_dict = dict()
twi = {"nayeon":1995, "sana":1996, "tzuyu":1999}
my_dict1 = {}
my_dict2 = dict()
print(twi, type(twi))
print(my_dict1, type(my_dict1))
print(my_dict2, type(my_dict2))
获取数据
twi = {"nayeon":1995, "sana":1996, "tzuyu":1999}
num1 = twi["nayeon"]
num2 = twi["tzuyu"]
num3 = twi["sana"]
print(num1)
print(num2)
print(num3)
字典的key和value可以是任意数字类型（key不可为字典）
- 嵌套字典
girl_group = {
"twice": {
"nayeon": 1995,
"sana": 1996,
"tzuyu": 1999
},
"blackpink": {
"jennie": 1996,
"lisa": 1997
}
}
print(f"birth year of girl group member:{girl_group}")
year = girl_group["twice"]["nayeon"]
print(f"birth year of nayeon:{year}")
常用操作
- 新增元素
字典[key]=value
- 更新元素
字典[key]=value
字典key不可以重复，所以对已存在的key执行上述操作，就是更新value值
twice = {"nayeon": 1995, "sana": 1996, "tzuyu": 1999}
print(twice)
twice["momo"] = 1996
twice["nayeon"]=1999
print(twice)
- 删除元素
字典.pop(key)
twice = {"nayeon": 1995, "sana": 1996, "tzuyu": 1999}
kid = twice.pop("tzuyu")- 清空元素
字典.clear()
- 获取全部的key
字典.keys()
- 统计字典内的元素数量
len（字典）
遍历
法1：通过获取全部的key来完成遍历
twice = {"nayeon": 1995, "sana": 1996, "tzuyu": 1999}
members = twice.keys() # 获取全部的keys
for key in members:
print(f"member:{key}")
print(f"birth year:{twice[key]}")法2：直接对字典进行for循环，每一次循环都是直接得到key
twice = {"nayeon": 1995, "sana": 1996, "tzuyu": 1999}
for key in twice:
print(f"member:{key}")
print(f"birth year:{twice[key]}")
七、总结
cr:黑马程序员
八、通用操作
-
遍历
-
统计功能
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5 }
print(max(my_list))
print(max(my_tuple))
print(max(my_str))
print(max(my_set))
print(max(my_dict)) 
- 通用类型转换
- 通用排序功能
reverse是默认参数，默认是false（正序），true是逆序
reverse：反转
排完序后会变成列表对象（字典会丢失value）
------------------------------------------------------------全文完------------------------------------------------------------
扫一扫
1928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
