[置顶] Python核心编程总结

  一、快速入门

1、Python不支持C语言的自增和自减操作

2、Python字符串有其特有的索引:第一个字符的索引是0，最后一个字符的索引是-1

3、print语句会默认的在每一行添加一个换行符，只要在print语句的最后添加一个逗号，就可以改变它的行为

二、Python基础

1、每一个Python脚本文件都可以被当成一个模块，模块以磁盘文件的形式存在。

2、Python赋值并不是将一个值赋给一个变量，对象是通过引用传递。

3、Python不支持前缀、后缀的自增、自减

4、Python不支持重载标识符，所以任何时刻都只有一个名字绑定

5、Python导入所需的模块，每个模块之导入一次，当函数内部的模块导入代码时不会被执行，除非该函数正在执行

6、如果模块是被导入的，__name__的值为模块名字；如果模块是被直接执行的，__name__的值为'__main__'

三、Python基础

1、对于对象身份是否一样（见博客）

2、str()函数得到的字符串可读性好，而repr()函数得到的字符串通常可以用来重新获得该对象，通常情况obj === eval(repr(obj))这个等式是成立的；而str就不行。但是要记住也不是repr后的对象都能通过eval重新获得此对系那个的原型的。

3、一个能保存单个字面对象的类型我们称为原子或标量存储，那些可以容纳多个对象的类型，我们称为容器存储（复合对象），且这些容器可以容纳不同类型的对象。

4、类型是否可变

可变类型： 列表、字典

不可变类型：数字、字符串、元组

（可变或不可变是否指更改后id是否一样）

5、python不支持字符类型，只有字符串类型

6、访问分类

直接访问：数字

顺序访问：字符串、列表、元组

映射访问：字典

四、数字

1、删除一个对象的引用del方法

2、Python的长整型与C语言或者其他编译型语言不同，能表达的值仅仅与你的机器支持的虚拟内存大小相关

五、序列：字符串、列表和元组

1、原始字符串的目的是为了对付那些在字符串中出现的特殊字符。在原始字符串里，所有的字符都是直接安装字面的意思来使用，没有转移特殊或不能打印的字符。

2、原始字符串仅仅是在紧靠第一个引号前加一个'r'也可以大写来表示。

3、chr返回函数对应的ASCII字符，而ord相反

4、string.find和string.index的区别是对于找不到find函数会返回一个-1的值，而index则会返回一个异常

5、三引号让程序员从引号和特殊字符串泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓所见所得格式的。

6、字符串是不可改变的，所以对字符串的一个字符或者一片字符的改动都是不允许的

7、Python标准库里面的绝大部分模块都是兼容Unicode的，除了pickle模块

8、一般用extend()方法来代替连接操作符把一个列表的内容加到另外一个列表中去，extend方法不会像连接操作重新建立一个新的列表

9、列表类型有属于自己的方法，列表才能构建--列表解析

10、列表用sorted进行排序时，排序使用的是字典序，而不是字母序（字面'T'的ASCII码值要比字面'a'的还要靠前）

11、无聊是list还是tuple都不可能完全的转换，传个tuple的一个列表对象不可能变成一个元组，而你传给list的对象也不可能真正的变成一个列表，虽然前后两个对象有着相同的数据集合（所以相等==），但是变量指向的却不是同一个对象了（is 操作会返回False）。

12、用index()来检查一个元素是否存在于一个list中并不是好主意，因为我们错了我，应该先用in成员关系操作符检查下，然后在用index()找到这个元素的位置。

13、那些可以改变对象值的可变对象的方法是没有返回值的

14、只有一个元素的元组需要在元组分隔符里面加一个逗号（，）用以防止跟普通的分组操作符混淆

In [86]: kTuple = ('a',)

In [87]: type(kTuple)
Out[87]: <type 'tuple'>

In [88]: kTuple = ('a')

In [89]: type(kTuple)
Out[89]: <type 'str'>

15、由于元组是不可变的，所以没有办法单独的删除一个元组的元素，当然可以把不需要的元素丢弃后，重新组成一个元组是没问题的。要显示的删除一整个元组，只要用del语句减少对象引用计数。当引用计数达到0的时候，该对象就会被析构

