企业官网建设流程全解析

1. 元组(Tuple)
   特点：小括号()、不可变、有序、可重复。
   不可变：tuple创建后不能做任何修改，元素无法修改，元组本身无法增加元素或删除元素(所谓的增加/删除元素本质是创建新元组)
   有序：元素有固定顺序
   可重复：可以包含重复元素

Python代码示例：
tup = (1, 2, 3, 2)
print(tup) # (1, 2, 3, 2)
print(tup[0]) # 1，有序，可索引
print(tup.count(2)) # 2，可重复
#tup[0] = 100 # TypeError: ‘tuple’ object does not support item assignment，创建后不能修改

#新增一个元素（本质是创建新元组）：
tup = (1, 2, 3)
tup2 = tup + (4,)
print(tup2) # (1, 2, 3, 4)
print(tup) # (1, 2, 3) 原元组不变

#删除一个元素（本质是创建新元组）：
tup = (1, 2, 3)
tup2 = tuple(x for x in tup if x != 3)
print(tup2) # (1, 2)
print(tup) # (1, 2, 3) 原元组不变

2. 列表[List]
   特点：中括号 []、可变、有序、可重复。
   可变：List创建后可以修改，元素可以修改，列表本身可以增加元素或删除元素
   有序：元素有固定顺序
   可重复：可以包含重复元素。

Python代码示例：
lst = [1, 2, 3, 2]
print(lst) # [1, 2, 3, 2]
print(lst[0]) # 1，有序，可索引
print(lst.count(2)) # 2，可重复
lst[0] = 100 # 可变，可以修改
print(lst) # [100, 2, 3, 2]

#新增一个元素：
lst = [1, 2, 3]
lst.append(4)
print(lst) # [1, 2, 3, 4]

#删除一个元素：
lst = [1, 2, 3]
lst.remove(2) # 按值删除
print(lst) # [1, 3]

#或用 pop 按索引删除：
lst = [1, 2, 3]
lst.pop(1) # 删除索引 1
print(lst) # [1, 3]

3. 集合{Set}
   特点：大括号 {}、可变、无序、元素唯一、空集合用 set()。
   可变：Set创建后可以新增或删除元素，但已经存在的元素本身必须不可变，因为元素不能索引
   无序：元素没有固定顺序
   元素唯一：自动去重

Python代码示例：
s = {1, 2, 3, 2, 2}
print(s) # {1, 2, 3}，自动去重
#print(s[0]) # TypeError: ‘set’ object is not subscriptable，无序，不能索引
s.add(4) # 可变
print(s) # {1, 2, 3, 4}

#新增一个元素：
s = {1, 2, 3}
s.add(4)
print(s) # {1, 2, 3, 4}

#删除一个元素：
s = {1, 2, 3}
s.remove(2)
print(s) # {1, 3}

#remove 删除不存在的元素会报错，可用 discard 更安全：
s = {1, 2, 3}
s.discard(5) # 不存在也不报错
print(s) # {1, 2, 3}

4. 字典{Dict}
   特点：大括号 {}、可变、无序、键值对、键唯一、值可重复。
   键值对：元素是key:value格式
   可变：键值对中，键无法改修改（d[“name”] = d.pop(“name1”)其实是删除旧键 + 新增新键的操作），值可以修改，字典本身可以新增和删除键值对

Python代码示例：
d = {“name”: “Alice”, “age”: 25}
print(d) # {‘name’: ‘Alice’, ‘age’: 25}
d[“age”] = 26 # 可变，可以修改
print(d) # {‘name’: ‘Alice’, ‘age’: 26}
d2 = {“name”: “Alice”, “name”: “Bob”}
print(d2) # {‘name’: ‘Bob’}，键唯一，重复会覆盖
d3 = {“a”: 1, “b”: 1}
print(d3) # {‘a’: 1, ‘b’: 1}，值可重复

#新增一个元素（键值对）：
d = {“name”: “Alice”, “age”: 25}
d[“city”] = “Beijing”
print(d) # {‘name’: ‘Alice’, ‘age’: 25, ‘city’: ‘Beijing’}

