python入门知识点（下）

51.函数的文档注释及作用

       """

       函数的文档注释:

              函数的注释文字.

 

       必须添加到函数定义的那一行的下面一行.

       好处:

              当使用Ctrl + Q查看函数的使用说明文档时,能够把文档注释自动显示出来.

       """

       def sum（）：

                     “””

                     打印5行“你好”

                     “””

                     for I in range(5)

                            print(“hello”)

sum()

52. 函数的参数 和 参数传递的过程

      

       """

       给函数指定参数:a和b都是参数

       参数的作用:

              是用来接收调用函数时传递过来的数据的,可以在函数内部处理这些数据.

 

 

       给函数设置参数的好处:

              让函数变得更加通用,提高的函数的扩展性.

       """

 

53. 函数的返回值

       # 如果函数有返回值,可以直接打印

       print(input())

 

       # list.append()方法没有返回值

       list.append("a")

       # 如果函数没有返回值,直接打印的结果为None,None表示空,就是什么都没有的意思.

       print(list.append("a"))

      

      

       定义一个函数,并且返回一个值.

 

       定义有返回值的函数的格式:

 

              def 函数名(形参1,形参2,...):

                     函数体

                     return 返回的数据

                    

              这里面return的作用:

                     把返回的数据 返回到函数的调用处,在哪个地方调用了函数,就把数据返回到哪个地方.

 

54. print函数 和 return 的区别

 

在有返回值的函数中,return是用来把返回值返回到函数的调用处的.没有打印的功能.

      

       与print函数没有任何关系,print函数只是用来打印数据的,没有返回数据的功能.

 

55. 函数的嵌套

       在定义一个函数时,在函数的内部调用了另外一个函数.

 

 

56. 解包

 

       组包:      把多个数据,组装到一个容器中;

       解包(拆包):   把容器中的多个数据拆出来.

 

57. 局部变量和全局变量

 

局部变量:在函数内部定义的变量;

       使用范围仅限于函数内部,不能再函数外面使用;

      

全局变量:在函数外部定义的变量;

       使用范围是整个程序文件,前提是先定义后使用.

 

58.通过global关键字修改全局变量的值(修改引用)

 

要想在函数内部修改全局变量的值:

              1.先使用global关键字声明全局变量:

                     global m

              2.修改全局变量的值:

                     m = 500

 

59. 引用1-引用的概念和特点

引用:

              数据在内存中对应的地址

 

       如果两个变量为同一个引用,那么这两个变量对应的数据一定相同;

       如果两个变量对应的数据相同,引用不一定相同;

 

60. 引用2-数字类型和字符串类型数据的缓存区

在解释器一启动的时候,会把小数字(-5~256)和短字符串(长度小于21)缓存到缓冲区中.

       当在程序中使用这些数字和字符串时,就直接从缓存区中取.

      

61. 函数参数的传递过程

传递数据,传递的是数据对应的地址.

 

62. 可变类型和不可变类型

 

可变类型:

              如果修改了数据的内容,数据的地址没有发生改变.

             

              有列表,字典,set集合

                    

       不可变类型:

              如果修改了数据的内容,数据的地址发生改变.

             

              有字符串,元组,数字

 

63.可变类型的影响

对于不可变类型，因变量不能修改，所以运算不会影响到变量自身

而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量

       64. 工具函数-range类型

       range(n):

              得到0到n之间的数据,包括0,但是不包括n.

              n是一个整数.

       range(m,n):

              得到m到n之间的数据,包括m,但是不包括n.

              m,n是一个整数.

65. 列表 推导式

 

 

 

66. 匿名函数

 

def 函数名(形参列表):

              函数体

              return 数据

             

       匿名函数:没有函数名的函数.

      

       定义匿名函数的格式:

              变量名 = lambda 形参1,形参2,... : 表达式

             

       匿名函数的返回值为 表达式 的值.

       匿名函数只能进行简单的逻辑处理.

 

 

 

 