16、由于元组不可变性，排序、替换、添加等对于元组操作来说就是多余的，这些方法没有被实现

17、元组对象本身是不可变的，但这并不意味元组包含的可变对象也不可变的；当元组内的某个元素是列表的时候就可以改变了

In [103]: print aTuple
--------> print(aTuple)
(123, 'abc', ['a'], ['a', 'b'])

In [104]: aTuple[3][0] = 'd'

In [105]: aTuple
Out[105]: (123, 'abc', ['a'], ['d', 'b'])

18、序列类型对象的浅拷贝是默认类型拷贝，并可以以下几种方式实施：（1）完全切片操作[:]（2）利用工厂函数，比如list(),dict()等，（3）使用copy模块的copy函数

19、深拷贝要采用copy.deepcopy()函数

20、关于拷贝的操作的警告：第一、非容器类型（比如数字、字符串、和其他原子类型的对象、像代码、类型和xrange对象等）没有被拷贝一说，浅拷贝是用完全切换操作来完成的。第二、如果元组变量只包含原子类型对象，对它的深拷贝将不会进行。

第六章 映射和集合类型

1、用工厂方法dict()来创建字典或者采用内建方法（版本2.3起）fromkeys()来创建一个"默认"字典

2、内建方法update()将整个字典的内容添加到另外一个字典

3、字典可以和所有的标准类型操作符一起工作，但却不支持像拼接和重复这样的操作。

4、字典大小算法的比较：首先是字典的大小，然后是键，最后是值，如果都一样的话则认为两者相等

5、字典中的元素是没有顺序的，输出不一样按你输入的一样

6、列表和字典这样的可变类型都是不可哈希的，不能作为键值；所有不可变的类型都是可哈希的。值相等的数值表示相同的键，即整型数字和浮点型数字值相同的话，在他们是相同的键值；元组不可变，但是也不是一成不变，所以要元组做有效的键值要有必要的限制，元组中只能包括像数字和字符串这样的不可变参数才可以。

7、集合有两种不同的类型：可变集合（set）和不可变集合（frozenset）

8、如果左右两个操作数的类型相同，多是可变集合或不可变集合，则所产生的记过类型是相同的，当如果不相同的话生成左的操作类型

9、

第七章 条件和循环

第八章 文件和输入输出

1、文件只是连续的字节序列，数据的传输经常会用到字节流，无论字节流由单个字节还是大块数据组成

2、当使用输入方法如read()或者readlines()从文件中读取行时，Python并不会删除行结束符，这个操作被留给程序员，反之用write()或者writelines()输出时也不会自动加入行结束符，应该程序员自己完成

3、text()方法是对seek()方法的补充，告诉你当前文件指针在文件中的位置

4、write和writelines的区别？？

5、Python提供了两个模块用来辅助处理命令行参数，原始模块getopt模块更简单，但不是很精细，而optparse更强大，且面向对象，若是简单的选项就采用getopt，复杂的话在采用optparse

第九章 错误和异常

1、可以在一个except子句里处理多个异常，except语句在处理多个异常时要求异常被放在一个元组里

2、如果确定需要捕获所有的异常，那么就使用新的BaseException

3、finally中的代码引发了另外一个异常或由于return、break、continue语法而终止，原来的异常将丢失而且无法重新引发

第十章 函数和函数式编程

1、许多静态类型的语言主张一个函数的类型就是其返回值的类型。在python中，由于python是动态地确定类型而且函数能返回不同类型的值，所以没有进行直接的类型关联

2、所有的对象都是通过引用来传递的，函数也不例外，当一个变量赋值时，实际是将相同对象的引用赋值给这个变量

3、函数可以作为参数传入其他函数来进行调用

4、函数调用中使用*和**符号来指定元组和字典的元素作为非关键字以及关键字参数的方法

5、可以通过使用functional模块中的partial()函数来创建PFA（偏函数）要警惕关键字

6、如果将全局变量的名字声明在一个函数体内的时候，全局变量的名字能被局部变量给覆盖掉。所以此时要用global语句声明

7、在2.1之前的版本中，最多为两个作用域：一个函数的局部作用域和全局作用域，虽然存在多个函数的嵌套，但不能访问超过两个作用域

