python整理
目录html
- 说明
- 代码精简&优化
- 框架-django
- 安全
- 基础
- 编写完美的 Python 命令行程序
- 虚拟环境使用
- 虚拟环境操做
- Python错误：安装cv2失败
- Python错误：IndentationError: unindent does not match any outer indentation level
- Python错误：控制台输出InsecureRequestWarning的问题
- requests取消SSL认证后消除warning信息
- 限制实例属性,使用__slots__变量,对继承的子类不起做用
- GUI
- 类/面向对象OOP
- 模块
- 偏函数partial
- 生成器
- 列表生成式
- 切片
- requests
- 文件读写
- 字典处理
- 列表排序
- random
- json模块
- 编译pyc文件
- @staticmethod和@classmethod的异同
- 库的安装
- pep8规范
- PyCharm选择性忽略PEP8代码风格警告信息
- python目录介绍
- python经常使用库
- py命名规范
- 输出彩色字符
- format函数
- bs4模块
- python代码简单性能调优
- python中os._exit()和 sys.exit(), exit(0)和exit(1) 的用法和区别
- 安装pygame
- Python错误：pip install SSLError【There was a problem confirming the ssl certificate】
- Python错误：AttributeError: module 'enum' has no attribute 'IntFlag'
- python打包exe
- pycharm 快捷键
- pycharm设置
- python导出已安装库方法
- python中子类初始化使用super报错
- time模块
- snownlp库
- 内置模块
- os模块
- sys模块
- 日历模块
- 获取当前函数名
- 文件操做
- 输出不换行
- 读取键盘输入
- 并发问题
- web应用：关于wsgi、框架、模板
- 如何使用Headless Chrome
- 其余
目录前端
说明
侵删
代码精简&优化
函数式编程-高阶函数
https://www.jianshu.com/p/a305c66c4f5apython
函数式编程-链式调用
https://www.jianshu.com/p/a6dc94930dcdmysql
list变为字符串
def list_demo():
list_tmp = ['1', '2', '4', '5']
pprint(''.join(list_tmp)) # 将list变为字符串
enumerate()函数
def enumerate_demo():
"""
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，通常用在 for 循环当中。
Python 2.3. 以上版本可用，2.6 添加 start 参数。
语法
enumerate(sequence, [start=0])
参数
sequence –可迭代对象。
start -- 下标起始位置。
返回值
enumerate(枚举) 对象。
"""
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
print(list(enumerate(seasons, start=1))) # 小标从 1 开始)
# for循环中的使用
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, seq[i])
zip()函数
def zip_demo():
"""
zip() 函数用于将可迭代的对象做为参数，将对象中对应的元素打包成一个个元组，而后返回由这些元组组成的列表。
若是各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操做符，能够将元组解压为列表
"""
a, b, c = [1, 2, 3], [4, 5, 6], [4, 5, 6, 7, 8]
print(zip(a, b)) # 打包为元组的列表
print(zip(a, c)) # 元素个数与最短的列表一致
# print(zip(*zipped)) # 与 zip 相反，可理解为解压，返回二维矩阵式
map()函数
def f(x):
"""有函数f(x)=x^2,把这个函数做用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上"""
return x * x
def map_demo():
# map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次做用到序列的每一个元素，并把结果做为新的list返回。
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(map(f, list1))
reduce()函数
def add(x, y):
return x + y
def reduce_demo():
"""
reduce把一个函数做用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素作累积计算
对一个序列求和，就能够用reduce实现"""
list2 = [1, 3, 5, 7, 9]
print(functools.reduce(add, list2))
# 固然求和运算能够直接用Python内建函数sum()，不必动用reduce。可是若是要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就能够派上用场
def fn(x, y):
return x * 10 + y
def sum_demo():
list2 = [1, 3, 5, 7, 9]
print(functools.reduce(fn, list2))
# 上面例子自己没大用处，可是，若是考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，就能够写出把str转换为int的函数：
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return functools.reduce(fn, map(char2num, s))
# 上面简化/使用lambda
def str2int_lambda(s):
return functools.reduce(lambda x, y: x * 10 + y, map(char2num, s))
filter()函数
def is_odd(n):
return n % 2 == 1
def filter_demo():
"""
接收一个函数和一个序列。把传入的函数依次做用于每一个元素，而后根据返回值是True仍是False决定保留仍是丢弃该元素。
在一个list中，删掉偶数，只保留奇数
"""
print(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
sorted()函数
def demo_sorted():
"""
Python内置的sorted()函数就能够对list进行排序
一般规定对于两个元素x和y，如认为x < y，则返回-1，如认为x == y，则返回0，若是认为x > y，则返回1
:return:
"""
print(sorted([36, 5, 12, 9, 21])) # 结果： [5, 9, 12, 21, 36]
# 此外，能够接收一个比较函数来实现自定义的排序。
def reversed_cmp(x, y): # 比较函数
"""
:param x: x
:param y: y
:return:
"""
if x > y:
return -1
if x < y:
return 1
return 0
返回函数/闭包结构
def calc_sum(*args):
ax = 0
for n in args:
ax = ax + n
return ax
def lazy_sum(*args):
"""
返回函数能够延迟计算
内部函数能够引用外部函数的参数和局部变量
每次调用外部函数都会返回一个新的函数，即便传入相同的参数
闭包
返回的函数并无马上执行，而是直到调用了才执行
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
若是必定要引用循环变量怎么办？方法是再建立一个函数，用该函数的参数绑定循环变量当前的值，
不管该循环变量后续如何更改，已绑定到函数参数的值不变
:param args:
:return:
"""
def demo_sum():
ax = 0
for n in args:
ax = ax + n
return ax
return demo_sum
匿名函数lambda
demo_lambda = lambda x, y, z: x + y + z
装饰器/decorator
"""
装饰器
好比在函数调用先后自动打印日志，但又不但愿修改now()函数的定义，
这种在代码运行期间动态增长功能的方式，称之为“装饰器”（Decorator）。
借助Python的@语法，把decorator置于函数的定义处
Python的decorator能够用函数实现，也能够用类实现
decorator能够加强函数的功能，定义起来虽然有点复杂，但使用起来很是灵活和方便。
参考：
# 不带参数的decorator
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print 'call %s():' % func.__name__
return func(*args, **kw)
return wrapper
# 带参数的decorator
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print '%s %s():' % (text, func.__name__)
return func(*args, **kw)
return wrapper
return decorator
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~↓
# 实例001
# 加强now函数的功能，在函数调用先后自动打印日志
def log(func):
def wrapper(*args, **kw):
print('call func: %s()' % func.__name__)
return func(*args, **kw)
return wrapper
@log
def now():
print('2013-12-25')
# 若是decorator自己须要传入参数，那就须要编写一个返回decorator的高阶函数，写出来会更复杂。
# 好比，要自定义log的文本
# 带参数的decorator
def log_01(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__), end='')
return func(*args, **kw)
return wrapper
return decorator
@log_01('带参装饰器 装饰函数')
def now_01():
print('2013-12-25')
# __________________________________↑
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~↓
# 实例002
# 在函数调用先后打印信息
class LogPlus:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print('start call {}'.format(self.func.__name__))
self.func(*args, **kwargs)
print('end call {}'.format(self.func.__name__))
@LogPlus
def demo_decorator_hello():
print('2017-11-06')
# __________________________________↑
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~↓
# 实例003
# 实现一个装饰器，能够传参和不传参
def log(something):
# if callable, this is a decorator, shape of @log
if callable(something):
func = something
@functools.wraps(func)
def wrapper(*args, **kwargs):
print('call {}'.format(func.__name__))
func(*args, **kwargs)
return wrapper
elif isinstance(something, str):
# else, this is a decorator function, shape of @log(something)
def decorator(func_tmp):
@functools.wraps(func_tmp)
def wrapper_tmp(*args, **kwargs):
print('{} {}'.format(something, func_tmp.__name__))
func_tmp(*args, **kwargs)
return wrapper_tmp
return decorator
else:
raise AttributeError("Attribute other than str is not supported")
@log
def demo_decorator_f1():
pass
@log('execute')
def demo_decorator_f2():
pass
# __________________________________↑
"""
获取父节点下多个子节点内容
def demo_get_all_text(self):
texts_xpath = '//div[@class="text"]'
elements = self.output(self.start_url, texts_xpath)
print(elements)
result = []
for item in elements:
result.append(''.jion(item.xpath('p/text()')))
for item in result:
print(item)
return result
# 或者直接以下：
def get_all_text(self):
texts_xpath = '//div[@class="text"]'
elements = self.output(self.start_url, texts_xpath)
result = [''.jion(item.xpath('p/text()')) for item in elements]
return result
框架-django
Python错误：django项目没法链接远程mysql的问题
https://www.cnblogs.com/zengjielin/p/8582826.htmllinux
Django 设置远程访问
setting.py–>ALLOWED_HOSTS = [“*”] //修改配置 python3 manage.py runserver 0.0.0.0:8000 //启动
安全
python提取强弱密码
https://github.com/r35tart/RW_Passwordgit
python混淆脚本打包免杀
https://mp.weixin.qq.com/s?__biz=MzUyMTk5OTUzOQ==&mid=2247483689&idx=1&sn=4474964136fc632647c40884e3f15963&chksm=f9d3c4f5cea44de34e0f2e0fba257cc75ccbf5f934d002ee14fb7237db6c3af10c1f79b53a67&mpshare=1&scene=1&srcid=&key=2cbf6115a3e77fb037c18b51d844f974a7221519d3346d7d73cf29d2ca56baaa6fc853b392cdc0c2e3eb15bd2974211a29fc2e3d9c05cf5eb7da408f877add23a35bcb8670b94b5efa1781b1ef9951d8&ascene=1&uin=MTk3MzU3NjM2MQ%3D%3D&devicetype=Windows+10&version=62060739&lang=zh_CN&pass_ticket=N6gIUbWVtgDoxrlksfFMBznbTlwAcaz9NT2MmEYQ8wLRSKGE2pBTbMA1Z41jzL2M程序员
基础
编写完美的 Python 命令行程序
https://mp.weixin.qq.com/s?__biz=MjM5MjAwODM4MA==&mid=2650712683&idx=3&sn=0738fa211001982fb5e64a8c6fa6242a&chksm=bea6dbb889d152ae80a5040982be0eec99ffb8923bc7484872e6474605647d35605446e7b54e&mpshare=1&scene=1&srcid=0119aJ9Le7IjqTCNwLUkdWZ3&key=904312b286f32b60e07c75db136896241949ad27400d020b257efa70019f432e84d91eeab6e6365f16a1ab825e4a4b120600353357da604465f250ce87b2753fb4d7f94aa13349bd6ca847066f2d0822&ascene=1&uin=MTk3MzU3NjM2MQ%3D%3D&devicetype=Windows+10&version=62060739&lang=zh_CN&pass_ticket=N6gIUbWVtgDoxrlksfFMBznbTlwAcaz9NT2MmEYQ8wLRSKGE2pBTbMA1Z41jzL2Mgithub
虚拟环境使用
virtualenv -p /usr/bin/python3 env35 //建立虚拟机环境 source env35/bin/activate //激活环境 deactivate //退出当前环境
虚拟环境操做
pip install virtualenv （ virtualenv 是一个建立隔绝的Python环境的工具） virtualenv venv （venv为虚拟环境目录名，目录名自定义） virtualenv -p /usr/bin/python2.7 venv （-p参数指定Python解释器程序路径） virtualenv --no-site-packages venv （不引入已经安装的第三方包） $ source venv/bin/activate (linux下激活) $ . venv/bin/deactivate (linux下退出) activate.bat （windows下进入E:\appiumEnv\Scripts后运行activate.bat文件进入虚拟环境） deactivate.bat （windows下进入E:\appiumEnv\Scripts后运行deactivate.bat文件退出虚拟环境） 执行 rm -rf venv （ 要删除一个虚拟环境，只需删除它的文件夹） 须要的话能够安装使用virtualenvwrapper（鉴于virtualenv不便于对虚拟环境集中管理，因此推荐直接使用virtualenvwrapper）
Python错误：安装cv2失败
2018年01月30日 15:43:35 我心永恒999 阅读数：58418 pip install opencv-python win10 python3.6可用 如今已经不行了，pip3能够
Python错误：IndentationError: unindent does not match any outer indentation level
缩进问题
Python错误：控制台输出InsecureRequestWarning的问题
问题： 使用Python3 requests发送HTTPS请求，已经关闭认证（verify=False）状况下，控制台会输出如下错误： InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings 解决方法： 在代码中添加如下代码便可解决： import urllib3 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) Python2添加以下代码便可解决： from requests.packages.urllib3.exceptions import InsecureRequestWarning # 禁用安全请求警告 requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
requests取消SSL认证后消除warning信息
# 禁用安全请求警告 requests.packages.urllib3.disable_warnings(InsecureRequestWarning) requests.get(url_temp)....
限制实例属性,使用__slots__变量,对继承的子类不起做用
class Person(object):
__slots__ = ("name", "age")
GUI
''' # 比较推荐的开发工具包四个：Gtk、Qt、Tk和wxwidgets # 七个优秀框架：Kivy、Pyforms、PyGObject（PyGi）、PyQt（收费）、PyGUI、libavg、wxPython、 Kivy 这是一个很是有趣的项目，基于OpenGL ES 2，支持Android和iOS平台的原生多点触摸，做为事件驱动的框架，Kivy很是适合游戏开发，很是适合处理从widgets到动画的任务。若是你想开发跨平台的图形应用，或者仅仅是须要一个强大的跨平台图形用户开发框架，Kivy都是不错的选择。 Pyforms 诞生只有两年的Pyforms是一个Python2.7/3.x跨环境图形应用开发框架，模块化和代码复用能够节省大量工做。 PyGObject（PyGi） PyGObject是一个利用GTK+为GNOME或Python应用开发的组件，可与跨平台代码库GObject绑定。GTK+是一个功能全面的免费跨平台widget开发工具包，为大量Linux和Windows/Mac OSX应用开发图形用户界面。 PyQt Qt是一个C++编写的跨平台开发框架，若是你的应用是彻底开源的，就能够无偿使用Qt，不然你须要购买商业许可。Qt已经存在好久，一度属于诺基亚公司，做为一个很是全面的工具代码库和API，被大量行业普遍采用，覆盖包括移动在内的多个平台。你的设备中使用的卫星导航应用，其图形用户界面每每就是Qt开发的。 PyGUI 与Kivy和PyQt相比，PyGUI的最大区别是仅仅面向UNIX、Macintosh和Windows平台。PyGUI的一个主要目的就是尽可能减小Python应用与平台底层GUI之间的代码量，若是你须要一个简单快速容易上手的GUI开发框架，那么PyGUI是一个不错的选择。 libavg libavg是一个C++编写的第三方开源库，能够运行在Linux、Mac OS X和Windows平台上。libavg被官方应用于艺术性较强的展现应用，能够同时处理数以千计的多媒体对象（图片、文本、视频和摄像头数据）。那些大屏幕上展现的多人共玩的多点触摸游戏，八成都有libavg的功劳。 wxPython 虽然尚未为Python3作好准备，可是做为资格最老，最流行的Python GUI开发框架之一，wxPython名气很大，不得不提。wxPython基于wxWidgets，是一个C++编写的跨平台GUI库，除了标准的对话框，还提供一个2D路径绘制API，支持多种文件格式以及文本编辑和字处理widgets。 '''
类/面向对象OOP
'''
类的访问限制
类属性前加双下划线、并给方法召回或修改属性
python能够动态绑定属性和方法
给实例绑定一个方法，绑定后对其余实例不适用
class Student(object):
pass
s = Student()
def set_age(self, age): # 定义一个函数做为实例方法
self.age = age
from types import MethodType
s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法
s.set_age(25)
print(s.age) # 验证
给class绑定方法
def set_score(self, score):
self.score = score
Student.set_score = MethodType(set_score, None, Student)
限制class的属性
使用__slots__,__slots__定义的属性仅对当前类起做用，对继承的子类是不起做用的
子类容许定义的属性就是自身的__slots__加上父类的__slots__
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义容许绑定的属性名称
@property
Python内置的@property装饰器就是负责把一个方法变成属性调用的
@property普遍应用在类的定义中，可让调用者写出简短的代码，同时保证对参数进行必要的检查，
这样，程序运行时就减小了出错的可能性。
定义只读属性--只定义getter方法
实例：
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
多重继承
若是须要“混入”额外的功能，经过多重继承就能够实现，
好比，让Ostrich除了继承自Bird外，再同时继承Runnable
在设计类的时候，咱们优先考虑经过多重继承来组合多个Mixin的功能，而不是设计多层次的复杂的继承关系。
因为Python容许使用多重继承，所以，Mixin就是一种常见的设计。
只容许单一继承的语言（如Java）不能使用Mixin的设计。
编写一个多进程模式的TCP服务，定义以下：
class MyTCPServer(TCPServer, ForkingMixin):
pass
定制类
__slots__属性限制
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义容许绑定的属性名称
__str__优化打印效果
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name: %s)' % self.name
print Student('Michael')
这样打印出来的实例，好看，且易看出实例内部重要的数据。
可是直接敲变量不用print，打印出来的实例仍是很差看
这是由于直接显示变量调用的不是__str__()，而是__repr__()，
二者的区别是__str__()返回用户看到的字符串，
而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。
解决办法是再定义一个__repr__()。
可是一般__str__()和__repr__()代码都是同样的，因此，有个偷懒的写法：
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
s = Student('Michael')
print(s)
__iter__返回一个迭代对象
以斐波那契数列为例
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化两个计数器a，b
def __iter__(self):
return self # 实例自己就是迭代对象，故返回本身
def next(self):
self.a, self.b = self.b, self.a + self.b # 计算下一个值
if self.a > 100000: # 退出循环的条件
raise StopIteration();
return self.a # 返回下一个值
for n in Fib():
print(n)
__getitem__按照下标取出元素
未处理负数和步进，以及一些未知不合理
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice):
start = n.start
stop = n.stop
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
f = Fib()
print(f[0:5])
__getattr__调用不存在的类的方法或属性时，避免报错，动态返回一个属性
简单链式调用
class Person:
def name(self, name):
self.name = name
return self
def age(self, age):
self.age = age
return self
def show(self):
print "My name is", self.name, "and I am", self.age, "years old."
p = Person()
p.name("Li Lei").age(15).show()
链式调用
class Chain(object):
def __init__(self, path=''):
self._path = path
def __getattr__(self, path):
return Chain('%s/%s' % (self._path, path))
def __str__(self):
return self._path
print(Chain().status.user123)
__call__实例自己调用
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
s = Student('Michael')
s()
'''
模块
'''
模块
在Python中，一个.py文件就称之为一个模块（Module）
任何模块代码的第一个字符串都被视为模块的文档注释
try:
import cStringIO as StringIO
except ImportError: # 导入失败会捕获到ImportError
import StringIO
try:
import json # python >= 2.6
except ImportError:
import simplejson as json # python <= 2.5
做用域 _
sys.path模块搜索路径
要添加本身的搜索目录，有两种方法：
一是直接修改sys.path，添加要搜索的目录：
import sys
sys.path.append('/Users/michael/my_py_scripts')
运行时修改，运行结束后失效。
二是设置环境变量PYTHONPATH
__future__模块，把下一个新版本的特性导入到当前版本，因而咱们就能够在当前版本中测试一些新版本的特性
from __future__ import unicode_literals #经过unicode_literals来使用Python 3.x的新的字符串的语法
'''
偏函数partial
def demo_add(x, y=1):
return x + y
def demo_partial():
"""
把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
当函数的参数个数太多，须要简化时使用
:return:
"""
from functools import partial
plus = partial(demo_add, 100)
print(plus(4))
生成器
def demo_009():
"""
生成器:
一边循环一边计算的机制，称为生成器
能够简单地把列表生成式改为generator，也能够经过函数实现复杂逻辑的generator。
构造：
方式一：列表生成式的[]改为()，就建立了一个generator
方式二：函数中带yield/变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
取值：
交互模式：generator.next()
代码中：for循环调用
:return:
"""
pass
# 斐波拉契数列
def fib(max_tmp):
n, a, b = 0, 0, 1
while n < max_tmp:
print(b)
a, b = b, a + b
n = n + 1
# 生成器版本
def fib_gen_branch(max_tmp):
n, a, b = 0, 0, 1
while n < max_tmp:
yield b
a, b = b, a + b
n = n + 1
列表生成式
def demo002():
"""
列表生成式/List Comprehensions:用来建立list的生成式
使用两个变量来生成list
"""
d = {'x': 'A', 'y': 'B', 'z': 'C'}
list_aps = [k + '=' + v for k, v in d.items()]
return list_aps
# 把一个list中全部的字符串变成小写/列表生成式运用
def lower_list():
list_tmp = ['Hello', 'World', 18, 'Apple', None]
print([s.lower() if isinstance(s, str) else s for s in list_tmp])
# 快速生成一个不重复的数字lis/列表推导式
def generate_num_list_not_same():
print(list(set(list(str(random.randint(1, 9)) for _ in range(11)))))
# [基础操做]列表推导式/字典推导式/生成器
def demo_list_and_jenerate():
print([num for num in list(range(21, 99))])
print([num for num in list(range(21, 99)) if num % 2 == 0])
print([num for num in range(21, 99) if num % 2 == 0])
print(num for num in range(21, 99) if num % 2 == 0) # 这是打印了一个生成器的内存地址
print([x * x for x in range(1, 11)])
print([x * x for x in range(1, 11) if x % 2 == 0])
print([d for d in os.listdir('.')]) # os.listdir能够列出文件和目录
切片
def demo001():
"""取一个list或tuple的部分元素"""
list_tmp = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
print(list_tmp[0:3])
print(list_tmp[-1]) # 取倒数第一个元素
requests
def demo_request():
"""
request 请求
response 响应
status_code 状态码
http code
200 成功
302 重定向
400 参数错误
403 无权限
405 错误的请求方法
500 服务器错误、没法返回
"""
res = requests.get('http://sogou.com')
# """ 上一行静态检查报错
print(res.ok)
print(res.url)
print(res.cookies)
print(res.headers)
print(dir(res))
print(res.status_code) # 获取响应码
print(res.text) # 字符串类型
print(res.content) # 字节流 bytes
文件读写
def write_file(file_name, res):
# FileName = 'http-tutorial.html'
with open(file_name, 'wb') as file:
file.write(res.content)
字典处理
def demo_dict():
"""有序字典可使用orderdict类库、python3.6之前dict无序"""
# 字典
my_dict = {}
my_dict.keys() # 获取dict全部键
my_dict.values() # 获取dict全部值
my_dict.items() # 获取一个列表、存放dict的键值对
my_dict.get('name') # 获取键为name的值、无此key返回None
# my_dict['key']#无此key则报错
my_dict['key'] = 'value' # 存在则更新/不存在则新增
my_dict.update(key='value') # 新增
my_dict.pop('key') # 删除键值对
列表排序
def sort_list():
my_list = ['北京', '上海', '重庆', '厦门', '四川', '三亚']
print(sorted(my_list)) # sorted不修改list自己元素index位置
my_list.sort() # sort方法会修改list自己元素index位置
random
def random_demo():
pprint(random.randint(1, 100)) # 生成随机数
json模块
def demo_json():
"""
json.dumps dict转str
json.dump 将python数据保存成json文件
json.loads str转dict
json.load 读取json数据
"""
print(json.dumps([])) # dumps能够格式化全部的基本数据类型为字符串
dict_tmp = {"name": "Tom", "age": 23}
print(json.dumps(dict_tmp)) # dict转str
a = {"name": "Tom", "age": 23}
with open("test.json", "w", encoding='utf-8') as fo:
# indent 超级好用，格式化保存字典，默认为None，小于0为零个空格
fo.write(json.dumps(a, indent=4)) # json.dump(a,f,indent=4) # 效果同样
with open("test.json", "r", encoding='utf-8') as fr:
aa = json.loads(fr.read())
fr.seek(0)
bb = json.load(fr) # 与 json.loads(f.read())一致
print(aa)
print(bb)
编译pyc文件
# python -m compileall xxx.py
@staticmethod和@classmethod的异同
class A(object):
"""
相同：
@staticmethod和@classmethod均可以直接类名.方法名()来调用
形参不一样：
@staticmethod不须要self参数和自身类的cls参数，就跟使用函数同样。
@classmethod也不须要self参数，但第一个参数须要是表示自身类的cls参数。
使用不一样：
@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
@classmethod由于持有cls参数，能够来调用类的属性，类的方法，实例化对象等，避免硬编码。
"""
bar = 1
@staticmethod
def foo():
print('foo')
@staticmethod
def static_foo():
print('static_foo')
print(A.bar)
@classmethod
def class_foo(cls):
print('class_foo')
print(cls.bar)
cls().foo()
def test_method_001():
A.static_foo()
A.class_foo()
库的安装
def demo_install_moduls():
"""
pip -r requirement.txt
pip3 install dateutil -i http://mirrors.aliyun.com/pypi/simple/
pip install Pinyin2Hanzi -i https://pypi.douban.com/simple
pip install pythonModuleName -i https://pypi.douban.com/simple（在命令行中添加镜像参数，可让pip从指定的镜像源安装软件。）
pip3 install progressbar -i https://pypi.douban.com/simple
pip install concurrently -i https://pypi.douban.com/simple
python -m pip36 install aiohttp progressbar -i https://pypi.douban.com/simple
解决pycharm没法安装模块的问题
python -m pip install --upgrade --force pip
pip install setuptools==33.1.1 -i https://pypi.douban.com/simple
python3.exe -m pip install ConfigParser
国内镜像
https://pypi.doubanio.com/simple/
https://pypi.douban.com/simple/
如下镜像未验证
http://pypi.douban.com/simple/ 豆瓣
http://mirrors.aliyun.com/pypi/simple/ 阿里
http://pypi.hustunique.com/simple/ 华中理工大学
http://pypi.sdutlinux.org/simple/ 山东理工大学
http://pypi.mirrors.ustc.edu.cn/simple/ 中国科学技术大学
https://pypi.tuna.tsinghua.edu.cn/simple 清华
"""
pass
pep8规范
def demo_pep8():
"""
1)
一行列数 : PEP 8 规定为 79 列，这个太苛刻了，若是要拼接url通常都会超\
一个函数 : 不要超过 30 行代码, 便可显示在一个屏幕类，能够不使用垂直游标便可看到整个函数。
一个类 : 不要超过 200 行代码，不要有超过 10 个方法。
一个模块 : 不要超过 500 行。
2)不要在一句import中多个库
不推荐
import os, sys
推荐
import os
import sys
在整理本身代码的时候记录的问题。
错误记录：W292 no newline at end of file
处理：打个回车有新的一空行便可（新行不要有空格）。
错误记录：E302 expected 2 blank lines, found 1
处理：上面只有一行空白，可是须要两个空白行
错误记录：E231 missing whitespace after ‘,’
翻译：“，”后要有空格
举例：
错误 print(“%s %s %s %s %s %s” % (A,B,D,E,K,L))
正确 print(“%s %s %s %s %s %s” % (A, B, D, E, K, L))
错误记录：E225 missing whitespace around operator
翻译：
举例：
错误 print(“%s %s %s %s %s %s”%(A, B, D, E, K, L))
正确 rint(“%s %s %s %s %s %s”% (A, B, D, E, K, L))
错误记录：E225 missing whitespace around operator
举例：
错误 f=open(“D:\\test.txt”, “ab”)
正确 f = open(“D:\\test.txt”, “ab”)
参考：
http://www.elias.cn/Python/PythonStyleGuide
"""
pass
PyCharm选择性忽略PEP8代码风格警告信息
def demo_escape_pep8_remind():
"""
方法一:
将鼠标移到提示的地方，按alt+Enter，选择忽略（Ignore）这个错误即好。
方法二
打开：File - Settings…… - Editor - Inspections
在python下找到 PEP8 coding style violation，在右边下面的Ignore errors里能够添加忽略的警告信息ID
id查找网页：https://pep8.readthedocs.io/en/latest/intro.html#configuration
"""
pass
python目录介绍
def demo_py_catalog():
"""
python模块位置
Python自带的模块：/usr/lib/python2.7/urllib.py
Python第三方模块：/usr/local/lib/python2.7/site-packages
"""
pass
python经常使用库
def demo_py_modules():
"""
网络请求: urllib/urllib2/httplib/requests/
网页解析: lxml/bs4/
数据分析挖掘: snownlp/jieba/Pinyin2Hanzi/
图像: ggplot/matplotlib/PIL/Pillow/
文本转语音：pyttsx3/
多任务：threading/multiprocessing/Queue/
打印/日志/调试：pprint/logging/pdb/traceback/
正则：re/
系统/调度：sys/subprocess/
文件处理：cvs/xlib/xlrd/configparser
加密：hashlib/
测试：selenium/
逻辑处理：itertools/functools/
序列化：json/simplejson/
数据库：redis/pymongo(py3)/MySQLdb(py2)/
注释：
lxml性能高于bs4
据so上的讨论simplejson性能高于json
subprocess调用shell命令的神器
traceback 调试
itertools 内建/操做迭代对象
functools 内建/包含partial及wraps等
pickle/cPickle 内建/序列化工具
timeit 内建/计算代码运行的时间等
---------------------------如下未整理
cProfile python性能测量模块
glob 相似与listfile，能够用来查找文件
atexit 有一个注册函数，可用于正好在脚本退出运行前执行一些代码
dis python 反汇编，当对某条语句不理解原理时，能够用dis.dis 函数来查看代码对应的python 解释器指令等等。
第三方库
paramiko ssh python 库
mechanize Stateful programmatic web browsing
pycurl cURL library module for Python
Fabric Fabric is a Python (2.5 or higher) library and command-line tool for streamlining the use of SSH for application deployment or systems administration tasks
xmltodict xml 转 dict，真心好用
flask web 微框架
ipdb 调试神器，同时推荐ipython！结合ipython使用
mako python模版引擎
numpy ， scipy 科学计算
scrapy 爬虫
django/tornado/web.py/web2py/uliweb/flask/twisted/bottle/cherrypy.等等 python web框架/服务器
sh 1.08 — sh v1.08 documentation 用来运行shell 模块的 极佳选择
virtualenv。建立独立 Python 环境的工具。
IPython。附带很是额外功能的交互环境。
httpie。一个命令行HTTP 客户端，cURL 的替代品，易用性更好。
you-get。一个 YouTube/Youku/Niconico 视频下载器。
youtube-dl。用来下载 YouTube 视频的工具。
Cython。优化的 Python 静态编译器。使用类型混合使 Python 编译成 C 或 C++ 模块来得到性能的极大提高。
Flake8：静态检查工具，它包含PyFlakes（静态检查Python代码逻辑错误）、pycodestyle和McCabe（分析Python代码复杂度）三个工具。
"""
pass
py命名规范
def demo_name_standard():
"""
大驼峰：
类名|AdStats|单词首字母大写,内部类可使用额外的前导下划线。
大写，下划线分割：
全局变量名
小写，下划线分割：
文件名、
模块名、
包名、
普通变量、
普通函数、
私有函数、（私有函数以__开头）
实例变量、（实例变量以_开头）
私有实例变量、（私有实例变量以__开头）
专有变量（专有变量__开头，__结尾，通常为python的自有变量，勿用）
————————————————————————————————————————————————————————————————————
Python风格指南建议将每一个导入语句单独成行
函数和方法的参数|总使用“self”做为实例方法的第一个参数。总使用“cls”做为类方法的第一个参数。若是一个函数的参数名称和保留的关键字冲突，一般使用一个后缀下划线好于使用缩写或奇怪的拼写。
全局变量|对于from M import *导入语句，若是想阻止导入模块内的全局变量可使用旧有的规范，在全局变量上加一个前导的下划线。*注意*:应避免使用全局变量
变量|变量名所有小写，由下划线链接各个单词。如color = WHITE，this_is_a_variable = 1 *注意*：1.不管是类成员变量仍是全局变量，均不使用 m 或 g 前缀。2.私有类成员使用单一下划线前缀标识，多定义公开成员，少定义私有成员。3.变量名不该带有类型信息，由于Python是动态类型语言。如 iValue、names_list、dict_obj 等都是很差的命名。
常量|常量名全部字母大写，由下划线链接各个单词如MAX_OVERFLOW，TOTAL。
异常|以“Error”做为后缀。
缩写|命名应当尽可能使用全拼写的单词，缩写的状况有以下两种：1.经常使用的缩写，如XML、ID等，在命名时也应只大写首字母，如XmlParser。2.命名中含有长单词，对某个单词进行缩写。这时应使用约定成俗的缩写方式。例如：function 缩写为 fn/text 缩写为 txt/object 缩写为 obj/count 缩写为 cnt/number 缩写为 num，等。
前导后缀下划线|一个前导下划线：表示非公有。一个后缀下划线：避免关键字冲突。两个前导下划线：当命名一个类属性引发名称冲突时使用。两个前导和后缀下划线：“魔”（有特殊用途）对象或者属性，例如__init__或者__file__。绝对不要创造这样的名字，而只是使用它们。*注意*：关于下划线的使用存在一些争议。Python 用下划线做为变量前缀和后缀指定特殊变量。
_xxx 不能用'from module import *'导入
__xxx__ 系统定义名字
__xxx 类中的私有变量名
核心风格：避免用下划线做为变量名的开始。
由于下划线对解释器有特殊的意义，并且是内建标识符所使用的符号，咱们建议程序员避免用下划线做为变量名的开始。通常来说，变量名_xxx被看做是“私有的”，在模块或类外不可使用。当变量是私有的时候，用_xxx 来表示变量是很好的习惯。由于变量名__xxx__对Python 来讲刑厥夂澹杂谄胀ǖ谋淞坑Φ北苊庹庵置绺瘛?br>
"单下划线" 开始的成员变量叫作保护变量，意思是只有类对象和子类对象本身能访问到这些变量；
"双下划线" 开始的是私有成员，意思是只有类对象本身能访问，连子类对象也不能访问到这个数据。
以单下划线开头（_foo）的表明不能直接访问的类属性，需经过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）表明类的私有成员；以双下划线开头和结尾的（__foo__）表明python里特殊方法专用的标识，如 __init__（）表明类的构造函数。
特定命名方式
主要是指 __xxx__ 形式的系统保留字命名法。项目中也可使用这种命名，它的意义在于这种形式的变量是只读的，这种形式的类成员函数尽可能不要重载。如
class Base(object):
def __init__(self, id, parent = None):
self.__id__ = id
self.__parent__ = parent
def __message__(self, msgid):
# …略
其中 __id__、__parent__ 和 __message__ 都采用了系统保留字命名法。
附:Google Python命名规范
module_name
package_name
ClassName
method_name
ExceptionName
function_name
GLOBAL_VAR_NAME,
instance_var_name
function_parameter_name
local_var_name
————————————————————————————————————————————————————————
from：http://hi.baidu.com/kxw102/blog/item/212e9f3859202fe33b87ce4b.html
理解Python命名机制
引子
我热情地邀请你们猜想下面这段程序的输出：
class A(object):
def __init__(self):
self.__private()
self.public()
def __private(self):
print 'A.__private()'
def public(self):
print 'A.public()'
class B(A):
def __private(self):
print 'B.__private()'
def public(self):
print 'B.public()'
b = B()
初探
正确的答案是：
A.__private()
B.public()
若是您已经猜对了，那么能够不看我这篇博文了。若是你没有猜对或者内心有所疑问，那个人这篇博文正是为您所准备的。
一切由为何会输出“A.__private()”开始。但要讲清楚为何，咱们就有必要了解一下Python的命名机制。
据 Python manual，变量名（标识符）是Python的一种原子元素。当变量名被绑定到一个对象的时候，变量名就指代这个对象，就像人类社会同样，不是吗？当变 量名出如今代码块中，那它就是本地变量；当变量名出如今模块中，它就是全局变量。模块相信你们都有很好的理解，但代码块可能让人费解些。在这里解释一下：
代码块就是可做为可执行单元的一段Python程序文本；模块、函数体和类定义都是代码块。不只如此，每个交互脚本命令也是一个代码块；一个脚本文件也是一个代码块；一个命令行脚本也是一个代码块。
接 下来谈谈变量的可见性，咱们引入一个范围的概念。范围就是变量名在代码块的可见性。若是一个代码块里定义本地变量，那范围就包括这个代码块。若是变量定义 在一个功能代码块里，那范围就扩展到这个功能块里的任一代码块，除非其中定义了同名的另外一变量。但定义在类中的变量的范围被限定在类代码块，而不会扩展到 方法代码块中。
迷踪
据上节的理论，咱们能够把代码分为三个代码块：类A的定义、类B的定义和变量b的定义。根据类定义，咱们知道代码给类A定义了三个成员变量（Python的函数也是对象，因此成员方法称为成员变量也行得通。）；类B定义了两个成员变量。这能够经过如下代码验证：
# >>> print '\n'.join(dir(A))
_A__private
__init__
public
# >>> print '\n'.join(dir(B))
_A__private
_B__private
__init__
public
咦，为何类A有个名为_A__private的 Attribute 呢？并且__private消失了！这就要谈谈Python的私有变量轧压了。
探究
懂 Python的朋友都知道Python把以两个或以上下划线字符开头且没有以两个或以上下划线结尾的变量看成私有变量。私有变量会在代码生成以前被转换为 长格式（变为公有）。转换机制是这样的：在变量前端插入类名，再在前端加入一个下划线字符。这就是所谓的私有变量轧压（Private name mangling）。如类A里的__private标识符将被转换为_A__private，这就是上一节出现_A__private和 __private消失的缘由了。
再讲两点题外话：
一是由于轧压会使标识符变长，当超过255的时候，Python会切断，要注意所以引发的命名冲突。
二是当类名所有如下划线命名的时候，Python就再也不执行轧压。如：
#>>> class ____(object):
def __init__(self):
self.__method()
def __method(self):
print '____.__method()'
#>>> print '\n'.join(dir(____))
__class__
__delattr__
__dict__
__doc__
__getattribute__
__hash__
__init__
__method # 没被轧压
__module__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__str__
__weakref__
\>>> obj = ____()
____.__method()
\>>> obj.__method() # 能够外部调用
____.__method()
如今咱们回过头来看看为何会输出“A.__private()”吧！
真相
相信如今聪明的读者已经猜到答案了吧？若是你尚未想到，我给你个提示：真相跟C语言里的宏预处理差很少。
由于类A定义了一个私有成员函数（变量），因此在代码生成以前先执行私有变量轧压（注意到上一节标红的那行字没有？）。轧压以后，类A的代码就变成这样了：
class A(object):
def __init__(self):
self._A__private() # 这行变了
self.public()
def _A__private(self): # 这行也变了
print 'A.__private()'
def public(self):
print 'A.public()'
是否是有点像C语言里的宏展开啊？
由于在类B定义的时候没有覆盖__init__方法，因此调用的仍然是A.__init__，即执行了self._A__private()，天然输出“A.__private()”了。
下面的两段代码能够增长说服力，增进理解：
\>>> class C(A):
def __init__(self): # 重写__init__，再也不调用self._A__private
self.__private() # 这里绑定的是_C_private
self.public()
def __private(self):
print 'C.__private()'
def public(self):
print 'C.public()'
\>>> c = C()
C.__private()
C.public()
############################
\>>> class A(object):
def __init__(self):
self._A__private() # 调用一个没有定义的函数，Python会把它给个人 ^_^～
self.public()
def __private(self):
print 'A.__private()'
def public(self):
print 'A.public()'
\>>>a = A()
A.__private()
A.public()
"""
pass
输出彩色字符
def demo_output_colorful_str():
r"""
实现过程：
终端的字符颜色是用转义序列控制的，是文本模式下的系统显示功能，和具体的语言无关。
转义序列是以ESC开头,即用\033来完成（ESC的ASCII码用十进制表示是27，用八进制表示就是033）
书写格式：
开头部分：\033[显示方式;前景色;背景色m + 结尾部分：\033[0m
注意：开头部分的三个参数: 显示方式，前景色，背景色是可选参数，能够只写其中的某一个；另外因为表示三个参数不一样含义的数值都是惟一的没有重复的，因此三个参数的书写前后顺序没有固定要求，系统都能识别；可是，建议按照默认的格式规范书写。
对于结尾部分，其实也能够省略，可是为了书写规范，建议\033[***开头，\033[0m结尾。
数值表示的参数含义：
显示方式: 0（默认值）、1（高亮）、22（非粗体）、4（下划线）、24（非下划线）、 5（闪烁）、25（非闪烁）、7（反显）、27（非反显）
前景色: 30（黑色）、31（红色）、32（绿色）、 33（黄色）、34（蓝色）、35（洋 红）、36（青色）、37（白色）
背景色: 40（黑色）、41（红色）、42（绿色）、 43（黄色）、44（蓝色）、45（洋 红）、46（青色）、47（白色）
常见开头格式：
\033[0m 默认字体正常显示，不高亮
\033[32;0m 红色字体正常显示
\033[1;32;40m 显示方式: 高亮 字体前景色：绿色 背景色：黑色
\033[0;31;46m 显示方式: 正常 字体前景色：红色 背景色：青色
"""
print("\033[1;31;40m您输入的账号或密码错误！\033[0m") # 输出格式为：字体高亮，红色前景，黄色背景 PS：前景色也就是字体的颜色
print("\033[0;31m%s\033[0m" % "输出红色字符") # 输出格式为：字体默认，红色前景
print("\033[0;32m%s\033[0m" % "输出字符") # 输出格式为：字体默认，红色前景
format函数
class DemoFormat(object):
"""相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，经过传入的参数进行格式化，而且使用大括号‘{}’做为特殊字符代替‘%’。"""
# 方法一：位置替换。在字符串模板中肯定位置，而且位置能够不按顺序，format()可传入任意数目的参数。
@staticmethod
def demo_001():
print('{0} {1}'.format('hello', 'world'))
print('{} {}'.format('hello', 'world'))
print('{0} {1} {0}'.format('hello', 'world'))
# 方法二：关键字替换。
@staticmethod
def demo_002():
print('i love {python}'.format(python='you'))
# 其余方法：能够指定输出长度和输出的对齐方式，其中对齐方式有一下几种
@staticmethod
def demo_003():
"""
< （默认）左对齐
> 右对齐
^ 中间对齐
= （只用于数字）在小数点后进行补齐
"""
print(format('string', '2s'))
print(format(3.14151617, '.5f'))
print('{0:>10}'.format('sqxu')) # 10个占位符，右对齐
print('{0:4.2f}'.format(3.141516))
print('{0:6.2f}'.format(3.141516))
print('{0:>6.2f}'.format(3.141516))
print('{1:<10},{0:<15}'.format('sqxu', 'USTC'))
print('name={name},age={age}'.format(name='sqxu', age=25))
# 经过格式化指示符来控制格式
@staticmethod
def demo_004():
"""
'b' - 二进制。将数字以2为基数进行输出。
'c' - 字符。在打印以前将整数转换成对应的Unicode字符串。
'd' - 十进制整数。将数字以10为基数进行输出。
'o' - 八进制。将数字以8为基数进行输出。
'x' - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
'e' - 幂符号。用科学计数法打印数字。用'e'表示幂。
'g' - 通常格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
'n' - 数字。当值为整数时和'd'相同，值为浮点数时和'g'相同。不一样的是它会根据区域设置插入数字分隔符。
'%' - 百分数。将数值乘以100而后以fixed-point('f')格式打印，值后面会有一个百分号。
"""
print('{0:b}'.format(3))
print('{0:c}'.format(30))
print('{0:d}'.format(3))
print('{0:o}'.format(10))
print('{0:x}'.format(30))
print('{0:e}'.format(3))
print('{0:f}'.format(3))
print('{0:g}'.format(3))
print('{0:n}'.format(3))
print('{0:n}'.format(3.1415))
print('{0:%}'.format(3.15))
bs4模块
def demo_bs4():
"""
bs4模块
新的库、可是价值小。支持多进程、不支持多线程、单例对象、每次只能一个一个处理、；
bs 4一分钟解析30多个页面、lxml700多页面
:return:
"""
pass
python代码简单性能调优
def demo_xingneng_simple():
"""
参考地址：https://blog.csdn.net/sinat_38682860/article/details/80600473?from=timeline&isappinstalled=0
方法：
一、优化算法时间复杂度
算法的时间复杂度对程序的执行效率影响最大，在 Python 中能够经过选择合适的数据结构来优化时间复杂度，如 list 和 set 查找某一个元素的时间复杂度分别是O(n)和O(1)。
不一样的场景有不一样的优化方式，总得来讲，通常有分治，分支界限，贪心，动态规划等思想。
二、减小冗余数据
如用上三角或下三角的方式去保存一个大的对称矩阵。在0元素占大多数的矩阵里使用稀疏矩阵表示。
三、合理使用 copy 与 deepcopy
对于 dict 和 list 等数据结构的对象，直接赋值使用的是引用的方式。
而有些状况下须要复制整个对象，这时可使用 copy 包里的 copy 和 deepcopy，这两个函数的不一样之处在于后者是递归复制的。效率也不同：（如下程序在 ipython 中运行）
四、使用 dict 或 set 查找元素
五、合理使用生成器（generator）和 yield
使用()获得的是一个 generator 对象，所须要的内存空间与列表的大小无关，因此效率会高一些。
可是对于须要循环遍历的状况，后者的效率反而更高，可是若是循环里有 break,用 generator 的好处是显而易见的。yield 也是用于建立 generator：
六、优化循环
循环以外能作的事不要放在循环内
七、优化包含多个判断表达式的顺序
对于 and，应该把知足条件少的放在前面，对于 or，把知足条件多的放在前面。
八、用 join 合并迭代器中的字符串
九、选择合适的格式化字符方式
% format 和 string直接相加 三种方式 选用format吧
十、不借助中间变量交换两个变量的值
a,b=1,2
a,b=b,a
十一、使用 if is
十二、使用级联比较x < y < z
1三、hile 1 比 while True 更快
1四、使用**而不是 pow
1五、使用 cProfile, cStringIO 和 cPickle 等用c实现相同功能（分别对应profile, StringIO, pickle）的包
1六、使用最佳的反序列化方式
1七、使用C扩展(Extension)
1八、并行编程
1九、终级大杀器：PyPy
20、使用性能分析工具
"""
python中os._exit()和 sys.exit(), exit(0)和exit(1) 的用法和区别
概述
python的程序有两中退出方式：os._exit()， sys.exit()
os._exit()会直接将python程序终止，以后的全部代码都不会继续执行。
sys.exit()会引起一个异常：SystemExit，若是这个异常没有被捕获，那么python解释器将会退出。若是有捕获此异常的代码，那么这些代码仍是会执行。捕获这个异常能够作一些额外的清理工做。0为正常退出，其余数值（1-127）为不正常，可抛异常事件供捕获。
os._exit()直接将python解释器退出，余下的语句不会执行。
sys.exit()的退出比较优雅，调用后会引起SystemExit异常，能够捕获此异常作清理工做。
通常来讲
os._exit() 用于在线程中退出，通常在fork出来的子进程中使用
sys.exit() 用于在主线程中退出。
安装pygame
pip install wheel
pip list ， 出现 wheel ，证实wheel插件安装成功
网址 http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame
下载须要的版本
而后到目录下执行命令 pip install pygame-1.9.2a0-cp27-none-win_amd64.whl(你下载pygame的对应名称)
检测安装是否成功 pip list
Python错误：pip install SSLError【There was a problem confirming the ssl certificate】
证书不受信任，关闭打开的fiddler
Python错误：AttributeError: module 'enum' has no attribute 'IntFlag'
从python 3.6开始，enum34库再也不与标准库兼容。该库也是没必要要的，所以您只需卸载它便可。 pip3 uninstall enum34 pip3 install --index-url https://pypi.douban.com/simple/ pyinstaller
python打包exe
方式1：cx_Freeze
方式2：py2exe
py2exe与安装的py版本有关
方式3：pyinsatller
pyinstaller -F -w (-i icofile) filename
默认-D，生成的带目录
-F，生成单一文件
-w，表示隐藏程序运行时的命令行窗口（不加-w会有黑色窗口）
-p，指定依赖路径
-i，指定图标
pycharm 快捷键
def demo_pycharm():
"""
ctrl+alt+l 格式化
ctrl+f4 关闭页签
"""
pass
pycharm设置
def demo_set_pycharm():
"""
Ctr+Alt+L快速格式化
ctrl+/快速注释
code style->python设置代码默认快速格式化格式
PyCharm3.0默认快捷键(翻译的)
一、编辑（Editing）
Ctrl + Space 基本的代码完成（类、方法、属性）
Ctrl + Alt + Space 快速导入任意类
Ctrl + Shift + Enter 语句完成
Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档
Shift + F1 外部文档
Ctrl + 鼠标 简介
Ctrl + F1 显示错误描述或警告信息
Alt + Insert 自动生成代
Ctrl + O 从新方法
Ctrl + Alt + T 选中
Ctrl + / 行注释
Ctrl + Shift + / 块注释
Ctrl + W 选中增长的代码块
Ctrl + Shift + W 回到以前状态
Ctrl + Shift + ]/[ 选定代码块结束、开始
Alt + Enter 快速修正
Ctrl + Alt + L 代码格式化
Ctrl + Alt + O 优化导入
Ctrl + Alt + I 自动缩进
Tab / Shift + Tab 缩进、不缩进当前行
Ctrl+X/Shift+Delete 剪切当前行或选定的代码块到剪贴板
Ctrl+C/Ctrl+Insert 复制当前行或选定的代码块到剪贴板
Ctrl+V/Shift+Insert 从剪贴板粘贴
Ctrl + Shift + V 从最近的缓冲区粘贴
Ctrl + D 复制选定的区域或行
Ctrl + Y 删除选定的行
Ctrl + Shift + J 添加智能线
Ctrl + Enter 智能线切割
Shift + Enter 另起一行
Ctrl + Shift + U 在选定的区域或代码块间切换
Ctrl + Delete 删除到字符结束
Ctrl + Backspace 删除到字符开始
Ctrl + Numpad+/- 展开折叠代码块
Ctrl + Numpad+ 所有展开
Ctrl + Numpad- 所有折叠
Ctrl + F4 关闭运行的选项卡
二、查找/替换(Search/Replace)
F3 下一个
Shift + F3 前一个
Ctrl + R 替换
Ctrl + Shift + F 全局查找
Ctrl + Shift + R 全局替换
三、运行(Running)
Alt + Shift + F10 运行模式配置
Alt + Shift + F9 调试模式配置
Shift + F10 运行
Shift + F9 调试
Ctrl + Shift + F10 运行编辑器配置
Ctrl + Alt + R 运行manage.py任务
四、调试(Debugging)
F8 跳过
F7 进入
Shift + F8 退出
Alt + F9 运行游标
Alt + F8 验证表达式
Ctrl + Alt + F8 快速验证表达式
F9 恢复程序
Ctrl + F8 断点开关
Ctrl + Shift + F8 查看断点
五、导航(Navigation)
Ctrl + N 跳转到类
Ctrl + Shift + N 跳转到符号
Alt + Right/Left 跳转到下一个、前一个编辑的选项卡
F12 回到先前的工具窗口
Esc 从工具窗口回到编辑窗口
Shift + Esc 隐藏运行的、最近运行的窗口
Ctrl + Shift + F4 关闭主动运行的选项卡
Ctrl + G 查看当前行号、字符号
Ctrl + E 当前文件弹出
Ctrl+Alt+Left/Right 后退、前进
Ctrl+Shift+Backspace 导航到最近编辑区域
Alt + F1 查找当前文件或标识
Ctrl+B / Ctrl+Click 跳转到声明
Ctrl + Alt + B 跳转到实现
Ctrl + Shift + I查看快速定义
Ctrl + Shift + B跳转到类型声明
Ctrl + U跳转到父方法、父类
Alt + Up/Down跳转到上一个、下一个方法
Ctrl + ]/[跳转到代码块结束、开始
Ctrl + F12弹出文件结构
Ctrl + H类型层次结构
Ctrl + Shift + H方法层次结构
Ctrl + Alt + H调用层次结构
F2 / Shift + F2下一条、前一条高亮的错误
F4 / Ctrl + Enter编辑资源、查看资源
Alt + Home显示导航条F11书签开关
Ctrl + Shift + F11书签助记开关
Ctrl + #[0-9]跳转到标识的书签
Shift + F11显示书签
六、搜索相关(Usage Search)
Alt + F7/Ctrl + F7文件中查询用法
Ctrl + Shift + F7文件中用法高亮显示
Ctrl + Alt + F7显示用法
七、重构(Refactoring)
F5复制F6剪切
Alt + Delete安全删除
Shift + F6重命名
Ctrl + F6更改签名
Ctrl + Alt + N内联
Ctrl + Alt + M提取方法
Ctrl + Alt + V提取属性
Ctrl + Alt + F提取字段
Ctrl + Alt + C提取常量
Ctrl + Alt + P提取参数
八、控制VCS/Local History
Ctrl + K提交项目
Ctrl + T更新项目
Alt + Shift + C查看最近的变化
Alt + BackQuote(’)VCS快速弹出
九、模版(Live Templates)
Ctrl + Alt + J当前行使用模版
Ctrl +Ｊ插入模版
十、基本(General)
Alt + #[0-9]打开相应的工具窗口
Ctrl + Alt + Y同步
Ctrl + Shift + F12最大化编辑开关
Alt + Shift + F添加到最喜欢
Alt + Shift + I根据配置检查当前文
Ctrl + BackQuote(’)快速切换当前计划
Ctrl + Alt + S 打开设置页
Ctrl + Shift + A查找编辑器里全部的动做
Ctrl + Tab在窗口间进行切换
一些经常使用设置：
1. pycharm默认是自动保存的，习惯本身按ctrl + s 的能够进行以下设置：
1. file -> Setting -> General -> Synchronization -> Save files on frame deactivation 和 Save files automatically if application is idle for .. sec 的勾去掉
2. file ->Setting -> Editor -> Editor Tabs -> Mark modified tabs with asterisk 打上勾
2. Alt + Enter: 自动添加包
3. 对于经常使用的快捷键，能够设置为visual studio(eclipse...)同样的：
file -> Setting -> Keymap -> Keymaps -> vuisual studio -> Apply
4. Pycharm中默认是不能用Ctrl+滚轮改变字体大小的，能够在file -> Setting ->Editor-〉Mouse中设置
5. 要设置Pycharm的字体，要先在file -> Setting ->Editor-〉Editor中选择一种风格并保存，而后才能够改变
6. 在setting中搜索theme能够改变主题，全部配色统一改变
"""
pass
python导出已安装库方法
def demo_output_moudles():
"""
pip freeze > requirements.txt //导出dependency
若是须要导入项目的库的话，能够先安装pip install pipreqs，而后命令行执行 pipreqs ./
pip install -r requirements.txt //安装dependency
另外，有些小细节也是值得一提的，
那就是"pip freeze > requirements.txt"指令必须用在整个工程项目彻底跑通了（也就是项目依赖已经所有安装完成）的状况下，
才能将全部的有关依赖库写入requirements.txt文件中去，
而“pip install -r requirements.txt”指令则使用于服务器部署时较为合适
:return:
"""
pass
python中子类初始化使用super报错
def demo_lower_calss_init_use_super_error():
"""
出现的TypeError: must be type, not classobj 缘由及解决
python中super只能应用于父类为新类，而不能应用于父类为经典类
所谓新类就是全部类都必需要有继承的类，若是什么都不想继承，就继承到object类。经典类报错
"""
pass
time模块
def demo_time():
"""
# python中时间日期格式化符号：
# %y 两位数的年份表示（00-99）
# %Y 四位数的年份表示（000-9999）
# %m 月份（01-12）
# %d 月内中的一天（0-31）
# %H 24小时制小时数（0-23）
# %I 12小时制小时数（01-12）
# %M 分钟数（00=59）
# %S 秒（00-59）
# %a 本地简化星期名称
# %A 本地完整星期名称
# %b 本地简化的月份名称
# %B 本地完整的月份名称
# %c 本地相应的日期表示和时间表示
# %j 年内的一天（001-366）
# %p 本地A.M.或P.M.的等价符
# %U 一年中的星期数（00-53）星期天为星期的开始
# %w 星期（0-6），星期天为星期的开始
# %W 一年中的星期数（00-53）星期一为星期的开始
# %x 本地相应的日期表示
# %X 本地相应的时间表示
# %Z 当前时区的名称
# %% %号自己
"""
# 时间戳都以自从1970年1月1日午夜（历元）通过了多长时间来表示。时间间隔是以秒为单位的浮点小数
print("当前时间戳为: %s" % time.time())
# 时间元组
print((time.localtime()))
# 格式化时间
print("本地时间为: %s" % time.asctime(time.localtime(time.time())))
# 格式化日期
# time.strftime(format[, t])
# 格式化成2016-03-20 11:45:39形式
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 格式化成2016-03-20形式
print(time.strftime("%Y-%m-%d", time.localtime()))
# 格式化成Sat Mar 28 22:24:24 2016形式
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))
snownlp库
def demo_snownlp():
"""
国人开发/针对中文文本进行挖掘/已有算法，需本身调用函数，根据不一样的文本构建语料库/
snownlp：
中文分词（算法是Character-Based Generative Model）
词性标注（原理是TnT、3-gram隐马）
情感分析（官网指明购物类评论准确率较高，由于语料库主要是购物方面，可本身构建相关领域语料库替换）
文本分类（原理是朴素贝叶斯）
转换拼音
繁体转简体
提取文本关键词（原理是TextRank）
提取摘要（原理是TextRank）
分割句子
文本类似（原理是BM25）。
"""
pass
内置模块
def builtin_modules():
"""
help(obj) 在线帮助, obj但是任何类型
callable(obj) 查看一个obj是否是能够像函数同样调用
repr(obj) 获得obj的表示字符串，能够利用这个字符串eval重建该对象的一个拷贝
eval_r(str) 表示合法的python表达式，返回这个表达式
dir(obj) 查看obj的name space中可见的name
hasattr(obj,name) 查看一个obj的name space中是否有name
getattr(obj,name) 获得一个obj的name space中的一个name
setattr(obj,name,value) 为一个obj的name
space中的一个name指向vale这个object
delattr(obj,name) 从obj的name space中删除一个name
vars(obj) 返回一个object的name space。用dictionary表示
locals() 返回一个局部name space,用dictionary表示
globals() 返回一个全局name space,用dictionary表示
type(obj) 查看一个obj的类型
isinstance(obj,cls) 查看obj是否是cls的instance
issubclass(subcls,supcls) 查看subcls是否是supcls的子类
################# 类型转换 ##################
chr(i) 把一个ASCII数值,变成字符
ord(i) 把一个字符或者unicode字符,变成ASCII数值
oct(x) 把整数x变成八进制表示的字符串
hex(x) 把整数x变成十六进制表示的字符串
str(obj) 获得obj的字符串描述
list(seq) 把一个sequence转换成一个list
tuple(seq) 把一个sequence转换成一个tuple
dict(),dict(list) 转换成一个dictionary
int(x) 转换成一个integer
long(x) 转换成一个long interger
float(x) 转换成一个浮点数
complex(x) 转换成复数
max(...) 求最大值
min(...) 求最小值
:return:
"""
pass
os模块
def demo_os():
"""
os.environ 一个dictionary 包含环境变量的映射关系
os.environ["HOME"] 能够获得环境变量HOME的值
os.chdir(dir) 改变当前目录 os.chdir('d:\\outlook')
注意windows下用到转义
os.getcwd() 获得当前目录
os.getegid() 获得有效组id os.getgid() 获得组id
os.getuid() 获得用户id os.geteuid() 获得有效用户id
os.setegid os.setegid() os.seteuid() os.setuid()
os.getgruops() 获得用户组名称列表
os.getlogin() 获得用户登陆名称
os.getenv 获得环境变量
os.putenv 设置环境变量
os.umask 设置umask
os.system(cmd) 利用系统调用，运行cmd命令
:return:
"""
pass
sys模块
def demo_sys():
import sys
"""
sys.argv 是一个 list,包含全部的命令行参数
sys.stdout sys.stdin sys.stderr 分别表示标准输入输出,错误输出的文件对象.
sys.stdin.readline() 从标准输入读一行 sys.stdout.write("a") 屏幕输出a
sys.exit() # 直接退出程序，不须要考虑平台等因素的影响，通常是退出Python程序的首选方法。
sys.exit(0) # 默认为0，表示正常退出。为1，表示异常退出
os._exit() # 直接退出，不会抛出异常，可是其使用会受到平台的限制，但咱们经常使用的Win32平台和基于UNIX的平台不会有所影响
os.kill() # 通常用于直接Kill掉进程，可是只能在UNIX平台上有效
os.popen() # 直接执行系统命令，而在Windows下其实就是使用taskkill来kill掉进程，其基本形式是，taskkill /pid 程序的PID号码
"""
print(sys.path) # sys.path 是一个list,指明全部查找module，package的路径
print(sys.platform) # 获得运行的操做系统环境
print(sys.modules) # 是一个dictionary，表示系统中全部可用的module
日历模块
class DemoCalendar(object):
# 返回指定年的某月
@staticmethod
def get_month(year, month):
return calendar.month(year, month)
# 返回指定年的日历
@staticmethod
def get_calendar(year):
return calendar.calendar(year)
# 判断某一年是否为闰年，若是是，返回True，若是不是，则返回False
@staticmethod
def is_leap(year):
return calendar.isleap(year)
# 返回某个月以每一周为元素的序列
@staticmethod
def get_month_calendar(year, month):
return calendar.monthcalendar(year, month)
获取当前函数名
def return_func_name():
"""
sys.getframe().f_code.co_name 方法永远获取当前所在的函数名称，inspect.stack()方法相对更灵活一些，在get_current_function_name函数中，sys获取的函数名称是get_cu
rrent_function_name,而inspect方法返回的结果是function_one。inspect.stack记录了当前的栈内信息，想进一步了解能够打印inspect.stack()信息。
我在function_one函数中调用了get_current_function_name，所以inspect.stack()返回的list中的第一个元组是有关get_current_function_name信息的，第二个元组才是function_one的相关信息。
:return:
"""
pass
文件操做
class DemoFileHandle(object):
"""
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。通常用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。通常用于非文本文件如图片等。
w 打开一个文件只用于写入。若是该文件已存在则将其覆盖。若是该文件不存在，建立新文件。
wb 以二进制格式打开一个文件只用于写入。若是该文件已存在则将其覆盖。若是该文件不存在，建立新文件。通常用于非文本文件如图片等。
w+ 打开一个文件用于读写。若是该文件已存在则将其覆盖。若是该文件不存在，建立新文件。
wb+ 以二进制格式打开一个文件用于读写。若是该文件已存在则将其覆盖。若是该文件不存在，建立新文件。通常用于非文本文件如图片等。
a 打开一个文件用于追加。若是该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容以后。若是该文件不存在，建立新文件进行写入。
ab 以二进制格式打开一个文件用于追加。若是该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容以后。若是该文件不存在，建立新文件进行写入。
a+ 打开一个文件用于读写。若是该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。若是该文件不存在，建立新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。若是该文件已存在，文件指针将会放在文件的结尾。若是该文件不存在，建立新文件用于读写。
"""
@staticmethod
def demo001():
# 打开一个文件
fo = open("foo.txt", "w")
# 打印文件的属性
print("文件名: ", fo.name)
print("是否已关闭 : ", fo.closed)
# print("访问模式 : ", fo.mode)
# print("末尾是否强制加空格 : ", fo.softspace)
print(
fo.read()) # read方法从一个打开的文件中读取文件的字符串。fo.read([count])在这里，count是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，若是没有传入count，它会尝试尽量多地读取更多的内容，极可能是直到文件的末尾。
fo.close() # 关闭打开的文件
# 打开一个文件
fo = open("foo.txt", "r+")
str_tmp = fo.read(10)
print("读取的字符串是 : ", str_tmp)
# 查找当前位置
position = fo.tell()
print("当前文件位置 : ", position)
# 把指针再次从新定位到文件开头
# position = fo.seek(0, 0)
fo.seek(0, 0)
str_tmp = fo.read(10)
print("从新读取字符串 : ", str_tmp)
# 关闭打开的文件
fo.close()
# 重命名文件test1.txt到test2.txt。
os.rename("test1.txt", "test2.txt")
# remove()方法删除文件，须要提供要删除的文件名做为参数
# 删除一个已经存在的文件test2.txt
os.remove("test2.txt")
# 在当前目录下建立一个新目录test
# 建立目录test
os.mkdir("test")
# 进入"/home/newdir"目录
# 将当前目录改成"/home/newdir"
os.chdir("/home/newdir")
# 给出当前目录
# # getcwd()方法显示当前的工做目录
print(os.getcwd())
# 删除目录
# rmdir()方法删除目录，目录名称以参数传递。在删除这个目录以前，它的全部内容应该先被清除。语法：os.rmdir('dirname')。目录的彻底合规的名称必须被给出，不然会在当前目录下搜索该目录。
# 删除”/tmp/test”目录
os.rmdir("/tmp/test")
输出不换行
def no_change_line():
"""
对于python2和python3都兼容的写法是：
print('hello', end='')
python 2.x, print 不换行
print x,
python 3.x print 不换行
print(x, end="")
:return:
"""
print('---', end="")
print('hello', end='')
# print 'hello', # py2
print('---', end="")
读取键盘输入
def demo_input():
"""
Raw_input函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
input([prompt]) 函数和 raw_input([prompt]) 函数基本相似，可是 input 能够接收一个Python表达式做为输入，并将运算结果返回。
"""
# pass
# str = raw_input("Enter your input: ") # py2
str_tmp = input("Enter your input: ") # 都转化为字符串类型
print(str_tmp)
并发问题
def demo_concurrency():
"""
[问题]
python中因为使用了全局解释锁（GIL）的缘由，代码并不能同时在多核上并发的运行，也就是说，Python的多线程不能并发
[GIL总结]
Python的多线程在多核CPU上，只对于IO密集型计算产生正面效果；而当有至少有一个CPU密集型线程存在，那么多线程效率会因为GIL而大幅降低。
Python GIL实际上是功能和性能之间权衡后的产物，它有其存在的合理性，也有较难改变的客观因素。
若是对并行计算性能较高的程序能够考虑把核心部分写成C模块，或用其余语言实现
GIL将会继续存在和改进
[避免GIL影响]
用multiprocessing替代Thread
multiprocessing库的出现很大程度上是为了弥补thread库由于GIL而低效的缺陷。
它完整的复制了一套thread所提供的接口方便迁移。惟一的不一样就是它使用了多进程而不是多线程。
每一个进程有本身的独立的GIL，所以也不会出现进程之间的GIL争抢。
固然multiprocessing也不是万能良药。它的引入会增长程序实现时线程间数据通信和同步的困难。
就拿计数器来举例子，若是咱们要多个线程累加同一个变量，对于thread来讲，申明一个global变量，用thread.Lock的context包裹住三行就搞定了。
而multiprocessing因为进程之间没法看到对方的数据，只能经过在主线程申明一个Queue，put再get或者用share memory的方法。
这个额外的实现成本使得原本就很是痛苦的多线程程序编码，变得更加痛苦了。
用其余解析器
既然GIL只是CPython的产物，那么其余解析器是否是更好呢？没错，像JPython和IronPython这样的解析器因为实现语言的特性，他们不须要GIL的帮助。
然而因为用了Java/C#用于解析器实现，他们也失去了利用社区众多C语言模块有用特性的机会。
因此这些解析器也所以一直都比较小众。毕竟功能和性能你们在初期都会选择前者，Done is better than perfect。
固然Python社区也在很是努力的不断改进GIL，甚至是尝试去除GIL。并在各个小版本中有了很多的进步。
有兴趣的读者能够扩展阅读这个Slide 另外一个改进Reworking the GIL - 将切换颗粒度从基于opcode计数改为基于时间片计数 -
避免最近一次释放GIL锁的线程再次被当即调度 - 新增线程优先级功能（高优先级线程能够迫使其余线程释放所持有的GIL锁）
:return:
"""
pass
web应用：关于wsgi、框架、模板
def demo_wsgi():
"""
其实一个Web App，就是写一个WSGI的处理函数，针对每一个HTTP请求进行响应。
可是如何处理HTTP请求不是问题，问题是如何处理100个不一样的URL。
一个最简单的想法是从environ变量里取出HTTP请求的信息，而后逐个判断.只是这么写下去代码是确定无法维护了
须要在WSGI接口之上能进一步抽象，让咱们专一于用一个函数处理一个URL，至于URL到函数的映射，就交给Web框架来作。
用Python开发一个Web框架十分容易，因此Python有上百个开源的Web框架。
常见web框架
Flask : Flask经过request.form['name']来获取表单的内容。
Django：全能型Web框架；
web.py：一个小巧的Web框架；
Bottle：和Flask相似的Web框架；
Tornado：Facebook的开源异步Web框架。
:return:
"""
pass
如何使用Headless Chrome
def demo_chrome_headless():
"""
Headless模式是Chrome59中的新特征、要使用Chrome须要安装chromedriver、其余用法与PhantomJS基本相同。更多资料请查看官方文档。参考资料：https://developers.google.com/web/updates/2017/04/headless-chrome
:return:
"""
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
chrome_options = Options()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
driver = webdriver.Chrome(chrome_options=chrome_options)
driver.get("https://cnblogs.com/")
print(driver.title)
其余
python2和3不一样
def demo_diff_between_py2_and_py3():
"""
换行
引包
一些模块名（mysql库等）
hashlib在hashing以前要编码
csv&ini读取文件时3须要加编码格式
异常处理写法，另外python3中一个except捕获多个异常须要用元组。
捕获异常时、文件不存在的异常状况异常名不一样
使用套接字的时候有区别，python3要求加一个b
"""
pass
- 语法变化
print再也不是语句而是函数 捕获异常由except exc , var 改成 except exc as var 弃用比较运算符<>为!= from module import * 如今只能用于模块不能用于函数 from .[mouodle] import name 是相对导入惟一正确语法，不以点开头的为绝对导入 sorted函数与列表的sort方法再也不接收cmp参数，使用key参数代替 整数除法如1/2返回浮点数，取整能够用1//2
- 标准库变化
模块删除或者重组,如： urlparse移到urllib.parse 延迟加载模块（import在函数内部）会使函数被调用时才可能发现库不可用
- 数据类型与集合的变化
字符串编码
python优点
def demo_005():
"""
软件开发：游戏后台、搜索、图形界面、网站、c/s软件、科学运算、
系统管理：脚本、it自动化工具、
"""
pass
代码合规手段
def demo_code_standard():
"""
代码合规手段：
测试驱动开发
代码审查
结对编程
性能分析
以及其余让代码更加可靠且符合预期的手段
:return:
"""
相关文章
- 1. Python整理
- 2. Python 变量整理
- 3. python日记整理
- 4. python学习整理
- 5. python 模块整理
- 6. Python笔记整理！
- 7. python 报错整理
- 8. 【python】模块整理
- 9. 整理python笔记
- 10. Python 目录整理
- 更多相关文章...
- • SQLite - Python - SQLite教程
- • Docker 安装 Python - Docker教程
- • Docker 清理命令
- • ☆技术问答集锦（13）Java Instrument原理
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Python整理
- 2. Python 变量整理
- 3. python日记整理
- 4. python学习整理
- 5. python 模块整理
- 6. Python笔记整理！
- 7. python 报错整理
- 8. 【python】模块整理
- 9. 整理python笔记
- 10. Python 目录整理