67. 递归函数

递归函数:

              在函数里面自己调用了自己.

 

       开发递归函数的两个条件:

              1.在函数内部自己调用自己

              2.给递归设置一个终止的条件

 

       递归函数非常耗费,所以以后尽量不要使用递归函数.

             

在python中递归的层次不能超过1000次.所以在定义递归函数时需要设置一个终止递归的条件.

      

       def func1()

              ...

              func1()

 

 

68.面向对象

面向对象概述如今主流的软件开发思想有两种：一个是面向过程，另一个是面向对象。面向过程出现得较早，典型代表为C语言，开发中小型项目的效率很高，但是很难适用于如今主流的大中型项目开发场景。面向对象则出现得更晚一些，典型代表为Java或C++等语言，更加适合用于大型开发场景。两种开发思想各有长短。

对于面向过程的思想： 需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为,需要自己编写代码(自己来做)

对于面向对象的思想：当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心谁帮我做这件事(偷懒,找人帮我做)

面向对象的三大特征有：封装性、继承性、多态性。

 

69.类与对象的关系

我们学习编程语言，就是为了模拟现实世界中的事物，实现信息化来提高工作效率。例如银行的业务系统、超市的结账系统等，都是如此。

面向对象的语言当中，“类”就是用来模拟现实事物的。

那么模拟现实世界的事物通常从两方面模拟：

1. 属性：事物的特征描述信息，用于描述某个特征“是什么”。 静
2. 行为：事物的能力行动方案，用于说明事物“能做什么”。

类中也有属性、行为两个组成部分，而“对象”是类的具体实例。例如：

1. 类：抽象的，是一张“手机设计图”。
2. 对象：具体的，是一个“真正的手机实例”。

 

 

70. 面向对象的概述

 

       面向过程:

              当需要实现一个功能的时候,首先考虑的该如何实现这个功能,考虑的实现的步骤和过程,然后自己亲力亲为来实现.(亲力亲为)

             

       面向对象:

             当需要实现一个功能的时候,首先考虑 谁能 实现这个功能,然后就让谁帮你实现. (偷懒,让别人帮我做)

       面向对象 是 基于面向过程.

      

       71. 类与对象的关系

 

              要想按照面向对象的思想开发软件,必须先得到一个对象;

       要想得到对象,必须要有一个叫做类的东西.

              因为程序中的对象 是通过类创建出来.所以必须现有一个类.

              类:是用来描述现实世界中的某一类事物;

      

       如何使用类描述某一类事物?

              把这一类事物共同的特点都抽取出来,写在类中.

              都有 姓名 ,年龄,性别 从静的方面描述的,叫做属性.

              都能 吃饭,学习,睡觉  从动的方面描述的,叫做行为.

              类 是 通过属性和行为来描述那一类事物.

              属性:姓名,年龄,性别

              行为:吃饭,学习,睡觉

 

       对象:

              就是那一类事物中一个个体.

             

             

       类与对象的关系:

              对象是根据类创建出来的.

             

       按照面向对象的思想开发一个功能:

              1.先定义一个类;

              2.使用类创建一个对象;

              3.调用对象的方法;

 

72.类的定义格式

class 类名:

    方法列表

 

 

object 是Python 里所有类的最顶级父类；

 

类名 的命名规则按照"大驼峰命名法"；

 

info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象

 

73.创建对象

 

74. 添加和获取对象的属性

 

 

75.__init__方法：

 

Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法，__init__()就是一个魔法方法，通常用来做属性初始化 或 赋值 操作。

如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，

如果为了能够在完成自己想要的功能，可以自己定义__init__方法，

所以一个类里无论自己是否编写__init__方法 一定有__init__方法。

 

在类内部获取 属性 和 实例方法，通过self获取；

在类外部获取 属性 和 实例方法，通过对象名获取。

 

如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址；

 

但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。

 

76.__str__魔法方法

