python入门笔记

#！/usr/bin/python	说名解析器
# -*- coding: UTF-8 -*-  可以进行中文注释
正则表达式：\  r  "" ‘’
不需要声明、定义，直接拿来变量就用
unicode :u
True False (注意大写)
if else  elif 制表缩进 后带冒号 if hh==5：
while ：注意空格与tab  else ：
for i in range(1,5)
break continue
int(raw_input(""))输入；len(s)获取s的长度strlen

标准数据类型：
｛
Numbers（数字）
String（字符串）""
List（列表）[]
Tuple（元组）()
Dictionary（字典）{}
｝
数字类型：
｛
int（有符号整型）10
long（长整型[也可以代表八进制和十六进制]）51924361L
float（浮点型）0.0
complex（复数）3.14j
｝
字符串
｛
字符串或串(String)是由数字、字母、下划线组成的一串字符。
python的字串列表有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
如果你的实要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = 'Hello World!'

print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第五个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串
｝
列表
{
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
列表用[ ]标识
#!/usr/bin/python
# -*- coding: UTF-8 -*-

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print list # 输出完整列表
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个的元素
print list[2:] # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表
}
元组
｛
类似于List（列表）。
·元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
·元组中只包含一个元素时，需要在元素后面添加逗号		tup1 = (50,);
·元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
·元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
·任意无符号的对象，以逗号隔开，默认为元组
#!/usr/bin/python
# -*- coding: UTF-8 -*-

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')

print tuple # 输出完整元组
print tuple[0] # 输出元组的第一个元素
print tuple[1:3] # 输出第二个至第三个的元素
print tuple[2:] # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2 # 输出元组两次
print tuple + tinytuple # 打印组合的元组
｝
元字典
｛
列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
·字典是另一种可变容器模型，且可存储任意类型对象
·字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
·不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
·键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
!/usr/bin/python
# -*- coding: UTF-8 -*-

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值

1	radiansdict.clear()			删除字典内所有元素
2	radiansdict.copy()			返回一个字典的浅复制
3	radiansdict.fromkeys()			创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
5	radiansdict.has_key(key)		如果键在字典dict里返回true，否则返回false
6	radiansdict.items()			以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys()			以列表返回一个字典所有的键
8	radiansdict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2)		把字典dict2的键/值对更新到dict里
10	radiansdict.values()			以列表返回字典中的所有值
｝
1、函数：
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
（1）定义一个函数
·函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
·任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
·函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
·函数内容以冒号起始，并且缩进。
·return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
（2）函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：

例子：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 定义函数
def printme( str ):
"打印任何传入的字符串"
print str;
return;

# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

（3）参数：必备参数 关键字参数 缺省参数 不定长参数
·1、关键字参数：
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时 不一致 ，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：

例子：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;

#调用printinfo函数
printinfo( age=50, name="miki" );

·2、不定长参数：
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。
基本语法如下：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return;

# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );

（4）、匿名函数：
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

2、pass  空语句

3、数字类型数据转换
int(x [,base ])         将x转换为一个整数
long(x [,base ])        将x转换为一个长整数
float(x )               将x转换到一个浮点数
complex(real [,imag ])  创建一个复数
str(x )                 将对象 x 转换为字符串
repr(x )                将对象 x 转换为表达式字符串
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )               将序列 s 转换为一个元组
list(s )                将序列 s 转换为一个列表
chr(x )                 将一个整数转换为一个字符
unichr(x )              将一个整数转换为Unicode字符
ord(x )                 将一个字符转换为它的整数值
hex(x )                 将一个整数转换为一个十六进制字符串
oct(x )                 将一个整数转换为一个八进制字符串
4、引入外部对象模块
import random
5、转义字符
正则表达式：\  r  "" ‘’
转义字符			描述
\(在行尾时)		续行符
\\			反斜杠符号
\'			单引号
\"			双引号
\a			响铃
\b			退格(Backspace)
\e			转义
\000			空
\n			换行
\v			纵向制表符
\t			横向制表符
\r			回车
\f			换页
\oyy			八进制数，yy代表的字符，例如：\o12代表换行
\xyy			十六进制数，yy代表的字符，例如：\x0a代表换行
\other			其它的字符以普通格式输出

6、格式化字符串格式符 %s 的字符串
字符串格式化使用与 C 中 sprintf 函数一样的语法。
例子：
#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21)
以上实例输出结果：
My name is Zara and weight is 21 kg!

符   号	描述
%c	 格式化字符及其ASCII码
%s	 格式化字符串
%d	 格式化整数
%u	 格式化无符号整型
%o	 格式化无符号八进制数
%x	 格式化无符号十六进制数
%X	 格式化无符号十六进制数（大写）
%f	 格式化浮点数字，可指定小数点后的精度
%e	 用科学计数法格式化浮点数
%E	 作用同%e，用科学计数法格式化浮点数
%g	 %f和%e的简写
%G	 %f 和 %E 的简写
%p	 用十六进制数格式化变量的地址

