1、语法结构
   	proxies = {
       	'协议':'协议://IP:端口号'
   	}
2、示例
    proxies = {
    	'http':'http://IP:端口号',
    	'https':'https://IP:端口号'
	}

import requests

url = 'http://httpbin.org/get'
headers = {
    'User-Agent':'Mozilla/5.0'
}
# 定义代理,在代理IP网站中查找免费代理IP
proxies = {
    'http':'http://112.85.164.220:9999',
    'https':'https://112.85.164.220:9999'
}
html = requests.get(url,proxies=proxies,headers=headers,timeout=5).text
print(html)

# -*- coding:utf-8 _*-
"""
@version:
author:安伟超
@time: 2020/09/12
@file: demo10_xicidaili_getIP.py.py
@environment:virtualenv
@email:awc19930818@outlook.com
@github:https://github.com/La0bALanG
@requirement:爬取66代理所有可用代理IP，存入文件，作为个人IP代理池
"""

import threading
import requests
import time
import random
from lxml import etree
from fake_useragent import UserAgent

class GetXiCiDaiLiIPSpider(object):
    '''

        面向对象思路：
        1.拆分功能细节。整体程序可拆分为:
            1.发请求获得页面
            2.解析页面
            3.持久化存储(写入文件保存)
        2.结合开闭原则，封装功能方法为私有方法，对外提供统一公共接口
        3.采用单例模式：假设本爬虫程序在多个时间、不同情况下多次使用，单例模式实现只创建一个对象，提升性能避免内存占用过高。

        '''

    _instance_lock = threading.Lock()

    # 单例模式实现：__new__方法
    def __new__(cls, *args, **kwargs):
        if not hasattr(GetXiCiDaiLiIPSpider, '_instance'):
            with GetXiCiDaiLiIPSpider._instance_lock:
                if not hasattr(GetXiCiDaiLiIPSpider, '_instance'):
                    GetXiCiDaiLiIPSpider._instance = object.__new__(cls)
        return GetXiCiDaiLiIPSpider._instance

    def __init__(self):
        self.__url = 'https://www.kuaidaili.com/free/inha/{}/'
        self.__headers = {
            'User-Agent':UserAgent().random
        }

    def __get_html(self,url,headers):
        return requests.get(url=url,headers=headers).text

    def __parse_html(self,html):
        dom = etree.HTML(html)
        tr_lists = dom.xpath('//table/tbody/tr')
        #第一个tr不是ip及端口号信息，跳过第1个，从第2个tr开始提取
        for tr in tr_lists:
            ip = tr.xpath('./td[1]/text()')[0]
            port = tr.xpath('./td[2]/text()')[0]
            self.__test_IP(ip,port)

    def __test_IP(self,ip,port):
        proxies = {
            'http': 'http://{}:{}'.format(ip, port),
            'https': 'https://{}:{}'.format(ip, port),
        }
        test_url = 'https://www.hao123.com/'
        try:
            res = requests.get(url=test_url,proxies=proxies,timeout=8)
            if res.status_code == 200:
                print('代理ip:%s:%s测试完毕，success,采用，即将写入代理池文件'%(ip,port))
                with open('proxies.txt','a') as f:
                    print('写入代理ip...')
                    f.write(ip + ':' + port + '\n')
                    print('写入完成，测试下一条代理ip...')
        except Exception as e:
            print('代理ip:%s:%s测试完毕，faild,不采用，测试下一条代理ip...'%(ip,port))
    def display(self):
        begin = int(input('请输入开始页数：'))
        end = int(input('请输入结束页数：'))
        for i in range(begin,end + 1):
            print('开始爬取第%d页代理ip...'%i)
            url = self.__url.format(i)
            self.__parse_html(self.__get_html(url,self.__headers))
            time.sleep(random.randint(0,3))

def test():
    GetXiCiDaiLiIPSpider().display()

if __name__ == '__main__':
    test()

1、语法结构
proxies = {
    '协议':'协议://用户名:密码@IP:端口号'
}

2、示例
proxies = {
	'http':'http://用户名:密码@IP:端口号',
  'https':'https://用户名:密码@IP:端口号'
}

import requests
url = 'http://httpbin.org/get'
proxies = {
    'http': 'http://用户名:密码@106.75.71.140:16816',
    'https':'https://用户名:密码@106.75.71.140:16816',
}
headers = {
    'User-Agent' : 'Mozilla/5.0',
}

html = requests.get(url,proxies=proxies,headers=headers,timeout=5).text
print(html)

