Python学习笔记(1)

朴灿烈づ我的快乐病毒、 2022-07-14 04:46 139阅读 0赞

1、最大优势在于它的字符串模式匹配能力，其提供一个十分强大的正则表达式匹配引擎。核心实现依赖Perl，但语法比Perl易懂的多。高级语言、面向对象、可拓展、可移植、语法清晰、易维护、高效的原型。  
2、python作用：科学计算（能计算超过C中double、long的长度）、图形化开发、系统脚本、web服务器、网络爬虫、服务器集群自动化运维。  
3、python中的变量不需要先定义，再使用，可以直接使用，还有重新使用用以存储不同类型的值。  
4、变量名遵循C命名风格，大小写敏感，变量引用计数。  
5、del语句可以直接释放资源，变量名删除，引用计数减1.  
6、变量内存自动管理回收，垃圾收集。  
7、指定编码在文件开头加入 \#coding=utf-8  
8、函数定义  
    def add(x, y):  
            z=x + y  
            return z

res=add(3, 5)  
    print res  
    a、def定义函数的关键字  
    b、x和y为形参，不需要类型修饰  
    c、函数定义行需要跟 ‘ ： ’  
    d、函数体整体缩进  
     f、函数可以拥有返回值，若无返回值，返回None，相当于C中的NULL  
9、函数内修改全局变量，使用global关键字  
10、逻辑表达式  
        not                 a的逻辑非  
        a  and  b        a和b逻辑与  
        a  or  b           a和b逻辑或  
        a  is  b           a和b是同一个对象  
        a  is not  b     a和b不是同一个对象  
11、分支语句  
        if  a >  b：  
                print("a > b")  
        elif  a == b：  
                print("a == b")  
        else：  
                print("a < b")  
12、循环语句  
        while  判断条件：  
                执行语句  
13、在python中，for ... else表示这样的意思，for中语句和普通的没有区别，else中的语句会在循环正常执行完（即 for 不是通过break跳出而中断的）的情况下执行， while ... else 也是一样。  
14、list列表  
        序列都可以进行操作包括索引，切片，加，乘，检查成员。序列中的每个元素都分配一个数字—它的位置，或索引，第一个索引是0，第二个是1，依次类推。  
        列表和元组二者均能保存任意类型的python对象，索引访问元素从开始列表元素用\[ \]包括，元素个数，值都可以改变元组元素用( )包括通过切片\[ \] \[：\]得到子集，此操作同于字符串相关操作切片使用的基本样式\[下限：上限：步长\]  
    a、访问列表中的值  
            aList = \[1, 2, 3, 4\]  
            aList       >>  \[1, 2, 3, 4\]  
            aList\[0\]   >>  1  
            aList\[2:\]  >>  \[3, 4\]  
            aList\[:3\]  >>  \[1, 2, 3\]  
    b、更新列表中的值  
            aList\[1\]=5  
    c、删除列表中的值  
            del  aList\[1\]    ==>  \[1, 2, 3\]  
    d、python列表脚本操作符  
            列表对 + 和 \* 的操作符与字符串相似。 + 号用于组合列表， \* 用于重复列表。  
            python表达式                                   结果                                    描述  
            len(\[1, 2, 3\])                                      3                                        长度  
            \[1, 2, 3\] + \[4, 5, 6\]                             \[1, 2, 3, 4, 5, 6\]                  组合  
            \[ 'Hi!' \]  \* 4                                         \[ 'Hi!' , 'Hi!' , 'Hi!' , 'Hi!' \]      重复  
            3  in  \[1, 2, 3\]                                    Ture                                   元素是否存在于列表中  
            for x  in \[1, 2, 3\] : print  x,                 1  2  3                                 迭代  
    e、python列表截取  
            python的列表截取与字符串操作类型，如下所示：  
                    L = \[ 'spam', 'Spam', 'SPAM' \]  
                    python表达式              结果                             描述  
                    L\[2\]                           'SPAM'                           读取列表中的第三个元素  
                    L\[-2\]                          'Spam'                            读取列表中倒数第二个元素  
                    L\[1:\]                          \[ 'Spam', 'SPAM' \]          从第二个元素开始截取   
    f、列表函数&方法  
            python包含以下函数：  
                    序号      函数  
                    1            cmp(list1, list2)        比较两个列表的元素  
                    2            len(list)                    列表元素个数  
                    3            max(list)                  返回列表元素最大值  
                    4            min(list)                   返回列表元素最小值  
                    5            list(seq)                   将元组转换为列表  
            python包含以下方法：  
                    序号      方法  
                    1            list.append(obj)               在列表末尾添加新的对象  
                    2            list.count(obj)                  统计某个元素在列表中出现的次数  
                    3            list.extend(seq)               在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）  
                    4            list.index(obj)                  从列表中找出某个值第一个匹配项的索引位置  
                    5            list.insert(index, obj)        将对象插入列表  
                    6            list.pop(obj=list\[-1\])         移除列表中的一个元素（默认最后一个元素），并且返回该元素的值  
                    7            list.remove(obj)               移除列表中某个值的第一个匹配项  
                    8            list.reverse()                    反向列表中元素  
                    9            list.sort(\[ func \])               对原列表进行排序  
