Python简单操作笔记

Python
    类型转换
       str(),repr()|format() : 将非字符类型转成子串
       int() : 转为整形
       float() : 转为浮点型

       list(s) : 将字串s转成列表
       tuple(s) : 将字串s转成元组
       set(s) : 将字串s转成集合
       frozenset(s) : 将字串s转成不可变集合
       dict(s) : 创建字典 其d必须是(key,value)的元组序列;

       chr(x) : 将整形转成字符
       ord(x) : 将字符转成整形
       hex(x) : 将整形转换成16进制字符
       bin(x) : 将整形转化成2进制
       oct(x) : 将整形转化成8进制

    数字类型
        Python的数字字面量 : 布尔型,整型,浮点型,复数
            True : 1
            False : 0
    序列类型
        字符类型
            字符串字面量 : 把文本放入单引号、双引号或三引号中(可以实现跨行定义)
        如果需要使用unicode编码,则在字符之前使用u进行标识,etc : u"luowen"

        文档字串 : 模块、类或函数的第一条语句如果是字符的话,该字符串就成为文档语句.必须保持严格的缩进

        字串操作
            str.islower() : 所有字符为小写,
            str.isupper() : 所有字符为大写
            str.upper() : 转换成大写
            str.lower() : 转换小写
            str.capitalize() : 首字母大写
            str.index(s,start) : s字符首次出现位置,start : 从start位置开始找
            str.replace(old,new,replaceTimes) : 字符替换
            str.split(s) : 已s做分割符分割
            s.join(str); : 以s做分割符,将列表组合成字串,str为序列
            str.strip(s) : 清楚一s开头或结尾的字符

    列表操作
        list.append(s); : 将一个元素append到list中 etc demo = [1,2,3] , s = [5,6]  result: [1,2,3,[5,6]]
        list.extend(list1); : 讲一个list1合并list中 result: [1,2,3,5,6]
        list.pop(s) : 将s从list中pop出来
        list.index(s) : 查找list中索引为s的值
        list.remove(s); : 删除列表list中值为s的元素
        list.reverse(); : 将list进行逆序 ‘在原处进行修改 修改地址‘
        list.sort(); : 将list中的元素进行排序 ‘在原处进行修改 修改地址‘
        list1 + list2 === list1.extend(list2) : 等同于extend
        s in t1 : 判断s是否在元组t1中
        s not in t1 : 判断s是否不在元组t1中

        列表复制方法
            l1 = [1,2,3,4]
            l2 = l1

            import copy
            l2 = copy.deepcopy(l1)

            l2 = l1[:]

    元组:
        表达式符号 : ()

        容器类型:
            任意对象的有序集合,通过索引访问其中的元素,不可变对象,长度固定,异构,嵌套
        常见操作:
            demo = () : 定义一个空元组
            demo = ‘x‘,‘y‘,‘z‘ : 定义了一个‘x y z‘ 的元组
            len(t) : 元组长度
            t1 + t2 : 两个元组合并
            s in t1 : 判断s是否在元组t1中
            s not in t1 : 判断s是否不在元组t1中

    字典 : dict
        字典在其他编程语言中又称作关联数组。
        通过键实现元素存取 : 无序集合 : 可变类型 : 长度可变 : 异构 : 嵌套
        etc.{key1:value1,key2:value2,....}

        空字典
            {},{‘x‘ : ‘2323‘,‘y‘:[1,2,3,4]}

            dict1.copy() : 复制dict1字典
            dict1.get(‘key‘) : 获取字典中键为key的只
            dict1.pop(‘x‘) : 字典中弹出键为‘x‘个元素
            dict1.items() : 将字典列表中的数据转换成元组
            dict1.items() : 获取字典中所有的值
            dict1.keys : 获取字典中所有的key
            dict1.popitem() : 随机弹出键和值
            dict1.has_key(‘x‘)  : 字典中是否含有键为‘x‘
            dict1.update(dict2) : 等同于php中的array_merge() ,dict2中的值会覆盖dict1的值
            iterator = dict1.iteritems() : 获取迭代器 iterator.next();

            zip(tuple1,tuple2); : 将两个元组转成列表[(1,‘x‘),(2,‘y‘)]

            dict1 = dict(zip(tuple1,tuple2)) : 生成一个字典

    集合SET:
        set1 = set(); : 构造一个set
        len(set1) : 返回s中的项目
        set1.copy : 复制set1集合
        set1.difference(set2) : 求差集 同set1 & set2
        set1.intersection(set2) : 求交际
        set1.isdisjoint(set2) : set1和set2有相同项返回True

    容器、类型、对象
        1、
        2、所有对象都有引用计数 sys.getrefcount(obj);
        3、列表和字典都支持潜复制和深复制，浅复制穿件一个新对象，对象里面的存放的对象没有发生变化，深复制：递归的全部复制对象（包括对象内部存放的对象）原有对象改变不会改变复制后的对象。copy.deepcopy()深复制
        4、Python中的所有对象都是“第一类”，这意味着所有对象都可以直接当做数据处理计算
        5、所有对象都支持迭代。
        6、所有序列都支持以下操作：
            s[i]
            s[i:j]
            s[i:j:stride]
            len(s)
            min(s)
            max(s)
            sum(s)
            all(s)
            any(s)
            s1 + s2 #链接
            s1 * N #重复
            obj in s1 #组成员
            obj not in s1
        7、可变序列操作
            s1[index] = value #元素赋值
            s1[i:j] = t #切片赋值
            del s1[index]
            del s1[i:j]
            del s1[i:j:stride]

