python爬虫基础

兆。2024-09-09 17:54

python

文章目录

变量

创建一个变量 ，直接写想要的变量名称就行，不需要定义变量的类型

python 复制代码 
a = 1				整型
b = 'hello world'	字符串
c = a + 1			整型运算   先计算a+1再赋值给c
d = b				字符串

变量类型

  • 用type()函数，获取括号里面的数据类型

  • 同c语言类型：

    int 整型
    float 浮点型
    str 字符串
    True/False 布尔型，只有真假
    list 列表形

输出

print()

  • python自动识别括号里面的''和""并消去
python 复制代码 
print(2)			2
a = 2
print(a)			2
print('hello')		hello  		python自动识别括号里面的''和""并消去
b = 'hi'
print(b)			hi
data = [2,4,'hello',True]		一个逗号就代表一个数据，从0开始，data[0]就是2
print(data)			[2,4,'hello',True]	会把data这个列表的所有信息全部打印
print(data[0])		2  打印第0个元素，从左到右是正索引，也就是之前学的
print(data[-4])		2	打印倒数第4个元素，从右往左数，从-1开始
	[2,4,'hello',True]
     0 1    2     3   从左到右
    -4 -3   -2    -1  从右往左
  • 连续打印多个内容
python 复制代码 
print('hello',2)   			hello 2

用逗号隔开，实现打印多个字符串

  • 拼接连续打印的字符串
python 复制代码 
print('hello' + str(2))  // str是字符串类型，这里是把类型强制转换成字符串了，不然会报错

用加号连接，使字符串连续

运行程序 ctrl+shift+f10

命名规范：字母，数字，下划线 开头不能是数字

尽量简单易懂，见名知意，和c语言教的那个差不多，不能是关键字啥的

注释： ctrl+？

字典 键key：值value

通过键，访问值，键和值对应形成键值对（一个名称而已）

python 复制代码 
preson = {'name':'张三','职位':'工程师'}			用逗号隔开存放多个键值对

print(preson['name'])		张三

一个键可以对应一个列表，这个列表可以存放多个信息，比如
singer = {'name':'zjl','songs':['七里香','本草纲目']}   用[]表示一个列表，再用单引号写具体的字符串
然后用数组的形式打印
print(singer)					{'name':'zjl','songs':['七里香','本草纲目']}
print(singer['name'])			zjl
print(singer['song'])		    ['七里香','本草纲目']
print(singer['song'][0])		七里香

上面分别是
打印整个字典
打印一个键，这个键对应一个值
打印一个键，对应的一个列表
打印一个键，对应列表的一个元素

修改字典的信息

python 复制代码 
singer['name'] = 'mff'
singer['songs'][0] = '忍者'

字典添加一个键值对

python 复制代码 
singer['年龄'] = 30

默认加在字典中已有键值对的后面

字典删除一个键值对

python 复制代码 
del singer['年龄']

实操案例--获取实时天气预报

  1. 引入模块 import
    1. requests 通过网址请求信息
    2. pprint 格式化信息
    3. 把字符串转换成字典类型
  2. 填写网址链接
    1. q=cangzhou，这个等号后面的拼音就是想要获得的城市的拼音
    2. APPID=f0c3eda7aa680434e17ae00aa2fba619等号后面的这一串是我自己的api密匙，需要去openweather官网自己注册
  3. 存放网址返回的数据

​ 我放在了data中

  1. 处理返回的数据
    1. 把字符串转成字典 json
    2. 再把杂乱的字典格式化一下 pprint
  2. 再把有用的数据打印出来就完了
python 复制代码 
import requests
import pprint # 把杂乱的数据格式化，本次是把data_json字典的数据格式化，方便我们自己使用数据
import json # 把像字典的字符串转成字典类型，以便后续的访问 python自带的

url ='http://api.openweathermap.org/data/2.5/weather?q=cangzhou&mode=json&units=metric&lang=zh_cn&APPID=f0c3eda7aa680434e17ae00aa2fba619'

data = requests.get(url)
# print(data) # 获取到<Response [200]>，这个信息，说明requests模块向上面这个网址发送请求，得到了正确信息

