python数据容器

一、list列表

亮点：python中的list可以存储不同类型的元素

# list_demo.py
# 数据列表的定义 及 下标获取指定元素
name_list = ["c++", "java", "python", "java"]
print(name_list)
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(type(name_list))

person = ["lwang", 20, "beijing"]
print(person)
print(person[0])
print(person[1])
print(person[2])
print(type(person))

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

# list提供的方法
# 查找指定元素的下标
index = name_list.index("c++")
print("c++ idex: %d" % index)

# 修改指定下标的元素
name_list[1] = "c#"
print("name_list[1]: %s" % name_list[1])
print(name_list)

# 在指定下标的位置插入元素
name_list.insert(1, "java")
print(name_list)

# 元素追加到一个元素到list末尾
name_list.append("php")
print(name_list)

# 元素追加整个容器的数据
lsit2 = [1,3,5]
name_list.extend(lsit2)  #python中的list可以存储不同类型的元素
print(name_list)

# 删除元素语法  1. del list[index]  2. list.pop(index) pop方法
del name_list[0]
print(name_list)

element = name_list.pop(1) # 从list中pop出该元素，可以通过返回值接收弹出的元素
print(f"element = {element}")
print(name_list)

# remove 删除list中第一个匹配的元素
name_list.remove("java")
print(name_list)
name_list.append("java")

print("name_list 中java的个数为：%d" % name_list.count("java"))

print("name_list 中总共元素的个数为：%d" % len(name_list))
# name_list.clear()
# print(name_list)

# list 的遍历
print("==================== name_list 的遍历 ========================")
def list_check_v1():
    index = 0
    for x in name_list:
        print(f"当前的元素为：{x}")

list_check_v1()
print("==================== 分割线 ========================")

def list_check_v2():
    index = 0
    while index < len(name_list):
        element = name_list.pop()
        print(f"当前的元素为：{element}")

list_check_v2()

二、元组tuple

元组中的元素不允许被修改

# tuple 元组

t1 = ("lwang", 20, "beijing")
print(t1[0]) # 支持下标获取元素
# t1[0] = "panda" # 元组中的元素不允许被修改

print(t1)
t2 = ()
t3 = tuple();

#元组中的元素可以是list
t4 = ("c++", "java", "python", [1, 3, 5])
print(t4)
t4[3][0] = 0  # 修改的是元组中的列表元素
print(t4)

print("c++在t4中的index为：%d" % t4.index("c++"))

idx = 0
while idx < len(t4):
    print(f"elemetn {t4[idx]}")
    idx += 1
print("=========== 分割线 ===========")
for item in t4:
    print(f"item {item}")

三、字符串string

同元组一样，也是不可修改的数据容器。

3.1 通过下标访问

3.2 index

语法：index = str.index(字符或者字符串)，查找指定字符或者字符串在str中的起始位置

3.1 replace

字符串替换，语法：newstr = str.replace(str1, str2) 表示，将str中的str1全部替换为str2，不是修改str本身，而是生成了新的字符串，通过返回值接收。

3.4 split

字符串分割，存入到列表对象。语法：list = str.split(分割标识)。str本身不变，会得到一个列表对象，通过返回值接收。

3.4 strip

去掉字符串前后的指定字符。new_str = str.strip(字符或者字符串) 参数默认为 “空格”

3.5 count

获取指定字符串在原始字符串中出现的次数。

3.5 len

获取字符串的长度。

str = ("hello world i am panda")

print(str)

print(str[0])
# str[0] = "H"  # 不允许修改

print("am 的idx 是%d " % str.index("am"))

new_str = str.replace("o", "O")
print(new_str)

res_list = str.split(" ")
print(res_list)


str2 = ("  here is strip test    ")
str3 = ("122121212here is strip test122121212")

new_str2 = str2.strip()
print(new_str2)

new_str3 = str3.strip("12")
print(new_str3)

cnt = str.count("l")
print(f"l 在str中出现的次数为：{cnt}")
print(f"str的长度为：{len(str)}")

