青魔法Python(持续更新)

时间 2019-11-08

标签 python 持续更新栏目 Python 繁體版

原文原文链接

青魔法Python-圣诞快乐

魏泯html

童心未泯就是，又是一个飞雪连天日，我团个雪球踢着走。python

*跳转到文章结尾* mysql

青魔法Python-圣诞快乐

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

操做系统:Windows10, Linux-Ubuntu

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

安装Python

在进行Python的开发以前，首先要保证你的电脑上已经安装了Python，但不要求必定是最新版本的。mongodb

Python解释器是一个轻量级小尺寸软件，能够在Python语言主网站下载（大约20~35M）.
Windows下直接进行傻瓜式安装
Mac下能够参照这篇文章：点击连接打开
Ubuntu系统下一般自带python

集成开发环境

IDLE（自带的集成开发环境）：在开始菜单中搜索便可。（小规模）
Notepad++:第三方开源记事本加强工具，反正我不用。（小规模）
sublime：轻量级，全能型集成开发工具。（大小规模）
Pycharm：这个是全宇宙最强的PythonIDE.（中大规模）

*返回目录再看看*shell

Pycharm的快捷操做参考

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编程知识

（参考自《Python程序设计（第二版）》嵩天）

计算机本质：

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

摩尔定律：

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

计算机的时代性总结

第一阶段：“计算机系统结构阶段”，由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的特色

粘性扩展：经过语法扩展接口，能够整合多种编程语言。
强制缩进：显著提升了程序的可读性。

while True:    #在Python中，使用缩进来表示层级关系，这是很酷的一个功能
    print("I miss you.")

库类丰富：是真的丰富。
跨平台：动态语言都是跨平台的。
语法简介：几乎是最简洁的
应用普遍：这个是真的普遍。
编码支持中文：默认以UTF-8的形式编码

著名的IPO编程方式

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

代码注释的学问

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

单行注释 (#号):

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

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

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

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

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

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

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

查看一下类型

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

返回目录

Python的内存管理

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

容器数据类型
列表与元祖：元祖比列表更快

编码

美国标准信息交换码 ASCII
UTF-8 "万国码" GB2312 "中文编码"
看看廖雪峰老师讲的，很是的透彻易懂。（https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431664106267f12e9bef7ee14cf6a8776a479bdec9b9000）

格式化输出format

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

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))
<class 'range'>
使用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模块实现
以括号来表示表达式或者来分组
回头把表格更新出来，字符串

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)
<class 'generator'>

直接打印

>>> generator
<generator object <genexpr> at 0x000002962143B938>

帮助信息

Help on generator object:
 
<genexpr> = 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()类型的变量。

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

days(天)
weeks(周)
minutes(分钟)
seconds(秒)
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这两个名字并非必须叫这个名字的，而*号是必须有的。

*args 和**kwargs能够单独使用
*args和**kwargs能够一块儿使用
一块儿使用时，*args必须在**kwargs前面
*会把list或者tuple分解为一个个参数传递给函数
**会把dict转成关键字参数
函数定义和函数调用，能够同时出现* 或者**
出如今函数调用时，必定要注意参数匹配的位置问题
*args是不带keyd容器及字符串，**kwargs是带‘key’的容器。
*args匹配多个元素，kwargs匹配键值对。

*args不定长参数案例

def func(*args):
print(args)
print(type(args))
func(1,2,'a')
# output:
(1, 2, 'a')
<class 'tuple'>
**kwargs不定长参数案例

def func(**kwargs):
print(kwargs)
print(type(kwargs))
func(a=1,b=2)
# output:
{'a': 1, 'b': 2}
<class 'dict'>
空的案例
拆包
大多数时候，只有一个容器被调用的时候，才能健康地使用*号进行拆包

单*号拆包

list1 = [1,2,3]
print(*list1)
双*号拆包

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的虚拟环境管理器

建立文件总署,而且移动进去

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

使用python安装virtualenv

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

使用virtualenv命令建立虚拟环境

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

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

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

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

cd Scripts
activate(激活环境)

而后就能够安装咱们所须要的包，好比Django1.11.1

pip install django==1.11.1

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

python

7.退出虚拟环境

deactivate

virtualenvwrapper 的使用：

virtualenvwrapper能够简化virtualenv包的操做

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

pip install virtualenvwrapper-win

查看安装的全部虚拟环境

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

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

设置系统环境变量(WIN10的话直接新建就能够)，后面添加本身想要的虚拟环境目录位置。

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

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

C:\mkvirtualenv Py3_django2

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

C:\mkvirtualenv -p python3 venv

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

C:\workon Py3_django2

列出全部环境,与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函数不可能完成复杂的逻辑，只能完成很是简单的功能。因为其实现的功能一目了然，甚至不须要专门的名字来讲明。
四个用法

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

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

闭包：将lambda函数做为其余函数的返回值，返回给调用者。

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

将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’为密钥的<class 'itsdangerous.signer.Signer'>对象
>>> 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中的一些黑科技

知道创宇·任务四象限

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

青魔法Python(持续更新)

青魔法Python-圣诞快乐

目录

青魔法Python-圣诞快乐

安装Python

集成开发环境

Pycharm的快捷操做参考

计算机基础知识与Python编程知识

计算机本质：

摩尔定律：

计算机的时代性总结

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

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

学习编程的目的

Python的特色

著名的IPO编程方式

代码注释的学问

别名

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

Python的内存管理

容器数据类型

编码

格式化输出format

Python列表的拆解

Python 面向对象编程-函数

函数名的本质

Python 面向对象编程-类

Python local()函数用法

可变字符串与有序字典

Python range() 函数用法

在python3中

字符串

字符串处理：正则表达式

match函数:

search()函数:

findall()函数

sub()函数

group()函数:

span函数:

贪婪匹配

非贪婪匹配

匹配模式

转义

数学模块

生成式与生成器

深刻理解Python生成器（Generator）

python2.x中

列表生成式

字典生成式

Python 时间模块 datetime 与 time

time

datetime

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

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

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

空值None

常量

Python help()函数

Python 不定长参数

拆包

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

Python strip()方法

Python os模块

Python深刻迭代器iterator与装饰器

Python关键字 yield

Python文件操做

shelve模块，标准库模块

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

Python的字典方法

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

Python多线程

随机数模块 random

Python的继承与多态

经典算法

深浅复制

MySqlDB数据库交互

MongoDB数据库交互

字符串方法

虚拟环境的使用

virtualenv的使用：

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

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