python爬虫

%10s，表示10个字符的宽度

同上

%.3f，保留三位小数

%10.3f，宽10并保留三位小数

按位与，都是1才是1，其他全是0

按位或，有1就是1

按位异或，不同就是1

按位取反，0变1，1变0

左移动相应位数，高位丢弃，低位补0

右移动相应位数，低位丢弃，高位补0

+,-

false

数值0

None

空字符串

空列表

空元组

空字典

空集合

比较值

是否是同一个地址

判断当前对象是否是指定对象的子类

一个占位符：没想好if判断后执行啥，先pass占个位

判断语句成立执行语句1，否则执行语句2

结束当前循环，本层

结束当前循环，直接进入下次循环，本层

当循环中不执行break，则执行else

break会让else中的代码不执行，continue就没这个功能

字符串长度为0或者1

符合标识符的字符串（只包含字符 数字 下划线）

字符串只在编译时进行驻留，而非运行时

[-5,256]之间的整数数字

因为字符串的拼接和修改比较影响性能

join（）是先计算所有字符串的长度，再拷贝，只new一次对象，效率比+高

找不到报valueerror

找不到报valueerror

找不到返回-1

找不到返回-1

my_str.count(str, start=0, end=len(my_str))

参数第一个是宽度，第二个是填充符（默认空格）

如果宽度参数小于字符串长度，则返回原字符串

同上

同上

一个参数，如果是-87654，在 - 后面填0 

maxsplit是可选参数

只要是数字就行，中文数字，中文大写数字，罗马数字

这个就只是阿拉伯数字

将列表中的元素用 * 合并成一个字符串

单个字符当一个元素

ord('a')

chr(97)

从0到4

从6到最后

字符串

整数

浮点数

一共三位

三位小数

宽10位，共三位小数

word = "赞美愚者"
encoding1 = word.encode(encoding='GBK')  # GBK编码格式 一个中文两个字节
encoding2 = word.encode(encoding='utf-8')  # utf-8 一个中文三个字节
print(encoding1)
print(encoding2)

decoding1 = encoding1.decode(encoding='GBK')
decoding2 = encoding2.decode(encoding='utf-8')
print(decoding1)
print(decoding2)

lst = [2*i for i in range(1, 6)]
>>[2, 4, 6, 8, 10]

获取制定元素的索引（第一个）

获取列表中index为1的元素

lstChild = lst[start : stop : step]

判断元素是否存在

遍历

统计元素个数

查询元素的索引

append()

extend()

insert()

remove()

pop()

clear()

del

lst[index]=修改后的元素

lst[start:stop]=[........]

lst.sort(reverser=True),表示降序

lst.sort(key=function( ))

sorted(lst, reverser=True), 降序

将列表倒叙

python test.py 卢卡斯
>>卢卡斯

set([列表])

set((元组))

set("字符串")

用{}创建的是空字典

in

not in

s.add(一个元素)

s.update(至少一个元素)

s.remove(元素)

s.discard(元素)

s.pop()

s.clear()

del s

集合的元素为不可变类型，所以无法修改

==

！=

s1.issubset(s2)

s2.issuperset(s1)

s1.isdisjoint(s2)

s1.intersection(s2)

s1 & s2

s1.union(s2)

s1 | s2

s1.difference(s2)

s1 - s2

s1.symmetric_difference(s2)

s1 ^ s2

s4 = {2*i for i in range(1, 6)}
>>{2, 4, 6, 8, 10}

d = {item.upper() : value for item, value in zip(items, values)}

[键]

get(键)

key的判断

遍历

del a["name"]

del a

a.clear

a["新键"]=对应的值

a["要修改的键"]=新值

获取字典中所有的键（key）

获取字典中所有的值（value）

获取字典中所有的键值对（key.value）

print(item)

print(a[item])

print(a.get(item))

[x for x in range(4)]

加条件

for嵌套循环

# 这样可以去键值对
for k,v in dict.items():
        print(k, v)

返回长度

返回最大值

del a或者del(a)

稍后再说

用到再说

a和b

a和b的实际值

结果是元组

结果是字典

*之后的参数只能用关键字参数传递

不过这样也可以def fun(a, b, *, c, **arges)
因为本质上它还是只有一个关键字参数，*只不过是个条件

def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)

要在函数内修改全局变量，先用global声明

def fun(a, b, opt):
    print(opt(a, b))