# print(data.text) # 查看获取到的内容,以text的格式查看data获取到的信息，此时是一个特大的字符串

data_json = json.loads(data.text) # 把data数据的text格式的内容转换成字典储存在data_json中

# print(type(data_json))  # data_json是dict的类型，即字典类型

pprint.pprint(data_json) # 格式化data_json的数据

# 然后就是提取信息了，用键值对的形式

temp = data_json['main']['temp'] # 挑出温度
city = data_json['name']
weather = data_json['weather'][0]['description']

print(city + '市的温度是' + str(temp) + '℃' + ' 天气状况是：' + weather)

字符串

空字符串的布尔值是0，false

转移字符

在拼写文件地址的时候，有很多斜杆来分割，构成了转移字符，在字符串前面加一个小写的r，就可以取消字符串的转义字符了

python 复制代码 
print('D:\a\asda')
# 修改一下
print(r'D:\a\asda')

字符串占位符

在字符串中写上{}这个花括号，进行占位，再配合format函数，把数据填充进去

python 复制代码 
# 字符串占位符，用{}占位，配合format函数，和%d一样，这个更好用
temp=23
station='小雨'
s1='温度是:' + str(temp) + '度'
print(s1)
s2='温度是:{}度，天气状况是：{}'.format(temp,station)
print(s2)
他们的打印效果是一样的，而且s2更直观，更好修改


# 通过format函数来简化之前天气预报的url的城市和id输入
city='shenzhen'
id='f0c3eda7aa680434e17ae00aa2fba619'
url ='http://api.openweathermap.org/data/2.5/weather?q={}&mode=json&units=metric&lang=zh_cn&APPID={}'.format(city,id)
print(url)

这里我们把对应的城市名的部分和id部分抠出来，再用占位符，后续就可以很方便的修改和使用了

字符串与列表

对于一个字符串可以按字母或者汉字标号

比如，Python爬虫工程师

python 复制代码 
s3 = 'Python爬虫工程师'
print(s3[0])		这是s3字符串的第0个字符，也就是P
print(s3[-1])		这是倒数第一个字符
print(s3[0:6])		这是从第0位到第6位，左开右闭，不打印第6位
print(s3[:6])		如果冒号前面不写，默认是从0开始
print(s3[6:12])		从6位到12位的内容
print(s3[6:])		从6位往后的所有内容
print(s3[6:8])		从6到8位，8不算

# P
# 师
# Python
# Python
# 爬虫工程师
# 爬虫工程师
# 爬虫

判断字符串的子串 index

用index函数，在这个函数里面填充子字符串，配合这个函数放在字符串的后面

如果在字符串中能找到子字符串，就会返回子字符串在字符串的起始位置（从0位开始）,否则程序会报错

python 复制代码 
s3 = 'Python爬虫工程师'
print(s3.index('Python'))		0
print(s3.index('爬虫'))		   6
print(s3.index('123'))			error

比较字符串的开头和结尾startswith/endswith

给你一个字符串判断前面几位或者后几位是什么东西

如果原字符串和比较的字符串相同，就返回Ture，否则位False

python 复制代码 
email = '123456@qq.com'
# 比较开头
print(email.startswith('123'))		Ture
print(email.startswith('1123'))		False
# 比较结尾
print(email.endswith('qq.com'))		Ture

字符串的长度函数len

python 复制代码 
email = '123456@qq.com'
print(len(email)) 				13

就是求字符串的长度

字符串列表化list

python 复制代码 
email = '123456@qq.com'
email_list = list(email)
print(email_list)		['1', '2', '3', '4', '5', '6', '@', 'q', 'q', '.', 'c', 'o', 'm']
# 效果就是下面这个
email_list = list(email)
email_list = ['1', '2', '3', '4', '5', '6', '@', 'q', 'q', '.', 'c', 'o', 'm']

使用list函数把字符串拆分成单个元素在新的变量里面

列表合并join

python 复制代码 
email_list = ['1', '2', '3', '4', '5', '6', '@', 'q', 'q', '.', 'c', 'o', 'm']
print("".join(email_list))   123456@qq.com
print(''.join(email_list))   123456@qq.com

在一个空的引号后面使用join函数，把括号里面的列表拼接成完整字符串

