基本语句

print: 输出

raw_input: 获得输入值

• int() 整形工厂函数（谢谢 MarkNV 和 TonySeek 两位师兄指出原先的错误）
• float() 浮点数工厂函数
• str() 工厂函数
• hex() 工厂函数
• long() 工厂函数
• oct() 将整数转化为八进制的字符串
• ord() 将ascII字符转化为ascII值

math 模块

• sin(x) 正弦
• cos(x) 余弦
• asin(x) 反正弦
• acos(x) 反余弦
• tan(x) 正切
• atan(x) 反正切
• hypot(x,y) 求直角三角形的斜边长度
• fmod(x,y) 求x/y的余数
• ceil(x) 取不小于x的最小整数
• floor(x) 取不大于x的最大整数
• fabs(x) 求绝对值
• exp(x) 求e的x次幂
• pow(x,y) 求x的y次幂
• log10(x) 求x的以10为底的对数
• sqrt(x) 对x的平方根
• pi π值

基本类型

数字类型

例如:

>>> 2.30-1.30
    0.99999999999999978
>>> 07+05    # 八进制
    12
>>> print "%o" % (07 + 05)
    14
>>> prtin "%x" % (0x7 + 0x5)
    c
>>> m = 9 + 3j
>>> n = 15 - 2j
>>> m + n     # 复数
    (24 + 1j)

运算符

运算符优先级：

1. 乘方运算符
2. 乘法、除法、取余
3. 加法、减法
4. 逻辑运算符

只有使用 print 输出字符串时,才会解释字符串中的转义字符

常用字符串操作 (模块 string ) ======================== =========================================================================== 字符串操作 描述 string.capitalize() 将字符串的第一个字母大写 string.count() 获得字符串中某一子字符串的数目 string.find() 获得字符串中某一子字符串的起始位置 0为第一位 -1表示未找到 string.isalnum() 检测字符串是否仅包含0-9 A-Z a-z string.isalpha() 检测字符串是否仅包含A-Z a-z string.isdigit() 检测字符串是否仅包含数字 string.islower() 检测字符串是否均为小写字符 string.isspace() 检测字符串中所有字符是否均为空白字符 string.istitle() 检测字符串中的单词是否为首字母大写 string.isupper() 检测字符串是否均为大写字母 string.join() 连接字符串 将字符串插入到括号内每两个字符之间 string.lower() 将字符串全部转换为小写 string.split() 分割字符串 string.swapcase() 将字符串中大写字母转换为小写,小写字母转换为大写 string.title() 将字符串中的单词 首字母大写 string.upper() 将字符串中全部字母转换为大写 len(string) 获取字符串长度 string * num 表示将字符串重复输出 num 次 ======================== ===========================================================================

格式化字符串

将字符串 s 转换为整数： string.atoi(s[,base])

获得绝对路径：

import os
os.listdir(r'absoulte-path')   # r(或R) 表示不转义

• 列表以 [] 括起来，有顺序，可以修改列表里的数据
• 元组以 () 括起来，有顺序，不能修改元祖内的数据
• 字典以 {} 括起来，无顺序，可以修改字典里的数据

常用文件操作：

打开文件： open(file_name, mode, buffer_size)    # 文件名，模式(r,w,b)，缓存区大小

循环：

for num in [...]:
    continue
    break
else:
    # 未被 break 时执行的代码

range([start,] stop [,step])

函数声明：

def <function_name> (param=default_value[,...]):
    <function_statement>
    return <return_value>

调用函数时，只能一次对参数赋值，不能用(, , x) 之类的赋值。使用下面的例子可以解决：

def example(x=None, y=None, z=None):
    if x is None:
        x = 1
    if y is None:
        y = 2
    if z is None:
        z = 3
    return (x + y + z)

另外，调用函数的时候，可以直接对参数赋值而不考虑参数的顺序：

def fun(x, y):
    return x - y

>>> fun(1, 2)
-1
>>> fun(y=1, x=2)
1

只输入函数名，不加括号，则返回函数在内存中的地址

若想将函数所有参数都放到一个元组里，可以使用： def fun(*params) 若想要函数所有参数都放在一个字典中，可以使用：def func(**params) 在 Python 中，使用可变对象（如列表）来表达改变参数值的目的。

Python 作用域分为：

1. 内置作用域
2. 局部作用域
3. 全局作用域

global x # 定义全局作用域

