企业官网建设流程全解析

一、数据容器

列表

列表名 = [元素、元素、元素]

participants = ["小林","小周","小李"]

num = [1,2,3,4,5,6,7,8,9,10]

（就拿num = [1,2,3,4,5,6,7,8,9,10]来为接下来的列表功能做例子）

（列表是有索引的，从前面往后是0、1、2......，从后面往前是-1、-2、-3......）

查看

按照对应元素所在位置，列表[索引]即可取出对应元素

（列表名[索引]）

修改

（列表名[索引] = 替换内容）

找到对应位置的元素后，重新赋值即可修改

删除

remove : 按照值查找，删除第一个匹配的元素，如果没找到会报错

（列表名.remove(元素)）

pop : 按照位置查找，弹出匹配位置的元素，可以使用变量接收。一般默认弹出最后一个，经常使用，如果数字超过range上限，则会报错

（列表名[索引]，如果不指定索引，默认是最后一个）

del：这个跟pop功能类似

（del 列表名[索引]，如果不指定索引，默认是最后一个）

增加

append ：将元素增加到列表末尾（注意：要是加入一个列表，加入进去后，还是列表

（列表名.append（元素））

extend ：将列表里面的元素，逐个添加到列表末尾

（列表名.extend(里面是一个列表以及其元素)）

insert：在指定下标索引的位置加入指定的元素

（列表名.insert(索引下标,元素)）

其他操作

clear:清空列表内容

（列表名.clear()）

index:查找某个元素的下标

（列表名.index(元素)）

count:统计某个元素在列表内的数量

（列表.count(元素)）

len:统计列表内有多少个元素

（len(列表名)）

索引和切片（正/负下标、步长）

scores = [88, 95, 76, 90, 83]
print("第 0 个(第一个):", scores[0]) # 88
print("第 2 个:", scores[2]) # 76
print("倒数第 1 个:", scores[-1]) # 83（从右往左数）
print("倒数第 2 个:", scores[-2]) # 90
print("切片 [1:4]:", scores[1:4]) # [95, 76, 90] 左闭右开
print("切片 [:] 复制:", scores[:]) # 整个列表的副本
print("步长 2 [0:5:2]:", scores[0:5:2]) # [88, 76, 83]
print("倒序 [::-1]:", scores[::-1]) # [83, 90, 76, 95, 88]

代码参数解读

• scores[0]— 下标从0开始；scores[0]是第一个元素。

• scores[-1]— 负数下标从末尾数，-1是最后一个。

• scores[1:4]— 切片"左闭右开"，包含下标 1~3，不含 4。

• scores[0:5:2]— 第三个数是步长，每隔 2 取一个。

• scores[::-1]— 步长为-1表示倒序。

预期效果

第 0 个(第一个): 88
第 2 个: 76
倒数第 1 个: 83
倒数第 2 个: 90
切片 [1:4]: [95, 76, 90]
切片 [:] 复制: [88, 95, 76, 90, 83]
步长 2 [0:5:2]: [88, 76, 83]
倒序 [::-1]: [83, 90, 76, 95, 88]

元组

元组名 = (元素、元素、元素)

注意：

1、元组由于不可修改的特性，所以其操作方法特别少，例如修改、增加、删除等操作都是不可行的，但是你若是在元组内嵌套了一个列表，是可以对列表内的元素进行操作的

2、index()、count()、len()这三个的使用方法跟列表的一样

打包和解包

第一种情况

a,b = b,a

第二种情况

t = (1,2,3,4,5,6,7) _,b,*rest = t print(b) print(rest)

字符串

字符串名 = 元素

（也就是变量名 = 值）

注意：

1、字符串跟元组很像，例如修改、增加、删除等操作也都是不可行的

2、index()、count()、len()这三个的使用方法跟列表的一样

集合

集合名 = {元素、元素、元素}

num = {1,2,3,4,5,6,7,8,9,10}

（就拿num = {1,2,3,4,5,6,7,8,9,10}来为接下来的列表功能做例子）

增加

add:添加一个元素

（集合名.add(元素)）

update:增加多个元素

（集合名.update([元素、元素、元素])）

（相当于把列表里面的元素，单独add到集合里面）

删除

remove:查找并删除元素，如果元素不存在，则会报错

（集合名.remove(元素))

discard:查找并删除元素，如果元素不存在，无事发生

（集合名.discard(元素))

pop:随机弹出一个元素

（集合名.pop()）

集合之间的运算

& 交集 找出两个集合之间的共同元素，构成新集合

| 并集 找出两个集合的所有元素，构成新集合

— 差集 A - A & B ，剔除所有A中同时属于B的元素

^ 对称差 A | B - A & B ，A与B的并集中，剔除所有AB交集的元素

（&、|、-、^这几个只是快捷符号，这几个符号都有英文）

成员判断

a in A 表示判断 a 是否属于 A

a not in A 表示判断 a 是否不属于 A

字典

字典名 = {key:value,key:value,key:value}

scores = {"语文": 88, "数学": 95, "英语": 76}

（拿这个举例子）

查看（取不到前者报错，后者返回默认）

（列表名[key]）

（列表名.get(key,默认值)）注意：找到key，就返回其对应的value，没有找到key，就返回你设置的默认值

增加&修改

scores = {"语文": 88, "数学": 95}
scores["英语"] = 76 # key 不存在 -> 新增
print("新增英语:", scores) # {'语文':88,'数学':95,'英语':76}

scores["数学"] = 100 # key 已存在 -> 修改
print("改数学:", scores) # {'语文':88,'数学':100,'英语':76}

删除（pop / del / clear）

scores = {"语文": 88, "数学": 95, "英语": 76}
v = scores.pop("语文") # 删 key 并返回其值
print("pop 语文:", v, scores) # 88 {'数学':95,'英语':76}

del scores["数学"] # 直接用 del 删，不返回
print("del 数学:", scores) # {'英语': 76}

scores.clear() # 清空
print("clear:", scores) # {}

遍历（keys / values / items）与判断 key

scores = {"语文": 88, "数学": 95, "英语": 76}
print("=== 遍历 key ===")
for k in scores.keys():
print(k)

print("=== 遍历 value ===")
for v in scores.values():
print(v)

print("=== 遍历 key-value（最常用） ===")（得到的是一个元组，可以打包解包）
for k, v in scores.items():
print(f"{k}: {v}")

print("'数学' 这个 key 在吗:", "数学" in scores) # True
print("查 value 在吗(慢):", 95 in scores.values()) # True

代码逐参数解读：

• d.keys()— 所有键；d.values()— 所有值；d.items()— 所有(键, 值)对。

• "数学" in scores— 判断 key 是否存在（很快）；判断 value 要用in scores.values()（慢一些）。

容器转换

1、三种容器之间可以自由转换

2、当前容器转换成另一种容器，也会拥有另一种容器的特性，数据也会发生相对应的变化

二、判断

条件判断if / elif / else

三元运算符

注意：

1、还有一种判断方式，那就是match / case

2、还有嵌套判断

三、循环

for循环

注意：

# 三种写法： # range(stop) 0 ~ stop - 1 # range(start,stop) start ~ stop - 1 # range(start,stop,step)

while循环

for循环和while循环共同点

# break ： 提前结束循环 # continue ： 跳过本次循环，开始下一次循环 # pass : 占位语句

扩展知识：

enumerate

注意：用enumerate处理数据，处理后是元组类型数据

zip

注意：用zip处理数据，处理后是元组类型数据