魔法方法str:

        比较特殊,当打印对象或者把对象转成字符类类型的时候,解释器会自动调用这个方法

        这个方法必要有一个返回值:return 字符串数据.

        通常在这个方法中返回对象的 属性名和属性值拼接的 字符串.

 

 

77.__del__魔法方法

魔法方法del:

        比较特殊,对象在即将被销毁的时候,解释器自动调用这个方法.

        作用:

            不是删除对象,没有删除对象的功能.

            是用来做临终遗言的事情的.

 

78. 属性值可以是一个对象

class FDJ:

              ...

             

             

       class Car:

              def __init__(self,fdj):

                     self.fdj = fdj

                    

                    

       fdj = FDJ()

 

       c = Car(fdj)

 

79. 私有属性的定义和使用

 

   class Student:

 

    """

        定义私有属性的格式:

            self.__属性 = 属性值

 

        私有的属性名 为 : __属性

        私有属性只能在类的里面访问,不能在类的外面访问

    """

    def __init__(self,name,age):

        self.name = name

        if 0 < age < 150:

            # 给私有属性赋值

            self.__age = age

        else:

            self.__age = 0

            print("传递的年龄不正确...")

"""

    为了能够在类的外面给私有属性赋值,得到私有属性的值,

    需要在类的里面给这属性添加一对set_xxx(),get_xxx(),xxx是属性名

   

    这个方法的作用:

        为了能够在类的外面给私有属性赋值

    """

    def set_age(self,age):

        if 0

            # 给私有属性赋值

            self.__age = age

        else:

            print("传递的年龄不正确...")

    """

       返回私有属性的值

       这个方法的作用:

           为了能够在类的外面 得到私有属性的值.

       """

    def get_age(self):

        return self.__age

 

    def __str__(self):

        return "姓名:%s,年龄:%d" % (self.name,self.__age)

 

   s = Student("尼古拉斯.赵四",200)

   # 在类的外面直接访问属性,给属性直接赋值

   # print(s.age)

   # 在类的外面访问私有属性,会报错:AttributeError: 'Student' object has no attribute '__age'

   # print(s.__age)

 

   # 这是给对象添加了一个公共的属性__age,赋值为300,无效

   # s.__age = 300

 

   # 通过set方法给私有属性赋值

   s.set_age(300)

 

   # 通过get方法得到私有属性值

   print(s.get_age())

   print(s)

80.私有方法

 

class Student:

    def __init__(self,name,age):

        self.name = name

        self.__age = age

    """

    定义私有方法的格式:

       def __方法名(self,形参列表):

            方法体

           

    特点:

        只能类的里面使用:需要通过self方法

    """

    def __tanlianai(self):

        print("哥哥谈恋爱了....")

 

 

    def func1(self):

        # 在类的里面调用私有方法:需要通过self方法

        self.__tanlianai()

 

 

    def __str__(self):

        return "姓名:%s,年龄:%d" % (self.name,self.__age)

 

   s = Student("尼古拉斯.赵四",200)

 

   s.func1()

   # 在类的外面不能通过对象直接调用私有方法

   # s.__tanlianai()

 

81. 封装的总结

 

   封装:

          1.把数据和方法组合到一起,写到类中;

          2.把类中不需要对外暴露的属性和方法隐藏起来;

          3.把代码块写到方法中,当别人调用这个方法时,只需要知道这个方法的作用(功能),不要知道具体实现的细节;

  

封装的好处:

          对外暴露功能,隐藏了功能实现的细节,可以提高开发效率;

 

 

82. .继承

 

   继承:子类继承父类,子类一旦继承父类,就拥有 了父类中非私有的属性和方法;

   继承的格式:

          class 子类名(父类名):

                 ...

子类不能继承父类中私有的属性和方法

 

83.多层继承

   """

多层继承:

    一层一层的继承

"""

 

class A:

    def __init__(self,a):

        self.a = a

 

    def methodA(self):

        print("----------methodA----------")

 