8、闭包更适合需要一个必需有自己的作用域的回调函数情况，尤其是回调函数是很小巧而且简单的

9、

[root@aa python]# cat my_lambda.py
#!/usr/bin/env python

x = 10
def foo():
     y = 5
     bar = lambda y=y: x + y
     print bar()
     y = 8
     print bar()

foo()

[root@aa python]# python my_lambda.py
15
15

原因是外部y的值被传入并在lambda中设置，所以虽然其值在稍后改变了，但是lambda的定义没变，若要改变替换的方案就是在lambda表达式中加入对函数局部变量y进行引用的局部变量z

[root@aa python]# cat my_lambda.py
#!/usr/bin/env python

x = 10
def foo():
     y = 5
     bar = lambda z: x + z
     print bar(y)
     y = 8
     print bar(y)

foo()

以上是针对2.1以前的版本才需要这样，2.1以后的版本由于支持可以访问超过两个鱼3就无需这样了，直接写

[root@aa python]# cat my_lambda.py
#!/usr/bin/env python

x = 10
def foo():
     y = 5
     bar = lambda : x + y
     print bar()
     y = 8
     print bar()

foo()

第十一章 模块

1、访问一个属性时，解释器必须在三个名称空间中的一个找到它，首先从局部名称空间开始，如果没有找到，解释器将继续查找全局名称空间，如果这也失败了，它将在内建名称空间里查找。

2、模块导入顺序

Python标准库模块

Python第三方模块

应用程序自定义模块

3、如果在一个模块的顶层导入，那么它的作用域是全局的，如果在函数中导入，那么它的作用域是局部的

4、一个模块只被加载一次，无论它被导入多少次

5、Python实现__future__指令让程序员为新事物做好准备。from __future__ import new_feature；只import_future__不会有任何变化，所以这是被禁止的。（事实上这个允许的，但它不会如你想的启用所有的特性）你必须显示地导入指定特性

6、reload()内建函数可以重新导入一个已经导入的模块，模块必须全部导入，且必须被导入成功。函数的参数必须是模块自身而不是好汉模块名的字符串。

7、import语句总是绝对导入，所以相对导入只应用于from-import语句

第十二章 面向对象编程

1、所有新式类必须继承至少一个父类，参数可以是一个（单继承）或多个（多重继承）用于继承父类。

2、object是"所有类之母"，如果你的类没有继承人和其他父类，boject将作为默认的父类。

3、Python严格要求，没有实例，方法是不能被调用的。这种限定就是Python所描述的绑定

4、查看类的属性，最简单实用dir()内建函数，另外是通过访问类字典属性__dict__，这是所有类都具备的特殊属性之一

5、__init__()应该返回None，如果定义了构造函数，它不应当返回任何对象，因为实例对象是自动在实例化调用后返回的。

6、实例仅有两个特殊属性：

I.__class__ 实例化I的类

I.__dict__ I的属性

7、__dict__属性由一个字典组成，包含一个实例的所有属性，键是属性名，值是属性对应的数据值。字典中仅有实例属性，没有类属性或特殊属性

8、可以采用类来访问类属性，如果实例没有同名的属性的话，也可以用实例来访问；此时若是类属性可变的情况下，通过实例修改此属性，对于类的属性也同样会发生改变

9、方法只有在其所属的类拥有实例时，才能被调用，当存在一个实例时，方法才被认为是绑定到那个实例了

10、staticmethod()和classmethod()内建函数创建静态方法和类方法

11、文档字符串对于类、函数/方法还有模块来说都是唯一的。不会被继承

12、Error when calling the metaclass bases

    Cannot create a consistent method resolution
order (MRO) for bases

13、重写__init__不会自动调用基类的__init__

14、多重继承有两个方面需要记住：首先要找到合适的属性，另外一个就是当你重写方法时，如何调用对应父类方法以"发挥他们的作用"

15、经典类，使用深度优先算法，因为新式类继承自object，新的菱形类继承结构出现，问题也就接着而来了，所以必须新建一个MRO

第十三章 执行环境

1、当用户输入一个列表是时，raw_input()返回一个列表字符串描绘，而input()返回实际的列表

第十四章 正则表达式

1、match是尝试从字符串起始处进行匹配，而search则是从左到右进行搜索匹配