青魔法Python（持续更新）

*跳转到文章结尾* https://www.cnblogs.com/Asterism-2012/p/10047356.html

目录

• 注释的学问

青魔法Python-圣诞快乐

python源于圣诞节，他的创造者是Guido van Rossum（贤者-龟叔）。

• 操作系统:Windows10,Linux Ubuntu

编译器：Pycharm 2018.1.3

常用操作：

• Ctrl+W 选中词组，再次按下则选中句子
• Shift+Enter 将光标直接另起一行
• Ctrl+Shift+上/下键 将选中行上移或下移一行
• Ctrl+Y 删除光标所在行
• Ctrl+Shift+Z 反撤销
• Alt+F12 呼出terminal（终端）,就是底下那个小黑框（目录默认位置为当前项目内根目录下）
• Ctrl+Alt+S 直接弹出设置窗口（setting）
• Ctrl+Shift+U 把所选词组变成大写
• Alt+左键或者右（方向键） 切换文档（子窗口）
• Ctrl+F4 关闭当前文档（子窗口）
• 快速搜索 Ctrl+W & Ctrl+F
• Ctrl+左键或者右键（方向键）跨越空格进行光标移动

在Pycharm中配置为我们的虚拟环境
先后点击：file—settings—Project-----project Interpreter用的时间长了自然就会了。

推荐书单：《python程序设计（第二版）》

• 美国标准信息交换码 ASCII
• UTF-8 “万国码” GB2312 “中文编码”

    ┌────────────────────────────────────────────────────────┐
    │Command Prompt - python                           _ □ x │
    ├────────────────────────────────────────────────────────┤
    │>>> print("Here not a world.")                          │
    │Here not a world.                                       │
    │>>> _                                                   │
    │                                                        │
    │                                                        │
    │                                    by: Asterism2012    |
    └────────────────────────────────────────────────────────┘

知道创宇·任务四象限

第一象限：紧急重要·赶紧搞定
第二象限：重要，不紧急·保持关注
第三象限：紧急不重要·学会拒绝
第四象限：不紧急，不重要·靠自律
——来自知道创宇技能表·受益匪浅

计算机本质：

• 根据指令操作数据的设备。
• 功能性和可编程性。
• 电子计算机、光计算机、超导计算机、量子计算机、生物计算机，这些都是不同材质的计算机。

摩尔定律：

• 英特尔创始人之一的 戈登·摩尔提出
• 单位面积集成电路上可容纳的晶体管数量，大约每两年翻一倍。
• 如果能够里用技术视角和专业精神去审视那些当代重要的预测法则，将使这些技术人才能够“借助规律预测未来”，更好地迎接每一个技术震撼带来的时代变革。

计算机的时代性总结

• 第一阶段：“计算机系统结构阶段”，由1946年开始，持续了35年，直到1981年。

  • 1972年，计算需求催生了高效执行的C语言，通过指优化底层内存使用。
  • 1981年，随着IBM PC为代表的个人计算机推出，计算机走向了大众视野。

• 第二阶段：“计算机网络和视窗阶段”。由1982年开始,直到2007年。持续了25年。

  • 面向全球子网连接的TCP/IP网络协议为标志，互联网时代到来。
  • 计算机围绕网络技术、视窗技术、多媒体技术发展，个人计算机和服务器为主要平台，提供视窗应用和网络服务。
  • 由于网络将不同类型系统互联，催生了具备跨平台功能的语言JAVA。
  • 视窗应用开发需求催生了VC、VB等视窗编程语言。
  • 2007年，美国iphone智能手机推出，计算机技术进入了面向移动网络应用的新阶段。

• 第三阶段：“复杂信息系统阶段”，这个阶段由2008年发展至今。

  • Andriod开源移动操作系统发布为起点，一大批新的概念和技术同时提出并且显著推动了计算技术的更新换代。
  • 包括移动互联网、多核众核、云计算、大数据、可穿戴计算、物联网、互联网加等等。
  • 反映了平台与应用的多样性，也带来了更复杂的安全问题。所有的技术与系统都在不断完善的过程中提供更安全可靠、用户体验更好的功能服务。
  • 人类会逐渐认识到计算机复杂性会达到人类能掌控的边界。
  • 面对复杂的功能性和紧迫的迭代周期，计算机需要更高抽象级别的语言来表达可编程性。（2008年Python3版本，已经成为了这个时代的主流编程语言。）

• 第四阶段：约2035年左右，步入“人工智能阶段”:

  • 随着深度学习、开源硬件、智能机器人、在线搜索引擎、量子计算等计算的逐步发展，未来某个时期会出现人工只能主导的计算的技术阶段。
  • 计算机或许已经没有了独立的载体，它整合一切可用自然资源，接管人类所有非创造性工作。计算机技术将会进入一个未知的新阶段。
  • 计算机功能性和可编程性的发展存在相互促进的关系，计算机长在借助人类智慧不断“进化”。

• 问题：

  • 计算机的定义是什么？它有哪两个显著特点？
  • 请调研并阐述不少于三个计算机领域中类似摩尔定律的预测法则或评估法则。
  • 请列出并阐述不少于五个近十年出现的计算机技术名词。

通用编程语言与专用编程语言

• 机器语言>汇编语言>高级语言
• 尽管科学家做出过很多努力，仍然无法再可预见的未来设计出能完全理解人类语言的计算机。
• 一般来说，通用编程语言比专用编程语言生命力更强。应用范围狭窄的则相反。
• Python、C/C++、C#、Go、Java是通用编程语言；

解释与编译：静态语言与动态语言

Python是一种计算机编程语言。计算机编程语言和我们日常使用的自然语言有所不同，最大的区别就是，自然语言在不同的语境下有不同的理解，而计算机要根据编程语言执行任务，就必须保证编程语言写出的程序决不能有歧义，所以，任何一种编程语言都有自己的一套语法，编译器或者解释器就是负责把符合语法的程序代码转换成CPU能够执行的机器码，然后执行。——廖雪峰

