我要成为python高手
我要成为python高手
安装python
python的安装，非常简单，这一步跳过，B站上很多大佬讲过。
声明：本次笔记参考B站大佬林粒粒呀 及菜鸟教程
print函数
初学python，这是我们认识的第一个函数，它可以很好的打印出字符串
print('我要成为python高手！')
print("hello! \n hi")
python的变量
python的变量是用来储存和代值的，它得有个名字，然后对它进行赋值,python是从上到下执行，所以需要先对变量赋值，然后才可以正常使用。变量命一般用数字，字母，下划线组成，一个好的项目文档，里面会有介绍如何取变量名。
a = 74
b = 56
c = a + b
print(c)eating = "晚饭次什么呢？"
eating_not = "窝不想次"
eating_do = "窝要次"
eating = eating_do
print(eating + "苦瓜汁")
print(eating + "南瓜汁")
print(eating + "香蕉汁")
#窝要次苦瓜汁
#窝要次南瓜汁
#窝要次香蕉汁python的数学运算
说到python数学的运算，加减乘除就不介绍了，最重要的库就是math啦，极大减小了我们的操作性，我们可以通过math的官方文档来使用它
import math
result = math.log2(8)
print(result)
#3.0
#经典求根公式
x1 = print((-b + math.sqrt(b**2-4*a*c)) / (2*a*c))
x2 = print((-b - math.sqrt(b**2-4*a*c)) / (2*a*c))python的数据类型----摘抄菜鸟教程
Number（数字）-------------Python3 支持 int、float、bool、complex（复数）。
String（字符串）--------------Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
bool（布尔类型）------------布尔类型即 True 或 False。True 和 False 都是关键字，表示布尔值。
List（列表）-----------------List（列表） 是 Python 中使用最频繁的数据类型。
Tuple（元组）---------------元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
Set（集合）---------------Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。
Dictionary（字典）-----------字典（dictionary）是Python中另一个非常有用的内置数据类型。
#对字符串求长度
a = "我要成为python高手"
print(len(a))
#索引获取字符，0开始
print(a[0])
#布尔类型
a1 = True
a2 = False
#空值
a3 = None
#type
print(type(a1))
input函数
input是python里面一个常见的获取输入的函数，它可以获取的用户的数据，它可以返回输入的结果(字符串)
age = int(input("您的年龄是:"))
age_10year = age + 10
print("您10年后的年龄是" + str(age_10year))python的条件判断
1.条件判断
if [条件]: 布尔值判断真假
[执行条件]
else [条件]:
[执行条件]
肚子饿指数 = int(input("输入当前的指数:"))
if 肚子饿指数 <= 50:
print("我要喝苦瓜汁，谢谢")
else:
print("谢谢，我还不饿")
2.嵌套条件语句
if [条件1]:
if [条件2]:
[语句A]
else:
[条件B]
else:
[条件C]
elif嵌套
if [条件1]:
[语句A]
elif [条件2]:
[语句B]
elif [条件3]:
[语句C]
else:
[语句D]
逻辑运算
处了嵌套。有时候还可以使用逻辑运算
if (wddzel > 10 and nddzel > 11 and taddzel > 15 and dajiddzel >20):
print("次饭")
else：
print("不饿呢")python列表
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型，列表是可变的，增加或者修改
list_1 = ["苦瓜","鸡蛋"]
list_1.append("西红柿")
list_1.remove("鸡蛋")
print(list_1)
print(len(list_1))
#列表2
list_2 = [87,89,54,74,0]
# print(min(list_2))
list_2_min = min(list_2)
list_2_max = max(list_2)
list_2_sorted = sorted(list_2)
print(list_2_min)
print(list_2_sorted)python字典
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
dIct_1 = {key1 : value1, key2 : value2 }
#增
dict_1[key3]=value3
#删
dict_1[key1]=value1
print(dict_1)
#查询
dIct_1 = {key1 : value1, key2 : value2 }
chaxun = input("你要查什么:")
if chaxun in dict_1:
print("我在这里！"+ chaxun )
print(dict_1[chaxun])
else:
print("找不到呢")
print("现在有" + str(len(dict_1))+"个值")
for循环
重复执行语句
for 变量名 in 可迭代对象
#对变量操作
list = [66,54,74,23,45,68,12,13]
for vale in list:
if vale > 10:
print(vale)
#结合range函数使用
toal = 0
for i in range(1,101):
toal = toal + i
print(toal)while循环
while 条件A:
行动B
count = 0
while count < 60:
print("oi")
count += 1
list1 = ["兄","弟","你","好","香"]
i = 0
while i < len(list1):
print(list1[i])
i +=1现在我们尝试用while来实现对输入的数字求平均值
total = 0
count = 0
user_vale = input("请输入：")
while user_vale != "q":
num = float(user_vale)
# total = num + total
total += num
count += 1
user_vale = input("请输入：")
if count == 0:
result = 0
else:
result = total / count
print(result)格式化字符串
format方法，指定替换一些内容
DRY原则----初识函数
Don't Repeat Yourself 写代码时尽量去避免一些重复的事，函数可以很好的把我们避免一些重复的事，自定义函数使用def:格式如下
def sanxing():
cental_angle_1 = 160
radius_1 = 30
sector_area_1 = cental_angle_1 / 360 * 3.14 * radius_1 **2
print(f'这个扇形的面积是:{sector_area_1}')
#sanxing()
#改进，传参，
def sanxing(cental_angle_1, radius_1):
# cental_angle_1 = 160
# radius_1 = 30
sector_area_1 = cental_angle_1 / 360 * 3.14 * radius_1 **2
print(f'这个扇形的面积是:{sector_area_1}')
sanxing(60,80)
函数需要调用才会被执行。上面的代码有一些小小的问题,现在我们需要了解一下什么是作用域
作用域：我们在函数里面定义的变量都是局部变量，在函数之外无法访问，像这样
def fun():
a = 5
print(a)
print(a)
#NameError: name 'a' is not defined现在return的作用就体现了，它会在函数调用后，返回我们想要它返回的东西
def fun():
a = 5
print(a)
return(a)
print(fun())return 的默认返回值是空值，来一个小小的练习，BMI计算器
def BMI(weight,height):
BMI = weight / height **2
if BMI <= 18.5:
category = "偏瘦"
elif 18.5 <= BMI <= 25:
category = "正常"
elif BMI <= 30:
category = "偏胖"
else:
category = "肥胖"
print(f'您的分类为:{category}')
return BMI
reselt=BMI(21,80)
print(reselt)模块的使用
python大佬们提供了大量的第三方库，我们可以直接拉来用
pip install 模块
引入模块的三种方法
import math | form ... import .... | form...import *
我们也可以去python的标准库找,以及pypi.org这个网站
面向对象编程---oop(菜鸟教程摘抄)
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。
如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。
接下来我们先来简单的了解下面向对象的一些基本特征。
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
现在我们来尝试实例化对象
class xts:
def __init__(self,age,name,sex):
self.age = age
self.name = name
self.sex = sex
xts1 = xts(20,"xts","nv")
print(xts1.name)
print(xts1.age)
print(xts1.sex)定义对象的方法，方法可以表示对象可以做那些事，现在有一个这样的需求
#定义一个学生类
#学生名字 学号 成绩
#能够打印三科成绩
class student:
def __init__(self,name,student_id):
self.name = name
self.studentd_id = student_id
self.grades = {"语文": 0,"数学":0,"英语":0}
#调用方法
def speak(self,course,grade):
if course in self.grades:
self.grades[course] = grade
def print_grades(self):
print(f'学生{self.name} 学号{self.studentd_id} 的成绩是：')
for course in self.grades:
print(f'{course}:{self.grades[course]}分')
#实例化对象
xts = student("小天使","10001")
xts.speak("语文",100)
xts.speak("数学",100)
xts.speak("英语",100)
# print(xts.name,xts.studentd_id,xts.grades)
print(xts.grades)
xts.print_grades()类的继承
Python中类的继承也就是一个类继承另一个类的话，便可以拥有所继承类的所有属性和方法，此时使用起来不仅方便且节省代码量。就像遗传的那样，儿子会继承父亲的一些特征
class Mammal:
def __init__(self,name,sex):
self.name = name
self.sex = sex
self.num_eye = 2
def breathe(self):
print(self.name + "会呼吸")
def eat(self):
print(self.name + "要干饭")
#子类
class Human(Mammal):
def read(self):
print(self.name + "会看书")
#子类2 猫猫
class cat(Mammal):
def read(self):
print(self.name + "在撒娇")
xts = Human("小天使","女")
print(xts.name,xts.sex)
xts.breathe()
xts.read()
maomao = cat("喵喵","母")
print(maomao .name,maomao.sex)
maomao.breathe()
maomao.read()
#super方法
# 父类
class Mammal:
def __init__(self,name,sex):
self.name = name
self.sex = sex
self.num_eye = 2
def breathe(self):
print(self.name + "会呼吸")
def eat(self):
print(self.name + "要干饭")
#子类 引入super方法
class Human(Mammal):
def __init__(self, name, sex):
super().__init__(name, sex)
self.has_tail = False
def read(self):
print(self.name + "会看书")
#子类2 猫猫
class cat(Mammal):
def __init__(self, name, sex):
super().__init__(name, sex)
self.has_tail = False
def read(self):
print(self.name + "在撒娇")
xts = Human("小天使","女")
print(xts.name,xts.sex)
xts.breathe()
xts.read()
maomao = cat("喵喵","母")
print(maomao .name,maomao.sex)
maomao.breathe()
maomao.read()做个小练习，巩固一下吧
#类的继承练习：人力系统
#员工分为两类 全职员工 FulltimeEmployee 兼职员工 ParttimeEmployee
#全职和兼职都要姓名 工号等属性
#都具备打印信息 print_info (打印姓名 工号的方法)
#全职有'月薪' calculate_monthly_pay属性
#兼职有日薪daily_salary 每月工作天数 work_days 属性
#全职和兼职都有计算月薪 calculate_monthly_pay的方法，但具体计算方法不一样
class Employee:
def __init__(self,name,id):
self.name = name
self.id = id
def print_info(self):
print(f'员工{self.name },工号是{self.id}')
#全职员工
class FulltimeEmployee(Employee):
def __init__(self, name, id,monthly_salary):
super().__init__(name, id)
self.monthly_salary = monthly_salary
def calculate_monthly_pay(self):
return self.monthly_salary
#兼职员工
class ParttimeEmployee(Employee):
def __init__(self, name, id,daily_salary,workdays):
super().__init__(name, id)
self.daily_salary = daily_salary
self.workdays = workdays
def calculate_monthly_pay(self):
return self.daily_salary * self.workdays
xts = FulltimeEmployee("小天使","10001","3K")
xxts = ParttimeEmployee("小小天使","10002",8,23)
result=xxts.calculate_monthly_pay()
print(result)文件操作
目录结构就像树根一样,/表示根目录，一切的文件和目录都在根目录下面，windowns的每个磁盘都有根目录。
绝对路径：从根目录出发，以/开头 C：\hmoe\data\a.py
相对路径：从参照目录出发 data\a.py
很多编辑器可以帮我们复制路径，所以不用担心
现在我们来用python来操作文件。
#读文件的方法
f = open('./data.txt',"r",encoding="utf-8")
print(f.read())
#read会占用大量的内存 传入字节可以避免这个问题
print(f.read(10))
#readline 只会读一行的内容
line = f.readline() #读第一行
while line != "": #判断当前行是否为空
print(line) #不为空则打印下一行
line = f.readline() #读取下一行
# readlines的用法 结合for循环使用
f = open('./data.txt',"r",encoding="utf-8")
lines = f.readlines() #把每行内容都存储在列表里
for line in lines:
print(line)
#读完要记得关闭文件
f.close()
#法2
with open("文件路径") as f:
print(f.read)上面学习了读文件，那么接下来怎么写呢？非常简单。
#写文件
#和读文件差不多 也是要先打开
#如果已经存在了该文件，那么用W模式会把原文件清空
with open("文件路径","w",encoding="utf-8") as f:
f.write("fgdhjubdshj!\n")
#a模式表示追加内容
with open("文件路径","a",encoding="utf-8") as f:
f.write("hello world!")
#读写模式
with open("文件路径","r+a",encoding="utf-8") as f:
f.write("hello world!")
# 实践时间
with open("./paem.txt","w",encoding="utf-8") as f:
f.write("我是小天使\n")
f.write("成功地当上了客服\n")
with open("./paem.txt","a",encoding="utf-8") as f:
f.write("工资1800\n")
f.write("每天笑哈哈\n")来到这里。你已经非常棒了，接下来我们学习python的异常处理，避免程序炸了
# #异常的类型，列如
number_list = [56,23,-5,96]
# number_list[4] #IndexError: list index out of range 索引错误
print(56 / 0) #ZeroDivisionError: division by zero 除零错误
f = open("./ht,txt","r") #FileNotFoundError: [Errno 2] No such file or directory: './ht,txt' 找不到文件错误
i = 'jfddf' * 'fkhjdl'
print(i) #TypeError: can't multiply sequence by non-int of type 'str' 类型错误
#异常类型非常的多，写的越多，错的越多，趁早放弃才是正途，哈哈哈，开个玩笑
#平时就应该多测试，把bug找出来，如果是客户的问题，那我们可以预判一波
try: #可能出现异常的代码
o = float(input("需要一个数字:"))
except ValueError:
print("您输入的不是数字，请重新运行程序")
except: #把所有的问题都指向一个问题
print("发生了未知的错误，请重新运行")
finally: #不管错误是否发生，都会运行
print("程序结束运行")
#测试是非常重要的bug是什么？让程序跑不起来的东西，只要写代码，就不存在不写bug的程序员
python爬虫实战
爬虫的基本原理----转载在腾讯云爬虫0126
经过了上面的学习，已经掌握了python的基础，现在我们可以尝试做一些有趣的东西，比如，爬虫。什么的爬虫
爬虫是一种自动化程序，能够模拟人类的浏览行为，从网络上获取数据。爬虫的工作原理主要包括网页请求、数据解析和数据存储等几个步骤。本文将详细介绍爬虫的基本工作原理，帮助读者更好地理解和应用爬虫技术。
首先，爬虫的第一步是网页请求。爬虫需要向目标网站发送HTTP请求，获取网页的内容。在发送请求之前，爬虫需要确定要爬取的目标网址，并选择合适的请求方法（如GET或POST）。爬虫还可以设置请求头部信息，模拟浏览器的请求，以避免被网站的反爬虫机制拦截。一旦发送了请求，爬虫就会等待服务器的响应，获取网页的内容。
接下来，爬虫需要对获取到的网页内容进行解析。网页通常是使用HTML、XML或JSON等标记语言编写的，爬虫需要根据网页的结构和规则，提取出需要的数据。爬虫可以使用解析库（如BeautifulSoup、lxml等）来解析网页，提取出标签、属性、文本等信息。爬虫还可以使用正则表达式来匹配和提取特定的数据。解析网页的过程中，爬虫还可以进行数据清洗和处理，以获取更加干净和规范的数据。
最后，爬虫需要将解析后的数据进行存储。爬虫可以将数据保存到本地文件或数据库中，以便后续的分析和应用。爬虫可以使用文件操作库（如csv、json、pickle等）来保存数据到文件中，也可以使用数据库操作库（如MySQL、MongoDB等）来保存数据到数据库中。在存储数据的过程中，爬虫还可以进行去重和去噪的操作，以确保数据的唯一性和准确性。
爬取音乐---网易云
源码如下，它可以帮我获取到https://music.163.com/discover/toplist?id=19723756这个网页里面的音乐，并把它们存放在xtsza这个文件夹里面
import requests
import re
import os
#网易云的爬取
#新建文夹夹
filename = 'xtsza\\'
if not os.path.exists(filename):
os.mkdir(filename)
url = 'https://music.163.com/discover/toplist?id=19723756'
# url = 'https://music.163.com/my/m/music/playlist?id=2693688039'
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0'
}
response = requests.get(url = url,headers=headers)
# print(response.text)
#正则表达，获取歌名和id
html_data = re.findall('<li><a href="/song\?id=(\d+)">(.*?)</a>',response.text)
# print(html_data)
#遍历网页的数据，使用接口下载
for num_id,title in html_data:
# http://music.163.com/song/media/outer/url?id={music}.mp3
music_url = f'http://music.163.com/song/media/outer/url?id={num_id}.mp3'
music_content=requests.get(url=music_url,headers=headers).content
#保存
with open(filename+ title +'.mp3',mode='wb') as f:
f.write(music_content)
print(num_id,title)
我们可以到该文件夹查看这些音乐。
爬取小说
爬虫也可以爬取小说，并将它们以txt文本文件的形式保存的下来，这里我选择了非常火的小说蛊真人为例子，话不多说，直接看源码吧
#爬取小说蛊真人
import requests
from bs4 import BeautifulSoup
import time
# 小说基础URL
base_url = "https://wap.biqige.info/0/573/"
output_file = "蛊真人2.txt"
# 自定义请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0'
}
# 抓取并保存章节内容
def fetch_and_save_chapter(chapter_url):
response = requests.get(chapter_url, headers=headers)
if response.status_code == 200:
soup = BeautifulSoup(response.content, "html.parser")
# 定位内容部分，确认使用正确的 class
content = soup.find("div", class_="novelcontent") # 确保这个 class 是正确的
title = soup.find("title") # 获取章节标题
# 如果标题中包含特定字符，提取所需部分
if title:
chapter_title = title.get_text().split(" - ")[0] # 可能需要调整，根据实际格式
else:
chapter_title = "未知章节"
if content:
with open(output_file, "a", encoding="utf-8") as file:
file.write(chapter_title + "\n") # 使用获取到的章节标题
file.write(content.get_text(separator="\n") + "\n\n")
print(f"已保存章节：{chapter_title}")
else:
print(f"章节内容未找到: {chapter_url}")
else:
print(f"无法访问章节：{chapter_url}，状态码：{response.status_code}")
# 抓取某一章节的所有分页
def fetch_chapter_with_pagination(chapter_id):
page_number = 1 # 从第一页开始
while page_number<=3:
chapter_url = f"{base_url}{chapter_id}-{page_number}.html" # 拼接章节URL
response = requests.get(chapter_url, headers=headers)
if response.status_code == 200:
fetch_and_save_chapter(chapter_url)
page_number += 1 # 进入下一页
time.sleep(1) # 添加延时，避免被封禁
else:
# 如果返回状态码不是200，说明没有更多的页面了
print(f"章节 {chapter_id} 的所有页面已抓取完毕。")
break
# 抓取所有章节
def fetch_all_chapters(start_chapter, end_chapter):
for chapter_id in range(start_chapter, end_chapter + 1):
fetch_chapter_with_pagination(chapter_id) # 抓取每个章节的所有页面
time.sleep(1) # 添加延时，避免被封禁
# 调用函数，开始抓取章节
fetch_all_chapters(start_chapter=517662, end_chapter=19765683)有些小说存在分页的情况，导致每一章只能爬取一部分，这也是我爬取的过程中遇到的一些问题，查阅了一些资料，勉勉强强的解决了，果然是活到老，学到老。爬取小说的大致情况就是这样了
爬取动画片
虽然现在我们的网络相当的发达，随时随地都会在网站上看到各种各样的的动画片，可是，总会有那么些时间，存在一些空白期，比如，高铁或者飞机上，这个时候想看动画片怎么办。聪明的你一定想到了，提前缓存好，是的，这是一个好办法，一集一集的下载又太麻烦了，现在就可以用到我们的爬虫技术了，下面找了一部我非常喜欢的动漫---黑皮女仆与少爷，虽然很好看，但是B站里面没有，呜呜呜
import os
import requests
import time
from tqdm import tqdm
# 创建存放视频的文件夹
download_folder = 'nvpu'
if not os.path.exists(download_folder):
os.makedirs(download_folder)
# 基础 URL 和集数范围
base_url = "https://play.xfvod.pro/X/X-%E6%96%B0%E6%9D%A5%E7%9A%84%E5%A5%B3%E4%BD%A3%E6%9C%89%E7%82%B9%E6%80%AA/"
total_episodes = 11
def download_video(episode_number, retries=3):
# 拼接每集的 URL
episode_url = f"{base_url}{episode_number:02}.mp4"
video_path = os.path.join(download_folder, f"episode_{episode_number:02}.mp4")
print(f"正在下载第 {episode_number} 集，保存为: {video_path}")
# 设置请求重试机制
for attempt in range(retries):
try:
# 发送请求，获取文件大小
response = requests.get(episode_url, stream=True, timeout=10)
# 检查请求状态
if response.status_code == 200:
total_size = int(response.headers.get('content-length', 0))
with open(video_path, "wb") as video_file, tqdm(
total=total_size, unit='B', unit_scale=True, desc=f"第 {episode_number} 集"
) as progress_bar:
for chunk in response.iter_content(chunk_size=1024):
if chunk:
video_file.write(chunk)
progress_bar.update(len(chunk))
print(f"第 {episode_number} 集下载完成！\n")
return
else:
print(f"第 {episode_number} 集请求失败，状态码: {response.status_code}")
break
except requests.RequestException as e:
print(f"第 {episode_number} 集下载失败，尝试 {attempt + 1}/{retries} 次。错误: {e}")
time.sleep(2) # 等待 2 秒后重试
print(f"第 {episode_number} 集下载失败，跳过。")
# 执行下载
for episode in range(1, total_episodes + 1):
download_video(episode)
time.sleep(1) # 等待 1 秒，避免请求过于频繁
print("全部视频下载完成！")视频文件太大了，加上进度条效果更好，等待下载完成，就可以在对应的文件夹里面看到了了。
声明
使用爬虫请在合法的条件下进行，侵犯别人的权益是非常不合法的