fun(1, 4, lambda x, y: x+y)

阶乘函数
def fac(n):
    if n == 1:
        return 1
    else:
        res = n*fac(n-1)
        return res

斐波拉契数列
F[n]=F[n-1]+F[n-2]  (n>=2,F[0]=0,F[1]=1)

python中一切皆对象
有id（内存空间），有type（数据类型），有值

一般首字母大写，其余小写

可以在外面通过Student.gender = None，加一个类属性

当通过实例对象调用方法的时候，self能够自动指向实例对象，从而拥有了操作这个对象中的属性或者方法的可能。

静态方法之所以不需要self，是因为方法内不需要实例对象的引用

能获取构造函数定义的变量，也不可以获取类的属性。

不能获取构造函数定义的变量，可以获取类的属性。

对象名.方法名

类名.方法名（类的对象）----方法定义处的self

调用属性

类中方法外的变量，被该类所有对象共享

使用类名直接访问的方法

使用类名直接访问的方法

再用B.aa就可以调用A的属性和方法了

如果属性不希望被外部调用，可以前面加2个_

没写父类的默认继承object

定义子类时，要在构造函数中调用父类的构造函数

支持多继承

单继承

1.super().__init__相对于类名.__init__，在单继承上用法基本无差
2.但在多继承上有区别，super方法能保证每个父类方法只会执行一次，而类名.方法()会导致方法可能被执行多次
3.多继承时，用super方法，对父类传参，由于super的算法，必须把参数全部传递，否则报错，所以就要加上*args和**kwargs
4.单继承时，用super方法，不用全部传参，只能传父类方法所需的参数，否则报错
注：在多继承时，尽量不用super，用父类名.方法（）
用super虽然对于同个父类的调用可以避免重复执行，但代码阅读难度增加，不利于debug

所有类的父类

子类想输出自己独有的东西，父类没有

反正就是调用类的方法很方便

class Dog():
    def bark(self):
        print("普通狗汪汪叫")


class LangDog(Dog):
    def bark(self):
        print("狼狗狂吠")


class ZangAo(Dog):
    pass


class Person():
    def pk_dog(self, dog):
        print('人向狗进行了攻击')
        dog.bark()


Anna = Person()
dog1 = Dog()
dog2 = LangDog()
dog3 = ZangAo()

Anna.pk_dog(dog1)
Anna.pk_dog(dog2)
Anna.pk_dog(dog3)

如果需要当前类做多个实例化，则只需要创建一个空间来存储实例对象

用户访问属性，传入一个参数，可以返回提前设定好的值

输出类的说明描述。类的说明写在类名下一行，__doc__只调用那段注释。

一般不去改

当成函数去用，就可以传参了

返回值只接受string

字典
一定要用foo['hahaha']操作才能调用这三个方法

gender属性只有stu1有

show()只有stu1能调用

@property
    def func(self):
        return '调用func'

foo = Foo()
res = foo.func

'''
对于京东商城中显示电脑主机的列表页面，
每次请求不可能把数据库中的所有内容都显示到页面上，
而是通过分页的功能局部显示，
所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据 这个分页的功能包括：
1.根据用户请求的当前页和总数据条数，计算出m和n
2.根据m和n去数据库中请求数据
'''

>>100

第一个参数是方法名，调用 对象.属性 时自动触发执行方法
第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数是字符串，调用 类名.属性.__doc__ ，此参数是该属性的描述信息
注：property中的参数顺序一定要按照get set del排序

>>num1是可引用内容
>>100
>>AttributeError:不拉不拉，test_1没num2这个属性

new和init的传参过程

for

while

1. 先定义主要类

2. 给这个类定义一个迭代器

3. MyList的实例对象my_list这时就可以用for循环遍历了

对比

原因

例

1.send方法与next方法类似
2.可以向生成器传递一个参数，并在生成器中进行接受
3.一般不在第一次获取值时使用，第一次获取时必须传递None
    print(my_iter.send(None))
4.可以在程序运行的过程中对当前的函数运行过程进行操作

关闭当前生成器（相当于删除或销毁）

return：代表整个函数结束，结束前返回值，函数中只能有一个，生成器中不可以有return
yield：不代表函数结束（只是暂停），返回一个生成器对象（可用next取到其值），函数中可以写多个yield

def person():
    def info():
        xxxxxx