• 静态语言和动态语言各有优缺
• 解释：是将源代码转换成目标代码的同时逐条执行目标代码的过程，速度相较慢。在意解释速度，解释速度和运行速度是相互作用的。
• 编译：将源代码转换成目标代码的过程，可以立即或稍后运行目标代码。不在意编译速度，而在于运行速度。交互运行与文件运行。
• 编译只用执行一次，而解释每次都需要源代码执行。区别相当于翻译资料与同声传译。
• 编译的好处：
  • 同等代码，代码执行更快
  • 已生成了的目标代码不依赖编译器，在同类型操作系统上使用灵活。
  • 代表性语言：C语言，Java语言
• 解释的好处：
  • 解释执行需要保留源代码，程序纠错和维护十分方便。
  • 只要存在编译器，源代码的移植性很好，可以在任何操作系统上运行。
  • 代表性语言：Javascript，PHP，Python

编程

• 编程的目的是：“使用计算机解决问题”。
• 编程训练思维，增进认识
• 带来乐趣，提高效率
• 带来就业机会，程序员是信息时代最重要的岗位之一。
• 计算思维：是区别于以数学为代表的逻辑思维，和物理为代表的证实思维的第三种思维方式。体现了一种抽象交互方式，形式化方法执行的思维模式。
• Python是一个开源语言，其解释器也是开源的，在Python主网站（www.python.org）可以自由下载。
• “Python2已经是遗产，Python3才是现在和未来。”
• 问题：
  • CPU可以直接理解什么样的程序设计语言？
  • 阐述解释和执行的区别与优缺点。
  • 列出三个学习编程的理由。

Python的特点

• 粘性扩展：通过语法扩展接口，可以整合多种编程语言。
• 强制缩进：显著提高了程序的可读性。
• 库类丰富：是真的丰富。
• 跨平台：动态语言都是跨平台的。
• 语法简介：几乎是最简洁的
• 应用广泛：这个是真的广泛。
• 编码支持中文：默认以UTF-8的形式编码

集成开发环境

• Python解释器是一个轻量级小尺寸软件，可以在Python语言主网站下载（大约20~35M）.
• IDLE（自带的集成开发环境）：在开始菜单中搜索即可。（小规模）
• Notepad++:第三方开源记事本增强工具，反正我不用。（小规模）
• sublime：轻量级，全能型集成开发工具。（大小规模）
• Pycharm：这个是全宇宙最强的PythonIDE.（中大规模）

著名的IPO编程方式

• IPO就是(Input-Process-Output):这几乎是统一的基本程序编写方法。更是描述计算问题的方式。
• 输入：
  1. 文件输入
  2. 网络输入
  3. 控制台输入
  4. 交互界面输入
  5. 随即数据输入
  6. 内部参数输入
• 输出：
  1. 控制台输出
  2. 图形输出
  3. 文件输出
  4. 网络输出
  5. 操作系统内部变量输出
• 处理：（Process）:它是程序的灵魂部分，计算问题的处理方法统称为“算法”
• 无输入输出的程序：辅助测试CPU系统性能

定义空字典、空集合、空列表

>>>dic1 = dict()
>>>set1 = set()
>>>lis1 = list()

查看一下类型

>>> type(dic1)
<class 'dict'>
>>> type(lis1)
<class 'list'>
>>> type(set1)
<class 'set'>

返回目录

代码注释方式

代码注释在每一个高级语言中都存在，用于用我们人的语言来为我们写的代码进行标注，提高我们代码的可读性，从而提高我们协同工作的效率，以及降低我们的维护代码的时间成本。

