您的位置:澳门皇家赌场真人在线 > 皇家赌场游戏 > Python之爬虫总括,数据类型和进制转变

Python之爬虫总括,数据类型和进制转变

发布时间:2019-11-09 07:40编辑:皇家赌场游戏浏览(109)

     

    一、爬虫之requests

    正文首要内容

      类别类型分类:

        (1卡塔 尔(阿拉伯语:قطر‎容器类别、扁平种类

        (2卡塔 尔(英语:State of Qatar)可变系列、不可变种类

      列表推导式

      生成器表达式

      元组拆包

      切片

      排序(list.sort方法和sorted函数)

      bisect

     

    python高级——目录

      文中代码均位于github上:https://github.com/ampeeg/cnblogs/tree/master/python高级

     

    松开操作

    软件名:anaconda  版本:Anaconda3-5.0.1-Windows-x86_64浙大镜像  下载链接:

    软件名:Pycharm  版本:pycharm-professional-2017.3.2  下载地址:百度就可以

    软件名:python    版本:3.6      下载地址:python.org

     


     

    澳门皇家赌场 1

    古板的给文件链接加多版本号的点子是行使gulp-rev,这里提出的缓和方案是选取python来替代gulp-rev。

        a、介绍:接收requests能够效仿浏览器的号令,比起在此之前使用的urllib,requests模块的api特别简便易行(本质正是包裹了urllib3卡塔 尔(阿拉伯语:قطر‎

    队列类型分类

     

       所谓系列,即成分有序排列,python标准库用C实现了增加的队列类型,根据体系中是还是不是可存放分裂等级次序的数据分为"容器体系"和"扁平体系"。

      容器连串能够存放统统类型的多少,而扁平类别只好存放黄金时代种类型      

        容器序列:list、tuple、collections.deque   
        扁平序列:str、bytes、bytearray、memoryview、array.array
      
      按照是否能修改的标准序列又可分为"可变序列"和"不可变序列":      
        可变序列:list、bytearrary、array.arrary、collections.deque和memoryview   
        不可变序列:tuple、str和bytes
    
      由于可变序列继承自不可变序列,所以可变序列继承的方法也较多,下面看看它们包含的方法:   
    
    方法名 不可变序列 可变序列
    __contains__  有 有 
    __iter__  有  有 
     __len__  有  有 
    __getitem__   有  有 
    __reversed__   有  有 
    index   有  有 
    count   有  有 
    __setitem__    有 
    __delitem__   有 
    insert   有 
    append   有 
    reverse   有 
    extend   有 
    pop   有 
    remove   有 
    __iadd__    有 

      

      大家以tuple和list类型为例,比较源代码中的方法,能够肯定开采list的章程多于tuple:

    澳门皇家赌场,  

    澳门皇家赌场 2

     

    conda安装

     

        b、注意:requests发送伏乞是将网页内容下载来今后,并不会奉行js代码,那要求大家友好解析目的站点然后发起新的requests诉求

    列表推导式

    # 列表推导式生成的是列表,会占用系统内存
    # 基本语法
    
    list_1 = [x for x in range(1, 20)]
    list_2 = [x ** 2 for x in range(1, 20)]
    
    
    print(list_1)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    print(list_2)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
    
    # 笛卡尔积型的列表推导式
    list_3 = [(x, y) for x in range(1, 3)        # 1,2
                     for y in range(7, 10)]      # 7、8、9
    
                                                 # 该表达式会先将1分别和7、8、9组合,然后再拿2和7、8、9组合,共6对
    print(list_3)  # [(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9)]
    
    
    list_4 = [x+y for x in range(1, 3)
                     for y in range(7, 10)]
    
    print(list_4)   # [8, 9, 10, 9, 10, 11]
    
    # 还可以添加if语句
    l = [1, 3, 4, 33, 45, 36, 422, 34, 67, 23, -4, -7, -345, 46, -6, -45, 32, -8, -4, 67, -4]
    
    list_5 = [x for x in l if x > 0]   # 只取出大于0的生成列表
    print(list_5)                      # [1, 3, 4, 33, 45, 36, 422, 34, 67, 23, 46, 32, 67]

     

    Step 1: anaconda安装及注意事项

    1. 暗中同意步骤安装
    2. 设置中勾选增添遭受变量    澳门皇家赌场 3
    3. 安装完成后,能够在Windows的cmd中实行python命令,看是还是不是足以进来python运营分界面

    4. 翻开系统情形变量中的客商path变量(作者的新闻如右卡塔 尔(阿拉伯语:قطر‎:C:Anaconda3;C:Anaconda3Librarymingw-w64bin;C:Anaconda3Libraryusrbin;C:Anaconda3Librarybin;C:Anaconda3Scripts

    5. 翻开安装完结的包: Windows命令行奉行:conda list
    import os
    import re
    import uuid
    import sys
    
    
    def file_extension(path):
        return os.path.splitext(path)[1]
    
    
    basePath = sys.argv[1]
    if len(sys.argv)==1:
        sys.exit()
    
    
    html_list = []
    
    
    def find_html(path):
        files = os.listdir(path=path)
    
        for item in files:
            abs_path = os.path.join(path, item)
            if not os.path.isdir(abs_path) and file_extension(abs_path) == ".html":
                html_list.append(abs_path)
    
            if (os.path.isdir(abs_path)):
                find_html(abs_path)
    
    
    def deal_html(html_list):
        for html_path in html_list:
            html_file = open(html_path, "r+", encoding='UTF-8')
            content = html_file.read()
            # print(html_file.read())
            # res = re.sub(r'<link (.*) href="(.*).css".*>',r'<link 1 href="2.css?v=1"3>',content)
            res1 = re.sub(r'<link (.*) href="(.*).css.*"(.*)>', lambda x: '<link ' + x.group(1) + ' href="' + x.group(
                2) + '.css?v=' + uuid.uuid1().hex + '"' + x.group(3) + '>', content)
            res2 = re.sub(r'<script src="(.*).js.*"></script>',
                          lambda x: '<script src="' + x.group(1) + '.js?v=' + uuid.uuid1().hex + '"></script>', res1)
            html_file.seek(0)
            html_file.truncate()
            html_file.write(res2)
            html_file.close()
    
    
    if __name__ == '__main__':
        find_html(basePath)
        deal_html(html_list)
    

        c、安装:pip3 install requests

    生成器表明式

    # 虽然列表推导式可以用来初始化元组、数组或其他序列类型,但是列表推导式会直接生成列表,占用内存
    # 而生成器遵守了迭代器协议,可以逐个产出元素,而不是先建立一个完整的列表
    
    
    # 生成器表达式直接将推导式的方括号换成圆括号即可
    
    g = (x for x in range(1, 10000))
    
    print(g)    # <generator object <genexpr> at 0x105c0efc0> :生成器对象
    
    
    from collections import Iterable, Iterator
    
    if isinstance(g, Iterable):
        print("iterable")          # 输出iterable: 说明生成器g是可迭代的
    
    if isinstance(g, Iterator):
        print("iterator")          # 输出iterator:说明生成器g是迭代器

     

      下边大家来对待一下列表推导式和生成器的频率

    # 比较列表推导式和生成器
    import time
    
    start_time = time.time()
    l = [x for x in range(1000000)]
    print(time.time() - start_time)     # 0.1361069679260254
    
    start_time = time.time()
    g = (x for x in range(1000000))
    print(time.time() - start_time)     # 1.1205673217773438e-05
    
    # 可见,生成器远快于推导式

     

    Step 2:   安装pycharm

    1. 自定义一个步骤,至于cdkey,csdn比非常多
    2. pycharm关联conda中的python解释器的格局,参照他事他说加以调查链接: 

     

    将以上代码另存成auto_version.py文件后,新建auto_version.bat文件,写入以下内容:

        d、各类哀告格局,常用的是requests.get()和requets.post()

    元组拆包

    # 我们经常这样给两个变量同时赋值
    a, b = 1, 2
    print(a, b)     # 1 2
    
    # 还可以这样
    a, b = [1, 2]
    print(a, b)     # 1 2
    
    # 也可以这样
    a, b = (1, 2)
    print(a, b)     # 1 2
    
    # 甚至可以这样
    a, b = "ab"
    print(a, b)     # a b
    
    '''
        像以上这样连续的赋值方式,右边可以使用逗号隔开;也可以是序列。
    
        当拆包赋值的是序列时,python解释器会先找该序列中的__iter__方法,如果该方法不存在,则寻找__getitem__方法。
    
        接下来说其他用法
    '''
    
    # 赋值后优雅地交换两个变量
    a, b = (1, 2)
    a, b = b, a
    print(a, b)        # 2 1
    
    # 使用*号来处理多余的数据
    a, b, *s = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(a, b, s)        # 1 2 [3, 4, 5, 6, 7, 8, 9]
                          # 这样从第三个元素开始的所有值都赋给了s
    
    a, b, *s = (1, 2, 3, 4, 5, 6, 7, 8, 9)
    print(a, b, s)        # 1 2 [3, 4, 5, 6, 7, 8, 9]
                          # 注意,本来是元组,赋之后的s变成了列表. 如果s为空的话也会返回空列表
    
    *s, a, b = (1, 2, 3, 4, 5, 6, 7, 8, 9)
    print(s, a, b)        # [1, 2, 3, 4, 5, 6, 7] 8 9
                          # *s也可以放在前面
    
    a, *s, b = (1, 2, 3, 4, 5, 6, 7, 8, 9)
    print(a, s, b)        # 1 [2, 3, 4, 5, 6, 7, 8] 9
                          # *s也可以放在中间
    
    # 嵌套元组拆包
    a, b, (c, d) = (1, 2, (3, 4))
    print(a, b, c, d)     # 1 2 3 4
                          # 只要按照右边的形式就可赋值
    
    a, b, *c = (1, 2, (3, 4))
    print(a, b, c)     # 1 2 [(3, 4)]

     

    澳门皇家赌场 4澳门皇家赌场 5

     1 ################################
     2 #
     3 # 以下的例子用以说明拆包赋值时,解释器会按照__iter__、__getitem__的顺序调用类中的方法
     4 #
     5 ################################
     6 class Foo:
     7     def __init__(self, s):
     8         self.s = s
     9 
    10     def __iter__(self):
    11         print("iter")
    12         return iter(self.s)
    13 
    14     def __getitem__(self, item):
    15         return self.s[item]
    16 
    17 if __name__ == "__main__":
    18     foo = Foo("sdfafasfasf")
    19     a, b, *s = foo
    20     print(a, b)
    

    拆包赋值的中间贯彻

     

      在此之前我们经过源码已经相比过list和tuple类中的方法和属性,上边列出《流畅的python》收拾的列表和元组的章程及质量:

    表 列表或元组的不二秘技和天性

      列  表 元  组
    s.__add__(s2)
    · ·
    s.__iadd__(s2) ·  
    s.append(e) ·  
    s.clear() ·  
    s.__contains__(e) · ·
    s.copy() ·  
    s.count(e) · ·
    s.__delitem__(p) ·  
    s.extend(it) ·  
    s.__getitem__(p) · ·
    s.__getnewargs__()   ·
    s.index(e) · ·
    x.insert(p,e) ·  
    s.__iter__() · ·
    s.__len__() · ·
    s.__mul__(n) · ·
    s.__imul__(n) ·  
    s.__rmul__(n) · ·
    s.pop([p]) ·  
    s.remove(e) ·  
    s.reverse() ·  
    s.__reversed__() ·  
    s.__setitem__(p,e) ·  
    s.sort([key], [reverse]) ·  

       

      表明:以上元组中不加黑点的不意味着绝不可这么使用,只是其成效和列表分化(表明里面有表达卡塔 尔(阿拉伯语:قطر‎。举例五个元组a和b举行增量赋值a+=b也是可以的,只是那些操作不是就地拼接,而是生成了新的元组。

    合法安装 

    python ./auto_version.py "D:your project dir"
    

    二、基于get请求

    切片

    '''
        在python中,内置的序列类型都支持切片操作,切片操作的用法十分简单:
        list[start: stop: step]    , 其中不包括区间范围内最后一个(事实上这是python的风格,一般不包含区间最后一个)
        python里面能使用切片操作是因为实现了__getitem__方法,切片时会给该方法传递slice(start: stop: step) 参数
    '''
    
    if __name__ == "__main__":
        # 基本操作
        l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        print(l[2:])     # 第3个元素到最后   :[3, 4, 5, 6, 7, 8, 9]
        print(l[:3])     # 第一个元素到最后   :[1, 2, 3]
    
        s = "abcdefghijklmn"
        print(s[2::2])   # 从第三个字母开始,隔一个字母取一个 : cegikm
        print(s[::-1])   # 倒序排列 : nmlkjihgfedcba
        print(s[::-2])   # 倒序隔一个取一个 nljhfdb
        print(s[-2::-2]) # 倒序第二隔开始,隔一个取一个
    
        # 利用切片赋值
        l[2:5] = [20, 30]
        print(l)         # [1, 2, 20, 30, 6, 7, 8, 9]
        try:
            l[2:5] = 40      # 报错:TypeError: can only assign an iterable
                             # 利用切片赋值时传入的必须是可迭代对象
        except Exception as e:
            print(e)         # can only assign an iterable
        l[2:5] = (40,)
        print(l)             # [1, 2, 40, 7, 8, 9]
        l[2:3] = "sajfljls"  # 字符串属于序列,也可以迭代
        print(l)             # [1, 2, 's', 'a', 'j', 'f', 'l', 'j', 'l', 's', 7, 8, 9]

     

    Step 3:  安装python3

    1. 跻身python.org下载最新python,链接:
    2. 设置python3.6时只顾勾选增多情况变量选项,澳门皇家赌场 6

       

    3. pip安装 澳门皇家赌场 7

       

       

       

    纠正巧.bat文件里的路子后,双击运转就能够。

    Python之爬虫总括,数据类型和进制转变。    a、基本诉求

    排序(list.sort方法和sorted函数)

    '''
        list.sort方法和sorted内置函数都有排序的功能,区别如下
            list.sort是就地排序列表,不会把原列表复制一份。该方法返回None,以提醒不会新建一个列表。
            sorted函数会新建一个列表作为返回值,这个函数可以接受任何可迭代对象,甚至包括不可变序列或生成器,最后返回的总是列表。
    
        list.sort和sorted都有两个参数:
            reverse:默认为False,设定为True以降序排列
            key:一个只有一个参数的函数,这个函数会作用于序列的每一个元素上,然后以该函数的结果作为关键字排序
    
    '''
    
    if __name__ == "__main__":
        # 1、list.sort就地排序,而sorted返回列表
        l = [x for x in range(10, 0, -1)]      # 初始化一个列表:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
        print(id(l), l)    # l最初的地址:4536449800 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
        l.sort()
        print(id(l), l)    # 排序后的地址:4536449800 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
                           # l前后的的地址没变,说明是就地排序
    
    
        l = [x for x in range(10, 0, -1)]  # 初始化一个列表:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
        print(id(l), l)  # l最初的地址:4415318984 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
        l = sorted(l)
        print(id(l), l)  # 排序后的地址:4415318792 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
        # 2、sorted可以接受任何可迭代对象
        l = (x for x in range(10, 0, -1))
        print(type(l))        # 迭代器 <class 'generator'>
        print(sorted(l))      # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
        s = "qwertyuiopasdfghjklzxcvbnm"   # 字符串序列
        print(sorted(s))      # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
    
        s = (1, 3, 2, 456, 345, 12, 2, 5, 78, 34)   # 不可变元组
        print(sorted(s))      # [1, 2, 2, 3, 5, 12, 34, 78, 345, 456]
    
        # 3、reverse参数
        s = "qwertyuiopasdfghjklzxcvbnm"
        print(sorted(s, reverse=True))   # ['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
    
    
        # 4、key参数
        s = "QwERTYuioPaSdfGHjKLzXcvbnm"
        print(sorted(s))    # ['E', 'G', 'H', 'K', 'L', 'P', 'Q', 'R', 'S', 'T', 'X', 'Y', 'a', 'b', 'c', 'd', 'f', 'i', 'j', 'm', 'n', 'o', 'u', 'v', 'w', 'z']
        print(sorted(s, key=str.lower))   # 忽略大小写 ['a', 'b', 'c', 'd', 'E', 'f', 'G', 'H', 'i', 'j', 'K', 'L', 'm', 'n', 'o', 'P', 'Q', 'R', 'S', 'T', 'u', 'v', 'w', 'X', 'Y', 'z']
        print(sorted(s, key=str.upper))   # 也是忽略大小写
    ##########################
    #
    #  以下自定义一个类也可使用sorted函数
    #
    ##########################
    
    class Obj:
        def __init__(self):
            self.s = [x for x in range(10, 0, -1)]
    
        def __getitem__(self, item):
            print("getitem")
            return self.s[item]
    
        def __repr__(self):
            return str(self.s)
    
        def __iter__(self):
            return iter(self.s)
    
    obj = Obj()
    print(obj)           # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    
    # 添加getitem后可以使用sorted函数  (实验时请注视掉getitem方法)
    print(sorted(obj))   #  打印10次getitem   , [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    # 添加iter方法
    print(sorted(obj))   # 此时解释器会先调用iter方法,不会再使用getitem方法
                         # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    使自定义类也可使用sorted函数调用

     

    import requests
    response=requests.get('http://dig.chouti.com/')
    print(response.text)
    

    bisect

    '''
        bisect模块主要用来管理有顺序的序列
        bisect模块包含的主要函数是bisect和insort,两个函数都使用二叉树方法搜索
        1、bisect(haystack, needle)
            haystack必须是一个有序的序列,该函数搜索needle在haystack中的位置,该位置使得将needle插入后haystack仍然升序
            查找到位置后可用haystack.insert()插入
    
        2、insort(seq, item)
            把item插入到seq中,并能保持seq的升序
    
    '''
    
    #  本人认为《流畅的python》中的对该模块介绍的例子比较经典,故引用之
    
    # 1、关于bisect.bisect的示例
    import bisect
    import sys
    
    HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
    NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]
    
    ROW_FMT = '{0:2d} @ {1:2d}    {2}{0:<2d}'
    
    def demo(bisect_fn):
        for needle in reversed(NEEDLES):
            position = bisect_fn(HAYSTACK, needle)
            offset = position * '  |'
            print(ROW_FMT.format(needle, position, offset))
    
    
    if __name__ == '__main__':
    
        if sys.argv[-1] == 'left':
            bisect_fn = bisect.bisect_left
        else:
            bisect_fn = bisect.bisect
    
        print('DEMO:', bisect_fn.__name__)
        print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))
        demo(bisect_fn)
    
    
        '''   输出如下
        DEMO: bisect
        haystack ->  1  4  5  6  8 12 15 20 21 23 23 26 29 30
        31 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |31
        30 @ 14      |  |  |  |  |  |  |  |  |  |  |  |  |  |30
        29 @ 13      |  |  |  |  |  |  |  |  |  |  |  |  |29
        23 @ 11      |  |  |  |  |  |  |  |  |  |  |23
        22 @  9      |  |  |  |  |  |  |  |  |22
        10 @  5      |  |  |  |  |10
         8 @  5      |  |  |  |  |8 
         5 @  3      |  |  |5 
         2 @  1      |2 
         1 @  1      |1 
         0 @  0    0 
        '''
    # 另,bisect.bisect函数有两个可选参数——lo和hi来缩小搜索范围,lo的默认值是0,hi的默认值是序列的长度
    # 再另,bisect.bisect函数其实是bisect_right函数的别名,还有一个bisect_left,插入位置如果有相等的元素时,插入元素会放在它相等的
    #      元素后面,后者会放在前面
    
    
    # 根据分数,查到等级
    
    def grade(score, breakpoints=[60, 70, 80, 90], grades = 'FDCBA'):
        i = bisect.bisect(breakpoints, score)     # 这里的bisect.bisect实际上使用的是bisect_right
        return grades[i]
    
    print([grade(score) for score in [33, 55, 90, 87, 65, 78, 34, 60, 100]])
    
    
    # 2、关于bisect.insort函数
    
    import bisect
    import random
    
    SIZE = 7
    
    random.seed(1729)
    
    my_list = []
    for i in range(SIZE):
        new_item = random.randrange(SIZE*2)
        bisect.insort(my_list, new_item)
        print('%2d ->' % new_item, my_list)
    
        '''输出:
        10 -> [10]
         0 -> [0, 10]
         6 -> [0, 6, 10]
         8 -> [0, 6, 8, 10]
         7 -> [0, 6, 7, 8, 10]
         2 -> [0, 2, 6, 7, 8, 10]
        10 -> [0, 2, 6, 7, 8, 10, 10]
        '''
    
    # 另,insort函数也有insort_left,背后使用的是bisect_left

     

        b、带参数get请求-----》》params

    python高等种类小说目录

    python高级——目录

     

     

        c、带参数get请求-----》》headers

    #通常我们在发送请求时都需要带上请求头,请求头是将自身伪装成浏览器的关键,常见的有用的请求头如下
    Host
    Referer #大型网站通常都会根据该参数判断请求的来源
    User-Agent #客户端
    Cookie #Cookie信息虽然包含在请求头里,但requests模块有单独的参数来处理他,headers={}内就不要放它了
    

         d、带参数get请求-----》》cookies

    三、基于post请求

         a、介绍

    #GET请求
    HTTP默认的请求方法就是GET
         * 没有请求体
         * 数据必须在1K之内!
         * GET请求数据会暴露在浏览器的地址栏中
    
    GET请求常用的操作:
           1. 在浏览器的地址栏中直接给出URL,那么就一定是GET请求
           2. 点击页面上的超链接也一定是GET请求
           3. 提交表单时,表单默认使用GET请求,但可以设置为POST
    
    
    #POST请求
    (1). 数据不会出现在地址栏中
    (2). 数据的大小没有上限
    (3). 有请求体
    (4). 请求体中如果存在中文,会使用URL编码!
    
    
    #!!!requests.post()用法与requests.get()完全一致,特殊的是requests.post()有一个data参数,用来存放请求体数据
    复制代码
    

        b、发送POST的乞请,模拟浏览器的记名行为

    四、响应Response

        a、response属性

    澳门皇家赌场 8澳门皇家赌场 9

    import requests
    respone=requests.get('http://www.jianshu.com')
    # respone属性
    print(respone.text)
    print(respone.content)
    
    print(respone.status_code)
    print(respone.headers)
    print(respone.cookies)
    print(respone.cookies.get_dict())
    print(respone.cookies.items())
    
    print(respone.url)
    print(respone.history)
    
    print(respone.encoding)
    
    #关闭:response.close()
    from contextlib import closing
    with closing(requests.get('xxx',stream=True)) as response:
        for line in response.iter_content():
        pass
    

    View Code

        b、编码难题

    #编码问题
    import requests
    response=requests.get('http://www.autohome.com/news')
    # response.encoding='gbk' #汽车之家网站返回的页面内容为gb2312编码的,而requests的默认编码为ISO-8859-1,如果不设置成gbk则中文乱码
    print(response.text)
    

        c、获取二进制

    #stream参数:一点一点的取,比如下载视频时,如果视频100G,用response.content然后一下子写到文件中是不合理的
    
    import requests
    
    response=requests.get('https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo-transcode/1767502_56ec685f9c7ec542eeaf6eac93a65dc7_6fe25cd1347c_3.mp4',
                          stream=True)
    
    with open('b.mp4','wb') as f:
        for line in response.iter_content():
            f.write(line)
    

        d、解析json

    #解析json
    import requests
    response=requests.get('http://httpbin.org/get')
    
    import json
    res1=json.loads(response.text) #太麻烦
    
    res2=response.json() #直接获取json数据
    
    
    print(res1 == res2) #True
    

    五、selenium模块

        a、介绍

    selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题
    
    selenium本质是通过驱动浏览器,完全模拟浏览器的操作,比如跳转、输入、点击、下拉等,来拿到网页渲染之后的结果,可支持多种浏览器
    
    from selenium import webdriver
    browser=webdriver.Chrome()
    browser=webdriver.Firefox()
    browser=webdriver.PhantomJS()
    browser=webdriver.Safari()
    browser=webdriver.Edge()
    

       b、安装

    #安装:selenium+chromedriver
    pip3 install selenium
    下载chromdriver.exe放到python安装路径的scripts目录中即可,注意最新版本是2.29,并非2.9
    国内镜像网站地址:http://npm.taobao.org/mirrors/chromedriver/2.29/
    最新的版本去官网找:https://sites.google.com/a/chromium.org/chromedriver/downloads
    
    #注意:
    selenium3默认支持的webdriver是Firfox,而Firefox需要安装geckodriver
    下载链接:https://github.com/mozilla/geckodriver/releases
    

    六、选择器

       a、基本使用

    澳门皇家赌场 10澳门皇家赌场 11

    from selenium import webdriver
    from selenium.webdriver import ActionChains
    from selenium.webdriver.common.by import By #按照什么方式查找,By.ID,By.CSS_SELECTOR
    from selenium.webdriver.common.keys import Keys #键盘按键操作
    from selenium.webdriver.support import expected_conditions as EC
    from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素
    import time
    
    driver=webdriver.Chrome()
    driver.get('https://www.baidu.com')
    wait=WebDriverWait(driver,10)
    
    try:
        #===============所有方法===================
        # 1、find_element_by_id
        # 2、find_element_by_link_text
        # 3、find_element_by_partial_link_text
        # 4、find_element_by_tag_name
        # 5、find_element_by_class_name
        # 6、find_element_by_name
        # 7、find_element_by_css_selector
        # 8、find_element_by_xpath
        # 强调:
        # 1、上述均可以改写成find_element(By.ID,'kw')的形式
        # 2、find_elements_by_xxx的形式是查找到多个元素,结果为列表
    
        #===============示范用法===================
        # 1、find_element_by_id
        print(driver.find_element_by_id('kw'))
    
        # 2、find_element_by_link_text
        # login=driver.find_element_by_link_text('登录')
        # login.click()
    
        # 3、find_element_by_partial_link_text
        login=driver.find_elements_by_partial_link_text('录')[0]
        login.click()
    
        # 4、find_element_by_tag_name
        print(driver.find_element_by_tag_name('a'))
    
        # 5、find_element_by_class_name
        button=wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'tang-pass-footerBarULogin')))
        button.click()
    
        # 6、find_element_by_name
        input_user=wait.until(EC.presence_of_element_located((By.NAME,'userName')))
        input_pwd=wait.until(EC.presence_of_element_located((By.NAME,'password')))
        commit=wait.until(EC.element_to_be_clickable((By.ID,'TANGRAM__PSP_10__submit')))
    
        input_user.send_keys('18611453110')
        input_pwd.send_keys('lhf@094573')
        commit.click()
    
        # 7、find_element_by_css_selector
        driver.find_element_by_css_selector('#kw')
    
        # 8、find_element_by_xpath
    
        time.sleep(5)
    
    finally:
        driver.close()
    

    View Code

    本文由澳门皇家赌场真人在线发布于皇家赌场游戏,转载请注明出处:Python之爬虫总括,数据类型和进制转变

    关键词:

上一篇:没有了

下一篇:python之常用模块,操作下拉菜单