举个栗子：

headers：

"""
Accept: application/json, text/javascript, */*; q=0.01
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: keep-alive
Content-Length: 248
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Cookie: OUTFOX_SEARCH_USER_ID=1559141275@10.169.0.83; JSESSIONID=aaaUEr86rzfeo7xp8b7rx; OUTFOX_SEARCH_USER_ID_NCOO=1009771993.8014448; ___rl__test__cookies=1599804152408
Host: fanyi.youdao.com
Origin: http://fanyi.youdao.com
Referer: http://fanyi.youdao.com/
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
X-Requested-With: XMLHttpRequest

"""
    
form表单数据：
"""
i: 朋友
from: zh-CHS
to: en
smartresult: dict
client: fanyideskweb
salt: 15998041524052
sign: bf3ecd8f4c8a282ed79468f49aeb69fd
lts: 1599804152405
bv: e915c77f633538e8cf44c657fe201ebb
doctype: json
version: 2.1
keyfrom: fanyi.web
action: lan-select

"""
    

# -*- coding:utf-8 _*-
"""
@version:
author:安伟超
@time: 2020/09/11
@file: demo09_re_headers_and_formData.py.py
@environment:virtualenv
@email:awc19930818@outlook.com
@github:https://github.com/La0bALanG
@requirement:使用正则表达式预处理headers及form表单数据
"""

import re

class demoSpider(object):

    def __init__(self):
        self.__headers = """
Accept: application/json, text/javascript, */*; q=0.01
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: keep-alive
Content-Length: 248
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Cookie: OUTFOX_SEARCH_USER_ID=1559141275@10.169.0.83; JSESSIONID=aaaUEr86rzfeo7xp8b7rx; OUTFOX_SEARCH_USER_ID_NCOO=1009771993.8014448; ___rl__test__cookies=1599804152408
Host: fanyi.youdao.com
Origin: http://fanyi.youdao.com
Referer: http://fanyi.youdao.com/
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
X-Requested-With: XMLHttpRequest
"""
        self.__formData = """
i: 朋友
from: zh-CHS
to: en
smartresult: dict
client: fanyideskweb
salt: 15998041524052
sign: bf3ecd8f4c8a282ed79468f49aeb69fd
lts: 1599804152405
bv: e915c77f633538e8cf44c657fe201ebb
doctype: json
version: 2.1
keyfrom: fanyi.web
action: lan-select
        """

    def re_parse(self,str_data):
        dict = {}
        for x,y in re.findall('(.*):(.*)',str_data):
            dict[x] = y.strip()
        return dict

    def display(self):
        headers = self.re_parse(self.__headers)
        form_data = self.re_parse(self.__formData)
        print(headers)
        print(form_data)

demoSpider().display()

pip install selenium

from selenium import webdriver

browser = webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.quit()

加载浏览器驱动： webdriver.Firefox()

打开页面：get()

关闭浏览器：quit()

最大化窗口： maximize_window()

设置窗口参数：set_window_size(600,800)

后退到前一页： back()

前进到后一页： forward()

刷新页面： refresh()

获得title并打印:title

单元素定位
    id定位：find_element_by_id()
    name定位：find_element_by_name()
    class定位：find_element_by_class_name()
    tag定位：find_element_by_tag_name()
    link定位：find_element_by_link_text()
    partial link 定位： find_element_by_partial_link_text()
    Xpath定位:
        绝对路径：find_element_by_xpath("绝对路径")
        元素属性：find_element_by_xpath("//unput[@id='kw']")
        层级与属性结合：find_element_by_xpath("//form[@id='loginForm']/ul/input[1]")
        逻辑运算符：find_element_by_xpath("//input[@id='kw' and@class='s_ipt']")

    CSS定位：find_element_by_css_selector(选择器)
多元素定位
    browser.find_elements_by_id('')
    browser.find_elements_by_name('')
    browser.find_elements_by_class_name('')
    browser.find_elements_by_xpath('')
    ... ...
节点对象操作
    ele.send_keys('') # 搜索框发送内容
    ele.click()
    ele.text # 获取文本内容，包含子节点和后代节点的文本内容
    ele.get_attribute('src') # 获取属性值