p = person()  # 这里只引用了info（），并没有调用，所以info没有运行，此时person（）这个函数还是占着内存
p（）  #  这样就运行了info（）这个函数，运行完就会释放内存

>>内部函数的参数为： 10
>>30

>>[DEBUG]: enter say_hello()
>>hello

效果一样，这是最简单的装饰器，被装饰函数无法传参

>>[DEBUG]: enter say()
>>hello! lucas

>>info: enter function say()
>>hello lucas

装饰器要求接收一个callable对象，并返回一个callable对象。
所以类装饰器中，__init__接收函数，重载__call__()并返回一个函数
一个装饰器可以装饰多个函数
一个函数可以有多个装饰器（很少用）

将它赋值给一个变量

拷贝它

为它增加属性

将它作为函数参数进行传递

创建一个类

实例对象由类对象创建，所以type（实例对象），出来的是对应的类
而类对象是由type创建，所以type（类对象），出来的是type。
object也是类，所有类都继承于object，但其创建者是type

type函数的第二种用法（自己写函数不要让一个函数有两种完全不同的功能）

例

例

只执行一个分支

except后面跟一个元组

自定义的异常要继承Exception

先定义一个异常类

在函数中主动抛出异常

调用函数

str_1='d52a733i2327ha244i982d23s553b245'

https://docs.python.org/zh-cn/3.9/library/exceptions.html#exception-hierarchy

不知道会有什么异常就用这个

'r'

'a'

'w'

‘w+’

'x'

't'

'b'

'rb'

'wb'

'ab'

'wb+'

注意：尽量一次只用一种模式，+模式好像不太好用

从根文件夹开始

相对于当前工作目录的路径

文件名这里写路径，不论是绝对路径还是相对路径

知名端口0-1023

1024 < 可用端口 < 10000

文本、二进制文件【图片音频视频】

不严格区分客户端和服务端

一对多

网络直播
游戏
部分物联网

严格区分客户端和服务端

发送数据前会先链接服务器，如果检查服务器不在线，就抛出异常

一对一

发送信息

循环发送

接收消息

循环接收

可选择聊天器

客户端

服务器

注意事项

文件下载服务器

线程有开始、顺序执行和结束3部分，有一个自己的指令指针，记录运行到什么地方。
线程的运行可能被抢占（中断）或暂时被挂起（睡眠），从而让其他线程运行，这叫作让步。

线程是运行代码的一个最基本的资源

运行代码
     是有线程去执行的

CPU读取内存中，代码的二进制数据。
由进程分配内存（进程是操作系统资源的一个分配的单位）

进程创建一个线程对象去运行代码

代码运行起来都是单线程程序
       操作系统创建一个进程来分配系统资源
       进程创建一个线程来运行代码

让进程创建多个线程来执行文件

多核CPU

时间片轮训

并行

并发

python同一时刻只能运行一个线程，但切换速度快也能称之为多任务

单线程

多线程

主线程和子线程

导入包

定义要运行的2个函数

放入线程

输出结果

前面都一样

关键是调用join（）

输出

比如下载10部电影
  首先开10个线程，获取电影数据
  join（）等待执行完成
  再开10个线程，下载电影数据

其他都一样，就是在线程start后print调用enumerate方法

如果多个线程同时对同一个全局变量操作，
会出现资源竞争问题，
从而数据结果会不正确。

互斥锁（避免资源竞争）

创建类，继承threading.Thread

创建实例对象，
因为有继承父类，
所以实例对象可以调用父类的start方法

先导包

消息控制类
用于处理连上服务器后
接收传过来的消息和服务器信息

TCP套接字
在initi里建套接字，绑本地信息，改listen
在run里accept，调用Message（接收信息），start

主函数
启动服务器

启动后可以同时连多个客户端

threading.Thread(target=子线程函数，daemon=True)

启动新线程成本高，涉及与操作系统交互。
尤其当需要创建大量生存期很短的线程时，线程池可极大提高性能.
且线程过多系统会卡，池可以限制运行的线程数量

创建大量空闲线程（指定数量）
有任务则启动执行，任务结束后返回空闲状态

包

创建对象

提交线程给池

判断线程是否结束

查看任务返回结果（阻塞，没算出结果阻塞当前线程）

关池

整体

用add_done_callback()，不阻塞

map()，同个函数不同参数

就绪态

执行态

等待态

属性

方法