单引号和双引号都可以

input获取信息

python 复制代码 
s5=input('请输入邮箱：')
print('邮箱号是：{}'.format(s5))

改进实时天气

python 复制代码 
import requests
import pprint 
import json 

city=input("请输入你所在的城市：")
id='f0c3eda7aa680434e17ae00aa2fba619'
url ='http://api.openweathermap.org/data/2.5/weather?q={}&mode=json&units=metric&lang=zh_cn&APPID={}'.format(city,id)

data = requests.get(url)
data_json = json.loads(data.text) 
pprint.pprint(data_json) 

print("{}市的温度是{}度，现在的天气状况是：{}，今天的气温是：{}到{}度".format(city,data_json['main']['temp'],data_json['weather'][0]['description'],data_json['main']['temp_max'],data_json['main']['temp_min']))

列表的增删查改

  • 增加列表元素append(元素)

​ 默认加在列表的队尾

​ 在使用append接口之前要确保列表是已存在的，空列表也行，否则报错

  • 删除列表元素del + list元素位置

  • 查看某位元素list位次

  • 改，直接把元素调出来当变量用

  • max函数取列表最大

  • min函数取列表最小

  • sort函数对列表进行排序

  • sort(reverse=True) 给sort里面加点条件就是逆序

python 复制代码 
ls1=[1,6,8,5,12,-3,0]
print(ls1)

print(ls1[0])
print(ls1[-1])
print(ls1[:4])
print(ls1[4:6])
print(ls1[4:])			和字符串一样的操作

#      start:end:step
#   开始：结尾：步长（间隔）
print(ls1[0:6:2])		第一个参数是起始位置，第二个是结束位置，第三个是间隔多少取一次元素

print(len(ls1))
print(max(ls1))			找列表中最大的元素
print(min(ls1))			找列表中最小的元素
ls1.sort()			对列表进行排序，从小到大
print(ls1)

ls1.sort(reverse=True)		对列表逆向排序，从大到小
print(ls1)

ls1.append(50)		增加列表元素，默认在队尾
ls1.append(51)
print(ls1)

del ls1[0]			删除列表元素
print(ls1)

ls1[0]=99			修改列表元素
print(ls1)

判断语句if else elif

python 复制代码 
a = 3
b = 2

# 只有一个if，叫单分支
if a>b:
    print(a)

b = 5
# if配合else，就是双分支
if a>b:
    print(a)
else:
    print(b)

# 有if和elif配合else就是多分支
sorce=86
if sorce>=90:
    print('A')
elif sorce>=80:
    print('B')
    print('s')
elif sorce>=60:
    print('C')
else:
    print('D')

在python里面不用写{}来限制满足条件后执行那些语句，只需要回车就行，就像sorce大于80的情况一样

if 后面也不用加括号了，只需要在条件后面加个冒号就行剩下的语句按个tab分割一下就行

循环语句 for + 变量名 + in + 范围：

python 复制代码 
# 列表
list1 = [25,65,33,61,56,8,56]
for i in list1:
    print(i)
#25 65 33 61 56 8 56

# 字符串
str1 = 'hello world'
for i in str1:
    print(i)
    
# h e l l o  w o r l d

for（关键词）+ i （变量）+in（关键词）+ 范围（最后的冒号，也是关键词）：

循环语句与字典

python 复制代码 
list2 = {'A':1,'B':2,'C':3}
for key,value in list2.items():
    print(key,value)
A 1
B 2
C 3
for key in list2.keys():
    print(key)
A
B
C
for value in list2.values():
    print(value)
1
2
3
  • 使用函数items获取字典里面的键值对，并依次赋值给前面的两个变量，分别赋值key和value
  • 使用keys这个函数，可以只获取字典里面的键
  • 使用values这个函数，只获取字典里面的值

range(start,end,step)函数生成序列

使用range函数，生成一个序列，

  • 不是列表，

  • 用逗号隔开

  • 也是左闭右开

python 复制代码 
a = range(1,10,2) #有三个参数的时候是 start,end,step     左闭右开，取不到end
#   range(1,10)    有两个参数的时候是 start,end         默认步长是1
#   range(10)    只有一个参数就是 end                   默认从0开始
print(a)	range(1, 10, 2)

