• python学习笔记之基础二(第二天) 凯


     银角大王之博客二:

           http://www.cnblogs.com/wupeiqi/articles/4911365.html

    1、编码转换介绍

          

     <1> . python2里有二种字符串unicode和str,其中unicode是最底层、最纯的,会根据终端的编码进行转化展示

    • str可以看作是unicode字符串经过某种编码后的字节组成的数组
    • unicode是真正意义上的字符串
    • 通过 encode 可以将unicode类型编码为str类型
    • 通过 decode 可以将str类型解码为unicode类型
    • python 会隐式地进行编码、解码,默认采用 ascii
    • 所有的编码、解码错误都是由于所选的编码、解码方式无法表示某些字符造成的

            Python 2 悄悄掩盖掉了 byte 到 unicode 的转换,只要数据全部是 ASCII 的话,所有的转换都是正确的,一旦一个非 ASCII 字符偷偷进入你的程序,那么默认的解码将会失效,从而造成 UnicodeDecodeError 的错误。py2编码让程序在处理 ASCII 的时候更加简单。你复出的代价就是在处理非 ASCII 的时候将会失败。

    一般硬盘存储或传输为utf-8(因为省空间、省带宽),读入内存中为unicode,二者如何转换

          a = '你好'              '\xe4\xbd\xa0\xe5\xa5\xbd'     <type 'str'>

          b = u'你好'             u'\u4f60\u597d'                <type 'unicode'>

          a.decode('utf-8')       u'\u4f60\u597d'   (utf-8格式解码为unicode)

          b.encode('utf-8')       '\xe4\xbd\xa0\xe5\xa5\xbd'  (unicode格式加密为utf-8)

        注:在python2.7版本中需要如上转换,在脚本中如要显示中文,

            只要在文件开头加入 # _*_ coding: UTF-8 _*_ 或者 #coding=utf-8 就行了

         <2> . python3也有两种数据类型:str和bytes;  str类型存unicode数据,bytse类型存bytes数据,与py2比只是换了一下名字而已。

              要将str类型转化为bytes类型,使用encode()内置函数;反过来,使用decode()函数

         <3> . python2与python3字符串编码的区别

    python3默认使用的是str类型对字符串编码,默认使用bytes操作二进制数据流,两者不能混淆!!
    Python3有两种表示字符序列的类型:bytes和str。前者的实例包含原始的8位值,后者的实例包含Unicode字符。Python2也有两种表示字符序列的类型,分别叫做str和Unicode,与Python3不同的是,str实例包含原始的8位值;而unicode的实例,则包含Unicode字符。

     

     2、字符串的常用函数format:


    S.format(*args, **kwargs) -> string

    Return a formatted version of S, using substitutions from args and kwargs.
    The substitutions are identified by braces ('{' and '}').


            name1 = "I am {0},age is {1}" 
    
            name1.format('kevin',33)
    
            li = ['kevin',33]
    
            name1.format(*li)
    
            name2 = "I am {ss},age is {dd}" 
    
            name2.format(ss='kevin',dd=33)
    
            dic = {'ss': 'kevin','dd':33}
    
            name2.format(**dic)

    3、元组的元素是不能被修改,但元素的元素能可以被被修改的

    >>> aa = (1,2,'a','b',['a',1,'b',2])
    >>> aa
    (1, 2, 'a', 'b', ['a', 1, 'b', 2])
    >>> aa[-1]
    ['a', 1, 'b', 2]
    >>> aa[-1].append('aaaa')
    >>> aa
    (1, 2, 'a', 'b', ['a', 1, 'b', 2, 'aaaa'])

    4、字典的循环

           当数据量达到上百万时,循环字典就不适合用dict.items(),因为首先会把一对对key和value转化为列表,然后在循环遍历输出,会增加内存使用。建议使用如下:

       

    >>> a = {1:'a',2:'b'}
    >>> for k in aa:print(k,aa[k])
    (1, 'a')
    (2, 'b')
    >>> for k in aa.keys():print(k,aa[k]) (1, 'a') (2, 'b')

     5、调用系统命令,并存入变量:

        1).import os

        a = os.system('df -Th')                                            可以获取命令执行后的返回值,但是获取不了命令的输出内容

        b = os.popen('df -Th','r')                                          可以获取命令的输出内容,但是获取不了命令执行后的返回值           

            a = os.popen("ls -l",'r')

            for i in a.readlines():

               print(i.strip())

        c = os.path.dirname(os.path.abspath(__file__))   获取当前的目录

       

        2).import commands

        c = commands.getoutput('df -Th')  返回一个字符串

              commands.getstatusoutput(cmd)返回(status,output)

              commands.getoutput(cmd)只返回输出结果

        3). import subprocess

            <1>. call

      执行命令,返回状态码,shell = True允许shell命令时字符串形式

                subprocess.call(["ls", "-l"])

                subprocess.call("exit 1", shell=True)

            <2>. check_call

      执行命令,如果执行状态码是0,则返回0,否则抛出异常

                subprocess.check_call(["ls", "-l"])

                subprocess.check_call("exit 1", shell=True) 

            <3>.check_output

      执行命令,如果状态码是0,则返回执行结果,否则抛出异常

                subprocess.check_output(["echo", "Hello World!"])

           subprocess.check_output("exit 1", shell=True)
            <4>. subprocess.getstatusoutput(cmd)
           调用check_output(cmd, shell=True, universal_newlines=True, stderr=STDOUT),返回tuple(status,data)
            <5>. getoutput(cmd)
           返回命令的输出结果或错误输出,即getstatusoutput(cmd)[1]
     
            <6>. subprocess.Popen(...) 

      用于执行复杂的系统命令

         参数:

    • args: 可以是字符串或者序列类型(如:list, tuple)。默认的,要执行的程序应该是序列的第一个字段,如果是单个字符串,它的解析依赖于平台。在unix中,如果args是一个字符串,那么这个字符串解释成被执行程序的名字或路径,然而,这种情况只能用在不需要参数的程序。
    • bufsieze: 指定缓冲。0表示无缓冲,1表示缓冲,任何其他的整数值表示缓冲大小,负数值表示使用系统默认缓冲,通常表示完全缓冲。默认值为0即没有缓冲。
    • stdin, stdout, stderr:分别表示程序的标准输入,输出,错误句柄
    • preexec_fn : 只在unix平台有效,用于指定一个可执行对象,它将在子进程中运行之前被调用
    • close_fds : 在windows平台下,如果close_fds被设置为true,则新创建的子进程将不会继承父进程的输入,输出,错误管道。所以不能将close_fds设置为true同时重定向子进程的标准输入,输出与错误。
    • shell : 默认值为False, 声明了是否使用shell来执行程序,如果shell=True,它将args看做一个字符串,而不是一个序列。在unix系统中,且shell=True, shell默认使用/bin/sh。
    • cwd : 用于设置子进程的当前目录。当它不为None时,子程序在执行前,它的当前路径会被替换成cwd的值。这个路径并不会被添加到可执行程序的搜索路径,所以cwd不能是相对路径。
    • env : 用于指定子进程的环境变量。如果env=None,子进程的环境变量将从父进程中继承。当它不为None时,它是新进程的环境变量的映射。可以用它来代替当前进程的环境。
    • universal_newlines : 不同系统的换行符不同, 文件对象stdout和stderr都被以文本文件的方式打开
    • startupinfo 与 createionflags只在windows下生效。将被传递给底层的CreateProcess()函数,用于设置子进程的一些属性,如:主窗口的外观,进程的优先级等等

       例:

          subprocess.Popen(["df","-Th"])  



        注:Popen对象创建后,主程序不会自动等待子进程完成,我们必须调用对象的wait()方法,父进程才会等待 (也就是阻塞block)

             child = subprocess.Popen(["ping","-c","5","www.baidu.com"])
             child.wait()
             print("parent process")

           此外,你还可以在父进程中对子进程进行其它操作,比如我们上面例子中的child对象:
                child.poll()           # 检查子进程状态
                child.kill()           # 终止子进程
                child.send_signal()    # 向子进程发送信号
                child.terminate()      # 终止子进程
          子进程的PID存储在child.pid

          实例:   

    #!/usr/bin/python3
    
    import subprocess,os,sys
    
    #obj = subprocess.Popen("mkdir t3", shell=True, cwd='/tmp',)
    #
    #obj = subprocess.Popen(["python3"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
    #obj.stdin.write("a = 35 * 20 + 31 \n")
    #obj.stdin.write("print(a)\n")
    #obj.stdin.write("b = 3 / 0\n")
    #obj.stdin.write("print(b)")
    #obj.stdin.close()
    #
    #cmd_out = obj.stdout.read()
    #obj.stdout.close()
    #cmd_error = obj.stderr.read()
    #obj.stderr.close()
    # 
    #print(cmd_out)
    #print("the cmd_error is %s" % cmd_error)
    #
    #obj1 = subprocess.Popen(["python3"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
    #
    #obj1.stdin.write("a = 35 * 20 + 31 \n")
    #obj1.stdin.write("print(a)")
    #out_error_list = obj1.communicate()
    #print(out_error_list)
    # 
    #
    #
    #obj2 = subprocess.Popen(["python3"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
    #
    #out_error_list = obj2.communicate('print("hello")')
    #print(out_error_list)
    # 
    #
    #child1 = subprocess.Popen("ls bb",shell=True, stdout=subprocess.PIPE)
    #print(child1.stdout.read())
    #child2 = subprocess.Popen(["cat"], stdin=child1.stdout,stdout=subprocess.PIPE)
    #print(child2.stdout.read())
    #out = child2.communicate()
    #print(out[0].decode('utf-8'))
    #
    #
    child = subprocess.Popen(["cat"], stdin=subprocess.PIPE,stdout=subprocess.PIPE)
    child.communicate('bb'.encode('utf-8'))
    cc = child.stdout.read()
    print(cc)
    child.stdout.close()
    
    
    #output_file = open("abc",'w');
    #return_code = subprocess.call(['ls','-l'],stdout=output_file);
    #output_file.close();
    #print(return_code);
    subprocess实例

    6、sys调用

        import sys

        sys.exit

        print sys.argv

        sys.path

    7、导入模板方法:

          1.import sys [as newname]  

        多次重复使用import语句时,不会重新加载被指定的模块,只是把对该模块的内存地址给引用到本地变量环境。

          2.from sys import argv或(*)

          3.reload()

        reload会重新加载已加载的模块,但原来已经使用的实例还是会使用旧的模块,而新生产的实例会使用新的模块;reload后还是用原来的内存地址;不能支持from。。import。。格式的模块进行重新加载。

       建议使用第一种,第二种导入的对象或变量会与当前的变量会冲突。

    8、字典复制:

    dict = {'name':'wang', 'sex':'m', 'age':34, 'job':'it'}

    info = dict            ##别名 (二个字典指向内存的同一地址空间)

    info1 = dict.copy()    #shadow copy 浅复制(嵌套字典第一层独立,第二层以下相关联)

    import copy

    copy.copy()            #shadow copy 浅复制

    copy.deepcopy()        #deep copy   深复制(完全独立)

    注:浅复制下的关联只是针对字典初始状态包含的嵌套对象,后新加的不会

    例:


    >>> dict
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'sex': 'm', 'age': 40, 'name': 'wang'}
    >>> dict_alias = dict
    >>> dict_copy = copy.copy(dict)
    >>> dict_deep = copy.deepcopy(dict)


    #添加、改变、删除第一层的对象键值,浅复制和深复制都不受影响

    >>> dict['age'] = 32

    >>> del dict['sex']
    >>> dict
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'age': 32, 'name': 'wang'}
    >>> dict_alias     
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'age': 32, 'name': 'wang'}
    >>> dict_copy      
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'age': 40, 'name': 'wang', 'sex': 'm'}
    >>> dict_deep      
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'age': 40, 'name': 'wang', 'sex': 'm'}


    #改变、删除原有的第二层的对象键值,浅复制受影响,而深复制都不受影响

    >>> dict['info'][2] = 100
    >>> dict
    {'info': ['a', 'b', 100, 2], 'job': 'it', 'age': 32, 'name': 'wang'}
    >>> dict_alias
    {'info': ['a', 'b', 100, 2], 'job': 'it', 'age': 32, 'name': 'wang'}
    >>> dict_copy
    {'info': ['a', 'b', 100, 2], 'job': 'it', 'age': 40, 'name': 'wang', 'sex': 'm'}
    >>> dict_deep
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'age': 40, 'name': 'wang', 'sex': 'm'}


    #添加第二层的对象,浅复制和深复制都不受影响

    >>> dict['new'] = {'a':1, 'b':2, 'c':5}
    >>> dict
    {'info': ['a', 'b', 100, 2], 'name': 'wang', 'age': 32, 'job': 'it', 'new': {'a': 1, 'c': 5, 'b': 2}}
    >>> dict_alias
    {'info': ['a', 'b', 100, 2], 'name': 'wang', 'age': 32, 'job': 'it', 'new': {'a': 1, 'c': 5, 'b': 2}}
    >>> dict_copy
    {'info': ['a', 'b', 100, 2], 'job': 'it', 'age': 40, 'name': 'wang', 'sex': 'm'}
    >>> dict_deep
    {'info': ['a', 'b', 1, 2], 'job': 'it', 'age': 40, 'name': 'wang', 'sex': 'm'}


    9、内置函数说明:

          __name__:主文件时返回main,否则返回文件名,可用来判断是否说主文件还是导入模块;

          __file__:文件的绝对路径;

          __doc__:文件开头的注释说明

    例:

    '''
        created by 2015-12-18
        @author: kevin
    '''


    if __name__ == '__main__':
        print('this is main file')
        print(__file__)
        print(__doc__)

    做人一定要靠自己
  • 相关阅读:
    poj2263
    poj2304
    低调是态度,也是智慧
    股票操作記錄2
    治病記錄(2013年)
    过年了
    治病記錄
    近段時間學習記錄
    新的一年
    關于設計
  • 原文地址:https://www.cnblogs.com/wushank/p/5060023.html
Copyright © 2020-2023  润新知