• 单行注释 (#号):

# 我是一段注释，我写的代码意思是这样的

• 多行注释 (''' ''' 三引号):

'''我是多行注释，我是可以换行显示的,
你看，我换行了'''

值得一提的是:多行注释不能放在在列表、集合、字典中:

dic1 = {                   │ lis1 = [              │set1 = {             
    '''Student dict'''     │    '''New List'''     │    '''New set'''        
    'name':'Tom',          │    1,                 │    1,  
    'age':'18'     # No    │    2           # No   │    2,      # No
}                          │]                      │}          

上面这种写法都是错误的。在容器类型的数据类型中，三引号囊括起来的内容会被视为字符串。
但是单行注释是被允许的:

set1 = [
    # New set
    1,2
]

像这样写是可以的，可以自己打印这些变量尝试一下。

别名

• 给导入的标准包起名

  from lxml import etree as e

格式化输出format

• 对字符串的办法，等待更新中
• 图灵测试是人工智能（AI）领域中的重要概念，用于评判机器是否具有人的智能。

引用计数（内存管理）

• Python中没有真正意义上的赋值，也没有指针概念，但是引用计数却是类似指针的概念，系统会自行判断。
• 但是当a = 1;b = 1时，1这个数据所在的内存地址的引用计数为2，名为a,b。但我们del b时，1这个数据的引用计数为1，名为a。

容器数据类型

• 列表与元祖：元祖比列表更快，而且元祖更冷门

关于编码

• 看看廖雪峰老师讲的，非常的透彻易懂。（https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431664106267f12e9bef7ee14cf6a8776a479bdec9b9000）

Python列表的拆解

• join函数将列表元素连接，拆解为字符串

    list = ["M","i","s","s"]

Python 面向对象编程-函数

函数名的本质

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

• max() 函数

max函数max()可以接收任意多个参数，并返回最大的那个：

>>> max(1, 2)
2
>>> max(2, 3, 1, -5)
3

Python 面向对象编程-类

• 正在更新中

Python local()函数用法

• 不作为返回值时候，会自动收集当前作用于内所有局部变量，保存为一个字典。作为返回值时，将函数作用域内所有局部变量以字典形式返回，注意不是键值对。
• 它的兄弟是globals（），法力无限，收集全局变量。

可变字符串与有序字典

• 正在更新中

Python range() 函数用法

• 在python2中,range函数被视为一个列表类型的对象（整数列表）。它会直接输出一个列表，通过更改参数来更改列表的值。
• 它拥有三个参数，依次分别是start（开始）,stop（结束）,step（步长）

range(start,stop,step)

• 参数说明：

start:计数从start开始，默认为0.

stop:计数到stop结束，但不包括stop。

step:计数跨度，默认为1。

• 指定一个参数

  range(8)
  [0, 1, 2, 3, 4, 5, 6, 7]

• 指定两个参数

  range(1,15)
  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

• 指定三个参数

  range(1,100,20)
  [1, 21, 41, 61, 81]

• 支持负参数（越来越小）

  range(-10,-20,-1)
  [-10, -11, -12, -13, -14, -15, -16, -17, -18, -19]

• 倒序

  range(100,19,-5)
  [100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20]

• 指定参数0

  range(0)
  []

• 不指定参数

  range()
  Traceback (most recent call last):
  File “”, line 1, in
  TypeError: range expected at least 1 arguments, got 0

在python3中

• range()被视为一个range类型(范围)的对象,使用type()函数则会看到

  type(range(0))
  

• 使用help()函数则会看到

  Help on class range in module builtins:

  class range(object)
  | range(stop) -> range object
  | range(start, stop[, step]) -> range object

• 在Python3中进行操作,不会返回列表，而是范围对象的内容。

  range(0)
  range(0, 0)

  range(-10,-20,-1)
  range(-10, -20, -1)

  range(1)
  range(0, 1)

  range(10,100,20)
  range(10, 100, 20)

Python深入正则表达式:re模块

• 正则表达式是处理字符串非常强大的工具，拥有自己的语法结构
• 对字符串操作的一种逻辑公式，用来表达对字符串的一种过滤逻辑。
• 并非Python独有,由re模块实现
• 以括号来表示表达式或者来分组
• 回头把表格更新出来，字符串

match函数:

• re.match()
  尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match（）就返回Nonere.match(正则表达式)

search()函数:

• re.search()
  扫描整个字符串、返回第一个匹配到的内容

findall()函数

• re.findall()
  扫描整个字符串，以列表形式返回所有匹配目标（分组），可以理解为一个大的group()

sub()函数

• re.sub() 也可以称作sub方法 ： 用于替换字符串中的指定内容

# 普通替换
>>>result = re.sub("d+","Hi",'123 world')
>>>result
Hi world
'''进阶替换(插入)
包含源字符串本身的内容  规定原生（字符串）的r与Back slash slash（“\”）转义来保证字符串的正确性'''
>>>result = re.sub("(\d+)",r"\1 123","456")
>>>result
456 123

• group()函数:

result.group(x)  #获取正则表达式中第x个括号中的字符串内容

• span函数:

• result.span():

• 贪婪匹配

• 匹配尽可能多的字符，贪婪模式不是很好控制，所以尽可能地使用贪婪模

>>>result = re.match('.*(\d+)',"a123")
>>>result.group(1)
a12

• 非贪婪匹配

>>>result = re.match('.*(\d+)',"a123")
>>>result.group(1)
a

• 匹配尽可能少的字符

• 匹配模式

• re.S 匹配包括换行符在内的所有字符
• 相关概念有常规匹配、泛匹配、匹配目标、贪婪匹配、非贪婪匹配等

• 转义

• 转义符号 “\” : 正则表达式识别不了大多数的特殊符号，所以我们需要把Back slash（反斜杠）来将它转义。

re.match('Hello \$world.','Hello $world.')

• 正则的空白字符\s

数学模块

• 正在更新中

生成式与生成器

深入理解Python生成器（Generator）

• 在Python中，这种一边循环一边计算的机制，称为生成器（Generator）
• 生成器的语法和列表生成式的语法非常相似，几乎让我低估它
• 值得一提的是，它与列表生成式有极大的不同——它具有很多内建方法
• 创建方法的说明：

通过生成式生成

通过函数生成

• 通过生成式生成

  generator = (i for i in range(10))

python2.x中

• 使用类型检查、直接打印、以及帮助帮助信息
• python2.7与python3.5的版本没有区别

类型检查type()

>>> type(generator)

直接打印

>>> generator
 at 0x000002962143B938>

帮助信息

Help on generator object:
 
 = class generator(object)
'''
译文：生成器的帮助信息：
'''

列表生成式

• 也可以叫做列表推导式，帮我们快速生成包含一堆数据的列表

>>>datelis = ["10月{}日".format for i in range(1,32)]
>>>datelis
['10月1日', '10月2日', '10月3日', '10月4日', '10月5日', '10月6日', '10月7日', '10月8日', '10月9日', '10月10日', '10月11日', '10月12日', '10月13日', '10月14日', '10月15日', '10月16日', '10月17日', '10月18日', '10月19日', '10月20日', '10月21日', '10月22日', '10月23日', '10月24日', '10月25日', '10月26日', '10月27日', '10月28日', '10月29日', '10月30日', '10月31日']

字典生成式

• 也可以叫做字典推导式，帮我们快速生成包含一堆数据的字典

>>>dicgene = {i:i for i in range(20)} # 最常规字典推导式
>>>dicgene
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19}
>>>dicgene2 = {index:i for i in enumerate(datelis)} # 常规的 用字典排序列表
>>>dicgene2
{0: '10月1日', 1: '10月2日', 2: '10月3日', 3: '10月4日', 4: '10月5日', 5: '10月6日', 6: '10月7日', 7: '10月8日', 8: '10月9日', 9: '10月10日', 10: '10月11日', 11: '10月12日', 12: '10月13日', 13: '10月14日', 14: '10月15日', 15: '10月16日', 16: '10月17日', 17: '10月18日', 18: '10月19日', 19: '10月20日', 20: '10月21日', 21: '10月22日', 22: '10月23日', 23: '10月24日', 24: '10月25日', 25: '10月26日', 26: '10月27日', 27: '10月28日', 28: '10月29日', 29: '10月30日', 30: '10月31日'}

Python 时间模块 datetime 与 time