Python表达式和语句
    表达式 : 某事
    语句 : 做某事

    逻辑运算:
           x or y, x and y not x

    成员关系:
            x in y , x not in y

    对象实例测试:
            x is y , x not is y

    比较运算:
            x > y .......

    位运算:
            x | y , x & y , x ^ y , x << y , x >> y

    一元运算:
            -x , +x , ~x

    幂运算: 
        x ** y

    调用运算:
            x(........)

    属性取值:
            x.attribute

    三元选择表达式:
        x if y else z  同(x == y ? x : z)

    匿名函数:
        lambda argus : expression

    生成器发送协议: yield x

    优先级:
        (......),[.......] , {............}
        s[i] , s[i][j]
        s.attribute
        s(.....)
        +x,-x,~x
        x ** y
        * , / ,// , %
        +,-
        <<,>>
        &
        ^
        |
        <,<=,>,>=,==,!=
        is,not is
        in,not in
        not
        or
        lambda

    语句:
        复制语句
        调用语句
        print:
        if/elif/else
        while/else
        pass:占位符
        break
        continue
        def
        return
        yield
        global #命名空间
        raise #触发异常
        import
        from #模块属性访问
        class #类
        try/except/finally #扑捉异常
        del #删除引用
        assert 调试检查
        with/as 循环管理器

    赋值语句:
        隐式复制: import,from,def,class,for,函数参数(arguments)

    生成序列:
        list1 = [i for i in range(1,11) if i % 2 == 0] #[2,4,6,8]

        l1 = [‘x‘,‘y‘,‘z‘]
        l2 = [1,2,3]
        list2 = [(i,j) for i in l1 for j in l2] #多项式相成

        将[]换成()就生成了一个生成器了,可以对应的生成器对象的next()方法取出数据

OS模块:
    目录:
        chdir() : 改变工作目录
        chroot() : 设定当前进程根目录
        listdir() : 列出所有文件名
        mkdir() : 创建目录
        makedirs() : 递归创建目录
        getcwd() : 获取工作目录
        rmdir() : 删除目录
        removedirs() : 删除多级目录

    文件:
        mkfifo() : 创建命名管道
        mknod() : 创建设备文件
        remove() : 删除文件
        unlink() : 删除文件
        rename() : 重命名
        stat() : 返回文件状态信息
        symlink() : 创建链接文件
        utime() : 更新文件时间戳
        tmpfile() : 创建并打开一个临时文件(打开模式是(w+b))
        walk() : 文件目录树

    权限:
        access(‘filename‘,‘userID‘) : 检验文件权限是否存在
        chmod(‘filename‘,‘modeNum‘) : 改变文件权限
        chown(‘filename‘,‘userID‘) : 改变宿主
        umask() : 设置默认访问权限(遮罩)

    文件描述符:
        open() : 底层操作系统的open()
        read() : 底层操作系统的read()
        write() : 底层操作系统的write

    设备文件:
        makedev() : 创建设备
        major(‘num‘) : 获取设备
        minor() :