15、元组Tuple  
        python的元组与列表类似，不同之处在于元组的元素不能修改。也可以进行分片和连接操作，元组使用小括号，列表使用方括号。  
       >>> aTuple = ('et', 77, 99.9)  
       >>> aTuple  
         ('et', 77, 99.9)  
        a、访问元组  
                >>>aTuple\[2\]  
                99.9  
        b、修改元组  
                >>>tup2 = (1, 2, 3, 4, 5, 6, 7)  
                >>>print tup2\[1:5\]  
                (2, 3, 4, 5)  
                >>>tup3 = tup2 + aTuple  
                >>>print  tup3  
               (1, 2, 3, 4, 5, 6, 7, 'et', 77, 99.9)  
        c、删除元素  
                元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组  
        d、元组运算符  
                与字符串一样，元组之间可以使用 + 号和 \* 号进行运算，这样就意味着他们可以组合和复制，运算后会生成一个新元组。  
        e、元组索引，截取  
                因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素。  
        f、元组内置函数  
                python元组包含了一下内置函数  
                序号      方法及描述  
                1         cmp(tuple1, tuple2)               比较两个元组元素  
                2         len(tuple)                              计算元组元素个数  
                3         max(tuple)                           返回元组中元素最大值  
                4         max(tuple)                           返回元组中元素最小值     
                5         tuple(seq)                            将列表转换为元组   
        g、多维元组访问实例  
                >>>tuple1 = \[ (2, 3), (4, 5) \]        
                >>>tuple1\[ 0 \]  
                (2, 3)  
                >>>tuple1\[ 0 \]\[ 1\]  
                3  
16、字典Dictionary  
        字典是python中的映射数据类型，由键值（key-value）构成，类似于关联数组或哈希表，key一般以数字和字符串居多，值则可以是任意类型的python对象，如其他容器模型，字典元素用大括号 \{ \} 包括，例如：  
        >>>dict = \{'Alice': '2341',    'Beth': '9102',    'Cecil': '3258'\}  
        >>>aDict = \{'host': 'noname'\}  
        每个键与值用冒号隔开（：），对每对用逗号分隔，整体放在花括号中（\{\}）。键key必须独一无二，但值则不必。值value可以取任何数据类型，但必须是不可变的。  
        a、访问字典里的值  
                >>> aDict\['host'\]  
                'noname'  
                >>>for  key  in  aDict  
                ...    print  key, aDict \[key\]  
                ...  
                host  noname  
                port  80

>>> aDict.keys()  
                \['host', 'port'\]  
                >>> aDict.values()  
        b、修改字典  
                向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。  
                >>> aDict \['port'\] = 80     \#如果有port  key ，值将会被更新，否则会被新建一个port  key  
                >>> aDict  
                        \{'host': 'noname',    'port' : 80 \}  
        c、删除字典元素  
                能删除单一的元素也能清空字典，清空只需要一项操作。  
                显示删除一个字典用del命令  
                        dict = \{'Name': 'Zara',    'Age': 7,    'Class': 'First'\};  
                        del dict\['Name'\];    \#删除键是‘Name’的条目  
                        dict.clear();            \#清空词典所有条目  
                        del  dict;                \#删除词典  
        d、字典键（key）的特性  
                字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。  
                两个重要的点需要记住：  
                1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住  
                2）键必须不可变，所以可以用数，字符串或元组充当，所以列表就不行了  
        e、字典内置函数&方法  
                python字典包含了以下内置函数：  
                序号      函数及描述  
                1            cmp(dict1,dict2)                                 比较两个字典元素  
                2            len(dict)                                              计算字典元素个数，即键的总数  
                3            str(dict)                                               输出字典可打印的字符串表示  
                4            type(variable)                                     返回输入的变量类型，如果变量是字典就返回字典类型  
                5            radiansdict.clear()                              删除字典内所有元素  
                6            radiansdict.copy()                              返回一个字典的浅复制  
                7            radiansdict.fromkeys()                       创建一个新字典，以序列seq中元素做字典键，val为字典所有键对应的初始值  
                8            radiansdict.get(key, defalut=None)    返回指定键值，如果值不存在字典中返回default值  
                9            radiansdict.has\_key(key)                   如果键在字典dict里返回true，否则返回false  
               10            radiansdict.items()                            以列表返回可遍历的（键，值）元组数组  
               11            radiansdict.keys()                             以列表返回一个字典所有的键  
               12            radiansdict.setdefault(key, default=None)      和get()类似，但如果键不已经存在于字典中，将会添加键并将值设为default  
               13            radiansdict.update(dict2)                   把字典dict2的键/值对更新到dict里  
               14            radiansdict.values()                           以列表返回字典中的所有值  