• Python版本:python3.6

time

下文的一部分time代表的是datetime类型的对象

• 获取当前时间戳:time.time()

>>>now = time.time()
1540374057.6383073

• 将时间戳转化为time类型元组:time.localtime()

>>>time.localtime(time.time())
time.struct_time(tm_year=2018, tm_mon=10, tm_mday=24, tm_hour=17, tm_min=42, tm_sec=44, tm_wday=2, tm_yday=297, tm_isdst=0)

• 格式化时间元祖为想要的字符串格式

>>>time.strftime("%Y%m%d %H:%M:%S",time.localtime(time.time()))
'20181024 18:00:21'

datetime

下文的一部分datetime 代表的是datetime类型的对象

• 获取当前时间:datetime.now()

  from datetime import datetime
  now = datetime.now()
  print(now)
  2018-10-23 14:36:14.238998

• 获取datetime对象的

datetime.strftime()函数 格式化时间

• 用于格式化datetime类型的对象，返回一个str类型的对象

格式符 说明
%a 星期的英文单词的缩写：如星期一， 则返回 Mon
%A 星期的英文单词的全拼：如星期一，返回 Monday
%b 月份的英文单词的缩写：如一月， 则返回 Jan
%B 月份的引文单词的缩写：如一月， 则返回 January
%c 返回datetime的字符串表示，如03/08/15 23:01:26
%d 返回的是当前时间是当前月的第几天
%f 微秒的表示： 范围: [0,999999]
%H 以24小时制表示当前小时
%I 以12小时制表示当前小时
%j 返回 当天是当年的第几天 范围[001,366]
%m 返回月份 范围[0,12]
%M 返回分钟数 范围 [0,59]
%p 返回是上午还是下午–AM or PM
%S 返回秒数 范围 [0,61]。。。手册说明的
%U 返回当周是当年的第几周 以周日为第一天
%W 返回当周是当年的第几周 以周一为第一天
%w 当天在当周的天数，范围为[0, 6]，6表示星期天
%x 日期的字符串表示 ：03/08/15
%X 时间的字符串表示 ：23:22:08
%y 两个数字表示的年份 15
%Y 四个数字表示的年份 2015
%z 与utc时间的间隔 （如果是本地时间，返回空字符串）
%Z 时区名称（如果是本地时间，返回空字符串）
%% %号本身

---

作者：ShomyLiu
来源：CSDN
原文：https://blog.csdn.net/shomy_liu/article/details/44141483
版权声明：本文为博主原创文章，转载请附上博文链接！

• 使用strftime获取当前时间的日期部分：%x

  from datetime import datetime
  now = datetime.now()
  date = now.strftime("%x")
  ‘10/23/18’

• 获取单独的 年 月 日 部分：datetime.year(),datetime.month(),datetime.day()

  now.year
  2018

  now.month
  10

  now.day
  23

• strftime()可以自定义格式化标准

  now.strftime("%x %X")
  ‘10/23/18 14:52:20’

datetime.strptime()函数 的简单使用

trptime是python datetime库中的函数，用于将一个日期字符串转成datetime日期格式便于后期处理，使用格式为datetime.strptime(date_string, format);格式化(format)使用的参数与上面所讲的strftime()所用的格式化参数是一样的，但是它要与字符串位置一一对应才行。

datetime计算时间差：timedelta()获取过去的时间

timedelta()是datetime()这个超类内置的方法，用于计算过去的时间，返回一个datetime.timedelta()类型的变量。

• 它的常用可选参数(无大小顺序):

1. days(天)
2. weeks(周)
3. minutes(分钟)
4. seconds(秒)
5. hours(小时) PS:除此之外，还有微秒等不常用的参数，如果有更多的学习兴趣或需要，可以直接去源码中翻看

• 导入datetime模块

import datetime

• 获取过去的时间（比如昨天）

>>> loseTime = datetime.timedelta(days=-1)
>>> loseTime
datetime.timedelta(-1)   
# 也可以是一周前,大家举一反三吧
# >>>loseTime = datetime.timedelta(weeks=-1)

• 获取今天、此刻的时间（当前时间）

>>> nowTime = datetime.datetime.now()
>>> nowTime
datetime.datetime(2018, 10, 25, 18, 53, 23, 108495)

• 接下来就可以直接用 loseTime 与 nowTime 进行计算时间差了

>>> that_time = nowTime+loseTime
>>> that_time
datetime.datetime(2018, 10, 24, 18, 53, 23, 108495)     # 时间变化了!看到没？

空值None

• 空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.14159265359

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。(----来自：廖雪峰的官方网站 https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431658624177ea4f8fcb06bc4d0e8aab2fd7aa65dd95000)

Python help()函数

Python 不定长参数

*args和与**kwargs

• 在再谈二者区别前，先要说明的是，语法的区别是* 和** 这两个符号影响，而*args和**kwargs只是约定的非强制性的。也就是说,arg和kwargs这两个名字并不是必须叫这个名字的，而*号是必须有的。

1. *args 和**kwargs可以单独使用
2. *args和**kwargs可以一起使用
3. 一起使用时，*args必须在**kwargs前面
4. *会把list或者tuple分解为一个个参数传递给函数
5. **会把dict转成关键字参数
6. 函数定义和函数调用，可以同时出现* 或者**
7. 出现在函数调用时，一定要注意参数匹配的位置问题
8. *args是不带keyd容器及字符串，**kwargs是带‘key’的容器。
9. *args匹配多个元素，kwargs匹配键值对。

• *args不定长参数案例

  def func(*args):
  print(args)
  print(type(args))
  func(1,2,‘a’)

  output:

  (1, 2, ‘a’)
  

• **kwargs不定长参数案例

  def func(**kwargs):
  print(kwargs)
  print(type(kwargs))
  func(a=1,b=2)

  output:

  {‘a’: 1, ‘b’: 2}
  

• 空的案例

• 拆包

大多数时候，只有一个容器被调用的时候，才能健康地使用*号进行拆包