OS子模块os.path:
    basename() : 文件基名 #etc. /etc/sysconfig/network-scripts => /etc/sysconfig
    dirname() : 路径基名 # etc ... => network-scripts
    join() : 将多个离散的路径名合并成一个 
    split() : 分割文件名 返回dirname,basename 结果元组
    splitext() : 返回(filename,extension) 元组 #返回文件的名字,和后缀

    信息:
        getatime() : 获取文件atime
        getctime() : 获取文件ctime
        getmtime() : 获取文件mtime
        getsize() : 获取文件大小

    查询:
        exists() : 判断文件是否存在
        isabs() : 判断制定路径是否是绝对路径
        isdir() : 判断是否是目录
        isfile() : 判断是否是文件
        islink() : 判断是否是符号链接
        ismount() : 判断是否是挂载点
        samefile() : 两个路径是否指向了同一个文件

对象序列化(持久存储):
    pickle() : 序列化
    marshal() : 序列化

    DBM接口:



Python 函数：
    demo = 1
    def f1():
        print demo # 1
        global demo
        demo = 2
        print demo # 2
    print demo #没有加global修饰的时候值为1 加了global时候则变成2

    函数参数可变参数:
        def fn1(*x):
                print x # 传入多个数据时候,x为元组
        def fn2(**x):
                print x # 传入多个数据时候,x为字典
        
        调用分解参数:
            demo = [1,3,4,5,6]
            def fn3(x,y,z):
                print x,y,z
            fn3(*demo) #将列表中的元素打散传入函数

    Python 匿名函数 lambda:
            f = lambda x,y,z: x + y + z
            f(1,2,4) #返回 7
            list1 = [ (lambda x: x*3 ),(lambda y: y*3)]
            for i in list1:
                print i(3)

            filter过滤器函数:
                filter(fn,list1) # fn为返回布尔类型函数,list1为列表

            多个队列函数 map(fn,list1,list2):
                list1 = [1,2,3,4]
                list2 = [‘S‘,‘M‘,‘T‘,‘W‘]
                map(None,list1,list2) # [(1,‘S‘),(2,‘M‘) ....] 同zip();

            多个序列整合一个序列 reduce:
                list1 = [1,2,3,4,5,6]
                reduce(lambda x,y: x+y,list1) #求出两个序列只和,对序列折叠

            Python闭合特性:
                def fn1(x):
                    def fn2(y):
                        return x+y
                    return fn2
                fDemo = fn1(2)
                fDemo(2) # 4
                fDemo(3) # 6 x= 2 被保存好了

            Python的闭包,闭包叫 lexical closure:

            yield 返回一个生成器对象:
                def fn1(x):
                    y = 0
                    while y <= x:
                        yield y
                        y += 1
                g1 = fn1(10)
                g1.next() # 返回1

            装饰器:
                1.本身是一个函数,其目的是装饰其他函数,是其他函数功能增强
                2.增强被装饰函数的功能
                3.装饰器需要接受一个函数,然后对其函数进行包装

                etc.
                    def deco(func):
                        def wrapper():
                            print "Please say somethings:"
                            func()
                            print "No zuo no die"
                        return wrapper()
                    @deco
                    def show():
                        return "I am from Mars."

            Python 递归:
                def dix(x):#实现阶乘
                    if x <= 1 : return 1
                    else : reutrn x * dix(x-1)