# 序列列表化
b = list(a)
print(b)	[1, 3, 5, 7, 9]

range函数生成的不是完整的列表，是一个范围，想要直接打印，需要列表化

求和函数sum

这个函数会自动对参数求和

python 复制代码 
# 比如，从1到100，求和，可以用for循环，也可以是sum函数 
total = 0
for i in range(1,101):
    total += i
    # total = total + i
print(total)

# 求和函数--sum
print(sum(range(1,101)))

# 应用
# 求1到100所有的奇数和
total = 0
for i in range(1,101,2):
    total += i
print(total)

print(sum(range(1,101,2)))

# 求1到100所有的偶数和
total = 0
for i in range(2,101,2):
    total += i
print(total)

print(sum(range(2,101,2)))

元组()

元组就是不可修改的列表，用法一样

python 复制代码 
list1 = [1,2,3,4,5,6,7,8,9] 	列表
list2 = (1,2,3,4,5,6,7,8,9)		元组

元组是（圆括号），列表是方括号

while循环

**while+条件语句： ** 条件语句成立就执行while

**while + not + 条件语句： ** 条件语句不成立就执行while

和c语言的用法一样，满足条件时循环，否则就跳出

python 复制代码 
a = 10
while a>0:
    print(a)
    a -= 1


user = ''   # 空语句的布尔值是False
# 检测用户名
while not user:         # 如果user是空的，就是假，再配合not，就是假假为真
    user = input('请输入用户名：')

print('你好，{}'.format(user))

遍历列表

python 复制代码 
list1 = [65,13,54,16,8]
i = 0
while i < len(list1):
    if list1[i] % 2 != 0:
        print(list1[i])
    i += 1

跳出循环 break/continue

break跳出整个循环体

在for-in或者while中，用一个if判断，来决定break语句是否执行，一旦执行，循环体结束

continue跳出本次循环，不妨碍下一轮循环

在for-in或者while中，用一个if判断，来决定continue语句是否执行，如果条件符合，这一轮的循环结束，不影响下一轮

函数

函数分类

  1. 内置函数 python自带的

  2. 自定义函数 程序员手搓的

  3. 模块函数 库文件中的函数

自定义函数--def+函数名（参数）

  • 函数的四种常见形式
python 复制代码 
# 无参无返回值
def are1():
    print(3.14*5*5)
# 有参无返回值
def are2(r):
    print(3.14*r*r)
# 无参有返回值
def are3():
    return 3.14*5*5
# 有参有返回值
def are4(r):
    return 3.14*r*r
# 调用方法
are1()
are2(5)
print(are3())
print(are4(5))

作用域

函数体内定义的局部变量，不能全局使用

全局变量可以在函数体内使用

局部变量优先于全局变量

global局部变量变成全局变量

使用global声明局部变量，就会影响下面的全局变量

使用global之后，也可以在函数体外面使用了

类和对象

class + 类名： 定义一个类

命名规则

定义函数第一个字母小写

定义类，第一个字母大写

类的实例化，类的创建

在类里面使用def关键字，加上两个下划线，选择_ _init _ _对类进行初始化，给这个对象填充属性

参数里面的self不用管，这个参数就是对象他自己，就像c++那个内置函数一样，都会偷偷干活，不用管

self是隐藏参数，直接忽视

在python里面f'{self.name}'和'{}'.format(self.name)这两种方式的效果一样

虽然这两种方式在结果上是相同的，但它们有一些不同之处：

  1. 可读性 ：
    • f-string（格式化字符串字面量）通常被认为更具可读性，尤其是在插入多个变量时。
  2. 性能 ：
    • f-string 在性能上略有优势，通常更快。
  3. Python 版本 ：
    • f-string 从 Python 3.6 开始引入，而 str.format() 在 Python 2.7 和 3.0 中都可以使用。

给类对象增加属性

直接在对象后面写属性，并赋值，就可以了

python 复制代码 
# 增加类的属性
aaa.height=180
print(aaa.height)

这个属性在设计的时候不存在，也只有这一个对象才多出来一个属性

