Python笔记

--HANL
都是个人的一些总结，发到这里记录一下，嘿嘿！

python不允许if语句中赋值

比较运算符优先逻辑运算符

Python的关键要素

• 基本数据类型
• 对象引用
• 组合数据类型
• 逻辑操作符
• 控制流程语句
• 算数操作符
• 函数的创建与调用

如何获取使用帮助

HELP:
    想获取某一对象支持使用的属性和方法：dir()
    某方法的具体使用帮助：help()
    获取可调用的对象的文档字串：print obj.__doc__

变量名命名规则：

命名惯例：
    以单一下划线开头变量名(_x)不会被from module import *语句导入
    前后有下划线的变量名(__x__)是系统定义的变量名，对python解释器有特殊意义
    以两个下划线开头但结尾没有下划线的变量名(__x)是类的本地变量
    交互模式下，"_"用于保存最后表达式的结果

    >>> 1+1
    2
    >>> print _
    2

    注意:变量名没有类型，对象才有

组合类型

序列类型
  列表是可变序列，元组是不可变序列
    列表：使用[]定义  ["This","is","a","pig"]
    可变对象，原处可变，
    元表：使用()定义  ("This,"is")
    不可变对象
    字符串也属于序列

逻辑运算

身份操作符
    is：判断左端的对象引用是否相同于右端对象引用；也可以与None进行
    In [16]: n = "jerry"
    In [19]: y = "jerry"
    In [20]: n is y
    Out[20]: True
成员操作符
    in或not in：测试成员关系

函数的创建与定义

使用def语句定义函数

def functionName(arguments):
    suite
ps：
def printName(name):
    print name
调用：
>>>printName('Jerry')
Jerry

callable() 可用于测试函数是否可以调用
每个python函数都有一个返回值，默认为None，也可以使用“return value”明确定义返回值
def语句会创建一个函数对象，并同时创建一个指向函数的对象引用

内置函数

dir(__builtin__) 查看内置函数
dir(),id(),type(),str(),help()

Python编程基础与编程风格

1.语句和语法
    #：注释，可从一行的多个地方开始
    \：续行
    ''': 也可做续行， 闭合操作符，单一语句跨行，多行注释
    同一行放置多个语句，使用分号作为分割符

2.模块
    每一个Python脚本文件都可以被当成是一个模块；
    模块里的代码可以是一段直接智行的脚本，也可以是一些类似库函数的代码从而可以由别的模块执行导入（import）。

3.标识符
    标识符是计算机语言中允许作为名字的有效集合

4.编程风格
    注释：既不能缺少注释，亦要避免过度注释
    文档：Python允许通过__doc__动态获得文档子串
    标识符：要做到见名知义，英文全拼

5.命名惯例
    以单一下划线开头变量名(_x)不会被from module import *语句导入
    前后有下划线的变量名(__x__)是系统定义的变量名，对python解释器有特殊意义
    以两个下划线开头但结尾没有下划线的变量名(__x)是类的本地变量
    交互模式下，"_"用于保存最后表达式的结果

文件结构

文件结构

Python文件主程序

主程序
    无论当前模块是被别人的模块导入还是作为脚本直接执行，都会智行这部分代码
注意：所有的模块都有能执行代码
    最高级别的Python语句（没有缩进的）在模块被导入时候就会执行，无论是否需要真的需要执行

    妥当的做法：除了那些真正需要执行的代码以外，所有的功能代码都通过函数建立，因此
        仅在主程序模块中编写大量的顶级执行代码
        用于被导入的模块只应该存在较少的顶级执行代码
__name__指示模块应该如何被加载
每个模块都有一个名为__name__的内建变量，此变量值会根据调用此模块的方式发生变化：
    如果模块是被导入，__name__的值是模块的名字
    如果模块是直接执行，__name__的值是'__main__'

Python对象特性、比较及核心数据类型

Python对象的相关术语

Python程序中保存的所有数据都是围绕对象这个概念展开的

• 程序中存储的所有数据都是对象

• 每个对象都有一个身份、一个类型和一个值

• 对象的类型也称对象的类别，用于描述对象的内部表示及他支持的方法的操作

• 创建特定的类型的对象时，有时也将该对象称为该类型的实例

    class：自定义类型
    type：
    instance：实例化
  

• 实例被创建后，其身份和类型就不可改变

    如果对象值是可以修改的，则称为可变对象
    如果对象的值不可修改，则称为不可变对象
  

• 如果某个对象包含对其它对象的引用，则将其称为容器

• 大多数对象都拥有大量的特有的数据属性和方法

    属性：与对象相关的值
    方法：被调用时将在对象上执行某些操作的函数
    使用点 . 运算符可以访问属性和方法
    /**
    类：数据和方法
        数据：变量
        方法：函数
    类：实例化成对象
        CA：
            IA：
            IB：
    **/
  

对象的身份与类型

Python内置函数id()可返回一个对象的身份，即该对象在内存中的位置

    is运算符用于比较两个对象的身份
        两个对象的比较：
            1、值比较：对象中的数据是否相同；
            2、身份比较：两个变量名引用的是否为同一对象；
            3、类型比较：两个对象的类型是否相同
            
    type()用于返回一个对象的类型
    对象类型本身也是一个对象，称为对象的类
        该对象的定义是唯一的，且对于某些类型的所有实例都是相同的
        所有类型对象都有一个指定的名称，可用于执行类型检查，如list、dict

if a is b:
    statements

if a == b:
    statemens

if type(a) is type(b):
    statemens

Python核心数据类型

数字：int，long，float，complex，bool
字符：str，unicode
列表：list
字典：dict
元组：tuple
文件：file
其它类型：集合（set），frozenset，类类型，None

其它文件类工具：pipes，fifos，sockets

类型装换：
    str(),repr()或format()：将非字符类型数据转换为字符；
    int():转换为整数；
    float():转换为浮点型；
    list(str):把str转换为列表；
    tuple(s)：将s转换为元表；
    set(s):将字符串s装换为集合；
    frozenset(s)：将字符串s转换为不可变集合；
    dict(d)：创建字典；其d必须是（key,value）的元组序列；
    chr(x)：将证书转换为字符；
    ord(x):将字符装换为整数值；
    hex(x):将字符装换为16进制；
    bin(x):2进制；
    oct(x):8进制；

数字类型：
    Python的数字字面量：布尔型，整数，浮点型，负数；
    True：1
    False：0

数字类型操作

数字类型操作

序列类型：
    字符类型：
        字符串字面量：把文本放入单引号、双引号、或三引号中；

如果要使用ubicode编码，则在字符之前使用字符u进行表示
str无法支持国际字符集，如果想要支持，需要str = u"hello world"

    文档字符串：（函数注释）
        模块、类或函数的第一条语句是一个字符的话，
        该字符串就成为文档字符串，可以使用__doc__属性引用；
    
    运算符：
        索引运算：[i]
        切片运算：[i:j]
        扩展切片：[i:j:stride]

序列字符串操作

序列操作

不可变序列操作

字符串操作

    支持运算：索引、切片、min()、max()、len()等
    支持操作：对象的自有方法

    列表：
        容器类型
            任意对象的有序集合，通过索引访问其中的元素，可变对象，
            异构，任意嵌套
        支持在原处修改：
            1.修改指定的索引元素，
            2.或修改指定分片，
            3.删除语句，
            4.内置方法。 
        l1 + l2：合并两个列表，返回一个新的列表；不会修改原列表
        l1 * N：把l1重复N次，返回一个新列表；
        
        in：成员关系判断字符，用法 item in container
        not in：obj not in container
    
        列表解析：[]

        列表复制方式：
            l1 = [1,2,3,4]
            l2 = l1
            
            import copy
            l2 = copy.deepcopy(11)

            l2 = l1[1:]
            
    元组：
        表达式符号：()
        
        容器类型
            任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定
            异构，嵌套
        
        常见操作：
            定义空元素：t1 = ()
            定义多元素：(1,2),(1,)

            t1 + t2:
            t1 * N:

            in:  成员关系判断
            not in: 
            
            虽然元组不可改变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组；

    字典：dict
        “灵活的内置数据结构，无序集合，键值组合（映射），类似关联数组，在字典中索引速度非常快”

        字典在其它编程语言中有称作关联数组或散列表：

        通过键实现元素存取；
        无序集合；
        可变类型容器；
        长度可变；
        支持异构，嵌套；
        
        ｛key1:value1,key2:value2,｝
        
        {} :空字典
        {'x':32,'y':[1,2,3]}

        字典复制：d2=d1.copy()
        
        d1.iteritems()  返回一个迭代器对象
    
        >>> dict(zip('zxc','123'))
        >>> {'c': '3', 'x': '2', 'z': '1'}


    类：数据+方法
        实例：
        3 + 5
        3.__add__(5)
    
    列表和字典：

    变量名在一个位置，对象在一个位置，变量名是指向对象的引用
    变量名没有类型，对象才有类型，

    点号运算符：
        属性：数据
            返回一个数据，显示则要使用print语句
        方法：操作  （）
            调用：执行一段代码，代码就是函数对象或者方法对象内部的一段代码
                
    可调用对象：callable()  函数，类，方法
    
    定义：
        字串：'',"",''' ''',""" """,
        列表：[]
        元组：()
        字典：{}
        数值：

    HELP:
        想获取某一对象支持使用的属性和方法：dir()
        某方法的具体使用帮助：help()
        获取可调用的对象的文档字串：print obj.__doc__

集合类型详解

集合：一组无序排列的可哈希的值：
    支持集合关系测试
    成员关系测试：
        in 
        not in
        迭代
    不支持：索引、元素获取、切片

集合的类型：set(),frozenset()

没有特定的语法格式，只能通过工厂函数创建

集合类型的方法和操作

容器、类型、对象 特性总结

1.列表元素和字典字面量，可以在不使用续行符的情况下，直接写在多行上，最后一个元素后面可以使用逗号，空元素不能使用逗号；

2.所有对象都有引用计数，将某对象放进一个新容器中，引用对象会增加，使用del语句使用删除操作或某次引用的修改超出当前对象的作用域时，对象的计数会减少，sys.getrefcount（s） 检测引用计数；

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的表达式和语句：

表达式叫某事，语句叫做某事

表达式：

语句：

Python中常用的表达式操作符：
    
    x + y,x - y 
    x * y,x / y,x // y, x % y

    逻辑运算：
    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 | y, x & y, x ^ y, x << y, x >> y

    一元运算：
    -x, +x, ~x 
    
    幂运算：
    x ** y

    索引和分片：
    x[i], x[i:j], x[i:j:stride]
    
    调用：
    x(...)

    取属性：
    x.attribute
    
    元组：(...)
    序列：[...]
    字典：{...}

    三元选择表达式：x if y else z

    匿名函数：lambda args: expression

    生成器函数发送协议：yield x

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

语句：
    赋值语句
    调用
    print：打印对象
    if/elif/else:条件判断
    for/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, 函数参数
    
    元组和列表分解赋值：当赋值符号(=)的左侧为元组或者列表时，Python会按照位置把右边的对象和左边的目标自左而右逐一进行配对；个数不同时会触发异常，此时可以切片的方式进行；

    多重目标复制： 
        num1 = num2 = num3 = 100

    增强赋值：+=, -=, *=, /=, //=, &=,

Python流程控制

条件测试

if 条件测试表达式

Python中真和假的含义
    1.任何非0数字和非空对象都为真；
    2.数字0、空对象和特殊对象None均为假；
    3.比较和相等策测试会递归的应用与数据结构中；
    4.返回值为Ture或False；

if

    In [47]: x = 1

    In [48]: y = 2

    In [49]: if x > y:
        ...:     print "the max number is %d." % x
        ...: else:
        ...:     print "the max number is %d." % y
        ...:
    the max number is 2.

elif

    In [51]: name = "jerry"

    In [53]: if name == "Tom":
        ...:     print "It is %s." % name
        ...: elif name == "hanmeimei":
        ...:     print "It is %s." % name
        ...: else:
        ...:     print "alien."
        ...:
    alien.



组合条件测试：
    X and Y: 与运算
    X or Y： 或运算
    not X： 非运算


A = X if Y else Z
    if Y:
        A = X
    else
        A = Z

expression1 if boolean_expression else expression2
    如果满足boolean_expression则显示expression1，否则显示expression2

    (三元表达式)
    In [55]: A = 7

    In [56]: B = 9
    
    In [57]: max = A if A > B else B
    
    In [58]: print max
    9

while：

    while bool_expression；
        while_suite
    else:
        else_suite

    break：跳出最内层循环；
    continue：跳到所处的最近层循环的开始处；
    pass：占位语句
    else代码块：循环正常终止才会执行；如果循环终止是由break跳出导致的，则else不会执行；

语法格式扩展：
    while bool_expression:
        while_suite
        if boolean_expression2:break
        if boolean_expression3:continue
    else:
        else_suite

for：

for expression1 in iterable:
    for_suite
else:
    else_sutie

1.通常，expression是一个单独的变量，或是一个变量序列，一般以元组的形式给出
2.如果以元组或列表用于expression，则其中的每个数据都会拆分到表达式的项，例如
    T=[(1,2),(3,4),(5,6),(7,8)]
    for (a,b) in T:
        print a,b

扩展形式：
    
    for expression in inerable:
        for_suite
        if boolean_expression2:break
        if boolean_expression3:continue
    else:
        else_suite

编写循环到的技巧
    for循环比while循环执行速度快
    python提供了两个内置函数，用于在for循环中制定特殊的循环
    range：一次性的返回连续的整数列表
    xrange：一次产生一个数据元素，相较于range更节约空间
    zip：返回并行的元素元组的列表，长用于在for循环中遍历数个序列

range函数

非完备遍历

        用于每隔一定的个数元素挑选一个元素
            >>>S= ‘www.knownsec.com’
            >>>range(0,len(S),2)
            [0, 2, 4, 6, 8, 10, 12, 14]
            
            >>>for i in range(1,len(S),2):
            >>>    print S[i],
            w . n w s c c m

    修改元表
        >>>L = [1,2,3,4,5]
        >>>for i in range(len(L)):L[i]+=1
        
        >>>print L
        [2,3,4,5,6]

并行遍历

并行遍历

回顾

1.动态语言
    sys.getrefcount() 查看引用次数
    
    增加对象的引用计数场景
        对象创建时
        将对象添加进容器时：类似list.append()
        当对象被当做参数传递给函数时
        为对象创建另外变量名

    减少引用技数：
        引用次对象的变量名被显示销毁：del x
        给引用次对象的某变量名重新赋值
        从容器中移除对象时，类似list.pop（）
        容器本身被销毁
2.if
    if boolean_expression:
        ...
    elif boolean_expresssion:
        ...
    else:
        ...

2.while
    while boolean_expression:
        while_suite
        if boolean_expression2: contiune
        if boolean_expression3: break
    else:
        else_suite

4.for
    for expression in object:
        for_suite
        """if boolean_expression2: contiune
        if boolean_expression3: break
    else:
        else_suite"""可省

Python迭代

迭代：重复做一件事
iterable（可迭代）对象
    支持每次返回自己所包含的一个成员对象
    对象实现了__iter__方法
        序列类型如：list，str，tuple
        非序列类型：dict，file
        用户自定义的一些包含了__iter__()或__getitem__()方法的类