python爬虫底子

python


  
变量

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

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

复制代码

变量范例

• 用type()函数，获取括号里面的数据范例
  
• 同c语言范例：
     int整型float浮点型str字符串True/False布尔型，只有真假list列表形
  

输出

print()

• python自动识别括号里面的‘’和“”并消去
  

1. print(2)                        2
2. a = 2
3. print(a)                        2
4. print('hello')                hello                  python自动识别括号里面的‘’和“”并消去
5. b = 'hi'
6. print(b)                        hi
7. data = [2,4,'hello',True]                一个逗号就代表一个数据，从0开始，data[0]就是2
8. print(data)                        [2,4,'hello',True]        会把data这个列表的所有信息全部打印
9. print(data[0])                2  打印第0个元素，从左到右是正索引，也就是之前学的
10. print(data[-4])                2        打印倒数第4个元素，从右往左数，从-1开始
11.         [2,4,'hello',True]
12.      0 1    2     3   从左到右
13.     -4 -3   -2    -1  从右往左

复制代码

• 连续打印多个内容
  

1. print('hello',2)                           hello 2

复制代码

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

• 拼接连续打印的字符串
  

1. print('hello' + str(2))  // str是字符串类型，这里是把类型强制转换成字符串了，不然会报错

复制代码

用加号连接，使字符串连续
运行步伐 ctrl+shift+f10

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

只管简单易懂，见名知意，和c语言教的那个差不多，不能是关键字啥的
注释： ctrl+？

字典 键key：值value

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

1. preson = {'name':'张三','职位':'工程师'}                        用逗号隔开存放多个键值对
3. print(preson['name'])                张三
5. 一个键可以对应一个列表，这个列表可以存放多个信息，比如
6. singer = {'name':'zjl','songs':['七里香','本草纲目']}   用[]表示一个列表，再用单引号写具体的字符串
7. 然后用数组的形式打印
8. print(singer)                                        {'name':'zjl','songs':['七里香','本草纲目']}
9. print(singer['name'])                        zjl
10. print(singer['song'])                    ['七里香','本草纲目']
11. print(singer['song'][0])                七里香
13. 上面分别是
14. 打印整个字典
15. 打印一个键，这个键对应一个值
16. 打印一个键，对应的一个列表
17. 打印一个键，对应列表的一个元素

复制代码

修改字典的信息

1. singer['name'] = 'mff'
2. singer['songs'][0] = '忍者'

复制代码

字典添加一个键值对

1. singer['年龄'] = 30

复制代码

默认加在字典中已有键值对的背面
字典删除一个键值对

1. del singer['年龄']

复制代码

实操案例–获取及时气候预报

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

​ 我放在了data中

• 处理返回的数据
  
  
  • 把字符串转成字典 json
    
  • 再把杂乱的字典格式化一下 pprint
    
  
  
• 再把有用的数据打印出来就完了
  

1. import requests
2. import pprint # 把杂乱的数据格式化，本次是把data_json字典的数据格式化，方便我们自己使用数据
3. import json # 把像字典的字符串转成字典类型，以便后续的访问 python自带的
5. url ='http://api.openweathermap.org/data/2.5/weather?q=cangzhou&mode=json&units=metric&lang=zh_cn&APPID=f0c3eda7aa680434e17ae00aa2fba619'
7. data = requests.get(url)
8. # print(data) # 获取到<Response [200]>，这个信息，说明requests模块向上面这个网址发送请求，得到了正确信息
10. # print(data.text) # 查看获取到的内容,以text的格式查看data获取到的信息，此时是一个特大的字符串
12. data_json = json.loads(data.text) # 把data数据的text格式的内容转换成字典储存在data_json中
14. # print(type(data_json))  # data_json是dict的类型，即字典类型
16. pprint.pprint(data_json) # 格式化data_json的数据
18. # 然后就是提取信息了，用键值对的形式
20. temp = data_json['main']['temp'] # 挑出温度
21. city = data_json['name']
22. weather = data_json['weather'][0]['description']
24. print(city + '市的温度是' + str(temp) + '℃' + ' 天气状况是：' + weather)

复制代码

字符串

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

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

1. print('D:\a\asda')
2. # 修改一下
3. print(r'D:\a\asda')

复制代码

字符串占位符

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

