一、温故而知新

1. 变量命名方式

旧的方式：

 username = 'xxxx'

 password = 'oooo'

新的方式：

 username, password = 'xxxx', 'oooo'

2. Python中如何定义常量

　　常量：指一旦初始化之后就无法修改的固定值。

　　Python中实际是没有这样的名称去定义一个常量的。但是通常变量名是全部大写的话，表示一个常量。比如：MYSQL_CONNECTION。

　　同时，《Python Cookbook》一书中提供了定义常量模块const，此类是定义了一个方法__setattr__()和一个异常类型ConstError，主要是判断定义的常量是否在字典中，在则抛出异常，否则，给新创建的常量赋值。代码如下：

 class _const:

     class ConstError(TypeError):pass

     def __setattr__(self,name,value):

         if self.__dict__.has_key(name):

             raise self.ConstError,"Can't rebind const (%s)"% name

         self.__dict__[name]=value

 import sys

 sys.modules[__name__]=_const()

　　经测试python2中可以运行，且报出异常const.ConstError: can't rebind const(magic)

3. pyc文件和__pycache__是怎么回事？And pyo ？

3.1 pyc 文件

　　pyc 是由py文件经过编译后二进制文件(也叫字节码文件)，py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由python 的虚拟机来执行的。pyc的内容，是跟python的版本相关的，不同版本编译后的pyc文件是不同的。

　　官方还有这样一段解释如下：

　　A program doesn't run any faster when it is read from a ‘.pyc’ or ‘.pyo’ file than when it is read from a ‘.py’ file; the only thing that's faster about ‘.pyc’ or ‘.pyo’files is the speed with which they are loaded.

　　When a script is run by giving its name on the command line, the bytecode for the script is never written to a ‘.pyc’ or ‘.pyo’ file. Thus, the startup time of a script may be reduced by moving most of its code to a module and having a small bootstrap script that imports that module. It is also possible to name a ‘.pyc’ or ‘.pyo’file directly on the command line.

如何手动生成：

　　python2.7版本中，通过如下方式可以生成：（Python3.5测试失败）

 Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec 5 2015, 20:40:30) [MSC v.1500 64 bit (

AMD64)] on win32

 Type "help", "copyright", "credits" or "license" for more information.

2 >>> import py_compile

3 >>> py_compile.compile("b.py")

4 >>> exit()

　　另外一种方式则是在其他python文件中import 该文件，无论2.7还是3.5都是可以生成的。

3.2 __pycache__

　　为了提高模块加载的速度，每个模块都会在__pycache__文件夹中放置该模块的预编译模块，命名为module.version.pyc,version是模块的预编译版本编码，一般都包含Python的版本号。例如在CPython 发行版3.5中，shopping.py文件的预编译文件就是：__pycache__/shopping.cpython-35.pyc。这种命名规则可以保证不同版本的模块和不同版本的python编译器的预编译模块可以共存。运行的当前脚本（__main__）不会生成pycache，被import的那些modules才会.

　　脚本在运行之前会首先检查python文件的最后编辑日期和预编译模块的编译时间，从而决定是否需要重新编译。预编译模块也是跨平台的，所以不同的模块是可以在不同的系统和不同的架构之间共享的。Python在两种情况下不检查缓存。第一种，从命令行中直接加载的模块总是会重新编译并且结果不保存。第二种，如果没有源模块，则不会检查缓存。为了支持无源代码的部署方式，应该将预编译模块放在源代码文件夹中而不是__pycache__中，并且不要包含源代码模块。

3.3 pyo ???　

　　pyo文件，是python编译优化后的字节码文件。pyo文件在大小上，一般小于等于pyc文件。如果想得到某个py文件的pyo文件，可以这样：
　　python -O -m py_compile xxxx.py。

　　参数说明：使用-O和-OO参数来降低预编译模块的大小。-O开关会去除assert语句，-OO开关会去除assert语句和__doc__字符串。因为有些模块要依赖这些语句，因此只有当你确认模块的内容时才去使用这些开关。优化模块的后缀名是.pyo。

　　.pyo和.pyc文件的执行速度不会比.py文件快，快的地方在于模块加载的速度。

　　compileall模块可以用来把某个文件夹的中的所有文件都编译成为.pyc或者.pyo文件。

官方的一段解释：

　　When the Python interpreter is invoked with the -O flag, optimized code is generated and stored in .pyo files. The optimizer currently doesn’t help much; it only removes assert statements. When -O is used, all bytecode is optimized; .pyc files are ignored and .py files are compiled to optimized bytecode.
　　A program doesn’t run any faster when it is read from a .pyc or .pyo file than when it is read from a .py file; the only thing that’s faster about .pyc or .pyo files is the speed with which they are loaded.

贴一个其他网站的对比图：

4. Python3 与Python2的另外一点区别

　　详情看下边的输出：

Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2015, 01:54:25) [MSC v.1900 64 bit (AM

D64)] on win32

Type "help", "copyright", "credits" or "license" for more information.

>>> a=12837912739817983719379179321

>>> type(a)

<class 'int'>

>>> exit()

Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec  5 2015, 20:40:30) [MSC v.1500 64 bit (

AMD64)] on win32

Type "help", "copyright", "credits" or "license" for more information.

>>> a=12837912739817983719379179321

>>> type(a)

<type 'long'>

　　从上边可以看出，python3中，int和long统一整合为“int”型。

5. is和 == 的区别

　　is检查两个对象是否是同一个对象(同一性)，类似C语言中的指针。判断同一性，可以用id来查看下在内存的地址空间。。(obj1 is obj2) 等价于 (id(obj1) == id(obj2))

　　==检查他们是否相等（等值性）。

异常现象：