不加p.join()，最后一个返回还是True，
因为系统回收进程需要时间，主程序直接运行等不到

Process（target=要运行的对象）

os.getpid（）获取当前进程pid
os.getppid（）获取当前进程父进程pid

子进程是复制了主进程的代码重新开辟的一块新内存
线程是同一个进程内的操作，就是同一块内存空间
进程是重新开辟新内存空间

代码说明

队列：先进先出列表（栈是先进后出）

通过队列实现进程通信

概念

案例

线程和进程都是计算机提供的
都是os提供的api，就是系统层面的功能接口，
python只是负责调度。
但协程是完全python创建的，语言层面的创造。
多线程其实也只有一个线程在运行，其他线程等在那也会浪费一些性能
所以不如就开一个线程。

协程性能大于多线程

协程的大致运行状态：
在一个线程中运行多个任务，
任务和任务之间来回切换，
并在同一时间内只能运行一个任务

greenlet（现在不用）

或者用yield（也很牵强，因为yield只能从上往下）

@asyncio.coroutine

主流用法

单线程爬虫

协程爬虫

原理

创建

基本应用

等待某些IO任务
await + 可等待对象

await探究

普通型（代码重复）

task放入列表

asyncio.run
中封装了loop和creat_task

创建task对象时，要保证事件循环已经存在

如果创建一个全局列表
1.列表中放入协程函数对象，
2.再用asyncio.wait（）将列表转为可等待对象
3.然后再用run

task是继承future的
在future对象中会保存当前执行的这个协程任务的状态
如果当前任务状态为finished，则await不再等待

有些库不支持协程，这时就可以用线程\进程池

# 迭代器执行的代码一般是IO耗时操作

数据表必须有表名

表中有字段

数据有类型

一些字段可能存在约束

表与表之间有关系

int

bit二进制整型（0false,1true）

tinyint

decimal（精度高）别名：货币类型

float

创建字符串要规定长度

varchar（常用）

char

text（超过255字符）

date

time

datetime

enum

primary key

not null

unique

default

foreign key

子主题

auto_increment

--这是一个注释

/*
多行
*/

mysql -uroot -p

show databases;

use 数据库名；

select database();

create database 数据库名 charset=utf8;

show create database 数据库名;

drop database 数据库名;

\q，exit

show tables;

create TABLE classes(
  id int UNSIGNED auto_increment PRIMARY KEY not null,
  name VARCHAR(10) not NULL
);

desc 表名；

表添加新列

重命名

不重命名

alter table 表名 drop 字段名；

show create table 表名；

drop table 表名；

select * from 表名；

select 字段，字段 from 表名；

设别名

去重

条件

排序

聚合函数

分组

分页

连接查询

自关联

子查询（可替代）

全字段

部分字段

多行插入

update 表名 set 字段1=值1，字段2=值2.... where 条件；

delete from 表名 where 条件；

is_delete=0 False，在页面中显示数据
is_delete=1 True，隐藏数据，数据在库里，但看不懂

create view 视图名 as select语句

drop view 视图名

特性ACID

操作（有头有尾不出错）

例

存在磁盘里，不删会一直在

页面缓存，验证码

select 10，选择10号数据库

字符串string

键命令

哈希hash

列表list

无序集合set

有序集合zset

终端进入

查看当前数据库

查看数据库s

切换or新建数据库

删除当前数据库

看当前数据库版本

创建数据库

查看集合s

删除集合

数据类型

数据操作

索引优化（一般情况下MongoDB不设置索引）

1.利用pymysql连接数据库

2.创建表

3.插入数据（更新表/删除表也一样，就是sql不一样）

插入数据，使用execute（）的参数

from redis import Redis

redis_obj = Redis(host='localhost', port=6379, db=0)

2.添加字符串

3.获取数据

4.修改数据（重新set）

5.删除key

6.获取key

太长了，点击图片查看

client['数据库']['集合']，不存在对应数据库或者集合，会自动创建

单条

多条

find_one( )
find( )

一条

多条

一条

多条

action属性 设置表单数据提交地址

method属性 设置表单提交的方式，一般有“GET”方式和“POST”方式, 不区分大小写

name属性 设置表单元素的名称，该名称是提交数据时的参数名

value属性 设置表单元素的值，该值是提交数据时参数名所对应的值

<style type="text/css">
    p{
        color: red;
    }
</style>