1. # 字符串占位符，用{}占位，配合format函数，和%d一样，这个更好用
2. temp=23
3. station='小雨'
4. s1='温度是:' + str(temp) + '度'
5. print(s1)
6. s2='温度是:{}度，天气状况是：{}'.format(temp,station)
7. print(s2)
8. 他们的打印效果是一样的，而且s2更直观，更好修改
11. # 通过format函数来简化之前天气预报的url的城市和id输入
12. city='shenzhen'
13. id='f0c3eda7aa680434e17ae00aa2fba619'
14. url ='http://api.openweathermap.org/data/2.5/weather?q={}&mode=json&units=metric&lang=zh_cn&APPID={}'.format(city,id)
15. print(url)
17. 这里我们把对应的城市名的部分和id部分抠出来，再用占位符，后续就可以很方便的修改和使用了

复制代码

字符串与列表

对于一个字符串可以按字母或者汉字标号
比如，Python爬虫工程师

1. s3 = 'Python爬虫工程师'
2. print(s3[0])                这是s3字符串的第0个字符，也就是P
3. print(s3[-1])                这是倒数第一个字符
4. print(s3[0:6])                这是从第0位到第6位，左开右闭，不打印第6位
5. print(s3[:6])                如果冒号前面不写，默认是从0开始
6. print(s3[6:12])                从6位到12位的内容
7. print(s3[6:])                从6位往后的所有内容
8. print(s3[6:8])                从6到8位，8不算
10. # P
11. # 师
12. # Python
13. # Python
14. # 爬虫工程师
15. # 爬虫工程师
16. # 爬虫

复制代码

判定字符串的子串 index

用index函数，在这个函数里面填充子字符串，配合这个函数放在字符串的背面
假如在字符串中能找到子字符串，就会返回子字符串在字符串的起始位置（从0位开始）,否则步伐会报错

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

复制代码

比较字符串的开头和末了startswith/endswith

给你一个字符串判定前面几位或者后几位是什么东西
假如原字符串和比较的字符串类似，就返回Ture，否则位False

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

复制代码

字符串的长度函数len

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

复制代码

就是求字符串的长度
字符串列表化list

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

复制代码

利用list函数把字符串拆分成单个元素在新的变量里面
列表合并join

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

复制代码

在一个空的引号背面利用join函数，把括号里面的列表拼接成完整字符串
单引号和双引号都可以
input获取信息

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

复制代码

改进及时气候

1. import requests
2. import pprint
3. import json
5. city=input("请输入你所在的城市：")
6. id='f0c3eda7aa680434e17ae00aa2fba619'
7. url ='http://api.openweathermap.org/data/2.5/weather?q={}&mode=json&units=metric&lang=zh_cn&APPID={}'.format(city,id)
9. data = requests.get(url)
10. data_json = json.loads(data.text)
11. pprint.pprint(data_json)
13. 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里面加点条件就是逆序
  

1. ls1=[1,6,8,5,12,-3,0]
2. print(ls1)
4. print(ls1[0])
5. print(ls1[-1])
6. print(ls1[:4])
7. print(ls1[4:6])
8. print(ls1[4:])                        和字符串一样的操作
10. #      start:end:step
11. #   开始：结尾：步长（间隔）
12. print(ls1[0:6:2])                第一个参数是起始位置，第二个是结束位置，第三个是间隔多少取一次元素
14. print(len(ls1))
15. print(max(ls1))                        找列表中最大的元素
16. print(min(ls1))                        找列表中最小的元素
17. ls1.sort()                        对列表进行排序，从小到大
18. print(ls1)
20. ls1.sort(reverse=True)                对列表逆向排序，从大到小
21. print(ls1)
23. ls1.append(50)                增加列表元素，默认在队尾
24. ls1.append(51)
25. print(ls1)
27. del ls1[0]                        删除列表元素
28. print(ls1)
30. ls1[0]=99                        修改列表元素
31. print(ls1)

复制代码

判定语句if else elif

1. a = 3
2. b = 2
4. # 只有一个if，叫单分支
5. if a>b:
6.     print(a)
8. b = 5
9. # if配合else，就是双分支
10. if a>b:
11.     print(a)
12. else:
13.     print(b)
15. # 有if和elif配合else就是多分支
16. sorce=86
17. if sorce>=90:
18.     print('A')
19. elif sorce>=80:
20.     print('B')
21.     print('s')
22. elif sorce>=60:
23.     print('C')
24. else:
25.     print('D')

复制代码

在python里面不用写{}来限制满足条件后执行那些语句，只需要回车就行，就像sorce大于80的情况一样
if 背面也不用加括号了，只需要在条件背面加个冒号就行剩下的语句按个tab分割一下就行
循环语句 for + 变量名 + in + 范围：

1. # 列表
2. list1 = [25,65,33,61,56,8,56]
3. for i in list1:
4.     print(i)
5. #25 65 33 61 56 8 56
7. # 字符串
8. str1 = 'hello world'
9. for i in str1:
10.     print(i)
11.    
12. # h e l l o  w o r l d

