python学习笔记：第七章面向对象

与java类似，python作为一种面向对象的编程语言，也可以创建自定义的对象和类。
它的特性主要有：继承，封装，多态，方法，属性，超类
1.变量的作用域

1. c = 50      #全局变量， 作用域为整个模块，若被引用，可作用域整个包
2.   
3. def plus(x,y):
4.     c = x + y           # 局部变量, 为函数中定义的变量，在函数外可被引用
5.     print(c)
6.   
7. plus(1,2)
8. print(c)                # 函数内部定义的变量只作用与函数内部
9. >
10. 3
11. 50

复制代码

两者转换

1. def demo():
2.     global c        # global  定义一个全局变量，  可被引用
3.     c = 2
5. demo()         
6. print(c)        # 先调用函数，再输出
7. > 2

复制代码

2.类与构造方法

每个类对应每个对象，下面有类变量
起到封装变量，封装函数，代码的作用

2.1定义一个类

格式

1. class 类名:  #首字母最好大写
2.         代码块

复制代码

1. class Student:               #命名，首字母大写
2.     name = '名字'
3.     age = 0
5.     def __init__(self):
6.         #构造函数, 无需调用直接运行  在给对象的赋值语句中即可运行
7.         print('在创建类对象时先运行构造函数')
8.         return None     #只能返回none 不可人为指定
10.     def grape(self, score): # 与java类似，self指向对象本身
11.         print(self.name + "的成绩是" + str(score))
13. bob = Student()
14. > 在创建类对象时先运行构造函数

复制代码

实例化类，给类赋值

1. student = Student()              #实例化
2. student.grape(100)             #调用
3. >
4. 在创建类对象时先运行构造函数
5. bob的成绩是100

复制代码

2.2构造函数

在创建对象时，就会被调用运行
可以没有
可以在构造函数中， 初始化对象的属性

• 不需要传参的构造函数
  

1. def __init__(self):
2.         pass

复制代码

• 需要传参的构造函数，需要有self，指向对象，与类无关
  

1. def __init__(self, name, age):
2.         pass

复制代码

• 上面两种形式可以同时存在，也可以只存在一种
  

2.3关于self

• self只有在类的方法中才会有，独立的函数或方法是不必带有self的
  
• self在定义类的方法时是必须有的，但在调用时不必传入相应的参数
  
• self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以
  
• self指向对象本身
  

• 调用构造函数时，可以通过 在类后面（）的方式调用
  

1. class Dog:
2.     def __init__(self):
3.         print('This is a dog.')
5. dog()
6. > This is a dog.

复制代码

调用实例方法时，通过对象调用

1. class School:               #命名，首字母大写
2.     name = '未定义'                 
3.     age = 0                  
5.     def __init__(self,name1,age1):            
6.         name = name1
7.         print(name)                  
8.         age =  age1                  
9.         return None     #只能返回none 不可人为指定
11. #调用构造函数时，通过  在类后面（）的方式调用
12. #调用实例方法时，通过对象调用
13. School1 = School(name1 = '中华小学',age1 = '80')
14. School2 = School(name1 = '安徽小学',age1 = '70')

复制代码

类中函数的实例变量与实参不同

1. def __init__(self,name1,age1):            
2.         #可在（）内，  加变量    在引用时，定义变量的值
3.         #通过 self 来保存特征值
4.         self.name = name1              
5.         #通过 self 来定义实例变量和访问实例变量
6.         self.age =  age1      
7.         #self.变量属性 = 变量名（形参）

复制代码

2.5实例变量与类变量

实例变量：
顾名思义，通过创建对象实例化产生，通过对象进行引用。在类内部表现为：self.变量名
类变量：直接与类本身相关，与对象无关，直接在类中被定义，可以转变为实例变量
当出现对象名.变量名 引用变量时，先对类里面的实例变量进行寻找，若无，则再去类变量中寻找

