企业官网建设流程全解析

在学习ai大模型之前，先把python的基础知识过一遍。
持续更新中……

列表

列表中的元素不一定是同种类型的数据结构，可以包含多种数据类型，比如字符串、元祖、字典、数字等等。
创建列表的几种方式：

1. 直接声明。

list1=[]list2=[1,'str',2]

2. 解析创建
   这种在项目中用到的比较多。range方法是左闭右开，即包含1，不包含11

list3=[valueforvalueinrange(1,11)]

3. 转化列表
   将其他类型的数据结构转为列表类型.

str1='abc'list1=list(str1)# 注意输出是['a','b','c']，而不是['abc']list2=list(range(1,11))# 输出[1,2,3,4,5,6,7,8,9,10]

注意：不能把int类型的数据转为列表，比如：

num1=123list1=list(num1)# ❌这种写法是错误，会显示TypeError: 'int' object is not iterable。

要想把num1转为列表，可以先转为字符串123，再使用list()方法
list2 = list(str(num1))
原理： list(iterator) 方法的底层逻辑是依次遍历可迭代对象 iterator 的每个元素，并把它们塞到一个新列表中。

数值列表常用统计计算方法：
sum(list) 求整个数值列表之和。
max(list) :整个数值列表的最大值
min(list) :整个数值列表的最小值
列表常用方法：

1. 增
   append() 方法和 insert() 方法
   insert() 方法传入第一个参数是索引，第二个参数是要插入的元素。使用insert方法把元素插入到索引位置时，索引后面的列表元素都向右移动

list1=[]list1.append(1)# [1]list1.append(2)# [1,2]list1.insert(1,5)# [1,5,2]

2. 获取列表切片
   list[i:j]：左闭右开区间
   省略i,从列表最开头开始；省略j，一直获取到列表末尾；如果i和j都省略，则复制整个列表，并且新列表和原列表是独立的
   如果是负数索引，则代表从最后往前数。
   列表切片获取出来的还是一个列表

list1=[iforiinrange(11)]print(list1[1:3])# [1,2]print(list1[:3])# [0,1,2]print(list1[3:])# [3,4,5,6,7,8,9,10]print(list1[-3:])# [8,9,10] 获取最后三个元素list2=list1[:]print(list2)# [0,1,2,3,4,5,6,7,8,9,10],list2和list1是独立的

3. 删除元素
   pop() 方法和 del() 方法
   pop方法删除末尾的元素,并返回最后一个元素
   del方法删除时需要一个索引，但是不返回这个元素

list1=['apple','xiaomi','vivo','oppo']ele=list1.pop()dellist1[1]print(list1)# ['apple', 'vivo']print(ele)# oppo

4. 列表排序和反转
   列表的 sort() 排序方法和 reverse() 反转方法会永久的改变原列表的排列顺序。sort方法排序只适用于同类型的数据，其本质是调用比较符 <
   全局的 sorted() 方法会生成一个新的排好序的列表，原列表保持不变，
   注意:sorted方法不是列表的，是全局方法，因此不能使用像 list.sorted() 这种方法，而是这样使用 sorted(list)

list1=['apple','xiaomi','vivo','oppo']print(list1)# ['apple','xiaomi','vivo','oppo']list1.sort()print(list1)# ['apple', 'oppo', 'vivo', 'xiaomi'],原列表的顺序永久改变list1=['apple','xiaomi','vivo','oppo']list2=sorted(list1)print(list1)# ['apple','xiaomi','vivo','oppo']print(list2)# ['apple', 'oppo', 'vivo', 'xiaomi']

sort之后是这种结果：不是根据字符串长度判断的，而是根据Unicode编码比较的。即单词首字母 a<o<v<x

reverse() 方法是把列表的顺序调换一下位置，永久的改变顺序，再调用一遍就会恢复原来的顺序

list1=['apple','xiaomi','vivo','oppo']list1.reverse()# ['oppo','vivo','xiaomi','apple']

字符串

常用方法

1. 增
   使用 + 或者 join() 方法. join方法常用
   join() 的用法：str.join(sequence).将序列sequence的各个元素用str连接起来形成一个新的字符串