复制代码

for（关键词）+ i （变量）+in（关键词）+ 范围（最后的冒号，也是关键词）：
循环语句与字典

1. list2 = {'A':1,'B':2,'C':3}
2. for key,value in list2.items():
3.     print(key,value)
4. A 1
5. B 2
6. C 3
7. for key in list2.keys():
8.     print(key)
9. A
10. B
11. C
12. for value in list2.values():
13.     print(value)
14. 1
15. 2
16. 3

复制代码

• 利用函数items获取字典里面的键值对，并依次赋值给前面的两个变量，分别赋值key和value
  
• 利用keys这个函数，可以只获取字典里面的键
  
• 利用values这个函数，只获取字典里面的值
  

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

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

• 不是列表，
  
• 用逗号隔开
  
• 也是左闭右开
  

1. a = range(1,10,2) #有三个参数的时候是 start,end,step     左闭右开，取不到end
2. #   range(1,10)    有两个参数的时候是 start,end         默认步长是1
3. #   range(10)    只有一个参数就是 end                   默认从0开始
4. print(a)        range(1, 10, 2)
6. # 序列列表化
7. b = list(a)
8. print(b)        [1, 3, 5, 7, 9]

复制代码

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

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

1. # 比如，从1到100，求和，可以用for循环，也可以是sum函数
2. total = 0
3. for i in range(1,101):
4.     total += i
5.     # total = total + i
6. print(total)
8. # 求和函数--sum
9. print(sum(range(1,101)))
11. # 应用
12. # 求1到100所有的奇数和
13. total = 0
14. for i in range(1,101,2):
15.     total += i
16. print(total)
18. print(sum(range(1,101,2)))
20. # 求1到100所有的偶数和
21. total = 0
22. for i in range(2,101,2):
23.     total += i
24. print(total)
26. print(sum(range(2,101,2)))

复制代码

元组()

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

1. list1 = [1,2,3,4,5,6,7,8,9]         列表
2. list2 = (1,2,3,4,5,6,7,8,9)                元组

复制代码

元组是（圆括号），列表是[方括号]
while循环

**while+条件语句： ** 条件语句成立就执行while
**while + not + 条件语句： ** 条件语句不成立就执行while
和c语言的用法一样，满足条件时循环，否则就跳出

1. a = 10
2. while a>0:
3.     print(a)
4.     a -= 1
7. user = ''   # 空语句的布尔值是False
8. # 检测用户名
9. while not user:         # 如果user是空的，就是假，再配合not，就是假假为真
10.     user = input('请输入用户名：')
12. print('你好，{}'.format(user))

复制代码

遍历列表

1. list1 = [65,13,54,16,8]
2. i = 0
3. while i < len(list1):
4.     if list1[i] % 2 != 0:
5.         print(list1[i])
6.     i += 1

复制代码

跳出循环 break/continue

break跳出整个循环体

在for-in或者while中，用一个if判定，来决定break语句是否执行，一旦执行，循环体结束
continue跳出本次循环，不妨碍下一轮循环

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

函数分类

• 内置函数 python自带的
  
• 自定义函数 步伐员手搓的
  
• 模块函数 库文件中的函数
  

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

• 函数的四种常见情势
  

1. # 无参无返回值
2. def are1():
3.     print(3.14*5*5)
4. # 有参无返回值
5. def are2(r):
6.     print(3.14*r*r)
7. # 无参有返回值
8. def are3():
9.     return 3.14*5*5
10. # 有参有返回值
11. def are4(r):
12.     return 3.14*r*r
13. # 调用方法
14. are1()
15. are2(5)
16. print(are3())
17. print(are4(5))

复制代码

作用域

函数体内定义的局部变量，不能全局利用
全局变量可以在函数体内利用
局部变量优先于全局变量
global局部变量变玉成局变量

利用global声明局部变量，就会影响下面的全局变量
利用global之后，也可以在函数体表面利用了
类和对象

class + 类名： 定义一个类

定名规则

定义函数第一个字母小写
定义类，第一个字母大写
类的实例化，类的创建

在类里面利用def关键字，加上两个下划线，选择_ _init _ _对类进行初始化，给这个对象填充属性
参数里面的self不用管，这个参数就是对象他自己，就像c++那个内置函数一样，都会偷偷干活，不用管
self是隐藏参数，直接忽视
在python里面f’{self.name}‘和’{}'.format(self.name)这两种方式的结果一样

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

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

给类对象增长属性

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

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

复制代码

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

1. # 类--人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()# 增加类的属性
2. aaa.height=180
3. print(aaa.height)
4. # 打印初始化结束初始化结束zhangsan 15 nanlisi 18 nuxiaozhang 15 nanxiaozhang正在说话180