#删除一个元素（键值对）：
d = {“name”: “Alice”, “age”: 25, “city”: “Beijing”}
del d[“age”]
print(d) # {‘name’: ‘Alice’, ‘city’: ‘Beijing’}

#或用 pop 删除并返回被删的值：
d = {“name”: “Alice”, “age”: 25}
age = d.pop(“age”)
print(age) # 25
print(d) # {‘name’: ‘Alice’}

元素（Element）：
元组、列表、集合、字典中的单个数据项，比如列表[10, “hello”] 中的 10 和 “hello”

索引（Index）：
元素的位置（从 0 开始），比如my_list[0] 表示访问第一个元素

长度（Length）：
my_tuple是列表，则len(my_tuple) 返回元组my_tuple的元素个数， len(str(my_tuple[4]))返回元组第5个元素的长度
my_list是列表，则len(my_list) 返回列表my_list的元素个数， len(my_list[4])返回列表第5个元素的长度
my_dict是字典，则len(my_dict) 返回字典my_dict的元素个数，len(my_dict[key])可以直接获取字典中某个键对应的值的长度
my_set是集合，则len(my_set) 返回集合my_set的元素个数,len(my_set[1])则会报错(“‘set’ object is not subscriptable”)
len() 只能用于可迭代对象（如字符串、列表、字典、集合等），而整数没有长度，如果len(int型数字)则会报错"object of type ‘int’ has no len()"
Python代码示例：
tup = (‘a’, ‘bb’, ‘ccc’, ‘dddd’)
print(len(tup)) # 4，元素个数
print(tup[2]) # ccc，第三个元素
print(len(tup[2])) # 3，第三个元素的长度

lst = [‘a’, ‘bb’, ‘ccc’]
print(len(lst)) # 3，元素个数
print(lst[2]) # ccc，第三个元素
print(len(lst[2])) # 3，第三个元素的长度

s = {‘a’, ‘bb’, ‘ccc’, ‘dddd’, ‘eeeee’}
print(len(s)) # 5，元素个数
s_list = list(s)
print(s_list[2]) # 第三个元素（顺序不固定）
print(len(s_list[2])) # 第三个元素的长度

d = {“name”: “Alice”, “age”: 25, “city”: “Beijing”}
print(len(d)) # 3，键值对个数
d_items = list(d.items())
print(d_items[2]) # (‘city’, ‘Beijing’)，第三个键值对
print(len(d_items[2][0])) # 4，第三个键 ‘city’ 的长度
print(len(d_items[2][1])) # 7，第三个值 ‘Beijing’ 的长度

其他一些示例
{}
{}表示一个空字典，而不是空集合。
my_type = {}
my_type1 = {“a”: 1, “b”: 2}
print(type(my_type)) # <class ‘dict’>
print(type(my_type1)) # <class ‘dict’>

set()
set()表示一个空集合。
my_type = set()
my_type1 = {1, 2, 3}
print(type(my_type)) # <class ‘set’>
print(type(my_type1)) # <class ‘set’>

列表 [-1]表示取倒数第一个元素
t = [10,9,8,7,6,5,4,3]
print(t[-1]) # 输出：3
print(t[-6]) # 输出：8

列表清空用clear()函数
my_list = [1, 2, 3, 4, 5]
print(“原始列表:”, my_list) # 输出: [1, 2, 3, 4, 5]
my_list.clear()
print(“清空后:”, my_list) # 输出: []

字典清除某个元素的值(键值对中的值)
my_dict = {‘A’: [1,2], ‘B’: [3], ‘C’: [4]}
my_dict[‘A’].clear()
print(my_dict)
#输出结果
{‘A’: [], ‘B’: [3], ‘C’: [4]}
或
my_dict = {‘name’: ‘Alice’, ‘age’: 25, ‘scores’: [85, 90, 78], ‘city’: ‘Beijing’}
my_dict[‘age’] = None
my_dict[‘scores’] = []
print(my_dict)
#输出结果
{‘name’: ‘Alice’, ‘age’: None, ‘scores’: [], ‘city’: ‘Beijing’}