python 复制代码 
# 类--人
class People:
    # 初始化
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        print('初始化结束')
	# 自定义函数，这个参数是缺一不可的，也就是内联函数的指针
    def data(self):
        print(self.name,self.age,self.sex)

    def speak(self):
        print('{}正在说话'.format(self.name))

# 创建对象--类的实例化
aaa = People('zhangsan',15,'nan')
bbb = People('lisi',18,'nu')
# 调用对象的信息
aaa.data()
bbb.data()
# 修改对象的值
aaa.name = 'xiaozhang'
aaa.data()

aaa.speak()

# 增加类的属性
aaa.height=180
print(aaa.height)

# 打印
初始化结束
初始化结束

zhangsan 15 nan
lisi 18 nu

xiaozhang 15 nan

xiaozhang正在说话

180

继承类

python 复制代码 
# 父类
class student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def study(self):
        print(f'{self.name}会学习')
# 子类---人工智能学生
class AI_student(student):
    def biancheng(self):
        print(f'{self.name}要学习AI了')
# 子类---机器设计学生
class JQ_student(student):
    def sheji(self):
        print(f'{self.name}会设计')

zhangsan = AI_student('张三',18,'男')
lisi = JQ_student('李四',19,'男')

zhangsan.study()		使用父类的函数
lisi.study()

zhangsan.biancheng()	使用子类的函数
lisi.sheji()

张三会学习
李四会学习
张三要学习AI了
李四会设计

对于一些类来说，有一些相同的属性，如果每个类都写这些属性，就会代码冗余，质量太差

所以，把这部分抽离出来，做成一个父类

其他一些特性，做成子类

就像上面的student这个类，是父类，包含姓名，年龄，性别

而子类，有人工智能学生和机器设计学生，他们分别又独立的会学习ai或设计机器

子类只需要在参数里面写上父类名，就可以继承父类的属性了

派生类super

针对的问题是：继承类无法创建子类自己的属性

利用super，可以在子类里面再初始化的时候增加自己的属性

python 复制代码 
class student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def study(self):
        print(f'{self.name}会学习')

class AI_student(student):
    def __init__(self,name,age,sex,score,major):	参数按顺序补全，在后面加上自己的参数
        super().__init__(name,age,sex)				利用super直接借用父类的初始化函数
        self.score = score							再对自己独特的参数初始化
        self.major = major

    def learn(self):
        print(f'{self.name}的专业是：{self.major},成绩是：{self.score}')	发现可以使用父类的参数也可以使用子类参数



zhangsan = AI_student('张三',18,'男',100,'python')

zhangsan.study()

zhangsan.learn()

类对象的优先级

使用变量时的优先级：

实例化的对象 > 子类里面定义的 > 父类定义 > 系统默认

zhangsan.name> AI_student.name> student.name>...

空语句占位符pass

比如，写了一个if语句，给他一个条件，但是目前不知道要他干啥，程序又必须有一个可以执行的命令，所以用pass占位，告诉程序你没错，目前用不到而已

多态---函数重载

就是在同时含有子类和父类的程序里面，调用变量的时候，程序可以自行选择子类

python 复制代码 
# 父类
class Animal:
    def speak(self):
        print('叫')

# 子类
class DDog(Animal):
    def speak(self):
        print('wangwangwang')

class CCat(Animal):
    def speak(self):
        print('mimimi')

dog=DDog()
cat = CCat()

dog.speak()
cat.speak()

# 多态
def speak(Anmail):
    Anmail.speak()

speak(dog)
speak(cat)

就像之前，使用len函数求长度的时候，既可以求字符串的长度，也可以求数列的长度，还可以求字典元素的个数，
就像c++里面的那个函数重载一样，同一个函数名，不同的参数，程序会根据你给的参数自动配对相应的函数

len('adsad')
len([1,2,3,5,4])
len({'a':1,'b':2})

_ _私有变量

就是对类里面的成员变量进行限制，不允许外部变量访问和修改

在创建类成员变量的时候前面加两个下划线

把self.name改成self._ _name 这里加上了一个空格，是为了方便观看

通过这个方法，哪怕外部使用双划线加变量名，也访问不到

唯一的方法，就是在外部调用的时候，在双划线的成员变量前面再加上类的名称

