Python 学习札记（一）

深入python

• http://sebug.net/paper/books/dive-into-python/html/index.html
• http://sebug.net/paper/books/python_hb/
  
• http://www.pythontab.com/html/pythontutorial3/

1.
静态类型语言一种在编译期间就确定数据类型的语言。大多数静态类型语言是通过要求在使用任一变量之前声明其数据类型来保证这一点的。 Java 和  C 是静态类型语言。 动态类型语言一种在运行期间才去确定数据类型的语言，与静态类型相反。 VBScript 和  Python 是动态类型的，因为它们确定一个变量的类型是在您第一次给它赋值的时候。 强类型语言一种总是强制类型定义的语言。 Java 和  Python 是强制类型定义的。您有一个整数，如果不明确地进行转换 ，不能将把它当成一个字符串。 弱类型语言一种类型可以被忽略的语言，与强类型相反。JavaScript是弱类型的。在 JavaScript中，您可以将字符串 '12' 和整数 3 进行连接得到字符串'123'，然后可以把它看成整数 123 ，所有这些都不需要任何的显示转换。

所以说 Python 既是动态类型语言 (因为它不使用显示数据类型声明)，又是强类型语言 (因为只要一个变量获得了一个数据类型，它实际上就一直是这个类型了)。

2.
文档化函数： 可以通过给出一个 doc string  (文档字符串) 来文档化一个  Python  函数。

3.

万物皆对象： 一切都可以赋值给变量或作为参数传递给函数

模块导入的搜索路径：import sys; sys.path

在运行时，通过向 sys.path 追加目录名，就可以在 Python 的搜索路径中增加新的目录，然后当您导入模块时，Python 也会在那个目录中进行搜索。这个作用在 Python 运行时一直生效。

4.

代码缩进：硬回车和‘:’分割代码

5.

所有的  Python  模块都是对象，并且有几个有用的属性。

与  C  一样， Python  使用 ==  做比较，使用 =  做赋值。与  C  不一样， Python  不支持行内赋值，所以不会出现想要进行比较却意外地出现赋值的情况。

6.

内置数据类型：Dictionary(字典)、List(列表)、Tuple(元组)、Set(集合)

7. Dictionary

键和值之间一对一的关系

Dictionary 没有元素顺序的概念

Dictionary 的 key 是大小写敏感的

del 允许您使用 key 从一个Dictionary中删除独立的元素。

clear 从一个 Dictionary 中清除所有元素。注意空的大括号集合表示一个没有元素的 Dictionary。

8. List

是一个用方括号包括起来的有序元素的集合。

列表下表总是从 0 开始。

负数索引从 List 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素的下标总是 -1 。

如果负数索引使您感到糊涂，可以这样理解：List[-n] == List[len(List) - n]。

您可以通过指定 2 个索引得到 List 的子集，叫做一个 “ slice ” 。返回值是一个新的 List，它包含了 List 中按顺序从第一个 slice 索引  开始，直到但是不包括第二个 slice 索引 的所有元素。

如：List[1:2]    List[:2]    List[1:]    List[:]    List[1:-1]    List[-3:-1]

append  向 List 的末尾追加单个元素

insert  将单个元素插入到 List 中。数值参数是插入点的索引。请注意，list 中的元素不必唯一

extend  用来连接 List

List 的两个方法 extend  和 append  看起来类似，但实际上完全不同。extend  接受一个参数，这个参数总是一个 List，并且把这个 List 中的每个元素添加到原 List 中。

如：li = ['a', 'b', 'c']    li.extend(['d', 'e', 'f'])  ===> li = ['a', 'b', 'c', 'd', 'e', 'f']

li = ['a', 'b', 'c']    li.append(['d', 'e', 'f'])  ===> li = ['a', 'b', 'c', ['d', 'e', 'f']]

index 方法 在 list 中查找一个值的首次出现并返回索引值。

如果在 List 中没有找到值， Python  会引发一个异常。

要测试一个值是否在 List 内，使用 in 。如果值存在，它返回 True ，否则返为 False  。

remove  方法从 List 中删除一个值的 首次出现 。

如果在 List 中没有找到值， Python  会引发一个异常来响应 index  方法。

pop  方法是一个有趣的东西。它会做两件事：删除 List 的最后一个元素，然后返回删除元素的值。请注意，这与 List[-1]  不同，后者返回一个值但不改变 List 本身。也不同于 List.remove(value) ，后者改变 List 但并不返回值。