复制代码

继承类

1. # 父类
2. class student:
3.     def __init__(self,name,age,sex):
4.         self.name = name
5.         self.age = age
6.         self.sex = sex
8.     def study(self):
9.         print(f'{self.name}会学习')
10. # 子类---人工智能学生
11. class AI_student(student):
12.     def biancheng(self):
13.         print(f'{self.name}要学习AI了')
14. # 子类---机器设计学生
15. class JQ_student(student):
16.     def sheji(self):
17.         print(f'{self.name}会设计')
19. zhangsan = AI_student('张三',18,'男')
20. lisi = JQ_student('李四',19,'男')
22. zhangsan.study()                使用父类的函数
23. lisi.study()
25. zhangsan.biancheng()        使用子类的函数
26. lisi.sheji()
28. 张三会学习
29. 李四会学习
30. 张三要学习AI了
31. 李四会设计

复制代码

对于一些类来说，有一些类似的属性，假如每个类都写这些属性，就会代码冗余，质量太差
以是，把这部分抽离出来，做成一个父类
其他一些特性，做成子类
就像上面的student这个类，是父类，包罗姓名，年龄，性别
而子类，有人工智能学生和机器计划学生，他们分别又独立的会学习ai或计划机器
子类只需要在参数里面写上父类名，就可以继承父类的属性了
派生类super

针对的题目是：继承类无法创建子类自己的属性
利用super，可以在子类里面再初始化的时候增长自己的属性

1. class student:
2.     def __init__(self,name,age,sex):
3.         self.name = name
4.         self.age = age
5.         self.sex = sex
7.     def study(self):
8.         print(f'{self.name}会学习')
10. class AI_student(student):
11.     def __init__(self,name,age,sex,score,major):        参数按顺序补全，在后面加上自己的参数
12.         super().__init__(name,age,sex)                                利用super直接借用父类的初始化函数
13.         self.score = score                                                        再对自己独特的参数初始化
14.         self.major = major
16.     def learn(self):
17.         print(f'{self.name}的专业是：{self.major},成绩是：{self.score}')        发现可以使用父类的参数也可以使用子类参数
21. zhangsan = AI_student('张三',18,'男',100,'python')
23. zhangsan.study()
25. zhangsan.learn()

复制代码

类对象的优先级

利用变量时的优先级：
实例化的对象 > 子类里面定义的 > 父类定义 > 体系默认
zhangsan.name> AI_student.name> student.name>…
空语句占位符pass

比如，写了一个if语句，给他一个条件，但是目前不知道要他干啥，步伐又必须有一个可以执行的命令，以是用pass占位，告诉步伐你没错，目前用不到而已
多态—函数重载

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

1. # 父类
2. class Animal:
3.     def speak(self):
4.         print('叫')
6. # 子类
7. class DDog(Animal):
8.     def speak(self):
9.         print('wangwangwang')
11. class CCat(Animal):
12.     def speak(self):
13.         print('mimimi')
15. dog=DDog()
16. cat = CCat()
18. dog.speak()
19. cat.speak()
21. # 多态
22. def speak(Anmail):
23.     Anmail.speak()
25. speak(dog)
26. speak(cat)
28. 就像之前，使用len函数求长度的时候，既可以求字符串的长度，也可以求数列的长度，还可以求字典元素的个数，
29. 就像c++里面的那个函数重载一样，同一个函数名，不同的参数，程序会根据你给的参数自动配对相应的函数
31. len('adsad')
32. len([1,2,3,5,4])
33. 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语句
善始善终
好处就是，步伐不会挂掉，会继续按照代码执行完步伐
主要针对的题目，是在以后利用爬虫的时候，可以判定出了什么题目，比如服务器崩了，或者之前代码有误等等
相当于一种步伐自动调试，自己处理碰到的题目

1. a=1
2. b=2
3. try:
4.     c=a/b
5. except:
6.     print('error')
7. else:
8.     print('a/b={}'.format(c))
9. finally:
10.     print('程序结束')
11.    
12. # a/b=0.5 程序结束
13.    
14. a=1
15. b=2
16. try:                                 b不能为0
17.     c=a/b
18. except:
19.     print('error')
20. else:
21.     print('a/b={}'.format(c))
22. finally:
23.     print('程序结束')
24.    
25. # error  程序结束
26.    
28. b=2
29. try:                         少一个变量
30.     c=a/b
31. except:
32.     print('error')
33. else:
34.     print('a/b={}'.format(c))
35. finally:
36.     print('程序结束')
37. # error  程序结束