用 lambda 声明匿名函数（没有函数名的函数）：

fun = lambda x : x * x - 1
>>> fun(3)
8

lambda 适用于小函数，可以调用函数，不能使用 print

导入模块

>>> import module
>>> import module as new_name
>>> from module import func

修改模块查找路径

>>> import os
>>> import sys
>>> os.getcwd()  # 当前工作目录
>>> sys.path     # Python 的查找路径。列表形式。

手动编译

>>> import py_compile
>>> py_compile.compile("/path/to/python/file")

手动优化编译

>>> python -o file/to/output
>>> python -oo file/to/output

Python 脚本中的 ``__name__`` 属性：

• 当脚本被当作模块导入时，__name__ 属性值为该模块名
• 当脚本独立运行时，__name__ 属性值为 __main__

__dir()__ ： 可以获得导入模块中的所有定义的名字、函数。

Python 路径区分大小写！

模块包

• 包相当于一个目录，在目录里新建一个名为 __init__.py 的文件，可以为空，表示这个目录为一个包。
• __init__.py 的主要用途是设置 __all__ 以及包含包初始所需要的代码。
• 相同目录直接使用 import
• 不同目录使用: from A.B import a

** Python 中的正则表达式 **

• 函数用于在字符串中匹配正则表达式 匹配成功返回MatchObject对象实例 re.match(pattern, string [,flags])
• 函数用于在字符串中查找正则表达式,如果找到,则返回MatchObject对象实例.``re.search(pattern ,string[,flags])``
• 函数用于在字符串中查找所有符合正则表达式的字符串,并返回这些字符串的列表.``re.findall(pattern ,string[,flags])``

pattern： 匹配模式

string： 要进行匹配的字符串

flags：可选参数，进行匹配的标志

flags:

1. re.I：忽略大小写。
2. re.L：根据本地设置而更换w W b B s S 的匹配内容
3. re.M 多行匹配模式
4. re.S 使用 "." 元字符匹配换行符
5. re.U 匹配 Unicode 字符。
6. re.X 忽略 pattern 中的空格，并且可以使用 "#" 注释。

re.sub(pattern, replacement, string [,maxcount]) 用于替换字符串中符合正则表达式的内容，它返回替换后的字符串。 re.subn(pattern, replacement, string [,maxcount]) 与 re.sub() 函数相同，只不过返回的是一个元组 re.split(pattern, string [,maxsplit=0]) 用于分割字符串 re.compile(pattern [,flags]) 将正则表达式编译生成正则表达式对象实例后，可以使用正则表达式对象实例提供的属性和方法对字符串进行处理。生成一个 RegexObject 对象实例。

使用组

• 组允许将正则表达式分解成几个不同的组成部分.在完成匹配或者搜索后,可以使用组编号访问不同部分匹配的内容.
• 组的扩展语法

1. (?Lmsux) 设置匹配标志,可以是i.L.m.s.u.x 以及他们的组合.其含义与编译标志相同.
2. (?:...) 表示此非一个组
3. (?P=name) 表示在此之前的名为name的组
4. (?#...) 表示注释
5. (?=...) 用于正则表达式之后,表示如果”=”后的内容在字符串中出现则匹配,但不返回”=”后的内容.
6. (?!...) 用于正则表达式之后,表示如果”!”后的内容在字符串中不出现则匹配,但不返回”!”后的内容.
7. (?<=...) 用于正则表达式之前,与(?=...)含义相同.
8. (?<!...)) 用于正则表达式之前,与(?!...)含义相同.

有关面向对象的思想

• 面向对象强调对象的“抽象”、“封装”、“继承”、“多态”。
• 面向对象程序设计方法的基本思想是将任何事物都当作对象，是其所属对象类的一个实例。
• 每一个对象都有其相对应的对象类。属于同一对象类的对象具有相同的属性以及操作方法等。
• 对象以对象类的形式将其内部的数据或者方法封装。对象与对象之间只是互相传递数据，而不能访问其他对象的内部。
• 对象的内部相对于其他对象来说是不可见的。不同的对象类之间可以通过集成的形式来拥有其他对象的属性和方法等，而形成父子关系。
• 面向对象程序设计的方法的基本过程： (1) 确定对象以其属性和方法等。 (2) 分析对象之间的联系确定其通信机制。 (3) 将具有共同特征的对象抽象为对象类。 (4) 设计、实现类，并确定类相互间的继承关系。 (5) 创建对象实例，实现对形象之间的相互联系。

