列表赋值:
        l1=[]
        l1.append()
    字典赋值：
        a={}
        a['key1']='value'
    字典动态赋值：
        创建只有一项元素的列表
        dict['key1']=[item,]
    如果字典不是空值，那么字典里里面的元素可以直接添加a['key1']='value'，如果字典是空，那么添加字典的方式：dict['key1']=[item,]
        例：
            #!/usr/bin/env python
            name={}
            file_obj=file('user_list','r')
            user_read=file_obj.readlines()
            file_obj.close()
            for item in user_read:
                user_str=item.strip()
                user_list=user_str.split(';')
                name[user_list[0]]=user_list[1:]
            print name
            {'tony': ['234', '2'], 'jony': ['123', '3'], 'tom': ['123', '2']}
    collection系列
        import collections x先导入模块
        counter(dict)扩展的字典
        most_common(3):取出里面的前3位数
        update:两者相加
        clear:清除
        1、计数器Counter
        2、有序字典
            o1=collections.OrderedDict(字典)
            维护一套字典+列表
        3、默认字典(字典里的value设置默认类型)
            from collections import defaultdict
            my_dict=collections.defaultdict(list) 默认定义成字典里面的value设置成列表。
            my_dict['key1'].append(1)
            例如：
                方法一默认字典：
                my_dict=collections.defaultdict(list)
                my_dict['key1'].append(1)
                方法二原生态定义：
                my_dict={}
                my_dict['key1']=[]
                my_dict['key1'].append()        
        4、可命名元组
            collections.namedtuple(创建命名的元组)  ###坐标中用的比较多
            (1)、创建类
            (2)、使用类创建对象
            (3)、使用对象
            例如：
                import collections
                #创建一个扩展的tuple的类，Mytuple
                Mytuple=collections.namedtuple('Mytuple',['x','y'])
                new=Mytuple(1,2)
                print new  ###Mytuple(x=1,y=2)
                ###调用
                new.x ==>1
                new.y==>2
        5、双向队列
            collections.deque
            (1)、双向都可以取，都可以插入
            (2)、线程安全，多线程抢占资源，加锁
            pop:删除右边的
            popleft：删除左边的
            reverse:反转
            append:追加
            注意：单项队列不在collections模块中，在Queue中
            import Queue
            #创建q队列，只存10个数
            q=Queue.Queue(10)
            添加：q.put(值)
            取数：q.get()
    迭代器
        必须要有iter这个方法。
    生成器
        yield  和 xrange ,生成器只有使用时才创建。
        
函数：
    代码块，
    __name__=="__main__":标示主程序是谁
    vars()==当前模块的所有变量
    __name__:"__main__"
    __doc__:注释
    __file__:文件路径
    reload(temp):重新加载导入到模块。
    divmod:分页
    pow(2,11):2的11次方
    all()：接受一个序列，判断，所有值都是真，返回真，否则返回假。
    例如：li=['tom','',19] ==>all(li)==>False
    any():只要有一个为真即为真。
    例如：li=['tom','',19] ==>any(li)==>True
    ord():字母转换为ASCII码
    chr():ASCII码转为字母
    enumerate([11,22,33,44],执行数字起始值)
    例如：
        enumerate([11,22,33,44],1):下标从1开始    
    1、def 定义函数的关键字
    2、函数名，日后通过函数名调用函数
    3、函数声明，不自动执行，调用后才执行
    4、函数的参数
    5、函数的返回值
    
    函数的返回值：
        告诉调用者成功与否。
        1、若没有返回值，则默认返回None
        2、如果有返回值return 值,则赋值给变量
    函数的参数：
        普通参数
            形式参数，形参   例如： def email(message) message:形参
            实际参数，实参     例如： email("CPU 报警")  "CPU 报警"：实参
            参数可以有n个
        默认参数
            def email(ff,aa,subject='nihao')
            1、不传值，则使用默认值，默认参数必须放置到参数列表的最后。
        动态参数
            def func(*args)
            1、接受多个参数
            2、内部自动构造元组。
            3、传序列是，前面加*,避免内部构造元组。
            动态参数一传列表：
                def func(*args)
                    print args[0]
                li=[11,22,33]
                func(*li)
            动态参数二传字典：
                def func(**kwargs):
                    print kwargs
                1、func(k1=123,k2='qws')
                2、dic={'k1':123,'k2':'qws'}
                    func(**dic)
            动态参数三两者结合：
                def func(*args,**kwargs)
文件操作
    1、打开文件
        open:推荐使用
        file：3.0以后集成到别的地方，不建议使用
        obj=open('log')
        obj.tell():文件指针位置显示
        obj.seek():指定指针位置，从哪个位置开始。
        obj.truncate():根据当前指针的位置，截取指针前面的数据，指针后面的数据舍弃。如若里面有参数，那么就不管指针的位置，直接截取传入的参数的值的个数。
        rb：以二进制方式打开只读
        rU：把文件里面的\n\b\r，统一转换为\n
        r+U：U只能跟r结合
    2、操作文件
        flush：刷新文件内部缓冲区
        next:获取下一行数据，若不存在，则报错
        read()：读取内容，可以加参数，则只读参数个数的字符到缓冲区
        xreadlines:只取一行
with
    自动关闭文件，不用在关心是否关闭了
    with open('log','r') as obj:
        obj.write(XXXXX)
    2.7以后支持：with open('log1','r') as obj1,open('log2','w') as obj2
        for line in obj1:
            new_line=line.replace()