1. 单*号拆包

   list1 = [1,2,3]
   print(*list1)

2. 双*号拆包

   dict1 = {‘a’:1,‘b’:2}
   def func(a,b):
   print(a,b)
   func(**dict1)

深入浅出Python isinstance()类型检查函数

它用于进行检查某一个变量的类型，但他是type()函数的高阶版本。它拥有更强大的功能，同时也拥有更多的发挥空间。

• 检测单个变量是否为某个类型

  dic1 = {‘a’:‘z’}
  isinstance(dic1,dict) # 这一行是判断dic1变量是否为字典类型
  True

  isinstance(dic1,tuple) # 这一行是判断dic1变量是否为元祖类型
  False

• 检测单个变量是否在所指定的类型范围内

  ‘’‘判断dic1是否是：
  整型、浮点型、字符串、列表、集合、字典、元祖类型中的一种
  ‘’’

  isinstance(dic1,(int,float,str,list,set,dict,tuple))
  True
  ‘’‘判断dic1是否是：
  整型、浮点型、字符串、列表、集合、元祖类型中的一种
  ‘’’

  isinstance(dic1,(int,float,str,list,set,tuple))
  False

• 检测多个变量是否在指定的类型范围内

  dic1 = {‘a’:‘z’}
  dic2 = {‘c’:‘w’}
  isinstance((dic1,dic2),(int,float,str,list,set,dict,tuple))
  True

  isinstance((dic1,dic2),(int,float,str,list,set,tuple))
  False

• 最常用的七种数据类型

  • 整型、浮点型、字符串、列表、集合、字典、元祖
  • int,float,str,list,set,dict,tuple

• 最后值得一提的是，此函数在Python2.x版本和Python3.x版本中，没有版本差异。

Python strip()方法

• Python strip() 方法用于移除字符串头尾指定的字符(默认为空格或换行符)或字符序列。

Python os模块

• 判断文件夹是否存在，不存在则创建

d = '新建文件夹'
if not os.path.exists(d):
    os.mkdir(d)

• 额外知识点: 以字符串形式表示当前文件的绝对路径 __file__

print(__file__)     # 不要以命令的形式执行它，告诉你，执行不了！...刚才不是我

默认是斜杠

• 查看所在的目录 os.path.dirname()

pth = os.path.dirname('C:/Users/DELL/Desktop/test.py')
print(pth)

Console:
C:/Users/DELL/Desktop
 
os.path.dirname 是比较动摇的，它传入的路径字符串里用的是反斜杠，它打印出来就是反斜杠。但是如果传入的路径字符里用的是斜杠，它打印出来的就是斜杠。

• 查看绝对路径 os.path.abspath()

os.path.abspath()

os.path.abspath 是非常坚定的（绝对路径，绝对懂吗？非常绝对）它不论你传入的是路径字符串励用的是反斜杠还是斜杠，他打印出来都是反斜杠~~~~ 额刚才不是我。算了太晚了 该睡了。

• 路径拼接 os.path.join()

os.path.join("C:/User/DELL/Desktop", "test.py")

Python深入迭代器iterator与装饰器

• iter对象是可迭代对象

Python关键字 yield

• 正在更新中

Python文件操作

shelve模块，标准库模块

• shelve存储数据就按照字典的方式存储数据

import shelve

f = shelve.open("shelve_test")
f['info'] = "alex"
f["age"] = [1,34,5,6,33,44]
f["name"] = {"name":"alex","add":"sz"}
f.close()

f = shelve.open("shelve_test")
print(f.get("info"))
print(f.get("age"))
print(f.get("name"))
print(f['info'])
print(f.values())
print(f.items())
print(f.keys())

• shelve也可以用with的方式打开

import shelve
with shelve.open("test_shelve.db") as f:
    f["k1"] = {
        "name":"zhangguojun1",
        "age":12,
        "address":"shenzhen1"
    }
    f["k4"] = ["张国军1","张国军2","张国军3"]
    print(f["k1"]["name"])
    print(f["k4"][0])

Python中的三目运算结构，位运算

• 正在更新中

Python的字典方法

• 字典.get(“键”,异常值)

• dict.items() 以列表返回可便利的（键、值）元祖数据,仍是一个字典对象

  for v,j in dict.items:
  print(v,j)

Python 高阶函数map() 与 zip()

• 正在更新中

Python多线程

• 线程是进程的最小单元
• 进程是一个真正的程序

随机数模块 random

• random.choice() 后面参数跟一个列表，每次会随机选择列表中的一个元素作为返回值

list1 = [1,2,3]
randint = random.choice(list1)

• 指定一个范围，随机抽取一个数：random.randrange()

>>>import random
>>>a = random.randrange(1,999)
>>>a
85

Python的继承与多态

今天先把Python三大特性之一的“封装”特性放在一边。聊一聊继承与多态，简单的来说，继承与多态是体现在面向对象编程中的类编程上。

• 继承:子类与父类的关系通常这样体现：

class Animals(object):      # object 是 Animals的父类
    def run(self,name="Animals"):
        print("%s are running.")
class Cats(Animals):        # Animals是Cats的父类
    def run(self,name="Cats"):
        print("%s are running.")
cats = Cats()   # 实例化Animals 的子类 Cats
cats.run()      # run方法体现继承,console: Cats are running.

• 多态:什么是多态？我们创建一个类的时候其实已经是创建了一种数据类型：

# 这体现了cats的数据类型是Animals
list0727 = []
print(isinstance(list0727,list))    # console:True
print(isinstance(cats,Cats))    # console:True
print(isinstance(cats,Animals))     # console:True

• 对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法

def run_twice(animals):     # 这里的形参名称是自己定义的，可以改成别的名称，但是这里只是为了方便我们记忆。
    animals.run()   
run_twice(Cats())     # console: Cats is running.    
'''接下来可以体现 动态语言 的 鸭子类型：
它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
'''
class People(objects):
    def run(self):
        print("People are running.")