1. class Dog:
2.         name = 'None' # 类变量
3.         nickname = 'Name' # 类变量
4.         def __init__(self, name):  # 这里name为函数形参
5.                 self.name = name  # 赋值实例变量
7. bob = dog('bobo')
8. print(bob.name)
9. print(bob.nickname)
10. >
11. bobo
12. None

复制代码

一个例子

1. class School():               #命名，首字母大写
2.     name = '未定义'                 
3.     age = 0         
4.     sum = 0                    # 与类相关的变量
5.     color = 'yellow'
6.     squire = '面积'
8.     def __init__(self,name1,age1,color1,squire1):            
9.         
10.         name = name1                    
11.         age =  age1     
12.         self.color = color1
13.         self.squire = squire1
14.         return None     
16. School1 = School(name1 = '中华小学',age1 = '80',color1 = 'blue',squire1 = '1000')
17. print(School1.name,'    ', School1.age)     #此时打印出了 类变量 (先在  实例变量  中查找，无， 则到类变量中找)
18. print(School1.__dict__)                     #以字典的形式输出 School1 的变量
19. print(School.name)     
20. print(School1.color,'    ', School1.squire)
21. print(School.__dict__)   

复制代码

2.4实例方法

格式

1. def 方法名(self, 形参): # self必须有 形参可有可无
2.     代码块

复制代码

2.5类方法与类变量

类方法的基本格式

1. @classmethod            #为装饰器
2. def plus_sum(cls):      #cls  为class 的缩写 作用与self类似
3.     pass

复制代码

类变量：只与类相关

1. __class__.变量名 或者是在类方法中的 cls.变量名   
2. 两者虽然表现形式不同，但为同一变量  `is`

复制代码

下面的例子，很好地通过实例变量与类变量进行班级人数和年龄的统计

1. class classroom:
2. sum = 0
3.     age = 0
4.     def __init__(self,name,age):
5.         self.__class__.sum += 1   # 总人数加一
6.         self.age = age
7.         self.__class__.age += self.age  # 学生年龄和
8.         age = self.__class__.age/self.__class__.sum
9.         print('当前班级学生总人数为:' + str(self.__class__.sum))
10.         print('当前班级的平均年龄为:' + str(age))
12.     @classmethod  
13.     def plus_sum(cls): # 利用类变量进行加和
14.         print('班级总人数为: ' + str(cls.sum))  
16. classroom.student1 = classroom(name = '憨批', age = 10)
17. classroom.student2 = classroom(name = '小逗比', age = 9)  
18. classroom.student3 = classroom(name = '土豆',age = 8)           
19. classroom.plus_sum()                # 通过类来调用 方法
20. classroom.student1.plus_sum()       # 通过对象来调用方法

复制代码

2.6静态方法

• 用的不多   与类 实例方法 关联不大   与普通函数区别不大
  

格式：

1. @staticmethod       # 装饰器
2. def add(x,y):
3.     print('This is a static method')

复制代码

• 类中的静态方法，可以访问类变量，对于实例变量和其他函数变量，无法访问
  
• 类中的静态方法，可以通过类直接调用，无需实例化
  

1. class Company:
2.     sum = 0
3.     bass_name = '刘大钞'
4.     def __init__(self,staff_a,staff_b,staff_c):
5.         self.staff_a = staff_a
6.         self.staff_b = staff_b
7.         self.staff_c = staff_c
8.         Company.sum = staff_a + staff_b + staff_c
9.    
10.     @staticmethod                   # 装饰器
11.     def add(x,y):                       # 与类方法实例方法不同，（）内无需强制添加变量
12.         print('This is a method')
13.         print(Company.bass_name)        #  正常引用类变量
14.         print(x + y)                #引用形参
15.         print(self.staff_a)             #报错
16.         print(staff_a)                  #报错
17.    
18.     Company1 = Company(staff_a = 10,staff_b = 20,staff_c = 30)
19.     Company1.add(1,2)
20.     Company.add(1,2)                #可正常被调用

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！