在Python中可以使用类建立一个对象模型，以及对象所拥有的属性和方法等。该模型能够较好地反应实物的本质，以及其相互之间的关系，其本质是更接近于人类认知事物所采用的计算模型。

类与对象

• 类是面向对象程序设计的基础。类具有抽象性、封装性、继承性和多态性。
• 类的抽象性是指类是对具有共同方法和属性的一类对象的描述。
• 类的封装型是指类将属性和方法封装，对于外部是不可见的。只有通过类提供的接口才能与属于类的实例对象进行信息交换。
• 类的继承性是指类可以由己有的类派生。派生出来的类拥有父类的方法和属性等。
• 类的多态性是指类可以根据不同的参数类型调用不同的方法。同一个方法可以处理不同类型的参数。实际上Python的内部已经很好地实现了多态。在Python中使用类不需要考虑太多不同类型数据之间的处理。
• 每个类都有具有自己的属性和方法。类的属性实际上就是类内部的变量。而类的方法则是在类内部定义的函数。
• 对象是具体的事物，是实例化后的类。每个对象的属性值可能不一样，但所有由同一类实例化得类的对象都拥有共同的属性和方法。
• 在程序中由类实例化生成的对象，然后使用对象的方法进行操作，完成任务。一个类的可以实例化生成多个对象。

** 类的定义 **

• 类的定义与函数的定义类似，但使用`class`关键字。同样需要注意缩进。
• 类的定义一般放在脚本的头部。在PY中也可以在if语句的分支中或者函数定义中定义类。

>>> class class_name:
>>>     statements

• 类还可以通过继承的形式获得。

>>> class sub_name(parent_name):
>>>     statements

• 父类，也就是要继承的类。
• 类定义后就产生了一个名字空间，与函数类似。在类内部使用的属性，相当于函数中的变量名，还可以在类的外部继续使用。类的内部与函数的内部一样，相当于一个局部作用域。不同类的内部也可以使用相同的属性名。

类的使用

类在定义后必须先实例化才能使用。类的实例化与函数调用类似，只要使用类名加圆括号的形式就可以实例化一个类。类实例化以后会生成一个对象。一个类可以实例化多个对象，对象与对象之间并不互相影响。类实例化以后可以使用其属性和方法等。

类的属性和方法

每一个类都具有自己的属性和方法。属性和方法是面向对象程序设计所独有的概念。属性是类所封装的数据，而方法则是类对数据进行的操作。

类的属性

• 类的属性实际上是类内部的变量。
• 类的属性分为 公有属性 和 私有属性。
• 数据保护是面向对象程序设计所特有的，在面向过程的程序设计中并没有数据保护的概念。
• 在Python中，类的内部声明一个私有成员不需要使用private关键字。而是用类中的属性的命名形式来表示类属性是公有还是私有的。
• 类中的私有属性是不能在类的外部进行操作的，这边起到了对属性的保护作用。
• Python中类的属性是以两条下划线开始的话，则该属性为类的私有属性，不能在类的外部被使用或访问。
• 类的方法实际上就是类内部使用def关键字定义的函数。定义类的方法与定义一个函数基本相同，在类的方法中同样也要使用缩进。
• 在类的内部使用def关键字可以为类定义一个方法。与函数定义不同的是，类的方法必须包含参数"self"，且"self"必须为第一个参数。
• 与类的属性相同，类的方法也可以是类私有的，类的私有方法不能在类的外部调用。和类的私有属性命名相同，类的私有方法名也要以两条下划线开始。类的私有方法只能在类的内部调用，而不能在类的外部调用。另外，在类的内部调用起私有方法。要使用"self.私有方法名"的形式。

类的专用方法(Specail Methods)

在PY中有一类以两条下弧线开始并且以两条下划线结束的类的方法，称之为类的转悠方法。专有方法是针对类的特殊操作。(private)

类的继承

• 一个新类可以通过继承来获得已有类的方法以及属性。
• 新类可以继承父类的共有属性和共有方法，但是不能继承分类的私有属性和私有方法。多重继承

多重继承是指创建的类同时拥有几个类的属性和方法。多重继承与单重继承不同的是在类名后边的圆括号中包含多个父类名，父类名之间用逗号分开。

class class_name(parent1, parent2):
     pass

多重继承需要注意圆括号中的父类名字的顺序。如果父类中有相同方法名，而在类中使用是未定义父类名，则使用前面的父类的方法。