from selenium.webdriver.common.keys import Keys
browser = webdriver.Chrome()
browser.get('http://www.baidu.com/')
# 1、在搜索框中输入"selenium"
browser.find_element_by_id('kw').send_keys('赵丽颖')
# 2、输入空格
browser.find_element_by_id('kw').send_keys(Keys.SPACE)
# 3、Ctrl+a 模拟全选
browser.find_element_by_id('kw').send_keys(Keys.CONTROL, 'a')
# 4、Ctrl+c 模拟复制
browser.find_element_by_id('kw').send_keys(Keys.CONTROL, 'c')
# 5、Ctrl+v 模拟粘贴
browser.find_element_by_id('kw').send_keys(Keys.CONTROL, 'v')
# 6、输入回车,代替 搜索 按钮
browser.find_element_by_id('kw').send_keys(Keys.ENTER)

from selenium import webdriver
# 导入鼠标事件类
from selenium.webdriver import ActionChains
driver = webdriver.Chrome()
driver.get('http://www.baidu.com/')
#移动到 设置，perform()是真正执行操作，必须有
element = driver.find_element_by_xpath('//*[@id="u1"]/a[8]')
ActionChains(driver).move_to_element(element).perform()
#单击，弹出的Ajax元素，根据链接节点的文本内容查找
driver.find_element_by_link_text('高级搜索').click()

# 获取当前所有句柄（窗口）
all_handles = browser.window_handles
# 切换browser到新的窗口，获取新窗口的对象
browser.switch_to.window(all_handles[1])

browser.switch_to.iframe(iframe_element)

pid = os.fork()
	功能： 创建新的进程
	返回值：整数，如果创建进程失败返回一个负数，如果成功则在原有进程中返回新进程的PID，在新进程中返回0
    
注意:
    子进程会复制父进程全部内存空间，从fork下一句开始执行。
    父子进程各自独立运行，运行顺序不一定。
    利用父子进程fork返回值的区别，配合if结构让父子进程执行不同的内容几乎是固定搭配。
    父子进程有各自特有特征比如PID PCB 命令集等。
    父进程fork之前开辟的空间子进程同样拥有，父子进程对各自空间的操作不会相互影响。
示例代码：
import os
from time import sleep

pid = os.fork()

if pid < 0:
    print("进程创建失败")
elif pid == 0:
    sleep(3)
    print("新的进程")
else:
    sleep(4)
    print("原来的进程")

print("实验完毕")

os.getpid()
	功能： 获取一个进程的PID值
	返回值： 返回当前进程的PID 
os.getppid()
	功能： 获取父进程的PID号
	返回值： 返回父进程PID
os._exit(status)
	功能: 结束一个进程
	参数：进程的终止状态
sys.exit([status])
	功能：退出进程
	参数：整数 表示退出状态
		字符串 表示退出时打印内容
        
代码举例：
"""
获取进程的PID值
"""

import os

pid = os.fork()

if pid < 0:
    print("Error")
elif pid == 0:
    print("Child PID:",os.getpid())
    print("Get Parent PID:",os.getppid())
else:
    print("Get Child PID:",pid)
    print("Parent PID:", os.getpid())
    
"""
进程退出
"""

import os,sys

# os._exit(0)  # 进程退出

sys.exit("Process exit") # 进程退出

print("进程退出")

#使用wait函数处理子进程退出
pid,status = os.wait()
功能：在父进程中阻塞等待处理子进程退出
返回值： pid  退出的子进程的PID
	status  子进程退出状态
    
# 通过信号处理子进程退出
#使用signal模块在父进程创建子进程前写如下语句 ：
import signal
signal.signal(signal.SIGCHLD,signal.SIG_IGN)
#特点：非阻塞，不会影响父进程运行，可以处理所有子进程退出

Process()
功能 ： 创建进程对象
参数 ： target 绑定要执行的目标函数 
	args 元组，用于给target函数位置传参
	kwargs 字典，给target函数键值传参

p.start()
功能 ： 启动进程

p.join([timeout])
功能：阻塞等待回收进程
参数：超时时间

代码举例1：
"""
multiprocessing 模块创建进程
【1】 将需要子进程执行的事件封装为函数
【2】 通过模块的Process类创建进程对象，关联函数
【3】 通过进程对象调用start启动进程
【4】 通过进程对象调用join回收进程
"""
from time import sleep
import multiprocessing


a = 1

# 进程执行函数
def fun():
    print("开始一个进程")
    sleep(5)
    global a
    print("a = ",a)
    a = 1000
    print("子进程执行结束")


# 创建进程对象
p = multiprocessing.Process(target=fun)

# 启动进程 此时进程诞生 执行函数作为进程的执行内容
p.start()

# 父进程做的
sleep(3)
print("父进程事件")