run_twice(People())
'''在静态语言中(例如)，如果要传入animals类型的参数,则传入的对象必须是animals类型 或者是它的子类，否则，将无法调用run（）方法。
但是，对于Python这样的动态语言来叔，则不需要传入Animal类型。我们只需要保证传入的对象有一个run（）方法就够了。
'''

这一小节来自于“廖雪峰的官方网站” https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431865288798deef438d865e4c2985acff7e9fad15e3000

经典算法

• 水仙花数
• 99乘法表
• 判断闰年
• 正在更新中
• 百钱白鸡
• 二分查找
• 选择排序
• 冒泡排序
• 正在更新中

深浅复制

• 正在更新中

MySqlDB数据库交互

• Python版本:Python3.5

• pymysql 是一个第三方包 pip install pymysql

• 建立数据库连接，并获取对象

  db = pymysql.connect(user=‘root’,password=‘mysql’,db=‘233’,charset=‘utf8’)

• 建立游标

  cursor = db.cursor()

• 编写sql语句

  以下六个变量都是初始化过的

  sql = ‘insert into ding(title,author,new_chapter,w_num,u_time,status)value("{}","{}","{}","{}","{}","{}")’.format(title,author,new_chapter,w_num,u_time,status)

• 使用游标执行语句

  cursor.excute(sql)

• 提交事务

  db.commit()

MongoDB数据库交互

• Python版本:python3.5

• 确保pymsql的安装 pip install

• 建立连接并且获取到连接对象

  myconn = pymongo.MongoClient(“localhost”,27017)

• 生成数据库

  mydb = myconn[“LagouWeb”]

• 生成集合

  mycoll = mydb[“zhaopin”]

• 将文档(必须是字典类型的数据)存入集合

  info = {key:value}
  mycoll.insert(info)

##字符串方法

• split() 切割

str.split(" ",3) 表示以空格来切，字符串，将其切成列表，只切前三个(第二个参数是可选的，就是可以不填写)

• startswith() 与 endswith() 判断字符串开头 与 判断字符串结尾