python2中如果比较float型数字， 比如a,b = 2.5,2.5 那么id(a) != id(b)

python3中如果比较float型数字， 比如a,b = 2.5,2.5 那么id(a) == id(b)　

　　上述的变化，或许是python3的一些优化，具体原因我还不知道，后续如果有学习到，会进行更新。

6. 字符串拼接符 “+” 、join 和 "%s"占位符的区别#这里的说法不一定正确，等待以后能力达到了， 自己去研究底层实现的区别

　　“+”是copy内存复制,所以每次“+”都需要进行内存拷贝,而join是一次性拷贝。

　　“%s”也是在定义变量的时候，提前划分一块内存空间出来。

　　当然了，不妨试试str.format()

二、新知识整理

1. 列表

　 python3中，新增copy和clear方法，代码如下

     def clear(self): # real signature unknown; restored from __doc__

         """ L.clear() -> None -- remove all items from L """

         pass

     def copy(self): # real signature unknown; restored from __doc__

         """ L.copy() -> list -- a shallow copy of L """

         return []

2.7与3.5的另一个差异：
　　2.7中，可以直接对列表进行排序,list.sort() ，列表中可以存在数字和字符串。
　　3.0中，会提示错误: TypeError: unorderable types: str() < int()。详情看下面代码：

 >>> a=['b',]

 >>> a.sort()

 Traceback (most recent call last):

   File "/work/shopping.py", line , in <module>

     a.sort()

 TypeError: unorderable types: int() < str()

2. 字典

python3 中去除了Python2 dict的has_key 、iteritems 、 itervalues 、 iterkeys、viewvalues 等方法。具体原因不知道...但是感觉少了迭代器，麻烦了很多。有迭代器，各种遍历不得不说会效率高很多……If you want to return an iterator in Python3.x, use iter(dictview) :

 >>> d = {'one':'', 'two':''}

 >>> type(d.items())

 <class 'dict_items'>

 >>>

 >>> type(d.keys())

 <class 'dict_keys'>

 >>>

 >>>

 >>> ii = iter(d.items())

 >>> type(ii)

 <class 'dict_itemiterator'>

 >>>

 >>> ik = iter(d.keys())

 >>> type(ik)

 <class 'dict_keyiterator'>

另外，随机的一些方法尽量少用：例如   dict.iterms() dict.values() dict.fromkeys() dict.popiterms()

3. 元组

　　tuple在python2/3中，无明显差异，具体不再说明。

4. 字符串

　　对于字符串，我一般是按照字符串=list的方式来记忆以及使用的。虽然不具备list的诸多方法，但是还是有很多共通处的。下面介绍string的几个非常好用的方法。

4.1 string.format(*args, **kwargs)

　　.format方法用来格式化输出字符串。与%s占位符是一样的。

>>> name='My name is {name} ,age is {age}'

>>> name.format(name='Bob',age=33)

或

>>> name='My name is {0} ,age is {1}'

>>> name.format(name='Bob',age=33)

输出：

>>> My name is Bob ,age is 33

4.2 string.center(width, fillchar=None)

　　.center方法返回指定长度的字符串，不足用fillchar来进行两侧填充。

 >>> name = 'Home Work Is Hard'

 >>> print(name.center(40,'#'))

 输出：

 ###########Home Work Is Hard############

5. 补充collections模块

　　Python的collections模块在这些内置数据类型的基础上，提供了几个额外的数据类型：namedtuple, defaultdict, deque, Counter, OrderedDict等，其中namedtuple和OrderDic是两个很实用的扩展类型。（写博客我认为最忌讳的就是洋洋洒洒一大堆，自己记忆麻烦，别人看着累赘，没有突出点）

5.1 namedtuple命名元组

namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。

eg : 如果要用坐标和半径表示一个圆，可以用namedtuple定义：

 from collections import *

 Yuan = namedtuple('circle',['x','y','z'])

 #或者Yuan = nametuple('circle','x y z')

 yuan = Yuan(1,2,3)

 print(yuan.x)

 print(yuan.y)

 print(yuan.z)

 输出：

 1

 2

 3

　　再来一个更加贴近实际的例子

from collections import namedtuple

# 变量名和namedtuple中的第一个参数一般保持一致，但也可以不一样

Student = namedtuple('Student', 'id name score')

# 或者 Student = namedtuple('Student', ['id', 'name', 'score'])

students = [(1, 'Wu', 90), (2, 'Xing', 89), (3, 'Yuan', 98), (4, 'Wang', 95)]

for s in students:

  stu = Student._make(s)

  print stu

#def _make(cls, iterable, new=tuple.__new__, len=len):

#       'Make a new named tuple object from a sequence or #iterable.'

#       return new(cls, iterable) 

# Output:

# Student(id=1, name='Wu', score=90)

# Student(id=2, name='Xing', score=89)

# Student(id=3, name='Yuan', score=98)

# Student(id=4, name='Wang', score=95)

5.2 OrderDic有序字典

　　使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。如果要保持Key的顺序，可以用OrderedDict

 >>> from collections import OrderedDict

 >>> d = dict([('a', 1), ('b', 2), ('c', 3)])

 >>> d # dict的Key是无序的

 {'a': 1, 'c': 3, 'b': 2}

 >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

 >>> od # OrderedDict的Key是有序的

 OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

 >>> od = OrderedDict()

 >>> od['z'] = 1

 >>> od['y'] = 2

 >>> od['x'] = 3

 >>> list(od.keys()) # 按照插入的Key的顺序返回

 ['z', 'y', 'x']

5.3 deque双向队列

　　本质上就是一个列表……只是增加了一些双向操作的方法。这里不再多描述。

今天的整理总结就到这儿，希望看完之后大家能有不同的收获。