<style type="text/css">
    .blue{color:blue}
    .big{font-size:20px}
    .box{width:100px;height:100px;background:gold} 
</style>

<div class="blue">这是一个div</div>
<h3 class="blue big box">这是一个标题</h3>
<p class="blue box">这是一个段落</p>

E 的所有 F 后代

E 的所有 子 F

G和F同父，F紧接在G之后

G和F同父，F在G后面

.box1,.box2,.box3{width:100px;height:100px}

overflow的设置项：
1. visible 默认值, 显示子标签溢出部分。
2. hidden 隐藏子标签溢出部分。
3. auto 如果子标签溢出，则可以滚动查看其余的内容。

none 元素隐藏且不占位置
inline 元素以行内元素显示
block 元素以块元素显示

javaScript 是一种弱类型语言，也就是说不需要指定变量的类型，JavaScript的变量类型由它的值来决定

1、返回函数中的值 2、执行完return函数执行结束

常用于 <input>, <select>, 和<a>

start：必需，开始删除的索引。
num：可选，删除数组元素的个数。
elementN：可选，在start索引位置要插入的新元素。

条件不成立时，do也会执行一次

setTimeout(func[, delay, param1, param2, ...]) 

setInterval(func[, delay, param1, param2, ...])

ECMAScript标准

DOM

BOM

navigator.webdriver
是否是模拟浏览器

<script>
    var person = new Object();

    // 添加属性：
    person.name = 'tom';
    person.age = '25';

    // 添加方法：
    person.sayName = function(){
        alert(this.name);
    }

    // 调用属性和方法：
    alert(person.age);
    person.sayName();
</script>

<script>
    var person2 = {
        name:'Rose',
        age: 18,
        sayName:function(){
            alert('My name is' + this.name);
        }
    }

    // 调用属性和方法：
    alert(person2.age);
    person2.sayName();
</script>

<script>
    $(function(){
        var $div = $('#div01');

        $div.prev().css({'color':'red'});
        $div.prevAll().css({'text-indent':50});
        $div.next().css({'color':'blue'});
        $div.nextAll().css({'text-indent':80});
        $div.siblings().css({'text-decoration':'underline'})
        $div.parent().css({'background':'gray'});
        $div.children().css({'color':'red'});
        $div.find('.sp02').css({'font-size':30});
    });  
</script>

点击子元素，点击事件会向它父级元素传递，也会触发父元素的点击事件

一次性绑定所有子元素

$父元素 . delegate(子元素，事件名，执行函数)

事件绑定在父元素上，执行对应子元素才会临时绑定一次事件

列子：
https://www.baidu.com/item/10056474?fr=aladdin http://IP:port/资源路径/?wd=python#flg 
协议 ：这代表网页使用的请求协议

域名部分：该URL的域名部分为“www.baidu.com”。一个URL中，也可以使用IP地址作为域名使用：202.108.22.5

端口部分：跟在域名后面的是端口，域名和端口之间使用“:”作为分隔符。端口不是一个URL必须的部分，如果省略端口部分。

资源部分：从域名后的最后一个“/”开始到“？”为止，是资源部分

查询参数：从“？”开始到“#”为止之间的部分为参数部分，又称搜索部分、查询部分

1.浏览器向地址栏中的URL发起请求，并获取相应

2.在返回的响应内容（html）中，会带有css、js、图片等url地址，以及ajax代码，
浏览器按照响应内容中的顺序依次发送其他的请求，并获取相应的响应

3.浏览器每获取一个响应就对展示出的结果进行添加（加载），
js，css等内容会修改页面的内容，js也可以重新发送请求，获取响应

4.从获取第一个响应并在浏览器中展示，直到最终获取全部响应，并在展示的结果中添加内容或修改
————这个过程叫做浏览器的渲染

注：但是在爬虫中，爬虫只会请求url地址，
对应的拿到url地址对应的响应（该响应的内容可以是html，css，js，图片等）
浏览器渲染出来的页面和爬虫请求的页面很多时候并不一样
所以在爬虫中，需要以url地址对应的响应为准来进行数据的提取

f12面板

一般常用的就get和post两个

，即统一资源定位符 URL，它可以唯一确定我们想请求的资源。

POST 请求中的表单数据，而对于 GET 请求，请求体则为空

组成

1.响应状态码Status Code

2. 响应头Response Headers

3. 响应体Response、（图片在Preview里看）

