创建一个变量 ，直接写想要的变量名称就行，不需要定义变量的类型
a = 1 整型
b = 'hello world' 字符串
c = a + 1 整型运算 先计算a+1再赋值给c
d = b 字符串
print()
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是字符串类型，这里是把类型强制转换成字符串了，不然会报错
用加号连接，使字符串连续
尽量简单易懂，见名知意，和c语言教的那个差不多，不能是关键字啥的
通过键，访问值，键和值对应形成键值对（一个名称而已）
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['年龄']
我放在了data中
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) # 获取到，这个信息，说明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位，左开右闭，不打印第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函数，在这个函数里面填充子字符串，配合这个函数放在字符串的后面
如果在字符串中能找到子字符串，就会返回子字符串在字符串的起始位置（从0位开始）,否则程序会报错
s3 = 'Python爬虫工程师'
print(s3.index('Python')) 0
print(s3.index('爬虫')) 6
print(s3.index('123')) error
给你一个字符串判断前面几位或者后几位是什么东西
如果原字符串和比较的字符串相同，就返回True，否则位False
email = '123456@qq.com'
# 比较开头
print(email.startswith('123')) True
print(email.startswith('1123')) False
# 比较结尾
print(email.endswith('qq.com')) True
email = '123456@qq.com'
print(len(email)) 13
就是求字符串的长度
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函数把字符串拆分成单个元素在新的变量里面
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函数，把括号里面的列表拼接成完整字符串
单引号和双引号都可以
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接口之前要确保列表是已存在的，空列表也行，否则报错
删除列表元素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)
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分割一下就行
# 列表
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
使用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函数生成的不是完整的列表，是一个范围，想要直接打印，需要列表化
这个函数会自动对参数求和
# 比如，从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 + 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
在for-in或者while中，用一个if判断，来决定break语句是否执行，一旦执行，循环体结束
在for-in或者while中，用一个if判断，来决定continue语句是否执行，如果条件符合，这一轮的循环结束，不影响下一轮
内置函数 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之后，也可以在函数体外面使用了
定义函数第一个字母小写
定义类，第一个字母大写
在类里面使用def关键字，加上两个下划线，选择_ _init _ _对类进行初始化，给这个对象填充属性
参数里面的self不用管，这个参数就是对象他自己，就像c++那个内置函数一样，都会偷偷干活，不用管
self是隐藏参数，直接忽视
虽然这两种方式在结果上是相同的，但它们有一些不同之处：
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，可以在子类里面再初始化的时候增加自己的属性
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>…
比如，写了一个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是个条件语句，这个语句很危险，为了防止程序运行到此处崩溃，就给了两个选项，告诉程序，如果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’ 这是一种文件打开的编码方式
一次读取整个文件
一次读取一行
也是一次读取整个文件，只是把文件内容放进一个列表里面
使用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 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()
writelines会把列表以字符串的形式写在文件里，
而write只能填写字符串，或者把列表类型转换成字符串，但是write会把整个列表写入
找到pyinstaller的安装路径，也就是这个库所在的文件夹
把想要打包的文件拷贝到库文件里面
再从网上找一个图片，自己转换成ico的后缀，这个后缀就是图标专用后缀
再打开命令行
使用命令语句打包：
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` 文件指定了一个自定义图标。