pop方法也可以传入index参数，明确要删除元素的下标索引。

List运算符：

• List 也可以用 + 运算符连接起来。list = list + otherlist 相当于 list.extend(otherlist)。但 + 运算符把一个新 (连接后) 的 List 作为值返回，而 extend 只修改存在的 list。也就是说，对于大型 List 来说，extend 的执行速度要快一些。
• Python 支持 += 运算符。li += ['two'] 等同于 li.extend(['two'])。+= 运算符可用于 list、字符串和整数，并且它也可以被重载用于用户自定义的类中。
• * 运算符可以作为一个重复器作用于 list。li = [1, 2] * 3 等同于 li = [1, 2] + [1, 2] + [1, 2]，即将三个 list 连接成一个。

9. Tuple

Tuple 是不可变的 List。一旦创建了一个 Tuple，就不能以任何方式改变它。

定义 tuple 与定义 list 的方式相同，但整个元素集是用小括号包围的，而不是方括号。

与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时，会得到一个新的 list ；当分割一个 tuple 时，会得到一个新的 tuple。

Tuple 没有方法， 可以使用 in  来查看一个元素是否存在于 tuple 中。

Tuple 和 List 对比

• Tuple 比 List 操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 Tuple 代替 List。
• 如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 Tuple 而不是 List，如同拥有一个隐含的 assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 Tuple 到 List 的转换 (需要使用一个特殊的函数)。
• Tuple 可以作为List的Key，而List不行。
• Tuple 可以用在字符串格式化中。

Tuple 可以转换成 List，反之亦然。内置的 Tuple  函数接收一个 List，并返回一个有着相同元素的 Tuple。而 List  函数接收一个 Tuple 返回一个 List。从效果上看，Tuple  冻结一个 List，而 List  解冻一个 Tuple。

补充1：集合(set)

• 数据类型—— set （集合） 。集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持 union（联合），intersection（交），difference（差）和sysmmetric difference（对称差集）等数学运算。
• 大括号或 set() 函数可以用来创建集合。 注意：想要创建空集合，你必须使用 set() 而不是 {}。
• 集合推导式----a = {x for x in 'abracadabra' if x not in 'abc'} ==>{'r', 'd'}

10. 连续赋值

(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)

a, b, c = (1, 2, 3)

x, y, z = 'I', 'am', 'boy'

11. 字符串格式化与字符串连接的比较

• + 是字符串连接操作符。
• 试图将一个字符串同一个非字符串连接会引发一个异常。与字符串格式化不同，字符串连接只能在被连接的每一个都是字符串时起作用。

12. 映射 List

对 List 的解析并不改变原始的 List。

join 方法：连接List与分割字符串

join  只能用于元素是字符串的 List；它不进行任何的强制类型转换。连接一个存在一个或多个非字符串元素的 List 将引发一个异常。

split 方法：将一个字符串分割成一个List。split方法可以接受第二个可选参数，表明需要分割的次数。

13.可选参数和命名参数

def info(object, spacing = 10, collapse = 1)

14.使用 type、str、dir和其他内置函数

• type 函数返回任意对象的数据类型
• str 函数将数据强制转换为字符串。（每一种数据都可以强制转换为字符串，当作用于模块时，其字符串形式包含了模块在磁盘上的路径名）
• dir 函数，返回对象的所有部件(方法，变量， 属性等)的列表
• callable 函数，它接受任何对象作为参数，如果参数是可调用的，返回True，否则返回False

15.通过 getattr 获取对象引用

• getattr是一个有用到令人无法致信的内置函数，可以返回任何对象的任何属性。
• 可以用于内置数据类型，也可以用于模块。

16.使用 getattr 创建分发者

def output(data, format = "text"):

output_funciton = getattr(XXX, "output_%s" % format)

return output_function(data)

17.过滤列表

[mapping-expression for element in source-list if filter-expression]

eg:

methodList = [method for method in dir(object) if callable(getattr(object, method))]

18.and 和 or 的特殊性质(短语判断)

and 和 or 执行布尔逻辑演算。但是它们并不返回布尔值，而是返回它们实际进行比较的值之一。

19.lambda函数

lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。lambda 函数不能包含命令， 包含的表达式不能超过一个。

lambda 函数在布尔环境中总是为真。

20. Python中的类