响应体str类型

响应体bytes类型

响应体json类型

响应状态码

请求头

响应头

响应的cookie

也是字典
一般会有很多参数，删掉没用的，一个个试

检测代理ip是否可用

在request headers里找到cookies，然后加在header里
cookie的内容都是键值对，去键和值就行

以键值对的方式，传参给cookies=

session实例在请求了一个网站后，对方服务器设置在本地的cookie会保存在session中，
下一次再使用session请求对方服务器的时候，会带上前一次的cookie

response.cookies是CookieJar类型
使用requests.utils.dict_from_cookiejar，能够实现把cookiejar对象转化为字典

在前面的requests的session类中，我们不需要处理cookie的任何细节，
如果有需要，我们可以使用这个

ssl的证书不安全导致

response = requests.get(url,timeout=3)

@retry(stop_max_attempt_number=3)
重试3次再报错

result = re.match（正则表达式，要匹配的字符串）
result.group（）提取数据group(0是匹配的信息，1,2...是其中组里的内容)

匹配不到会报错，所以用的少

match（从头找一个）

search（找一个）

findall（找所有）

sub（替换）

compile（编译）

{m，n}中间不能加空格

^开头字符
结尾字符$

[^字符字符字符]

不转译(比如Windows中的路径)

[\u4e00-\u9fa5]

非贪婪：在量词后面加？

爬取前十页列表中的小说名

线程池异步爬取猫眼电影图片

快速的定位特定元素以及获取节点信息

语法

例

from lxml import etree

html = etree.HTML(text) 
ret_list = html.xpath("xpath字符串")

把每个小说的详情页面链接和小说的名字组成一个字典

爬取链家网里的租房信息获取【标题，位置，房屋的格局（三室一厅），关注人数，单价，总价】

find_all(name, attrs, recursive, text, **kwargs)
返回列表

find

css选择器

获取文本

获取属性

python对象转成json对象，生成字符串

dict类型数据转成str，并写入json文件中

json字符串解码成python

从json文件中读取数据

JSON数据只能有一个顶级[ ]or{ }，所以要循环写入多个数据，要注意数据格式

import csv 
with open('data.csv', 'w') as csvfile: 
    writer = csv.writer(csvfile) 
    writer.writerow(['id', 'name', 'age']) 
    writer.writerow(['10001', 'Mike', 20]) 
    writer.writerow(['10002', 'Bob', 22]) 
    writer.writerow(['10003', 'Jordan', 21])

q = Queue(maxsize=100)

q.put(值)

q.put_nowait(值)

q.get()

q.get_nowait()

获取队列中现存数据的个数

队列中维持了一个计数，
计数不为0时候让主线程阻塞等待，
队列计数为0的时候才会继续往后执行

put的时候计数+1，get不会-1，get需要和task_done 一起使用才会-1

E:\1palegechong\1图灵\7.爬虫\4.高性能爬虫

E:\1palegechong\1图灵\7.爬虫\4.高性能爬虫

占资源，但也不是用不到

用不到

对比

browser = webdriver.Chrome()
browser = webdriver.Firefox()
browser = webdriver.Edge()
browser = webdriver.PhantomJS()
browser = webdriver.Safari()

browser.get("http://www.baidu.com/")

browser.maximize_window()

browser.set_window_size(480, 800)

js_code = 'window.open("http://httpbin.org/ip");'
browser.execute_script(js_code)

browser.find_element(By.NAME,'wd').send_keys("selenium")

browser.find_element(By.ID,"su").click()

print(browser.page_source.encode('utf-8'))

print(browser.get_cookies())

print(browser.get_screenshot_as_file('123.png'))

print(browser.current_url)

关闭浏览器

关闭当前页面

禁止加载图片

关闭自动关闭

无头模式
不打开浏览器，在后台运行

关这个

设置user agent

添加插件

设置代理

通过标签name

ID选择器

css选择器

xpath选择器

列表中的每个节点都是 WebElement 类型

输入文字

清空文字

点击按钮

from selenium import webdriver
from selenium.webdriver import ActionChains

browser = webdriver.Chrome()
url = 'http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable'
browser.get(url)
log = browser.find_element(By.XPATH, '//div[@id="iframewrapper"]/iframe')
browser.switch_to.frame(log)
source = browser.find_element(By.CSS_SELECTOR,'#draggable')
target = browser.find_element(By.CSS_SELECTOR,'#droppable')
actions = ActionChains(browser)
# 按住source，拖到target后放
actions.drag_and_drop(source, target)
# 执行
actions.perform()