比如，dog.name >>> dog.__name >>> dog._Anmail__name

这上面三个，只有最后面的那个可以访问和修改类里面的成员变量

异常捕获 try except else finally

把可能出错的语句，写在try语句里面，假如真的出现异常，就执行except语句，没用出现异常就执行else里面的语句，

最后无论发生哪种情况都会执行finally里面的语句

就是说，try是个条件语句，这个语句很危险，为了防止程序运行到此处崩溃，就给了两个选项，告诉程序，如果try里面的语句挂了，就执行except的语句，否则就是else，无论哪种情况都要执行finally语句

有始有终

好处就是，程序不会挂掉，会继续按照代码执行完程序

主要针对的问题，是在以后使用爬虫的时候，可以判断出了什么问题，比如服务器崩了，或者之前代码有误等等

相当于一种程序自动调试，自己处理遇到的问题

python 复制代码 
a=1
b=2
try: 
    c=a/b
except:
    print('error')
else:
    print('a/b={}'.format(c))
finally:
    print('程序结束')
    
# a/b=0.5 程序结束
    
a=1
b=2
try: 				b不能为0
    c=a/b
except:
    print('error')
else:
    print('a/b={}'.format(c))
finally:
    print('程序结束')
    
# error  程序结束
    

b=2
try: 			少一个变量
    c=a/b
except:
    print('error')
else:
    print('a/b={}'.format(c))
finally:
    print('程序结束')
# error  程序结束

文件读取

使用open函数，把绝对/完整路径放到第一个参数就可以打开文件了

第二个参数是：mode='r'，意思就是以读的形式打开一个文件

第三个参数是：encoding='utf-8' 这是一种文件打开的编码方式

f.read()

一次读取整个文件

f.readline()

一次读取一行

f.readlines()

也是一次读取整个文件，只是把文件内容放进一个列表里面

while循环读取文件每一行

使用while语句，再搭配读一行的函数，就可以分批循环读取数据了

python 复制代码 
# 打开文件
f = open(r'E:\pycharmxiangmu\pythonProject2\abc',mode='r',encoding='utf-8')


# 文件操作
# 读全部
txt = f.read()
print(txt)
# 读一行
txt = f.readline()      # 111
# 读全部，并转换成列表
txt = f.readlines()     # ['111\n', '222\n', '333']
print(txt)



while txt:
    txt = f.readline()
    print(txt)

111

222

333   发现是有空行的，因为print函数自动换行，在文件里面也有换行符，所以要消掉一个
while txt:
    txt = f.readline()
    print(txt,end='')   # 让print里面end的换行符为空，就不会换行了

# 关闭文件
f.close()

# 检查是否关闭文件
print(f.closed)     # 如果已经关闭文件，返回True，否则False

with as: 读取文件，文件操作完成之后自动关闭文件

python 复制代码 
# 打开文件
with open(r'E:\pycharmxiangmu\pythonProject2\abc',mode='r',encoding='utf-8') as f:
    # 文件操作
    # 读一行
    txt = f.readline()    
    print(txt, end='')
    while txt:
        txt = f.readline()
        print(txt,end='')   


# 检查是否关闭文件
print(f.closed)     # True  成功关闭

用 with + open() + as + 变量名： 完成对文件的打开

然后对文件操作的过程全部tab一下

最后自动关闭文件

写入文件

python 复制代码 
# 以只读的形式打开文件abc.txt，并把文件指针放在f
f = open(r'E:\pycharmxiangmu\pythonProject2\abc.txt',mode='r',encoding='utf-8')
# 以只写的方式创建一个文件abc1.txt
f1 = open(r'E:\pycharmxiangmu\pythonProject2\abc1.txt',mode='w',encoding='utf-8')
# 以追加的方式打开文件abc1.txt
f1 = open(r'E:\pycharmxiangmu\pythonProject2\abc1.txt',mode='a',encoding='utf-8')

txt = f.readline() txt只获取一行的内容

while txt:			判断txt不为空
    f1.write(txt)	把txt的内容写入f1的文件中
    txt = f.readline()  txt再读下一行

f.close()
f1.close()

write与writelines

writelines会把列表以字符串的形式写在文件里，

