Python初步学习章程

[TOC]

分析下学过的每个编程语言都离不开下面几个模块的操作。

掌握这些基本掌握语言所有精髓。

根据Java模块学习流程，整理出来Python知识面，很粗略。

大部分摘自网络。

仅供参考。

源博： Python初步学习章程- http://www.cockybook.com/?p=145

Python知识面：

语法基础、类class、基本常识（模块、包）

中文版：

英文版：

内建函数

cmp() min()  max() len() enumerate() zip()  sum() list() tuple()等。

详细参见：点这里…

os包

os.sep 可以取代操作系统特定的路径分割符。

os.name字符串指示你正在使用的平台。比如对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'。

os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径。

os.getenv()和os.putenv()函数分别用来读取和设置环境变量。

os.listdir()返回指定目录下的所有文件和目录名。

os.remove()函数用来删除一个文件。

os.system()函数用来运行shell命令。

os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。

os.path.split()函数返回一个路径的目录名和文件名。

os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。

os.path.existe()函数用来检验给出的路径是否真地存在

os和os.path模块

os.listdir(dirname)：列出dirname下的目录和文件

os.getcwd()：获得当前工作目录

os.curdir:返回但前目录（'.')

os.chdir(dirname):改变工作目录到dirname

os.path.isdir(name):判断name是不是一个目录，name不是目录就返回false

os.path.isfile(name):判断name是不是一个文件，不存在name也返回false

os.path.exists(name):判断是否存在文件或目录name

os.path.getsize(name):获得文件大小，如果name是目录返回0L

os.path.abspath(name):获得绝对路径

os.path.normpath(path):规范path字符串形式

os.path.split(name):分割文件名与目录（事实上，如果你完全使用目录，它也会将最后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在）

os.path.splitext():分离文件名与扩展名

os.path.join(path,name):连接目录与文件名或目录

os.path.basename(path):返回文件名

os.path.dirname(path):返回文件路径

sys

    sys.argv           命令行参数List，第一个元素是程序本身路径 
　　sys.modules.keys() 返回所有已经导入的模块列表 
　　sys.exc_info()     获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息 
　　sys.exit(n)        退出程序，正常退出时exit(0) 
　　sys.hexversion     获取Python解释程序的版本值，16进制格式如：0x020403F0 
　　sys.version        获取Python解释程序的版本信息 
　　sys.maxint         最大的Int值 
　　sys.maxunicode     最大的Unicode值 
　　sys.modules        返回系统导入的模块字段，key是模块名，value是模块 
　　sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 
　　sys.platform       返回操作系统平台名称 
　　sys.stdout         标准输出 
　　sys.stdin          标准输入 
　　sys.stderr         错误输出 
　　sys.exc_clear()    用来清除当前线程所出现的当前的或最近的错误信息 
　　sys.exec_prefix    返回平台独立的python文件安装的位置 
　　sys.byteorder      本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little' 
　　sys.copyright      记录python版权相关的东西 
　　sys.api_version    解释器的C的API版本 
　　sys.version_info 
　　>>> sys.version_info 
　　(2, 4, 3, 'final', 0) 'final'表示最终,也有'candidate'表示候选，表示版本级别，是否有后继的发行 
　　sys.displayhook(value)      如果value非空，这个函数会把他输出到sys.stdout，并且将他保存进__builtin__._.指在python的交互式解释器里，'_'代表上次你输入得到的结果，hook是钩子的意思，将上次的结果钩过来 
　　sys.getdefaultencoding()    返回当前你所用的默认的字符编码格式 
　　sys.getfilesystemencoding() 返回将Unicode文件名转换成系统文件名的编码的名字 
　　sys.setdefaultencoding(name)用来设置当前默认的字符编码，如果name和任何一个可用的编码都不匹配，抛出LookupError，这个函数只会被site模块的sitecustomize使用，一旦别site模块使用了，他会从sys模块移除 
　　sys.builtin_module_names    Python解释器导入的模块列表 
　　sys.executable              Python解释程序路径 
　　sys.getwindowsversion()     获取Windows的版本 
　　sys.stdin.readline()        从标准输入读一行，sys.stdout.write("a") 屏幕输出a 

　　