str.startswith(" ") 表示检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。（str.startswith(str, beg=0,end=len(string)）

虚拟环境的使用

操作系统：windows10

为什么使用虚拟环境?搭建独立python运行环境。防止相同包的不同版本之间相互冲突和覆盖。

virtualenv的使用：

virtualenv是是python的虚拟环境管理器

1. 创建文件总署,并且移动进去

md virtual_now(会在当前目录创建一个名为‘virtual_now’的子文件夹)
cd virtual_now

2. 使用python安装virtualenv

pip install virtualenv(pip是python的包管理工具)

3. 使用virtualenv命令创建虚拟环境

virtualenv --no-site-packages newenv
(像创建文件夹一样创建了一个环境目录‘newenv’)
#关于--no-site-pakeages参数#：它不会复制已存在的第三方包

使用指定Python解释器的方式创建环境:

virtualenv -p c:\python27\python.exe venv

4. 在命令行下进入Scripts的目录下，进入虚拟环境。进入Scripts后输入activate回车即可。

cd Scripts
activate(激活环境)

5. 然后就可以安装我们所需要的包，比如Django1.11.1

pip install django==1.11.1

6. 查看python版本：注意，这种虚拟环境是使用我们的默认解释器创建的，我的默认解释器是python3.5。

python

7.退出虚拟环境

deactivate

virtualenvwrapper 的使用：

virtualenvwrapper可以简化virtualenv包的操作

1. 安装virtualenvwrapper-win(它是windows下的虚拟环境管理器)

pip install virtualenvwrapper-win

2. 查看安装的所有虚拟环境

C:\workon
Pass a name to activate one of the following virtualenvs:
==============================================================================

3. 创建虚拟环境管理目录(虚拟环境都会进入这个目录中)：

设置系统环境变量(WIN10的话直接新建就可以)，后面添加自己想要的虚拟环境目录位置。

┌────────────────────────────────────────────────────────┐
│ Edit system variables                            _ □ x │
├────────────────────────────────────────────────────────┤
│                   ┌──────────────────────────────────┐ │
│ Variable Name(N)  │  WORKON_HOME                     │ │
│                   └──────────────────────────────────┘ │
│                   ┌──────────────────────────────────┐ │
│ Variable Value(V) │  E:\virtual_now                  │ │
│                   └──────────────────────────────────┘ │
│                             ┌────────┐  ┌────────┐     │
│                             │   OK   │  │ Cancel │     │
│                             └────────┘  └────────┘     │
└────────────────────────────────────────────────────────┘  by: Asterism

4. 创建环境(以Python3版本的Django2为例,名称自定义)

C:\mkvirtualenv Py3_django2

以指定python3环境的方式建立虚拟环境

C:\mkvirtualenv -p python3 venv 

5. 使用虚拟环境（进入虚拟环境

C:\workon Py3_django2

6. 列出所有环境,与workon不同的是，它会显示环境所在的系统路径

C:\lsvirtualenv

• 退出虚拟环境（注销虚拟环境）

C:\deactivate

• 移动到当前环境的site-packages目录

C:\cdsitepackages 

• 列出当前环境中site-packages内容

C:\lssitepackages 

• 清除环境内所有第三方包

C:\wipeenv 

• 删除指定环境

C:\rmvirtualenv Py3_django2

• cpvirtualenv 复制环境

C:\cpvirtualenv Py3_django2

• setvirtualenvproject 绑定现存的项目和环境

C:\> setvirtualenvproject Py3_django2

---

部分参考：
作者：lliuz
来源：CSDN
原文：https://blog.csdn.net/melpancake/article/details/54578711
版权声明：本文为博主原创文章，转载请附上博文链接！

• virtualenvwrapper --help 的翻译

 virtualenvwrapper-win is a port of Dough Hellman’s virtualenvwrapper to Windows
 batch scripts.
    (virtualenvwrapper-win是Dough Hellman开发的 windows操作系统的
批处理脚本。)
 Commands available:
    (可用命令:)
   add2virtualenv: add directory to the import path

   cdproject: change directory to the active project

   cdsitepackages: change to the site-packages directory

   cdvirtualenv: change to the $VIRTUAL_ENV directory

   lssitepackages: list contents of the site-packages directory

   lsvirtualenv: list virtualenvs

   mkproject: create a new project directory and its associated virtualenv

   mkvirtualenv: Create a new virtualenv in $WORKON_HOME

   rmvirtualenv: Remove a virtualenv

   setprojectdir: associate a project directory with a virtualenv
   toggleglobalsitepackages: turn access to global site-packages on/off

   virtualenvwrapper: show this help message

   whereis: return full path to executable on path.

   workon: list or change working virtualenvs

虚拟环境的使用

操作系统：Linux

• 目录：/home/.virtualenvs 可以移动进去进行修改数据
• 安装虚拟环境:

sudo pip install virtualenv (安装)
sudo pip install virtualenvwrapper (打包安装)

• 创建虚拟环境:

(python2） mkvirtualenv [环境名]
(python3） mkvirtualenv -p python3 [环境名]

• 查询和使用虚拟环境:

workon  （查询）
workon [虚拟环境名] （使用）
deactivate (退出虚拟环境)
rmvirtualenv （删除虚拟环境）

• 查询环境变量路径

which python
where python

pip包的使用：

• 安装指定包

pip install 包名
pip install 包名==版本号

• 删除扩展包(卸载扩展包)

pip uninstall 扩展报名

• 使用pip包管理器查看扩展包（第三方）

pip freeze
pip freeze >

• 展示所有包:pip list（包括标准包）

pip list

• 导出所有包内容，包重新定向到文档 freeze >

pip freeze > requirements.txt

• 安装指定文档中的依赖包

pip install -r requirements.txt

• 可以直接使用镜像源(地址)，加-i指定地址
  很多时候，pip默认指向的国外源不稳定，所以我们可以使用国内源进行安装很多扩展包

国内源：
阿里云 http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣(douban) http://pypi.douban.com/simple/
清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/

pip install -i http://pypi.douban.com/simple 模块名

如果出现不信任的报错，则需要在命令后加上：

pip install -i http://pypi.douban.com/simple --trusted-host pypi.douban.com 模块名

• 更新pip版本
  python -m pip install --upgrade pip

#!/usr/bin/env python与#!/usr/bin/python的区别(/bin/可执行文件)

脚本语言的第一行，++目的就是指出++，你想要你的这个++文件中的代码用什么可执行程序去运行++它，#!/usr/bin/python是告诉操作系统执行这个脚本的时候，调用/usr/bin下的python解释器；
#!/usr/bin/env python这种用法是为了++防止操作系统用户没有将python装在默认的/usr/bin路径++里。当系统看到这一行的时候，首先会到env设置里查找python的安装路径，再调用对应路径下的解释器程序完成操作。
(#!/usr/bin/python相当于写死了python路径;
#!/usr/bin/env python会去环境设置寻找python目录：推荐这种写法。）

尊重版权：转载自博客园 https://www.cnblogs.com/walk1314/p/7076853.html （Mr_Walker），如需转载请注明出处，尊重他人的劳动成果，也尊重你自己。

Lambda 匿名函数

• 一个语法：在Python中，lambda的语法是唯一的。其形式如下：

  lambda argument_list: expression

  lambda是Python预留的关键字，argument_list和expression由用户自定义

• 这里的argument_list是参数列表。它的结构与Python中函数(function)的参数列表是一样的。具体来说，argument_list可以有非常多的形式。例如

  • a, b
  • a=1, b=2
  • *args
  • **kwargs
  • a, b=1, *args
  • 空
    …

• 这里的expression是一个关于参数的表达式。表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的。以下都是合法的表达式：expression：不能包含分支或循环（但允许条件表达式），也不能包含return（或yield）函数。如果为元组，则应用圆括号将其包含起来。

  • 1
  • None
  • a + b
  • sum(a)
  • 1 if a >10 else 0
    …

• 三个特性lambda函数有如下特性：

  • lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。
  • lambda函数有输入和输出：输入是传入到参数列表argument_list的值，输出是根据表达式expression计算得到的值。
  • lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。

• 四个用法

1. Lambda本质上的用法只有一个，那就是定义一个Lamda函数，但是在实践使用的过程中还可以分为几种扩展用法：
2. 用来屏蔽函数或标准库函数：

time.sleep=lambda x:None
'''后续代码中调用time库的sleep函数将不会执行原有的功能。例如，执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。括号中的x代表这个标准库函数的原本形参。'''

3. 闭包：将lambda函数作为其他函数的返回值，返回给调用者。

return lambda x,y:x+y
'''。这时，lambda函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或者内部函数。对应的，将包含嵌套函数的函数称之为外部函数。内部函数能够访问外部函数的局部变量，这个特性是闭包(Closure)编程的基础，在这里我们不展开。'''

4. 将lambda函数作为参数传递给其他函数,最基本的就是Print()函数。部分Python内置函数接收函数作为参数。典型的此类内置函数有这些。

filter(lambda x: x % 3 == 0, [1, 2, 3])
 
sorted函数。此时lambda函数用于指定对列表中所有元素进行排序的准则。例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。
 
map函数。此时lambda函数用于指定对列表中每一个元素的共同操作。例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1，其结果[2, 3, 4]。
 
reduce函数。此时lambda函数用于指定列表中两两相邻元素的结合条件。例如reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来，其结果是'1, 2, 3, 4, 5, 6, 7, 8, 9'。

• 一个争议

事实上，关于lambda在Python社区是存在争议的。Python程序员对于到底要不要使用lambda意见不一致。

---

作者：独孤球是
来源：CSDN
原文：https://blog.csdn.net/zjuxsl/article/details/79437563?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文链接！

• 我自己写的一个 求平方的匿名函数

>>>pf = lambda x:x**2
>>>pf(1)
1
>>>pf(2)
4

• 求几个数之和的匿名函数

  f = lambda *args:sum(args)
  f(1,2,3,4)
  10

内置函数

• filter()

函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

• filter(function, iterable)

  def is_odd(n):
  return n % 2 == 1
  newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
  print(newlist)

• print()

print()函数接收很多参数，我们需要主要学习的是sep,end,file这个三个参数;可以在源码中看到，他们的默认值是：sep=' ', end='\n', file=None
sep是改变多个输出内容的分隔符，end是改变输出末尾的换行，file则是输出到一个文件
- file参数
# file参数指向的应该是一个文件对象 with open("new.txt","a+") as f: print("Print over.",file=f) # 这样可以将输出内容打印到一个文件中去

• enumrate()

遍历索引：当遍历一个可迭代对象时候，使用此函数可以提供遍历索引。

>>>for index,name in all_name:
...    print(index,name)
1 tom
2 lily
3 alice
...

python os模块

在python编程时操作文件与目录、以及使用shell命令，就需要os模块的支持。os模块包含普遍的操作系统功能，与具体的平台无关。

培养个人代码风格

• 显式释放自己申请的内存资源是一个卓越的习惯。使用del命令来显式删除对象。
  • del 对象

生成六位验证码

sms_code = "%06d" % random.randint    # 生成验证码

django建立redis数据库连接

• views视图

from django_redis import get_redis_connection
redis_conn = get_redis_connection

• dev(setting.py)配置

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/0",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    },
    "session": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    },
    # 图片验证码的redis
    "verify_codes": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/2",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }

}
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "session"

使用redis管道

# 使用redis的pipeline管道一次执行多个命令
pl = redis_conn.pipeline()
# 保存短信验证码
redis_conn.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPRIES, sms_code)

# 保存当前的时间，只是做个记录而已，60s过期
redis_conn.setex('sms_interval', constants.SMS_CODE_REDIS_INTERVAL, datetime.now())
# 让管道执行命令
pl.execute()

数学变量在这里

• 平均数 mea
• 个位数 unit
• 十位数 ten
• 百位数 hund
• 千位数 thou
• 个数 num
• 分母 den
• 分子 nume0

itsdangerous签名模块

itsdangerous(它是危险的)，顾名思义。以下是来自官方网站的介绍。

• 安装

(Py_Django2.0.6) C:\Users\DELL\Desktop\meiduo-email>pip install itsdangerous

• Signer方法

>>> from itsdangerous import Signer     # 导入Signer方法
>>> s = Signer('secret-key')    # 实例化一个以‘secret-key’为密钥的对象
>>> s.sign('my string')     # 使用这个对象含有的密钥 使用字符串生成签名
b'my string.wh6tMHxLgJqB6oY1uT73iMlyrOA'    # 这一步是可逆的
>>> s.unsign('my string.wh6tMHxLgJqB6oY1uT73iMlyrOA')       # 对这个签名进行转码
b'my string'

• TimedJSONWebSignatureSerializer模块

它继承了JSONWebSignatureSerializer类。

首先我们来看生成令牌和解码令牌的代码：
from itsdangerous import TimedJSONWebSignatureSerializer
    s = TimedJSONWebSignatureSerializer(app.config['SECRET_KEY'], expires_in=3600)
    token = s.dumps({'confirm': 23})
    data = s.loads(token)
--------------------- 
作者：她叫徐晓jie 
来源：CSDN 
原文：https://blog.csdn.net/sinat_34927324/article/details/78378911 
版权声明：本文为博主原创文章，转载请附上博文链接！

我们老师的老大使用这个模块生成了token，并且对它进行了解密。

def generate_email_verify_url(self):
    serializer = TJWSSerializer(settings.SECRET_KEY, expires_in=24*60*60)       # 生成token
    data = {'user_id': self.id, 'email': self.email}
    token = serializer.dumps(data).decode()
    verify_url = 'http://127.0.0.1:8080/success_verify_email.html?token=' + token
    return verify_url

解密。

@staticmethod  # 类可以直接调用
    def check_email_verify_token(token):
        """
        检查验证邮件的token
        """
        serializer = TJWSSerializer(settings.SECRET_KEY, expires_in=300)
        try:
            data = serializer.loads(token)      # 对token进行解码
        except BadData:
            return None
        else:
            email = data.get('email')
            user_id = data.get('user_id')
            User.objects.filter(id=user_id, email=email).update(email_active=True)
            return True

Pythonic 与 Python之禅

• Pythonic

英[paɪ’θɒnɪk] 美[paɪ’θɒnɪk]
adj. 神谕的，预言的，大蟒似的;
Pythoner们常说，写代码要写得Pythonic一些，那么什么是Pythonic呢？Pythonic其实是一种编码风格。瞧瞧这翻译，够酷炫的。神谕的，什么是神谕？那是神说的话，神说话，一向简单简短又充满哲理。这就是我们写Python程序要达成的目标，Python代码应该写的简短又精彩。

• Python之禅

• Python之禅是Python的一个彩蛋，在Python交互式解释器中输入import this就会显示Tim Peters的The Zen of python
• 原文

>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

• 翻译

Python之禅 by Tim Peters
 
优美胜于丑陋（Python 以编写优美的代码为目标）
明了胜于晦涩（优美的代码应当是明了的，命名规范，风格相似）
简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现）
复杂胜于凌乱（如果复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁）
扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套）
间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题）
可读性很重要（优美的代码是可读的）
即便假借特例的实用性之名，也不可违背这些规则（这些规则至高无上）
不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写 except:pass 风格的代码）
当存在多种可能，不要尝试去猜测
而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法）
虽然这并不容易，因为你不是 Python 之父（这里的 Dutch 是指 Guido ）
做也许好过不做，但不假思索就动手还不如不做（动手之前要细思量）
如果你无法向人描述你的方案，那肯定不是一个好方案；反之亦然（方案测评标准）
命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召）
 
出自：意气相许的许
链接：https://www.jianshu.com/p/0e1f38c2c122
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

• Python中的一些黑科技

*返回目录再看看*