复制代码

文件读取

利用open函数，把绝对/完整路径放到第一个参数就可以打开文件了
第二个参数是：mode=‘r’，意思就是以读的情势打开一个文件
第三个参数是：encoding=‘utf-8’ 这是一种文件打开的编码方式
f.read()

一次读取整个文件
f.readline()

一次读取一行
f.readlines()

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

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

1. # 打开文件
2. f = open(r'E:\pycharmxiangmu\pythonProject2\abc',mode='r',encoding='utf-8')
5. # 文件操作
6. # 读全部
7. txt = f.read()
8. print(txt)
9. # 读一行
10. txt = f.readline()      # 111
11. # 读全部，并转换成列表
12. txt = f.readlines()     # ['111\n', '222\n', '333']
13. print(txt)
17. while txt:
18.     txt = f.readline()
19.     print(txt)
21. 111
23. 222
25. 333   发现是有空行的，因为print函数自动换行，在文件里面也有换行符，所以要消掉一个
26. while txt:
27.     txt = f.readline()
28.     print(txt,end='')   # 让print里面end的换行符为空，就不会换行了
30. # 关闭文件
31. f.close()
33. # 检查是否关闭文件
34. print(f.closed)     # 如果已经关闭文件，返回True，否则False

复制代码

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

1. # 打开文件
2. with open(r'E:\pycharmxiangmu\pythonProject2\abc',mode='r',encoding='utf-8') as f:
3.     # 文件操作
4.     # 读一行
5.     txt = f.readline()   
6.     print(txt, end='')
7.     while txt:
8.         txt = f.readline()
9.         print(txt,end='')   
12. # 检查是否关闭文件
13. print(f.closed)     # True  成功关闭

复制代码

用 with + open() + as + 变量名： 完成对文件的打开
然后对文件操作的过程全部tab一下
最后自动关闭文件
写入文件

1. # 以只读的形式打开文件abc.txt，并把文件指针放在f
2. f = open(r'E:\pycharmxiangmu\pythonProject2\abc.txt',mode='r',encoding='utf-8')
3. # 以只写的方式创建一个文件abc1.txt
4. f1 = open(r'E:\pycharmxiangmu\pythonProject2\abc1.txt',mode='w',encoding='utf-8')
5. # 以追加的方式打开文件abc1.txt
6. f1 = open(r'E:\pycharmxiangmu\pythonProject2\abc1.txt',mode='a',encoding='utf-8')
8. txt = f.readline() txt只获取一行的内容
10. while txt:                        判断txt不为空
11.     f1.write(txt)        把txt的内容写入f1的文件中
12.     txt = f.readline()  txt再读下一行
14. f.close()
15. 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的文件里面生成好了
上面那个流程是正确的但是出了点小题目，需要调整参数如下

1. pyinstaller --onefile --hidden-import=requests --icon=D:\Python\Python312\Lib\site-packages\PyInstaller\111.ico hello.py
3. 以下是您提供的 `pyinstaller` 命令的参数解释：
5. ### 参数解释
7. 1. **`pyinstaller`**:
8.    - 这是调用 PyInstaller 工具的命令。
10. 2. **`--onefile`**:
11.    - 这个选项指示 PyInstaller 将所有文件打包成一个单独的可执行文件（`.exe`）。没有这个参数时，PyInstaller 将创建一个包含多个文件和资源的文件夹。
12.    
13. 这个参数就可以调整为-F和-D了，使用-F或者-D可以使打包速度更快
15. 3. **`--hidden-import=requests`**:
16.    - 此参数指定了一个隐式依赖项。某些库可能在运行时被动态导入，PyInstaller 可能无法自动检测到它们。通过使用此参数，您可以确保 `requests` 模块被包含在打包文件中。
17. 我感觉应该是我的电脑没找到我的库在哪里，需要额外声明一下   
20. 4. **`--icon=D:\Python\Python312\Lib\site-packages\PyInstaller\111.ico`**:
21.    - 这个选项允许您为生成的可执行文件指定一个图标。在这个例子中，路径 `D:\Python\Python312\Lib\site-packages\PyInstaller\111.ico` 是图标文件的位置。图标必须是 `.ico` 格式。
22. 这个就是我想要设置的图标的绝对路径
25. 5. **`hello.py`**:
26.    - 最后，这是要打包的 Python 脚本的文件名。PyInstaller 将分析这个文件，并根据文件中的代码生成可执行文件。
28. ### 总结
30. 这个命令通过将 `hello.py` 打包成一个单独的可执行文件，确保 `requests` 库被正确导入，并且为最终的 `.exe` 文件指定了一个自定义图标。

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。