string包

字符串中字符大小写的变换： 

S.lower() #小写 
S.upper() #大写 
S.swapcase() #大小写互换 
S.capitalize() #首字母大写 
String.capwords(S) 
#这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起 
S.title() #只有首字母大写，其余为小写，模块中没有这个方法 


字符串在输出时的对齐： 

S.ljust(width,[fillchar]) 
#输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。 
S.rjust(width,[fillchar]) #右对齐 
S.center(width, [fillchar]) #中间对齐 
S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足 

字符串中的搜索和替换： 

S.find(substr, [start, [end]]) 
#返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索 
S.index(substr, [start, [end]]) 
#与find()相同，只是在S中没有substr时，会返回一个运行时错误 
S.rfind(substr, [start, [end]]) 
#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号 
S.rindex(substr, [start, [end]]) 
S.count(substr, [start, [end]]) #计算substr在S中出现的次数 
S.replace(oldstr, newstr, [count]) 
#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换 
S.strip([chars]) 
#把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None 
S.lstrip([chars]) 
S.rstrip([chars]) 
S.expandtabs([tabsize]) 
#把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个 
字符串的分割和组合： 

S.split([sep, [maxsplit]]) 
#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 
S.rsplit([sep, [maxsplit]]) 
S.splitlines([keepends]) 
#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。 
S.join(seq) #把seq代表的序列──字符串序列，用S连接起来 

字符串的mapping，这一功能包含两个函数： 

String.maketrans(from, to) 
#返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。 
S.translate(table[,deletechars]) 
# 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果S为unicode字符串，那么就不支持 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。 
字符串还有一对编码和解码的函数： 

S.encode([encoding,[errors]]) 
# 其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。这一部分内容涉及codecs模块，不是特明白 

S.decode([encoding,[errors]]) 
字符串的测试函数，这一类函数在string模块中没有，这些函数返回的都是bool值： 

S.startwith(prefix[,start[,end]]) 
#是否以prefix开头 
S.endwith(suffix[,start[,end]]) 
#以suffix结尾 
S.isalnum() 
#是否全是字母和数字，并至少有一个字符 
S.isalpha() #是否全是字母，并至少有一个字符 
S.isdigit() #是否全是数字，并至少有一个字符 
S.isspace() #是否全是空白字符，并至少有一个字符 
S.islower() #S中的字母是否全是小写 
S.isupper() #S中的字母是否便是大写 
S.istitle() #S是否是首字母大写的 

字符串类型转换函数，这几个函数只在string模块中有： 

string.atoi(s[,base]) 
#base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串 
string.atol(s[,base]) #转成long 
string.atof(s[,base]) #转成float 

这里再强调一次，字符串对象是不可改变的，也就是说在python创建一个字符串后，你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后，都会返回一个新的字符串，原字串并没有变。其实这也是有变通的办法的，可以用S=list(S)这个函数把S变为由单个字符为成员的list，这样的话就可以使用S[3]='a'的方式改变值，然后再使用S=" ".join(S)还原成字符串

迭代器（iter）

参考：点这里…

lambda 表达式

filter(function, sequence)：对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple（取决于sequence的类型）返回：

>>> def f(x): return x % 2 != 0 and x % 3 != 0 
>>> filter(f, range(2, 25)) 
[5, 7, 11, 13, 17, 19, 23]
>>> def f(x): return x != 'a' 
>>> filter(f, "abcdef") 
'bcdef'

map(function, sequence) ：对sequence中的item依次执行function(item)，见执行结果组成一个List返回：

>>> def cube(x): return x*x*x 
>>> map(cube, range(1, 11)) 
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> def cube(x) : return x + x 
... 
>>> map(cube , "abcde") 
['aa', 'bb', 'cc', 'dd', 'ee']
另外map也支持多个sequence，这就要求function也支持相应数量的参数输入：
>>> def add(x, y): return x+y 
>>> map(add, range(8), range(8)) 
[0, 2, 4, 6, 8, 10, 12, 14]

