python

变量

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

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

变量类型

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

  • 同c语言类型:

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

输出

print()

  • 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  从右往左
  • 连续打印多个内容
print('hello',2)   			hello 2

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

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

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

运行程序 ctrl+shift+f10

命名规范:字母,数字,下划线 开头不能是数字

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

注释: ctrl+?

字典 键key:值value

通过键,访问值,键和值对应形成键值对(一个名称而已)

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])		七里香

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

修改字典的信息

singer['name'] = 'mff'
singer['songs'][0] = '忍者'

字典添加一个键值对

singer['年龄'] = 30

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

字典删除一个键值对

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. 再把有用的数据打印出来就完了
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,就可以取消字符串的转义字符了

print('D:\a\asda')
# 修改一下
print(r'D:\a\asda')

字符串占位符

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

# 字符串占位符,用{}占位,配合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爬虫工程师

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

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

判断字符串的子串 index

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

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

s3 = 'Python爬虫工程师'
print(s3.index('Python'))		0
print(s3.index('爬虫'))		   6
print(s3.index('123'))			error

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

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

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

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

字符串的长度函数len

email = '123456@qq.com'
print(len(email)) 				13

就是求字符串的长度

字符串列表化list

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

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获取信息

s5=input('请输入邮箱:')
print('邮箱号是:{}'.format(s5))

改进实时天气

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里面加点条件就是逆序

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

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 + 范围:

# 列表
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(关键词)+ 范围(最后的冒号,也是关键词):

循环语句与字典

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函数,生成一个序列,

  • 不是列表,

  • 用逗号隔开

  • 也是左闭右开

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

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

# 比如,从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)))

元组()

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

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语言的用法一样,满足条件时循环,否则就跳出

a = 10
while a>0:
    print(a)
    a -= 1


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

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

遍历列表

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+函数名(参数)

  • 函数的四种常见形式
# 无参无返回值
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 中都可以使用。

给类对象增加属性

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

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

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

# 类--人
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

继承类

# 父类
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,可以在子类里面再初始化的时候增加自己的属性

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占位,告诉程序你没错,目前用不到而已

多态—函数重载

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

# 父类
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语句

有始有终

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

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

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

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语句,再搭配读一行的函数,就可以分批循环读取数据了

# 打开文件
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: 读取文件,文件操作完成之后自动关闭文件

# 打开文件
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一下

最后自动关闭文件

写入文件

# 以只读的形式打开文件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` 文件指定了一个自定义图标。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部