# 浏览器滚动到底部 10000位置
document.documentElement.scrollTop=10000
# 滚动到顶部
document.documentElement.scrollTop=0

# 移动到页面最底部  
window.scrollTo(0, document.body.scrollHeight)
 
# 移动到指定的坐标(相对当前的坐标移动)
window.scrollBy(0, 700)
# 结合上面的scrollBy语句，相当于移动到700+800=1600像素位置  
window.scrollBy(0, 800)
 
# 移动到窗口绝对位置坐标，如下移动到纵坐标1600像素位置  
window.scrollTo(0, 1600)
# 结合上面的scrollTo语句，仍然移动到纵坐标1200像素位置  
window.scrollTo(0, 1200)

from selenium import webdriver
from selenium.webdriver.common.by import By


url = 'https://pic.netbian.com/4kmeinv/index.html'
browser = webdriver.Chrome()
browser.get(url)
src = browser.find_elements(By.XPATH, '//ul[@class="clearfix"]/li/a/img')
for i in src:
    url = i.get_attribute('src')
    print(url)

print(browser.window_handles)

browser.switch_to.window(browser.window_handles[1])

https://selenium-python.readthedocs.io/api.html#module-selenium.common.exceptions

加选项，设置屏蔽

f12 console，判断是否是模拟浏览器

最好用管理员打开cmd

下载了别人的项目，导入别人的requirements

scrapy已实现

scrapy已实现

scrapy已实现

需要手写

需要手写

一般不用手写

一般不用手写

下载后scrapy，查看信息

一键生成各种模块

scrapy genspider douban movie.douban.com

scrapy crawl douban（爬虫name）--nolog（无日志）

1. response.xpath方法的返回结果是一个类似list的类型，其中包含的是selector对象，操作和列表一样，但是有一些额外的方法
2. extract() 返回一个包含有字符串的列表
3. extract_first() 返回列表中的第一个字符串，列表为空没有返回None
4. spider中的parse方法必须有
5. 需要抓取的url地址必须属于allowed_domains,但是start_urls中的url地址没有这个限制
6. 启动爬虫的时候注意启动的位置，是在项目路径下启动

response对象属性

在爬虫文件douban.py中parse()函数中最后添加
yield item
**注意：yield能够传递的对象只能是：BaseItem,Request,dict,None**

class MyspiderPipeline:
    # 爬虫文件中提取数据的方法每yield一次item，就会运行一次
    # 该方法为固定名称函数
    def process_item(self, item, spider):
        print(item)

ITEM_PIPELINES

这里要在配置里关闭pipeline

cmdline.execute('scrapy crawl douban -o douban.json -s FEED_EXPORT_ENCODING="utf-8"'.split())

- CRITICAL：严重错误
- ERROR：一般错误
- WARNING：警告
- INFO: 一般信息
- DEBUG：调试信息

**注意：** 默认的日志等级是DEBUG

Versions:所使用的工具版本信息
Overridden settings： 重写的配置
Telnet Password：Telnet 平台密码（Scrapy附带一个内置的telnet控制台，用于检查和控制Scrapy运行过程）
Enabled extensions ：开启的拓展功能
Enabled downloader middlewares：开启的下载器中间件
Enabled spider middlewares：开启的爬虫中间件
Enabled item pipelines：开启的管道
Dumping Scrapy stats：所以的信息汇总

修改配置文件

1. 找到下一页的url地址
2. 构造url地址的请求，传递给引擎

重写start_requests方法
(只要重写方法就行，不用考虑调用的问题)

scrapy.Request(url[,callback,method="GET",headers,body,cookies,meta,dont_filter=False])

1. 中括号中的参数为可选参数
2. callback：表示当前的url的响应交给哪个函数去处理
3. meta：实现数据在不同的解析函数中传递，meta默认带有部分数据，比如下载延迟，请求深度等
4. dont_filter:默认为False，会过滤请求的url地址，即请求过的url地址不会继续被请求，对需要重复请求的url地址可以把它设置为Ture，比如贴吧的翻页请求，页面的数据总是在变化;start_urls中的地址会被反复请求，否则程序不会启动
5. method：指定POST或GET请求
6. headers：接收一个字典，其中不包括cookies
7. cookies：接收一个字典，专门放置cookies
8. body：接收一个字典，为POST的数据