而write只能填写字符串，或者把列表类型转换成字符串，但是write会把整个列表写入

打包文件

步骤

找到pyinstaller的安装路径，也就是这个库所在的文件夹

  • 找到python的安装文件夹
    • 打开Lib
      • 再打开site-packages
        • 最后找到库文件PyInstaller，再点开，就是库文件夹了

把想要打包的文件拷贝到库文件里面

再从网上找一个图片，自己转换成ico的后缀，这个后缀就是图标专用后缀

再打开命令行

使用命令语句打包：

  • 打包成一个exe文件：pyinstaller -i 111.ico -F -c 111.py
  • 打包成一个文件夹：pyinstaller -i 111.ico -D -c 111.py

​ pyinstaller

​ -i 的意思是设置图标

​ 111.ico 你想要设置的图标名称

​ -F 就是exe文件

​ -c 是说明有窗口

​ 最后是你想要打包的文件

然后就会在一个dist的文件里面生成好了

上面那个流程是正确的但是出了点小问题，需要调整参数如下

复制代码 
pyinstaller --onefile --hidden-import=requests --icon=D:\Python\Python312\Lib\site-packages\PyInstaller\111.ico hello.py

以下是您提供的 `pyinstaller` 命令的参数解释：

### 参数解释

1. **`pyinstaller`**:
   - 这是调用 PyInstaller 工具的命令。

2. **`--onefile`**:
   - 这个选项指示 PyInstaller 将所有文件打包成一个单独的可执行文件（`.exe`）。没有这个参数时，PyInstaller 将创建一个包含多个文件和资源的文件夹。
   
这个参数就可以调整为-F和-D了，使用-F或者-D可以使打包速度更快

3. **`--hidden-import=requests`**:
   - 此参数指定了一个隐式依赖项。某些库可能在运行时被动态导入，PyInstaller 可能无法自动检测到它们。通过使用此参数，您可以确保 `requests` 模块被包含在打包文件中。
我感觉应该是我的电脑没找到我的库在哪里，需要额外声明一下   


4. **`--icon=D:\Python\Python312\Lib\site-packages\PyInstaller\111.ico`**:
   - 这个选项允许您为生成的可执行文件指定一个图标。在这个例子中，路径 `D:\Python\Python312\Lib\site-packages\PyInstaller\111.ico` 是图标文件的位置。图标必须是 `.ico` 格式。
这个就是我想要设置的图标的绝对路径


5. **`hello.py`**:
   - 最后，这是要打包的 Python 脚本的文件名。PyInstaller 将分析这个文件，并根据文件中的代码生成可执行文件。

### 总结

这个命令通过将 `hello.py` 打包成一个单独的可执行文件，确保 `requests` 库被正确导入，并且为最终的 `.exe` 文件指定了一个自定义图标。
相关推荐
笨鸟先飞，勤能补拙4 小时前
AI 赋能网络安全：技术全景、成熟度评估与实战案例
人工智能·python·安全·web安全·网络安全·sqlite·github
长和信泰光伏储能5 小时前
京津冀光伏发电：绿色能源的未来之路
python·能源
浦信仿真大讲堂5 小时前
从重复操作到自动化闭环：如何让 CST 与 Python 真正协同起来
python·自动化·cst·仿真软件·达索软件
Gu Gu Study6 小时前
ScoutLoop开放域深度研究引擎（agent的初步设计想法）
人工智能·python
卷无止境6 小时前
写代码这件事，到底该讲究点什么？
后端·python
卷无止境6 小时前
循环复杂度到底在算什么，Python 代码怎么才能写得让人一看就懂
后端·python
lpfasd1236 小时前
MediaCrawler 项目深度分析
chrome·python·chrome devtools
Dxy12393102167 小时前
Python项目打包成EXE完整教程（PyInstaller实战避坑）
开发语言·python
bamb007 小时前
一个项目带你入门AI应用开发01
python
0566468 小时前
Python康复训练——常用标准库
开发语言·python·学习
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02GitHub 镜像站点03国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）042026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片05微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08AI科技热点日报 | 2026年07月01日09Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费102026 年 AI 大模型 & AI 编程工具实战全总结