reduce(function, sequence,starting_value)：对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用，例如可以用来对List求和：

>>> def add(x,y): return x + y 
>>> reduce(add, range(1, 11)) 
55 （注：1+2+3+4+5+6+7+8+9+10）
>>> reduce(add, range(1, 11), 20) 
75 （注：1+2+3+4+5+6+7+8+9+10+20）

lambda：这是Python支持一种有趣的语法，它允许你快速定义单行的最小函数，类似与C语言中的宏，这些叫做lambda的函数，是从LISP借用来的，可以用在任何需要函数的地方：

>>> g = lambda x: x * 2 
>>> g(3) 
6 
>>> (lambda x: x * 2)(3) 
6

我们也可以把filter map reduce 和lambda结合起来用，函数就可以简单的写成一行。
例如

kmpathes = filter(lambda kmpath: kmpath,                  
    map(lambda kmpath: string.strip(kmpath),
        string.split(l, ':')))     

看起来麻烦，其实就像用语言来描述问题一样，非常优雅。
对 l 中的所有元素以':'做分割，得出一个列表。对这个列表的每一个元素做字符串strip，形成一个列表。对这个列表的每一个元素做直接返回操作(这个地方可以加上过滤条件限制)，最终获得一个字符串被':'分割的列表，列表中的每一个字符串都做了strip，并可以对特殊字符串过滤。

文件操作（文件和输入输出）

python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。
得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()
返回指定目录下的所有文件和目录名:os.listdir()
函数用来删除一个文件:os.remove()
删除多个目录：os.removedirs（r“c：\python”）
检验给出的路径是否是一个文件：os.path.isfile()
检验给出的路径是否是一个目录：os.path.isdir()
判断是否是绝对路径：os.path.isabs()
检验给出的路径是否真地存:os.path.exists()
返回一个路径的目录名和文件名:os.path.split()     eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt') 
分离扩展名：os.path.splitext()
获取路径名：os.path.dirname()
获取文件名：os.path.basename()
运行shell命令: os.system()
读取和设置环境变量:os.getenv() 与os.putenv()
给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
指示你正在使用的平台：os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'
重命名：os.rename（old， new）
创建多级目录：os.makedirs（r“c：\python\test”）
创建单个目录：os.mkdir（“test”）
获取文件属性：os.stat（file）
修改文件权限与时间戳：os.chmod（file）
终止当前进程：os.exit（）
获取文件大小：os.path.getsize（filename）

文件操作：
os.mknod("test.txt")        创建空文件
fp = open("test.txt",w)     直接打开一个文件，如果文件不存在则创建文件
关于open 模式：
w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )

fp.read([size])                     #size为读取的长度，以byte为单位
fp.readline([size])                 #读一行，如果定义了size，有可能返回的只是一行的一部分
fp.readlines([size])                #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
fp.write(str)                      #把str写到文件中，write()并不会在str后加上一个换行符
fp.writelines(seq)            #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
fp.close()                        #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。  如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush()                                      #把缓冲区的内容写入硬盘
fp.fileno()                                      #返回一个长整型的”文件标签“
fp.isatty()                                      #文件是否是一个终端设备文件（unix系统中的）
fp.tell()                                         #返回文件操作标记的当前位置，以文件的开头为原点
fp.next()                                       #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
fp.seek(offset[,whence])              #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
fp.truncate([size])                       #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

目录操作：
os.mkdir("file")                   创建目录
复制文件：
shutil.copyfile("oldfile","newfile")       oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile")            oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
复制文件夹：
shutil.copytree("olddir","newdir")        olddir和newdir都只能是目录，且newdir必须不存在
重命名文件（目录）
os.rename("oldname","newname")       文件或目录都是使用这条命令
移动文件（目录）
shutil.move("oldpos","newpos")   
删除文件
os.remove("file")
删除目录
os.rmdir("dir")只能删除空目录
shutil.rmtree("dir")    空目录、有内容的目录都可以删
转换目录
os.chdir("path")   换路径

相关例子 
 1 将文件夹下所有图片名称加上'_fc'
python代码:
# -*- coding:utf-8 -*-
import re
import os
import time
#str.split(string)分割字符串
#'连接符'.join(list) 将列表组成字符串
def change_name(path):
    global i
    if not os.path.isdir(path) and not os.path.isfile(path):
        return False
    if os.path.isfile(path):
        file_path = os.path.split(path) #分割出目录与文件
        lists = file_path[1].split('.') #分割出文件与文件扩展名
        file_ext = lists[-1] #取出后缀名(列表切片操作)
        img_ext = ['bmp','jpeg','gif','psd','png','jpg']
        if file_ext in img_ext:
            os.rename(path,file_path[0]+'/'+lists[0]+'_fc.'+file_ext)
            i+=1 #注意这里的i是一个陷阱
        #或者
        #img_ext = 'bmp|jpeg|gif|psd|png|jpg'
        #if file_ext in img_ext:
        #    print('ok---'+file_ext)
    elif os.path.isdir(path):
        for x in os.listdir(path):
            change_name(os.path.join(path,x)) #os.path.join()在路径处理上很有用

img_dir = 'D:\\xx\\xx\\images'
img_dir = img_dir.replace('\\','/')
start = time.time()
i = 0
change_name(img_dir)
c = time.time() - start
print('程序运行耗时:%0.2f'%(c))
print('总共处理了 %s 张图片'%(i))
输出结果：
程序运行耗时:0.11
总共处理了 109 张图片

异常exception、try、catch、finally

//Python常见异常类:
异常                | 描述
NameError           | 尝试访问一个没有申明的变量
ZeroDivisionError   | 除数为0
SyntaxError         | 语法错误
IndexError          | 索引超出序列范围
KeyError            | 请求一个不存在的字典关键字
IOError             | 输入输出错误（比如你要读的文件不存在）
AttributeError      | 尝试访问未知的对象属性
ValueError          | 传给函数的参数类型不正确，比如给int()函数传入字符串形

//捕获异常
    //1 一般形式
    try:
        try_suite
    except Exception1,Exception2,...,Argument:
        exception_suite
        #other exception block
    else:
        no_exceptions_detected_suite
    finally:
        always_execute_suite
    //2 最常用方式
    try:  
        res = 2/0  
    except ZeroDivisionError:  
        print "Error:Divisor must not be zero!" 

    //3 有原因的
    try:  
        res = 2/0,'这里有错误哦~~~'
    except ZeroDivisionError,reasion:  
        print "Error:Divisor must not be zero! "+reasion

    //4 带else的捕获,和带finally子句
    import syslog  
    try:  
        f = open("/root/test.py")  
    except IOError,e:  
        syslog.syslog(syslog.LOG_ERR,"%s"%e)  
    else:  
        syslog.syslog(syslog.LOG_INFO,"no exception caught\n")  
    finally:
        f.close()

    //5 上下文管理（with） ，这个东西可以帮你管理你打开的资源，如文件。。。
    //  只有支持上下文管理协议（context management protocol）的对象才可以 
    //  有decimal.Context、thread.LockType、threading.Lock、threading.RLock、threading.Condition、threading.Semaphore、threading.BoundedSemaphore
    语法：  with context_expr [as var]:  
                with_suite  
    使用：    
    with open('/root/test.py') as f:  
        for line in f:  
        print line  