17、字符串处理与特殊函数  
    用引号括起来的字符集合称之为字符串，引号可以是一对单引号，双引号，三引号（单/双）。  
    备注：pytthon中三引号可以将复杂的字符串进行复制：Python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。  
    a、创建字符串很简单，只要为变量分配一个值即可。例如：  
        var1 = 'hello world!'  
        var2 = "hello world!"  
        var3 = ' ' 'hello world!' ' '  
        var4 = " " "hello world!" " "  
    b、但是如果要输出 hello "world"怎么办呢？  
        print "hello \\"world\\" "     \#利用\\的转义意义  
        print ' ' 'hello "world" ' ' '  
    c、python访问字符串中的值  
        Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。  
        Python访问字符串，可以使用方括号来截取字符串——即分片操作  
                var1 = 'hello world!'  
                var2 = "hello world!"  
                print "var1\[0\]: ", var1\[0\]  
                print "var2\[1:5\]: ", var2\[1:5\]  
    d、Python字符串更新  
        可以对已经存在的字符串进行修改，并赋值给另一个变量。  
                var1 = 'hello world!'  
                print "Update mystr :- ",var1\[:6\] + 'python'     
                Update mystr :- hello python  
    e、Python字符串运算符  
        下表实例变量a值为字符串"hello", b变量值为"python":  
        操作符     描述                                实例  
        +              字符串连接                     a+b 输出：hellopython  
        \*              重复输出字符串              a\*2 输出：hellopython  
        \[ \]            通过索引获取字符           a\[1\] 输出：e  
        \[:\]            截取字符串中的一部分    a\[1:4\]  输出：ell  
        in            成员运算符                      如果字符串中包含给定的字符返回 True  
        not in      成员运算符                      如果字符串中不包含给定的字符返回True  
        r/R          原始字符串                      字符串直接按照字面的意思来使用，没有转义或不能打印的字符

