Python基础知识笔记

　　以守护进程运行python脚本，nohup python test1.py &1.基础知识1.0 包package
　　python package需要有一个名为init.py的文件，不然就是普通的package，则无法import package下的模块。可以在init.py文件里写入要被使用的模块，这样import package时，系统会直接去init.py里面寻找模块或者函数。
　　当导入一个package时，python解释器会首先在内置模块中寻找，若没有则在sys.path列表中寻找。参考
　　1.1 变量命名规则
　　python变量名只能包含以下字符：大小写字母、数字、下划线(_)，名称不允许以数字开头。并且以下划线开头的名字有特殊含义。
　　1.2 可变对象与不可变对象
　　可变对象：列表list、字典dict、集合set不可变对象：数值(int,float)、字符串(str)、元组(tuple)
　　1.3python容器
　　列表
　　创建列表：a=[],a=list() 赋值：a=[],b=a  此时，a,b共享同一个对象。 复制(新表)：a=[],b=a.copy(),c=list(a),d=a[:]  此时b，c，d是新的对象，不共享，和a没有任何关系。属于浅复制；浅复制只复制一层(外层)
　　元组
　　创建元组：a=(),a=tuple()  a=(1,)等价于a=1, 元组元素不可更改
　　字典
　　创建字典：a={}，a=dict() 复制：copy() 赋值：=
　　集合
　　创建集合：a=set(),a={1} 集合运算：交集(&),并集(|),差集(-)
　　1.4 格式化
　　python有两种格式化方式，习惯称为旧式和新式；这两种方式在python2和python3中都适用。
　　使用%的旧式格式化
　　旧式格式化的形式为：string % data，其中string包含的式待插值序列。
　　>>> ＂%s＂%4.12 ＂4.12＂ >>> ＂%f＂%4.12 ＂4.120000＂ >>> ＂my name is %s,age is %d ＂%(＂ss＂,14) ＂my name is ss,age is 14 ＂ >>> ＂%10d %10f %10s＂%(12,11,＂dad＂)  #设置最小域宽度为10格字符，左侧用空格补充 ＂        12  11.000000        dad＂ >>> ＂%-10d %-10f %-10s＂%(12,11,＂dad＂)  #左对齐 ＂12         11.000000  dad       ＂ >>> ＂%.4f %.3d＂%(12.13131,11)  #数据截断，设置最大字符宽度 ＂12.1313 011＂
　　使用{}和format的新式格式化
　　>>> ＂{}{}＂.format(12,13) ＂1213＂ >>> ＂{1}{0}＂.format(12,13)  #指定插入的顺序，参数从0开始。 ＂1312＂ >>> ＂{m}{n}＂.format(n=12,m=13)  #命名变量参数 ＂1312＂ >>> ＂{1:d} {0:f}＂.format(12,13)  #使用:实现格式化类型 ＂13 12.000000＂ >>> ＂{1:<4d} {0:<5f}＂.format(12,13)  #左对齐<，右对齐>,居中^ ＂13   12.000000＂ >>> ＂{1:^4d} {0:<5.3f}＂.format(12,13) #精度和旧式一样，但也有不同 ＂ 13  12.000＂ >>> ＂{:^4.3}＂.format(12)  #新格式中无法对整数设定精度 Traceback (most recent call last):   File ＂＂, line 1, in 
　　1.5 代码注释
　　#单行注释1 print(123)#单行注释2  #多行注释1 #ddd #ddd #ddd  ＂＂＂ 多行注释2 ddd ＂＂＂
　　1.6 python2 VS python3
　　1.6.1 print
　　在python3中，print是函数，使用 print(＂helloworld＂)             不换行输出，print(＂hello＂,end=＂＂)                        print(＂world＂)   输出：helloworld 在python2中，print是关键字，print ＂helloworld＂             不换行输出，pring ＂hello＂,                        print ＂world＂   输出：hello world (以空格分割)
　　1.6.2 input
　　--------python2 >>> a=input()      #会做计算处理 12 >>> print a,type(a) 12  >>> a=raw_input()   #对输入都以字符串处理 12 >>> print a,type(a) 12  >>> --------python3 >>> a=input() 12 >>> print(a) 12 >>> print(type(a))  #所有输入都作为字符串处理  >>>
　　1.6.3 整除
　　-----------python2 >>> print 5/2    #向下取整 2         -----------python3 >>> print (5/2)  #默认进行浮点数除法 2.5 >>> print (5//2)  #取模 2
　　1.6.4 range
　　-------------python2 >>> print range(4)   #返回列表 [0, 1, 2, 3] ------------python3 >>> print(range(4))  #返回range对象 range(0, 4) #循环访问py2和py3基本一样
　　1.6.5 字符串
　　python3表示字符串的两种类型：bytes和str，前者的实例包含原始的8位值(一个字节)，后者实例包含unicode字符。 python2表示字符串的两种类型：unicode和str，前者包含Unicode字符，后者包含原始的8位值。 二进制转化为Unicode字符，使用decode；Unicode字符转二进制，使用encode。
　　1.6.6 列表推导产生的变量泄漏问题
　　python2
　　>>> x = ＂my precious＂ >>> dummy = [x for x in ＂ABC＂] >>> x ＂C＂ >>> dummy [＂A＂, ＂B＂, ＂C＂]
　　python3
　　>>> x = ＂my precious＂ >>> dummy = [x for x in ＂ABC＂] >>> x ＂my precious＂ >>> dummy [＂A＂, ＂B＂, ＂C＂]
　　python2中，在列表推导中同名变量的赋值可能会影响上下文环境；而在python3中，都有自己的局部作用域。使用生成器则不会出现这种变量泄漏问题。
　　1.6.7 import
　　python2默认是按照相对路径导入模块和包，python3默认则是按照绝对路径导入。
　　python2引入一个module时会先在当前目录搜索，然后再去搜索路径(sys.path)搜索；而python3直接在搜索路径搜索，为了导入，使用显式路径导入。
　　Python2.x 缺省为相对路径导入，Python3.x 缺省为绝对路径导入。绝对导入可以避免导入子包覆盖掉标准库模块（由于名字相同，发生冲突）。如果在 Python2.x 中要默认使用绝对导入，可以在文件开头加入如下语句：
　　from __future__ import absolute_import
　　这句 import 并不是指将所有的导入视为绝对导入，而是指禁用 implicit relative import（隐式相对导入）, 但并不会禁掉 explicit relative import（显示相对导入）。
　　from .foo import Foo    #python2、3都适用 from .bar import Bar    #python2、3都适用 #from mdl.foo import Foo    #python2、3都适用 #from mdl.bar import Bar    #python2、3都适用 #from foo import Foo    #python3不适用 #from bar import Bar    #python3不适用
　　1.6.8 Exception
　　py2 : except exc, var
　　py3 : except exc as var,使用 as 作为关键词
　　1.6.9 不等运算符
　　Python 2.x中不等于有两种写法 != 和 <>
　　Python 3.x中去掉了<>, 只有!=一种写法
　　1.6.10 dict方法
　　py2中dict的keys()、items()、values() 是列表,iteritems()返回迭代器
　　py3中dict的keys()、items()、values() 是类或迭代器，非基础数据类型，执行json的加解密时，需要注意
　　py3中iteritems() 和 viewitems() 这两个方法都已经废除了，而items()得到的结果是和py2里面viewitems()一致的。在py3里用items()替换iteritems() ，可以用于for来循环遍历
　　1.6.11 数据类型
　　在Python2中long是比int取值范围更大的整数，Python3中取消了long类型，int的取值范围扩大到之前的long类型范围。
　　python3版本中增加了bytes类型
　　1.6.12 重载
　　当我们想对python中原有的模块进行覆盖，又不希望退出当前的程序，就需要用到重载的概念
　　# python2 内置函数 reload(module)  # python3  from importlib import reload reload(module)
　　1.7 项目依赖库安装
　　pip freeze > requirements.txt 导出项目的依赖。pip install -r requirements.txt 在项目中一次性安装依赖
　　1.8 用venv 配置不同的开发环境
　　pip install virtualenv进入到项目目录，执行virtualenv --no-site-packages venv(虚拟环境到名字) no-site-packages意思是不复制系统到安装包，得到的是纯净的环境激活虚拟环境 source venv/bin/activate。进入了venv环境，pip包时只安装到该环境下，系统python环境不受任何影响(windows系统venvScriptsactivate)，激活后Python 解释器的路径就被添加进PATH 中。退出虚拟环境 deactivate,回到系统python环境
　　python3内置了用于创建虚拟环境的venv，可直接使用python3 -m venv .venv（Linux下）
　　py -3 -m venv .venv
　　virtualenv --python=/usr/local/bin/python3 env3 #创建指定python版本的虚拟环境 --python 指定python解释器
　　1.9.代码风格
　　折叠长行的首选方法是在小括号，中括号，大括号中使用Python隐式换行。长行可以在表达式外面使用小括号来变成多行。连续行使用反斜杠更好。和None比较用is缩进使用4个空格，而不要用tab不要在for和while后面用else为变量赋值时，赋值符号的左右侧应该各自写上一个空格。文件中的函数和类之间应该用两个空行隔开。在同一个类中，各方法之间应该用一个空行隔开。
　　1.10.新式类和旧式类
　　python2中既有新式类又有旧式类，并且默认为经典类，只有显示继承object才是新式类。
　　class a(Object):pass    #新式类写法 class a():pass        #经典类(旧式类)写法 class a:pass            #经典类写法        类.mro()      #查看解析顺序列表，只有新式类有该属性。     ---------------------------------------------------------------------- class a():     pass c=a() print dir(c) ---------------------------------out [＂__doc__＂, ＂__module__＂] class a(object):     pass c=a() print dir(c) ----------------------------   ---out [＂__class__＂, ＂__delattr__＂, ＂__dict__＂, ＂__doc__＂, ＂__format__＂, ＂__getattribute__＂, ＂__hash__＂, ＂__init__＂, ＂__module__＂, ＂__new__＂, ＂__reduce__＂, ＂__reduce_ex__＂, ＂__repr__＂, ＂__setattr__＂, ＂__sizeof__＂, ＂__str__＂, ＂__subclasshook__＂, ＂__weakref__＂] *:在编写python类时，尽量使用新式类，其包含更多属性。
　　python3中只有新式类，默认式新式类，不必显式继承object。
　　新式类增加了slots内置属性, 可以把实例属性的种类锁定到slots规定的范围之中。
　　如果类是经典类，在多继承的情况下，会按照深度优先方式查找；如果类是新式类，在多继承的情况下，会按照广度优先方式查找；
　　1.11.python序列化
　　什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
　　json是可以在不同语言之间交换数据的，而pickle只在python之间使用。json只能序列化最基本的数据类型，而pickle可以序列化所有的数据类型，包括类，函数都可以序列化。
　　序列化的目的：
　　以某种存储形式使自定义对象持久化。将对象从一个地方传递到另一个地方。使程序更具维护性。
　　1.11.1 Json序列化
　　用于字符串 和 python数据类型间进行转换
　　Python
　　JSON
　　dict
　　object
　　list, tuple
　　array
　　str, unicode
　　string
　　int, long, float
　　number
　　True
　　true
　　False
　　false
　　None
　　null
　　JSON
　　Python
　　object
　　dict
　　array
　　list
　　string
　　unicode
　　number (int)
　　int, long
　　number (real)
　　float
　　true
　　True
　　false
　　False
　　null
　　None
　　-----------------------------loads和dumps--------------------------- import json dic = {＂k1＂:＂v1＂,＂k2＂:＂v2＂,＂k3＂:＂v3＂} str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串 print(type(str_dic),str_dic)  # {＂k3＂: ＂v3＂, ＂k1＂: ＂v1＂, ＂k2＂: ＂v2＂} #注意，json转换完的字符串类型的字典中的字符串是由＂＂表示的  dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典 #注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由＂＂表示 print(type(dic2),dic2)  # {＂k1＂: ＂v1＂, ＂k2＂: ＂v2＂, ＂k3＂: ＂v3＂}   list_dic = [1,[＂a＂,＂b＂,＂c＂],3,{＂k1＂:＂v1＂,＂k2＂:＂v2＂}] str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型  print(type(str_dic),str_dic) # [1, [＂a＂, ＂b＂, ＂c＂], 3, {＂k1＂: ＂v1＂, ＂k2＂: ＂v2＂}] list_dic2 = json.loads(str_dic) print(type(list_dic2),list_dic2) # [1, [＂a＂, ＂b＂, ＂c＂], 3, {＂k1＂: ＂v1＂, ＂k2＂: ＂v2＂}] -------------------------load和dump---------------------------- import json f = open(＂json_file＂,＂w＂) dic = {＂k1＂:＂v1＂,＂k2＂:＂v2＂,＂k3＂:＂v3＂} json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件 f.close()  f = open(＂json_file＂) dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回 f.close() print(type(dic2),dic2
　　1.11.2 pickle序列化
　　用于python特有的类型 和 python的数据类型间进行转换。pickle操作文件时，需要以二进制的方式操作。
　　import pickle dic = {＂k1＂:＂v1＂,＂k2＂:＂v2＂,＂k3＂:＂v3＂} str_dic = pickle.dumps(dic) print(str_dic)  #一串二进制内容  dic2 = pickle.loads(str_dic) print(dic2)    #字典  import time struct_time  = time.localtime(1000000000) print(struct_time) f = open(＂pickle_file＂,＂wb＂) pickle.dump(struct_time,f)   #f.write(pickle.dumps(struct_time)) f.close()  f = open(＂pickle_file＂,＂rb＂) struct_time2 = pickle.load(f)  #struct_time2=pickle.loads(f.read()) print(struct_time2.tm_year)
　　1.11.3 json序列化非基本数据类型
　　如果目标对象是基本数据类型，则不会执行转换方法
　　import json  class Info(object):     def __init__(self,name,age):         # super().__init__()         self.name=name         self.age=age  info=Info(＂selfeasy＂,12)  #由于json不支持将对象转为为序列化对象，所以需要做转换处理，实现default方法 ＂＂＂两种转换方式 1. 实现default参数所指定的方法 2. 继承JSONEncoder，并实现default方法 ＂＂＂ # 1. 实现default方法, 当反序列化时，为了保持原来的目标对象，需要实现object_hook所指向的函数方法 def makeJson(obj):     return dict(name=obj.name,age=obj.age)  def load_Json(obj):     return Info(obj[＂name＂], obj[＂age＂])  a=json.dumps(info, default=makeJson) print(a) print(json.loads(a,object_hook=load_Json))   # 2.继承JSONEncoder,实现default方法  class JsonMake(json.JSONEncoder):     def default(self, o):         if isinstance(o,Info):             return dict(name=o.name,age=o.age)         return super().default(o)  a=json.dumps(info, cls=JsonMake) print(a) print(json.loads(a,object_hook=load_Json))
　　1.12.猴子补丁(Monkey patch)
　　在动态语言中，不去改变源码而对功能进行追加和变更，是在程序运行的过程中去修改。
　　1.追加功能 2.功能变更 3.修正程序错误
　　4.增加钩子，在执行某个方法的同时执行一些其他的处理，如打印日志，实现AOP等。
　　class XiaoMing(object):     def favorite(self):         print ＂apple＂  class God(object):     @classmethod     def new_xiaoming_favorite(cls):         print ＂banana＂      @classmethod     def monkey_patch(cls):         XiaoMing.favorite = cls.new_xiaoming_favorite  God.monkey_patch()  xiaoming = XiaoMing() xiaoming.favorite() >> banana
　　1.13.上下文管理器
　　上下文管理器是一个对象，为操作提供了额外的上下文消息，以一种优雅的方式将额外的处理封装起来。如果一个类实现了__enter__和__exit__方法则表明该类的实例是一个上下文管理器。上下文管理器通常和with搭配使用。实现上下文管理器的两种方式：类和装饰器
　　类实现上下文管理器
　　class context(object):     def __init__(self):         print (＂上下文管理器初始化＂)          def __enter__(self):         print(＂上下文管理器开始执行＂)         return self          def __exit__(self,exec_type, exec_value, exec_traceback):         print (＂上下文执行结束＂)      def operator(self):         print (1/2) with context() as obj:     obj.operator() --------------------------------out 上下文管理器初始化 上下文管理器开始执行 0.5 上下文执行结束
　　备注 :当operator改为1/0时，程序执行后抛出异常；但是当在exit方法中返回True时(默认为False)，程序不会报错，因为结果返回true就表示告诉python解释器，异常已捕获并解决，不需要往外抛了。
　　装饰器实现上下文管理器
　　可以不用写一个类来实现上下文管理器，类的实现过于繁杂。python提供了一个装饰器，只需按照它的协议来实现函数内容，即可以将该函数对象变成一个上下文管理器。
　　from contextlib import contextmanager from traceback import format_exc @contextmanager def context(a,b):     print (＂上下文管理器开始运行＂)  #enter方法     f=a/b     try:         yield f     except Exception:         print (＂处理异常＂)     finally:         print(＂finally＂)   with context(1,2) as f:     print (123)     print(f) ----------------------------------out 上下文管理器开始运行 123 0.5 finally
　　备注:try之前的代码会在装饰器的__enter__方法中执行；当执行到yield时，它的产出值会作为__enter__的返回值，赋值给as后的变量。当with块的代码执行完成后，上下文管理器会在yield处恢复，继续执行yield后的代码，后面的代码在装饰器的__exit__方法中被调用。
　　当程序发生异常时，后面的代码不会执行(包括finally代码)
　　上下文管理器类与@contextmanager中最大的区别在于对异常的处理。以类的方式实现的上下文管理器，在引发异常时，exit方法内的代码仍会正常执行；而以生成器函数实现的上下文管理器，在引发异常时，exit方法会将异常传递给生成器，如果生成器无法正确处理异常，则yield之后的代码不会执行。
　　1.14. 可散列的数据类型
　　如果一个对象是可散列的，那么在这个对象的生命周期中，它的散列值是不变的，而且这个对象需要实现 __hash__() 方法。另外可散列对象还要有 __eq__() 方法，这样才能跟其他键做比较。如果两个可散列对象是相等的，那么它们的散列值一定是一样的。原子不可变数据类型(str、bytes 和数值类型)都是可散列类型。
　　1.15. Python 运行时
　　python -m xxx  #相当于import，当作模块运行，当前脚本路径不会加入到sys.path中。 python xxx.py  #直接运行，当前脚本路径会加入到sys.path中。  python -m site #显示sys.path的值内容，即python搜索模块的目录
　　1.16. 原地操作
　　许多运算符都有原地操作，如add方法对应的原地操作是iadd。python中的运算符和operator模块中的函数是对应的
　　不可变类型的目标
　　对于不可变的目标如字符串、数字、元组等，当调用一个原地方法是，分两步执行，运算和赋值。当调用原地函数时，只执行运算嘛，不执行赋值操作。如下：
　　>>> import operator >>> a=＂hello＂ >>> operator.iadd(a, ＂ world＂)#若要更新变量，则需要执行赋值操作，即a=operator.iadd(a, ＂ world＂) ＂hello world＂ >>> a ＂hello＂
　　可变类型的目标
　　对于可变的目标，如列表、字典，原地方法将执行更新，因此不需要后续赋值操作。如下:
　　>>> import operator >>> s = [＂h＂, ＂e＂, ＂l＂, ＂l＂, ＂o＂] >>> iadd(s, [＂ ＂, ＂w＂, ＂o＂, ＂r＂, ＂l＂, ＂d＂]) [＂h＂, ＂e＂, ＂l＂, ＂l＂, ＂o＂, ＂ ＂, ＂w＂, ＂o＂, ＂r＂, ＂l＂, ＂d＂] >>> s [＂h＂, ＂e＂, ＂l＂, ＂l＂, ＂o＂, ＂ ＂, ＂w＂, ＂o＂, ＂r＂, ＂l＂, ＂d＂]
　　1.17 python -c 和-m区别
　　0. python xxx.py 直接运行 1. python -m xxx.py当作模块执行，相当于import 2. python -c 当作命令，脚本执行
　　1.18 查看包搜索路径的几种方法
　　import sys from pprint import pprint pprint(sys.path)
　　python -c ＂import sys;print sys.path＂
　　python -m site
　　1.19 快速构建HTML帮助文档
　　python -m pydoc -p 8180 #开启本地http服务
　　1.20 字符串转义
　　正则表达式re中就用到了转义
　　当字符串中使用到特殊字符时，有时候我们不想让其发生转义，而想原样式输出，我们可以使用r字符来定义原始字符串。如下：
　　str = ＂Python Java＂  print(str) # out  Python Java  str = r＂Python Java＂ print(str)  # out Python Java
　　2.错误解决方法
　　2.1 ImportError错误
　　普通的package和python packae
　　错误分析:from package import xxx 时，package无法被识别为python package      解决办法：在package下新建__init__.py即可，此时package被视为python package
　　循环导入
　　from a  inport b  # module a     from b import a   # module b
　　解决办法:
　　在模块的最后使用import语句。在函数内导入模块(即使用到该模块内容的函数内部)