代码探险家

这个屌丝很懒，什么也没留下！

热门标签

前端，爬虫，多线程，基础_前端线程基础

作者：代码探险家 | 2024-07-26 15:17:54

踩

前端线程基础

前端爬虫线程进程基础

01. URI 和 URL

URI - Universal Resource Identifier ----> 统一资源标识符

URL - Universal Resource Locator ----> 统一资源定位符

URI = URL + URN(x)

https://www.baidu.com:443/index.html （URI 全写名称）

http://14.215.177.38:80/index.html （IP 地址）

https://www.taobao.com/ （只写域名访问）

协议- HTTP / HTTPS

HTTP - Hyper-Text Transfer Protocol (超文本传输协议)

HTML - Hyper-Text Markup Language（超文本标记语言）

HTTPS - HTTP over SSL —> 安全的HTTP（在HTTP协议的基础上，通过SSL或TLS提供加密处理数据、验证对方身份以及数据完整性保护）

域名 / IP地址 —> 要连接的主机

端口号 —>端口用来区分不同的服务

资源路径

DNS - Domain Name System ----> 将域名解析为 IP 地址

02. 超文本传输协议

1. HTTP协议 - 请求响应式的协议

（1）HTTP请求

请求行 -->GET / HTTP/1.1

GET：从服务器获取资源

POST：向服务器提交数据

请求头 --> 键值对 – 告诉服务器的额外的信息

空行（\r\n）

消息体 --> 你要发给服务器的数据

(2) HTTP响应

响应行 --> HTTP/1.1 200 OK

响应状态码 --> 404 Not Found / 403 Forbidden
2xx：成功了
3xx：重定向
4xx：请求有问题
5xx：服务器有问题

响应头 - 键值对 - 服务器给浏览器的额外信

空行（\r\n）

消息体 - 服务器发给浏览器的数据

如果请求的是图片，就获得图片的二进制数据

如果请求的网页，就获得网页的源代码，浏览器执行代码，用户看到页面

03. HTML （超文本标记语言 )

1. HTML - 超文本标记语言 — 网页的内容都是写在标签里面


<!doctype html>
    <html>
        <head>
            写在这里的内容不会显示在浏览器窗口
            但是这里却包含了网页比较重要的元信息
        </head>
        
        <body>
            写在这里的内容会显示在浏览器窗口中
        
        </body>
    </html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. HTML 页面源代码由三个要素构成

1. 标签 -->数据（content - 承载内容）

2. 层叠样式表（CSS）—>显示（display - 渲染页面）

3. JavaScript（ JS ）—> 行为（behavior - 交互行为）

#### 标签

**1.文本 h1 h6 , p , sub , sup , em **

   h1~h6：标题
   p：段落
   sub / sup：下标、上标 
   em / strong: 强调
1
2
3
4

2.图像 img 标签


<img src="" alt="">

img  src属性

1
2
3
4
5

**3.链接 a 标签 **

a --> href/属性 name/属性 target/属性 （ _self, _blank, _parent/ _top ） 

（1）页面链接
（2）锚链接
（3）功能链接
1
2
3
4
5

4.表格 table 标签

<table></table>  td 行 * tr 列
1

**5.列表 ul , ol , dl **

 ul - 无序列表（unordered list） - li（列表项，list  item）
 ol - 有序列表（ordered   list）
 dl - 定义列表（definition list）- dt（定义标题）/ dd（定义描述）
1
2
3

**6.音视频 audio ， video **

 audio    <audio src=""></audio>

 video     <video src=""></video>
1
2
3

04. css 选择器

选择器：对于爬虫来说是一个相对来说很重要的知识点

1. 通配符选择器：*

2. ID选择器：#id_name

3. 类选择器：.class_name

4. 标签选择器：标签名

5. 父子选择器

6. 标签1>标签2：标签1下面的标签2（紧挨着标签1的下一级）

7. 标签1>标签2:nth-child(n) （first-child、last-child）标签1第n个标签2

8. 后代选择器：标签1 标签2（标签2在标签1的低级）

9. 兄弟选择器：标签1~标签2

10. 相邻兄弟选择器：标签1+标签2

05. 爬虫基础

爬虫的步骤:

1. 确定获取数据的网址（分析网页动态）

1）静态页面

resp = requests.get('url')
print(resp.text)         
# text：获取文本信息，content：获取二进制文件
1
2
3

2）动态页面


# 方法一：

driver = webdriver.Chrome()
driver.get('url')

# page_source是带动态内容的页面源代码

soup = bs4.BeautifulSoup(driver.page_source, 'html.parser')
print(soup)

# 方法二：

# 寻找网页JSON，找到JSON之后解析JSON代码

resp = requests.get('url')
data_dict = resp.json()
print(data_dict)




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 代码请求访问数据地址（伪装身份）

1）使用HTTP请求头之User-Agent模拟浏览器的信息进而骗过网站

2）通过cookies，我们获取到cookie后就可以携带cookie来访问需要登录后的页面了。

3）商业代理 IP （cokie 池）

注意：爬取数据的时候建议时间休眠

3. 解析页面数据

1）正则表达式

resp = requests.get('url')

pattern = re.compile(r'正则表达式')

results = pattern.findall(resp.text)

1
2
3
4
5
6

2）css 选择器

resp = requests.get('url')

soup = bs4.BeautifulSoup.select('selector --> 标签层级方式获取')

for x in soup:
    # 获取标签下的文字信息
    print(x.text)
    # 获取标签内属性内容
    print(x.attrs['标签属性名'])
    
1
2
3
4
5
6
7
8
9
10

4. 保存数据（写入excle文档）


# 创建工作薄
wb = xlwt.Workbook()
# 创建表单
sheet = wb.add_sheet(表单名)
col_names = (列表名1，列表名2，。。。)
    for index, name in enumerate(col_names):
        sheet.write(0, index, name)
rank = 0
for info_div in info_divs:
    rank += 1
	for i in range(范围):
    	sheet.write(行,列, 元素)
wb.save('路径/文件名.xls')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

06. 多线程多进程

1. 基础概念：（进程，线程）

1. 多进程：

进程：我们运行的程序通常会对应到一个或者多个进程，进程是操作系统分配内存的基本单位

2. 多线程：

线程：一个进程通常会包含一个或多个线程，线程是操作系统分配CPU的基本单位

**3. 异步编程：**以进程、线程、协程、函数/方法作为执行任务程序的基本单位，结合回调、事件循环、信号量等机制，以提高程序整体执行效率和并发能力的编程方式。

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
资源分配给进程，同一进程的所有线程共享该进程的所有资源。
CPU分给线程，即真正在CPU上运行的是线程。

2. threading模块， ThreadPoolExecutor线程池

threading模块


# 创建一个线程对象t1，任务是target=函数，args=参数(传给函数的参数)，start让线程开始工作，daemon=True守护线程t1，主线程会等待t1执行完。

t1 = Thread(target=output1，daemon=True)
t1.start()
t1.join()	# 主线程等待t1线程结束任务，遇到join,主线程被阻塞，可以给join传入时间参数，表示等待的时长，单位s

print(t1.name)	# 打印线程的名字

1
2
3
4
5
6
7
8
9

ThreadPoolExecutor线程池


from concurrent.futures.thread import ThreadPoolExecutor

# 创建一个拥有16个线程的线程池，

with ThreadPoolExecutor(max_workers=16) as pool:
    f = pool.submit(工作目标函数, 传给函数的参数)
    
1
2
3
4
5
6
7
8

3. 线程调度 (threading.Condition)


# 创建一个condition对象

condition = Condition(RLock())

# 唤醒暂停的线程让他们恢复执行

condition.notify_all()

# 遇到不能继续执行任务的情况释放锁并进入等待状态，等待被唤醒，被唤醒之后若是韩式无法继续执行，又继续等待，可给wait传入时间参数，表示等待的时间，单位s

condition.wait() 

1
2
3
4
5
6
7
8
9
10
11
12
13

注意：

多线程并不一定就能提高速度，可以观察，线程的数量不同，实际的运行效果也是不同的

并⾏：并⾏性是指同⼀时刻内发⽣两个或多个事件。并⾏是在不同实体上的多个事件
并发性是指同⼀时间间隔内发⽣两个或多个事件。并发是在同⼀实体上的多个事件

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/885934