Python 面向对象:

        简单类实例:
            class MyClass():
                data = ‘value‘
            def myMethod(self):
                return self.data
        __varname__(): #Python会在某种特定情况下自动调用

        Python构造器: #__init__():
            class MyClass():
                data = ‘hello world‘
                def __init__(self,x):
                    self.str = x
            demo = Myclass(‘luowen‘)
            demo.str # => ‘luowen‘

        Python析构器: # __del__ 当调用del时候会调用class中的del方法
            class MyClass():
                data = ‘value‘
                def __init__(self,x):
                    self.voice = x
                def __del__(self):
                    pass
                def saySomeThing(self):
                    print self.voice

        Python类的一些属性:
            __doc__ # 类的文档信息
            __name__ # 类的名字
            __bases__ # 
            __dict__ # 类的属性
            __module__ # 类所在的模块
            __class__ # 类的名字

        Python类中可用变量:
            1.实例变量 #self.data
            2.局部变量 : 方法内部创建变量,属于每个实例特有的数据 # demo = MyClass demo.data
            3.类变量(也称静态变量,可以直接使用) # 类名.变量名 __name__
            4.全局变量:直接使用

        Python类中可用方法:
            1.issubclass(sub,sup): 判断一个类手否由另一个类派生
            2.isinstance(obj1,obj2) : 判断一个对象是否是一个给定的类型
            3.hasattr(obj,‘attr‘) : 判断一个对象是否具有某个属性
            5.super(type[.obj]) 在之类中找出其父类,以便于调用其属性
                一般情况下仅能采用非绑定凡是调用祖先类方法
                而super()可用于传入实例或类型对象.

    Python 中的模块:
            顶层文件
            模块文件1
            模块文件2
            模块文件3
    
    Python 包 :
        /dir
            | __init__.py
            | mod1.py
            | mod2.py
            | mod3.py
        import dir.mod1 as demo #导入
        demo.xx #使用


    Python打包:
        distiuls from

        name                : 包的名称(必须)
        Version             : 版本号(必须)
        author              : 作者名称
        author_email        : 作者电子
        maintainer          : 维护者的名称
        maintainer_email    : 维护者电子邮件
        url                 : 包的主页
        description         : 包的简短描述
        long_description    : 包的详细描述
        download_url        : 包的下载未知
        Classfiers          : 字符串分类列表


    Python 打包命令 :
        setup.py sdist --formats = asflow
            zip : zip file
            gztar : tar.gz file
            bztar : tar.bz2 file
            ztar : tar.Z file
            tar : tar file
        setup bdist # 打包二进制文件
            gztar : tar.gz file
            ztar : tar.Z file
            tar : tar file
            zip : zip file
            RPM : RPM Package
            pkgtool : Solaris pkgtool
            wininst : Windows上自解压的zip格式包
            msi : Microsoft Installer #Windows可安装文件

            bdist_dump:
            bdist_rpm :
            bdist_wininst :
            bdist_msi :

            setup.py中setup()中可用参数:
                platforms : 平台列表
                license : 许可证
                py_modules : 各模块名称组成的列表,此些模块可能位于包的根目录下,也可能位于某子包目录中
                packages : 各子包名称的列表

etc #打包是咧

#!/usr/bin/env python 
# file name setup.py
from distutils.core import setup

setup(
        name = ‘pkg1‘
        version = ‘0.1‘
        author = ‘Luowen‘
        author_email = ‘admin@admin.com‘
        maintainer = ‘luowen@luowen.com‘
        py_modules = [‘mod1‘,‘mod2‘,‘mod3‘]
        url = ‘http://www.luowen.com‘
        download_url = ‘http://www.luowen.com/pythonmoudles/download‘
        description = ‘Luowen Test Moudles‘
)

#打包目录结构
        demo
        |__init__.py
        |mod1.py
        |mod2.py
        |mod3.py
        |setup.py
        |README

    python setup.py sdist # 打包
    python setup.py install # 安装

# pip easy_install 简单快速安装工具

    Python模块、包、打包
        安装：
            python setup.py install # build and install

        第三方模块的默认安装路径为 : site-packages
            /usr/local/python27/lib/python2.7/site-pakcages

        Python setup.py install 
            --user="USERNAME" # 把路径安装在其他的目录
            --prefix="PATH" # 安装目录
            --exec-prefix="PATH" # 对你制定公共目录有写的权限

        深度定制:
            --install-purelib=/path/to/path_lib
            --install-platlib=/path/to/plat_lib
            --install-lib=/path/to/lib

            --install-scripts=/path/to/bin # 可执行文件的安装路径
            --install-headers=

    Python异常:
        1.语法错误
        2.逻辑错误
    try:
        #coding
    except IOError,e:
        print e
    except (Exception1,Exception2)[e1,e2]:
        suite__
    else:
        else_suite

    try:
        try_suite #异常代码抛出问题
    finally:
        finally_suite #用于资源释放

StandaardError: #标准异常超类
    ArithmeticError:#抽象子类
        AssertionError:
        AttributeError:
        FloatingPointError:
        IOError:
        ImportError:
        IndentationError:
        IndexError: #索引超出范围异常
    LookupError:#抽象子类
        KeyError:
        KeyboardInterrupt:
        MemoryError:
        NameError:
        NotImplementedError:
        OSError:
        OverflowError:
    EnvironmentError:#抽象子类
        SyntaxError
        SystemError
        TypeError
        UnboundLocalError
        UnicodeError
        ValueError
        WindowsError
        ZeroDivisionError

断言:
    assert condtion , ‘error reson‘