精华内容
下载资源
问答
  • 来一起愉快的开始Python吧

    千次阅读 2017-10-23 22:50:35
    python-愉快的开始什么是pythonpython的具有快平台性 Windows Linux Mac/Os 定义Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。一张图片告诉你Python语言的强大就像我们当初学习的Rxjava2.x和...

    python-愉快的开始

    什么是python?

    python的具有快平台性
    • Windows
    • Linux
    • Mac/Os

    定义

    Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。

    一张图片告诉你Python语言的强大

    就像我们当初学习的Rxjava2.x和Rxjava1一样,api的变动同样需要我们进一步去更新自己的技术。

    Python2和python3的ApI的不bi比较

    http://bbs.fishc.com/forum.php?mod=viewthread&tid=35509&highlight=Python3

    下载

    https://www.python.org/downloads/

    安装

    Python下载.png

    如何启动Python

    通过IDLE去启动。

    什么是IDLE

    IDLE 是一个Pyhton Shell,一个通过键入文本与程序交互的途径。类似于XSHell和cmd。

    谱写我的第一个HelloWord

    Python之HelloWord.png

    谱写小案例测试:

    谱写第一个小案例.png

    案例输出结果.png

    总之

    学习一门语言,我们就需要深入其中,把变成语言想象成你的女朋朋友 ,你的情人。这样子你学习起来才会更加用心了吗。

    阅读更多

    高级UI特效仿直播点赞效果—一个优美炫酷的点赞动画

    一个实现录音和播放的小案例

    NDK项目实战—高仿360手机助手之卸载监听

    玩转自定义柱形图—教你玩一把牛逼的

    加入大牛圈

    相信自己,没有做不到的,只有想不到的

    如果你觉得此文对您有所帮助,欢迎入群 QQ交流群 :644196190
    微信公众号:终端研发部

    技术+职场

    展开全文
  • 让我们拿起python吧-python科普篇

    千次阅读 2015-02-09 23:50:07
    可能是因为Python语言练就了动态语言的以柔克刚、借力打力的太极推手功夫,加上Python简单导致的生产力指数级增长效应,Python应该是应用最全面的一种语言了。 从脚本、到web开发、到嵌入使用、到客户端、到...
    软件业的特点,就是层出不穷的新东东涌现。Windows早就革了DOS的命,浏览器差不多革了桌面软件的命,云计算准备再革所有软件的命,最后还追上个乔布斯说一切听他的。

    动荡的软件界,让人眼花缭乱。这一切的后面,是失落的编程族:好容易才精通的东西,随之变得一钱不值。曾经的人才,如同数码产品般的迅速贬值。乃至好多人怀疑,编程是吃青春饭的行当。

    在我前10年的编程经历里,重复着同样的杯具。Turbo C学完了,用Borland C,Visual C++太麻烦,开始用PowerBuilder快速开发,接上去Delphi、C++Builder、JBuilder,十八般武艺都学完了,结果又蹦出 个新时髦。哪天有个终结?在软件的浪潮里,程序员太渺小了。我们害怕自己,会同过气的语言一样昙花一现,成为过眼烟云。

    不是我见异思迁,而是潮流不可阻挡。但直至Python出现,故事开始转折。

    起源于上世纪80年代末的Python语言(http://python.org),是一种开放源代码的解释型高级动态类型语言,语法简练、类库丰富,以开发效率高著称。

    20多年的发展时间,Python是愈久弥香,经历住了时间的考验。Python是Goolge的三大语言之一;全球最大的视频网站 YouTube,以及国内的豆瓣网也是采用Python开发;最新最热的行当中,python是往往web game的首选开发语言之一,谷歌和国内的易度云计算开发平台也都选择了Python语言。

    这就是神奇的Python,在交错的语言大战中,Python却成为一颗长青树,不断焕发新的光彩。

    而Python也成为我最近8年的编程生涯的主体,或许这将是我作为程序员的归属,一直走下去。让我们一起分享下这不一样的Python。

    简单是硬道理
    ====================

    php被很多严肃的开发人员诟病,太简单、太脏了。然而php却被企业所喜欢,连yahoo和facebook都选择了php, php不断在发展,生命力异常旺盛。

    为什么?因为简单。

    程序语言,从机器语言到汇编,到高级语言,不就是简单在驱动吗?程序员也是人,需要更容易使用的语言。时髦点的话,就是语言也要多为咱程序员服务了,人机接口、用户体验要好。

    因为简单,所以开发效率高;因为简单,所以容易阅读和维护;因为简单,所以不怕没人接手;因为简单,重构下也无妨;因为简单,项目经理就不必写伪代码了,直接Coding出框架代码吧.

    简单带来的优势,是成指数级别增长。简单省了钱,加快的进度,减少的项目风险,首先老板会喜欢。简单是硬道理。.net同样是靠简单占领了不小的市场份额。

    python语言最早设计指导思想之一,就是想提高代码的可读性。Python语言采用缩进来标识代码块,而Java采用的是配对的大括号来标 识。不仅仅是排版更漂亮,Python的数据结构非常简单和统一,Python自带非常庞大的类库,很多东西拿来即可。这样,相同的逻辑,使用 python可能只需要java五分之一的代码量。

    很多软件爱拿自己“数百万行代码”出来说事,表明自己很强大。而在Python的世界里,人们在炫耀相同的功能后,喜欢说我只有几千行代码(比如 Python上的对象数据库系统ZODB就只有不到5千行代码)。背后的意思是,放心用吧,有问题你也很容易维护这个系统;或者如果有时间,你自己也可以 接管这个代码。

    Pythonic之美
    ======================

    php靠一个“简单”占领了市场,php的哲学是quick and dirty;Python同样简单,但Python的哲学是Pythonic。Pythonic是什么?Pythonic是quick and not dirty,也就是quick and beautiful.

    这个Pythonic之美,代表了程序员的素养和品味。什么是好的代码?什么是漂亮的代码?有一本书,叫做《unix编程艺术》,实际上一本对编 程审美进行洗脑的经典书籍。而Python语言的设计理念,正符合了这种编程审美。因此,Python深受高端开发人员的喜欢,Python和他们有相同 的文化。这如同,很多人将拥有Mac机作为自己审美品味的象征一样。

    让我们再一次领略下Pythonic的禅意,它作为一个彩蛋隐藏在python的this模块::

    >>> import this

    下面是我基于赖勇浩先生的首译,稍作更改后的翻译::

    (让我们来说说该如何写代码:)
    优美胜于丑陋,
    清晰明了胜于晦涩,
    简洁胜于复杂,
    而复杂又胜于杂乱。
    扁平胜于多层嵌套,
    适当空行、错落有致胜于拥挤不堪,
    可读性很重要。
    虽然实用主义往往和上述规则矛盾,
    但所有特例都不足以打破他们。
    绝不要忽略异常(不写 except:pass),
    除非你进行精准地捕获。
    当你遇到含糊不清,不要尝试猜测可能,
    一定有一种,而且绝对是唯一的一种明显的处理方法。
    虽然你可能一开始很难找到这条路,除非你是 Python 之父。
    现在就动手好过永远不做,
    虽然不做通常好于蛮干。
    实现方法如果难以表述,那这思路就肯定不对;
    反之如果容易表述,那可能是个好想法。
    命名空间是一个值得叫好的想法,我们应当多加利用。

    Python宝库
    ===================
    Python号称自带电池(Battery Included),也就是有强大的类库。

    Python内建的类库就已经非常全面了。从web抓取,到xml解析,到嵌入式数据库,到压缩包的处理,到邮件协议,到json解析,而且不断在增长。

    如果你还觉得不够,可到http://pypi.python.org上 去找,这里有1万多种第三方的类库。从图片处理、到加密算法,到excel文件解析生成,到pdf文件转换,可谓应有尽有,无所不能。探访这里的乐趣,就 如同海边拾贝,如同山间采菌,那种惊喜,那种“大国大民”的优越感,让你在心底涌现出投身Python的幸福,进而归属感倍增。

    更重要的是,所有的这些宝贝,全部开源,而且大都是类 BSD协议的开源,您直接用于商业。有了这些,我会经常为自己选择了Python而庆幸,这使得我们像易度这样庞大的应用快速构建起来。

    Python自带强大的包管理机制,简简单单一个easy_install命令,您就可以在线安装升级、卸载这些包。这类似debian/ubuntu的apt包管理机制一般方便。

    全能选手
    ===============
    可能是因为Python语言练就了动态语言的以柔克刚、借力打力的太极推手功夫,加上Python简单导致的生产力指数级增长效应,Python应该是应用最全面的一种语言了。
    从脚本、到web开发、到嵌入使用、到客户端、到云计算,python都干得不错。你只需要学会Python这一门语言,老板给你什么任务你几乎都能完成。让我们随着时间的年轮滚进,看看Python应乎潮流的72变。

    操作系统脚本
    -----------------------------

    几乎所有的Linux发行版本和Mac都自带了Python解释环境,还有Nokia的S60手机平台,可直接运行python脚本。简洁的 Python语法,即便是不大懂开发的系统管理员或者企业IT人员,也可以快速掌握。事实上Ubuntu和Red Hat的安装程序,以及 Gentoo的包管理系统也是用python开发的。

    就我所知,Google的那些爬虫,就大都采用python编写完成。料想他们调整一次调整一次排名算法不会太麻烦吧。

    最佳伴侣
    -----------------------

    很多软件往往选择会选择将整个Python接上去内嵌到软件中,作为一个操控软件的脚本语言。

    最典型的是各种3D动画软件,大都使用Python来做特效。比如Maya、Blender等;一些2D的图像处理软件,比如GIMP等也可Python来更灵活的处理图片。

    其他的,OpenOffice可以内嵌Python编写宏;知名的地理信息系统ArcGIS采用Python作为脚本语言;一些游戏引擎,也通常 选择Python作为游戏逻辑的编写工具;还有一些有限元分析软件和数据统计分析和挖掘的软件,也采用Python作为使用接口。

    客户端程序
    -------------------------

    现在的桌面,已经不是Windows一统天下了,Linux和Mac的用户在逐渐增多。谁都想自己写的程序,能够在多个平台上运行。Python就是这为数不多的选择之一。

    国内limodou编写的UliPad文本编辑器就是用Python编写的;而最早的BT下载客户端,也是采用Python。

    Web 应用
    --------------------------------

    Web应用是Python大放光彩的领域。豆瓣网站很pythonic,网站风格完全符合python简洁、漂亮、优美的审美。而豆瓣也是采用了python上的一个叫做quixote的web框架开发完成。更大的YouTue.com案例我就不多说了。

    Python上的web轻量级框架,其实可能有数十种之多(这可能需要归功于Python的生产效率)。最流行的是Django,其他的包括 TurboGears、Pylons、BFG等。随着Python上的web服务网关接口(WSGI)的逐渐普及,各个web框架直接的公共部分 (WSGI中间件)也越来越多,有很多框架也产生相互合并的意图。分久必合,我相信统一是web框架之间竞争的最后结果。

    在今天webgame“肆虐”的风潮里,Python同样高调登场。5分钟版的开心农场就是采用Python开发的。Python是众多webgame工作室的首选游戏逻辑语言。

    企业应用
    ------------------------------

    Python上的企业应用代表,著名的包括开源的ERP软件OpenERP。OpenERP从后台到客户端,到web端,全部是采用Python开发完成。

    另外一个就是Plone。Plone是一个世界级的开源内容管理软件,被包括美国中情局在内的全世界众多政府大机构、军方和大企业使用。Plone基于Python上的一个重量级web应用框架Zope开发。

    云时代的新生
    ---------------------------------

    在如今云计算风生水起的时代,Python被谷歌云开发平台Goolge App Engine奉为首选的云计算语言。而国内的易度云办公平台,从内部实现到第三方的PaaS开发,都采用了Python语言。当前在云存储方面的新星 DropBox,更是从后台到客户端,全面采用了Python语言。

    如果云代表了软件业未来之一,那Python这一次真正开始走在最前面。

    说说缺点
    -------------------------

    没有哪个人是完美的,Python也一样。

    Python的一个大问题是,对多处理器支持不好。也就是一个Python进程,目前只能在一个处理器上运行。这对于日益普及的多处理器架构,不 能说是一个缺憾。当然对于web应用,采用多进程负载均衡便能解决这一问题。目前Python也正在提供一个支持多处理器的版本,但是还没有达到稳定的版 本,相应不久的未来这个问题可以得到解决。

    另外一个问题是解释型语言的通病,就是性能问题。这个问题,Python社区有个pypy项目,将Python的解释型执行,转换为编译执行,大 大提升效率。只是这个pypy还没有到正式版本。谷歌内部也启动了一个项目,号称目标是将Python的执行效率提升5倍,让我们拭目以待。

    尾声
    ================
    我们是职业程序手,我们需要经久耐用、多快好省、功力强大的语言。我选择了Python,你呢?
    原文:
    http://www.douban.com/group/topic/13347288/
    展开全文
  • 5 个无聊 Python 程序,用 Python 整蛊你的朋友们吧

    万次阅读 多人点赞 2021-01-09 22:35:52
    亲爱的朋友们,Python 整蛊程序之一 整蛊程序之二 整蛊程序之三 整蛊程序之四

    Python 能做很多无聊,但有意思的事情,例如接下来的一些案例。

    以下程序,不要发代码,要不实现不了你整蛊的目的。

    要打包成一个 exe 程序,发给朋友才有意思。

    使用 pip install pyinstaller

    打包命令如下:

    pyinstaller -F 文件名.py
    

    过程中如果出现 BUG(一般是编码错误),点击导航查看解决方案

    无聊程序之一

    while True:
    	n = input("猜猜我在想啥?")
    	print("猜错喽")
    

    你的朋友将永远无法知道你在想什么。

    当然我安装 360 之后,程序没了。有兴趣研究免杀的,可以在给本文点个赞,点赞过 100,橡皮擦出套 Python 免杀教程。

    天空是蔚蓝色,窗外有千纸鹤
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧

    无聊程序之二

    死命弹窗

    import tkinter.messagebox
    
    while True:
        tkinter.messagebox.showerror('Windows 错误','你的电脑正在被攻击!')
    

    运行之后,很就刺激了,如果对方不会杀进程,更刺激。
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧
    天空是蔚蓝色,窗外有千纸鹤

    无聊程序之三

    调用默认浏览器,无限打开 CSDN ,让他爱上学习。

    import webbrowser
    while True:
        webbrowser.open('www.csdn.net')
    

    额,使用之后,橡皮擦自己的电脑死机了。
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧

    瞬间 CPU…
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧
    天空是蔚蓝色,窗外有千纸鹤

    无聊程序之四

    这个程序就动感多了,会随机出现弹窗。

    import tkinter as tk
    import random
    import threading
    import time
    
    
    def boom():
        window = tk.Tk()
        width = window.winfo_screenwidth()
        height = window.winfo_screenheight()
        a = random.randrange(0, width)
        b = random.randrange(0, height)
        window.title('你是一个傻狍子')
        window.geometry("200x50" + "+" + str(a) + "+" + str(b))
        tk.Label(window, text='你是一个傻狍子', bg='green',
                 font=('宋体', 17), width=20, height=4).pack()
        window.mainloop()
    
    
    threads = []
    for i in range(100):
        t = threading.Thread(target=boom)
        threads.append(t)
        time.sleep(0.1)
        threads[i].start()
    

    运行效果如下图所示,非常带劲,可以任意修改。
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧
    天空是蔚蓝色,窗外有千纸鹤

    无聊程序之五

    该程序在橡皮擦看来能排到第一,甚至可以和当下最火的枪茅台案例结合一下。

    import os
    import time
    a = """
    
         oooo oooooooooo.            .oooooo..o                     oooo         o8o  oooo  oooo
         `888 `888'   `Y8b          d8P'    `Y8                     `888         `"'  `888  `888
         888  888      888         Y88bo.       .ooooo.   .ooooo.   888  oooo  oooo   888   888
         888  888      888          `"Y8888o.  d88' `88b d88' `"Y8  888 .8P'   `888   888   888
         888  888      888 8888888      `"Y88b 888ooo888 888        888888.     888   888   888
         888  888     d88'         oo     .d8P 888    .o 888   .o8  888 `88b.   888   888   888
    .o. 88P o888bood8P'           8""88888P'  `Y8bod8P' `Y8bod8P' o888o o888o o888o o888o o888o
    `Y888P
    
    功能列表:
    1.预约商品
    2.秒杀抢购商品
    """
    print(a)
    
    key = input("请选择:")
    
    if key == "1":
         time.sleep(1.5)
         print('没有预约到\n')
         time.sleep(3)
         print('没事的,来抱一哈\n')
    
    else:
         print("既然如此...")
         time.sleep(3)
         print("那你想得美~~~~~")
         os.system('shutdown -r -t 10')
    time.sleep(10)
    

    天空是蔚蓝色,窗外有千纸鹤
    别运行,运行之后别怪我。

    pyinstaller 编码 BUG

    在使用 pyinstaller 进行打包 exe 的时候,会出现如下错误:

      File "c:\users\administrator\appdata\local\programs\python\python37\lib\site-packages\PyInstaller\utils\hooks\__init__.py", line 68, in __exec_python_cmd
        txt = exec_python(*cmd, env=pp_env)
      File "c:\users\administrator\appdata\local\programs\python\python37\lib\site-packages\PyInstaller\compat.py", line 526, in exec_python
        return exec_command(*cmdargs, **kwargs)
      File "c:\users\administrator\appdata\local\programs\python\python37\lib\site-packages\PyInstaller\compat.py", line 321, in exec_command
        out = out.decode(encoding)
    AttributeError: 'str' object has no attribute 'decode'
    

    截图如下:
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧
    按照 BUG 提示的位置,修改下述代码:

    out = out.decode(encoding) # 改为  out = out
    

    打包成功在 dist 文件中找寻 exe 程序即可。
    10 个无聊 Python 程序,用 Python 整蛊你的朋友们吧

    写完了,创意时刻

    想学 Python 爬虫,可以订阅橡皮擦专栏哦~ 🈲🈲🈲🈲 点击发现惊喜 🈲🈲🈲🈲

    今天是持续写作的第 49 / 100 天。
    如果你有想要交流的想法、技术,欢迎在评论区留言。


    如果你想跟博主建立亲密关系,可以关注同名公众号 梦想橡皮擦,近距离接触一个逗趣的互联网高级网虫。
    博主 ID:梦想橡皮擦,希望大家点赞评论收藏

    展开全文
  • Python

    万次阅读 2017-09-23 14:38:03
    就学习一下Python吧,听说这是一门很神奇的语言。下面言归正传~    在线文档查询:点击查看    IDE:IntelJ。    有关IntelJ的安装与注册详见博文《IntelliJ IDEA 2016注册方法和注册码》。    下面介绍...

    预备知识:

    空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。此外,
    Python还提供了列表、字典等多种数据类型,还允许创建自定义数据类型。Python的注释以 # 开头,后面的文字直到行
    尾都算注释# 这一行全部都是注释...print 'hello' # 这也是注释   会输出hello如果一个字符串包含很多需要转义
    的字符,对每一个字符都进行转义会很麻烦。为了避免这种情况,我们可以在字符串前面加个前缀 r ,表示这是一个 raw 字符串,里面的字符就不需要转义了。例如:r'\(~_~)/ \(~_~)/'
    但是r'...'表示法不能表示多行字符串,也不能表示包含'和 "的字符串(为什么?)
    如果要表示多行字符串,可以用'''...'''表示:
    '''Line 1
    Line 2
    Line 3'''
    上面这个字符串的表示方法和下面的是完全一样的:
    'Line 1\nLine 2\nLine 3'
    还可以在多行字符串前面添加 r ,把这个多行字符串也变成一个raw字符串:
    r'''Python is created by "Guido".
    It is free and easy to learn.
    Let's start learn Python in imooc!'''
    ----------------------------------------------------------------------------------------------------------------------------------------------------------
    a = True
    print a and 'a=T' or 'a=F'
    计算结果不是布尔类型,而是字符串 'a=T',这是为什么呢?因为Python把0、空字符串''和None看成 False,其他数
    值和非空字符串都看成 True,所以:True and 'a=T' 计算结果是 'a=T'
    继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'要解释上述结果,又涉及到 and 和 or 运算的一条重要法则:短路计
    算。1. 在计算 a and b 时,如果 a 是 False,则根据与运算法则,整个结果必定为 False,因此返回 a;如果 a 是 True,则整个计算结果必定取决与 b,因此返回 b。2. 在计算 a or b 时,如果 a 是 True,则根据或运算法则,整个计算结果必定为 True,因此返回 a;如果 a 是 False,则整个计算结果必定取决于 b,因此返回 b。所以Python解释器在做布尔运算时,只要能提前确定计算结果,它就不会往后算了,直接返回结果。
    Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素。list是数学意义上的有序集合,也就是说,list中的元素是按照顺序排列的。构造list非常简单,按照上面的代码,直接用 [ ] 把list的所有元素都括起来,就是一个list对象。通常,我们会把list赋值给一个变量,这样,就可以通过变量来引用
    list:classmates = ['Michael', 'Bob', 'Tracy']
    print classmates
    由于Python是动态语言,所以list中包含的元素并不要求都必须是同一种数据类型,我们完全可以在list中包含各种:
    L = ['Michael', 100, True]
    索引从 0 开始,也就是说,第一个元素的索引是0,第二个元素的索引是1,以此类推。我们可以用 -1 这个索引来表示最后一个元素,类似的,倒数第二用 -2 表示,倒数第三用 -3 表示,倒数第四用 -4 表示
    append()总是把新的元素添加到 list 的尾部。list的 insert()方法,它接受两个参数,第一个参数是索引号,第二个参数是待添加的新元素
    pop()方法总是删掉list的最后一个元素,并且它还返回这个元素,所以我们执行 L.pop() 后,会打印出这个元素。可以用 pop(2)把索引为2的元素删除
    替换: L = ['Adam', 'Lisa', 'Bart']   L[2] = 'Paul'

    tuple是另一种有序的列表,中文翻译为“ 元组 ”。tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修

    改了。创建tuple和创建list唯一不同之处是用( )替代了[ ]。获取 tuple 元素的方式和 list 是一模一样的
    t = (1)  print t结果为1,因为()既可以表示tuple,又可以作为括号表示运算时的优先级,结果 (1) 被Python解释

    器计算出结果 1,导致我们得到的不是tuple,而是整数 1。
    正是因为用()定义单元素的tuple有歧义,所以 Python 规定,单元素 tuple 要多加一个逗号“,”,这样就避免了歧义:t = (1,)   print t 结果为(1,)

    tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。

    即指向'a',就不能改成指向'b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
    注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块,上面的3,4行 print 语句就构成一个代码块(但不包括第5行的print)。如果 if 语句判断为 True,就会执行这个代码块。

    缩进请严格按照Python的习惯写法:4个空格,不要使用Tab,更不要混合Tab和空格,否则很容易造成因为缩进引起的语法错误。

    注意: if 语句后接表达式,然后用:表示代码块开始。

    如果你在Python交互环境下敲代码,还要特别留意缩进,并且退出缩进需要多敲一行回车 练习:
    score=55
    if score >= 60:
        score=bytes(score)
        print 'passed:'+score
    else:
        print 'nopass'
    age = 8
    if age >= 6:
        print 'teenager'
    elif age >= 18:
        print 'adult'
    else:
        print 'kid'
    Python的 for 循环就可以依次把list或tuple的每个元素迭代出来:L = ['Adam', 'Lisa', 'Bart']
    for name in L:
        print name
    注意:  name 这个变量是在 for 循环中定义的,意思是,依次取出list中的每一个元素,并把元素赋值给 name,然后执行for循环体,这样,遍历一个list或tuple就非常容易了
    花括号 {} 表示这是一个dict,然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。由于

    dict也是集合,len() 函数可以计算任意集合的大小:

    可以简单地使用 d[key] 的形式来查找对应的 value
    通过 key 访问 dict 的value,如果key不存在,会直接报错:KeyError。要避免 KeyError 发生,有两个办法:一是先判断一下 key 是否存在,用 in 操作符:

    if 'Paul' in d:
        print d['Paul']
    二是使用dict本身提供的一个 get 方法,在Key不存在的时候,返回None
    dict的第一个特点是查找速度快,无论dict有10个元素还是10万个元素,查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

    不过dict的查找速度快不是没有代价的,dict的缺点是占用内存大,还会浪费很多内容,list正好相反,占用内存小,但是查找速度慢。由于dict是按 key 查找,所以,在一个dict中,key不能重复。

    dict的第二个特点就是存储的key-value序对是没有顺序的!这和list不一样
    dict的第三个特点是作为 key 的元素必须不可变,Python的基本类型如字符串、整数、浮点数都是不可变的,都可以作为 key。但是list是可变的,就不能作为 key。
    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }要把新同学'Paul'的成绩 72 加进去,用赋值语句 d['Paul'] = 72如果 key 已经存在,则赋值会用新的 value 替

    换掉原来的 value
    练习:
    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }
    for key in d:
        print key
        print d[key]
        print d.get(key)
    set 持有一系列元素,这一点和 list 很像,但是set的元素没有重复,而且是无序的,这点和 dict 的 key很像。创建 set 的方式是调用 set() 并传入一个 list,list的元素将作为set的元素:s = set(['A', 'B', 'C'])添加重复元素,重复元素最后只存在一个
    由于set存储的是无序集合,所以我们没法通过索引来访问。

    访问 set中的某个元素实际上就是判断一个元素是否在set中。
    s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
    Bart是该班的同学吗?'Bart' in s输出True
    遍历:
    s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
    for name in s:
        print name
    输出('Lisa', 85)
    ('Adam', 95)
    ('Bart', 59)
    添加元素时,用set的add()方法,删除set中的元素时,用set的remove()方法,不存在会报错

    在Python中,定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用 return 语句返回。return None可以简写为return。
    在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple
    使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。
    Python自带的 int() 函数,其实就有两个参数,int()函数的第二个参数是转换进制,如果不传,默认是十进制 

    (base=10),如果传了,就用传入的参数。
    可变参数的名字前面有个 * 号,我们可以传入0个、1个或多个参数给可变参数

    在python2中有input和raw_input两个函数,其中raw_input将所有输入作为字符串看待,返回字符串类型。
    input函数支持表达式、数字类型、字符串类型,接受为表达式时,只返回其执行结果。
    在python3中对input和raw_input函数进行了整合,仅保留了input函数(认为raw_input函数是冗余的)。
    同时改变了input的用法——将所有的输入按照字符串进行处理,并返回一个字符串。
     sqrt()方法返回x的平方根(x>0)。
    语法
    以下是sqrt()方法的语法:
    import math

    math.sqrt( x )
     
    注意:此函数是无法直接访问的,所以我们需要导入math模块,然后需要用math的静态对象来调用这个函数。参数
    1.    x -- 这是一个数值表达式。返回值
    此方法返回x的平方根,对于x>0。例子下面的例子显示了sqrt()方法的使用。

    #!/usr/bin/python
    import math  # This will import math module
    print "math.sqrt(100) : ", math.sqrt(100)
    print "math.sqrt(7) : ", math.sqrt(7)
    print "math.sqrt(math.pi) : ", math.sqrt(math.pi)

    当我们运行上面的程序,它会产生以下结果:
    math.sqrt(100) : 10.0
    math.sqrt(7) : 2.64575131106
    math.sqrt(math.pi) : 1.77245385091
    map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上

    ,得到一个新的 list 并返回。注意:map()函数不改变原有的 list,而是返回一个新的 list。

    在使用Python编译的时候出现如下错误:
    SyntaxError: Non-ASCII character '\xe5' in file Test1.py on line 8, but no encoding declared; see 

    http://www.python.org/peps/pep-0263.html for details
    解决方法
    python的默认编码文件是用的ASCII码,将文件存成了UTF-8,编译就可以通过。或在在py文件开头(必须是第一行)加入
    [python] view plain copy
    #coding=utf-8  
    或者
    [python] view plain copy
    # -*- coding:utf-8 -*-  
    原因
    如果要在python2的py文件里面写中文,则必须要添加一行声明文件编码的注释,否则python2会默认使用ASCII编码。
    可以使用unicode函数
    print u'你好';
    print (unicode("请输入销售额", encoding="utf-8"))
    将utf-8编码转换为unicode就可以输出中文了。
    将ASCII字符转换为对应的数值即‘a’-->65,使用ord函数,ord('a')
    反正,使用chr函数,将数值转换为对应的ASCII字符,chr(65)

    reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似,一个函数 f,一个list,但行为和 map()不同,reduce()传入的函数 f 必须接收两个参数,reduce()对list的每个元素反复调用函数f,并返回最终结果值。reduce()还可以接收第3个可选参数,作为计算的初始值。
    例如,编写一个f函数,接收x和y,返回x和y的和:

    def f(x, y):
        return x + y
    调用 reduce(f, [1, 3, 5, 7, 9])时,reduce函数将做如下计算:

    先计算头两个元素:f(1, 3),结果为4;
    再把结果和第3个元素计算:f(4, 5),结果为9;
    再把结果和第4个元素计算:f(9, 7),结果为16;
    再把结果和第5个元素计算:f(16, 9),结果为25;
    由于没有更多的元素了,计算结束,返回结果25。
    filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter

    ()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。
    注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
    当rm为空时,默认删除空白符(包括'\n', '\r', '\t', ' ')
    Python内置的 sorted()函数可对list进行升序排序
    但 sorted()也是一个高阶函数,它可以接收一个比较函数来实现自定义排序,比较函数的定义是,传入两个待比较的元
    素 x, y,如果 x 应该排在 y 的前面,返回 -1,如果 x 应该排在 y 的后面,返回 1。如果 x 和 y 相等,返回 0。
    定义一个函数 f(),我们让它返回一个函数 g,可以这样写:

    def f():
        print 'call f()...'
        # 定义函数g:
        def g():
            print 'call g()...'
        # 返回函数g:
        return g
    调用函数 f,我们会得到 f 返回的一个函数:

    >>> x = f()   # 调用f()
    call f()...
    >>> x   # 变量x是f()返回的函数:
    <function g at 0x1037bf320>
    >>> x()   # x指向函数,因此可以调用
    call g()...   # 调用x()就是执行g()函数定义的代码
    内层函数引用了外层函数的变量(参数也算变量),然后返回内层函数的情况,称为闭包(Closure)。

    闭包的特点是返回的函数还引用了外层函数的局部变量,所以,要正确使用闭包,就要确保引用的局部变量在函数返回后不能变。举例如下:
    # 希望一次返回3个函数,分别计算1x1,2x2,3x3:
    def count():
        fs = []
        for i in range(1, 4):
            def f():
                 return i*i
            fs.append(f)
        return fs

    f1, f2, f3 = count()
    你可能认为调用f1(),f2()和f3()结果应该是1,4,9,但实际结果全部都是 9(请自己动手验证)。
    原因就是当count()函数返回了3个函数时,这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用,所以,此时他们并未计算 i*i,当 f1 被调用时:

    >>> f1()
    9     # 因为f1现在才计算i*i,但现在i的值已经变为3
    因此,返回函数不要引用任何循环变量,或者后续会发生变化的变量。
    def count():
        fs = []
        for i in range(1, 4):
            def f(j):
                def g():
                    return j*j
                return g
            r = f(i)
            fs.append(r)
        return fs
    f1, f2, f3 = count()
    print f1(), f2(), f3()
    输出1 4 9

    关键字lambda 表示匿名函数,冒号前面的 x 表示函数参数。
    匿名函数有个限制,就是只能有一个表达式,不写return,返回值就是该表达式的结果。
    Python的 decorator 本质上就是一个高阶函数,它接收一个函数作为参数,然后,返回一个新函数。
    使用 decorator 用Python提供的 @ 语法,这样可以避免手动编写 f = decorate(f) 这样的代码。要让 @log 自适应任何参数定义的函数,可以利用Python的 *args 和 **kw,保证任意个数的参数总是能正常调用。

    在定义 Person 类时,可以为Person类添加一个特殊的__init__()方法,当创建实例时,__init__()方法被自动调用,我们就能在此为每个实例都统一加上以下属性:

    class Person(object):
        def __init__(self, name, gender, birth):
            self.name = name
            self.gender = gender
            self.birth = birth

    __init__() 方法的第一个参数必须是 self(也可以用别的名字,但建议使用习惯用法),后续参数则可以自由指定,和定义函数没有任何区别。

    相应地,创建实例时,就必须要提供除 self 以外的参数:

    xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
    xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')
    只有以双下划线开头的"__job"不能直接被外部访问。
    但是,如果一个属性以"__xxx__"的形式定义,那它又可以被外部访问了,以"__xxx__"定义的属性在Python的类中被称
    为特殊属性,有很多预定义的特殊属性可以使用,通常我们不要把普通属性用"__xxx__"定义。
    以单下划线开头的属性"_xxx"虽然也可以被外部访问,但是,按照习惯,他们不应该被外部访问。
    在class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。
    要在class中定义类方法,需要这么写:
    class Person(object):
        count = 0
        @classmethod
        def how_many(cls):
            return cls.count
        def __init__(self, name):
            self.name = name
            Person.count = Person.count + 1
    print Person.how_many()
    p1 = Person('Bob')
    print Person.how_many()
    通过标记一个 @classmethod,该方法将绑定到 Person 类上,而非类的实例。类方法的第一个参数将传入类本身,通
    常将参数名命名为 cls,上面的 cls.count 实际上相当于 Person.count。
    因为是在类上调用,而非实例上调用,因此类方法无法获得任何实例变量,只能获得类的引用。
    如果已经定义了Person类,需要定义新的Student和Teacher类时,可以直接从Person类继承:
    class Person(object):
        def __init__(self, name, gender):
            self.name = name
            self.gender = gender
    定义Student类时,只需要把额外的属性加上,例如score:
    class Student(Person):
        def __init__(self, name, gender, score):
            super(Student, self).__init__(name, gender)
            self.score = score
    一定要用 super(Student, self).__init__(name, gender) 去初始化父类,否则,继承自 Person 的 Student 将没有 name 和 gender。
    函数super(Student, self)将返回当前类继承的父类,即 Person ,然后调用__init__()方法,注意self参数已在
    super()中传入,在__init__()中将隐式传递,不需要写出(也不能写)。
    当我们拿到变量 p、s、t 时,可以使用 isinstance 判断类型:
    >>> isinstance(p, Person)
    True    # p是Person类型
    >>> isinstance(p, Student)
    False   # p不是Student类型
    >>> isinstance(p, Teacher)
    False   # p不是Teacher类型
    对于实例变量,dir()返回所有实例属性,包括`__class__`这类有特殊意义的属性。注意到方法`whoAmI`也是 s 的一个属性。
    如何去掉`__xxx__`这类的特殊属性,只保留我们自己定义的属性?回顾一下filter()函数的用法。
    dir()返回的属性是字符串列表,如果已知一个属性名称,要获取或者设置对象的属性,就需要用 getattr() 和 setattr( )函数了:
    >>> getattr(s, 'name')  # 获取name属性
    'Bob'
    >>> setattr(s, 'name', 'Adam')  # 设置新的name属性
    >>> s.name
    'Adam'
    >>> getattr(s, 'age')  # 获取age属性,但是属性不存在,报错:
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'Student' object has no attribute 'age'
    >>> getattr(s, 'age', 20)  # 获取age属性,如果属性不存在,就返回默认值20:
    20
    如果要把一个类的实例变成 str,就需要实现特殊方法__str__(),Python 定义了__str__()和__repr__()两种方法,
    __str__()用于显示给用户,而__repr__()用于显示给开发人员。
    有一个偷懒的定义__repr__的方法:
    class Person(object):
        def __init__(self, name, gender):
            self.name = name
            self.gender = gender
        def __str__(self):
            return '(Person: %s, %s)' % (self.name, self.gender)
        __repr__ = __str__
    要让 len() 函数工作正常,类必须提供一个特殊方法__len__(),它返回元素的个数。例如,我们写一个 Students 类,把名字传进去:
    class Students(object):
        def __init__(self, *args):
            self.names = args
        def __len__(self):
            return len(self.names)
    对 int、str 等内置数据类型排序时,Python的 sorted() 按照默认的比较函数 cmp 排序,但是,如果对一组 
    Student 类的实例排序时,就必须提供我们自己的特殊方法 __cmp__():
    class Student(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
        def __str__(self):
            return '(%s: %s)' % (self.name, self.score)
        __repr__ = __str__
        def __cmp__(self, s):
            if self.name < s.name:
                return -1
            elif self.name > s.name:
                return 1
            else:
                return 0
    上述 Student 类实现了__cmp__()方法,__cmp__用实例自身self和传入的实例 s 进行比较,如果 self 应该排在前
    面,就返回 -1,如果 s 应该排在前面,就返回1,如果两者相当,返回 0。所有的函数都是可调用对象。
    一个类实例也可以变成一个可调用对象,只需要实现一个特殊方法__call__()。
    我们把 Person 类变成一个可调用对象:
    class Person(object):
        def __init__(self, name, gender):
            self.name = name
            self.gender = gender
        def __call__(self, friend):
            print 'My name is %s...' % self.name
            print 'My friend is %s...' % friend
    现在可以对 Person 实例直接调用:
    >>> p = Person('Bob', 'male')
    >>> p('Tim')
    My name is Bob...
    My friend is Tim...
    


    Python进阶(二十一)-Python学习进阶资料

      学习Python已经将近2周了,掌握了基本的语法,并学习了简单的爬虫操作,现将相关学习资料整理如下。大部分资料均取材于慕课网,感觉一路学下来受益匪浅。

    1.Python入门

    2.Python进阶

    3.Python装饰器

    4.Python-面向对象

    5.Python-走进Requests库

    6.Python操作MySQL数据库

    7.Python遇见数据采集

    8.Python开发简单爬虫

    9. 多线程爬虫

    10. Django初体检

    11.Django入门与实战

    12.Flask 开发基础与入门

    13.在 Flask 应用中使用 MySQL

    14.Flask 与 BootStrap 搭建网页

      当然,这其中也不乏收费的教学视频。不过,Maybe可以在别的地方找到该资源~(窃喜)

    15. Python分布式爬虫打造搜索引擎 Scrapy精讲

    16. 强力django+杀手级xadmin 打造上线标准的在线教育平台

      Demo


    Python进阶(一)-初识Python数据元素:列表&元组

    Python不像JS或者PHP这种弱类型语言里在字符串连接时会自动转换类型,而是直接报错。要解决这个方法只有提前把int转成string,然后再拼接字符串即可。

    如代码:

    1
    2
    3
    4
    5
    # coding=utf8
    str='你的分数是:'
    num=82
    text=str+num+'分 | 琼台博客'
    printtext

    执行结果

    python数字与字符串拼接

    直接报错:TypeError: cannot concatenate 'str' and 'int' objects

    解决这个方法只有提前把num转换为字符串类型,可以使用bytes函数把int型转换为string型。

    代码:

    1
    2
    3
    4
    5
    6
    # coding=utf8
    str='你的分数是:'
    num=82
    num=bytes(num)
    text=str+num+'分 | 琼台博客'
    printtext

    结果搞定:

    python字符串与数字拼接报错解决


      毕业论文已完成,下面就是等待盲审结果了。在此期间,已感觉论文无从看起。就学习一下Python吧,听说这是一门很神奇的语言。下面言归正传~ 
      在线文档查询:点击查看 
      IDE:IntelJ。 
      有关IntelJ的安装与注册详见博文《IntelliJ IDEA 2016注册方法和注册码》。 
      下面介绍一下Python中几种不熟悉的数据元素:列表、元组、字典、时间。

    1列表

    1.1初始化列表

    list=['physics', 'chemistry', 1997, 2000];
    • 1

    1.2访问列表中的值

    list[0]
    • 1

    1.3更新列表

    nums[0]="ljq";
    • 1

    1.4删除列表元素

    del nums[0];
    • 1

    1.5列表脚本操作符

      列表对+和的操作符与字符串相似。+号用于组合列表,号用于重复列表,例如:

    print len([1, 2, 3]); #3
    print [1, 2, 3] + [4, 5, 6]; #[1, 2, 3, 4, 5, 6]
    print ['Hi!'] * 4; #['Hi!', 'Hi!', 'Hi!', 'Hi!']
    print 3 in [1, 2, 3] #True
    for x in [1, 2, 3]: print x, #1 2 3
    • 1
    • 2
    • 3
    • 4
    • 5

    1.6列表截取

    L=['spam', 'Spam', 'SPAM!'];
    print L[2]; #'SPAM!'
    print L[-2]; #'Spam'
    print L[1:]; #['Spam', 'SPAM!']
    • 1
    • 2
    • 3
    • 4

    1.7列表函数&方法

    list.append(obj) #在列表末尾添加新的对象
    list.count(obj) #统计某个元素在列表中出现的次数
    list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    list.index(obj) #从列表中找出某个值第一个匹配项的索引位置,索引从0开始
    list.insert(index, obj) #将对象插入列表
    list.pop(obj=list[-1]) #移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    list.remove(obj) #移除列表中某个值的第一个匹配项
    list.reverse() #反向列表中元素,倒转
    list.sort([func]) #对原列表进行排序
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2元组(tuple)

      Python的元组与列表类似,不同之处在于元组的元素不能修改;元组使用小括号(),列表使用方括号[];元组创建很简单,只需要在括号中添加元素,并使用逗号(,)隔开即可,

    tup1 = ('physics', 'chemistry', 1997, 2000);
    • 1

     创建空元组,例如:

    tup = ();
    • 1

      元组中只有一个元素时,需要在元素后面添加逗号,例如:

    tup1 = (50,);
    • 1

      元组与字符串类似,下标索引从0开始,可以进行截取,组合等。

    2.1访问元组

    tup1 = ('physics', 'chemistry', 1997, 2000);
    tup1[0]#physics
    • 1
    • 2

    2.2修改元组

      元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,例如:

    tup1 = (12, 34.56);
    tup2 = ('abc', 'xyz');
    • 1
    • 2
     #以下修改元组元素操作是非法的。
     tup1[0] = 100;
     #创建一个新的元组
     tup3 = tup1 + tup2;
     print tup3; #(12, 34.56, 'abc', 'xyz')
    • 1
    • 2
    • 3
    • 4
    • 5

    2.3删除元组

      元组中的元素值是不允许删除的,可以使用del语句来删除整个元组,例如:

    tup = ('physics', 'chemistry', 1997, 2000);
    print tup;
    del tup;
    • 1
    • 2
    • 3

    2.4元组运算符

      与字符串一样,元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。 
    这里写图片描述

    2.5元组索引&截取

    L = ('spam', 'Spam', 'SPAM!');
    print L[2]; #'SPAM!'
    print L[-2]; #'Spam'
    print L[1:]; #['Spam', 'SPAM!']
    • 1
    • 2
    • 3
    • 4

    2.6元组内置函数

    cmp(tuple1, tuple2) 比较两个元组元素。
    len(tuple) 计算元组元素个数。
    max(tuple) 返回元组中元素最大值。
    min(tuple) 返回元组中元素最小值。
    

    tuple(seq) 将列表转换为元组。

    Python进阶(二)-初识Python数据元素:字典&时间

    3字典

    3.1字典简介

      字典(dic dictionary)是除列表之外python中最灵活的内置数据结构类型。 列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。 
      字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下:

    dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};
    • 1

      也可如此创建字典:

    dict1 = { 'abc': 456 };
    dict2 = { 'abc': 123, 98.6: 37 };
    • 1
    • 2

      每个键与值必须用冒号隔开(:),每对用逗号分割,整体放在花括号中({})。键必须独一无二,但值则不必;值可以取任何数据类型,但必须是不可变的,如字符串,数或元组。

    3.2访问字典里的值

    dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
    print "dict['name']: ", dict['name'];
    print "dict['age']: ", dict['age'];
    • 1
    • 2
    • 3

    3.3修改字典

      向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对。 
    如下实例:

    dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
    dict["age"]=27; #修改已有键的值
    dict["school"]="wutong"; #增加新的键/值对
    print "dict['age']: ", dict['age'];
    print "dict['school']: ", dict['school'];
    • 1
    • 2
    • 3
    • 4
    • 5

    3.4删除字典

    del dict['name']; # 删除键是'name'的条目
    dict.clear(); # 清空词典所有条目
    del dict ; # 删除词典
    • 1
    • 2
    • 3
    • 注意:字典不存在,del会引发一个异常

    3.5字典内置函数&方法

    cmp(dict1, dict2) #比较两个字典元素。
    len(dict) #计算字典元素个数,即键的总数。
    str(dict) #输出字典可打印的字符串表示。
    type(variable) #返回输入的变量类型,如果变量是字典就返回字典类型。
    clear() #删除字典内所有元素
    copy() #返回一个字典的浅复制
    fromkeys() #创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
    get(key, default=None) #返回指定键的值,如果值不在字典中返回default值
    has_key(key) #如果键在字典dict里返回true,否则返回false
    items() #以列表返回可遍历的(键, 值) 元组数组
    keys() #以列表返回一个字典所有的键
    setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
    update(dict2) #把字典dict2的键/值对更新到dict里
    values() #以列表返回字典中的所有值
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    4日期和时间

    4.1获取当前时间

    import time, datetime;
    localtime = time.localtime(time.time())
    print "Local current time :", localtime
    • 1
    • 2
    • 3

      说明:time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)属于struct_time元组,struct_time元组具有如下属性: 
    这里写图片描述

    4.2获取格式化的时间

      可以根据需求选取各种格式,但是最简单的获取可读的时间模式的函数是asctime():

    4.2.1日期转换为字符串

      首选:print time.strftime(‘%Y-%m-%d %H:%M:%S’); 
      其次:print datetime.datetime.strftime(datetime.datetime.now(), ‘%Y-%m-%d %H:%M:%S’) 
      最后:print str(datetime.datetime.now())[:19]

    4.2.2字符串转换为日期

    expire_time = "2013-05-21 09:50:35"
    d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
    print d;
    • 1
    • 2
    • 3

    4.2.3获取日期差

    oneday = datetime.timedelta(days=1)
    #今天,2014-03-21
    today = datetime.date.today()
    #昨天,2014-03-20
    yesterday = datetime.date.today() - oneday
    #明天,2014-03-22
    tomorrow = datetime.date.today() + oneday
    #获取今天零点的时间,2014-03-21 00:00:00
    today_zero_time=datetime.datetime.strftime(today, '%Y-%m-%d %H:%M:%S')
    #0:00:00.001000 
    print datetime.timedelta(milliseconds=1), #1毫秒
    #0:00:01 
    print datetime.timedelta(seconds=1), #1秒
    #0:01:00 
    print datetime.timedelta(minutes=1), #1分钟
    #1:00:00 
    print datetime.timedelta(hours=1), #1小时
    #1 day, 0:00:00 
    print datetime.timedelta(days=1), #1天
    #7 days, 0:00:00
    print datetime.timedelta(weeks=1)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    4.2.4获取时间差

    #1 day, 0:00:00
    oneday = datetime.timedelta(days=1)
    #今天,2014-03-21 16:07:23.943000
    today_time = datetime.datetime.now()
    #昨天,2014-03-20 16:07:23.943000
    yesterday_time = datetime.datetime.now() - oneday
    #明天,2014-03-22 16:07:23.943000
    tomorrow_time = datetime.datetime.now() + oneday
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

      注意时间是浮点数,带毫秒。 
      那么要获取当前时间,需要格式化一下:

    print datetime.datetime.strftime(today_time, '%Y-%m-%d %H:%M:%S')
    print datetime.datetime.strftime(yesterday_time, '%Y-%m-%d %H:%M:%S')
    print datetime.datetime.strftime(tomorrow_time, '%Y-%m-%d %H:%M:%S')
    • 1
    • 2
    • 3

    4.2.5获取上个月最后一天

    last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)
    • 1

    4.2.6字符串日期格式化为秒数

      返回浮点类型

    expire_time = "2013-05-21 09:50:35"
    d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
    time_sec_float = time.mktime(d.timetuple())
    print time_sec_float
    • 1
    • 2
    • 3
    • 4

    4.2.7日期格式化为秒数

      返回浮点类型

    d = datetime.date.today()
    time_sec_float = time.mktime(d.timetuple())
    print time_sec_float
    • 1
    • 2
    • 3

    4.2.8秒数转字符串

    time_sec = time.time()
    print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))


    Python进阶(三)-函数式编程之reduce()

      官方解释如下: 
      Apply function of two arguments cumulatively to the items of sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the sequence. If the optional initializer is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty. If initializer is not given and sequence contains only one item, the first item is returned. 
      格式: reduce (func, seq[, init()]) 
      reduce()函数即为化简函数,它的执行过程为:每一次迭代,都将上一次的迭代结果(注:第一次为init元素,如果没有指定init则为seq的第一个元素)与下一个元素一同传入二元func函数中去执行。在reduce()函数中,init是可选的,如果指定,则作为第一次迭代的第一个元素使用,如果没有指定,就取seq中的第一个元素。

    举例

      有一个序列集合,例如[1,1,2,3,2,3,3,5,6,7,7,6,5,5,5],统计这个集合所有键的重复个数,例如1出现了两次,2出现了两次等。大致的思路就是用字典存储,元素就是字典的key,出现的次数就是字典的value。方法依然很多 
    第一种:for循环判断

    def statistics(lst): 
      dic = {} 
      for k in lst: 
        if not k in dic: 
          dic[k] = 1
        else: 
          dic[k] +=1
      return dic
    lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
    print(statistics(lst)) 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    第二种:比较取巧的,先把列表用set方式去重,然后用列表的count方法

    def statistics2(lst): 
      m = set(lst) 
      dic = {} 
      for x in m: 
        dic[x] = lst.count(x) 
      return dic
    lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
    print statistics2(lst) 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    第三种:用reduce方式

    def statistics(dic,k):
      if not k in dic:
        dic[k] = 1
      else:
        dic[k] +=1
      return dic
    lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]
    print reduce(statistics,lst,{}) 
    #提供第三个参数,第一次,初始字典为空,作为statistics的第一个参数,然后遍历lst,作为第二个参数,然后将返回的字典集合作为下一次的第一个参数
    或者 
    d = {} 
    d.extend(lst) 
    print reduce(statistics,d) 
    #不提供第三个参数,但是要在保证集合的第一个元素是一个字典对象,作为statistics的第一个参数,遍历集合依次作为第二个参数 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

      通过上面的例子发现,凡是要对一个集合进行操作的,并且要有一个统计结果的,能够用循环或者递归方式解决的问题,一般情况下都可以用reduce方式实现。


    Python进阶(四)-浅谈Python闭包

      在函数内部定义的函数和外部定义的函数是一样的,只是他们无法被外部访问:

    def g():
        print 'g()...'
    def f():
        print 'f()...'
        return g
    • 1
    • 2
    • 3
    • 4
    • 5

      将 g 的定义移入函数 f 内部,防止其他代码调用 g:

    def f():
        print 'f()...'
        def g():
            print 'g()...'
        return g
    • 1
    • 2
    • 3
    • 4
    • 5

      但是,考察定义的 calc_sum 函数:

    def calc_sum(lst):
        def lazy_sum():
            return sum(lst)
        return lazy_sum
    • 1
    • 2
    • 3
    • 4

      注意: 发现没法把 lazy_sum 移到 calc_sum 的外部,因为它引用了 calc_sum 的参数 lst。

    • 像这种内层函数引用了外层函数的变量(参数也算变量),然后返回内层函数的情况,称为闭包(Closure)。

      闭包的特点是返回的函数还引用了外层函数的局部变量,所以,要正确使用闭包,就要确保引用的局部变量在函数返回后不能变。举例如下:

    # 希望一次返回3个函数,分别计算1x1,2x2,3x3:
    def count():
        fs = [ ]
        for i in range(1, 4):
            def f():
                 return i*i
            fs.append(f)
        return fs
    f1, f2, f3 = count()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

      你可能认为调用f1(),f2()和f3()结果应该是1,4,9,但实际结果全部都是 9(请自己动手验证)。 
      原因就是当count()函数返回了3个函数时,这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用,所以,此时他们并未计算 i*i,当 f1 被调用时:

    >>> f1()
    9     # 因为f1现在才计算i*i,但现在i的值已经变为3
    • 1
    • 2

      因此,返回函数不要引用任何循环变量,或者后续会发生变化的变量。

    举例

      返回闭包不能引用循环变量,请改写count()函数,让它正确返回能计算1x1、2x2、3x3的函数。 
      考察下面的函数 f:

    def f(j):
        def g():
            return j*j
        return g
    • 1
    • 2
    • 3
    • 4

      它可以正确地返回一个闭包g,g所引用的变量j不是循环变量,因此将正常执行。 
      在count函数的循环内部,如果借助f函数,就可以避免引用循环变量i。 
      参考代码:

    def count():
        fs = []
        for i in range(1, 4):
            def f(j):
                def g():
                    return j*j
                return g
            r = f(i)
            fs.append(r)
        return fs
    f1, f2, f3 = count()
    print f1(), f2(), f3()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    程序实例

    这里写图片描述



    Python进阶(五)-浅谈python匿名函数

      高阶函数可以接收函数做参数,有些时候,我们不需要显式地定义函数,直接传入匿名函数更方便。 
      在Python中,对匿名函数提供了有限支持。还是以map()函数为例,计算 f(x)=x2 时,除了定义一个f(x)的函数外,还可以直接传入匿名函数:

    >>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
    [1, 4, 9, 16, 25, 36, 49, 64, 81]
    • 1
    • 2

      通过对比可以看出,匿名函数 lambda x: x * x 实际上就是:

    def f(x):
        return x * x
    • 1
    • 2
    • 关键字lambda 表示匿名函数,冒号前面的 x 表示函数参数。

      匿名函数有个限制,就是只能有一个表达式,不写return,返回值就是该表达式的结果。 
      使用匿名函数,可以不必定义函数名,直接创建一个函数对象,很多时候可以简化代码:

    >>> sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y))
    [9, 5, 3, 1, 0]
    • 1
    • 2

      返回函数的时候,也可以返回匿名函数:

    >>> myabs = lambda x: -x if x < 0 else x 
    >>> myabs(-1)
    1
    >>> myabs(1)
    1
    • 1
    • 2
    • 3
    • 4
    • 5

    举例

      利用匿名函数简化以下代码:

    def is_not_empty(s):
        return s and len(s.strip()) > 0
    filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])
    • 1
    • 2
    • 3

      定义匿名函数时,没有return关键字,且表达式的值就是函数返回值。 
    参考代码:

    print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

    Python进阶(六)-python编写无参数decorator

      Python的 decorator 本质上就是一个高阶函数,它接收一个函数作为参数,然后,返回一个新函数。 
      使用 decorator 用Python提供的 @ 语法,这样可以避免手动编写 f = decorate(f) 这样的代码。 
      考察一个@log的定义:

    def log(f):
        def fn(x):
            print 'call ' + f.__name__ + '()...'
            return f(x)
        return fn
    • 1
    • 2
    • 3
    • 4
    • 5

      对于阶乘函数,@log工作得很好:

    @log
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    print factorial(10)
    • 1
    • 2
    • 3
    • 4

      结果: 
      call factorial()… 
      3628800 
      但是,对于参数不是一个的函数,调用将报错:

    @log
    def add(x, y):
        return x + y
    print add(1, 2)
    • 1
    • 2
    • 3
    • 4

      结果: 
      Traceback (most recent call last): 
       File “test.py”, line 15, in 
       print add(1,2) 
      TypeError: fn() takes exactly 1 argument (2 given) 
      因为 add() 函数需要传入两个参数,但是 @log 写死了只含一个参数的返回函数。 
      要让 @log 自适应任何参数定义的函数,可以利用Python的 *args 和 **kw,保证任意个数的参数总是能正常调用:

    def log(f):
        def fn(*args, **kw):
            print 'call ' + f.__name__ + '()...'
            return f(*args, **kw)
        return fn
    • 1
    • 2
    • 3
    • 4
    • 5

      现在,对于任意函数,@log 都能正常工作。

    举例

      请编写一个@performance,它可以打印出函数调用的时间。 
      计算函数调用的时间可以记录调用前后的当前时间戳,然后计算两个时间戳的差。 
      参考代码:

    import time
    def performance(f):
        def fn(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            print 'call %s() in %fs' % (f.__name__, (t2 - t1))
            return r
        return fn
    
    @performance
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    print factorial(10)

    Python进阶(七)-浅谈python3和Python2的区别

      不管使用何种版本的Python语言,都需要遵循编程规范,不该有的缩进一定不能有。否则会出现莫名其妙的错误,如下图所示: 
    这里写图片描述
      在应用Python编程时,首先要明确所使用Python版本,因为版本2与3之间存在着很多细节性的差异。稍有不慎就会入坑~下面介绍一下具体应用中的细节性差异。 
      具体参照:https://docs.python.org/3/whatsnew/3.0.html

    print函数

      Python3中print为一个函数,必须用括号括起来;Python2中print为class)。Python 2 的 print 声明已经被 print() 函数取代了,这意味着我们必须包装我们想打印在小括号中的对象。

    举例

    在Python 2中:

    print 'Hello, World!'
    • 1

    在Python 3中:

    print( 'Hello, World!')
    • 1

    reduce()函数

      在Python 3里,reduce()函数已经被从全局名字空间里移除了,它现在被放置在fucntools模块里。使用时要先引入from functools import reduce

    try except

    try: 
    except Exception, e :

        try:
             except    Exception as e :
    • 1
    • 2

    打开文件

    原: file( ….. ) 
    或 open(…..) 
    改为: 
    只能用 open(…..)

    从键盘录入一个字符串

    原: raw_input( “提示信息” ) 
    改为: input( “提示信息” )

    整形除法自动转为float

    python2: 
    1/2 
    2/2 
    1//2 



    python3: 
    1/2 
    2/2 
    1//2 
    0.5 
    1.0 
    0

    新的字符串格式化方法format取代%5.

    xrange重命名为range.

    !=取代 < >

    long重命名为int.

    exec变成函数

    Py3.X源码文件默认使用utf-8编码,这就使得以下代码是合法的:

        >>> 中国 = 'china' 
        >>>print(中国) 
        china 
    • 1
    • 2
    • 3

    python3中替换python2中cmp函数

      Python 3.4.3 的版本中已经没有cmp函数,被operator模块代替,在交互模式下使用时,需要导入模块。在没有导入模块情况下,会出现下面的错误: 
    这里写图片描述 
      提示找不到cmp函数了,那么在python3中该如何使用这个函数呢? 
      所以要导入模块 
    这里写图片描述 
    看下面给的内置函数

    operator.lt(a, b)     #相当于 a<b 从第一个数字或字母(ASCII)比大小
    operator.le(a, b)     #相当于a<=b
    operator.eq(a, b)     #相当于a==b 字母完全一样,返回True
    operator.ne(a, b)     #相当于a!=b
    operator.ge(a, b)     #相当于 a>=b
    operator.gt(a, b)     #相当于a>b
    operator.__lt__(a, b)     
    operator.__le__(a, b)     
    operator.__eq__(a, b)     
    operator.__ne__(a, b)     
    operator.__ge__(a, b)     
    operator.__gt__(a, b)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

      这几个函数就是用来替换之前的cmp,函数的返回值是布尔值。

    除法

    • 在python3.0中,/ 现在总是执行真除法,不管操作数的类型,都会返回包含任何余数的一个浮点结果。// 执行Floor除法,它截除掉余数并且针对整数操作数返回一个整数,如果有任何一个操作数是浮点数类型,则返回一个浮点数。
    • 在python2.6中,/ 表示传统除法,如果两个操作数都是整数的话,执行截断的整数除法(好像是Floor除法????);否则,执行浮点除法(保留余数,好像是真除法?)。//执行Floor除法,并且像在python3.0中一样工作,对于整数执行截断除法,对于浮点数执行浮点除法。

    Python进阶(八)-编写带参数decorator

      继续考察@log 装饰器:

    def log(f):
        def fn(x):
            print 'call ' + f.__name__ + '()...'
            return f(x)
        return fn
    • 1
    • 2
    • 3
    • 4
    • 5

      发现对于被装饰的函数,log打印的语句是不能变的(除了函数名)。 
      如果有的函数非常重要,希望打印出’[INFO] call xxx()…’,有的函数不太重要,希望打印出’[DEBUG] call xxx()…’,这时,log函数本身就需要传入’INFO’或’DEBUG’这样的参数,类似这样:

    @log('DEBUG')
    def my_func():
        pass
    • 1
    • 2
    • 3

      把上面的定义翻译成高阶函数的调用,就是:

    my_func = log('DEBUG')(my_func)
    • 1

      上面的语句看上去还是比较绕,再展开一下:

    log_decorator = log('DEBUG')
    my_func = log_decorator(my_func)
    • 1
    • 2

      上面的语句又相当于:

    log_decorator = log('DEBUG')
    @log_decorator
    def my_func():
        pass
    • 1
    • 2
    • 3
    • 4

      所以,带参数的log函数首先返回一个decorator函数,再让这个decorator函数接收my_func并返回新函数:

    def log(prefix):
        def log_decorator(f):
            def wrapper(*args, **kw):
                print '[%s] %s()...' % (prefix, f.__name__)
                return f(*args, **kw)
            return wrapper
        return log_decorator
    
    @log('DEBUG')
    def test():
        pass
    print test()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    执行结果: 
    [DEBUG] test()… 
    None 
      对于这种3层嵌套的decorator定义,你可以先把它拆开:

    # 标准decorator:
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator
    
    # 返回decorator:
    def log(prefix):
        return log_decorator(f)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

      拆开以后会发现,调用会失败,因为在3层嵌套的decorator定义中,最内层的wrapper引用了最外层的参数prefix,所以,把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

    举例

      在@performance实现打印秒的同时,请给 @performace 增加一个参数,允许传入’s’或’ms’:

    @performance('ms')
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    • 1
    • 2
    • 3

      要实现带参数的@performance,就需要实现:

    my_func = performance('ms')(my_func)
    • 1

    需要3层嵌套的decorator来实现。 
    参考代码:

    import time
    def performance(unit):
        def perf_decorator(f):
            def wrapper(*args, **kw):
                t1 = time.time()
                r = f(*args, **kw)
                t2 = time.time()
                t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
                print 'call %s() in %f %s' % (f.__name__, t, unit)
                return r
            return wrapper
        return perf_decorator
    
    @performance('ms')
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    print factorial(10)

    Python进阶(九)-Python陷阱:Nonetype

      今天解决一位网友的问题,内容如下: 
      请教代码问题

    def calc_prod(lst):
        def ff():
            print map(lambda x:x*x,lst)
        return ff
    
    f = calc_prod([1, 2, 3, 4])
    print f()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    结果: 
    [1, 4, 9, 16] 
    None 
      这样写输出为什么有None 
      针对这一问题,自己在IDEA中进行了调试,发现果然多输出了一行None。出现这一现象确实很令人费解。 
    自己写了简单的测试语句,如下:

    b = print(5)
    print(b)
    • 1
    • 2

    通过断点调试,内容如下: 
    这里写图片描述 
      发现b的值确实为None,且其类型为NoneType。

    那么什么是Nonetype?

      要理解这个,首先要理解Python对象,python对象具有三个特性:身份、类型、值。 
      这三个特性在对象创建时被赋值。只有值可以改变,其他只读。类型本身也是对象。 
      Null与None是Python的特殊类型,Null对象或者是None Type,它只有一个值None. 
      它不支持任何运算也没有任何内建方法. None和任何其他的数据类型比较永远返回False。 
      None有自己的数据类型NoneType。你可以将None复制给任何变量,但是你不能创建其他NoneType对象。 
      一句话总结:Null对象是python对象,又叫做NoneType,None是这个对象的值。 
      看过了NoneType的解释,之所以出现None就很好理解了。 
      NoneType之所以出现是因为定义了一个变量或函数,却没有值或者返回值,因此会默认值为None。 
      而在上面的程序中,虽然高阶函数calc_prod()有返回值ff,但是ff()却没有返回值,则传递到外层函数calc_prod()同样没有返回值,故输出了None。 若代码改为如下所示,则可以完美实现列表的输出。

    def calc_prod(lst):
        def ff():
            return map(lambda x:x*x,lst)
        return ff
    
        f = calc_prod([1, 2, 3, 4])
        print(f())

    Python进阶(十)-Python 编程规范

      在学习一门新的编程语言时,掌握其良好的编程规范可避免一些细节性错误的发生。去除一些不必要的学习障碍。

    分号

      不要在行尾加分号, 也不要用分号将两条命令放在同一行. 
    行长度 
      每行不超过80个字符 
    例外:

    • 1.长的导入模块语句
    • 2.注释里的URL

      不要使用反斜杠连接行. 
      Python会将圆括号, 中括号和花括号中的行隐式连接起来 , 你可以利用这个特点. 如果需要, 你可以在表达式外围增加一对额外的圆括号.

    foo_bar(self, width, height, color='black', design=None, x='foo',emphasis=None, highlight=0)
         if (width == 0 and height == 0 and
             color == 'red' and emphasis == 'strong'):
    • 1
    • 2
    • 3

      如果一个文本字符串在一行放不下, 可以使用圆括号来实现隐式行连接:

    x = ('This will build a very long long '
         'long long long long long long string')
    • 1
    • 2

      在注释中,如果必要,将长的URL放在一行上。 
    Yes:

    # See details at
    # http://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html
    • 1
    • 2

    No:

    # See details at
    # http://www.example.com/us/developer/documentation/api/content/\
    # v2.0/csv_file_name_extension_full_specification.html
    • 1
    • 2
    • 3

    注意上面例子中的元素缩进; 你可以在本文的缩进部分找到解释.

    括号

      宁缺毋滥的使用括号 
      除非是用于实现行连接, 否则不要在返回语句或条件语句中使用括号. 不过在元组两边使用括号是可以的. 
    Yes:

     if foo:
             bar()
         while x:
             x = bar()
         if x and y:
             bar()
         if not x:
             bar()
         return foo
         for (x, y) in dict.items(): ...
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    No:

     if (x):
             bar()
         if not(x):
             bar()
         return (foo)
    • 1
    • 2
    • 3
    • 4
    • 5

    缩进

      用4个空格来缩进代码 
      绝对不要用tab, 也不要tab和空格混用. 对于行连接的情况, 你应该要么垂直对齐换行的元素(见行长度部分的示例), 或者使用4空格的悬挂式缩进(这时第一行不应该有参数): 
    Yes:

           # Aligned with opening delimiter
           foo = long_function_name(var_one, var_two,
                                    var_three, var_four)
    
           # Aligned with opening delimiter in a dictionary
           foo = {
               long_dictionary_key: value1 +
                                    value2,
               ...
           }
    
           # 4-space hanging indent; nothing on first line
           foo = long_function_name(
               var_one, var_two, var_three,
               var_four)
    
           # 4-space hanging indent in a dictionary
           foo = {
               long_dictionary_key:
                   long_dictionary_value,
               ...
           }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    No:

          # Stuff on first line forbidden
          foo = long_function_name(var_one, var_two,
              var_three, var_four)
    
          # 2-space hanging indent forbidden
          foo = long_function_name(
            var_one, var_two, var_three,
            var_four)
    
          # No hanging indent in a dictionary
          foo = {
              long_dictionary_key:
                  long_dictionary_value,
                  ...
          }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    空行

      顶级定义之间空两行, 方法定义之间空一行 
      顶级定义之间空两行, 比如函数或者类定义. 方法定义, 类定义与第一个方法之间, 都应该空一行. 函数或方法中, 某些地方要是你觉得合适, 就空一行.

    空格

      按照标准的排版规范来使用标点两边的空格。 
      括号内不要有空格. 
    Yes:

    spam(ham[1], {eggs: 2}, [])
    • 1

    No:

    spam( ham[ 1 ], { eggs: 2 }, [ ] )
    • 1

      不要在逗号, 分号, 冒号前面加空格, 但应该在它们后面加(除了在行尾). 
    Yes:

    if x == 4:
             print x, y
         x, y = y, x
         ```
    No:  
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    if x == 4 : 
    print x , y 
    x , y = y , x

    参数列表, 索引或切片的左括号前不应加空格.
    Yes: spam(1)
    no: spam (1)
    Yes: dict['key'] = list[index]
    No:  dict ['key'] = list [index]
    在二元操作符两边都加上一个空格, 比如赋值(=), 比较(==, <, >, !=, <>, <=, >=, in, not in, is, is not), 布尔(and, or, not). 至于算术操作符两边的空格该如何使用, 需要你自己好好判断. 不过两侧务必要保持一致.
    Yes: x == 1
    No:  x<1
    当’=’用于指示关键字参数或默认参数值时, 不要在其两侧使用空格.
    Yes: def complex(real, imag=0.0): return magic(r=real, i=imag)
    No:  def complex(real, imag = 0.0): return magic(r = real, i = imag)
    不要用空格来垂直对齐多行间的标记, 因为这会成为维护的负担(适用于:, #, =等):
    Yes:
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
     foo = 1000  # comment
     long_name = 2  # comment that should not be aligned
     dictionary = {
         "foo": 1,
         "long_name": 2,
         }
    
    
    No:
    
    • 1
    • 2
    • 3
     foo        = 1000  # comment
     long_name  = 2     # comment that should not be aligned
     dictionary = {
         "foo"      : 1,
         "long_name": 2,
         }
    

    Shebang

      大部分.py文件不必以#!作为文件的开始. 根据 PEP-394 , 程序的main文件应该以 #!/usr/bin/python2或者 #!/usr/bin/python3开始. 
      (译者注: 在计算机科学中, Shebang (也称为Hashbang)是一个由井号和叹号构成的字符串行(#!), 其出现在文本文件的第一行的前两个字符. 在文件中存在Shebang的情况下, 类Unix操作系统的程序载入器会分析Shebang后的内容, 将这些内容作为解释器指令, 并调用该指令, 并将载有Shebang的文件路径作为该解释器的参数. 例如, 以指令#!/bin/sh开头的文件在执行时会实际调用/bin/sh程序.) 
      #!先用于帮助内核找到Python解释器, 但是在导入模块时, 将会被忽略. 因此只有被直接执行的文件中才有必要加入#!.

    注释

      确保对模块, 函数, 方法和行内注释使用正确的风格

    文档字符串

      Python有一种独一无二的的注释方式: 使用文档字符串. 文档字符串是包, 模块, 类或函数里的第一个语句. 这些字符串可以通过对象的doc成员被自动提取, 并且被pydoc所用. (你可以在你的模块上运行pydoc试一把, 看看它长什么样). 我们对文档字符串的惯例是使用三重双引号”“”( PEP-257 ). 一个文档字符串应该这样组织: 首先是一行以句号, 问号或惊叹号结尾的概述(或者该文档字符串单纯只有一行). 接着是一个空行. 接着是文档字符串剩下的部分, 它应该与文档字符串的第一行的第一个引号对齐. 下面有更多文档字符串的格式化规范.

    模块

      每个文件应该包含一个许可样板. 根据项目使用的许可(例如, Apache 2.0, BSD, LGPL, GPL), 选择合适的样板. 
    函数和方法 
    下文所指的函数,包括函数, 方法, 以及生成器. 
    一个函数必须要有文档字符串, 除非它满足以下条件: 
    外部不可见 
    非常短小 
    简单明了 
      文档字符串应该包含函数做什么, 以及输入和输出的详细描述. 通常, 不应该描述”怎么做”, 除非是一些复杂的算法. 文档字符串应该提供足够的信息, 当别人编写代码调用该函数时, 他不需要看一行代码, 只要看文档字符串就可以了. 对于复杂的代码, 在代码旁边加注释会比使用文档字符串更有意义. 
      关于函数的几个方面应该在特定的小节中进行描述记录, 这几个方面如下文所述. 每节应该以一个标题行开始. 标题行以冒号结尾. 除标题行外, 节的其他内容应被缩进2个空格. 
    Args: 
      列出每个参数的名字, 并在名字后使用一个冒号和一个空格, 分隔对该参数的描述.如果描述太长超过了单行80字符,使用2或者4个空格的悬挂缩进(与文件其他部分保持一致). 描述应该包括所需的类型和含义. 如果一个函数接受*foo(可变长度参数列表)或者**bar (任意关键字参数), 应该详细列出*foo和**bar. 
    Returns: (或者 Yields: 用于生成器) 
      描述返回值的类型和语义. 如果函数返回None, 这一部分可以省略. 
    Raises: 
    列出与接口有关的所有异常.

    def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
        """Fetches rows from a Bigtable.
    
        Retrieves rows pertaining to the given keys from the Table instance
        represented by big_table.  Silly things may happen if
        other_silly_variable is not None.
    
        Args:
            big_table: An open Bigtable Table instance.
            keys: A sequence of strings representing the key of each table row
                to fetch.
            other_silly_variable: Another optional variable, that has a much
                longer name than the other args, and which does nothing.
    
        Returns:
            A dict mapping keys to the corresponding table row data
            fetched. Each row is represented as a tuple of strings. For
            example:
    
            {'Serak': ('Rigel VII', 'Preparer'),
             'Zim': ('Irk', 'Invader'),
             'Lrrr': ('Omicron Persei 8', 'Emperor')}
    
            If a key from the keys argument is missing from the dictionary,
            then that row was not found in the table.
    
        Raises:
            IOError: An error occurred accessing the bigtable.Table object.
        """
        pass
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

      类应该在其定义下有一个用于描述该类的文档字符串. 如果你的类有公共属性(Attributes), 那么文档中应该有一个属性(Attributes)段. 并且应该遵守和函数参数相同的格式.

    class SampleClass(object):
        """Summary of class here.
    
        Longer class information....
        Longer class information....
    
        Attributes:
            likes_spam: A boolean indicating if we like SPAM or not.
            eggs: An integer count of the eggs we have laid.
        """
    
        def __init__(self, likes_spam=False):
            """Inits SampleClass with blah."""
            self.likes_spam = likes_spam
            self.eggs = 0
    
        def public_method(self):
            """Performs operation blah."""
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    块注释和行注释

      最需要写注释的是代码中那些技巧性的部分. 如果你在下次代码审查的时候必须解释一下, 那么你应该现在就给它写注释. 对于复杂的操作, 应该在其操作开始前写上若干行注释. 对于不是一目了然的代码, 应在其行尾添加注释.

    ‘# We use a weighted dictionary search to find out where i is in 
    ‘# the array. We extrapolate position based on the largest num 
    ‘# in the array and the array size and then do binary search to 
    ‘# get the exact number.’

    if i & (i-1) == 0: # true iff i is a power of 2

      为了提高可读性, 注释应该至少离开代码2个空格. 
      另一方面, 绝不要描述代码. 假设阅读代码的人比你更懂Python, 他只是不知道你的代码要做什么.

    ‘# BAD COMMENT: Now go through the b array and make sure whenever i occurs 
    ‘# the next element is i+1

      如果一个类不继承自其它类, 就显式的从object继承. 嵌套类也一样. 
    Yes: class SampleClass(object): 
    pass 
    class OuterClass(object): 
    class InnerClass(object): 
    pass 
    class ChildClass(ParentClass): 
    “”“Explicitly inherits from another class already.”“” 
    No: class SampleClass: 
    pass 
    class OuterClass: 
    class InnerClass: 
    pass

      继承自 object 是为了使属性(properties)正常工作, 并且这样可以保护你的代码, 使其不受Python 3的一个特殊的潜在不兼容性影响. 这样做也定义了一些特殊的方法, 这些方法实现了对象的默认语义, 包括 newinitdelattrgetattributesetattrhashrepr, and str .

    字符串

      即使参数都是字符串, 使用%操作符或者格式化方法格式化字符串. 不过也不能一概而论, 你需要在+和%之间好好判定. 
    Yes: x = a + b 
    x = ‘%s, %s!’ % (imperative, expletive) 
    x = ‘{}, {}!’.format(imperative, expletive) 
    x = ‘name: %s; score: %d’ % (name, n) 
    x = ‘name: {}; score: {}’.format(name, n) 
    No: x = ‘%s%s’ % (a, b) # use + in this case 
    x = ‘{}{}’.format(a, b) # use + in this case 
    x = imperative + ‘, ’ + expletive + ‘!’ 
    x = ‘name: ’ + name + ‘; score: ’ + str(n) 
      避免在循环中用+和+=操作符来累加字符串. 由于字符串是不可变的, 这样做会创建不必要的临时对象, 并且导致二次方而不是线性的运行时间. 作为替代方案, 你可以将每个子串加入列表, 然后在循环结束后用 .join 连接列表. (也可以将每个子串写入一个 cStringIO.StringIO 缓存中.) 
    Yes: items = [‘

    ‘] 
    for last_name, first_name in employee_list: 
    items.append(‘’ % (last_name, first_name)) 
    items.append(‘
    %s, %s
    ‘) 
    employee_table = ”.join(items) 
    No: employee_table = ‘’ 
    for last_name, first_name in employee_list: 
    employee_table += ‘’ % (last_name, first_name) 
    employee_table += ‘
    %s, %s
    ’ 
      在同一个文件中, 保持使用字符串引号的一致性. 使用单引号’或者双引号”之一用以引用字符串, 并在同一文件中沿用. 在字符串内可以使用另外一种引号, 以避免在字符串中使用. GPyLint已经加入了这一检查.

    (译者注:GPyLint疑为笔误, 应为PyLint.) 
    Yes: 
    Python(‘Why are you hiding your eyes?’) 
    Gollum(“I’m scared of lint errors.”) 
    Narrator(‘“Good!” thought a happy Python reviewer.’) 
    No: 
    Python(“Why are you hiding your eyes?”) 
    Gollum(‘The lint. It burns. It burns us.’) 
    Gollum(“Always the great lint. Watching. Watching.”) 
      为多行字符串使用三重双引号”“”而非三重单引号’‘’. 当且仅当项目中使用单引号’来引用字符串时, 才可能会使用三重’‘’为非文档字符串的多行字符串来标识引用. 文档字符串必须使用三重双引号”“”. 不过要注意, 通常用隐式行连接更清晰, 因为多行字符串与程序其他部分的缩进方式不一致. 
    Yes: 
    print (“This is much nicer.\n” 
    “Do it this way.\n”) 
    No: 
    print “”“This is pretty ugly. 
    Don’t do this. 
    “”“

    文件和sockets

      在文件和sockets结束时, 显式的关闭它. 
      除文件外, sockets或其他类似文件的对象在没有必要的情况下打开, 会有许多副作用, 例如:

    • 1.它们可能会消耗有限的系统资源, 如文件描述符. 如果这些资源在使用后没有及时归还系统, 那么用于处理这些对象的代码会将资源消耗殆尽.
    • 2.持有文件将会阻止对于文件的其他诸如移动、删除之类的操作.
    3.仅仅是从逻辑上关闭文件和sockets, 那么它们仍然可能会被其共享的程序在无意中进行读或者写操作. 只有当它们真正被关闭后, 对于它们尝试进行读或者写操作将会抛出异常, 并使得问题快速显现出来.
    • 1

      而且, 幻想当文件对象析构时, 文件和sockets会自动关闭, 试图将文件对象的生命周期和文件的状态绑定在一起的想法, 都是不现实的. 因为有如下原因:

    • 1.没有任何方法可以确保运行环境会真正的执行文件的析构.不同的Python实现采用不同的内存管理技术, 比如延时垃圾处理机制. 延时垃圾处理机制可能会导致对象生命周期被任意无限制的延长.
    • 2.对于文件意外的引用,会导致对于文件的持有时间超出预期(比如对于异常的跟踪, 包含有全局变量等).

      推荐使用 “with”语句 以管理文件:

    with open("hello.txt") as hello_file:
        for line in hello_file:
            print line
    • 1
    • 2
    • 3

      对于不支持使用”with”语句的类似文件的对象,使用

    contextlib.closing():
    import contextlib
    with contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:
        for line in front_page:
            print line
    Legacy AppEngine 中Python 2.5的代码如使用”with”语句, 需要添加 “from __future__ import with_statement”.
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    TODO注释

      为临时代码使用TODO注释, 它是一种短期解决方案. 不算完美, 但够好了. 
      TODO注释应该在所有开头处包含”TODO”字符串, 紧跟着是用括号括起来的你的名字, email地址或其它标识符. 然后是一个可选的冒号. 接着必须有一行注释, 解释要做什么. 主要目的是为了有一个统一的TODO格式, 这样添加注释的人就可以搜索到(并可以按需提供更多细节). 写了TODO注释并不保证写的人会亲自解决问题. 当你写了一个TODO, 请注上你的名字.

    ‘# TODO(kl@gmail.com): Use a “*” here for string repetition. 
    ‘# TODO(Zeke) Change this to use relations. 
    “`

      如果你的TODO是”将来做某事”的形式, 那么请确保你包含了一个指定的日期(“2009年11月解决”)或者一个特定的事件(“等到所有的客户都可以处理XML请求就移除这些代码”).

    导入格式

      每个导入应该独占一行 
    Yes: import os 
    import sys 
    No: import os, sys 
      导入总应该放在文件顶部, 位于模块注释和文档字符串之后, 模块全局变量和常量之前. 导入应该按照从最通用到最不通用的顺序分组: 
    标准库导入 
    第三方库导入 
    应用程序指定导入 
    每种分组中, 应该根据每个模块的完整包路径按字典序排序, 忽略大小写. 
    import foo 
    from foo import bar 
    from foo.bar import baz 
    from foo.bar import Quux 
    from Foob import ar

    语句

    通常每个语句应该独占一行 
    不过, 如果测试结果与测试语句在一行放得下, 你也可以将它们放在同一行. 如果是if语句, 只有在没有else时才能这样做. 特别地, 绝不要对 try/except 这样做, 因为try和except不能放在同一行. 
    Yes: 
    if foo: bar(foo) 
    No: 
    if foo: bar(foo) 
    else: baz(foo) 
    try: bar(foo) 
    except ValueError: baz(foo) 
    try: 
    bar(foo) 
    except ValueError: baz(foo)

    访问控制

      在Python中, 对于琐碎又不太重要的访问函数, 你应该直接使用公有变量来取代它们, 这样可以避免额外的函数调用开销. 当添加更多功能时, 你可以用属性(property)来保持语法的一致性. 
      (译者注: 重视封装的面向对象程序员看到这个可能会很反感, 因为他们一直被教育: 所有成员变量都必须是私有的! 其实, 那真的是有点麻烦啊. 试着去接受Pythonic哲学吧) 
      另一方面, 如果访问更复杂, 或者变量的访问开销很显著, 那么你应该使用像 get_foo() 和 set_foo() 这样的函数调用. 如果之前的代码行为允许通过属性(property)访问 , 那么就不要将新的访问函数与属性绑定. 这样, 任何试图通过老方法访问变量的代码就没法运行, 使用者也就会意识到复杂性发生了变化.

    命名

    module_name, package_name, ClassName, method_name, ExceptionName, function_name, GLOBAL_VAR_NAME, instance_var_name, function_parameter_name, local_var_name. 
    应该避免的名称 
    单字符名称, 除了计数器和迭代器. 
    包/模块名中的连字符(-) 
    双下划线开头并结尾的名称(Python保留, 例如init)

    命名约定

      所谓”内部(Internal)”表示仅模块内可用, 或者, 在类内是保护或私有的. 
      用单下划线(_)开头表示模块变量或函数是protected的(使用import * from时不会包含). 
      用双下划线(__)开头的实例变量或方法表示类内私有. 
      将相关的类和顶级函数放在同一个模块里. 不像Java, 没必要限制一个类一个模块. 
      对类名使用大写字母开头的单词(如CapWords, 即Pascal风格), 但是模块名应该用小写加下划线的方式(如lower_with_under.py). 尽管已经有很多现存的模块使用类似于CapWords.py这样的命名, 但现在已经不鼓励这样做, 因为如果模块名碰巧和类名一致, 这会让人困扰.

    Python之父Guido推荐的规范

    Type Public Internal 
    Modules lower_with_under _lower_with_under 
    Packages lower_with_under 
    Classes CapWords _CapWords 
    Exceptions CapWords 
    Functions lower_with_under() _lower_with_under() 
    Global/Class Constants CAPS_WITH_UNDER _CAPS_WITH_UNDER 
    Global/Class Variables lower_with_under _lower_with_under 
    Instance Variables lower_with_under _lower_with_under (protected) or __lower_with_under (private) 
    Method Names lower_with_under() _lower_with_under() (protected) or __lower_with_under() (private) 
    Function/Method Parameters lower_with_under 
    Local Variables lower_with_under

    Main

      即使是一个打算被用作脚本的文件, 也应该是可导入的. 并且简单的导入不应该导致这个脚本的主功能(main functionality)被执行, 这是一种副作用. 主功能应该放在一个main()函数中. 
      在Python中, pydoc以及单元测试要求模块必须是可导入的. 你的代码应该在执行主程序前总是检查 if name == ‘main’ , 这样当模块被导入时主程序就不会被执行. 
    def main(): 

    if name == ‘main‘: 
    main() 
      所有的顶级代码在模块导入时都会被执行. 要小心不要去调用函数, 创建对象, 或者执行那些不应该在使用pydoc时执行的操作.



    Python进阶(十一)-定义实例方法

      一个实例的私有属性就是以__开头的属性,无法被外部访问。那这些属性定义有什么用? 
      虽然私有属性无法从外部访问,但是,从类的内部是可以访问的。除了可以定义实例的属性外,还可以定义实例的方法。 
      实例的方法就是在类中定义的函数,它的第一个参数永远是 self,指向调用该方法的实例本身,其他参数和一个普通函数是完全一样的。

    class Person(object):
        def __init__(self, name):
            self.__name = name
    
        def get_name(self):
            return self.__name
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

      get_name(self) 就是一个实例方法,它的第一个参数是self。init(self, name)其实也可看做是一个特殊的实例方法。 
    调用实例方法必须在实例上调用:

    p1 = Person('Bob')
    print p1.get_name()  # self不需要显式传入
    # => Bob
    • 1
    • 2
    • 3

      在实例方法内部,可以访问所有实例属性,这样,如果外部需要访问私有属性,可以通过方法调用获得,这种数据封装的形式除了能保护内部数据一致性外,还可以简化外部调用的难度。

    举例

      请给 Person 类增加一个私有属性 __score,表示分数,再增加一个实例方法 get_grade(),能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。 
    注意get_grade()是实例方法,第一个参数为self。

    参考代码:

    class Person(object):
    
        def __init__(self, name, score):
            self.__name = name
            self.__score = score
    
        def get_grade(self):
            if self.__score >= 80:
                return 'A'
            if self.__score >= 60:
                return 'B'
            return 'C'
    
    p1 = Person('Bob', 90)
    p2 = Person('Alice', 65)
    p3 = Person('Tim', 48)
    
    print p1.get_grade()
    print p2.get_grade()
    print p3.get_grade()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    运行结果 
    这里写图片描述



    Python进阶(十二)-浅谈python中的方法

      我们在 class 中定义的实例方法其实也是属性,它实际上是一个函数对象:

    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
        def get_grade(self):
            return 'A'
    
    p1 = Person('Bob', 90)
    print p1.get_grade
    # => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
    print p1.get_grade()
    # => A
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

      也就是说,p1.get_grade 返回的是一个函数对象,但这个函数是一个绑定到实例的函数,p1.get_grade() 才是方法调用。 
    因为方法也是一个属性,所以,它也可以动态地添加到实例上,只是需要用 types.MethodType() 把一个函数变为一个方法:

    import types
    def fn_get_grade(self):
        if self.score >= 80:
            return 'A'
        if self.score >= 60:
            return 'B'
        return 'C'
    
    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
    
    p1 = Person('Bob', 90)
    p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
    print p1.get_grade()
    # => A
    p2 = Person('Alice', 65)
    print p2.get_grade()
    # ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
    # 因为p2实例并没有绑定get_grade
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

      给一个实例动态添加方法并不常见,直接在class中定义要更直观。

    举例

      由于属性可以是普通的值对象,如 str,int 等,也可以是方法,还可以是函数,大家看看下面代码的运行结果,请想一想 p1.get_grade 为什么是函数而不是方法:

    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
            self.get_grade = lambda: 'A'
    
    p1 = Person('Bob', 90)
    print p1.get_grade
    print p1.get_grade()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

      直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同,函数调用不需要传入 self,但是方法调用需要传入 self。


    Python进阶(十三)-浅谈sorted 函数应用

      众所周知,def cmp 作为方法存在,用sort对实例进行排序时,会用到class 中的cmp。但是,在python3中,取消了 sorted对cmp的支持。 
      python3 中有关排序的sorted方法如下:

    sorted(iterable,key=None,reverse=False)
    • 1

      其中,key接受一个函数,这个函数只接受一个元素,默认为None。 
    reverse是一个布尔值。如果设置为True,列表元素将被倒序排列,默认为False。 
      下面着重介绍key的作用原理: 
      key指定一个接收一个参数的函数,这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None 。

    例1

    students = [('john', 'A', 15), ('jane', 'B', 12), ('dave','B', 10)]
    sorted(students,key=lambda s: x[2]) #按照年龄来排序
    • 1
    • 2

      结果:[(‘dave’,’B’, 10), (‘jane’, ‘B’, 12), (‘john’, ‘A’, 15)]

    例2

      这是一个字符串排序,排序规则:小写<大写<奇数<偶数 
    s = ‘asdf234GDSdsf23’ #排序:小写-大写-奇数-偶数

    print("".join(sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x))))
    • 1

      原理:先比较元组的第一个值,如果相等就比较元组的下一个值,以此类推。 
      先看一下Boolean value 的排序: 
      print(sorted([True,Flase]))===>结果[False,True] 
      Boolean 的排序会将 False 排在前,True排在后 .

    • 1.x.isdigit()的作用是把数字放在前边,字母放在后边.
    • 2.x.isdigit() and int(x) % 2 == 0的作用是保证奇数在前,偶数在后。
    • 3.x.isupper()的作用是在前面基础上,保证字母小写在前大写在后.
    • 4.最后的x表示在前面基础上,对所有类别数字或字母排序。

      最后结果:addffssDGS33224

    例3

    一道面试题:

    list1=[7, -8, 5, 4, 0, -2, -5]
    #要求1.正数在前负数在后 2.正数从小到大 3.负数从大到小
    sorted(list1,key=lambda x:(x<0,abs(x)))
    • 1
    • 2
    • 3

      解题思路:先按照正负排先后,再按照大小排先后。


    Python进阶(十四)- 基础课程结课总结:高阶函数

      在慕课网完成了廖雪峰老师的《Python入门》与《Python进阶》两门基础课程。在此做一下简单的知识点小结。

    函数式编程

      Python特点:

    • 不是纯函数式编程(允许变量存在);
    • 支持高阶函数(可以传入函数作为变量);
    • 支持闭包(可以返回函数);
    • 有限度的支持匿名函数;

      高阶函数:

    • 变量可以指向函数;
    • 函数的参数可以接收变量;
    • 一个函数可以接收另一个函数作为参数;
    def add(x,y,f):  
        return f(x)+f(y)  
    #14
    add(-5,9,abs)  
    • 1
    • 2
    • 3
    • 4

    内置高阶函数map()

      map函数有两个参数,一个是函数,另一个是列表,返回值为对传入的列表中每一个元素执行传入的函数操作之后得到的列表;

    def format_name(s):  
        return s.title()
    
    print map(format_name, ['adam', 'LISA', 'barT'])  
    • 1
    • 2
    • 3
    • 4

    内置高阶函数reduce()

      reduce函数也有两个参数,一个是函数,另一个是列表,返回值为对list的每一个元素反复调用函数f,得到最终结果,以下函数为连乘;

    def prod(x, y):  
        return x*y;  
    
    print reduce(prod, [2, 4, 5, 7, 12])  
    • 1
    • 2
    • 3
    • 4

    内置高阶函数filter()

      filter函数接受函数参数f和列表参数lst,f对lst元素进行判断,返回lst元素中调用f函数结果为true的元素组成的列表(将不满足f函数条件的元素过滤掉);

    import math  
    
    def is_sqr(x):  
        return int(math.sqrt(x))*int(math.sqrt(x))==x  
    
    print filter(is_sqr, range(1, 101))  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    自定义排序函数sorted()

      sorted函数接受一个列表lst和一个函数参数f,f为自定义的比较lst元素大小的函数,返回值为lst中元素按f函数排列的列表;

    def cmp_ignore_case(s1, s2):  
        return cmp(s1.lower(),s2.lower())  
    
    print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)
    • 1
    • 2
    • 3
    • 4

    返回函数:

    def calc_prod(lst):  
        def prod(x,y):  
            return x*y;  
        def g():
            return reduce(prod,lst)  
        return g; 
    
    f = calc_prod([1, 2, 3, 4])  
    print f()  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    闭包

      内层函数使用外层函数的参数,然后返回内层函数;

    def count():  
        fs = []  
        for i in range(1, 4):  
            def f(j):  
                def g():  
                  return j*j;  
                return g  
            fs.append(f(i))  
        return fs  
    
    f1, f2, f3 = count()  
    print f1(), f2(), f3()  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    匿名函数

      传入函数参数不需要显式定义函数,可以用lambda x:statement x为参数,statement为对参数执行的语句;

    def is_not_empty(s):  
        return s and len(s.strip()) > 0  
    
    print filter(lambda s:s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])  
    • 1
    • 2
    • 3
    • 4

    装饰器

      给函数添加新功能,并简化该函数调用;

    无参数装饰器

    def log(f): 
        def fn(*args, **kw): #*args,**kw保证对任意个数参数都能正常调用  
            print 'call ' + f.__name__ + '()...'  
            return f(*args, **kw)
        return fn
    
    @log   #调用日志装饰器  
    def factorial(n):  
        return reduce(lambda x,y: x*y, range(1, n+1))  
    #call factorial()...  
    #3628800  
    print factorial(10)  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    带参数装饰器

    def log(prefix):  
        def log_decorator(f):  
            def wrapper(*args, **kw):  
                print '[%s] %s()...' % (prefix, f.__name__)  
                return f(*args, **kw)  
            return wrapper  
        return log_decorator  
    
    @log('DEBUG') #DEBUG为给装饰器传入的参数  
    def test():  
        pass  
    #[DEBUG] test()...  
    #None  
    print test()  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

      利用functool.wraps作用在返回的新函数上,使得调用装饰器以后不改变原函数的信息

    import time, functools  
    def performance(unit):  
        def perf_decorator(f):  
            @functools.wraps(f)  
            def wrapper(*args, **kw):  
                t1 = time.time()  
                r = f(*args, **kw)  
                t2 = time.time()  
                t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)  
                print 'call %s() in %f %s' % (f.__name__, t, unit)  
                return r  
            return wrapper  
        return perf_decorator  
    
    @performance('ms')  
    def factorial(n):  
        return reduce(lambda x,y: x*y, range(1, n+1))  
    print factorial.__name__  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    偏函数

      functools.partial(f,f的默认参数) 减少需要提供给f的参数

    import functools  
    int2 = functools.partial(int, base=2)  
    int2('1000000')  #64


    Python进阶(十五)-file文件操作

      Python下文件操作与Java差不多。打开文件的模式有三种:

    • r,只读模式(默认)。
    • w,只写模式。【不可读;不存在则创建;存在则删除内容;因为会清空原有文件的内容,一定要慎用】
    • a,追加模式。【可读; 不存在则创建;存在则只追加内容;】

      注意最后要记得关闭文件:f.close() 
      python只能将字符串写入到文本文件。要将数值数据存储到文本本件中,必须先试用函数str()将其转换为字符串格式。

    #r模式(只读模式)
    f = open('yesterday',encoding='utf-8')
    data = f.read()
    f.close()
    print(data)
    #只读文件的前5行:
    f = open('yesterday','r',encoding='utf-8')
    for i in range(5):
        print(f.readline())
    #以列表的方式读取这个文件
    f = open('yesterday','r',encoding='utf-8')
    for line in f.readlines():
        print(line)
    #对文件的第3行,做一个特殊的打印(这种方式比较低效,因为它会先把文件全部读取到内存中,文件较大时会很影响性能)
    f = open('yesterday','r',encoding='utf-8')
    for index,line in enumerate(f.readlines()):
        if index == 2:
            print('-----测试线----',line)
            continue
        print(line)
    #比较高效的,逐行读取文件内容,因为它是一行一行的去读取文件,不会先把文件一次性全部读取到内存中
    f = open('yesterday','r',encoding='utf-8')
    for line in f:
        print(line)
    #比较高效的,对文件的3三行进行过特殊打印
    f = open('yesterday','r',encoding='utf-8')
    count = 0
    for line in f:
        if count == 2:
            print('------测试线----:',line)
        count += 1
        print(line)
    
    #w模式(如果没有就创建文件,如果有就清空文件,一定要慎用)
    f = open('yesterday','w',encoding='utf-8')
    f.write("这就是一行测试\n")
    f.write("测试2\n")
    f.write("测试3")
    
    #a模式(追加模式,如果没有就创建文件,如果有就把内容追加进去)
    f = open('yesterday','a',encoding='utf-8')
    f.write("test1\n")
    
    #文件光标的操作
    f = open('yesterday','r',encoding='utf-8')
    #获得文件的光标
    print(f.tell())
    print(f.readline())
    print(f.tell())
    #回到最开始的位置(也可以指定一个位置,前提是你得知道你去往的字符具体在哪个位置才行)
    f.seek(0)
    
    #显示文件的编码
    print(f.encoding)
    #显示文件句柄的编号(我并不确定这个说法是否正确,用到时请仔细去查一下)
    print(f.fileno())
    #测试是否是一个终端设备文件
    print(f.isatty())
    #把缓存的内容刷新到硬盘(进度条那个脚本里有写一个示例)
    f.flush()
    #指定文件从哪里开始截断,如果没有参数,默认从0开始等于清空了这个文件
    #f.truncate()
    
    #r+ 模式(读,追加模式)
    f = open('yesterday','r+',encoding='utf-8')
    data = f.read()
    print(data)
    f.write("test...\n")
    
    #还有 w+写读模式, a+追加读模式,这一般不用,真用到了再去了解下吧
    #rb 模式,以二进制的方式读取这个文件
    #wb 模式,二进制写
    '''
    
    '''
    #with语句(很实用,记得要经常用哟~,在《Python编程从入门到实战》那本书里的文件与异常那一章有详细用法)
    #为了避免打开文件后忘记关闭,可以通过管理上下文,即:
    with open('log','r') as f:
    
        ...
    #如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。
    #在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:
    with open('log1') as obj1, open('log2') as obj2:
        pass
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84

    参考资料

      http://www.yiibai.com/python3/file_methods.html


    Python进阶(十六)-正则表达式

      正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。 
      Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。 
      在python中使用正则表达式,需要引入re模块;下面介绍下该模块中的一些方法;

    compile和match

      re模块中compile用于生成pattern的对象,再通过调用pattern实例的match方法处理文本最终获得match实例;通过使用match获得信息;

    import re
    
    # 将正则表达式编译成Pattern对象
    pattern = re.compile(r'rlovep')
    # 使用Pattern匹配文本,获得匹配结果,无法匹配时将返回None
    m = pattern.match('rlovep.com')
    if m:
    # 使用Match获得分组信息
        print(m.group())
    ### 输出 ###
    # rlovep
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

      re.compile(strPattern[, flag]): 
      这个方法是Pattern类的工厂方法,用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag是匹配模式,取值可以使用按位或运算符’|’表示同时生效,比如re.I | re.M。另外,你也可以在regex字符串中指定模式,比如re.compile(‘pattern’, re.I | re.M)与re.compile(‘(?im)pattern’)是等价的。 
      可选值有:

    • re.I(re.IGNORECASE): 忽略大小写(括号内是完整写法,下同)
    • M(MULTILINE): 多行模式,改变’^’和’$’的行为
    • S(DOTALL): 点任意匹配模式,改变’.’的行为
    • L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
    • U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
    • X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。

    Match

      Match对象是一次匹配的结果,包含了很多关于此次匹配的信息,可以使用Match提供的可读属性或方法来获取这些信息。 
      属性:

    • string: 匹配时使用的文本。
    • re: 匹配时使用的Pattern对象。
    • pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
    • endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
    • lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组,将为None。
    • lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组,将为None。

    方法:

    group([group1, …])

      获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名;编号0代表整个匹配的子串;不填写参数时,返回group(0);没有截获字符串的组返回None;截获了多次的组返回最后一次截获的子串。

    groups([default]):

      以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代,默认为None。

    groupdict([default])

    返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内。default含义同上。

    start([group])

      返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引)。group默认值为0。

    end([group])

      返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1)。group默认值为0。

    span([group])

      返回(start(group), end(group))。

    expand(template)

      将匹配到的分组代入template中然后返回。template中可以使用\id或\g、 \g引用分组,但不能使用编号0。\id与\g是等价的;但\10将被认为是第10个分组,如果你想表达 \1之后是字符’0’,只能使用\g<1>0。

    pattern

      Pattern对象是一个编译好的正则表达式,通过Pattern提供的一系列方法可以对文本进行匹配查找。 
      Pattern不能直接实例化,必须使用re.compile()进行构造。 
      Pattern提供了几个可读属性用于获取表达式的相关信息:

    • pattern: 编译时用的表达式字符串。
    • flags: 编译时用的匹配模式。数字形式。
    • groups: 表达式中分组的数量。
    • groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典,没有别名的组不包含在内。

    实例方法[ | re模块方法]:

    match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])

      这个方法将从string的pos下标处起尝试匹配pattern;如果pattern结束时仍可匹配,则返回一个Match对象;如果匹配过程中pattern无法匹配,或者匹配未结束就已到达endpos,则返回None。 
    pos和endpos的默认值分别为0和len(string);re.match()无法指定这两个参数,参数flags用于编译pattern时指定匹配模式。 
      注意:这个方法并不是完全匹配。当pattern结束时若string还有剩余字符,仍然视为成功。想要完全匹配,可以在表达式末尾加上边界匹配符’$’。

    search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])

      这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern,如果pattern结束时仍可匹配,则返回一个Match对象;若无法匹配,则将pos加1重新尝试匹配;直到pos=endpos时仍无法匹配则返回None。 pos和endpos的默认值分别为0和len(string));re.search()无法指定这两个参数,参数flags用于编译pattern时指定匹配模式。

    split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])

      按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数,不指定将全部分割。

    findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])

      搜索string,以列表形式返回全部能匹配的子串。

    finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])

      搜索string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。

    sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])

      使用repl替换string中每一个匹配的子串后返回替换后的字符串。 当repl是一个字符串时,可以使用\id或\g、\g引用分组,但不能使用编号0。 当repl是一个方法时,这个方法应当只接受一个参数(Match对象),并返回一个字符串用于替换(返回的字符串中不能再引用分组)。 count用于指定最多替换次数,不指定时全部替换。

    subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])

      返回 (sub(repl, string[, count]), 替换次数)。

    re.match函数

      re.match 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。 
      函数语法: 
      re.match(pattern, string, flags=0) 
      函数参数说明: 
    这里写图片描述
    匹配成功re.match方法返回一个匹配的对象,否则返回None。 
    我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 
    这里写图片描述

    实例 1

    #!/usr/bin/python
    # -*- coding: UTF-8 -*- 
    
    import re
    print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
    print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

      以上实例运行输出结果为: 
      (0, 3) 
      None

    实例 2

    #!/usr/bin/python3
    import re
    
    line = "Cats are smarter than dogs"
    
    matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
    
    if matchObj:
       print ("matchObj.group() : ", matchObj.group())
       print ("matchObj.group(1) : ", matchObj.group(1))
       print ("matchObj.group(2) : ", matchObj.group(2))
    else:
       print ("No match!!")
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

      以上实例执行结果如下: 
      matchObj.group() : Cats are smarter than dogs 
      matchObj.group(1) : Cats 
      matchObj.group(2) : smarter

    re.search方法

      re.search 扫描整个字符串并返回第一个成功的匹配。 
      函数语法: 
      re.search(pattern, string, flags=0) 
      函数参数说明: 
    这里写图片描述
    匹配成功re.search方法返回一个匹配的对象,否则返回None。 
    我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 
    这里写图片描述

    实例一

    import re
    print(re.search("rlovep","rlovep.com").span())
    print(re.search("com","http://rlovep.com").span())
    • 1
    • 2
    • 3

    实例二

    import re
    line = "This is my blog"
    #匹配含有is的字符串
    matchObj = re.search( r'(.*) is (.*?) .*', line, re.M|re.I)
    #使用了组输出:当group不带参数是将整个匹配成功的输出
    #当带参数为1时匹配的是最外层左边包括的第一个括号,一次类推;
    if matchObj:
        print ("matchObj.group() : ", matchObj.group())#匹配整个
        print ("matchObj.group(1) : ", matchObj.group(1))#匹配的第一个括号
        print ("matchObj.group(2) : ", matchObj.group(2))#匹配的第二个括号
    else:
        print ("No match!!")
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

      输出: 
      matchObj.group() : This is my blog 
      matchObj.group(1) : This 
      matchObj.group(2) : my

    search和match区别

      re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None;而re.search匹配整个字符串,直到找到一个匹配。

    实例

    #!/usr/bin/python3
    
    import re
    
    line = "Cats are smarter than dogs";
    
    matchObj = re.match( r'dogs', line, re.M|re.I)
    if matchObj:
       print ("match --> matchObj.group() : ", matchObj.group())
    else:
       print ("No match!!")
    
    matchObj = re.search( r'dogs', line, re.M|re.I)
    if matchObj:
       print ("search --> matchObj.group() : ", matchObj.group())
    else:
       print ("No match!!")
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

      以上实例运行结果如下: 
      No match!! 
      search –> matchObj.group() : dogs

    检索和替换

      Python 的re模块提供了re.sub用于替换字符串中的匹配项。 
      语法: 
      re.sub(pattern, repl, string, count=0) 
      参数:

    • pattern : 正则中的模式字符串。
    • repl : 替换的字符串,也可为一个函数。
    • string : 要被查找替换的原始字符串。
    • count : 模式匹配后替换的最大次数,默认 0 表示替换所有的匹配。

    实例

    #!/usr/bin/python3
    import re
    
    phone = "2004-959-559 # 这是一个电话号码"
    
    # 删除注释
    num = re.sub(r'#.*$', "", phone)
    print ("电话号码 : ", num)
    
    # 移除非数字的内容
    num = re.sub(r'\D', "", phone)
    print ("电话号码 : ", num) 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

      以上实例执行结果如下: 
      电话号码 : 2004-959-559 
      电话号码 : 2004959559 
      repl 参数是一个函数 
      以下实例中将字符串中的匹配的数字乘于 2:

    #!/usr/bin/python
    
    import re
    
    # 将匹配的数字乘于 2
    def double(matched):
        value = int(matched.group('value'))
        return str(value * 2)
    
    s = 'A23G4HFD567'
    print(re.sub('(?P<value>\d+)', double, s))
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

      执行输出结果为: 
      A46G8HFD1134

    正则表达式修饰符 - 可选标志

      正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志: 
    这里写图片描述

    正则表达式模式

      模式字符串使用特殊的语法来表示一个正则表达式:

    • 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
    • 多数字母和数字前加一个反斜杠时会拥有不同的含义。
    • 标点符号只有被转义时才匹配自身,否则它们表示特殊的含义。
    • 反斜杠本身需要使用反斜杠转义。
    • 由于正则表达式通常都包含反斜杠,所以你最好使用原始字符串来表示它们。模式元素(如 r’/t’,等价于’//t’)匹配相应的特殊字符。

      下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数,某些模式元素的含义会改变。 
    这里写图片描述
    这里写图片描述
    这里写图片描述

    正则表达式实例

    字符匹配 
    这里写图片描述
    这里写图片描述

    参考资料

      http://www.runoob.com/python3/python3-reg-expressions.html


    Python进阶(十七)-Python 字符串操作

    去空格及特殊符号

    s.strip().lstrip().rstrip(',')
    • 1

    复制字符串

    #strcpy(sStr1,sStr2)
    sStr1 = 'strcpy'
    sStr2 = sStr1
    sStr1 = 'strcpy2'
    print sStr2
    • 1
    • 2
    • 3
    • 4
    • 5

    连接字符串

    #strcat(sStr1,sStr2)
    sStr1 = 'strcat'
    sStr2 = 'append'
    sStr1 += sStr2
    print sStr1
    • 1
    • 2
    • 3
    • 4
    • 5

    查找字符

    #strchr(sStr1,sStr2)
    # < 0 为未找到
    sStr1 = 'strchr'
    sStr2 = 's'
    nPos = sStr1.index(sStr2)
    print nPos
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    比较字符串

    #strcmp(sStr1,sStr2)
    sStr1 = 'strchr'
    sStr2 = 'strch'
    print cmp(sStr1,sStr2)
    • 1
    • 2
    • 3
    • 4

    扫描字符串是否包含指定的字符

    #strspn(sStr1,sStr2)
    sStr1 = '12345678'
    sStr2 = '456'
    #sStr1 and chars both in sStr1 and sStr2
    print len(sStr1 and sStr2)
    • 1
    • 2
    • 3
    • 4
    • 5

    字符串长度

    #strlen(sStr1)
    sStr1 = 'strlen'
    print len(sStr1)
    • 1
    • 2
    • 3

    将字符串中的大小写转换

    #strlwr(sStr1)
    sStr1 = 'JCstrlwr'
    sStr1 = sStr1.upper()
    #sStr1 = sStr1.lower()
    print sStr1
    • 1
    • 2
    • 3
    • 4
    • 5

    追加指定长度的字符串

    #strncat(sStr1,sStr2,n)
    sStr1 = '12345'
    sStr2 = 'abcdef'
    n = 3
    sStr1 += sStr2[0:n]
    print sStr1
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    字符串指定长度比较

    #strncmp(sStr1,sStr2,n)
    sStr1 = '12345'
    sStr2 = '123bc'
    n = 3
    print cmp(sStr1[0:n],sStr2[0:n])
    • 1
    • 2
    • 3
    • 4
    • 5

    复制指定长度的字符

    #strncpy(sStr1,sStr2,n)
    sStr1 = ''
    sStr2 = '12345'
    n = 3
    sStr1 = sStr2[0:n]
    print sStr1
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    将字符串前n个字符替换为指定的字符

    #strnset(sStr1,ch,n)
    sStr1 = '12345'
    ch = 'r'
    n = 3
    sStr1 = n * ch + sStr1[3:]
    print sStr1
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    扫描字符串

    #strpbrk(sStr1,sStr2)
    sStr1 = 'cekjgdklab'
    sStr2 = 'gka'
    nPos = -1
    for c in sStr1:
        if c in sStr2:
            nPos = sStr1.index(c)
            break
    print nPos
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    翻转字符串

    #strrev(sStr1)
    sStr1 = 'abcdefg'
    sStr1 = sStr1[::-1]
    print sStr1
    • 1
    • 2
    • 3
    • 4

    查找字符串

    #strstr(sStr1,sStr2)
    sStr1 = 'abcdefg'
    sStr2 = 'cde'
    print sStr1.find(sStr2)
    • 1
    • 2
    • 3
    • 4

    分割字符串

    #strtok(sStr1,sStr2)
    sStr1 = 'ab,cde,fgh,ijk'
    sStr2 = ','
    sStr1 = sStr1[sStr1.find(sStr2) + 1:]
    print sStr1
    #或者
    s = 'ab,cde,fgh,ijk'
    print(s.split(','))
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    连接字符串

    delimiter = ','
    mylist = ['Brazil', 'Russia', 'India', 'China']
    print delimiter.join(mylist)
    • 1
    • 2
    • 3

    截取字符串

    str = ’0123456789′
    print str[0:3] #截取第一位到第三位的字符
    print str[:] #截取字符串的全部字符
    print str[6:] #截取第七个字符到结尾
    print str[:-3] #截取从头开始到倒数第三个字符之前
    print str[2] #截取第三个字符
    print str[-1] #截取倒数第一个字符
    print str[::-1] #创造一个与原字符串顺序相反的字符串
    print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
    print str[-3:] #截取倒数第三位到结尾
    print str[:-5:-3] #逆序截取,具体啥意思没搞明白?
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    python字符串跟整型互转

    print ("整型:",int(50))
    a=int(50)
    print("整型:",type(a))
    numStr = "50";
    print ("字符串:",type(numStr))
    convertedInt = int(numStr);
    print("字符串转换为整型:",convertedInt)
    convertedstr=str(a)
    print("整型转换为字符串:",convertedInt)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    这里写图片描述

    参考资料

      http://www.runoob.com/python3/python3-string.html


    Python进阶(十八)-Python3爬虫实践

      这篇文章主要介绍了如何使用Python3爬取csdn博客访问量的相关资料,在Python2已实现的基础上实现Python3爬虫,对比版本之间的差异所在,需要的朋友可以参考下。 
      使用python来获取自己博客的访问量,也是后面将要开发项目的一部分,后边会对博客的访问量进行分析,以折线图和饼图等可视化的方式展示自己博客被访问的情况,使自己能更加清楚自己的哪些博客更受关注。其实,在较早之前博客专家本身就有这个功能,不知什么原因此功能被取消了。

    一.网址分析

    这里写图片描述
      进入自己的博客页面,网址为:http://blog.csdn.net/sunhuaqiang1。 网址还是比较好分析的:就是csdn的网址+个人csdn登录账号,我们来看下一页的网址。 
    这里写图片描述
      看到第二页的地址为:http://blog.csdn.net/sunhuaqiang1/article/list/2后边的数字表示现在正处于第几页,再用其他的页面验证一下,确实是这样的,那么第一页为什么不是http://blog.csdn.net/sunhuaqiang1/article/list/1呢,那么我们在浏览器中输http://blog.csdn.net/sunhuaqiang1/article/list/1试试,哎,果然是第一页啊,第一页原来是被重定向了,http://blog.csdn.net/sunhuaqiang1被重定向到http://blog.csdn.net/sunhuaqiang1/article/list/1,所以两个网址都能访问第一页,那么现在规律就非常明显了: http://blog.csdn.net/sunhuaqiang1/article/list/ + 页号

    二.获取标题

      右键查看网页的源代码,我们看到可以找到这样一段代码: 
    这里写图片描述 
    这里写图片描述 
      我们可以看到标题都是在标签

    <span class="link_title">
    <a href="/sunhuaqiang1/article/details/50651235">
    ...
    </a>
    </span>
    • 1
    • 2
    • 3
    • 4
    • 5

      中的。所以我们可以使用下面的正则表达式来匹配标题:

    <span class="link_title"><a href=".*?">(.*?)</a></span>
    • 1

    三.获取访问量

      拿到了标题之后,就要获得对应的访问量了,经过对源码的分析,我看到访问量的结构都是这样的:

    <span class="link_view" title="阅读次数"><a href="/sunhuaqiang1/article/details/51289580" title="阅读次数">阅读</a>(12718)</span>
    • 1

      括号中的数字即为访问量,我们可以用下面的正则表达式来匹配:

    <span class="link_view".*?><a href=".*?" title="阅读次数">阅读</a>\((.*?)\)</span>
    • 1

      其中,’.?’的含义是启用正则懒惰模式。必须跟在或者+后边用。 
      如:“< img src=”test.jpg” width=”60px” height=”80px”/>” 
      如果用正则匹配src中内容非懒惰模式匹配

    src=".*"
    • 1

      匹配结果是:src=”test.jpg” width=”60px” height=”80px” 
      意思是从=”往后匹配,直到最后一个”匹配结束 
    懒惰模式正则:

    src=".*?"
    • 1

      结果:src=”test.jpg” 
      因为匹配到第一个”就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。

    • .表示除\n之外的任意字符
    • *表示匹配0-无穷
    • +表示匹配1-无穷

    四.尾页判断

      接下来我们要判断当前页是否为最后一页,否则我们就不能判断什么时候结束了,我找到了源码中‘尾页’的标签,发现是下面的结构:

    <a href="/sunhuaqiang1/article/list/2">下一页</a> <a href="/sunhuaqiang1/article/list/7">尾页</a>
    • 1

      所以我们可以用下面的正则表达式来匹配,如果匹配成功就说明当前页不是最后一页,否则当前页就是最后一页。

    <a href=".*?">尾页</a>
    • 1

    五.编程实现

      下面是摘自的Python2版完整的代码实现:

    #!usr/bin/python
    # -*- coding: utf-8 -*-
    '''
    Created on 2016年2月13日
    @author: ***
    使用python爬取csdn个人博客的访问量,主要用来练手
    '''
    import urllib2
    import re
    #当前的博客列表页号
    page_num = 1
    #不是最后列表的一页
    notLast = 1
    account = str(raw_input('输入csdn的登录账号:'))
    while notLast:
        #首页地址
        baseUrl = 'http://blog.csdn.net/'+account
        #连接页号,组成爬取的页面网址
        myUrl = baseUrl+'/article/list/'+str(page_num)
        #伪装成浏览器访问,直接访问的话csdn会拒绝
        user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
        headers = {'User-Agent':user_agent}
        #构造请求
        req = urllib2.Request(myUrl,headers=headers)
        #访问页面
        myResponse = urllib2.urlopen(req)
        myPage = myResponse.read()
        #在页面中查找是否存在‘尾页'这一个标签来判断是否为最后一页
        notLast = re.findall('<a href=".*?">尾页</a>',myPage,re.S)
        print '---------------第%d页-------------' % (page_num,)
        #利用正则表达式来获取博客的标题
        title = re.findall('<span class="link_title"><a href=".*?">(.*?)</a></span>',myPage,re.S)
        titleList=[]
        for items in title:
            titleList.append(str(items).lstrip().rstrip())
        #利用正则表达式获取博客的访问量
        view = re.findall('<span class="link_view".*?><a href=".*?" title="阅读次数">阅读</a>\((.*?)\)</span>',myPage,re.S)
        viewList=[]
    for items in view:
        viewList.append(str(items).lstrip().rstrip())
    #将结果输出 
    for n in range(len(titleList)):
        print '访问量:%s 标题:%s' % (viewList[n].zfill(4),titleList[n])
    #页号加1
    page_num = page_num + 1
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

      由于自己现在的IDE为Python3,且自己在学习Python3。故在此基础上实现Python2项目的升级改造,并在改造过程中发现版本之间的差异性。以下为Python3版本下的爬虫代码。

    #!usr/bin/python
    # -*- coding: utf-8 -*-
    '''
    Created on 2017年3月19日
    @author: SUN HuaQiang
    目的:使用python爬取csdn个人博客的访问量,主要用来练手Python爬虫
    收获:1.了解Python爬虫的基本过程
          2.在Python2的基础上实现Python3,通过对比发现版本之间的差异
    '''
    import urllib.request
    import urllib
    import re
    
    #当前的博客列表页号
    page_num = 1
    #初始化最后列表的页码
    notLast = 1
    account = str(input('请输入csdn的登录账号:'))
    while notLast:
        #首页地址
        baseUrl = 'http://blog.csdn.net/' + account
        #连接页号,组成爬取的页面网址
        myUrl = baseUrl+'/article/list/' + str(page_num)
        #伪装成浏览器访问,直接访问的话csdn会拒绝
        user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
        headers = {'User-Agent':user_agent}
        #构造请求
        req = urllib.request.Request(myUrl,headers=headers)
        #访问页面
        myResponse = urllib.request.urlopen(req)
        #python3中urllib.read返回的是bytes对象,不是string,得把它转换成string对象,用bytes.decode方法
        myPage = myResponse.read().decode()
        #在页面中查找是否存在‘尾页'这一个标签来判断是否为最后一页
        notLast = re.findall('<a href=".*?">尾页</a>', myPage, re.S)
        print ('-----------第%d页--------------' % (page_num,))
        #利用正则表达式来获取博客的标题
        title = re.findall('<span class="link_title"><a href=".*?">(.*?)</a></span>',myPage,re.S)
        titleList=[]
        for items in title:
            titleList.append(str(items).lstrip().rstrip())
        #利用正则表达式获取博客的访问量
        view = re.findall('<span class="link_view".*?><a href=".*?" title="阅读次数">阅读</a>\((.*?)\)</span>',myPage,re.S)
        viewList=[]
        for items in view:
            viewList.append(str(items).lstrip().rstrip())
        #将结果输出
        for n in range(len(titleList)):
            print ('访问量:%s 标题:%s' % (viewList[n].zfill(4),titleList[n]))
        #页号加1
        page_num = page_num + 1
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

      下面是部分结果: 
    这里写图片描述 
      瑕疵:通过爬虫结果可以发现,在CSDN中,对于设置为指定的文章,爬取结果存在一定的问题,还包含部分css代码。 
      改善:通过更改获取博文标题的正则表达式,即可解决此问题。 
    这里写图片描述 
    这里写图片描述 
    这里写图片描述” 
      想法是好的,但是直接利用正则实现标题获取时遇到了困难,暂时并未实现理想结果。 
      遂改变思路,将利用正则获取后的字符串再进行二次正则,即替换操作,语句如下:

    for items in title:
        titleList.append(re.sub('<font color="red">.*?</font>', '', str(items).lstrip().rstrip()))
    • 1
    • 2

      更改后的结果如下。并同时为每篇博文进行了编号。 
    这里写图片描述 
      同时,自己还希望获取到的信息包括:访问总量、积分、等级、排名、粉丝、原创、转载、译文、评论等数据信息。 
      以上信息在网页源码中如下所示。

    <ul id="blog_rank"> 
        <li>访问:<span>459285次</span></li> 
        <li>积分:<span>9214</span> </li> 
        <li >等级: <span style="position:relative;display:inline-block;z-index:1" > 
        <img src="http://c.csdnimg.cn/jifen/images/xunzhang/jianzhang/blog6.png" alt="" style="vertical-align: middle;" id="leveImg"> 
        <div id="smallTittle" style=" position: absolute; left: -24px; top: 25px; text-align: center; width: 101px; height: 32px; background-color: #fff; line-height: 32px; border: 2px #DDDDDD solid; box-shadow: 0px 2px 2px rgba (0,0,0,0.1); display: none; z-index: 999;"> 
        <div style="left: 42%; top: -8px; position: absolute; width: 0; height: 0; border-left: 10px solid transparent; border-right: 10px solid transparent; border-bottom: 8px solid #EAEAEA;"></div> 
        积分:9214 </div> 
        </span> </li> 
        <li>排名:<span>第1639名</span></li> 
        </ul> 
        <ul id="blog_statistics"> 
        <li>原创:<span>425篇</span></li> 
        <li>转载:<span>44篇</span></li> 
        <li>译文:<span>2篇</span></li> 
        <li>评论:<span>108条</span></li> 
        </ul> 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

      则获取访问信息的正则表达式为:

    #利用正则表达式获取博客信息
    sumVisit = re.findall('<li>访问:<span>(.*?)</span></li>', myPage, re.S)
    credit = re.findall('<li>积分:<span>(.*?)</span> </li>', myPage, re.S)
    rank = re.findall('<li>排名:<span>(.*?)</span></li>', myPage, re.S)
    grade = re.findall('<li >.*?<img src=.*?/blog(.*?).png.*?>.*?</li>', test3, re.S)
    original = re.findall('<li>原创:<span>(.*?)</span></li>', myPage, re.S)
    reprint = re.findall('<li>转载:<span>(.*?)</span></li>', myPage, re.S)
    trans = re.findall('<li>译文:<span>(.*?)</span></li>', myPage, re.S)
    comment = re.findall('<li>评论:<span>(.*?)</span></li>', myPage, re.S)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    这里写图片描述
      根据网页源码,可得出其正则表达式为

    staData = re.findall('<li><a href=.*?>(.*?)</a><span>(.*?)</span></li>', myPage, re.S)
    
    for i in staData:
        print(i[0] + ':' + i[1].lstrip('(').rstrip(')')+'篇')
    • 1
    • 2
    • 3
    • 4

      经过以上操作,得到的用户Blog信息如下图所示: 
    这里写图片描述 
      最终遇到的问题是:有关粉丝数的爬取遇到了问题,因为前面数据信息的获取不需要用户登录,而用户粉丝数是在用户已登录情景下获取的,故需要将用户登录信息添加进去。犯愁~ 
      PS:论文盲审送回来了,自己这段时间要用来修改论文了,后面的博客后面再说吧~

    注意事项

    • urllib2在3.5中为urllib.request;
    • raw_input()在3.5中为input();
    • python3中urllib.read()返回的是bytes对象,不是string,得把它转换成string对象,用bytes.decode()方法;
    • re.S意在使.匹配包括换行在内的所有字符;
    • python3对urllib和urllib2进行了重构,拆分成了urllib.request, urllib.response,urllib.parse,urllib.error等几个子模块,这样的架构从逻辑和结构上说更加合理。urljoin现在对应的函数是urllib.parse.urljoin

      注:Python2部分的爬虫代码为网络获取,在此向匿名人士表示感谢。


    Python进阶(十九)-Python3安装第三方爬虫库BeautifulSoup4

      在做Python3爬虫练习时,从网上找到了一段代码如下:

    #使用第三方库BeautifulSoup,用于从html或xml中提取数据
    from bs4 import BeautifulSoup
    • 1
    • 2

      自己实践后,发现出现了错误,如下所示: 
    这里写图片描述 
      以上错误提示是说没有发现名为“bs4”的模块。即“bs4”模块未安装。 
      进入Python安装目录,以作者IDE为例, 
    这里写图片描述 
    这里写图片描述 
      控制台提示第三方库BeautifulSoup4安装成功!回到之前的程序中,会发现IntelJ已经检测到第三方库BS4的安装,已自更新项目,此时项目恢复正常,无错误提示。

    常见问题

       在做BS4爬虫练习时,新建的文件名为bs4.py,结果出现如下错误提示: 
    这里写图片描述 
      即ImportError: cannot import name BeautifulSoup一般有一下几种情况: 
       1. 在python2.x下安装的BeautifulSoup在python3.x下运行会报这种错,可用pip3 install Beautifulsoup4 . 
       2. 导入时指定bs4 像这样: from bs4 import BeautifulSoup. 
       3. 太巧合,如果你测试的文件名正好命名为bs4.py,那怎么整都会报这个错,把名字改成其他的吧。

      BS4官方文档 

    Python进阶(二十)-Python爬虫实例讲解

      本篇博文主要讲解Python爬虫实例,重点包括爬虫技术架构,组成爬虫的关键模块:URL管理器、HTML下载器和HTML解析器。

    爬虫简单架构


    这里写图片描述

    程序入口函数(爬虫调度段)

    #coding:utf8
    import time, datetime
    
    from maya_Spider import url_manager, html_downloader, html_parser, html_outputer
    
    
    class Spider_Main(object):
        #初始化操作
        def __init__(self):
            #设置url管理器
            self.urls = url_manager.UrlManager()
            #设置HTML下载器
            self.downloader = html_downloader.HtmlDownloader()
            #设置HTML解析器
            self.parser = html_parser.HtmlParser()
            #设置HTML输出器
            self.outputer = html_outputer.HtmlOutputer()
    
        #爬虫调度程序
        def craw(self, root_url):
            count = 1
            self.urls.add_new_url(root_url)
            while self.urls.has_new_url():
                try:
                    new_url = self.urls.get_new_url()
                    print('craw %d : %s' % (count, new_url))
                    html_content = self.downloader.download(new_url)
                    new_urls, new_data = self.parser.parse(new_url, html_content)
                    self.urls.add_new_urls(new_urls)
                    self.outputer.collect_data(new_data)
    
                    if count == 10:
                        break
    
                    count = count + 1
                except:
                    print('craw failed')
    
            self.outputer.output_html()
    
    if __name__ == '__main__':
        #设置爬虫入口
        root_url = 'http://baike.baidu.com/view/21087.htm'
        #开始时间
        print('开始计时..............')
        start_time = datetime.datetime.now()
        obj_spider = Spider_Main()
        obj_spider.craw(root_url)
        #结束时间
        end_time = datetime.datetime.now()
        print('总用时:%ds'% (end_time - start_time).seconds)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    URL管理器

    class UrlManager(object):
        def __init__(self):
            self.new_urls = set()
            self.old_urls = set()
    
        def add_new_url(self, url):
            if url is None:
                return
            if url not in self.new_urls and url not in self.old_urls:
                self.new_urls.add(url)
    
        def add_new_urls(self, urls):
            if urls is None or len(urls) == 0:
                return
            for url in urls:
                self.add_new_url(url)
    
        def has_new_url(self):
            return len(self.new_urls) != 0
    
        def get_new_url(self):
            new_url = self.new_urls.pop()
            self.old_urls.add(new_url)
            return new_url
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    网页下载器

    import urllib
    import urllib.request
    
    class HtmlDownloader(object):
    
        def download(self, url):
            if url is None:
                return None
    
            #伪装成浏览器访问,直接访问的话csdn会拒绝
            user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
            headers = {'User-Agent':user_agent}
            #构造请求
            req = urllib.request.Request(url,headers=headers)
            #访问页面
            response = urllib.request.urlopen(req)
            #python3中urllib.read返回的是bytes对象,不是string,得把它转换成string对象,用bytes.decode方法
            return response.read().decode()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    网页解析器

    import re
    import urllib
    from urllib.parse import urlparse
    
    from bs4 import BeautifulSoup
    
    class HtmlParser(object):
    
        def _get_new_urls(self, page_url, soup):
            new_urls = set()
            #/view/123.htm
            links = soup.find_all('a', href=re.compile(r'/item/.*?'))
            for link in links:
                new_url = link['href']
                new_full_url = urllib.parse.urljoin(page_url, new_url)
                new_urls.add(new_full_url)
            return new_urls
    
        #获取标题、摘要
        def _get_new_data(self, page_url, soup):
            #新建字典
            res_data = {}
            #url
            res_data['url'] = page_url
            #<dd class="lemmaWgt-lemmaTitle-title"><h1>Python</h1>获得标题标签
            title_node = soup.find('dd', class_="lemmaWgt-lemmaTitle-title").find('h1')
            print(str(title_node.get_text()))
            res_data['title'] = str(title_node.get_text())
            #<div class="lemma-summary" label-module="lemmaSummary">
            summary_node = soup.find('div', class_="lemma-summary")
            res_data['summary'] = summary_node.get_text()
    
            return res_data
    
        def parse(self, page_url, html_content):
            if page_url is None or html_content is None:
                return None
    
            soup = BeautifulSoup(html_content, 'html.parser', from_encoding='utf-8')
            new_urls = self._get_new_urls(page_url, soup)
            new_data = self._get_new_data(page_url, soup)
            return new_urls, new_data
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    网页输出器

    class HtmlOutputer(object):
    
        def __init__(self):
            self.datas = []
    
        def collect_data(self, data):
            if data is None:
                return
            self.datas.append(data )
    
        def output_html(self):
            fout = open('maya.html', 'w', encoding='utf-8')
            fout.write("<head><meta http-equiv='content-type' content='text/html;charset=utf-8'></head>")
            fout.write('<html>')
            fout.write('<body>')
            fout.write('<table border="1">')
            # <th width="5%">Url</th>
            fout.write('''<tr style="color:red" width="90%">
                        <th>Theme</th>
                        <th width="80%">Content</th>
                        </tr>''')
            for data in self.datas:
                fout.write('<tr>\n')
                # fout.write('\t<td>%s</td>' % data['url'])
                fout.write('\t<td align="center"><a href=\'%s\'>%s</td>' % (data['url'], data['title']))
                fout.write('\t<td>%s</td>\n' % data['summary'])
                fout.write('</tr>\n')
            fout.write('</table>')
            fout.write('</body>')
            fout.write('</html>')
            fout.close()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    运行结果

    这里写图片描述

      完整代码 


    Python进阶(二十二)-Python3使用PyMysql连接mysql数据库

      python语言的3.x完全不向前兼容,导致我们在python2.x中可以正常使用的库,到了python3就用不了.比如说mysqldb。 
      目前MySQLdb并不支持python3.x,Python3.x连接MySQL的方案有:oursql, PyMySQL, myconnpy 等 
      下面来说下python3如何安装和使用pymysql,另外两个方案我会在以后再讲。

    1.pymysql安装

      pymysql就是作为python3环境下mysqldb的替代物,进入命令行,使用pip安装pymysql。

    pip install pymysql3
    • 1

    这里写图片描述

    2.pymysql使用

      如果想使用mysqldb的方式,那么直接在py文件的开头加入如下两行代码即可。

    #引入pymysql
    import pymysql 
    #当成是mysqldb一样使用,当然也可以不写这句,那就按照pymysql的方式
    pymysql.install_as_MySQLdb()
    • 1
    • 2
    • 3
    • 4

    3.安装测试示例

    import pymysql
    
    print(pymysql)
    • 1
    • 2
    • 3

      会看到控制台输出以下信息: 
    这里写图片描述 
      说明pymysql安装成功,可正常使用。

    4.pymysql操作示例

    #导入pymysql的包
    import pymysql
    
    # print(pymysql)
    
    try:
        #获取一个数据库连接,注意如果是UTF-8类型的,需要制定数据库
        conn = pymysql.connect(host='localhost', port=3308, user='lmapp', passwd='lmapp', db='test', charset='utf8')
        cur = conn.cursor()#获取一个游标
    
        sql_query = "select * from user"
        sql_insert = "insert into user(uid, uname, passwd) VALUES ('18853883587', 'SHQ', 'TEST')"
        sql_update = "update user set uname='ZQY' WHERE uid='18353102061'"
        sql_delete = "delete from user WHERE uid='18353102062'"
    
        cur.execute(sql_query)
        data = cur.fetchall()
        cur.execute(sql_insert)
        print(cur.rowcount)
        cur.execute(sql_update)
        print(cur.rowcount)
        cur.execute(sql_delete)
        print(cur.rowcount)
        for d in data :
            #注意int类型需要使用str函数转义
            print(type(d[0]))
            print("UID: "+d[0]+'  用户名: '+d[1]+"  密码: "+d[2])
        #提交事务
    conn.commit()
        cur.close()#关闭游标
        conn.close()#释放数据库资源
    except  Exception :
    #异常情况下,进行事务回滚
    conn.rollback()
        print("操作失败")
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    5.pymysql操作示例-银行转帐

    #coding:utf8
    
    import pymysql
    
    
    class TranferMoney(object):
        def __init__(self, conn):
            self.conn = conn
    
        #检查账户有效性
        def check_acct_available(self, source_acctid):
            try:
                cursor = self.conn.cursor()
                sql_query = "select * from account where acctid='%s'"%source_acctid
                cursor.execute(sql_query)
                print('check_acct_available:', sql_query)
                rs = cursor.fetchall()
                if len(rs) != 1:
                    raise Exception('帐号%s不存在'%source_acctid)
            finally:
                cursor.close()
    
        #检查账户金额
        def has_enough_money(self, source_acctid, money):
            try:
                print(type(money))
                cursor = self.conn.cursor()
                sql_query = "select * from account where acctid=%s and money >= %d"%(source_acctid, money)
                cursor.execute(sql_query)
                print('has_enough_money:', sql_query)
                rs = cursor.fetchall()
                if len(rs) != 1:
                    raise Exception('帐号%s余额不足'%source_acctid)
            finally:
                cursor.close()
    
        #账户减款
        def reduce_money(self, source_acctid, money):
            try:
                cursor = self.conn.cursor()
                sql_query = "update account set money=money-%d where acctid = '%s'"%(money, source_acctid)
                cursor.execute(sql_query)
                print('reduce_money:', sql_query)
                if cursor.rowcount != 1:
                    raise Exception('帐号%s减款错误'%source_acctid)
            finally:
                cursor.close()
    
        #账户加款
        def add_money(self, source_acctid, money):
            try:
                cursor = self.conn.cursor()
                sql_query = "update account set money=money+%d where acctid = '%s'"%(money, source_acctid)
                cursor.execute(sql_query)
                print('reduce_money:', sql_query)
                if cursor.rowcount != 1:
                    raise Exception('帐号%s加款错误'%source_acctid)
            finally:
                cursor.close()
    
        def transfer(self, source_acctid, target_accid, money):
            try:
                self.check_acct_available(source_acctid)
                self.check_acct_available(target_accid)
                self.has_enough_money(source_acctid, money)
                self.reduce_money(source_acctid, money)
                self.add_money(target_accid, money)
                self.conn.commit()
            except Exception as e:
                print("Exception:", e)
                self.conn.rollback()
                raise e
    
    if __name__ == '__main__':
        source_acctid = input("请输入转账方帐号:")
        target_accid = input("请输入收款方帐号:")
        money = input("请输入转款金额:")
        conn = pymysql.connect(host='localhost', port=3308, user='lmapp', passwd='lmapp', db='test', charset='utf8')
        tranfer_money = TranferMoney(conn)
        try:
            tranfer_money.transfer(source_acctid, target_accid, int(money))
            print("转账成功")
        except Exception as e:
            print('Error:', e)
        finally:
            conn.close()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86

    数据库插入操作

      以下实例使用执行 SQL INSERT 语句向表 EMPLOYEE 插入记录:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    import MySQLdb
    
    # 打开数据库连接
    db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )
    
    # 使用cursor()方法获取操作游标 
    cursor = db.cursor()
    
    # SQL 插入语句
    sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
             LAST_NAME, AGE, SEX, INCOME)
             VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
    try:
       # 执行sql语句
       cursor.execute(sql)
       # 提交到数据库执行
       db.commit()
    except:
       # Rollback in case there is any error
       db.rollback()
    
    # 关闭数据库连接
    db.close()
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    附 PEP 249 – Python Database API Specification v2.0文档

    connect参数

    这里写图片描述

    connect方法

    这里写图片描述

    cursor方法

    这里写图片描述

    fetch*方法介绍

    这里写图片描述

    DQL

    这里写图片描述

    DML

    这里写图片描述

    事务特性

    这里写图片描述


    Python进阶(二十三)-Django使用pymysql连接MySQL数据库做增删改查

    IDE说明

      Python:3.5 
      Django:1.10 
      Pymysql:0.7.10 
      Mysql:5.5 
      注:Django1.10默认使用的是mysqlDB模块来操作数据库,而该模块已不支持Python3,所以需要其他的方式连接数据库。 
      本文选择使用pymysql连接组件。

    前言

      在学习完Python基础之后,继续学习Python Web开发方面的知识。首先决定学习Django Web开发框架。在连接数据库一块,视频教学中使用的是django内置的sqlite数据库,之前自己使用的是mysql数据库,遂决定继续使用mysql数据库。

    mysql连接配置

      查看了使用mysql的settings.py项目配置文件信息,如下:

      'default': {  
            'ENGINE': 'django.db.backends.mysql', 
            'NAME': 'mydatabaseName',  
            'USER': 'mydatabaseuser',  
            'PASSWORD': 'mypassword',  
            'HOST': '127.0.0.1',  
            'PORT': '3306',  
        }  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

      具体含义就不再解释了,一看就懂。配置好之后,在命令行项目目录下输入服务端运行命令:

    python manage.py runserver
    • 1

      却出现了错误提示,信息如下: 
    Django.core.exceptions. ImproperlyConfigured:Error loading MySqldb module:no module named ‘MySQLdb’. 
      看来,Django1.10默认使用的是mysqldb连接组件。但是,在python3.x中已经不支持那个组件了,取而代之的则是pymysql连接组件。遂决定使用pymysql连接组件。 
      采用上述配置方式的话默认会调用mysqlDB模块,由于Python3已经不支持该模块,所以需要修改该配置文件所在目录下的init.py文件

    import pymysql
    pymysql.install_as_MySQLdb() 
    • 1
    • 2

      再次执行方式一的数据库同步命令即可。但是却出现了如下错误提示: 
    ImportError:cannot import name “Thing2Literal” 
      之所以出现以上错误,是因为MySQLdb里面有一个Thing2Literal方法,在pymysql里没有,所以导致报错。还有可能就是由于pymysql的版本低,存在这个问题,建议下载最新版本的pymysql,于是我重新下载pymysql,版本是最新的0.7.10(pip install pymysql),然后进行如下操作: 
    1.将settings里面的DATABASES改成MySQL相关

    DATABASES = {
        # 'default': {
        #     'ENGINE': 'django.db.backends.sqlite3',
        #     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        # },
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'OPTIONS':{'read_default_file': os.path.join(BASE_DIR, 'database.cnf'),}
            #数据库名
            # 'NAME' : 'csdn',
            # 'USER' : 'lmapp',
            # 'PASSWORD' : 'lmapp',
            # 'HOST' : '127.0.0.1',
            # 'PORT' : '8088',
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    2.在settings的上一级目录中添加my.cnf 文件,内容如下:

    [client]
    database = 'csdn'
    user = 'lmapp'
    password = 'lmapp'
    default-character-set = utf8
    host = '127.0.0.1'
    port = 8088
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

      在项目manage.py同级目录下输入命令

    python manage.py makemigrations
    python manage.py migrate
    • 1
    • 2

      至此,数据表关联成功,后面进行校验操作。 
      设想:Django是否可以读取已存在的数据库信息?必须得首先通过Django建立数据表吗?答案是NO,不过可以采用将Django生成的数据表保存于已存在数据库中,然后将原来的数据表明更改为“项目名称_数据表名”的形式,从而使用原有的数据表信息。 
    这里写图片描述 
      更新后的数据表信息如下: 
    这里写图片描述

    创建超级管理员

    python manage.py createsuperuser
    
    # 按照提示输入用户名和对应的密码就好了邮箱可以留空,用户名和密码必填
    
    # 修改 用户密码可以用:
    python manage.py changepassword username
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    业务逻辑层设计

      接下来实现前端显示数据表信息。 
      业务逻辑层信息如下:

    #业务逻辑层
    from django.http import HttpResponse
    from django.shortcuts import render, render_to_response
    
    #注:每个响应对应一个函数,函数必须返回一个响应
    from blog import models
    
    def blogs(request):
        # return HttpResponse("Hello world ! ")
        # article = models.Blog.objects.get(pk='41078855')
        # return render(request, 'blog/index.html', {"article": articles})
        #获取全部博客信息
    articles = models.Blog.objects.all()
        #返回至前端渲染
    return render_to_response("blog/index.html",locals()) #必须用这个return
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    前端显示

      客户端前端显示页面信息如下:

    index.html
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>CSDN</title>
    </head>
    <body>
    <!--<h1>{{ article.title }}</h1>-->
    <!--<h3>{{ article.viewcnt }}</h3>-->
    <body>
    <p>博文信息</p>
    {% for article in articles %}
    <p>{{article.title}}&nbsp&nbsp&nbsp:&nbsp&nbsp&nbsp{{article.viewcnt}}</p>
    <br>
    {% endfor %}
    </body>
    </body>
    </html>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

      显示效果如下所示(有点丑): 
    这里写图片描述

    管理端设计

      Django另外一个神奇的功能就是自带Admin管理端。而且做的还挺精致。登录Django管理界面之前,需要首先创建超管员,在DOS窗口输入命令

    python manage.py createsuperuser
    • 1

      然后就是设置密码、邮箱等注册信息。创建好超管员身份之后,可在相应的auth_user数据表中查看信息。 
    这里写图片描述 
      其默认使用的英文,若更改为中文,只需修改settings.py在的语言设置,如下:

    LANGUAGE_CODE = 'zh-Hans'
    • 1

      若要在管理端实现数据表信息的管理,只需要在admin.py中添加如下代码即可实现。真可谓言简意赅啊。

    from django.contrib import admin
    
    # Register your models here.
    from blog.models import User,Blog
    
    admin.site.register(User)
    admin.site.register(Blog)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

      登录管理端之后即可看到数据表中的信息。 
    这里写图片描述

    列表项设置

      其中,Blogs与Users分别对应数据库中的blog_blog与blog_user数据表。点击其中一个项目,例如点击Blogs,显示如下页面: 
    这里写图片描述
      这就有问题了,可以看到在管理段博客列表中显示的博客列表名称均为“Blog Object”即所获取到的Blog对象。可否实现博客名称显示呢?答案是肯定的。修改一下blog中的models.py。

    # coding:utf-8
    from django.db import models
    
    # Create your models here.
    class User(models.Model):
        uid = models.CharField(primary_key=True, max_length=30)
        homeurl = models.CharField(max_length=45)
        sumvisit = models.IntegerField()
        credit = models.IntegerField()
        grade = models.IntegerField()
        rank = models.IntegerField()
        fans = models.IntegerField()
        original = models.IntegerField()
        reprint = models.IntegerField()
        trans = models.IntegerField()
        comment = models.IntegerField()
        blogcnt = models.IntegerField()
        # 在Python2中用__unicode__代替__str__
        def __str__(self):
            return self.uid
    
    class Blog(models.Model):
        uid = models.CharField(max_length=30)
        title = models.CharField(max_length=200)
        url = models.CharField(primary_key=True, max_length=30, null=False)
        viewcnt = models.IntegerField()
    
        # 在Python2中用__unicode__代替__str__
        def __str__(self):
            return self.title
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

      添加的重点就是在定义每一个类时同时定义一个python内置的序列化函数str,这样就可以实现列表项目的显示定制功能了。 
    这里写图片描述
    这里写图片描述
      点击每一个列表项可进入博文编辑页面。 
    这里写图片描述

    单页显示条数设置

      在博客列表中,发现单页显示条目为100,未免有点多,可否实现单页显示条数定制化操作呢。在admin.py中输入以下代码即可。

    #设置每页显示条目数
    list_per_page = 30
    • 1
    • 2

      另外,可实现在列表显示与字段相关的其它内容。例如在博客列表中,可附加显示每篇博文的访问量等信息。 
    这里写图片描述
      具体的操作方法是在admin.py中修改代码如下:

    from django.contrib import admin
    
    # Register your models here.
    from blog.models import User,Blog
    
    class ArticleAdmin(admin.ModelAdmin):
        list_display = ('title', 'viewcnt',)
    
    admin.site.register(Blog,ArticleAdmin)
    
    admin.site.register(User)
    # admin.site.register(Blog)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

      其中,list_display 就是来配置要显示的字段的,当然也可以显示非字段内容,或者字段相关的内容,list_display中的参数就是待显示的数据属性。

    搜索功能

      在博客列表页面需要实现搜索功能,同样需要修改admin.py文件。

    from django.contrib import admin
    
    # Register your models here.
    from blog.models import User,Blog
    
    class ArticleAdmin(admin.ModelAdmin):
        list_display = ('title', 'viewcnt',)
        search_fields = ('title',)
    
        #queryset 是默认的结果,search_term 是在后台搜索的关键词
        def get_search_results(self, request, queryset, search_term):
            queryset, use_distinct = super(ArticleAdmin, self).get_search_results(request, queryset, search_term)
            try:
                search_term_as_int = int(search_term)
                queryset |= self.model.objects.filter(age=search_term_as_int)
            except:
                pass
            return queryset, use_distinct
    
    admin.site.register(Blog,ArticleAdmin)
    admin.site.register(User)
    # admin.site.register(Blog)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

      实现效果如下: 
    这里写图片描述

    数据属性名称设置

      在查看博主信息时,看到博主属性名称均为英文,可否实现别名替换? 
    这里写图片描述
      原来在建立数据类时通过verbose_name属性即可设置别名,models.py中代码如下:

    fans = models.IntegerField(verbose_name="粉丝")
    • 1

      替换后的博主信息页面如下: 
    这里写图片描述

    数据类别名设置

      同时,可取数据类的别名。例如,将“User”取别名为“博主”。同样需要在models.py中相应的数据类中添加如下代码:

    class Meta:
        verbose_name = "博文"
        #更改复数显示方式
        verbose_name_plural = "博文"
    • 1
    • 2
    • 3
    • 4

    这里写图片描述
      注:凡是涉及到管理端操作的功能均需在admin.py文件中添加即可。 
      在学习过程中,发觉Django的后台功能实在是太强大了,由于models模块实现了ORM框架。经过一系列操作,可以发现管理端的数据CRUD操作已经完全实现,无需用户书写任何数据库操作代码。省心省力啊!

    附 Django学习资料

      pymysql版本查看命令(请告知我,谢谢~)

    Django基础教程

    Django官网

    菜鸟教程


    Python进阶(二十四)-Python中函数的参数定义和可变参数

      刚学用Python的时候,特别是看一些库的源码时,经常会看到func(*args, **kwargs)这样的函数定义,这个和*让人有点费解。其实只要把函数参数定义搞清楚了,就不难理解了。 
      先说说函数定义,我们都知道,下面的代码定义了一个函数funcA

    def funcA():
      pass
    • 1
    • 2

      显然,函数funcA没有参数。 
      下面这个函数funcB就有两个参数了,

    def funcB(a, b):
      print a
      print b
    • 1
    • 2
    • 3

      调用的时候,我们需要使用函数名,加上圆括号扩起来的参数列表,比如 funcB(100, 99),执行结果是: 
    100 
    99 
      很明显,参数的顺序和个数要和函数定义中一致,如果执行funcB(100),Python会报错的: 
    TypeError: funcB() takes exactly 2 arguments (1 given) 
      我们可以在函数定义中使用参数默认值,比如

    def funcC(a, b=0):
      print a
      print b
    • 1
    • 2
    • 3

      在函数funcC的定义中,参数b有默认值,是一个可选参数,如果我们调用funcC(100),b会自动赋值为0。 
      OK,目前为止,我们要定义一个函数的时候,必须要预先定义这个函数需要多少个参数(或者说可以接受多少个参数)。一般情况下这是没问题的,但是也有在定义函数的时候,不能知道参数个数的情况(想一想C语言里的printf函数),在Python里,带*的参数就是用来接受可变数量参数的。看一个例子