//**抛出异常(raise)**
语法：raise [SomeException [, args [,traceback]]  
使用1： raise NameError,('reason1','reason2')
使用2：
        >>> raise NameError
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        NameError
        >>> raise NameError()  #异常类的实例
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        NameError
        >>> raise NameError,("There is a name error","in test.py")
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        >>> raise NameError("There is a name error","in test.py")  #注意跟上面一个例子的区别
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        NameError: ('There is a name error', 'in test.py')
        >>> raise NameError,NameError("There is a name error","in test.py")  #注意跟上面一个例子的区别
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        NameError: ('There is a name error', 'in test.py')

//**断言assert ，可以raise异常**
    语法： assert expression[,reason]
    使用：
    >>> assert len('love') == len('like')  
    >>> assert 1==1  
    >>> assert 1==2,"1 is not equal 2!"  
    Traceback (most recent call last):  
      File "<stdin>", line 1, in <module>  
    AssertionError: 1 is not equal 2! 

//**使用sys模块获取异常**
  使用：  >>> try:
         1/0
     except:
         import sys
         tuple = sys.exc_info()

    >>> print tuple
    (<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or modulo by zero',), <traceback object at 0x7f538a318b48>)
    >>> for i in tuple:
         print i

    <type 'exceptions.ZeroDivisionError'> #异常类    
    integer division or modulo by zero #异常类的实例
    <traceback object at 0x7f538a318b48> #跟踪记录对象

参考：http://blog.csdn.net/sinchb/article/details/8392827

多线程

Python中使用线程有两种方式：函数或者用类来包装线程对象。
1、  函数式：调用thread模块中的start_new_thread()函数来产生新线程。如下例：
import time
import thread
def timer(no, interval):
    cnt = 0
    while cnt<10:
        print 'Thread:(%d) Time:%s/n'%(no, time.ctime())
        time.sleep(interval)
        cnt+=1
    thread.exit_thread()


def test(): #Use thread.start_new_thread() to create 2 new threads
    thread.start_new_thread(timer, (1,1))
    thread.start_new_thread(timer, (2,2))

if __name__=='__main__':
    test()
//上面的例子定义了一个线程函数timer,它打印出10条时间记录后退出，每次打印的间隔由interval参数决定。thread.start_new_thread(function, args[, kwargs])的第一个参数是线程函数（本例中的timer方法），第二个参数是传递给线程函数的参数，它必须是tuple类型，kwargs是可选参数。
    //线程的结束可以等待线程自然结束，也可以在线程函数中调用thread.exit()或thread.exit_thread()方法。

2、  创建threading.Thread的子类来包装一个线程对象，如下例：
import threading
import time
class timer(threading.Thread): #The timer class is derived from the class threading.Thread
    def __init__(self, num, interval):
        threading.Thread.__init__(self)
        self.thread_num = num
        self.interval = interval
        self.thread_stop = False

    def run(self): #Overwrite run() method, put what you want the thread do here
        while not self.thread_stop:
            print 'Thread Object(%d), Time:%s/n' %(self.thread_num, time.ctime())
            time.sleep(self.interval)
    def stop(self):
        self.thread_stop = True


def test():
    thread1 = timer(1, 1)
    thread2 = timer(2, 2)
    thread1.start()
    thread2.start()
    time.sleep(10)
    thread1.stop()
    thread2.stop()
    return

if __name__ == '__main__':
    test()

    //threading.Thread类的使用：

    //1，在自己的线程类的__init__里调用threading.Thread.__init__(self, name = threadname) Threadname为线程的名字
   // 2， run()，通常需要重写，编写代码实现做需要的功能。
   // 3，getName()，获得线程对象名称
   // 4，setName()，设置线程对象名称
   // 5，start()，启动线程
   // 6，jion([timeout])，等待另一线程结束后再运行。
   // 7，setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。
   // 8，isDaemon()，判断线程是否随主线程一起结束。
   // 9，isAlive()，检查线程是否在运行中。

   参考：http://blog.csdn.net/lazy_tiger/article/details/3861844#

网络编程socket

python 编写server的步骤：

//1. 第一步是创建socket对象。调用socket构造函数。如：

socket = socket.socket( family, type )

//family参数代表地址家族，可为AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用于同一台机器上的进程间通信。type参数代表套接字类型，可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字)。

//2.第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的：
socket.bind( address )
//由AF_INET所创建的套接字，address地址必须是一个双元素元组，格式是(host,port)。host代表主机，port代表端口号。如果端口号正在使用、主机名不正确或端口已被保留，bind方法将引发socket.error异常。

//3. 第三步是使用socket套接字的listen方法接收连接请求。
socket.listen( backlog )
//backlog指定最多允许多少个客户连接到服务器。它的值至少为1。收到连接请求后，这些请求需要排队，如果队列满，就拒绝请求。

//4. 第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。
connection, address = socket.accept()
//调 用accept方法时，socket会时入“waiting”状态。客户请求连接时，方法建立连接并返回服务器。accept方法返回一个含有两个元素的 元组(connection,address)。第一个元素connection是新的socket对象，服务器必须通过它与客户通信；第二个元素 address是客户的Internet地址。

//5. 第五步是处理阶段，服务器和客户端通过send和recv方法通信(传输 数据)。服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。调用recv 时，服务器必须指定一个整数，它对应于可通过本次方法调用来接收的最大数据量。recv方法在接收数据时会进入“blocked”状态，最后返回一个字符 串，用它表示收到的数据。如果发送的数据量超过了recv所允许的，数据会被截短。多余的数据将缓冲于接收端。以后调用recv时，多余的数据会从缓冲区 删除(以及自上次调用recv以来，客户可能发送的其它任何数据)。

//6. 传输结束，服务器调用socket的close方法关闭连接。

python编写client的步骤：

   //1. 创建一个socket以连接服务器：
   socket = socket.socket( family, type )
   //2.使用socket的connect方法连接服务器。对于AF_INET家族,连接格式如下：
   socket.connect( (host,port) )
    //host代表服务器主机名或IP，port代表服务器进程所绑定的端口号。如连接成功，客户就可通过套接字与服务器通信，如果连接失败，会引发socket.error异常。
   //3. 处理阶段，客户和服务器将通过send方法和recv方法通信。
   //4. 传输结束，客户通过调用socket的close方法关闭连接。
   例子 服务端 server.py：
   if __name__ == '__main__':  
    import socket  
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
    sock.bind(('localhost', 8001))  
    sock.listen(5)  
    while True:  
        connection,address = sock.accept()  
        try:  
            connection.settimeout(5)  
            buf = connection.recv(1024)  
            if buf == '1':  
                connection.send('welcome to server!')  
            else:  
                connection.send('please go out!')  
        except socket.timeout:  
            print 'time out'  
        connection.close()  

   客户端client.py：
   if __name__ == '__main__':  
    import socket  
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
    sock.connect(('localhost', 8001))  
    import time  
    time.sleep(2)  
    sock.send('1')  
    print sock.recv(1024)  
    sock.close()  

正则表达式

re.match

re.match 尝试从字符串的开始匹配一个模式，如：下面的例子匹配第一个单词。

[python] view plaincopy
import re  

text = "JGood is a handsome boy, he is cool, clever, and so on..."  
m = re.match(r"(/w+)/s", text)  
if m:  
    print m.group(0), '/n', m.group(1)  
else:  
    print 'not match'  

re.match的函数原型为：re.match(pattern, string, flags)

第一个参数是正则表达式，这里为”(/w+)/s”，如果匹配成功，则返回一个Match，否则返回一个None；

第二个参数表示要匹配的字符串；

第三个参数是标致位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

re.search

re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。

import re  

text = "JGood is a handsome boy, he is cool, clever, and so on..."  
m = re.search(r'/shan(ds)ome/s', text)  
if m:  
    print m.group(0), m.group(1)  
else:  
    print 'not search'  

re.search的函数原型为： re.search(pattern, string, flags)

每个参数的含意与re.match一样。

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

re.sub

re.sub用于替换字符串中的匹配项。下面一个例子将字符串中的空格 ' ' 替换成 '-' : 

import re  

text = "JGood is a handsome boy, he is cool, clever, and so on..."  
print re.sub(r'/s+', '-', text)  

re.sub的函数原型为：re.sub(pattern, repl, string, count)

其中第二个函数是替换后的字符串；本例中为'-'

第四个参数指替换个数。默认为0，表示每个匹配项都替换。

re.sub

还允许使用函数对匹配项的替换进行复杂的处理。如：re.sub(r'/s', lambda m: '[' + m.group(0) + ']', text, 0)；将字符串中的空格' '替换为'[ ]'。

re.split

可以使用re.split来分割字符串，如：re.split(r'/s+', text)；将字符串按空格分割成一个单词列表。

re.findall

re.findall可以获取字符串中所有匹配的字符串。如：re.findall(r'/w*oo/w*', text)；获取字符串中，包含'oo'的所有单词。

re.compile

可以把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。下面是一个正则表达式对象的一个例子：

import re  

text = "JGood is a handsome boy, he is cool, clever, and so on..."  
regex = re.compile(r'/w*oo/w*')  
print regex.findall(text)   #查找所有包含'oo'的单词  
print regex.sub(lambda m: '[' + m.group(0) + ']', text) #将字符串中含有'oo'的单词用[]括起来。  

详细参考：

• 网友整理非常详细
• 官网

数据库

Python数据库管理的时候，不同的数据库会有不同的操作包。
在Python安装的时候会自带sqlite3 数据库包，如果是mysql就要自己下载Mysql操作包进行安装。

操作方式有两种：

• 一种是直接使用python api 操作，就像java使用jdbc操作一样。

##插入：
import MySQLdb

try:
    conn=MySQLdb.connect(host='localhost',user='root',passwd='root',port=3306)
    cur=conn.cursor()

    cur.execute('create database if not exists python')
    conn.select_db('python')
    cur.execute('create table test(id int,info varchar(20))')

    value=[1,'hi rollen']
    cur.execute('insert into test values(%s,%s)',value)

    values=[]
    for i in range(20):
        values.append((i,'hi rollen'+str(i)))

    cur.executemany('insert into test values(%s,%s)',values)
    cur.execute('update test set info="I am rollen" where id=3')

    conn.commit()
    cur.close()
    conn.close()

except MySQLdb.Error,e:
     print "Mysql Error %d: %s" % (e.args[0], e.args[1])

     ##查询：
     import MySQLdb

try:
    conn=MySQLdb.connect(host='localhost',user='root',passwd='root',port=3306)
    cur=conn.cursor()

    conn.select_db('python')
    count=cur.execute('select * from test')
    print 'there has %s rows record' % count

    result=cur.fetchone()
    print result
    print 'ID: %s info %s' % result

    results=cur.fetchmany(5)
    for r in results:
        print r

    print '=='*10
    cur.scroll(0,mode='absolute')

    results=cur.fetchall()
    for r in results:
        print r[1]

    conn.commit()   ##commit() 提交
    cur.close()
    conn.close()

except MySQLdb.Error,e:
     print "Mysql Error %d: %s" % (e.args[0], e.args[1])

常用函数：

    commit() 提交
    rollback() 回滚

    **cursor用来执行命令的方法:**
    callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数
    execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数
    executemany(self, query, args):执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数
    nextset(self):移动到下一个结果集

    **cursor用来接收返回值的方法:**
    fetchall(self):接收全部的返回结果行.
    fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
    fetchone(self):返回一条结果行.
    scroll(self, value, mode='relative'):移动指针到某一行.如果mode='relative',则表示从当前所在行移动value条,如果 mode='absolute',则表示从结果集的第一行移动value条.

    **如果出现了乱码，可以尝试以下方法：**
    conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python') 中加一个属性：
     改为：
    conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python',charset='utf8') 
    charset是要跟你数据库的编码一样，如果是数据库是gb2312 ,则写charset='gb2312'。

- 另一种使用orm框架操作，orm框架式第三方的软件包，目前知道好用的有django、storm

详细参考：点这里…

WEB编程

说来话长，建议系统学习

• django 详细参考：点这里…

GUI编程

说来话长，建议系统学习

• wxpython 详细参考：点这里…
• pyqt4 详细参考：点这里…
  注：现在pyqt5也出来了适用于python3

持续补充…