• 定义：class className[(superClass)]:
• __init__方法，功能类似C++中的构造函数，但是在Python中，调用__init__时，实例对象已经存在了。
• 类的每一个方法的第一个参数都是指向当前实例的引用，self。但是在调用的时候，不需要管它，Python会自动加上此参数。
• 当一个类继承自一个父类时，子类方法中必须显示的调用父类中合适的方法。
• 注意 __init__ 方法从不返回一个值。
• 创建类的实例，只需要调用一次类即可，不需要加入new操作符。

21. 垃圾回收--“引用计数”

22. 专用类方法  不应该手动调用这些专用方法，而且使用一些特殊语法时Python自动调用的。专用方法可以被重写。

• __getitem__ 正确地使用 __getitem__ 的方法是让 Python 来替你调用。比如：dict[key]
• __setitem__
• 更多的专用方法
• __repr__
• __cmp__
• __len__
• __delitem__

23. Python中的私有函数

• 私有函数不可以从它们的模块外面被调用
• 私有类方法不能够从它们的类外面被调用
• 私有属性不能够从它们的类外面被访问
• 以两个下划线("__")开始，且不以两个下划线结束：私有方法/属性
• 以两个下划线("__")开始，且以两个下划线结束：专用方法/内置属性
• Python中对私有方法采用 name manging 技术，将私有方法自动改名“_className + functionName”

24. 文件目录

使用 os/os.path或者glob模块。glob模块允许使用通配符来匹配目录或则文件。

25. Python中的正则表达式，支持松散的正则表达式结构

pattern = re.compile(r''''

    ....      #here have some comments

    ....      #comments

'', re.VERBOSE);

26. 基于dictionary的字符串格式化

params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}

"%(pwd)s" % params

27. locals 和 globals

locals返回当前作用域的变量组成的字典，globals不但返回全局变量（还包括被导入的模块，模块中定义的类及函数等）。

locals是只读的，globals不是。locals实际上没有返回局部名字空间，它返回的是一个拷贝。而globals返回实际的全局名字空间，它不是一个拷贝，与locals的行为完全相反。

28. 包

所谓的包(package)，实际上都是一个个的py文件，或者是多个py文件组合在一起的。

包的导入实际就是导入包目录的__init__.py文件。包的逻辑结构(包括类和方法等)都会在__init__.py中作声明。(其实它可以什么也不定义；可以只是一个空文件，但是必须要存在。 )

• from xml.dom import minidom 从一个嵌套包 (xml.dom)中导入一个模块 (minidom)
• from xml.dom.minidom import Element 从一个来自嵌套包 (xml.dom) 的模块 (minidom) 中导入一个类 (Element)
• from xml import dom 导入 dom 包 (xml 的一个嵌套包)，并将其作为一个模块
• import xml 将根层次的 xml 包作为一个模块导入

29. Python Unicode

使用如下的声明方式：

s = u'Dive in' 

• 在打印时，Python会试图将字符串转换为你的默认编码，通常是 ASCII 编码。
• 如果原始的字符串中包含非 ASCII 字符，必须进行encode。如下
• s = u'La Pe\xf1a',  print s.encode('latin-1')
• 转换的默认编码也是可以定制的
• sys.setdefaultencoding()
• 定制文件的编码  # -*- coding: UTF-8 -*-

30. 输入流和类文件对象

抽象输入流：需要输入流的函数接受一个类文件(file-like)对象，所谓的类文件对象会带有一个read方法去读文件，可能还会有一个size参数，用来确定一次读取多大size的内容。避免直接操作物理文件。

StringIO模块：将一个字符串转换为一个类文件对象。屏蔽了原始输入源，这里原始的输入源就是一个硬编码的字符串。

eg: 接受单个参数source，并返回类文件对象。source 是某种类型的字符串；它可能是一个 URL (例如 'http://slashdot.org/slashdot.rdf')，一个本地文件的完整或者部分路径名 (例如 'binary.xml')，或者是一个包含了待解析 XML 数据的字符串。

def openAnything(source):                  
    # try to open with urllib (if source is http, ftp, or file URL)
    import urllib                         
    try:                                  
        return urllib.urlopen(source)      
    except (IOError, OSError):            
        pass                              

    # try to open with native open function (if source is pathname)
    try:                                  
        return open(source)                
    except (IOError, OSError):            
        pass                              

    # treat source as string
    import StringIO                       
    return StringIO.StringIO(str(source)) 

31. 标准输入、输出、错误

stout stderr 都是类文件对象，但是他们是只读的，没有read方法。

32.......