7、列表函数&方法
序号	函数
1	cmp(list1, list2)		比较两个列表的元素
2	len(list)			列表元素个数
3	max(list)			返回列表元素最大值
4	min(list)			返回列表元素最小值
5	list(seq)			将元组转换为列表

序号	方法
1	list.append(obj)		在列表末尾添加新的对象
2	list.count(obj)			统计某个元素在列表中出现的次数
3	list.extend(seq)		在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)			从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)		将对象插入列表
6	list.pop(obj=list[-1])		移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)		移除列表中某个值的第一个匹配项
8	list.reverse()			反向列表中元素
9	list.sort([func])		对原列表进行排序

8、时间和日历
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

获取当前时间戳
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import time;  # 引入time模块

ticks = time.time()
print "当前时间戳为:", ticks
输出结果：当前时间戳为: 1459994552.51

struct_time元组：

序号	属性	值
0	tm_year	2008
1	tm_mon	1 到 12
2	tm_mday	1 到 31
3	tm_hour	0 到 23
4	tm_min	0 到 59
5	tm_sec	0 到 61 (60或61 是闰秒)
6	tm_wday	0到6 (0是周一)
7	tm_yday	1 到 366(儒略历)
8	tm_isdst	-1, 0, 1, -1是决定是否为夏令时的旗帜

获取当前时间：从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。localtime（）
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import time

localtime = time.localtime(time.time())
print "本地时间为 :", localtime
输出：本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

9、模块

# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Zara")

#要导入模块fib的fibonacci函数
from fib import fibonacci

#设置模块路径
set PYTHONPATH=/usr/local/lib/python
命名空间和作用域：
·一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量
Python会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给全局变量在一个函数里赋值，必须使用global语句。
global VarName的表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。

global VarName

dir函数：函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
globals()：返回的是所有在该函数里能访问的全局名字
locals()：返回的是所有能在该函数里访问的命名
reload()：重新导入之前导入过的模块

像main函数一样命令行带参数
impotr sys #加载sys模块
sys.argv为参数
str=sys.argv[1];

引用模块：
import mymodule
mymodule.function()#使用mymodule 的function函数

10、文件io
·输入：
(1)raw_input 从标准输入读入一行文本返回一个字符串（去掉结尾的换行符）
(2)input	input 可以接收一个Python表达式作为输入，并将运算结果返回。
#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = raw_input("请输入：");
print "你输入的内容是: ", str
str = input("请输入：");
print "你输入的内容是: ", str

结果：
请输入：Hello Python！
你输入的内容是:  Hello Python！
请输入：[x*5 for x in range(2,10,2)]
你输入的内容是:  [10, 20, 30, 40]

·打开关闭文件 open/close
file对象属性：
属性	描述
file.closed	返回true如果文件已被关闭，否则返回false。
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

例子：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 打开一个文件
fo = open("foo.txt", "wb")#fo=file("foo.txt", "wb")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace
# 关闭打开的文件
fo.close()

输出结果：
文件名:  foo.txt
是否已关闭 :  False
访问模式 :  wb
末尾是否强制加空格 :  0

·write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n')：
fo.write( "www.runoob.com!\nVery good site!\n");

·read()方法
被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，
它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
fo.read([count]);
·readline()
法读文件的每一行

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 打开一个文件
fo = open("foo.txt", "wb")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace

fo.write( "www.runoob.com!\nVery good site!\n");
str = fo.read(10);
print "读取的字符串是 : ", str
# 关闭打开的文件
fo.close()

·文件定位
tell()方法告诉你文件内的当前位置
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

·重命名和删除文件

os.rename(current_file_name, new_file_name)#当前的文件名和新文件名。

·创建目录
mkdir
·改变当前的工作路径
chdir()
·删除目录
rmdir
·获得当前工作路径
getcwd()
1	file.close()		关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()		刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()		返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()		如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next()		返回文件下一行。
6	file.read([size])	从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size])	读取整行，包括 "\n" 字符。
8	file.readlines([sizehint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence])设置文件当前位置
10	file.tell()		返回文件当前位置。
11	file.truncate([size])	截取文件，截取的字节通过size指定，默认为当前文件位置。
12	file.write(str)		将字符串写入文件，没有返回值。
13	file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

11、异常处理
try/except语句

/***************************************************************************/
1、类
class myclass:
‘my class’#类介绍
def __init__(self, name, salary):
self.name = name
self.salary = salary
myclass.empCount += 1#empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用myclass.empCount访问。
print '构造函数'
def __del__（self）
class_name = self.__class__.__name__
print ‘析构函数’
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name,  ", Salary: ", self.salary