# 回收进程，防止僵尸进程
p.join(1)
print("==================================")
print("a:",a)


"""
p = os.fork()
if pid == 0:
    fun()
    os._exit()
else:
    os.wait()
"""

代码举例2：
"""
process 示例
"""

from multiprocessing import Process
from time import sleep

# 带有参数的进程函数
def worker(sec,name):
    for i in range(3):
        sleep(sec)
        print("I'm %s"%name)
        print("I'm working...")

# 位置传参
# p = Process(target=worker,args=(2,'Lucy'))

# 关键字传参
p = Process(target=worker,args=(2,),kwargs={'name':'Lily'})

p.start()
p.join()

print("======================")

代码举例3：
"""
process 示例  创建多个子进程
"""

from multiprocessing import Process
from time import sleep
import os

def th1():
    sleep(3)
    print("吃饭")
    print(os.getppid(),'--',os.getpid())

def th2():
    sleep(2)
    print("睡觉")
    print(os.getppid(),'--',os.getpid())

def th3():
    sleep(4)
    print("打豆豆")
    print(os.getppid(),'--',os.getpid())


jobs = []
for th in  [th1,th2,th3]:
    p = Process(target=th)
    jobs.append(p) # 保留每一个进程对象
    p.start()

for i in jobs:
    i.join()

代码举例：
"""
进程对象属性
"""

from multiprocessing import Process
import time

def fun():
    for i in range(3):
        print(time.ctime())
        time.sleep(2)

# 创建进程对象
p = Process(target=fun,name = "Tarena")

p.daemon = True # 父进程退出时，它创建的这个子进程也退出

p.start()

# p.name = "Tedu"
print("Name:",p.name)
print("is alive:",p.is_alive())
print("PID:",p.pid)
time.sleep(1)

代码举例：
"""
自定义进程类
"""

from multiprocessing import Process


# 自己定义一个进程类
class MyProcess(Process):
    def __init__(self,value):
        super().__init__() # 加载父类的init中的属性
        self.value = value

    # 充分发挥才能，实现你的进程事件
    def fun1(self):
        print("步骤一")

    def fun2(self):
        print("步骤二")

    # 功能启动函数
    def run(self):
        self.fun1()
        self.fun2()

p = MyProcess(2) # 定义进程对象
p.start() # 将run作为进程执行
p.join()

from multiprocessing import Pool

Pool(processes)
功能： 创建进程池对象
参数： 指定进程数量，默认根据系统自动判定

pool.apply_async(func,args,kwds)
功能: 使用进程池执行 func事件
参数： func 事件函数
      args 元组  给func按位置传参
      kwds 字典  给func按照键值传参
返回值： 返回函数事件对象

pool.close()
功能： 关闭进程池

pool.join()
功能： 回收进程池中进程

"""
进程池演示
* 父进程结束，进程池也会销毁
*  执行的事件函数必须在进程池创建之前声明
"""

from multiprocessing import Pool
from time import sleep,ctime

# 进程池事件
def worker(msg):
    sleep(2)
    print(ctime(),'--',msg)

# 创建进程池
pool = Pool(4)

# 向进程池放事件
for i in range(10):
    msg = "Tedu%d"%i
    pool.apply_async(func=worker,args=(msg,))

# 关闭进程池  不能再添加新的事件
pool.close()

# 回收
pool.join()

from threading import Thread 

t = Thread()
功能：创建线程对象
参数：target 绑定线程函数
     args   元组 给线程函数位置传参
     kwargs 字典 给线程函数键值传参

 t.start()

 t.join([timeout])

demo1:
"""
thread1.py  创建线程演示
步骤 ：同Ｐｒｏｃｅｓｓ用法
1. 封装线程函数
2. 创建线程对象
3. 启动线程
4. 回收线程
"""

from threading import Thread
from time import sleep
import os

a = 1

# 线程函数
def music():
    for i in range(3):
        sleep(2)
        print(os.getpid(),"播放：黄河大合唱")
    global a
    print('a = ',a)
    a = 1000

# 创建线程对象
t = Thread(target=music)

t.start() # 启动线程 将music函数作为线程执行内容

for i in range(4):
    sleep(1)
    print(os.getpid(),"播放:葫芦娃")

t.join() # 回收线程

print("a:",a)

demo2:
"""
thread2.py  线程函数传参
"""

from threading import Thread
from time import sleep

# 含有参数的线程函数
def fun(sec,name):
    print("含有参数的线程")
    sleep(sec)
    print("%s执行完毕"%name)

