【郑州校区】python常用标准库

-------------------系统内建函数-------------------
1、字符串
    str='这是一个字符串数据测试数据'对应
    str[0]：获取str字符串中下标为0的字符。
    str[3]：获取str字符串中下标为3的字符。
    str[0:3]：获取到字符串中从下标为0到下标为3的字符串。

    str.find()：返回指定str字符串中是否存在指定的字符串数据信息；如果存在则返回字符串首字母的下标，如果不存在则返回-1。
    str.index()：返回指定str字符串中是否存在指定的字符串数据信息；如果存在则返回字符串首字母的下标，如果不存在进行错误异常处理。
    str.count()：返回指定str字符串中被查找字符串存在的个数信息。
    len(str)：返回指定str字符串的字符总长度；如果字符串为空，则返回值为0。
    str.replace('替换前字符','替换后字符'，指定替换的次数)：进行指定str字符串中指定字符数据的替换操作，并将替换后的数据进行返回。
    str.split(" ",切割次数):进行指定字符串的切割，返回被切割后的字符串列表数据信息；如果切割次数不填，默认进行最大的切割次数。
    str.capitalize()：将指定str字符串的第一个字符进行大写。
    str.startswith(匹配字符串数据)：返回boolen类型，匹配指定str字符串是否以指定字符串数据开头。
    str.endswith(匹配字符串数据)：返回boolen类型，匹配指定str字符串是否以指定字符串数据结尾。
    str.lower()：将指定的字符串数据信息进行统一的小写转换并返回转换后的数据。
    str.upper()：将指定的字符串数据信息进行统一的大写转换并返回转换后的数据。
    str.ljust(指定返回的字符串长度)：返回一个字符串，将指定str进行左对齐，如果str字符串长度小于指定的长度，则进行右侧的空格补充操作。
    str.rjust(指定返回的字符串长度)：返回一个字符串，将指定str进行右对齐，如果str字符串长度小于指定的长度，则进行左侧的空格补充操作。
    str.center(制定返回的字符串长度)：返回一个字符串，将制定str进行中间对齐，如果str字符串长度小于指定的长度，则进行两边的空格的补充操作。
    str.lstrip()：返回字符串，删除左侧的空格。
    str.rstrip()：返回字符串，删除末尾的空格。
    str.rfind()：类似find函数，从指定字符串的右侧开始进行查找，返回查找到的字符串第一个字符的下标。
    str.rindex()：类似index函数，从指定str字符串的左侧开始进行查找，返回查找到的字符串第一个字符串下标。
    str.partition(指定分割的字符串)：从指定str字符串中，查找制定分割的字符串，返回一个列表包含它的前面部分，它自身和它的后面部分；如果字符串的匹配没有成功，则返回它自身和前后两个空字符。
    str.rpartition(指定分割的字符串)：类似partition函数，只是指定的分割字符串是从右开始查找的。
    str.splitlines()：进行行分割，返回一个列表，以每行数据作为一个元素进行保存。
    str.isdigit()：返回boolen类型，判断指定str字符串中的数据是否为字母或数字。
    str.isalpha()：返回boolen类型，判断指定str字符串中的数据是否为纯字母。
    str.isalnum()：返回boolen类型，判断指定str字符串中的数据是否为纯数字。
    str.isspace()：返回boolen类型，判断指定str字符串中的数据是否只包含空格。
    str.isupper()：返回boolen类型，判断指定str字符串中的数据是否为纯大写。
    str.islower()：返回boolen类型，判断指定str字符串中的数据是否为纯小写。
    mystr.join(str)：将类表mystr中的数据，根据指定的str字符串进行拼接操作；返回拼接后的字符串数据信息。
    print("%0.1f",float(result*1.0))：进行浮点数的转换，并打印小数点后一位的数据
    print("%d*%d=%d"%(j,i,i*j),end=' ')：结束最后的换行

2、文件流
    文件流对应的基础操作：
        f=open('文件名','访问模式')；if f：返回boolen类型，判断文件是否打开。
            w：打开一个文件只用于写入；如果该文件已经存在则将其覆盖；如果该文件不存在，则创建一个新的文件。
            r：以只读的方式打开文件；文件的指针将会放在文件的开头；这个是默认模式。
            a：打开一个文件用于追加；如果该文件已存在，文件指针将会放在文件的结尾；也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

            rb：以二进制格式打开一个文件用于只读，文件指针将会放在文件的开头。这是默认模式。
            wb：以二进制格式打开一个文件用于写入，如果该文件已存在则将其进行覆盖。如果该文件不存在则创建新文件。
            ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后；如果该文件不存在，创建新文件进行写入操作。

            r+：打开一个文件用于读写；文件指针将会放在文件的开头。
            w+：打开一个文件用于读写；如果噶文件已存在则将其覆盖。如果该文件不存在，创建新文件
            a+：打开一个文件用于读写；如果该文件存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

            rb+：以二进制格式打开一个文件用于读写；文件指针将会放在文件的开头。
            wb+：以二进制格式打开一个文件用于读写；如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
            ab+：以二进制格式打开一个文件用于追加；如果该文件已存在，文件指针将会放在文件的结尾；如果文件不存在，创建新文件用于读写。


         f.close()：文件流操作结束后进行关闭。
         f.wirte(写入的内容)：打开文件后，将指定内容写入文件中。
         f.read(读取数据的长度)：使用read可以从文件中读取指定长度的数据，并将指针移到这条数据之后；默认读取全部数据。
         f.readline()：读取文件中一行数据的信息，指针移动的下一行。
         f.readlines()：读取整个文件的数据信息信息，返回一个列表，列表中每个元素为一行数据的信息。
         f.tell()：查看当前位置，就是指针对应的位置。
    seek(offset,from)：将指针定位到某个位置
        from：方向
            0：表示文件的开头。
            1：表示文件的当前位置。
            2：表示文件的末尾。
        offset：偏移量
            测试
              f.seek(5,0)：文件开头，向后偏移5个位置
              f.seek(-3,2)：文件结尾，向前偏移3个位置