原始字符串除在字符串的第一个引号前加字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。  
        print r'hello\\n'  
    f、Python字符串格式化  
        Python支持格式化字符串的输出。  
        在Python中，字符串格式化使用与C中sprintf函数一样的语法。  
        print "My name is %s and weight is %d Kg!" % ('Zara', 21)  
    g、字符串各种函数  
        1)、以下start和end可以缺省参数  
                mystr = 'hello world itcast and itcastcpp'  
        2)、检测str是否包含在mystr中，如果是返回开始的索引值，否则返回-1  
                mystr.find(str, start=0, end=len(mystr))  
        3)、跟find()方法一样，只不过如果str不在mystr中会报一个异常  
                mystr.index(str, start=0, end=len(mystr))  
        4)、返回str在start和end之间在mystr里面出现的次数  
                mystr.count(str, start=0, end=len(mystr))  
        5)、以encoding指定的编码格式解码mystr，如果出错默认报一个ValueError的异常，除非errors指定的是’ignore‘或'replace'  
                mystr.decode(encoding='UTF-8', errors='strict')  
        6)、以encoding指定的编码格式编码mystr，如果出错默认报一个ValueError的异常，除非errors指定的是’ignore‘或'replace'  
                mystr.encode(encoding='UTF-8', errors='strict')  
        7)、把mystr中的str1替换成str2，如果count指定，则替换不超过count次  
                mystr.replace(str1, str2, mystr.count(str1))  
        8)、以str为分隔符切片mystr，如果maxsplit有指定值，则仅分隔maxsplit个子字符串  
                mystr.split(str=" ", 2)  
        9)、把字符串的第一个字符大写  
                mystr.capitalize()  
        10)、返回一个原字符串中居中，并使用空格填充至长度width的新字符串  
                mystr.center(width)  
        11)、检查字符串（start, end）是否以obj 开始/结束，如果是返回True，否则返回False。  
                mystr.endswitch(obj, 0, len(mystr))  
                mystr.startswitch(obj, 0, len(mystr))  
        12)、把字符串mystr中的tab符号转为空格，默认的空格数tabsize是8。  
                mystr.expandtabs(tabsize=8)  
        13)、如果mystr至少有一个数字并且所有字符都是字母（不包含数字和空格）则返回True，否则返回False。  
                mystr.isalnum()  
        14)、如果mystr至少有一个字母并且所有字符都是字母或数字则返回True，否则返回False。  
                mystr.isalpha()  
        15)、如果mystr只包含十进制数字返回True否则返回False。  
                mystr.isdecimai()  
        16)、如果mystr只包含数字则返回True否则返回False。  
                mystr.isdigit()  
        17)、如果mystr中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False  
                mystr.islower()  
        18)、如果mystr中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False  
                mystr.isupper()  
        19)、如果mystr中只包含数字字符，则返回True，否则返回False。  
                mystr.isnumeric()  
        20)、如果mystr中只包含空格，则返回True，否则返回False。  
                mystr.isspace()  
        21)、如果mystr是标题化的（见title()）则返回True，否则返回False。  
                mystr.istitle()  
        22)、转换mystr中的大写字母为小写。  
                mystr.lower()  
        23)、转换mystr中的小写字母为大写。  
                mystr.upper()  
        24)、mystr中每个字符后面插入str，构造出一个新的字符串。  
                mystr.join(str)  
        25)、返回一个原字符串左对齐，并使用空格填充至长度width的新字符串。  
                mystr.ljust(width)  
        26)、返回一个原字符串右对齐，并使用空格填充至长度width的新字符串。  
                mystr.rjust(width)  
        27)、截掉mystr左边的空格。  
                mystr.lstrip()  
        28)、删除mystr字符串末尾的空格。  
                mystr.rstrip()  
        29)、类似find()函数，不过是从右边开始查找  
                mystr.rfind(str, start=0, end=len(mystr))  
        30)、类似index()，不过是从右边开始  
                mystr.rindex(str, start=0, end=len(mystr))  
        31)、把mystr以str分割成三部分str前，str，str后  
                mystr.partition(str)  
        32)、类似partition()函数，不过是从右边开始  
               mystr.rpartition(str)  
        33)、按照行分隔，返回一个包含各行作为元素的列表  
                mystr.splitines()  
        34)、返回长度为width的字符串，原字符串mystr右对齐，前面填充0  
                mystr.zfill(width)  
        35)、检查字符串是否包含十进制字符，这种方法只存在于unicode对象。  
                mystr.isdecimal()  
    h、函数定义  
        def  functonname( parameters ) :  
                "函数\_文档字符串"  
                function \_suite             
                return \[expression\]  
        默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。  
    i、按值传递参数和按引用传递参数  
        1)、按值传递，单个变量  
        2)、按引用传递  
    j、匿名函数  
        用lambda关键词能创建小型匿名函数，这种函数得名于省略了用def声明函数的标准步骤。  
        lambda函数的语法只包含一个语句，如下：  
            lambda \[arg1 \[,arg2, ...... argn\]\] : expression  
            如下实例：sun = lambda arg1, arg2 : arg1 + arg2;  
                              print "value of total : ", sum(10, 20)

18、面向对象  
    面向对象介绍  
        类（Class）：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。  
        对象：通过定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。  
        实例化：创建一个类的实例，类的具体对象。  
        方法：类中定义的函数。  
        数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。  
        方法重载：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），重载。  
        实例变量：定义在方法中的变量，只作用于当前实例的类。  
        类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。  
        继承：即一个派生类（derived class）继承基类（base class）的字段和方法。  
                继承也允许把一个派生类的对象作为一个基类对象对待。  
19、创建类  
        使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例：  
            a、类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self作为第一个参数。  
            b、可以直接在类外通过对象名访问，如果想定义成私有的，则需在前面加2个下划线 '\_\_"  
            c、构造方法\_\_init\_\_()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。  
            d、构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。  
            e、析构方法\_\_del\_\_(self)在释放对象时调用，支持重载，可以在里面进行一些释放资源的操作，不需要显示调用。  
            f、创建语法  
                class ClassName  
                        '类的帮组信息'     \#类文档字符串  
                        类变量             \#类体  class\_suite由类成员，方法，数据属性组成  
                        def  \_\_init\_\_(self, paramera) :  
                        def  函数(self, ...)  
                        ......