当前位置:首页 > > Python电子书网盘下载
Python数据抓取技术与实战 Python数据抓取技术与实战
码农之家

码农之家 提供上传

资源
30
粉丝
38
喜欢
459
评论
12

    Python数据抓取技术与实战 PDF 清晰影印版

    Python电子书
    • 发布时间:

    给大家带来的一篇关于Python相关的电子书资源,介绍了关于Python数据抓取技术与实战方面的内容,本书是由电子工业出版社出版,格式为PDF,资源大小59.3 MB,潘庆和,赵星驰编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.5,更多相关的学习资源可以参阅转义字符Web代码PHP毕业设计Python基础Android、等栏目。

  • Python数据抓取技术与实战 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1tcW1A0ir76fQItL2vVBHo
  • 提取码:hmk6
  • 读者评价

    从13年底开始使用python进行数据抓取,主要在业余时间进行,也是一种爱好.抓取过各类网站.其中遇到并解决了各类问题,比如对加密Flash文本内容的抓取与解密,使用Tor进行IP的获取,滑块儿类验证码,以及分布式抓取监控平台的搭建等等,随着经验的积累目前基本可以应对和解决各类抓取问题了.在这个过程中进行了一些总结, 对于一些问题总结成了论文:<<Web站点拓扑结构获取方法研究>>(2015)和<<一种通用分布式数据抓取系统的设计与实现>>(2016),其中第二篇包含了本书"监控系统"部分内容.本书(2016)也是这段时间一些工作的总结,主要介绍了一些抓取的基础知识和实施方式,但不是全部工作内容,考虑到抓取某些特定网站可能带来的问题,很多内容和实例在最后定稿时删掉了.写一本书结构既要从整体把握,还要注意细节,内容也要详略得当,对于我来说能力精力有限,可能会有不周.借助豆瓣这个平台希望能和各位读者交流,我会解答大家阅读时的问题.希望我们互相交流,共同进步.

    本书对html/xml的介绍几乎没有,对密码、验证码、动态抓取等等数据抓取会出现的可能状况的介绍也十分不够。在python的各种包、库的安装与介绍上也很不足。光安装selenium,本人花了1个多小时解决出现的报错问题,而这个细节在本书仅仅用一句话轻描淡写地带过。本书介绍的spynner库在python3不可用,而本书竟然就是用的python3。抓取的例子少得可怜。大量的篇幅花在讲解一些新手用不到、老手已经懂的内容上。

    内容简介

    如何在大数据时代获得实时的数据信息,分析挖掘、提取出有价值的信息,并以直观清晰的图形表示出关键的数量关系和概念,是一个值得研究的问题。本书通过数据抓取篇(如何获得数据信息)、数据分析篇(分析挖掘,提取出有价值的信息)、数据可视化篇(以直观清晰的图形表示出关键的数量关系和概念)详细描述数据抓取、分析、展示的整个流程,每一篇自成一体,可以单独学习掌握。

    内容节选

    python提供了json库,专门用于json格式内容的解析处理。

    json的使用比较简单,常用的方法有load、loads、dump和dumps,我们这里结合mongodb,可以存储大量的json数据。

    查询北京大学地图的url,它返回的是json格式。我们可以通过该例子说明问题,网址如下:

    http://ditu.amap.com/detail/get/detail?id=B000A816R6,代码如下:

    import requests
    import json
    url='http://ditu.amap.com/detail/get/detail?id=B000A816R6'
    res = requests.get(url).text
    json_dict=json.loads(res)
    print(type(json_dict))
    print(json_dict.keys())
    print(json_dict['data'])
    print('lng:'+json_dict['data']['base']['x']+','+'lat:'+json_dict['data']['base']['y'])

    输出部分结果如下所示:

    <class 'dict'>
    dict_keys(['status', 'data'])
    {'src_info': [], ... 'author_id': '', 'review_weburl': '', 'recommend': '', 'quality_flag': 48, 'high_quality': 0, 'aos_tag_score': 33.599999999999994, 'gold_num': 5, 'gold_type': '22', ... 'intro': '北京大学创于1898年,初名京师大学堂,是第一所国立综合性大学,也是当时中国的最高教育行政机关.辛亥革命后,于1912年改为现名. 作为新文化运动的中心和“五四”运动的策源地,作为中国最早传播马克思主义和民主科学思想的发祥地,作为中国共产党最早的活动基地,北京大学为民族的振兴和解放、国家的建设和发展、社会的文明和进步做出了不可代替...}
    lng:116.31088,lat:39.99281

    既然我们已经把数据取下来了,那么我们现在就可以用mongodb做存储了

    我们需要安装mongodb,在之前的文章中我们已经介绍过了。还要在python中安装pymongodb模块(它搭起了python和mongodb的桥梁)

    pip3 install pymongo
    #如果你安装的是anaconda,那么你还可以用以下命令安装
    conda install pymongo

    安装完成之后,我们就可以将json的处理和存储给结合起来了,环境启动如下所示:

    net start mongodb
    mongo    #这里我们已经把mongo的path加入了系统环境PATH中,所以可以不用完整路径信息
    
    #手工建立数据库
    > use bj_map   #创建名为bj_map的数据库,并转到该数据库下操作
    > db
    bj_map
    > db.createCollection("pos_info")   #在bj_map数据库下创建pos_info表
    { "ok" : 1 }    #表示该表创建成功
    
    #代码建立数据库
    #由于没有相对应的数据库和集合,mongodb会自动创建

    mongodb的端口号为27017(固定端口号更为方便,我们在配置mongodb服务的时候固定的端口号)

    import requests
    import json
    import pymongo
    
    #数据库信息配置
    ip='127.0.0.1'
    port=27017
    db_name ='bj_map'
    collection_name ='pos_info'
    
    #北京大学
    url_1='http://ditu.amap.com/detail/get/detail?id=B000A816R6'
    #清华大学
    url_2='http://ditu.amap.com/detail/get/detail?id=B000A7BD6C'
    urls=[url_1,url_2]
    
    #数据库连接
    mongo_conn=pymongo.MongoClient(ip,port)
    db=mongo_conn[db_name]
    collection=db[collection_name]
    
    for url in urls:
        try:
            print(url)
            res = requests.get(url).text
            json_dict=json.loads(res)
            collection.save(json_dict)
        except Exception as e:
            print(e)

     

    输出结果:

    http://ditu.amap.com/detail/get/detail?id=B000A816R6
    http://ditu.amap.com/detail/get/detail?id=B000A7BD6C

    我们可以在mongodb数据库中去查看

    mongo
    > db['pos_info'].count()
    2
    >db['pos_info'].find()
    {... "motto" : "爱国 进步 科学 民主", "intro" : "北京大学创于1898年,初名京师大学堂,是...}
    {... "motto" : "自强不息 厚德载物", "intro" : "清华大学(Tsinghua University),简称清华...}

    或者说我们打开pycharm,用pycharm的mongo插件查看。点击界面右侧栏中的Mongo Explorer→选择第三个图标“mongo settings”→点击右侧绿色的“+”→label和user database都填写“bj_map”,server_url默认就好,用test connection按钮测试。至此,我们就可以查看了。

    作者介绍

    潘庆和,2011年7月毕业于哈尔滨工业大学计算机科学与技术学院,计算机应用技术专业,获得工学博士学位。2011年8月至今,哈尔滨商业大学计算机与信息工程学院,计算机科学与技术专业教师,讲师,主教课程:本科专业课《操作系统》,《专业英语》,研究生《形式语言与自动机》,《大数据技术基础》。2014年获得哈尔滨商业大学优秀教师称号。

    目录

    • 第1章 Python基础1
    • 1.1 Python安装1
    • 1.2 安装pip 6
    • 1.3 如何查看帮助7
    • 1.4 第一个程序10
    • 1.5 文件操作25
    • 1.6 循环28
    • 1.7 异常30
    • 1.8 元组30
    • 1.9 列表32
    • 1.10 字典36
    • 1.11 集合38
    • 1.12 随机数39
    • 1.13 enumerate的使用40
    • 1.14 第二个例子41
    • 第2章 字符串解析46
    • 2.1 常用函数46
    • 2.2 正则表达式50
    • 2.3 BeautifulSoup 55
    • 2.4 json结构62
    • 第3章 单机数据抓取77
    • 3.1 单机顺序抓取77
    • 3.2 requests 107
    • 3.3 并发和并行抓取117
    • 第4章 分布式数据抓取137
    • 4.1 RPC的使用138
    • 4.2 Celery系统145
    • 第5章 全能的Selenium 159
    • 5.1 Selenium单机159
    • 5.2 Selenium分布式抓取178
    • 5.3 Linux无图形界面使用Selenium 188
    • 第6章 神秘的Tor 191
    • 6.1 抓取时IP封锁的问题191
    • 6.2 Tor的安装与使用192
    • 6.3 Tor多线程197
    • 6.4 Tor与Selenium结合205
    • 第7章 抓取常见问题210
    • 7.1 Flash 210
    • 7.2 桌面程序211
    • 7.3 U盘213
    • 7.4 二级三级页面214
    • 7.5 图片的处理214
    • 7.6 App数据抓取214
    • 第8章 监控框架221
    • 8.1 框架说明223
    • 8.2 监控系统实例225
    • 第9章 拥抱大数据229
    • 9.1 Hadoop生态圈229
    • 9.2 Cloudera环境搭建231

    读书笔记

    详解Python函数any()和all()的用法和区别

    Python函数any()和all()的用法及区别介绍

    引子

    平常的文本处理工作中,我经常会遇到这么一种情况:用python判断一个string是否包含一个list里的元素。

    这时候使用python的内置函数any()会非常的简洁:

    fruits = ['apple', 'orange', 'peach']
    str = "I want some apples"
    if any(element in str for element in fruits):
      print "string contains some fruits."

    any()

    其实any函数非常简单:判断一个tuple或者list是否全为空,0,False。如果全为空,0,False,则返回False;如果不全为空,则返回True。

    all()

    all函数正好和any相反:判断一个tuple或者list是否全为不为空,0,False。如果全不为空,则返回True;否则返回False。

    这里需要注意的是,空tuple和空list的返回值是True

    python中内建函数all()和any()的区别

    all(x) 是针对x对象的元素而言,如果all(x)参数x对象的所有元素不为0、”、False或者x为空对象,则返回True,否则返回False
    如:

    In [25]: all(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0
    Out[25]: True
    In [26]: all(['a', 'b', '', 'd']) #列表list,存在一个为空的元素
    Out[26]: False
    In [27]: all([0, 1,2, 3]) #列表list,存在一个为0的元素
    Out[27]: False
    In [28]: all(('a', 'b', 'c', 'd')) #元组tuple,元素都不为空或0
    Out[28]: True
    In [29]: all(('a', 'b', '', 'd')) #元组tuple,存在一个为空的元素
    Out[29]: False
    In [30]: all((0, 1,2, 3)) #元组tuple,存在一个为0的元素
    Out[30]: False
    In [31]: all([]) # 空列表
    Out[31]: True
    In [32]: all(()) # 空元组
    Out[32]: True

    any(x)是判断x对象是否为空对象,如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true

    In [33]: any(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0
    Out[33]: True
    In [34]: any(['a', 'b', '', 'd']) #列表list,存在一个为空的元素
    Out[34]: True
    In [35]: any((0,1)) #元组tuple,存在一个为空的元素
    Out[35]: True
    In [36]: any((0,'')) #元组tuple,元素都为空
    Out[36]: False
    In [37]: any(()) # 空元组
    Out[37]: False
    In [38]: any([]) # 空列表
    Out[38]: False

    python中any()和all()如何使用

    any(iterables)和all(iterables)对于检查两个对象相等时非常实用,但是要注意,any和all是python内置函数,同时numpy也有自己实现的any和all,功能与python内置的一样,只不过把numpy.ndarray类型加进去了。因为python内置的对高于1维的ndarray没法理解,所以numpy基于的计算最好用numpy自己实现的any和all。

    本质上讲,any()实现了或(OR)运算,而all()实现了与(AND)运算。

    对于any(iterables),如果可迭代对象iterables(至于什么是可迭代对象,可关注我的下篇文章)中任意存在每一个元素为True则返回True。特例:若可迭代对象为空,比如空列表[],则返回False。
    官方文档如是说:

    Return True if any element of the iterable is true. If the iterable is empty, return False.

    伪代码(其实是可以运行的python代码,但内置的any是由C写的)实现方式:

    def any(iterable):
        for element in iterable:
            if element:
                return True
        return False

    对于all(iterables),如果可迭代对象iterables中所有元素都为True则返回True。特例:若可迭代对象为空,比如空列表[],则返回True。

    官方文档如是说:

    Return True if all elements of the iterable are true (or if the iterable is empty).

    伪代码(其实是可以运行的python代码,但内置的all是由C写的)实现方式:

    def all(iterable):
        for element in iterable:
            if not element:
                return False
        return True

    python的模块由两类语言开发,一类为纯python,一类为编译型语言,比如C/C++/Fortran。绝大多数标准库由纯python开发,这是由于python语言具有简洁性及短的开发周期。这些模块的源码很容易获得,在ipython下可用module??打印到屏幕上查看,或者写一个脚本保存起来,比如下面这样:

    import os
    import inspect as inspect
    import pandas as pd
    
    path = r"D:\python3_dev\package_down"
    os.chdir(path)
    
    series = inspect.getsource(pd.Series)
    with open("pd_series_code.py", "w") as f:
        f.write(series)

    当然,也可以到python安装包下查找,但是效率很低。

    python inspect.getsource(object)只能查看用python写的module, class, method, function, traceback, frame, or code object。可以看看getsource的文档字符串,了解其基本功能。

    >>>inspect.getsource.__doc__
    'Return the text of the source code for an object.\n\n    
    The argument may be a module, class, method, function, traceback, frame,\n    
    or code object.  The source code is returned as a single string.  An\n    
    OSError is raised if the source code cannot be retrieved.'

    对于有些模块,通常是关乎运行性能的,一般都由编译型语言开发,比如os模块和for循环N多层的线性代数等模块。所以无法通过getsource方法获得源码,通常会抛出一个TypeError异常。要查看这些模块的源码,需要到GitHub上的python/cpython目录下找,比如在Objects目录下可找到listobject.c,这是list模块的C代码。

    那么怎么知道一个模块是内置的呢?可用type(object)或object.__module__。比如

    >>>type(all)
    builtin_function_or_method
    >>>all.__module__
    'builtins'

    一个2X3 ndarray 的例子。用numpy自己实现的all很容易判断两个array是否相等,但python内置的却抛出了异常。

    >>>x = np.ones((2,3))
    >>>x1 = np.ones((2,3))
    >>>np.all(x==x1)
    True
    >>>xe = x==x1
    >>>xe.all()
    True
    >>>all(xe)#这里调用了python内置模块all()
    ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

    但是,还有更pythonic的写法,因为numpy有一个模块array_equal,可以直接判断两个array是否完全相等或某个轴相等,其实他也是用np.all实现的。

    >>>np.array_equal(x, x1)
    True

    其实也不要惊讶,这只是python的常规操作。轮子已经被匠人造好,拿来用就OK了!如果你觉得自己可以造出更金光闪闪的轮子,那就抡起你的斧头;如果觉得已经够完美,那就拿来主义,不要再造了。

     

    python线程锁相关技巧和操作示例

    Python线程下使用锁的技巧分享

    使用诸如Lock、RLock、Semphore之类的锁原语时,必须多加小心,锁的错误使用很容易导致死锁或相互竞争。依赖锁的代码应该保证当出现异常时可以正常的释放锁。

    典型代码如下:

    try:
      lock.acquire()
      #关键部分
      ...
    finally:
      lock.release()

    另外,所有种类的锁还支持上下文管理协议(写起来更简洁):

    with语句自动获取锁,并且在控制流离开上下文时自动释放锁。

    with lock:
      #关键部分
      ...

    此外,编写代码时一般应该避免同时获取多个锁,例如下面就应该尽量避免:

    这通知很统一导致应用程序神秘死锁,尽管与集中策略可以避免出现这种情况(如分层锁定),但是最好在编写代码时避免这种嵌套锁。

    with lock_A:
      #关键部分
      ...
      with lock_B:
        #B的关键部分
        ...

    尽管在Python中可以使用各种锁和同步原语的组合编写非常传统的多线程程序,但有一种首推的编程方式要优于其他所有编程方式:即将多线程程序组织为多个独立任务的集合,这些任务之间通过消息队列进行通信,例如下面要讲的queue模块。

    Python多线程编程之多线程加锁操作示例

    Python语言本身是支持多线程的,不像PHP语言。

    下面的例子是多个线程做同一批任务,任务总是有task_num个,每次线程做一个任务(print),做完后继续取任务,直到所有任务完成为止。

    # -*- coding:utf-8 -*-
    #! python2
    import threading
    start_task = 0
    task_num = 10000
    mu = threading.Lock()  ###通过工厂方法获取一个新的锁对象
    class MyThread(threading.Thread):  ###类MyThread继承基类threading.Thread
      def run(self): ##线程启动的入口函数,子类需重写
        global start_task
        global mu
        global start_task
        while start_task < task_num:  ##如果任务没有完成,则继续
          if mu.acquire():  ##加锁
            if start_task < task_num:
              print start_task
              start_task = start_task + 1
            mu.release()  ##释放锁
    def test():
      thread_all = []
      for i in range(6): ##for循环创建6个线程
        t = MyThread() ##创建线程
        thread_all.append(t)
        t.start()  ###启动线程
      for i in range(6):
        thread_all[i].join()  ##等待线程结束
    if __name__ == "__main__":
      test()
    
    

    运行上述代码,则输出1~9999

    测试加锁与不加锁效果:将任务数设置为1千万或者以上,在多核机器上将print输出分别保存,就能说明问题。

    python线程中同步锁详解

    在使用多线程的应用下,如何保证线程安全,以及线程之间的同步,或者访问共享变量等问题是十分棘手的问题,也是使用多线程下面临的问题,如果处理不好,会带来较严重的后果,使用python多线程中提供Lock Rlock Semaphore Event Condition 用来保证线程之间的同步,后者保证访问共享变量的互斥问题

    Lock & RLock:互斥锁 用来保证多线程访问共享变量的问题
    Semaphore对象:Lock互斥锁的加强版,可以被多个线程同时拥有,而Lock只能被某一个线程同时拥有。
    Event对象: 它是线程间通信的方式,相当于信号,一个线程可以给另外一个线程发送信号后让其执行操作。
    Condition对象:其可以在某些事件触发或者达到特定的条件后才处理数据

    1、Lock(互斥锁)

    请求锁定 — 进入锁定池等待 — 获取锁 — 已锁定 — 释放锁

    Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。

    可以认为Lock有一个锁定池,当线程请求锁定时,将线程至于池中,直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

    构造方法:
    Lock()

    实例方法:
    acquire([timeout]): 使线程进入同步阻塞状态,尝试获得锁定。
    release(): 释放锁。使用前线程必须已获得锁定,否则将抛出异常。

    if mutex.acquire():
     counter += 1
     print "I am %s, set counter:%s" % (self.name, counter)
      mutex.release()

    2、RLock(可重入锁)

    RLock(可重入锁)是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念,处于锁定状态时,RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire(),释放锁时需要调用release()相同次数。

    可以认为RLock包含一个锁定池和一个初始值为0的计数器,每次成功调用 acquire()/release(),计数器将+1/-1,为0时锁处于未锁定状态。

    构造方法:
    RLock()

    实例方法:
    acquire([timeout])/release(): 跟Lock差不多。

    3、Semaphore(共享对象访问)

    咱们再聊聊Semaphore ,说实话Semaphore是我最晚使用的同步锁,以前类似的实现,是我用Rlock实现的,相对来说有些绕,毕竟Rlock 是需要成对的锁定和开锁的》。。。

    Semaphore管理一个内置的计数器,
    每当调用acquire()时内置计数器-1;
    调用release() 时内置计数器+1;
    计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。

    直接上代码,我们把semaphore控制为3,也就是说,同时有3个线程可以用这个锁,剩下的线程也之只能是阻塞等待了…

    #coding:utf-8
    #blog xiaorui.cc
    import time
    import threading
    
    semaphore = threading.Semaphore(3)
    
    def func():
     if semaphore.acquire():
      for i in range(3):
       time.sleep(1)
       print (threading.currentThread().getName() + '获取锁')
      semaphore.release()
      print (threading.currentThread().getName() + ' 释放锁')
    
    
    for i in range(5):
     t1 = threading.Thread(target=func)
     t1.start()

    4、Event(线程间通信)

    Event内部包含了一个标志位,初始的时候为false。
    可以使用使用set()来将其设置为true;
    或者使用clear()将其从新设置为false;
    可以使用is_set()来检查标志位的状态;

    另一个最重要的函数就是wait(timeout=None),用来阻塞当前线程,直到event的内部标志位被设置为true或者timeout超时。如果内部标志位为true则wait()函数理解返回。

    import threading
    import time
    
    class MyThread(threading.Thread):
     def __init__(self, signal):
      threading.Thread.__init__(self)
      self.singal = signal
    
     def run(self):
      print "I am %s,I will sleep ..."%self.name
      self.singal.wait()
      print "I am %s, I awake..." %self.name
    
    if __name__ == "__main__":
     singal = threading.Event()
     for t in range(0, 3):
      thread = MyThread(singal)
      thread.start()
    
     print "main thread sleep 3 seconds... "
     time.sleep(3)
    
     singal.set()
    
    

    5、Condition(线程同步)

    可以把Condition理解为一把高级的琐,它提供了比Lock, RLock更高级的功能,允许我们能够控制复杂的线程同步问题。threadiong.Condition在内部维护一个琐对象(默认是RLock),可以在创建Condigtion对象的时候把琐对象作为参数传入。Condition也提供了acquire, release方法,其含义与琐的acquire, release方法一致,其实它只是简单的调用内部琐对象的对应的方法而已。Condition还提供了如下方法(特别要注意:这些方法只有在占用琐(acquire)之后才能调用,否则将会报RuntimeError异常。):

    Condition.wait([timeout]):

    wait方法释放内部所占用的琐,同时线程被挂起,直至接收到通知被唤醒或超时(如果提供了timeout参数的话)。当线程被唤醒并重新占有琐的时候,程序才会继续执行下去。

    Condition.notify():

    唤醒一个挂起的线程(如果存在挂起的线程)。注意:notify()方法不会释放所占用的琐。

    Condition.notify_all()
    Condition.notifyAll()

    唤醒所有挂起的线程(如果存在挂起的线程)。注意:这些方法不会释放所占用的琐。

    对于Condition有个例子,大家可以观摩下。

    from threading import Thread, Condition
    import time
    import random
    
    queue = []
    MAX_NUM = 10
    condition = Condition()
    
    class ProducerThread(Thread):
     def run(self):
      nums = range(5)
      global queue
      while True:
       condition.acquire()
       if len(queue) == MAX_NUM:
        print "Queue full, producer is waiting"
        condition.wait()
        print "Space in queue, Consumer notified the producer"
       num = random.choice(nums)
       queue.append(num)
       print "Produced", num
       condition.notify()
       condition.release()
       time.sleep(random.random())
    
    
    class ConsumerThread(Thread):
     def run(self):
      global queue
      while True:
       condition.acquire()
       if not queue:
        print "Nothing in queue, consumer is waiting"
        condition.wait()
        print "Producer added something to queue and notified the consumer"
       num = queue.pop(0)
       print "Consumed", num
       condition.notify()
       condition.release()
       time.sleep(random.random())
    
    
    ProducerThread().start()
    ConsumerThread().start()
    

    Python3.6及TensorFlow的安装和配置流程(图解)

    python3.6.3安装图文教程 TensorFlow安装配置方法

    一、Python官网下载自己电脑和系统对应的Python安装包。

     网址:下载地址

    一直往下拉到Files,这里我下载的是Windows x86-64 executable installer

    (注意:要装TensorFlow必须安装64位的Python,TensorFlow不支持32位)<

    二、下载python-3.6.3-amd64.exe应用程序

    下载完成后得到一个python-3.6.3-amd64.exe应用程序,右击以管理员身份运行该安装包;可以选择默认一路安装,也可以customize,自定义想要安装的路径;

     建议install for all users, 这里我安装的路径为D:\Python36;

     勾选 add to PATH ,可以省去后面的配置系统环境变量的步骤;一路next完成安装。

    三、测试是否安装成功

    打开cmd,输入Python;(如下图表明已安装成功)

    若显示python不是系统命令,说明系统环境变量未配置成功;下面介绍系统环境变量的配置。

    计算机(或我的电脑)-右键属性-环境变量-系统变量-path,双击打开path的编辑窗,加入Python的安装路径。如D:\Python36\Scripts\;D:\Python36\;(若在末尾不用加分号)

    确定之后重新cmd测试是否安装成功。

    四、安装后找到Python3.6文件夹

    安装完后可以在系统所有应用程序中找到Python3.6文件夹;

    为了方便可以把IDLE右键发送到桌面快捷方式。

    至此,Python3.6的安装就结束了。

    下面介绍TensorFlow的安装

    在上面的Python安装过程中,通常已经安装好了pip,下面就可以用pip来方便地安装各种开发需要的工具包。

    1.去下面的网址下载你需要的包。(TensorFlow,nltk,numpy 等等都可以找到)

    点击:下载地址

    2.这里以tensorflow为例,下载一个对应版本的TensorFlow

    3.把该文件放到Python安装路径下的Scripts文件夹下,如D:\Python36\Scripts

    4.打开cmd, 进入该路径,输入 pip install tensorflow-1.4.0-cp36-cp36m-win_amd64.whl

    按回车开始安装。

    安装成功的结果:

    其他工具包的安装都可以仿照此例,如自然语言处理NLTK的安装如下:

    下面就可以开始你的Python开发了。

    Win7 64位下python3.6.5安装配置图文教程

    一、安装python

    1、首先进入网站下载:点击打开链接(或自己输入网址),进入之后如下图,选择图中红色圈中区域进行下载。

    关注公众号:资料在线,干货满满。

    2、下载完成后如下图所示

    3、双击exe文件进行安装,如下图,并按照圈中区域进行设置,切记要勾选打钩的框,然后再点击Customize installation进入到下一步:

    4、对于上图中,可以通过Browse进行自定义安装路径,也可以直接点击Install进行安装,点击install后便可以完成安装了。

    5、为了检查我们的python是否安装成功,可以在命令窗口中输入python进行查询,如显示下图一的信息则表示成功了,如显示第二张图的信息则表示出错了。

    二、认识编程环境

    1、在开始运行处运行命令cmd,进行dos模式,输入python,即可进行python的交互式环境。

    2、进行到IDLE界面

    3、交互式界面可以用于简单的学习,编写较大程序时应到具体的python文件中,python文件默认的后缀为.py,我们可以新建文本文件,然后把后缀扩展名改为.py,然后

    最后选择菜单中的Run下的run module即可运行,快捷键为F5。

    第一次自己动手安装,还有许多问题要解决。

    安装过程小插曲,运行的时候提示:

    解决方法如下:

    (1)把C:\Windows\SysWOW64的api-ms-win-crt-runtime-l1-1-0.dll删除掉。

    (2)重新安装api-ms-win-crt-runtime-l1-1-0.dll(其实这个就是VC redit.exe里面的)

    安装VC redit.exe程序解决

    是VC的一个程序:VC redit.exe 下载链接

    下载安装完成两个目录下都会有了, 重启电脑,这时候就可以正常运行。

    python小白一枚,还有许多需要学习的地方,先记录一下。下一篇再整理一些pip安装教程。

    还有一个小补充:

    EOL while scanning string literal,提示这个异常的原因是:这个异常造成的原因是字符串,引号没有成对出现。

    win10下python3.5.2、tensorflow和matplotlib安装教程

    win10环境下搭建python3.5.2和tensorflow

    在win10环境下搭建python3.5.2和tensorflow平台,供大家参考,具体内容如下

    操作步骤如下:

    1、官网(https://www.python.org/ )下载python3.5.2 

    选择Downloads-Windows

    选择64位executable installer

    2、安装过程,双击.exe可执行文件

    一路默认下去!

      

    3、安装成功后打开cmd命令窗口

    print(“Hello World!”)回车后出现HelloWorld!即可

    4、python -m pip install -U pip 用来更新pip

    5、win10安装tensorflow (可参考 网址

    这里我安装tensorflow-cpu版本

    · 在命令行输入:pip install --upgrade --ignore-installed tensorflow

    6、安装库的方法

    下载库的网址:链接地址

     

     cp35代表适用python3.5版本,win64表示适用于64位电脑,下载版本如下红色字所示文件:

    以安装库matplotlib为例:

    至此环境搭建完成!

    注意事项:

    库报错

    解决:所有库必须统一来源、统一安装,下载网址

    win10下tensorflow和matplotlib安装教程

    本文介绍了一系列安装教程,具体如下

    1.安装Python

    版本选择是3.5.1,因为网上有些深度学习实例用的就是这个版本,跟他们一样的话可以避免版本带来的语句规范问题

    python的下载官网

    2.安装easy_install

    • 在Python的官网下载easy_install的安装包,下载地址
    • 下载完成后解压zip,解压后双击setup.py,会跳出一个黑框闪一下,这时python目录下的scripts文件夹中有了easy_install的应用程序文件。
    • 接下来配置环境变量:计算机→系统属性→高级系统设置→环境变量→双击path→添加Python和scripts的路径
    • win+R+cmd打开命令行,输入easy_install virtualenv,回车

    安装了easy_install之后安装Python库就方便了,直接在命令行中输入easy_install+libname就行了。但试验了几次后发现pip比较适合我这种小白,所以安装了pip。

    3.安装pip

    • 在命令行里输入easy_install pip,回车
    • 检查pip是否成功安装,直接在命令行里输入pip
    • pip版本升级,在命令行里输入:python -m pip install -U pip

    注意空格,比如python与-m之间就有个空格

    4.安装tensorflow

    确定计算机联网了,网速也要保证,有次我的网速太慢了,不得已一个组件一个组件的下,最后再输入以下那条命令,也成功了,但网速快的话是可以自动一次性下载完成的

    在命令行输入:pip install --upgrade --ignore-installed tensorflow

    安装完成后在Python中输入import tensorflow 可能会出现找不到模块的错误,这时需要安装MSVCP140.DLL,下载安装完成后重启电脑就可以了,下载地址

    5.安装matplotlib

    特别只出一个Python第三方组件库,内容很全:链接地址

    • 从刚才提到的第三方库中下载matplotlib,选择文件时注意cp35代表适用Python3.5版本,win64表示适用于64位电脑
    • 记住下载的matplotlib的路径,我一般会放在Python文件夹下
    • 打开命令行,输入cd 安装路径,回车。如果把所有下载的组件都放到这个安装路径的话,用cd转到这个路径再用pip安装就很方便
    • 在命令行继续输入pip install 文件名,文件名一定要写对写全。用这种法还可以安装很多组件,比如我文件夹下的那个pywin32。示例图如下:

    可以用一个简单的例子验证matplotlib是否安装正确,由于我还没有开始学matplotlib,这个例子用的是其他文章里的 (可以发现这篇文章里让安装的各种组件,在安装tensorflows的时候就已经自动安装好了,若是网速不够导致timeout,就要挨个下载安装这些组件)            

     例子:

    以上就是本文的全部内容,希望对大家的学习有所帮助

    Python高级编程技巧总结

    符合语言习惯的 Python 优雅编程技巧

    Python最大的优点之一就是语法简洁,好的代码就像伪代码一样,干净、整洁、一目了然。要写出 Pythonic(优雅的、地道的、整洁的)代码,需要多看多学大牛们写的代码,github 上有很多非常优秀的源代码值得阅读,比如:requests、flask、tornado,下面列举一些常见的Pythonic写法。
    0. 程序必须先让人读懂,然后才能让计算机执行。

    “Programs must be written for people to read, and only incidentally for machines to execute.”

    1. 交换赋值

    ##不推荐
    temp = a
    a = b
    b = a 
    ##推荐
    a, b = b, a # 先生成一个元组(tuple)对象,然后unpack

    2. Unpacking

    ##不推荐
    l = ['David', 'Pythonista', '+1-514-555-1234']
    first_name = l[0]
    last_name = l[1]
    phone_number = l[2] 
    ##推荐
    l = ['David', 'Pythonista', '+1-514-555-1234']
    first_name, last_name, phone_number = l
    # Python 3 Only
    first, *middle, last = another_list

    3. 使用操作符in

    ##不推荐
    if fruit == "apple" or fruit == "orange" or fruit == "berry":
      # 多次判断 
    ##推荐
    if fruit in ["apple", "orange", "berry"]:
      # 使用 in 更加简洁

    4. 字符串操作

    ##不推荐
    colors = ['red', 'blue', 'green', 'yellow']
    result = ''
    for s in colors:
      result += s # 每次赋值都丢弃以前的字符串对象, 生成一个新对象 
    ##推荐
    colors = ['red', 'blue', 'green', 'yellow']
    result = ''.join(colors) # 没有额外的内存分配

    5. 字典键值列表

    ##不推荐
    for key in my_dict.keys():
      # my_dict[key] ... 
    ##推荐
    for key in my_dict:
      # my_dict[key] ...
    # 只有当循环中需要更改key值的情况下,我们需要使用 my_dict.keys()
    # 生成静态的键值列表。

    6. 字典键值判断

    ##不推荐
    if my_dict.has_key(key):
      # ...do something with d[key] 
    ##推荐
    if key in my_dict:
      # ...do something with d[key]

    7. 字典 get 和 setdefault 方法

    ##不推荐
    navs = {}
    for (portfolio, equity, position) in data:
      if portfolio not in navs:
          navs[portfolio] = 0
      navs[portfolio] += position * prices[equity]
    ##推荐
    navs = {}
    for (portfolio, equity, position) in data:
      # 使用 get 方法
      navs[portfolio] = navs.get(portfolio, 0) + position * prices[equity]
      # 或者使用 setdefault 方法
      navs.setdefault(portfolio, 0)
      navs[portfolio] += position * prices[equity]

    8. 判断真伪

    ##不推荐
    if x == True:
      # ....
    if len(items) != 0:
      # ...
    if items != []:
      # ... 
    ##推荐
    if x:
      # ....
    if items:
      # ...

    9. 遍历列表以及索引

    ##不推荐
    items = 'zero one two three'.split()
    # method 1
    i = 0
    for item in items:
      print i, item
      i += 1
    # method 2
    for i in range(len(items)):
      print i, items[i]
    ##推荐
    items = 'zero one two three'.split()
    for i, item in enumerate(items):
      print i, item

    10. 列表推导

    ##不推荐
    new_list = []
    for item in a_list:
      if condition(item):
        new_list.append(fn(item)) 
    ##推荐
    new_list = [fn(item) for item in a_list if condition(item)]

    11. 列表推导-嵌套

    ##不推荐
    for sub_list in nested_list:
      if list_condition(sub_list):
        for item in sub_list:
          if item_condition(item):
            # do something... 
    ##推荐
    gen = (item for sl in nested_list if list_condition(sl) \
          for item in sl if item_condition(item))
    for item in gen:
      # do something...

    12. 循环嵌套

    ##不推荐
    for x in x_list:
      for y in y_list:
        for z in z_list:
          # do something for x &amp; y 
    ##推荐
    from itertools import product
    for x, y, z in product(x_list, y_list, z_list):
      # do something for x, y, z

    13. 尽量使用生成器代替列表

    ##不推荐
    def my_range(n):
      i = 0
      result = []
      while i &lt; n:
        result.append(fn(i))
        i += 1
      return result # 返回列表
    ##推荐
    def my_range(n):
      i = 0
      result = []
      while i &lt; n:
        yield fn(i) # 使用生成器代替列表
        i += 1
    *尽量用生成器代替列表,除非必须用到列表特有的函数。

    14. 中间结果尽量使用imap/ifilter代替map/filter

    ##不推荐
    reduce(rf, filter(ff, map(mf, a_list)))
    ##推荐
    from itertools import ifilter, imap
    reduce(rf, ifilter(ff, imap(mf, a_list)))
    *lazy evaluation 会带来更高的内存使用效率,特别是当处理大数据操作的时候。

    15. 使用any/all函数

    ##不推荐
    found = False
    for item in a_list:
      if condition(item):
        found = True
        break
    if found:
      # do something if found... 
    ##推荐
    if any(condition(item) for item in a_list):
      # do something if found...

    16. 属性(property)

    =
    ##不推荐
    class Clock(object):
      def __init__(self):
        self.__hour = 1
      def setHour(self, hour):
        if 25 &gt; hour &gt; 0: self.__hour = hour
        else: raise BadHourException
      def getHour(self):
        return self.__hour
    ##推荐
    class Clock(object):
      def __init__(self):
        self.__hour = 1
      def __setHour(self, hour):
        if 25 &gt; hour &gt; 0: self.__hour = hour
        else: raise BadHourException
      def __getHour(self):
        return self.__hour
      hour = property(__getHour, __setHour)

    17. 使用 with 处理文件打开

    ##不推荐
    f = open("some_file.txt")
    try:
      data = f.read()
      # 其他文件操作..
    finally:
      f.close()
    ##推荐
    with open("some_file.txt") as f:
      data = f.read()
      # 其他文件操作...

    18. 使用 with 忽视异常(仅限Python 3)

    ##不推荐
    try:
      os.remove("somefile.txt")
    except OSError:
      pass
    ##推荐
    from contextlib import ignored # Python 3 only
    with ignored(OSError):
      os.remove("somefile.txt")

    19. 使用 with 处理加锁

    ##不推荐
    import threading
    lock = threading.Lock()
    lock.acquire()
    try:
      # 互斥操作...
    finally:
      lock.release()
    ##推荐
    import threading
    lock = threading.Lock()
    with lock:
      # 互斥操作...

    20. 参考

    1) Idiomatic Python: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html
    2) PEP 8: Style Guide for Python Code: http://www.python.org/dev/peps/pep-0008/

    有关Python的22个编程技巧

    1. 原地交换两个数字

    Python 提供了一个直观的在一行代码中赋值与交换(变量值)的方法,请参见下面的示例:

    x,y= 10,20
    print(x,y)
    x,y= y,x
    print(x,y)
    #1 (10, 20)
    #2 (20, 10)

    赋值的右侧形成了一个新的元组,左侧立即解析(unpack)那个(未被引用的)元组到变量 <a> 和 <b>。

    一旦赋值完成,新的元组变成了未被引用状态并且被标记为可被垃圾回收,最终也完成了变量的交换。

    2. 链状比较操作符

    比较操作符的聚合是另一个有时很方便的技巧:

    n= 10
    result= 1< n< 20
    print(result)
    # True
    result= 1> n<= 9
    print(result)
    # False

    3. 使用三元操作符来进行条件赋值

    三元操作符是 if-else 语句也就是条件操作符的一个快捷方式:

    [表达式为真的返回值] if [表达式] else [表达式为假的返回值]

    这里给出几个你可以用来使代码紧凑简洁的例子。下面的语句是说“如果 y 是 9,给 x 赋值 10,不然赋值为 20”。如果需要的话我们也可以延长这条操作链。

    x = 10 if (y == 9) else 20

    同样地,我们可以对类做这种操作:

    x = (classA if y == 1 else classB)(param1, param2)

    在上面的例子里 classA 与 classB 是两个类,其中一个类的构造函数会被调用。

    下面是另一个多个条件表达式链接起来用以计算最小值的例子:

    def small(a,b,c):
    returnaifa<= banda<= celse(bifb<= aandb<= celsec)
    print(small(1,0,1))
    print(small(1,2,2))
    print(small(2,2,3))
    print(small(5,4,3))
    #Output
    #0 #1 #2 #3

    我们甚至可以在列表推导中使用三元运算符:

    [m**2 if m > 10 else m**4 for m in range(50)]
    #=> [0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401]

    4. 多行字符串

    基本的方式是使用源于 C 语言的反斜杠:

    multiStr= “select * from multi_row
    where row_id < 5”
    print(multiStr)
    # select * from multi_row where row_id < 5

    另一个技巧是使用三引号:

    multiStr= “””select * from multi_row
    where row_id < 5″””
    print(multiStr)
    #select * from multi_row
    #where row_id < 5

    上面方法共有的问题是缺少合适的缩进,如果我们尝试缩进会在字符串中插入空格。所以最后的解决方案是将字符串分为多行并且将整个字符串包含在括号中:

    multiStr= (“select * from multi_row ”
    “where row_id < 5 ”
    “order by age”)
    print(multiStr)
    #select * from multi_row where row_id < 5 order by age

    5. 存储列表元素到新的变量中

    我们可以使用列表来初始化多个变量,在解析列表时,变量的数目不应该超过列表中的元素个数:【译者注:元素个数与列表长度应该严格相同,不然会报错】

    testList= [1,2,3]
    x,y,z= testList
    print(x,y,z)
    #-> 1 2 3

    6. 打印引入模块的文件路径

    如果你想知道引用到代码中模块的绝对路径,可以使用下面的技巧:

    import threading
    import socket
    print(threading)
    print(socket)
    #1- <module ‘threading' from ‘/usr/lib/python2.7/threading.py'>
    #2- <module ‘socket' from ‘/usr/lib/python2.7/socket.py'>

    7. 交互环境下的 “_” 操作符

    这是一个我们大多数人不知道的有用特性,在 Python 控制台,不论何时我们测试一个表达式或者调用一个方法,结果都会分配给一个临时变量: _(一个下划线)。

    >>> 2+ 1
    3
    >>> _
    3
    >>> print_
    3
    “_” 是上一个执行的表达式的输出。

    8. 字典/集合推导

    与我们使用的列表推导相似,我们也可以使用字典/集合推导,它们使用起来简单且有效,下面是一个例子:

    testDict= {i: i *iforiinxrange(10)}
    testSet= {i *2foriinxrange(10)}
    print(testSet)
    print(testDict)
    #set([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
    #{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

    注:两个语句中只有一个 <:> 的不同,另,在 Python3 中运行上述代码时,将 <xrange> 改为 <range>。

    9. 调试脚本

    我们可以在 <pdb> 模块的帮助下在 Python 脚本中设置断点,下面是一个例子:

    import pdb
    pdb.set_trace()

    我们可以在脚本中任何位置指定 <pdb.set_trace()> 并且在那里设置一个断点,相当简便。

    10. 开启文件分享

    Python 允许运行一个 HTTP 服务器来从根路径共享文件,下面是开启服务器的命令:

    # Python 2
    python -m SimpleHTTPServer
    # Python 3
    python3 -m http.server

    上面的命令会在默认端口也就是 8000 开启一个服务器,你可以将一个自定义的端口号以最后一个参数的方式传递到上面的命令中。

    11. 检查 Python 中的对象

    我们可以通过调用 dir() 方法来检查 Python 中的对象,下面是一个简单的例子:

    test= [1,3,5,7]
    print(dir(test))
    [‘__add__', ‘__class__', ‘__contains__', ‘__delattr__', ‘__delitem__', ‘__delslice__', ‘__doc__', ‘__eq__', ‘__format__', ‘__ge__', ‘__getattribute__', ‘__getitem__', ‘__getslice__', ‘__gt__', ‘__hash__', ‘__iadd__', ‘__imul__', ‘__init__', ‘__iter__', ‘__le__', ‘__len__', ‘__lt__', ‘__mul__', ‘__ne__', ‘__new__', ‘__reduce__', ‘__reduce_ex__', ‘__repr__', ‘__reversed__', ‘__rmul__', ‘__setattr__', ‘__setitem__', ‘__setslice__', ‘__sizeof__', ‘__str__', ‘__subclasshook__', ‘append', ‘count', ‘extend', ‘index', ‘insert', ‘pop', ‘remove', ‘reverse', ‘sort']

    12. 简化 if 语句

    我们可以使用下面的方式来验证多个值:

    if m in [1,3,5,7]:

    而不是:

    if m==1 or m==3 or m==5 or m==7:

    或者,对于 in 操作符我们也可以使用 ‘{1,3,5,7}' 而不是 ‘[1,3,5,7]',因为 set 中取元素是 O(1) 操作。

    13. 一行代码计算任何数的阶乘

    Python 2.x.
    result= (lambdak: reduce(int.__mul__,range(1,k+1),1))(3)
    print(result)
    #-> 6
    Python 3.x.
    import functools
    result= (lambdak: functools.reduce(int.__mul__,range(1,k+1),1))(3)
    print(result)
    #-> 6

    14. 找到列表中出现最频繁的数

    test= [1,2,3,4,2,2,3,1,4,4,4]
    print(max(set(test),key=test.count))
    #-> 4

    15. 重置递归限制

    Python 限制递归次数到 1000,我们可以重置这个值:

    import sys
    x=1001
    print(sys.getrecursionlimit())
    sys.setrecursionlimit(x)
    print(sys.getrecursionlimit())
    #1-> 1000
    #2-> 1001

    请只在必要的时候采用上面的技巧。

    16. 检查一个对象的内存使用

    在 Python 2.7 中,一个 32 比特的整数占用 24 字节,在 Python 3.5 中利用 28 字节。为确定内存使用,我们可以调用 getsizeof 方法:

    在 Python 2.7 中

    import sys
    x=1
    print(sys.getsizeof(x))
    #-> 24
    在 Python 3.5 中
    import sys
    x=1
    print(sys.getsizeof(x))
    #-> 28

    17. 使用 __slots__ 来减少内存开支

    你是否注意到你的 Python 应用占用许多资源特别是内存?有一个技巧是使用 __slots__ 类变量来在一定程度上减少内存开支。

    import sys
    classFileSystem(object):
    def __init__(self,files,folders,devices):
    self.files= files
    self.folders= folders
    self.devices= devices
    print(sys.getsizeof(FileSystem))
    classFileSystem1(object):
    __slots__= [‘files','folders','devices']
    def __init__(self,files,folders,devices):
    self.files= files
    self.folders= folders
    self.devices= devices
    print(sys.getsizeof(FileSystem1))
    #In Python 3.5
    #1-> 1016
    #2-> 888

    很明显,你可以从结果中看到确实有内存使用上的节省,但是你只应该在一个类的内存开销不必要得大时才使用 __slots__。只在对应用进行性能分析后才使用它,不然地话,你只是使得代码难以改变而没有真正的益处。

    【译者注:在我的 win10 python2.7 中上面的结果是:

    #In Python 2.7 win10
    #1-> 896
    #2-> 1016

    所以,这种比较方式是不那么让人信服的,使用 __slots__ 主要是用以限定对象的属性信息,另外,当生成对象很多时花销可能会小一些,具体可以参见 python 官方文档:

    The slots declaration takes a sequence of instance variables and reserves just enough space in each instance to hold a value for each variable. Space is saved because dict is not created for each instance. 】

    18. 使用 lambda 来模仿输出方法

    import sys
    lprint=lambda *args:sys.stdout.write(” “.join(map(str,args)))
    lprint(“python”,”tips”,1000,1001)
    #-> python tips 1000 1001

    19.从两个相关的序列构建一个字典

    t1= (1,2,3)
    t2= (10,20,30)
    print(dict(zip(t1,t2)))
    #-> {1: 10, 2: 20, 3: 30}

    20. 一行代码搜索字符串的多个前后缀

    print(“http://www.google.com”.startswith((“http://”,”https://”)))
    print(“http://www.google.co.uk”.endswith((“.com”,”.co.uk”)))
    #1-> True
    #2-> True

    21. 不使用循环构造一个列表

    import itertools
    test= [[-1,-2],[30,40],[25,35]]
    print(list(itertools.chain.from_iterable(test)))
    #-> [-1, -2, 30, 40, 25, 35]

    22. 在 Python 中实现一个真正的 switch-case 语句

    下面的代码使用一个字典来模拟构造一个 switch-case。

    def xswitch(x):
    returnxswitch._system_dict.get(x,None)
    xswitch._system_dict= {‘files': 10,'folders': 5,'devices': 2}
    print(xswitch(‘default'))
    print(xswitch(‘devices'))
    #1-> None
    #2-> 2

     

    Python 3.7中dataclass装饰器用法详解

    Python 3.7新功能之dataclass装饰器详解

    前言

    Python 3.7 将于今年夏天发布,Python 3.7 中将会有许多新东西:

    • 各种字符集的改进
    • 对注释的推迟评估
    • 以及对dataclass的支持

    最激动人心的新功能之一是 dataclass 装饰器。

    什么是 Data Class

    大多数 Python 开发人员编写过很多像下面这样的类:

    class MyClass:
     def __init__(self, var_a, var_b):
     self.var_a = var_a
     self.var_b = var_b

    dataclass 可以为简单的情况自动生成方法,例如,一个__init__接受这些参数并将其分配给自己,之前的小例子可以重写为:

    @dataclass
    class MyClass:
     var_a: str
     var_b: str

    那么通过一个例子来看看如何使用吧

    星球大战 API

    可以使用 requests 从星球大战 API 获取资源:

    response = requests.get('https://swapi.co/api/films/1/')
    dictionary = response.json()

    让我们来看看 dictionary (简化过)的结果:

    {
     'characters': ['https://swapi.co/api/people/1/',… ],
     'created': '2014-12-10T14:23:31.880000Z',
     'director': 'George Lucas',
     'edited': '2015-04-11T09:46:52.774897Z',
     'episode_id': 4,
     'opening_crawl': 'It is a period of civil war.\r\n … ',
     'planets': ['https://swapi.co/api/planets/2/', … ],
     'producer': 'Gary Kurtz, Rick McCallum',
     'release_date': '1977-05-25',
     'species': ['https://swapi.co/api/species/5/',…],
     'starships': ['https://swapi.co/api/starships/2/',…],
     'title': 'A New Hope',
     'url': 'https://swapi.co/api/films/1/',
     'vehicles': ['https://swapi.co/api/vehicles/4/',…]

    封装 API

    为了正确地封装一个 API,我们应该创建一个用户可以在其应用程序中使用的对象,因此,在Python 3.6 中定义一个对象来包含requests对 /films/endpoint的响应:

    class StarWarsMovie:
     def __init__(self,
       title: str,
       episode_id: int,
       opening_crawl: str,
       director: str,
       producer: str,
       release_date: datetime,
       characters: List[str],
       planets: List[str],
       starships: List[str],
       vehicles: List[str],
       species: List[str],
       created: datetime,
       edited: datetime,
       url: str
       ):
    
     self.title = title
     self.episode_id = episode_id
     self.opening_crawl= opening_crawl
     self.director = director
     self.producer = producer
     self.release_date = release_date
     self.characters = characters
     self.planets = planets
     self.starships = starships
     self.vehicles = vehicles
     self.species = species
     self.created = created
     self.edited = edited
     self.url = url
    
     if type(self.release_date) is str:
      self.release_date = dateutil.parser.parse(self.release_date)
    
     if type(self.created) is str:
      self.created = dateutil.parser.parse(self.created)
    
     if type(self.edited) is str:
      self.edited = dateutil.parser.parse(self.edited)

    仔细的读者可能已经注意到这里有一些重复的代码。

    这是使用 dataclass 装饰器的经典案例,我们需要创建一个主要用来保存数据的类,只需一点验证,所以让我们来看看我们需要修改什么。

    首先,data class 自动生成一些 dunder 方法,如果我们没有为 data class 装饰器指定任何选项,则生成的方法有:__init__,__eq__和__repr__,如果你已经定义了__repr__但没定义__str__,默认情况下 Python(不仅仅是 data class)将实现返回__repr__的输出__str__方法。因此,只需将代码更改为以下代码即可实现四种 dunder 方法:

    @dataclass
    class StarWarsMovie:
     title: str
     episode_id: int
     opening_crawl: str
     director: str
     producer: str
     release_date: datetime
     characters: List[str]
     planets: List[str]
     starships: List[str]
     vehicles: List[str]
     species: List[str]
     created: datetime
     edited: datetime
     url: str

    我们去掉了__init__方法,以确保 data class 装饰器可以添加它生成的对应方法。不过,我们在这个过程中失去了一些功能,我们的 Python 3.6 构造函数不仅定义了所有的值,还试图解析日期,我们怎样才能用 data class 来做到这一点呢?

    如果要覆盖 __init__,我们将失去 data class 的优势,因此,如果要处理任何附加功能可以使用新的 dunder 方法:__post_init__,让我们看看__post_init__方法对于我们的包装类来说是什么样子的:

    def __post_init__(self):
     if type(self.release_date) is str:
      self.release_date = dateutil.parser.parse(self.release_date)
    
     if type(self.created) is str:
      self.created = dateutil.parser.parse(self.created)
    
     if type(self.edited) is str:
      self.edited = dateutil.parser.parse(self.edited)

    就是这样! 我们可以使用 data class 装饰器在用三分之二的代码量实现我们的类。

    更多好东西

    通过使用装饰器的选项,可以为用例进一步定制 data class,默认选项是:

    @dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)
    • init决定是否生成__init__ dunder 方法
    • repr决定是否生成__repr__ dunder方法
    • eq对__eq__ dunder 方法也是如此,它决定相等性检查的行为(your_class_instance == another_instance)
    • order 实际上创建了四种 dunder 方法,它们确定所有检查小于,and/or,大于的行为,如果将其设置为 true,则可以对对象列表进行排序。

    最后两个选项确定对象是否可以被哈希化,如果你想使用你的 class 的对象作为字典键的话,这是必要的。

    更多信息请参考:PEP 557 -- Data Classes

    python类装饰器用法实例

    本文实例讲述了python类装饰器用法。分享给大家供大家参考。具体如下:

    #!coding=utf-8 
    registry = {} 
    def register(cls): 
      registry[cls.__clsid__] = cls 
      return cls 
    @register 
    class Foo(object): 
      __clsid__ = '123-456' 
      def bar(self): 
        pass 
    print registry 
    
    

    运行结果如下:

    {'123-456': <class '__main__.Foo'>}

    希望本文所述对大家的Python程序设计有所帮助。

    Python 使用类写装饰器的小技巧

    最近学到了一个有趣的装饰器写法,就记录一下。

    装饰器是一个返回函数的函数。写一个装饰器,除了最常见的在函数中定义函数以外,Python还允许使用类来定义一个装饰器。

    1、用类写装饰器

    下面用常见的写法实现了一个缓存装饰器。

    def cache(func):
      data = {}
      def wrapper(*args, **kwargs):
        key = f'{func.__name__}-{str(args)}-{str(kwargs)})'
        if key in data:
          result = data.get(key)
          print('cached')
        else:
          result = func(*args, **kwargs)
          data[key] = result
          print('calculated')
        return result
      return wrapper

    看看缓存的效果。

    @cache
    def rectangle_area(length, width):
      return length * width
    rectangle_area(2, 3)
    # calculated
    # 6
    rectangle_area(2, 3)
    # cached
    # 6

    装饰器的@cache是一个语法糖,相当于func = cache(func),如果这里的cache不是一个函数,而是一个类又会怎样呢?定义一个类class Cache, 那么调用func = Cache(func)会得到一个对象,这时返回的func其实是Cache的对象。定义__call__方法可以将类的实例变成可调用对象,可以像调用函数一样调用对象。然后在__call__方法里调用原本的func函数就能实现装饰器了。所以Cache类也能当作装饰器使用,并且能以@Cache的形式使用。

    接下来把cache函数改写为Cache类:

    class Cache:
      def __init__(self, func):
        self.func = func
        self.data = {}
      def __call__(self, *args, **kwargs):
        func = self.func
        data = self.data
        key = f'{func.__name__}-{str(args)}-{str(kwargs)})'
        if key in data:
          result = data.get(key)
          print('cached')
        else:
          result = func(*args, **kwargs)
          data[key] = result
          print('calculated')
        return result

    再看看缓存结果,效果一样。

    @Cache
    def rectangle_area(length, width):
      return length * width
    rectangle_area(2, 3)
    # calculated
    # 6
    rectangle_area(2, 3)
    # cached
    # 6

    2、装饰类的方法

    装饰器不止能装饰函数,也经常用来装饰类的方法,但是我发现用类写的装饰器不能直接用在装饰类的方法上。(有点绕…)

    先看看函数写的装饰器如何装饰类的方法。

    class Rectangle:
      def __init__(self, length, width):
        self.length = length
        self.width = width
      @cache
      def area(self):
        return self.length * self.width
    r = Rectangle(2, 3)
    r.area()
    # calculated
    # 6
    r.area()
    # cached
    # 6

    但是如果直接换成Cache类会报错,这个错误的原因是area被装饰后变成了类的一个属性,而不是方法。

    class Rectangle:
      def __init__(self, length, width):
        self.length = length
        self.width = width
      @Cache
      def area(self):
        return self.length * self.width
    r = Rectangle(2, 3)
    r.area()
    # TypeError: area() missing 1 required positional argument: 'self'
    Rectangle.area
    # <__main__.Cache object at 0x0000012D8E7A6D30>
    r.area
    # <__main__.Cache object at 0x0000012D8E7A6D30>

    回头再来看看没有装饰器的情况,Python在实例化对象后把函数变成了方法。

    class Rectangle:
      def __init__(self, length, width):
        self.length = length
        self.width = width
    
      def area(self):
        return self.length * self.width
    
    Rectangle.area
    # <function Rectangle.area at 0x0000012D8E7B28C8>
    r = Rectangle(2, 3)
    r.area
    # <bound method Rectangle.area of <__main__.Rectangle object

    因此解决办法很简单,要用类写的装饰器来装饰类的方法,只需要把可调用对象包装成函数就行。

    # 定义一个简单的装饰器,什么也不做,仅仅是把可调用对象包装成函数
    def method(call):
      def wrapper(*args, **kwargs):
        return call(*args, **kwargs)
      return wrapper
    class Rectangle:
      def __init__(self, length, width):
        self.length = length
        self.width = width
      @method
      @Cache
      def area(self):
        return self.length * self.width
    r = Rectangle(2, 3)
    r.area()
    # calculated
    # 6
    r.area()
    # cached
    # 6

    或者用@property还能直接把方法变成属性。

    class Rectangle:
      def __init__(self, length, width):
        self.length = length
        self.width = width
      @property
      @Cache
      def area(self):
        return self.length * self.width
    r = Rectangle(2, 3)
    r.area
    # calculated
    # 6
    r.area
    # cached
    # 6

    总结

    用类写装饰器并非什么特别的技巧,一般情况下确实没必要这么写,不过这样就可以用一些类的特性来写装饰器,比如类的继承,也算是提供了另一种思路吧。

    上一篇:Python机器学习算法  下一篇:Python设计模式

    展开 +

    收起 -

     
    《Python数据抓取技术与实战》学习笔记

    Copyright 2018-2020 xz577.com 码农之家

    本站所有电子书资源不再提供下载地址,只分享来路

    免责声明:网站所有作品均由会员网上搜集共同更新,仅供读者预览及学习交流使用,下载后请24小时内删除

    版权投诉 / 书籍推广 / 赞助:QQ:520161757