3、列表、字典、元组操作
    1、列表:
        strList=['']：列表的创建。
        str='字符串'
        newStr='新的字符串'。
        strList.append：进行列表数据信息的添加操作。
        strList[0]=newStr：根据下标，进行列表指定元素数据信息的修改操作
        str in strLsit：返回boolen类型，指定字符串信息是否在列表中存在。
        for item in strList：进行列表数据的遍历操作，item为元素值
        del strList[0]：根据列表下标，删除指定的列表元素。
        strList.pop()：删除列表最后一个元素的数据信息。
        strList.remove('元素的值')：根据元素的值进行删除操作。

    2、字典：
        修改元素：根据Key值进行修改
        添加元素：infor['age']=18
        删除元素：del
        清空字典中的数据信息：infor.clear

    3、字典的常见操作
        dic={1:'xiaohao',2:'xiaodong'}：创建一个字典对象。
        dic.keys()：获取字典所有对应的键，以列表的形式进行返回。
        dic.valuses()：获取字典所有对应的值，以列表的形式进行返回。
        dic.items()：获取字典中的键值数据，以列表的形式返回，每个元素都一个元组，分别存放着键和值。
        dic.has_key(1)：返回boolen类型，判断键值是否存在

    4、元组：
        tuple=(1,2,3,4,5)：创建一个元组。
        tuple[2]：根据下标读取到第三个元素。
        tuple[-2]：根据下标读取到倒数第二个元素。
        tuple[1:]：截取元组第二个元素到最后。
        cmp(tuple1,tuple2)：比较两个元组中的元素。
        max(tuple)：返回元组中元素的最大值。
        min(tuple)：返回元组中元素的最小值。
        tuple(seq)：将列表转换为元组。

    5、运算符操作列表、字典、元组的技巧：
        1、len((1,2,3,4))：获取到元组中元素的个数。
        2、(1,2,3,4) +(1,2,3,4,5) ；进行两个元组的合并，获取到一个新的元组。
        3、['Hi']*4：创建一个新的列表，并将列表中的数据进行复制四次。
        4、1 in (1,2,3,4)：判断元素是否存在；返回boolen类型。

4、异常捕获
    定义：某些错误操作导致程序无法正常运行
    异常捕获：
          try：
          except(NameError,IOError),result：
              print(result)#返回具体的错误信息
          else：
              print("我是else")
          finally:
              print("我是finally")

5、range：获取
    1、help(range):
        range(stop) -> list of integers
        range(start, stop[, step]) -> list of integers
    2、参数分析：
        1、start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）。
        2、stop:到stop结束，但不包括stop.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5。
        3、step:每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)。
    3、示例：
        a = range(5)
        list(a)