list1=['apple','xiaomi','vivo','oppo']print('!'.join(list1))# 输出apple!xiaomi!vivo!oppo

join()方法的在处理大量字符串的性能要比+快
2. 删
replace() 方法.它会把整个字符串所有的字符都删除或替换
rstrip() ：删除字符串末尾的空格
lstrip() :删除字符串开头的空格
strip() :开头和末尾的空格都删除
注意：字符串属于不可变对象，因此使用replace方法其实会生成一个新字符串对象，原字符串不变。

str1='Hello,World!Python,is beautiful'str2=str1.replace(',','')print(str1)# 'Hello,World!Python,is beautiful'print(str2)# 'HelloWorld!Pythonis beautiful' 凡是带,的地方都会被删除

3. 字符串切片
   同列表的切片
4. 改
   字符串属于不可变对象，不能直接更改字符串的某个元素，否则会报错。不能使用 str1[0] = ‘a’ 这种方式
   因此有两种方法更改：字符串拼接或转为列表再转为字符串

str1='Hello,World!Python,is beautiful'# 1.使用字符串拼接，替换单个字符str_index=str1.find('H')str2='a'+str1[str_index+1:]print(str2)# aello,World!Python,is beautiful#2.转为列表，再替换，再转为字符串list_str=list(str1)str_index=list_str.index('H')list_str[str_index]='a'str2=''.join(list_str)print(str2)# aello,World!Python,is beautiful#1.使用字符串拼接，将Python改成TypeScriptstr_len=len('Python')str_index=str1.find('Python')str2=str1[:str_index]+'TypeScript'+str1[str_index+str_len+1:]print(str2)# 2.使用replace方法str2=str1.replace('Python','TypeScript')

5. 查
   使用 find() 方法查找单个字符或字符串，找到的话返回索引，没找到返回-1.
   注意：find只会查找第一个匹配项，找到之后就不再往后查找了

str1='Hello,World!Python,is beautiful'index1=str1.find('P')# 返回12index2=str1.find('Python')# 12index3=str1.find('python')# -1index4=str1.find('Ppp')#-1

字符串的一些方法：
upper() 把字符都变成大写
lower() 把字符都变成小写
title() 只把开头的字符变成大写

元组

不能修改的元素组成的列表叫做元组，用括号来表示。
元组中的元素不可修改，但是它可以被遍历、切片、查看元素内容。但是不能修改元组中的值，可以把整个元组的值进行修改
查看元组中的值：中括号+索引值
元组切片：同列表，左闭右开区间

tuple1=(1,2,'aaa',True)print(tuple1[0])# 1print(tuple1[1:3])# (2, 'aaa')tuple1=(3,4,5)# 对整个元祖进行修改print(tuple1)# （3，4，5）

字典

用大括号包起来的键值对，键和值之间用冒号分隔，键值对之间用逗号分隔。
键的类型可以是字符串、数值、元组等不可变类型，必须是可哈希对象，因此列表、字典、集合不能做键，值可以是任意类型

1. 增

dict[key]=value dict1={"name":"张三","age":18}print(dict1)dict1['sex']='男'print(dict1)# {'name': '张三', 'age': 18, 'sex': '男'}

2. 删
   pop(key,default) 和 popitem()
   pop需要知道要删除的键，返回删除键对应的值，如果键不存在，报KeyError错误
   popitem不需要传递参数，默认删除字典中最后一个元素，返回键和值组合成的元组

dict1={"name":"张三","age":18,"sex":"男"}# popvalue=dict1.pop('age')# 18print(dict1)# {"name":"张三","sex":"男"}# popitemvalue2=dict1.popitem()print(value2)# ('sex','男') <class 'tuple'>print(dict1)# {"name":"张三","age":18}

3. 获取
   dict[key],注意：字典中的key是什么类型，此处的key就应该是什么类型
4. 遍历（常用）
   使用for循环并结合以下方法
   items() :同时遍历键、值
   keys() :只遍历键
   values() :只遍历值

