目录
目录
侵删https://www.jianshu.com/p/a305c66c4f5a
https://www.jianshu.com/p/a6dc94930dcd
def list_demo():
list_tmp = ['1', '2', '4', '5']
pprint(''.join(list_tmp)) # 将list变为字符串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])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 相反，可理解为解压，返回二维矩阵式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))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))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]))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 0def 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_sumdemo_lambda = lambda x, y, z: x + y + z"""
装饰器
比如在函数调用前后自动打印日志，但又不希望修改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 resulthttps://www.cnblogs.com/zengjielin/p/8582826.html
setting.py–>ALLOWED_HOSTS = [“*”] //修改配置
python3 manage.py runserver 0.0.0.0:8000 //启动https://github.com/r35tart/RW_Password
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
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=N6gIUbWVtgDoxrlksfFMBznbTlwAcaz9NT2MmEYQ8wLRSKGE2pBTbMA1Z41jzL2M
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）2018年01月30日 15:43:35 我心永恒999 阅读数：58418
pip install opencv-python
win10 python3.6可用
现在已经不行了，pip3可以缩进问题问题：
使用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.packages.urllib3.disable_warnings(InsecureRequestWarning)
requests.get(url_temp)....class Person(object):
__slots__ = ("name", "age")'''
# 比较推荐的开发工具包四个：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。
''''''
类的访问限制
类属性前加双下划线、并给方法召回或修改属性
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的新的字符串的语法
'''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 + 1def 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]) # 取倒数第一个元素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) # 字节流 bytesdef 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位置def random_demo():
pprint(random.randint(1, 100)) # 生成随机数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)# python -m compileall xxx.pyclass 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 清华
"""
passdef 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
"""
passdef 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
"""
passdef demo_py_catalog():
"""
python模块位置
Python自带的模块：/usr/lib/python2.7/urllib.py
Python第三方模块：/usr/local/lib/python2.7/site-packages
"""
passdef 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代码复杂度）三个工具。
"""
passdef 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()
"""
passdef 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" % "输出字符") # 输出格式为：字体默认，红色前景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))def demo_bs4():
"""
bs4模块
新的库、但是价值小。支持多进程、不支持多线程、单例对象、每次只能一个一个处理、；
bs 4一分钟解析30多个页面、lxml700多页面
:return:
"""
passdef demo_xingneng_simple():
"""
参考地址：https://blog.csdn.net/sinat_38682860/article/details/80600473?from=timeline&isappinstalled=0
方法：
1、优化算法时间复杂度
算法的时间复杂度对程序的执行效率影响最大，在 Python 中可以通过选择合适的数据结构来优化时间复杂度，如 list 和 set 查找某一个元素的时间复杂度分别是O(n)和O(1)。
不同的场景有不同的优化方式，总得来说，一般有分治，分支界限，贪心，动态规划等思想。
2、减少冗余数据
如用上三角或下三角的方式去保存一个大的对称矩阵。在0元素占大多数的矩阵里使用稀疏矩阵表示。
3、合理使用 copy 与 deepcopy
对于 dict 和 list 等数据结构的对象，直接赋值使用的是引用的方式。
而有些情况下需要复制整个对象，这时可以使用 copy 包里的 copy 和 deepcopy，这两个函数的不同之处在于后者是递归复制的。效率也不一样：（以下程序在 ipython 中运行）
4、使用 dict 或 set 查找元素
5、合理使用生成器（generator）和 yield
使用()得到的是一个 generator 对象，所需要的内存空间与列表的大小无关，所以效率会高一些。
但是对于需要循环遍历的情况，后者的效率反而更高，但是如果循环里有 break,用 generator 的好处是显而易见的。yield 也是用于创建 generator：
6、优化循环
循环之外能做的事不要放在循环内
7、优化包含多个判断表达式的顺序
对于 and，应该把满足条件少的放在前面，对于 or，把满足条件多的放在前面。
8、用 join 合并迭代器中的字符串
9、选择合适的格式化字符方式
% format 和 string直接相加 三种方式 选用format吧
10、不借助中间变量交换两个变量的值
a,b=1,2
a,b=b,a
11、使用 if is
12、使用级联比较x < y < z
13、hile 1 比 while True 更快
14、使用**而不是 pow
15、使用 cProfile, cStringIO 和 cPickle 等用c实现相同功能（分别对应profile, StringIO, pickle）的包
16、使用最佳的反序列化方式
17、使用C扩展(Extension)
18、并行编程
19、终级大杀器：PyPy
20、使用性能分析工具
"""概述
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() 用于在主线程中退出。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证书不受信任，关闭打开的fiddler从python 3.6开始，enum34库不再与标准库兼容。该库也是不必要的，因此您只需卸载它即可。
pip3 uninstall enum34
pip3 install --index-url https://pypi.douban.com/simple/ pyinstaller方式1：cx_Freeze
方式2：py2exe
py2exe与安装的py版本有关
方式3：pyinsatller
pyinstaller -F -w (-i icofile) filename
默认-D，生成的带目录
-F，生成单一文件
-w，表示隐藏程序运行时的命令行窗口（不加-w会有黑色窗口）
-p，指定依赖路径
-i，指定图标def demo_pycharm():
"""
ctrl+alt+l 格式化
ctrl+f4 关闭页签
"""
passdef demo_set_pycharm():
"""
Ctr+Alt+L快速格式化
ctrl+/快速注释
code style->python设置代码默认快速格式化格式
PyCharm3.0默认快捷键(翻译的)
1、编辑（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 关闭运行的选项卡
2、查找/替换(Search/Replace)
F3 下一个
Shift + F3 前一个
Ctrl + R 替换
Ctrl + Shift + F 全局查找
Ctrl + Shift + R 全局替换
3、运行(Running)
Alt + Shift + F10 运行模式配置
Alt + Shift + F9 调试模式配置
Shift + F10 运行
Shift + F9 调试
Ctrl + Shift + F10 运行编辑器配置
Ctrl + Alt + R 运行manage.py任务
4、调试(Debugging)
F8 跳过
F7 进入
Shift + F8 退出
Alt + F9 运行游标
Alt + F8 验证表达式
Ctrl + Alt + F8 快速验证表达式
F9 恢复程序
Ctrl + F8 断点开关
Ctrl + Shift + F8 查看断点
5、导航(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显示书签
6、搜索相关(Usage Search)
Alt + F7/Ctrl + F7文件中查询用法
Ctrl + Shift + F7文件中用法高亮显示
Ctrl + Alt + F7显示用法
7、重构(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提取参数
8、控制VCS/Local History
Ctrl + K提交项目
Ctrl + T更新项目
Alt + Shift + C查看最近的变化
Alt + BackQuote(’)VCS快速弹出
9、模版(Live Templates)
Ctrl + Alt + J当前行使用模版
Ctrl +Ｊ插入模版
10、基本(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可以改变主题，所有配色统一改变
"""
passdef 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:
"""
passdef demo_lower_calss_init_use_super_error():
"""
出现的TypeError: must be type, not classobj 原因及解决
python中super只能应用于父类为新类，而不能应用于父类为经典类
所谓新类就是所有类都必须要有继承的类，如果什么都不想继承，就继承到object类。经典类报错
"""
passdef 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")))def demo_snownlp():
"""
国人开发/针对中文文本进行挖掘/已有算法，需自己调用函数，根据不同的文本构建语料库/
snownlp：
中文分词（算法是Character-Based Generative Model）
词性标注（原理是TnT、3-gram隐马）
情感分析（官网指明购物类评论准确率较高，因为语料库主要是购物方面，可自己构建相关领域语料库替换）
文本分类（原理是朴素贝叶斯）
转换拼音
繁体转简体
提取文本关键词（原理是TextRank）
提取摘要（原理是TextRank）
分割句子
文本相似（原理是BM25）。
"""
passdef 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:
"""
passdef 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:
"""
passdef 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，表示系统中所有可用的moduleclass 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:
"""
passclass 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:
"""
passdef 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:
"""
passdef 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)def demo_diff_between_py2_and_py3():
"""
换行
引包
一些模块名（mysql库等）
hashlib在hashing之前要编码
csv&ini读取文件时3需要加编码格式
异常处理写法，另外python3中一个except捕获多个异常需要用元组。
捕获异常时、文件不存在的异常情况异常名不同
使用套接字的时候有区别，python3要求加一个b
"""
passprint不再是语句而是函数
捕获异常由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在函数内部）会使函数被调用时才可能发现库不可用字符串编码def demo_005():
"""
软件开发：游戏后台、搜索、图形界面、网站、c/s软件、科学运算、
系统管理：脚本、it自动化工具、
"""
passdef demo_code_standard():
"""
代码合规手段：
测试驱动开发
代码审查
结对编程
性能分析
以及其他让代码更加可靠且符合预期的手段
:return:
"""原文：https://www.cnblogs.com/w00chann/p/10897889.html