# 创建多个线程
jobs = []
for i in range(5):
    t = Thread(target=fun,args=(2,),kwargs={'name':"T%d"%i})
    jobs.append(t) # 存储线程对象
    t.start()

for i in jobs:
    i.join()

"""
线程属性
"""

from threading import Thread
from time import sleep

def fun():
    sleep(3)
    print("线程属性测试")

t = Thread(target = fun)

# 在start前设置,分支线程随主线程结束而结束
t.setDaemon(True)

t.start()

t.setName("Tedu")
print("Name:",t.getName())

print("is alive:",t.is_alive())
print("daemon:",t.isDaemon())

"""
自定义线程类
"""

from threading import Thread
import time

class MyThread(Thread):
    def __init__(self,song,sec):
        super().__init__()
        self.song = song
        self.sec = sec

    def run(self):
        for i in range(3):
            print("Playing %s : %s"%(self.song,time.ctime()))
            time.sleep(self.sec)

t = MyThread('凉凉',2)
t.start()
t.join()

from threading import Event

e = Event()  创建线程event对象

e.wait([timeout])  阻塞等待e被set

e.set()  设置e，使wait结束阻塞

e.clear() 使e回到未被设置状态

e.is_set()  查看当前e是否被设置

"""
event 线程同步互斥方法示例
"""

from threading import Event,Thread

s = None # 在线程之间进行通信
e = Event() # 创建event对象

#　线程函数
def yzr():
    print("杨子荣前来拜山头")
    global s
    s = "天王盖地虎"
    e.set()  # 解除主线程阻塞

t = Thread(target=yzr)
t.start()

# 主线程验证信息
print("说对口令就是自己人")
e.wait() # 在主线程使用之前先阻塞
if s == '天王盖地虎':
    print("宝塔镇河妖")
    print("确认过眼神，你是对的人")
else:
    print("打死他，无情啊")

t.join()

from  threading import Lock

lock = Lock()  创建锁对象
lock.acquire() 上锁  如果lock已经上锁再调用会阻塞
lock.release() 解锁

with  lock:  上锁
...
...
	 with代码块结束自动解锁

"""
thread_lock.py lock方法解决同步互斥
"""

from threading import Thread,Lock

a = b = 0
lock = Lock() # 创建锁对象

# 线程函数
def value():
    while True:
        lock.acquire()
        if a != b:
            print("a = %d,b = %d"%(a,b))
        lock.release()

t = Thread(target=value)
t.start()

while True:
    lock.acquire() # 上锁
    a += 1
    b += 1
    lock.release() # 解锁

    # with lock:  #上锁
    #     a += 1
    #     b += 1
                # 语句块结束解锁

t.join()

"""
模仿死锁现象
"""
from threading import Lock,Thread
from time import sleep

# 账户
class Account:
    def __init__(self,id,balance,lock):
        self.id = id
        self.balance = balance # 存款
        self.lock = lock

# 初始化2个账户
Tom = Account('1',5000,Lock())
Abby = Account('2',4000,Lock())

# 转账
def transfer(f,t,amount):
    """
    :param f:  转出
    :param t:  转入
    :param amount: 金额
    """
    f.lock.acquire() # 自己的锁住
    f.balance -= amount
    f.lock.release()  # 账户解锁   不会产生死锁

    sleep(0.1)
    t.lock.acquire() # 对方的账户锁住
    t.balance += amount

    # f.lock.release() # 账户解锁 会产生死锁
    t.lock.release()

t1 = Thread(target=transfer,args=(Tom,Abby,1500))
t2 = Thread(target=transfer,args=(Abby,Tom,500))
t1.start()
t2.start()
t1.join()
t2.join()

print("Tom:",Tom.balance)
print("Abby:",Abby.balance)

# 方法1（利用cookie）
	1、先登录成功1次,获取到携带登陆信息的Cookie（处理headers）
	2、利用处理的headers向URL地址发请求
# 方法2(利用requests.get()中cookies参数)
	1、先登录成功1次,获取到cookie,处理为字典
	2、res=requests.get(xxx,cookies=cookies)
# 方法3（利用session会话保持）
	1、实例化session对象
		session = requests.session()
	2、先post : session.post(post_url,data=post_data,headers=headers)
		1、登陆，找到POST地址: form -> action对应地址
		2、定义字典，创建session实例发送请求
		# 字典key ：<input>标签中name的值(email,password)
		# post_data = {'email':'','password':''}
	3、再get : session.get(url,headers=headers)