6、map：函数
    1、help(map):
        map(...)
        map(function, sequence[, sequence, ...]) -> list
    2、参数分析：
        1、function:是一个函数
        2、sequence:是一个或多个序列,取决于function需要几个参数
        3、返回值是一个list
    3、语法：
        参数序列中的每一个元素分别调用function函数，返回包含每次function函数返回值的list。
    4、示例
        #函数需要一个参数
        map(lambda x: x*x, [1, 2, 3])
        [1, 4, 9]

        #函数需要两个参数
        map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])
        [5, 7, 9]

        #函数为None,相当于合并参数为元祖
        map(None, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
        [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

        #两个序列参数个数不一致时，个数少的补None
        map(None, [1, 3, 5, 7, 9], [2, 4, 6])
        [(1, 2), (3, 4), (5, 6), (7, None), (9, None)]

7、filter：函数
    1、help(filter):
        filter(...)
        filter(function or None, sequence) -> list, tuple, or string

        Return those items of sequence for which function(item) is true.  If
        function is None, return the items that are true.  If sequence is a tuple
        or string, return the same type, else return a list.
    2、参数分析：
        1、function:接受一个参数，返回布尔值True或False
        2、sequence:序列可以是str，tuple，list
    3、语法
        filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为True的元素。返回值的类型和参数sequence的类型相同
    4、示例
        filter(lambda x: x%2, [1, 2, 3, 4])
        [1, 3]

        filter(None, "she")
        'she'

8、reduce：函数
    1、help(reduce):
        reduce(...)
            reduce(function, sequence[, initial]) -> value

            Apply a function of two arguments cumulatively to the items of a sequence,
            from left to right, so as to reduce the sequence to a single value.
            For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
            ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
            of the sequence in the calculation, and serves as a default when the
            sequence is empty.
    2、参数分析：
        1、function:该函数有两个参数
        2、sequence:序列可以是str，tuple，list
        3、initial:固定初始值

    3、语法
        reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。 第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial 作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。 注意function函数不能为None。
    4、示例
        reduce(lambda x, y: x+y, [1,2,3,4])
        10

        reduce(lambda x, y: x+y, [1,2,3,4], 5)
        15

        reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')
        'ddaabbcc'

9、sorted：函数
    1、help(sorted):
        sorted(...)
            sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
    2、参数分析：
        自定义cmp比较函数，返回三种情况：
            x<y 返回-1
            x>y 返回1
            x==y 返回0
    3、示例
        def cmp_ignore_case(s1, s2):
            u1 = s1.upper()
            u2 = s2.upper()
            if u1 < u2:
                return -1
            if u1 > u2:
                return 1
            return


-------------------系统库函数，帮助文档查找-------------------
    1、库函数：print()、raw_input() 系统给的叫库函数

    2、用户自定义函数：如果系统中，没有需要的功能，那么此时就需要自己开发一个，这就是自定义函数

    3、ipython下：
        dir(包名)：查看该包下的对应的函数信息
        help(包名)：查看该包中的分装的函数信息
        包名.path：可以获取到指定包对应的文件路径


-------------------builtins：内建函数默认加载-------------------


-------------------os：操作系统接口-------------------
    import os引用系统的包
    os.name()：判断现在正在使用的平台，widows返回'nt'；Linux返回'posix'。
    os.getcwd()：得到当前工作的目录。
    os.listdir()：指定所有目录下所有的文件和目录名。
    os.remove()：删除指定文件。
    os.rmdir()：删除指定目录。
    os.mkdir()：创建目录，只能建立一层。
    os.makedirs()：递归创建目录。
    os.path.isfile()：判断制定对象是否为文件。是返回True，否则False。
    os.path.isdir()：判断指定对象是否为目录。是True，否则False。
    os.path.exists()：检验指定的对象是否存在。是True，否则False。
    os.path.split()：返回路径的目录和文件名。
    os.getcwd()：获得当前工作的目录。
    os.system()：执行shell命令。
    os.chdir()：改变目录到指定目录。
    os.path.getsize()：获得文件的大小，如果为目录，返回0。
    os.path.abspath()：获得绝对路径。
    os.path.join(path,name)：连接目录和文件名。
    os.path.basename(path)：返回文件名。
    os.path.dirname(path)：返回文件路径。


-------------------sys：Python自身的运行环境-------------------
    import sys引用系统的包
    sys.stdin
    sys.argv：获取到执行文件时，对应的参数信息


-------------------functools：常用的工具-------------------
    1、概念：
        functools 是python2.5被引人的,一些工具函数放在此包里。

    2、操作：
        1、import functools ：引用对应的包
        2、dir(functools) ：查看包中对应的工具函数

    1、partial函数（偏函数）：
        1、概念：
            把一个函数的某些参数设置默认值，返回一个新的函数，调用这个新函数会更简单。
        2、示例：
            import functools
            def showarg(*args, **kw):
                print(args)
                print(kw)

            p1=functools.partial(showarg, 1,2,3)
            p1()
            p1(4,5,6)
            p1(a='python', b='itcast')

            p2=functools.partial(showarg, a=3,b='linux')
            p2()
            p2(1,2)
            p2(a='python', b='itcast')

    2、wraps函数：
        1、概念：
            使用装饰器时，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。Python的functools包中提供了一个叫wraps的装饰器来消除这样的副作用
        2、示例：
            import functools
            def note(func):
                "note function"
                @functools.wraps(func)
                def wrapper():
                    "wrapper function"
                    print('note something')
                    return func()
                return wrapper

            @note
            def test():
                "test function"
                print('I am test')

            test()
            print(test.__doc__)


-------------------json：编码和解码 JSON 对象-------------------


-------------------logging：记录日志，调试-------------------


-------------------fork/multiprocessing：多进程-------------------
    import os ：

    1、pid=os.fork()：程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），然后复制父进程的所有信息到子进程中；然后父进程和子进程都会从fork()函数中得到一个返回值，其进程中这个值一定是0，而父进程中是子进程的 id号；主：fock()函数只能在Unix/Linux/Mac上运行，windows不可以运行。

        import os

        # 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
        pid = os.fork()

        if pid == 0:
            print('哈哈1')
        else:
            print('哈哈2')

    os.getpid()：获取到当前进程的PID号
    os.getppid()：获取到父进程的PID号

    2、进程创建的第二种方式：
    from multiprocessing import Process：引用对应的包。

    p=Process(target=run_proc,args=('test',))：调用Process类，进行进程对象的创建操作。为参数target赋值进程要实现的方法，为参数args赋值方法中传入对应的参数。
    p.start()：开启执行对应的进程操作。
    p.join()：等待当前进程执行结束，可以等待子进程结束后再继续向下运行，通常用于进程间的同步。
    multiprocessing.cpu_count()：获取到进程执行的所使用的cpu的内核个数。

    pipe=multiprocessing.Pipe()：管道实现进程间的通讯。一个管道有两个端口，分别为pipe[0]与pipe[1]
    pipe[0].send(向管道中添加的数据)：管道的添加操作。
    pipe[0].recv()：从管道中取出对应的数据信息。

    3、from multiprocessing import Process,Queue：应用对应的包，为实现进程之间的通信操作；管道的俩个端一个是负责向里面写入数据，一个是负责向外面读取数据。
    q=Queue()：创建一个队列对象。
    q.put(要添加到队列中的数据信息)：将制定的数据添加到队列当中去。
    q.get(True)：从队列中要提取出的队列数据信息。
    q.empty()：判断当前队列是否为空。


-------------------threading：多线程-------------------
    1、线程应用的第一种模式thread模块是比较底层的模块
        import thread：引用对应的模块包。

        thread.start_new_thread(defName,())创建开启一个新的线程；第一个参数为新线程要执行的方法，第二个参数为元组传递执行方法对应需要参数；注：python元组为一个时需要(元素,)一个元素加一个'，'进行表示。
        thread.exit_thread()：主线程调用该方法表示所有的线程结束操作；子线程通过调用exit.thread()的方法来表示实现当前子线程的结束操作。
        thread.join()： python的Thread类中还提供了join()方法，使得一个线程可以等待另一个线程执行结束后再继续运行。这个方法还可以设定一个timeout参数，避免无休止的等待。因为两个线程顺序完成，看起来象一个线程，所以称为线程的合并
        thread.setDaemon(True)：默认情况主线程退出时会等待子线程的结束，如果希望主线程不等待子线程，可以设置子线程为后台线程，主线程退出，子线程随即结束。


    2、线程应用的第二种模式threading模块是对thread模块进行了一定的封装，可以更方便我们的使用。
        import threading：引用对应的模块包。
        myThread=threading.Thread(target=defName,args=('Alice',))创建一个线程，target赋值要执行线程的方法，args复制执行方法需要的参数信息。
        myThread.start()：线程开始执行。
        num=len(threading.enumerate)：查看当前执行的线程的数量。

    3、线程的应用的第三种方式创建一个线程类，继承基类threading.Thead；重写基类的def run(self):方法，将该线程要执行的程序写在该方法中。
        class MyThread(threading.Thread)：创建一个线程类
        进行基类构造函数的创建操作
        def __init__(self,name,time):
             threading.Thread.__init__(self,name='可以为线程的名字进行复制')

        myThread=MyThread()：线程对象的创建。
        myThread.start()：该线程执行。

    4、threading模块中定义了Lock()类，可以方便的处理锁定。
        mutex=threading.Lock()：互斥锁对象的创建。
        if mutex.acquire([blocking])：进行锁定，锁定成功后返回true；锁定方法acquire()可以有一个blocking参数。如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有指定，那么默认为True）；如果设定blocking为False，则当前线程不会堵塞。
        mutex.release()：执行完程序内容后进行锁的释放操作。

    5、支持同一线程多次请求同一资源，python提供了可重入锁。RLock对象中，同时维护着一个Lock和一个counter变量；counter变量存储acquire的次数，从而使得资源可以多次被acquire；直到一个线程中的所有的acquire被release，其他的线程才可以获得资源
        mutex=threading.RLock()：创建可重入锁对象。
        mutex.acquire()：进行上锁。
        mutex.release()：进行释放。

    6、python提供的Condition对象提供了对复杂线程同步问题的支持；Condition被称为条件变量；Condition维护着一个锁和一个waiting池。
        con=threading.Condition()：创建条件变量对象；可以接受一个Lock/RLock对象作为参数，如果没有指定则内部默认创建一个RLock
        con.acquire()：进行加锁。
        con.wait()：线程会释放Condition内部的锁并进入blocked（堵塞）状态，同时在waiting池中记录这个线程。
        con.notify()：Condition对象会从waiting池中挑选一个线程，通知其调用acquire方法尝试取到锁。
        con.notifyAll()：Condition对象通知waiting池中所有的线程，尝试acquire内部锁。作用防止有的线程永远处于沉默状态。
        con.release()：进行释放。

        threading.Event可以是一个线程等待其他线程的通知。其内置了一个标志，初始值为False。线程通过wait()方法进入等待状态，直到另一个线程调度set()方法将内置标志设置为True是，Event通知所有等待状态的线程回复运行。还可以用isSet()方法查询Event对象内置状态的当前值。
        event=threading.Event()：进行对应Envent对象的创建。
        def __init__(self,threadName,event):
             self.threadEvent=event ：重构对应threading.Thread基类中__init__的方法。
        self.threadEvent.wait()：使线程进入等待状态。
        event.set()：启动waiting池中等待的线程。


-------------------Queue：队列-------------------
    from Queue import Queue：引用对应的模块包。
    queue=Queue()：创建一个队列对象。
    queue.qsize()：获取队列中元素的数量。
    queue.put(向队列中添加的数据)：想队列中添加元素。
    queue.set()：从队列中取出元素。
    queue.empty()：判断队列是否为空。


-------------------copy：拷贝-------------------


-------------------time：时间-------------------


-------------------datetime：日期和时间-------------------


-------------------calendar：日历-------------------


-------------------hashlib：加密算法-------------------


-------------------random：生成随机数-------------------
    import random：引用对应的包
    random.random()：默认在0到1之间随机获取数据信息。
    random.uniform(1,5)：1到5之间随机获取对应的数值；包含小数部分。
    random.randint(10.50)：10到50之间对应随机获取对应的整数
    random.randrange(0,51,2)：0到51之间对应随机获取对应的3的倍数


-------------------re：字符串正则匹配-------------------
    import re：引用对应的包
    result=re.match(正则表达式，要匹配的字符串)：从第一个字符向后依次进行正则匹配操作，匹配出对应的数据信息。
    result.group()：如果上一步匹配到数据的话，可以使用group方法来提取数据。
    result=re.search(正则表达式，要匹配的字符串)：从匹配到的第一个字符向后依次进行匹配操作。
    result==None：判断获取的书数据是否为空。
    re.search(r'\d+','my hight 177 cm').group()：匹配出指定字符串中符合正则表达式的第一条数据（只能匹配一个）。
    re.findall(r'\d+','my hight 177 cm my weight 100 kg')：配匹配出指定字符串中所有符合正则表达式的有效数据，并以列表的形式进行返回。
    re.sub(r'\d+','100','my high 177 cm')：将匹配到的数据进行替换，参数：对应的正则表达式，要替换的数据，匹配出来的数据；

    方法一：
    #coding=utf-8
    import re

    ret = re.sub(r"\d+", '998', "python = 997")
    print ret

    返回结果：998

    方法二：
    #coding=utf-8
    import re

    def add(temp):
        strNum = temp.group()
        num = int(strNum) + 1
        return str(num)

    ret = re.sub(r"\d+", add, "python = 997")
    print ret

    ret = re.sub(r"\d+", add, "python = 99")
    print ret
    返回结果：100

    re.split(r':| ','address:beijing xxx@126.com')：根据匹配进行切割字符串，并返回一个列表。案例：根据：或空格进行字符串的切割操作，结果：['address','beijing','xxx@126.com']


-------------------socket：标准的 BSD Sockets API-------------------


-------------------shutil：文件和目录管理-------------------


-------------------glob：基于文件通配符搜索-------------------


-------------------keyword:关键字-------------------
    import keyword：引用对应的包
    keyword.kwlist()：获取对应的列表，列表中存储python中的对应关键字

【郑州校区】python常用标准库

-------------------系统内建函数-------------------
1、字符串
    str='这是一个字符串数据测试数据'对应
    str[0]：获取str字符串中下标为0的字符。
    str[3]：获取str字符串中下标为3的字符。
    str[0:3]：获取到字符串中从下标为0到下标为3的字符串。

    str.find()：返回指定str字符串中是否存在指定的字符串数据信息；如果存在则返回字符串首字母的下标，如果不存在则返回-1。
    str.index()：返回指定str字符串中是否存在指定的字符串数据信息；如果存在则返回字符串首字母的下标，如果不存在进行错误异常处理。
    str.count()：返回指定str字符串中被查找字符串存在的个数信息。
    len(str)：返回指定str字符串的字符总长度；如果字符串为空，则返回值为0。
    str.replace('替换前字符','替换后字符'，指定替换的次数)：进行指定str字符串中指定字符数据的替换操作，并将替换后的数据进行返回。
    str.split(" ",切割次数):进行指定字符串的切割，返回被切割后的字符串列表数据信息；如果切割次数不填，默认进行最大的切割次数。
    str.capitalize()：将指定str字符串的第一个字符进行大写。
    str.startswith(匹配字符串数据)：返回boolen类型，匹配指定str字符串是否以指定字符串数据开头。
    str.endswith(匹配字符串数据)：返回boolen类型，匹配指定str字符串是否以指定字符串数据结尾。
    str.lower()：将指定的字符串数据信息进行统一的小写转换并返回转换后的数据。
    str.upper()：将指定的字符串数据信息进行统一的大写转换并返回转换后的数据。
    str.ljust(指定返回的字符串长度)：返回一个字符串，将指定str进行左对齐，如果str字符串长度小于指定的长度，则进行右侧的空格补充操作。
    str.rjust(指定返回的字符串长度)：返回一个字符串，将指定str进行右对齐，如果str字符串长度小于指定的长度，则进行左侧的空格补充操作。
    str.center(制定返回的字符串长度)：返回一个字符串，将制定str进行中间对齐，如果str字符串长度小于指定的长度，则进行两边的空格的补充操作。
    str.lstrip()：返回字符串，删除左侧的空格。
    str.rstrip()：返回字符串，删除末尾的空格。
    str.rfind()：类似find函数，从指定字符串的右侧开始进行查找，返回查找到的字符串第一个字符的下标。
    str.rindex()：类似index函数，从指定str字符串的左侧开始进行查找，返回查找到的字符串第一个字符串下标。
    str.partition(指定分割的字符串)：从指定str字符串中，查找制定分割的字符串，返回一个列表包含它的前面部分，它自身和它的后面部分；如果字符串的匹配没有成功，则返回它自身和前后两个空字符。
    str.rpartition(指定分割的字符串)：类似partition函数，只是指定的分割字符串是从右开始查找的。
    str.splitlines()：进行行分割，返回一个列表，以每行数据作为一个元素进行保存。
    str.isdigit()：返回boolen类型，判断指定str字符串中的数据是否为字母或数字。
    str.isalpha()：返回boolen类型，判断指定str字符串中的数据是否为纯字母。
    str.isalnum()：返回boolen类型，判断指定str字符串中的数据是否为纯数字。
    str.isspace()：返回boolen类型，判断指定str字符串中的数据是否只包含空格。
    str.isupper()：返回boolen类型，判断指定str字符串中的数据是否为纯大写。
    str.islower()：返回boolen类型，判断指定str字符串中的数据是否为纯小写。
    mystr.join(str)：将类表mystr中的数据，根据指定的str字符串进行拼接操作；返回拼接后的字符串数据信息。
    print("%0.1f",float(result*1.0))：进行浮点数的转换，并打印小数点后一位的数据
    print("%d*%d=%d"%(j,i,i*j),end=' ')：结束最后的换行

2、文件流
    文件流对应的基础操作：
        f=open('文件名','访问模式')；if f：返回boolen类型，判断文件是否打开。
            w：打开一个文件只用于写入；如果该文件已经存在则将其覆盖；如果该文件不存在，则创建一个新的文件。
            r：以只读的方式打开文件；文件的指针将会放在文件的开头；这个是默认模式。
            a：打开一个文件用于追加；如果该文件已存在，文件指针将会放在文件的结尾；也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

            rb：以二进制格式打开一个文件用于只读，文件指针将会放在文件的开头。这是默认模式。
            wb：以二进制格式打开一个文件用于写入，如果该文件已存在则将其进行覆盖。如果该文件不存在则创建新文件。
            ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后；如果该文件不存在，创建新文件进行写入操作。

            r+：打开一个文件用于读写；文件指针将会放在文件的开头。
            w+：打开一个文件用于读写；如果噶文件已存在则将其覆盖。如果该文件不存在，创建新文件
            a+：打开一个文件用于读写；如果该文件存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

            rb+：以二进制格式打开一个文件用于读写；文件指针将会放在文件的开头。
            wb+：以二进制格式打开一个文件用于读写；如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
            ab+：以二进制格式打开一个文件用于追加；如果该文件已存在，文件指针将会放在文件的结尾；如果文件不存在，创建新文件用于读写。


         f.close()：文件流操作结束后进行关闭。
         f.wirte(写入的内容)：打开文件后，将指定内容写入文件中。
         f.read(读取数据的长度)：使用read可以从文件中读取指定长度的数据，并将指针移到这条数据之后；默认读取全部数据。
         f.readline()：读取文件中一行数据的信息，指针移动的下一行。
         f.readlines()：读取整个文件的数据信息信息，返回一个列表，列表中每个元素为一行数据的信息。
         f.tell()：查看当前位置，就是指针对应的位置。
    seek(offset,from)：将指针定位到某个位置
        from：方向
            0：表示文件的开头。
            1：表示文件的当前位置。
            2：表示文件的末尾。
        offset：偏移量
            测试
              f.seek(5,0)：文件开头，向后偏移5个位置
              f.seek(-3,2)：文件结尾，向前偏移3个位置

3、列表、字典、元组操作
    1、列表:
        strList=['']：列表的创建。
        str='字符串'
        newStr='新的字符串'。
        strList.append：进行列表数据信息的添加操作。
        strList[0]=newStr：根据下标，进行列表指定元素数据信息的修改操作
        str in strLsit：返回boolen类型，指定字符串信息是否在列表中存在。
        for item in strList：进行列表数据的遍历操作，item为元素值
        del strList[0]：根据列表下标，删除指定的列表元素。
        strList.pop()：删除列表最后一个元素的数据信息。
        strList.remove('元素的值')：根据元素的值进行删除操作。

    2、字典：
        修改元素：根据Key值进行修改
        添加元素：infor['age']=18
        删除元素：del
        清空字典中的数据信息：infor.clear

    3、字典的常见操作
        dic={1:'xiaohao',2:'xiaodong'}：创建一个字典对象。
        dic.keys()：获取字典所有对应的键，以列表的形式进行返回。
        dic.valuses()：获取字典所有对应的值，以列表的形式进行返回。
        dic.items()：获取字典中的键值数据，以列表的形式返回，每个元素都一个元组，分别存放着键和值。
        dic.has_key(1)：返回boolen类型，判断键值是否存在

    4、元组：
        tuple=(1,2,3,4,5)：创建一个元组。
        tuple[2]：根据下标读取到第三个元素。
        tuple[-2]：根据下标读取到倒数第二个元素。
        tuple[1:]：截取元组第二个元素到最后。
        cmp(tuple1,tuple2)：比较两个元组中的元素。
        max(tuple)：返回元组中元素的最大值。
        min(tuple)：返回元组中元素的最小值。
        tuple(seq)：将列表转换为元组。

    5、运算符操作列表、字典、元组的技巧：
        1、len((1,2,3,4))：获取到元组中元素的个数。
        2、(1,2,3,4) +(1,2,3,4,5) ；进行两个元组的合并，获取到一个新的元组。
        3、['Hi']*4：创建一个新的列表，并将列表中的数据进行复制四次。
        4、1 in (1,2,3,4)：判断元素是否存在；返回boolen类型。

4、异常捕获
    定义：某些错误操作导致程序无法正常运行
    异常捕获：
          try：
          except(NameError,IOError),result：
              print(result)#返回具体的错误信息
          else：
              print("我是else")
          finally:
              print("我是finally")

5、range：获取
    1、help(range):
        range(stop) -> list of integers
        range(start, stop[, step]) -> list of integers
    2、参数分析：
        1、start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）。
        2、stop:到stop结束，但不包括stop.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5。
        3、step:每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)。
    3、示例：
        a = range(5)
        list(a)

6、map：函数
    1、help(map):
        map(...)
        map(function, sequence[, sequence, ...]) -> list
    2、参数分析：
        1、function:是一个函数
        2、sequence:是一个或多个序列,取决于function需要几个参数
        3、返回值是一个list
    3、语法：
        参数序列中的每一个元素分别调用function函数，返回包含每次function函数返回值的list。
    4、示例
        #函数需要一个参数
        map(lambda x: x*x, [1, 2, 3])
        [1, 4, 9]

        #函数需要两个参数
        map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])
        [5, 7, 9]

        #函数为None,相当于合并参数为元祖
        map(None, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
        [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

        #两个序列参数个数不一致时，个数少的补None
        map(None, [1, 3, 5, 7, 9], [2, 4, 6])
        [(1, 2), (3, 4), (5, 6), (7, None), (9, None)]

7、filter：函数
    1、help(filter):
        filter(...)
        filter(function or None, sequence) -> list, tuple, or string

        Return those items of sequence for which function(item) is true.  If
        function is None, return the items that are true.  If sequence is a tuple
        or string, return the same type, else return a list.
    2、参数分析：
        1、function:接受一个参数，返回布尔值True或False
        2、sequence:序列可以是str，tuple，list
    3、语法
        filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为True的元素。返回值的类型和参数sequence的类型相同
    4、示例
        filter(lambda x: x%2, [1, 2, 3, 4])
        [1, 3]

        filter(None, "she")
        'she'

8、reduce：函数
    1、help(reduce):
        reduce(...)
            reduce(function, sequence[, initial]) -> value

            Apply a function of two arguments cumulatively to the items of a sequence,
            from left to right, so as to reduce the sequence to a single value.
            For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
            ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
            of the sequence in the calculation, and serves as a default when the
            sequence is empty.
    2、参数分析：
        1、function:该函数有两个参数
        2、sequence:序列可以是str，tuple，list
        3、initial:固定初始值

    3、语法
        reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。 第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial 作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。 注意function函数不能为None。
    4、示例
        reduce(lambda x, y: x+y, [1,2,3,4])
        10

        reduce(lambda x, y: x+y, [1,2,3,4], 5)
        15

        reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')
        'ddaabbcc'

9、sorted：函数
    1、help(sorted):
        sorted(...)
            sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
    2、参数分析：
        自定义cmp比较函数，返回三种情况：
            x<y 返回-1
            x>y 返回1
            x==y 返回0
    3、示例
        def cmp_ignore_case(s1, s2):
            u1 = s1.upper()
            u2 = s2.upper()
            if u1 < u2:
                return -1
            if u1 > u2:
                return 1
            return


-------------------系统库函数，帮助文档查找-------------------
    1、库函数：print()、raw_input() 系统给的叫库函数

    2、用户自定义函数：如果系统中，没有需要的功能，那么此时就需要自己开发一个，这就是自定义函数

    3、ipython下：
        dir(包名)：查看该包下的对应的函数信息
        help(包名)：查看该包中的分装的函数信息
        包名.path：可以获取到指定包对应的文件路径


-------------------builtins：内建函数默认加载-------------------


-------------------os：操作系统接口-------------------
    import os引用系统的包
    os.name()：判断现在正在使用的平台，widows返回'nt'；Linux返回'posix'。
    os.getcwd()：得到当前工作的目录。
    os.listdir()：指定所有目录下所有的文件和目录名。
    os.remove()：删除指定文件。
    os.rmdir()：删除指定目录。
    os.mkdir()：创建目录，只能建立一层。
    os.makedirs()：递归创建目录。
    os.path.isfile()：判断制定对象是否为文件。是返回True，否则False。
    os.path.isdir()：判断指定对象是否为目录。是True，否则False。
    os.path.exists()：检验指定的对象是否存在。是True，否则False。
    os.path.split()：返回路径的目录和文件名。
    os.getcwd()：获得当前工作的目录。
    os.system()：执行shell命令。
    os.chdir()：改变目录到指定目录。
    os.path.getsize()：获得文件的大小，如果为目录，返回0。
    os.path.abspath()：获得绝对路径。
    os.path.join(path,name)：连接目录和文件名。
    os.path.basename(path)：返回文件名。
    os.path.dirname(path)：返回文件路径。


-------------------sys：Python自身的运行环境-------------------
    import sys引用系统的包
    sys.stdin
    sys.argv：获取到执行文件时，对应的参数信息


-------------------functools：常用的工具-------------------
    1、概念：
        functools 是python2.5被引人的,一些工具函数放在此包里。

    2、操作：
        1、import functools ：引用对应的包
        2、dir(functools) ：查看包中对应的工具函数

    1、partial函数（偏函数）：
        1、概念：
            把一个函数的某些参数设置默认值，返回一个新的函数，调用这个新函数会更简单。
        2、示例：
            import functools
            def showarg(*args, **kw):
                print(args)
                print(kw)

            p1=functools.partial(showarg, 1,2,3)
            p1()
            p1(4,5,6)
            p1(a='python', b='itcast')

            p2=functools.partial(showarg, a=3,b='linux')
            p2()
            p2(1,2)
            p2(a='python', b='itcast')

    2、wraps函数：
        1、概念：
            使用装饰器时，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。Python的functools包中提供了一个叫wraps的装饰器来消除这样的副作用
        2、示例：
            import functools
            def note(func):
                "note function"
                @functools.wraps(func)
                def wrapper():
                    "wrapper function"
                    print('note something')
                    return func()
                return wrapper

            @note
            def test():
                "test function"
                print('I am test')

            test()
            print(test.__doc__)


-------------------json：编码和解码 JSON 对象-------------------


-------------------logging：记录日志，调试-------------------


-------------------fork/multiprocessing：多进程-------------------
    import os ：

    1、pid=os.fork()：程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），然后复制父进程的所有信息到子进程中；然后父进程和子进程都会从fork()函数中得到一个返回值，其进程中这个值一定是0，而父进程中是子进程的 id号；主：fock()函数只能在Unix/Linux/Mac上运行，windows不可以运行。

        import os

        # 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
        pid = os.fork()

        if pid == 0:
            print('哈哈1')
        else:
            print('哈哈2')

    os.getpid()：获取到当前进程的PID号
    os.getppid()：获取到父进程的PID号

    2、进程创建的第二种方式：
    from multiprocessing import Process：引用对应的包。

    p=Process(target=run_proc,args=('test',))：调用Process类，进行进程对象的创建操作。为参数target赋值进程要实现的方法，为参数args赋值方法中传入对应的参数。
    p.start()：开启执行对应的进程操作。
    p.join()：等待当前进程执行结束，可以等待子进程结束后再继续向下运行，通常用于进程间的同步。
    multiprocessing.cpu_count()：获取到进程执行的所使用的cpu的内核个数。

    pipe=multiprocessing.Pipe()：管道实现进程间的通讯。一个管道有两个端口，分别为pipe[0]与pipe[1]
    pipe[0].send(向管道中添加的数据)：管道的添加操作。
    pipe[0].recv()：从管道中取出对应的数据信息。

    3、from multiprocessing import Process,Queue：应用对应的包，为实现进程之间的通信操作；管道的俩个端一个是负责向里面写入数据，一个是负责向外面读取数据。
    q=Queue()：创建一个队列对象。
    q.put(要添加到队列中的数据信息)：将制定的数据添加到队列当中去。
    q.get(True)：从队列中要提取出的队列数据信息。
    q.empty()：判断当前队列是否为空。


-------------------threading：多线程-------------------
    1、线程应用的第一种模式thread模块是比较底层的模块
        import thread：引用对应的模块包。

        thread.start_new_thread(defName,())创建开启一个新的线程；第一个参数为新线程要执行的方法，第二个参数为元组传递执行方法对应需要参数；注：python元组为一个时需要(元素,)一个元素加一个'，'进行表示。
        thread.exit_thread()：主线程调用该方法表示所有的线程结束操作；子线程通过调用exit.thread()的方法来表示实现当前子线程的结束操作。
        thread.join()： python的Thread类中还提供了join()方法，使得一个线程可以等待另一个线程执行结束后再继续运行。这个方法还可以设定一个timeout参数，避免无休止的等待。因为两个线程顺序完成，看起来象一个线程，所以称为线程的合并
        thread.setDaemon(True)：默认情况主线程退出时会等待子线程的结束，如果希望主线程不等待子线程，可以设置子线程为后台线程，主线程退出，子线程随即结束。


    2、线程应用的第二种模式threading模块是对thread模块进行了一定的封装，可以更方便我们的使用。
        import threading：引用对应的模块包。
        myThread=threading.Thread(target=defName,args=('Alice',))创建一个线程，target赋值要执行线程的方法，args复制执行方法需要的参数信息。
        myThread.start()：线程开始执行。
        num=len(threading.enumerate)：查看当前执行的线程的数量。

    3、线程的应用的第三种方式创建一个线程类，继承基类threading.Thead；重写基类的def run(self):方法，将该线程要执行的程序写在该方法中。
        class MyThread(threading.Thread)：创建一个线程类
        进行基类构造函数的创建操作
        def __init__(self,name,time):
             threading.Thread.__init__(self,name='可以为线程的名字进行复制')

        myThread=MyThread()：线程对象的创建。
        myThread.start()：该线程执行。

    4、threading模块中定义了Lock()类，可以方便的处理锁定。
        mutex=threading.Lock()：互斥锁对象的创建。
        if mutex.acquire([blocking])：进行锁定，锁定成功后返回true；锁定方法acquire()可以有一个blocking参数。如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有指定，那么默认为True）；如果设定blocking为False，则当前线程不会堵塞。
        mutex.release()：执行完程序内容后进行锁的释放操作。

    5、支持同一线程多次请求同一资源，python提供了可重入锁。RLock对象中，同时维护着一个Lock和一个counter变量；counter变量存储acquire的次数，从而使得资源可以多次被acquire；直到一个线程中的所有的acquire被release，其他的线程才可以获得资源
        mutex=threading.RLock()：创建可重入锁对象。
        mutex.acquire()：进行上锁。
        mutex.release()：进行释放。

    6、python提供的Condition对象提供了对复杂线程同步问题的支持；Condition被称为条件变量；Condition维护着一个锁和一个waiting池。
        con=threading.Condition()：创建条件变量对象；可以接受一个Lock/RLock对象作为参数，如果没有指定则内部默认创建一个RLock
        con.acquire()：进行加锁。
        con.wait()：线程会释放Condition内部的锁并进入blocked（堵塞）状态，同时在waiting池中记录这个线程。
        con.notify()：Condition对象会从waiting池中挑选一个线程，通知其调用acquire方法尝试取到锁。
        con.notifyAll()：Condition对象通知waiting池中所有的线程，尝试acquire内部锁。作用防止有的线程永远处于沉默状态。
        con.release()：进行释放。

        threading.Event可以是一个线程等待其他线程的通知。其内置了一个标志，初始值为False。线程通过wait()方法进入等待状态，直到另一个线程调度set()方法将内置标志设置为True是，Event通知所有等待状态的线程回复运行。还可以用isSet()方法查询Event对象内置状态的当前值。
        event=threading.Event()：进行对应Envent对象的创建。
        def __init__(self,threadName,event):
             self.threadEvent=event ：重构对应threading.Thread基类中__init__的方法。
        self.threadEvent.wait()：使线程进入等待状态。
        event.set()：启动waiting池中等待的线程。


-------------------Queue：队列-------------------
    from Queue import Queue：引用对应的模块包。
    queue=Queue()：创建一个队列对象。
    queue.qsize()：获取队列中元素的数量。
    queue.put(向队列中添加的数据)：想队列中添加元素。
    queue.set()：从队列中取出元素。
    queue.empty()：判断队列是否为空。


-------------------copy：拷贝-------------------


-------------------time：时间-------------------


-------------------datetime：日期和时间-------------------


-------------------calendar：日历-------------------


-------------------hashlib：加密算法-------------------


-------------------random：生成随机数-------------------
    import random：引用对应的包
    random.random()：默认在0到1之间随机获取数据信息。
    random.uniform(1,5)：1到5之间随机获取对应的数值；包含小数部分。
    random.randint(10.50)：10到50之间对应随机获取对应的整数
    random.randrange(0,51,2)：0到51之间对应随机获取对应的3的倍数


-------------------re：字符串正则匹配-------------------
    import re：引用对应的包
    result=re.match(正则表达式，要匹配的字符串)：从第一个字符向后依次进行正则匹配操作，匹配出对应的数据信息。
    result.group()：如果上一步匹配到数据的话，可以使用group方法来提取数据。
    result=re.search(正则表达式，要匹配的字符串)：从匹配到的第一个字符向后依次进行匹配操作。
    result==None：判断获取的书数据是否为空。
    re.search(r'\d+','my hight 177 cm').group()：匹配出指定字符串中符合正则表达式的第一条数据（只能匹配一个）。
    re.findall(r'\d+','my hight 177 cm my weight 100 kg')：配匹配出指定字符串中所有符合正则表达式的有效数据，并以列表的形式进行返回。
    re.sub(r'\d+','100','my high 177 cm')：将匹配到的数据进行替换，参数：对应的正则表达式，要替换的数据，匹配出来的数据；

    方法一：
    #coding=utf-8
    import re

    ret = re.sub(r"\d+", '998', "python = 997")
    print ret

    返回结果：998

    方法二：
    #coding=utf-8
    import re

    def add(temp):
        strNum = temp.group()
        num = int(strNum) + 1
        return str(num)

    ret = re.sub(r"\d+", add, "python = 997")
    print ret

    ret = re.sub(r"\d+", add, "python = 99")
    print ret
    返回结果：100

    re.split(r':| ','address:beijing xxx@126.com')：根据匹配进行切割字符串，并返回一个列表。案例：根据：或空格进行字符串的切割操作，结果：['address','beijing','xxx@126.com']


-------------------socket：标准的 BSD Sockets API-------------------


-------------------shutil：文件和目录管理-------------------


-------------------glob：基于文件通配符搜索-------------------


-------------------keyword:关键字-------------------
    import keyword：引用对应的包
    keyword.kwlist()：获取对应的列表，列表中存储python中的对应关键字