*重载 ！*

重载允许通过继承而创建的类重新定义父类的方法。不仅可以重载方法，而且还可以重载运算符，以使用自创建的类。

方法重载

• 通过继承而创建的类，其父类的方法不一定能满足类的需要。新类实际上只是该部分功能，为了避免明明函数的麻烦而可以使用方法重载来解决。
• 方法的重载实际上就是在类中使用`def`关键字重载父类的方法。如果重载父类中的方法，但又需要在类中先使用父类的该方法，可以使用父类名加`.`加方法名的形式调用。

运算符重载

Python中运算符都有相对应的函数，在类中运算符都有相对应的专有方法。因此运算符的重载实际上是对运算符对应的专有方法的重载。

模块中的类

类与函数一样，也可以写到模块中。在其他的脚本中可以通过导入模块名使用定义的类。模块中类的使用方式与模块中函数类似。实际上可以将模块中的类当作函数一样使用。

异常与调试

使用``try``语句处理异常。和 Python 中其他语句一样，try``语句也要使用缩进结果。``try 语句也有一个可选的 else 语句块。

try:
    pass
except<exception1>:
    pass
except<exception2>:
    pass
else:
    pass

try语句还有另外一种特殊的形式:

try:
    pass
finally:
    pass

不管try语句中是否发生异常,都将执行finally 语句块。

多重异常处理

在Python中可以在try语句中嵌套另外一个try语句。由于Python将try语句放在堆栈中，一旦引发异常，Python将匹配最近的except语句。如果except忽略该异常，则异常将被外围try语句捕获。

引发异常

除了内置的异常意外，在Python中还可以通过使用raise语句手工引发异常。在类中也可以使用raise 引发异常，并向异常传递数据。使用raise可以定义新的错误类型，以适应脚本的需要。例如对用户输入数据的长度有要求，则可以使用raise引发异常，以确保数据输入符合要求。

使用raise引发异常

raise exception
raise exception, data
raise class_name
assert  simplified_raise_statement
assert  condition_test, exception_data

• 在Python中使用 assert 语句同样可以引发异常。但与 raise 语句不同， assert 语句是在条件测试为假时，才引发异常.
• assert 一般用于开发时对程序条件的验证.只有当内置``__debug__``为``True``时，assert``语句才有效.当 Python 脚本以 -O 选项编译成字节码文件时，``assert 语句将被移除.

自定义异常类

在 Python 中可以通过继承 Exception 类来创建自己的异常类。异常类和其他的类并没有区别，一般仅在异常类中定义几个属性信息。

使用pdb调试

在 Python 中脚本的语法错误可以被 Python 解释器发现，但是脚本出现的错误，或者其他的一些变量使用错误却不容易被发现。如果脚本运行后没有获得预想的结果，则需要对脚本进行调试。pdb模块是Python自带的调试模块。使用该模块可以为脚本设置断点、单步执行、查看变量值等。pdb模块可以以命令行参数的形式启动，也可以通过 import 将其导入使用。

运行语句

run(statement [,global[, localst]])
statement: 要调试的语句块，以字符串的形式。
globals 可选参数,设置statement 运行的全局环境变量.
locals 可选参数 设置statement运行的局部环境变量

运行表达式

在 Python 中可以使用 pdb 模块的 runeval 函数来调试表达式。

runevel(expression[,globals[,locals]])
expression：要调试的表达式，以字符串的形式。
globals：可选参数，设置statement运行的全局环境变量。
locals：可选参数，设置statement运行的局部环境变量。

运行函数

在 Python 中可以使用 pdb 模块的 runcall` 函数来调试函数。

runcall(function[, argument,...])
function  函数名
argument  函数的参数

设置硬断点

在Python中可以使用pdb模块的set_trace函数在脚本中设置硬断点.set_trace 函数一般在".py"脚本中使用。

set_trace()
(Pdb) list  列出脚本内容
(Pdb) continue   继续执行

Python扩展和嵌入

• 通过扩展Python 用C/C++来完成对效率要求高的部分.Python功能强大,完全可以将其嵌入到C/C++中.
• Python提供了支持C/C++接口,可以方便地使用C/C++来扩展Python.用C/C++编写的Python扩张主要用于完成底层的系统操作,以及提高执行速度.
• Python提供了接口API.通过使用API函数可以编写Python扩展.