三、数据容器（序列）的切片

实际上就是从原始序列中按照指定的步长取子序列。可以从左往右取，也可以从右往左取。

# 切片
# 语法：序列[start:end:step]，表示从start位置开始没间隔step选取一个元素，不包含end位置的元素，返回新的序列
# step 可以为负数，表示从右往左取元素，默认step为1
name_list = ["c++", "java", 1, 2, 3, 4]

new_list = name_list[1:4]
print(new_list)

new_list = name_list[-1:-4:-1]
print(new_list)

t1 = ("one", "two", "three", "four", "five", ["six", "seven", "eight", "nine"])
print(t1)

t2 = t1[0:5:2]
print(t2)

str = "1234567891011"
print(str)
new_str = str[::1]
print(new_str)
new_str = str[::3]
print(new_str)

new_str = str[::] # 起始可以不写，表示从头到尾，默认step为1
print(new_str)

new_str = str[::-1] # 起始可以不写，表示从头到尾，step为-1，表示从尾到头取，步长为1
print(new_str)

三、集合set

不允许重复，乱序。

# 集合 set
# 乱序，不重复
my_set = {"c++", "java", "c++", "python"}
print(my_set)
print(f"my_set的类型是：{type(my_set)}")

# 1.添加元素
my_set.add(1)
print(my_set)

# 2.移除指定元素
my_set.remove(1)
print(my_set)

# 3.随机弹出一个元素，集合本身元素减1
element = my_set.pop()
print(element)
print(my_set)

# 4.清空集合
# my_set.clear()
# print(my_set)

# 5.求差集
# 语法：s1.difference(s2) 意思是，s1集合有s2没有的元素

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 7, 8, 9}
# s3 = s1.difference(s2)
# print(f"集合s1 和 s2 的差集为：{s3}")
#
# s3 = s2.difference(s1)
# print(f"集合s2 和 s1 的差集为：{s3}")

# 6.消除两个集合的差集，语法：s1.difference_update(s2)
# 功能: 删除集合s1中和s2相同的元素，s1发生变化，s2不变,查看s1
s1.difference_update(s2)
print(f"集合s1消除 和 s2 的差集后为：{s1}")

# 7.求并集
s3 = s1.union(s2)
print(s3)

# 8.统计集合元素的个数
count = len(s3)
print("合并后的s3的元素个数是：%d 个" % count)

# 9.集合的遍历
for item in s3:
    print(item)

四、字典dict

# 字典 dict
# 语法： {k1:v1, k2:v2, ... , kn:vn}

# 1.定义
# 不允许重复的key，如果出现了重复的key,新值会覆盖掉旧值
my_dict = {"lwang":100, "panda":90, "jazz":80, "lwang":70}
print(my_dict)

print(my_dict["lwang"])
print(my_dict["panda"])
print(my_dict["jazz"])

# 2.字典嵌套
person_info = {
    "lwang":{"age":20, "addr":"beijing"},
    "lyz":{"age":18, "addr":"beijing"},
    "darren":{"age":30, "addr":"changsha"},
}
print(person_info)

print("lyz's age = %d " % person_info["lyz"]["age"])

# 3.添加元素
my_dict["lyz"] = 100
print(my_dict)

# 4.修改指定元素
my_dict["lwang"] = 149
print(my_dict)

# 5.删除元素
score = my_dict.pop("lwang")
print(score)
print(my_dict)

# # 6.清空字典
# my_dict.clear()
# print(my_dict)

# 7.获取全部的key
keys = my_dict.keys()
print(keys)

#  8.遍历
for key in keys:
    print(f"key:value = {key}:{my_dict[key]}")

# 9.字典元素的个数
num = len(my_dict)
print("my_dict 元素的个数是：%d " % num)

推荐一个零声学院免费教程，个人觉得老师讲得不错，
分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，
fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，
TCP/IP，协程，DPDK等技术内容，点击立即学习: