python 总结

python 随笔

关键字

def
    函数定义的 关键字       


lambda 
    lambda 参数,参数 : 表达式
    lambda表达式  本质是 匿名参数对象


global
    全局变量声明
    在函数中 显示的声明 全局变量,再使用 ( global  x )


布尔值
    True                true
    False       非       false


pass
    空代码块

基础

函数参数
    按照 形参的顺序调用
    按照 形参参数名调用(不用考虑参数顺序) 
            fun(y=2,x=3)
    默认参数 —— 前面的形参 可为空,后面的形参 可设置为默认值
               也可按参数名 指定 部分参数
             (实参赋值时,优先赋值给前面的形参,后面的用默认值)
    
    变长参数 —— 传递任意数量的参数
            参数存在 tuple 中,传递给形参
            def fun(*args):        指定 *
    
    键值对参数 —— 参数作为 键值对传递
            参数存在 map 中,传递给形参
            def fun(**args)        指定 **
            
            实参调用时,必须是 fun( a = 3, b = 4)
            print 输出结果是 a:3
                            b:4      (map形式输出)


类:
    类的方法:           def  a( self ):
        首个参数必须为 self, 表示 类的对象本身
    
    __init__( self, 参数列表 )          类的初始化函数(创建时执行)


逻辑运算符:  
    and                     &&
    or          没有          ||
    not                     ~


模块:
    
    import  模块名             
            模块名.函数   /    模块名.属性
            
    from  模块名   import   函数/属性   as   别名               
            直接调用别名(前面不用添加   模块名)        


异常:
    try :
        xxx
    except :
        异常信息输出  


所有列表(list  /  tuple  /  str  ):
    遍历
    索引操作
    切片操作
    连接


tuple  元组:
    ( Ture, 2, 'c', 3.45, 'hello' )
    创建后 不能修改的列表
    
    使用:
         print '%s is %d' % ('name', 29)             
         return (2, 3)      返回 元组


list    列表:
    [ Ture, 2, 'c', 3.45, 'hello' ]
    创建后,里面元素可以任意修改
    
    list[ : -1]     从左边初始位置开始,到 从右数第 2个
    ( 切片 )  
    list[ : ]       左边初始位置开始,到列表的最后 1 个 
    
    list.append( 元素 )入栈     列表末尾 添加对象
    list.pop( 元素 )  出栈      移除列表中的元素,并返回
    list.count( 元素 )        元素 在列表中的 次数
    list.extend( list 序列 )  列表尾 添加 一个列表的元素
    list.index( 元素 )        元素 首次出现的 索引
    list.insert( 索引, 元素 )       在索引处 添加元素
    list.remove( 元素 )       移除列表中第一个匹配项
    list.reverse()          反转
    list.sort()         排序


列表解析
    [ x的操作  for x in list对象  if  判断条件  and/or  条件 ]
  例:
    [ x for x in range(1,101) if x%2==0 and x%3==0 and x%5==0 ]


字典 dict :               key -- value   键值对
    { key1 : value1, 
      key2 : value2,
      key3 : value3
     }
     
     key 值必须唯一 ( list 不能做  key)
     通过 key 来获取值 (不能通过 索引 index 获取)


str   字符串:

    str.split( '字符' )       将 str 字符串 按照'字符'分割,形成 list 列表
    
    '字符'.join( list / tuple )       用'字符' 将列表元素  连接成  字符串
    '字符'.join( str )                用'字符' 将 str 的每个字符 连接成 字符串


file   文件:
    d = file( 文件名,   文件操作模式 )           打开文件
    d = open( 文件名,   文件操作模式 )       打开文件(与 file( ) 类似)
    with  open( 文件名 ) as  别名:
        xxxx 
    
    d.read( )               文件读入字符串 str
    d.readline( )           读入文件的一行内容
    d.readline( )           按行读入文件,生成一个 list
    
    d.write( xx )           向文件中  写入数据


正则表达式:
    re  模块
    
    pattern = re.compile( '表达式' )
    
    match = patten.match( '待匹配字符串' )





内建函数

del     删除列表的元素
        del  ls[3]

type( 对象 )          对象的类型

len(列表/元组)      对象的长度
                    len( list对象 )       list 的元素个数
max( 列表/元组 )
min( 列表/元组 )
                    
sorted(列表)          对列表排序,返回排序好的列表

list(元组 / 字符串)      转换为 列表对象
tuple(列表 / 字符串)     列表  转化为 元组对象
str( 列表 / 元组)           转化为 字符串对象
    
help(对象)        解析对象(模块、类、方法、变量)的用法;

dir(对象)         对象中 可用的函数列表
                    例 : dir(list)
                        
input()             输入按照 变量 格式处理(如果 字符串变量 未命名,则报错)
                    输入字符串格式 —— 如果该变量没有定义,则报错
                                    或者在''    “”    中输入字符串
raw_input()         不管输入是什么格式,都按照 字符串格式处理 ( str )


map( 函数, 序列1,序列2,…… )
    map() 是内置函数
        用于将 多个序列作用于 其参数“函数” 中
        (一个、多个序列,根据某些规则,映射到另一些序列上)
    
    “函数” 可以是定义的函数,也可以是 lambda 匿名函数
        作用于序列的方法
    “序列”  可以是 list,也可以是 tumple
        要被作用的序列
    map(None, 列表……) 函数为 None时,返回参数组成的列表


reduce( 函数, 序列 )
    内置函数
        用于对 序列 做某种计算,输出一个计算结果的值
        (对一个序列 进行计算)
    
    “函数”    作用于序列 的函数
        参数的个数是 2 个 ———— 从后续的“序列” 中取参数
    “序列”    被函数作用的 序列

技巧

import __builtin__
dir(__builtin__)        查看内建模块的方法、属性

模块

time 模块
    time.time()         输出当前时间( 距离某时刻的秒数 )
    time.sleep( x )     程序暂停 x 秒


urllib 模块
    urllib.urlopen( url )  
        返回 url 对应的文件对象( file ),对它进行文件的读写操作


json 模块
    json.loads( 字符串 )           将 字符串 解析为 JSON格式
                                            ( 类似  字典对象 )


thread 模块:
    thread.start_new_thread( function, args )
        创建新线程,处理 function 函数,args 是 函数的参数
        args 必须是 tuple 格式 —— (args1, )
    
    多线程 常用于 爬虫爬取不同网络的数据


math 模块
    python 的 数学模块
    
    常数:
        math.pi
        math.e
    
    方法:
        math.ceil(x)    
        math.floor(x)
        math.pow(x, y)  x 的 y 次方
        math.log(x, y)  以y为底的、x的对数
        math.sqrt(x)        
        math.fabs(x)


random 模块
    随机数 模块
    
函数:
    random.randint(整数a, 整数b)    [a,b] 中产生一个随机整数(包括a、b)
    .random()                   [0,1)   0.0--1.0中 产生1个随机浮点数
    .uniform(a,b)               [a, b] 中 产生一个 随机浮点数(包括a, b)
    .randrange(a, b, step)  [a, b) 中 按照 step为间隔,产生随机数

    
    .choice( 序列 )           从序列中随机选取1个元素
    .sample(序列, k)       从 序列中 随机选择 k个元素,生成新的序列
    .shuffle(序列)            把序列随机打乱排序


os.path 模块
    操作文件路径名的模块
    
    os.path.abspath( path )         返回规范化的绝对路径
    os.path.basename(path)          文件
    os.path.dirname(path)           目录名 (文件所在的目录)
    os.path.getmtime(path)          path 对应文件的 最后修改时间
    os.path.getsize(path)           文件大小
    os.path.isfile(path)            是文件?
            isdir(path)             是目录?
    os.path.join(path,path ……)      几个 path 连接起来
    os.path.split(path)             path 分裂为2部分(路径, 文件)


sys 模块  
    系统运行时相关 模块(系统函数, 系统属性)  
    
    sys.path            path 环境变量
    sys.platform        平台标识符
    sys.version         解释器的版本信息
    sys.exit()
    
    sys.stdin
    sys.stdout
    sys.stderr          标准输出系列


os 模块
    操作系统的各种接口
    
    进程操作:
      os.name()         系统名字
      os.environ()      环境变量
      os.getenv(name)       获取某环境变量 对应的值
     
      os.getuid()
         getpid()
    
    文件对象操作:
        os.fdopen( fd )         根据文件描述符,返回文件对象
        os.open(file, flags)
        os.read(fd, n)          从文件中读取 n个字节
        os.write(fd, str)       字符串 写入文件
    
    目录操作:
        os.getcwd()             当前工作目录
        os.chmod(path, mode)
        os.chown(path, uid, gid)        修改文件的用户、组
        os.mkdir(path, mode)            创建目录
        os.remove(path)
        os.rename(src, dst)
        os.listdir(path)                列出路径下所有文件
        
    系统操作:
        os.system( cmd )            命令行中运行  cmd  命令


re 模块:
    正则表达式
    
    2 个子类对象:
        Pattern  模式对象
        Match   匹配的结果对象

1、Pattern 对象:   
    pat = re.compile(  '正则表达式 文本' )     
            生成 Pattern 对象 —— 即 编译好的正则表达式
    属性:
        pat.pattern         编译的 字符串
        pat.flags           编译用的 匹配模式
        pat.groups          分组的数量
        pat.groupindex      
    方法:
        pat.match( str, pos, end )
            从 字符串str 的 pos处开始、到end处结束,查看匹配情况;
            如果匹配成功,返回一个 Match对象;
        pat.search( str, pos, end )
        
        pat.split( string )     按照所有匹配的 pat ,将 string 分割、生成list 
        pat.findall( string )   以列表形式,返回所有匹配的字符串
        pat.sub( rep, string )  用 rep 替换 string 中的 pat 子串
        
                
2、Match 对象:
    mat = pat.match(  待匹配字符串 )
    或 mat = re.match(  正则表达式, 待匹配字符串 )
            生成 Match 对象 —— 即 匹配结果
    属性:
        match.string            匹配的字符串
        match.re            匹配的 pattern 模式对象
        match.pos
        match.endpos        开始、结束搜索的索引
        match.index         最后捕获的分组在文中的索引
        match.lastgroup
    方法:
        match.group( )      返回一个/多个 分组的字符串
        match.groups( )     元组形式返回所有的捕获字符串

进阶

下划线命名 函数、属性:
    _get :      单下划线开头              (保护变量)
        只能被该类、及子类调用
        表示 模块的内部函数、内部变量;            
        
       from moduleName import *    时,不能使用它们
       import moduleName 时,通过 moduleName._get 可访问
       
    
    __get :     双下划线开头              (私有变量)
        只有该类的对象能够访问 —— 子类对象不能访问
        
        避免与子类函数、变量重名,使用时 自动改变名字
            如 __get ,在使用时 名字改变为 _moduleName__get
    
    
    __get__:        python 的 魔术对象  ————  特殊方法名
        python 官方定义的一些对象,与用户对象名字区分开
        用户最好不要以该方式命名;
        但用户可以 重写、覆盖 __get__  魔术对象

推荐阅读更多精彩内容