"创建 Employee 类的第一个对象"
emp1 = myclass("Zara", 2000)
#访问属性
emp1.displayEmployee()
#访问类变量
print "Total Employee %d" % Employee.empCount

类的继承：
继承语法： class 派生类名（基类名）：
特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:        # 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"

def parentMethod(self):
print '调用父类方法'

def setAttr(self, attr):
Parent.parentAttr = attr

def getAttr(self):
print "父类属性 :", Parent.parentAttr

class Child(Parent): # 定义子类
def __init__(self):
print "调用子类构造方法"

def childMethod(self):
print '调用子类方法 child method'

c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法
c.getAttr()          # 再次调用父类的方法

结果：
调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 200

运算符重载：
#!/usr/bin/python

class Vector:
def __init__(self, a, b):
self.a = a
self.b = b

def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
以上代码执行结果如下所示:
Vector(7,8)

类的属性
｛
hasattr(emp1, 'age')    #  检查是否存在一个属性。如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 访问对象的属性。返回 'age' 属性的值
setattr(emp1, 'age', 8) #设置一个属性。如果属性不存在，会创建一个新属性 # 添加属性 'age' 值为 8
delattr(empl, 'age')    #  设置一个属性。如果属性不存在，会创建一个新属性删除属性 'age'

类内部属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

访问：类名.__doc__

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。
在类的内部调用 self.__private_methods
类的方法
在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性

类变量：类名.变量名，类名之后；类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；相当于加了static
类实例变量：self.d；实例变量则属对象私有，某一个对象将其值改变，不影响其他对象； 与this类似

_xxx      不能用'from module import *'导入 在模块或类外不可以使用；开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；
__xxx__  系统定义名字；子类访问时需要在参数中添加srlf ；a._Test__zzz
__xxx    类中的私有变量名 ；开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据
但是也可以把私有变量进行转化：使子类的对象也能访问：
规则是：_<类名><私有变量>   a._Test__zzz

__init__(self,~)	构造函数
__del__(self)		析构函数

继承时：初始化派生类构造函数并不会自动初始化父类的构造函数，需要自己调用：父类名.__init__(self,~)
｝

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class JustCounter:
__secretCount = 0  # 私有变量
publicCount = 0    # 公开变量

def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount  # 报错，实例不能访问私有变量

结果：出现错误
1
2
2
Traceback (most recent call last):
File "test.py", line 17, in
print counter.__secretCount  # 报错，实例不能访问私有变量
AttributeError: JustCounter instance has no attribute '__secretCount'

将如下代码替换以上代码的最后一行代码：

print counter._JustCounter__secretCount

执行以上代码，执行结果如下：
1
2
2
2

2、正则表达式：
import re

re.match(pattern, string, flags=0)//匹配的正则表达式,要匹配的字符串,标志位
从头开始匹配。匹配成功re.match方法返回一个匹配的对象，否则返回None。
re.search(pattern, string, flags=0)//匹配的正则表达式,要匹配的字符串,标志位
整个字符串；re.search 扫描整个字符串并返回第一个成功的匹配位置。
re.sub(pattern, repl, string, max=0)
替换字符串中的匹配项，返回不能匹配的

可选标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式：
模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}
re{ n,}	精确匹配n个前面表达式。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	G匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字及下划线
\W	匹配非字母数字及下划线
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的子表达式。
\10	匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

一些函数：
string raw_input("~") 	外部输入		i=int(raw_input("pls input i:"))
del			删除变量		del i;del j,k

数学函数：
函数			返回值 ( 描述 )
abs(x)			返回数字的绝对值，如abs(-10) 返回 10
ceil(x)			返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)		如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)			返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)			返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)		返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)			如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)		返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)		返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)		返回给定参数的最小值，参数可以为序列。
modf(x)			返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)		x**y 运算后的值。
round(x [,n])		返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)			返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

随机数函数：
import random 通常需要引入外部的random模块
函数					描述
choice(seq)				从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()				随机生成下一个实数，它在[0,1)范围内。
seed([x])				改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)				将序列的所有元素随机排序
uniform(x, y)				随机生成下一个实数，它在[x,y]范围内。
调用：random.choice( seq  ) ，random.random()。。。。

三角函数：

函数			描述
acos(x)			返回x的反余弦弧度值。
asin(x)			返回x的反正弦弧度值。
atan(x)			返回x的反正切弧度值。
atan2(y, x)		返回给定的 X 及 Y 坐标值的反正切值。
cos(x)			返回x的弧度的余弦值。
hypot(x, y)		返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)			返回的x弧度的正弦值。
tan(x)			返回x弧度的正切值。
degrees(x)		将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)		将角度转换为弧度