class B(A):

    def __init__(self,a,b):

        self.b = b

        super().__init__(a)

 

    def methodB(self):

        print("----------methodB----------")

 

 

class C(B):

    def __init__(self,a, b,c):

        self.c = c

        super().__init__(a,b)

 

    def methodC(self):

        print("----------methodC----------")

 

   c = C("A类","B类","C类")

   print(c.a)

   print(c.b)

   print(c.c)

 

 

84. 在子类中添加方法

 

可以在子类中添加方法,目的是为了扩展自己的功能;

 

85. 子类中重写父类中的方法

 

"""

   重写父类中的方法:

          在子类中定义一个与父类中方法重名的方法.

 

   重写方法后,当通过子类对象调用这个方法时,调用的是子类中的重写后的方法.

 

   重写方法的原因:

          父类中的方法不能满足子类的需要,但是子类又想保留这个方法的名字.

   """

   class Fu(object):

 

          def run_company(self):

                 print("按照父亲的方式经营公司...")

 

          def method01(self):

                 print("method01...")

 

   # 子类继承父类

   class Zi(Fu):

 

          # 重写父类中的run_company方法

          def run_company(self):

                 print("按照儿子的方式经营公司")

 

 

   zi = Zi()

   # 调用的是重写的方法

   zi.run_company()

   # 调用的是 从父类中继承过来的方法

   zi.method01()

 

86.在子类中调用父类中被重写的方法

   """

   在子类中调用父类中被重写的方法,有三种方式:

          方式1:

                 父类名.方法名(self,形参值的列表)

 

          方式2:

                 super(子类名,self).方法名(形参值的列表)

 

          方式3:

                 super().方法名(形参值的列表)

 

          super是父类名.

 

   如果想改进父类中的这个方法,不要直接改.

   需要定义一个子类,继承父类,然后重写父类中方法,调用父类中被重写的方法,增加自己的代码.

   """