meta的形式:字典
meta的作用：meta可以实现数据在不同的解析函数中的传递

特别注意
1. meta参数是一个字典
2. meta字典中有一个固定的键`proxy`，表示代理ip，关于代理ip的使用我们将在scrapy的下载中间件的学习中进行介绍
3. meta的download_timeout设置请求超时

例子

在items.py文件中定义要提取的字段：

修改douban.py

- response.xpath()：直接测试xpath规则是否正确
- response.url：当前响应的url地址
- response.request.url：当前响应对应的请求的url地址
- response.headers：响应头
- response.body：响应体，也就是html代码，默认是byte类型
- response.requests.headers：当前响应的请求头

process_item(self,item,spider):实现对item数据的处理

open_spider(self, spider): 在爬虫开启的时候仅执行一次

close_spider(self, spider): 在爬虫关闭的时候仅执行一次

首先在settings里开启pipeline

然后修改pipeline.py

1. 不同的pipeline可以处理不同爬虫的数据，通过spider.name属性来区分
2. 不同的pipeline能够对一个或多个爬虫进行不同的数据处理的操作，比如一个进行数据清洗，一个进行数据的保存
3. 同一个管道类也可以处理不同爬虫的数据，通过spider.name属性来区分

1. 使用之前需要在settings中开启
2. pipeline在setting中键表示位置(即pipeline在项目中的位置可以自定义)，值表示距离引擎的远近，越近数据会越先经过
3. 有多个pipeline的时候，process_item的方法必须return item,否则后一个pipeline取到的数据为None值
4. pipeline中process_item的方法必须有，否则item没有办法接受和处理
5. process_item方法接受item和spider，其中spider表示当前传递item过来的spider
6. open_spider(spider) :能够在爬虫开启的时候执行一次
7. close_spider(spider) :能够在爬虫关闭的时候执行一次
8. 上述俩个方法经常用于爬虫和数据库的交互，在爬虫开启的时候建立和数据库的连接，在爬虫关闭的时候断开和数据库的连接

1. 主要功能是在爬虫运行过程中进行一些处理，如对非200响应的重试（重新构造Request对象yield给引擎）
2. 也可以对header以及cookie进行更换和处理
3. 其他根据业务需求实现响应的功能

方法汇总

实操

- 请求时数字越小权重越高,越先执行    
- 响应时数字越大越先执行

var x;
此时x是undefined

var x = 2
x = 3

JS引擎在预编译代码时，会优先获取所有被var声明的变量和function声明的函数，将它们放在代码的头部然后从上到下执行。
且函数提升优于变量提升

块作用域由 { } 包括

只有等到声明变量的那一行代码出现，才可以获取和使用该变量

这也意味着const声明时就必须初始化，不能等到之后赋值。

>>456
>>123
这里就涉及函数提升，函数声明会提到前面去

多个自执行函数，在前面加个修饰符，常用 ！

定义一个全局变量，
把函数体赋值给全局变量，
然后就能调用这个内部函数了

>>[Arguments] { '0': 1, '1': 2, '2': 3, '3': 6, '4': 5 } object
>>undefined

类型是object
不论传入的参数数量与定义的参数数量是否一致，都可以看到

var car = {name:"xialuo", model:500, color:"white"};

person = new Object();

person.firstname="John";
person.lastname="Doe";
person.age=50;

属性的值

var person = {
   firstName: "xl",
   lastName : "lili",
   id : 5566,
   fullName : function()
   {
      return this.firstName + " " + this.lastName;
   }
};

可以使用替换技术把解混淆的JS放进去调试
  注：只可以针对原文件
JS 他是一个文件地址  原理就是关系映射
  用处：1、删除JS里面的debugger   2、替换混淆JS  3、替换动态变化JS文件

这里有全部的浏览器环境、扣JS的时候可以使用他调试 先跑通JS再去pycharm里面补环境即可

js标签是从上往下顺序单线程加载的

做逆向的的时候 重点是关注发包

dom断点（在加密前断点）

xhr断点（在加密后）

1.

2.

function 目标方法（）{ }

var _constructor = constructor;
Function.prototype.constructor = function(s) {
    
    if ( s== "debugger") {
        console.log(s);
        return null;
    }
    return _constructor(s);
}