文档章节

Python初步学习章程

_Leo_
 _Leo_
发布于 2013/12/25 17:24
字数 7619
阅读 672
收藏 41

[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'> #异常类 &nbsp; &nbsp;
    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编程

说来话长,建议系统学习

GUI编程

说来话长,建议系统学习
  • wxpython 详细参考:点这里...
  • pyqt4 详细参考:点这里...
    **注:**现在pyqt5也出来了适用于python3

持续补充...

© 著作权归作者所有

共有 人打赏支持
_Leo_

_Leo_

粉丝 10
博文 8
码字总数 11837
作品 0
广州
高级程序员
加载中

评论(1)

_简简单单_
_简简单单_
好帖子。
python!!等了好久吧,我来了。

先学习Python的哲学,这样可以让我知道是不是适合我去学。然后,学习一些Python的基本语法,网络上还是很多这类电子书的。了解后,就可以找些资料对比各各框架,选择出最适合自己需求的。初步...

倒逼live
2014/03/12
0
0
Whoosh 原理与实战1--Python 搜索框架 Whoosh 简介

Whoosh 是一个纯 Python 编写的搜索框架,类似于Lucene。比较简单,可以快速构建站内搜索。也可以在此基础上构建搜索引擎,但需要自己扩展 爬虫Spider 和 中文分词组件。 Whoosh详细可以查看...

从前
2012/11/12
0
2
连 00 后学 Python 了,身为程序员的我慌了

2018 年 1 月 16 日,教育部召开新闻发布会,正式将人工智能、物联网、大数据处理划入高中新课标,并于今年秋季开始执行。这意味着,现在 16 岁的学生就要开始学习编程了! 本次核心目标:修...

dqcfkyqdxym3f8rb0
05/06
0
0
《Python从小白到大牛》简介

本书是一部系统论述Python编程语言、OOP编程思想以及函数式编程思想的立体化教程(含纸质图书、电子书、教学课件、源代码与视频教程)。为便于读者高效学习,快速掌握Python编程方法。本书作...

tony关东升
06/26
0
0
7个实战案例、24个学习视频、12G干货资料...带你免费入门《Python数据分析》!...

相信许多做数据的都有这样的经历: 你花大半天整合了一张数据表,却因为其他部门的错误,导致表格结构全错了!于是你又要吭哧吭哧重新来过...... 每次数据都重复洗一遍,还这么慢,要是有一劳...

tw6cy6ukydea86z
05/23
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

@SpringBootApplication 注解

@SpringBootApplication注解是一个组合注解,包含以下注解 @Target(ElementType.TYPE) 注解的作用目标 @Retention(RetentionPolicy.RUNTIME) Reteniton的作用是定义被它所注解的注解保留多久,...

java.刘
35分钟前
0
0
sentinel自定义DataSource实战

序 本文主要研究一下如何自定义sentinel的DataSource,这里以jdbc为例。 maven <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-sen......

go4it
51分钟前
1
0
xgboost/gbdt在调参时为什么树的深度很少就能达到很高的精度?

问题: 用xgboost/gbdt在在调参的时候把树的最大深度调成6就有很高的精度了。但是用DecisionTree/RandomForest的时候需要把树的深度调到15或更高。用RandomForest所需要的树的深度和Decisio...

tantexian
52分钟前
0
0
php-fpm的pool - 慢执行日志 - 进程管理 - open_basedir

php-fpm的pool : 为避免多站点使用同一个pool时因一个站点故障导致php资源耗尽,牵连使用同一个pool的其他站点的正常工作,可对每一个站点设置独立pool。 增加pool: 1.编辑php-fpm配置文件...

ZHENG-JY
今天
0
0
Linux之ssh服务默认端口修改

导读 SSH是标准的网络协议,可用于大多数UNIX操作系统,能够实现字符界面的远程登录管理,它默认使用22号端口,采用密文的形式在网络中传输数据,相对于通过明文传输的Telnet,具有更高的安全...

问题终结者
今天
1
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部