"""

   class Fu(object):

 

          def run_company(self):

                 print("按照父亲的方式经营公司...")

 

          def method01(self):

                 print("method01...")

 

   # 子类继承父类

   class Zi(Fu):

 

          # 重写父类中的run_company方法

          def run_company(self):

                 print("按照儿子的方式经营公司")

 

          # 在子类中调用父类中被重写的方法

          def func1(self):

                 # 调用子类中重写方法run_company

                 self.run_company()

 

                 # 调用父类中的run_company

                 # 方式1

                 # Fu.run_company(self)

 

                 # 方式2:

                 # super(Zi,self).run_company()

 

                 # 方式3:

                 super().run_company()

   zi = Zi()

   zi.func1()

 

87. 继承中的两个细节

 

   class Fu(object):

 

          def __init__(self, money, house):

                 self.money = money

                 self.house = house

                 # 私有属性

                 self.___girl_friend = "青霞"

 

          def run_company(self):

                 print("按照父亲的方式经营公司...")

 

          # 私有方法

          def __xiyu(self):

                 print("父亲洗浴了...")

 

 

          #定义了一个公共的方法,在里面调用私有属性和方法

          def func1(self):

                 print("父亲的女朋友:%s" % self.___girl_friend)

                 self.__xiyu()

 

   # 子类继承父类

   class Zi(Fu):

 

          # 给子类添加属性

          def __init__(self,money,house,girl_friend):

                 self.girl_friend = girl_friend

                 # 调用父类中的init方法,目的是为了给子类对象添加父类中定义的两个属性

                 super().__init__(money,house)

 

   zi = Zi(200000000,"别墅","vivi")

   print(zi.money)

   zi.func1()

 

88. 继承中的两个细节

 

   class Fu(object):

 

          def __init__(self, money, house):

                 self.money = money

                 self.house = house

                 # 私有属性

                 self.___girl_friend = "青霞"

 

          def run_company(self):

                 print("按照父亲的方式经营公司...")

 

          # 私有方法

          def __xiyu(self):

                 print("父亲洗浴了...")

 

 

          #定义了一个公共的方法,在里面调用私有属性和方法

          def func1(self):

                 print("父亲的女朋友:%s" % self.___girl_friend)

                 self.__xiyu()

 

   # 子类继承父类

   class Zi(Fu):

 

          # 给子类添加属性

          def __init__(self,money,house,girl_friend):

                 self.girl_friend = girl_friend

                 # 调用父类中的init方法,目的是为了给子类对象添加父类中定义的两个属性

                 super().__init__(money,house)

 

 

 

 

   zi = Zi(200000000,"别墅","vivi")

   print(zi.money)

   zi.func1()

 

89. 多继承-调用指定父类中的方法

   """

   多继承的格式:

          一个子类同时继承了多个父类.

 

   格式:

          class 子类名(父类1,父类2,...):

                 子类的代码

   """

 

  

class A:

          def __init__(self,a):

                 self.a = a

 

          def methodA(self):

                 print("----------methodA----------")

 

 

          def show(self):

                 print("----------A类中的show方法----------")

 

   class B:

          def __init__(self,b):

                 self.b = b

 

 

          def methodB(self):

                 print("----------methodB----------")

 

          # A类中也有这个方法

          def show(self):

                 print("----------B类中的show方法----------")

 

   # 多继承

   class C(A,B):

          def __init__(self,a, b,c):

                 self.c = c

                 A.__init__(self,a)

                 B.__init__(self,b)

 

 

          def methodC(self):

                 print("----------methodC----------")

                 #调用A类中的方法

                 super().show()

 

                 # 调用指定父类中的方法:通过第一种方式

                 B.show(self)

 

 

   c = C("A类","B类","C类")

   print(c.a)

   print(c.b)

   print(c.c)

 

   c.methodA()

   c.methodB()

   c.methodC()

 

   # 查看搜索方法的顺序

   print(C.mro())

 

90. 实例属性和实例方法

实例:就是一个对象.

   实例化:创建对象.

   实例属性:对象的属性.

   实例方法:对象的方法.

 

   通过self添加的属性叫做实例属性.

   存储在对象中的属性叫做实例属性.

  

   实例方法:

          第一个形参是self的方法,就是实例方法.

91. 类对象 类属性

 

class Student:

          ...

   类属性:所有的对象共享共用的属性,这个属性不专属于某一个对象,是所有的对象共享共用的.

  

   类属性的定义:

          定义在类的里面,方法的外面.

         

   如何访问类属性:

          1.在类的外面:

                 类名.类属性名

                 对象名.类属性名

         

          2.在类的里面:

                 类名.类属性名

                 对象名.类属性名

                

   如何修改类属性的值呢?

          类名.类属性名 = 修改后的值

 

92.类方法

 

   class Student:

 

          def __init__(self,name,age,gender):

                 self.name = name

                 self.age = age

                 self.gender = gender

 

          def study(self):

 

                 print("好好学习,贴图天天向上")

 

                 # 在类的里面通过self调用类方法

                 # self.close("王五")

 

                 # 在类的里面通过类名调用类方法

                 Student.close("王五")

          """

          方法的中的cls参数值是当前的类对象,其实就是Student

          当调用这个方法时,解释器会自动把类对象传递给cls

         

          在这个方法中无法访问实例属性和实例方法,因为无法得到self.

          """

          @classmethod

          def close(cls,name):

                 print(cls)

                 print(name)

                 print("最后一个同学关灯...")

 

                 # 调用类方法

                 cls.test()

 

          @classmethod

          def test(cls):

 

                 print("test...")

 

 

   s1 = Student("zhangsan",30,"男")

 

   # 在类的外面通过对象名调用类方法:对象名.类方法(形参值的列表)

   # s1.close("zhangsan")

 

   # 在类的外面通过类名调用类方法:对象名.类方法(形参值的列表)

   # Student.close("李四")

   s1.close("李四")

92.静态方法

 

   class Student:

 

          kongtiao = "格力空调"

          def __init__(self,name,age,gender):

                 self.name = name

                 self.age = age

                 self.gender = gender

 

          def study(self):

 

                 print("好好学习,贴图天天向上")

 

                 # 在类的里面通过self调用类方法

                 # self.close("王五")

 

                 # 在类的里面通过类名调用类方法

                 Student.close("王五")

 

          """

          可以在这个方法中通过cls访问类属性类方法

          """

          @classmethod

          def close(cls,name):

                 print(cls)

                 print(name)

                 print("最后一个同学关灯...")

 

 

          @staticmethod

          def show():

                 # 通过类名访问类属性和非方法

                 print(Student.kongtiao)

                 Student.close("赵六")

 

   s1 = Student("zhangsan",30,"男")

 

   #通过对象调用静态方法

   s1.show()

 

   #通过类名调用静态方法

   Student.show()

 

93. __new__方法

 

   class Student:

 

          """

          这个方法是用来创建对象的.

          当创建对象时,解释器会自动调用这个方法创建一个空白对象.

          如何创建对象的?

                 通过调用object类中的new方法创建的,创建出来的是一个空白对象,然后返回对象.

          """

          def __new__(cls, *args, **kwargs):

                 return super().__new__(cls)

 

          def __init__(self,name,age,gender):

                 self.name = name

                 self.age = age

                 self.gender = gender

 

          def study(self):

 

                 print("好好学习,贴图天天向上")

 

 

   s1 = Student("zhangsan",30,"男")

 

   print(s1.name)

 

94. 单例的设计模式(了解)

 

   设计模式:

          为了解决某一类的问题而设计出来的一种方案.

         

   单例:

          在系统中这个类只有一个实例对象.

          不管创建对象创建了几次,在系统中始终只有一个对象.

  

95. 异常的概述

   异常:执行程序时程序抛出的红色信息.

   异常类是用来描述某一类异常的.

  

   程序中出现的异常需要处理,如果不处理会影响后续代码的执行.

 

 

96. 处理异常的基本格式

 

   基本格式:

          try:

                 可能会出现异常的代码块

          exept :

                 处理异常的代码块

                

          处理异常并不能消灭异常不让异常出现,只是捕获住这个异常,不让它影响后面代码的执行.

 

97.自定义异常类

 

   原因:

          1.解释器自带的异常类不能满足我们的需要.

          2.解释器自带的异常类不容易学习.

         

   自定义异常类:

          1.继承异常父类

          2.重写init方法

 

98. 异常处理中抛出自定义异常

 

   """

   自定义异常类:

          1.继承父类

          2.重写init方法

 

   """

class AgeError(Exception):

    def __init__(self,msg):

        self.msg = msg

 

 

class Student:

    def __init__(self,name,age):

        self.name = name

        self.__age = age

 

    def set_age(self,age):

        if 0

            self.__age = age

        else:

            # 抛出年龄错误的异常:

            raise AgeError("年龄必须在0到150之间...")

 

s = Student("zhangsan",28)

 

try:

    s.set_age(200)

except AgeError as e:

    print(e)

99. 包

 

   包:就是工程目录下面的一个文件夹.

  

   包的作用:

          对程序文件进行分类管理的.

         

   包的命名规则:

          1.可以使用多个单词组成,单词之间不要有间隔;

          2.尽量使用一个单词作为包名,一般都是使用功能模块名字的英文缩写;

 

100.多态

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态 ，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

鸭子类型：虽然我想要一只"鸭子"，但是你给了我一只鸟。 但是只要这只鸟走路像鸭子，叫起来像鸭子，游泳也像鸭子，我就认为这是鸭子。

Python的多态，就是弱化类型，重点在于对象参数是否有指定的属性和方法，如果有就认定合适，而不关心对象的类型是否正确。

 

转载于:https://www.cnblogs.com/omak/p/9887721.html

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！