dict1={"name":"张三","age":18,"sex":"男"}forkey,valueindict1.items():print(f'{key}-{value}')# name-张三 age-18 sex-男forkeyindict1.keys():print(key)# name age sexforvalueindict1.values():print(value)# 张三 18 男

5. 更新
   update(dict) 方法用来更新当前字典,传入的参数是另一个字典或包含键值对可迭代对象（元组）.
   传入的参数有三种形式：一个字典、关键字参数的形式、可迭代的包含键值对的对象
   如果dict中的键在当前字典没有的，则添加键值对；如果有，则更新键对应的值

dict1={"name":"张三","age":18,"sex":"男"}dict2={'age':20,'city':'beijing'}dict1.update(dict2)print(dict1)# {'name': '张三', 'age': 20, 'sex': '男', 'city': 'beijing'}# 包含键值对可迭代对象dict1.update([('career','it'),('area','bbb')])print(dict1)#{'name': '张三', 'age': 20, 'sex': '男', 'city': 'beijing', 'career': 'it', 'area': 'bbb'}# 关键字参数的形式dict1.update(age=22,area='ccc')print(dict1)# {'name': '张三', 'age': 22, 'sex': '男', 'city': 'beijing', 'career': 'it', 'area': 'ccc'}

判断

if
if elif else
多个条件使用and 关键字，所有条件都为True时，总体才为True;or关键字，只要其中一个条件为True，结果就是True
(not)in关键字用来判断元素是否在容器中；这里的容器可以是字符串、列表、元组、集合、字典
注意：当是字典时，判断的是key而不是值。如果想判断值，使用字典的 values() 方法

dict1={"name":"张三","age":18,"sex":"男"}print('name'indict1)# Trueprint('张三'indict1)# Falseprint('张三'indict1.values())# True

函数

1. 定义：def关键字+函数名+小括号+冒号+后面的缩进内容
   函数使用return关键字来返回值，调用函数可以需要用一个变量来接收它的返回值
   如果不写return语句，默认返回None;如果只写一个return关键字，但后面没有内容，也是返回None

deffunc_name():return1

2. 函数参数传递
   有两种方式：位置参数传递和关键字参数传递
   使用的这两种可以混用，但是位置参数必须在关键字参数前面，关键字参数后面不能有位置参数，否则会报错

deffun_name(name,age,sex):print(f'姓名：{name},年龄：{age},性别：{sex}')fun_name('zs',18,'男')# 位置参数传递fun_name(name='zs',age=18,sex='男')# 关键字参数传递fun_name('zs',age=18,sex='男')# 位置和关键字参数混用，位置参数必须在前，关键字参数后面不能有位置参数，否则会报错

2.1 多个参数时，形参和实参的数量不一致时
当不知道一个函数要传多少参数时，可以使用 **args **或kwargs这两个可装任意参数的大包

*args 负责接收任意数量的位置参数，打包成元组，*代表打包多余的位置参数到名为args的空元组中，如何获取这些参数呢？使用for循环遍历这些参数

**kwargs 负责接收任意数量的关键字参数 ，打包成字典,代表打包多余的关键字参数到名为kwargs的空字典中，如果获取这些参数呢？使用for循环结合字典的items方法

defposition_arg(a,b,*args):total=a+bforiinargs:total+=ireturntotalprint(position_arg(a=9,b=10))# 19print(position_arg(1,11,14,16))# 42defkeywords_arg(school,**kwargs):all_args={'school':school}all_args.update(kwargs)fork,vinall_args.items():print(f'{k}-{v}')keywords_arg(school='haha',product='apple',price=9999)# school-haha product-apple price-9999keywords_arg('xxx',name='zs',age=18,sex='男')# school-xxx name-zs age-18 sex-男

**kwargs还有一个常用的方法，结合setattr方法给对象的属性赋值. setattr(object,k,v) 方法用来给对象object设置属性，键名是k,值是v；如果键不存在则创建，如果存在，则更新它的值

classStudent:passdefset_arg(object,**kwargs):fork,vinkwargs.items():setattr(object,k,v)t=Student()set_arg(t,name='zs',age=18)print(t.name)# zsprint(t.age)# 18