【我要学python】面向对象系统学习

第一节：初识类的定义和调用 c1.py

#类 = 面向对象

#类 最基本作用：封装

#类中不仅可以定义变量 还可以定义函数等等，例：

1 class student( ):
2     name = ' '
3     age = 0
4     
5     def print_file():
6         pass

#类的实例化

 1 s = student()

#调用类方法

2 s.print_file()

#类中编写的函数与普通编写的函数有区别——self ，例：

class student( ):
    name = ' '
    age = 0
    
    def print_file(self):   #要调用类自身的变量需要加上self
       print('name:' + self.name)   
       print('age:' + str(self.age))   

    #print_file() 报错 类负责定义封装 不要在类里调用

第二节：函数与方法的区别 c2.py

#如何在另外一个模块使用我们的类

1 #c2.py调用c1.py的类
2 from c1 import student
3 s = student()
4 s.print_file()

#方法和函数的区别

多数情况下，c，c++把此概念称为函数；java，c#把此概念称为方法。

方法：设计层面的称谓

函数：程序运行，过程式的称谓

也就是说面向对象更关心代码的设计

#类中的变量

变量：在类中被称为数据成员

体现类的封装性

第三节：类与对象 c3.py

#类和对象到底是什么？它们有什么关系？

类是现实世界或思维世界中实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起

类和对象通过实例化关联在一起

#类的设计在于 行为与特征 的设计

 1 class student( ):
 2     name = ' '
 3     age = 0
 4     def do_homework(slef):
 5          print('homework')        
 6 
 7 #print_file 打印档案行为属于student主体明显不太适合 ，做作业的方法属于student方法没毛病
 8 
 9 class printer():    
10     def print_file(self):   
11        print('name:' + self.name)   
12        print('age:' + str(self.age))

#类像一个印刷机，能够通过模板做出各种各样的对象。

通过student类（像一个模板模板）可以产生学生A,学生B...很多个对象,它们都有的特性是name和age

第四节:构造函数

#实例化

a = student( ) #用student这个模板来创造实例a

#构造函数的介绍：

class student():
    def _init_(self):    #构造函数
        print('student')

s1 = student()
s1.__init__() 
#输出
student
student 
#有两个student 原因是：构造函数是调用时python使其自动进行的 无需再调用一次

#注意：构造函数只能return None 也就是默认不写return

#利用构造函数使对象实例化时多种多样

class student():
    name = ' '
    age = 0
    def __init__(self,name,age):
        name = name  #这里python自己知道左边是变量 右边是形参 是合法的
        age = age

s1 = student('大头',18) #实例化的多样性

print(s1.name) 

#输出空值 是为什么呢？！因为这里打印的是类变量name

print(student.name) 

#同样输出 空值

第四节，类变量和实例变量

#类变量和实例变量

类变量：与类关联的变量

实例变量：和对象关联在一起的

#用self完成实例变量的定义
def __init__(self,name,age):
        self.name = name self.age = age

class student():
    name = '你的青'  #类变量
    age = 19
    def __init__(self,name,age):
        self.name = name   #实例变量
        self.age = age     #实例变量

s1 = student('大头',19)
print(s1.name)
print(student.name)

#输出

大头
你的青

第五节：类与对象的变量查找顺序

class student():
    name = '你的青 '
    age = 0
    def __init__(self,name,age):
        name = name  
        age = age

s1 = student('大头',18) 

print(s1.name) 
print(student.name) 

#输出
你的青
你的青

#因为在外部调用时python首先寻找实例里面查找对应变量，没有找到的话就会去类变量里面寻找。

第六节：self与实例方法

class student():
    name = '你的青 '         #类变量
    age = 0
    def __init__(self,name,age):
        name = name  
        age = age        print(age)       #访问实例变量 最好是带上self. 
        print(name)      #没加self的读取的只是形参变量. 这里的age和name都是形参接收的值。

s1 = student('大头',18) 

#输出

18
大头

#实例方法的特点即 方法第一个参数需要传入self

第七节：在实例方法内部 中访问实例变量与类变量

#总结已经学习的内容

#方法来定义我们的行为和特征

class student():
    sum1 = 0 

    def __init__(self,name,age):
        self.name = name
        self.age = age
        
        print(sum1)

#输出

'sum1' is not define 报错

 1 class student():
 2     sum1 = 0 
 3 
 4     def __init__(self,name,age):
 5         self.name = name
 6         self.age = age
 7         
 8         print(student.sum1) #在实例方法内访问类变量方法一
 9         print(self.__class__.sum1) #在实例方法内访问类变量方法二
10 
11 #输出
12 
13 0 
14 0

第八节：新方法——类方法

#类变量的作用

 1 #实例方法操作类变量
 2 
 3 class student():
 4     sum1=0
 5     
 6     def __init__(self,name,age):
 7         self.name = name
 8         self.age = age
 9         self.__class__.sum1 += 1
10         print("当前班级学生总数：" + str(self.__class__.sum1))
11 
12 s1 = student('小帅哥',18)
13 s2 = student('小仙女',18)
14 s1 = student('你的青',19)
15 
16 #输出
17 当前班级学生总数：1
18 当前班级学生总数：2
19 当前班级学生总数：3

#如何定义一个类方法

 1 class student():
 2     sum1 = 0
 3 
 4     def __init__(self,name,age):
 5         self.name = name
 6         self.age = age
 7 
 8     @classmethod  # 增加一个装饰器
 9     def plus_sum(cls):  # 默认cls 即class简写 也可以用self
10         cls.sum1 += 1
11         print("当前班级学生总数：" + str(cls.sum1))
12 
13 s1 = student('小帅哥', 18)
14 student.plus_sum()
15 s2 = student('小仙女', 18)
16 student.plus_sum()
17 s1 = student('你的青', 19)
18 student.plus_sum()
19 
20 #输出
21 当前班级学生总数：1
22 当前班级学生总数：2
23 当前班级学生总数：3

#为什么要这样做？规范！和student实例对象无关的东西，例如班级总人数就可以放在类方法里

第九节：新方法——静态方法

class student():
     sum1 = 0
 
     def __init__(self,name,age):
         self.name = name
         self.age = age      
     
     @classmethod  # 增加一个类装饰器
     def plus_sum(cls):  # 默认cls 即class简写 也可以用self
         cls.sum1 += 1
         print("当前班级学生总数：" + str(cls.sum1))

     @staticmethod  # 增加一个静态装饰器
     def add(x,y):
        print('this is a static method')

s1 = student
s1.add(1,2)
student.add(1,2)

#输出
this is a static method
this is a static method

#静态方法不同点 函数定义时参数不需要写self 调用时就要写class名
#尽量少用静态方法 和类关联不大

第十节：成员可见性：公开和私有

#探讨python下面变量,方法的可见性

#类的外部 类的内部

class student():
     sum1 = 0
 
     def __init__(self,name,age):
         self.name = name
         self.age = age   
         self.score = 0

     def marking(self,score):    #python提倡所有对于类下面变量的更改通过方法来完成
     if score < 0:              #（粉色代码）这样规则和机制的灵活性很就高
　　　　 return '分数不能为负'
　　　self.score = score
     print(self.name + '同学本次考试分数为：' + str(self.score))
     
     @classmethod  # 增加一个类装饰器
     def plus_sum(cls):  # 默认cls 即class简写 也可以用self
         cls.sum1 += 1
         print("当前班级学生总数：" + str(cls.sum1))

     @staticmethod  # 增加一个静态装饰器
     def add(x,y):
        print('this is a static method')

s1 = student('青', 20)
s1.marking(60)
result = s1.marking(-6)
print(result)

#输出

青同学本次考试分数为：60
分数不能为负

#如何使类的变量或者方法私有化（即类的外部无法访问调用）

#在其他很多语言中，对类的范围是有明确要求的，private代表私有 public代表公开

#在python中，私有化只需要添加双下划线

class student():
 
     def __init__(self,name,age):
         self.name = name
         self.age = age   
         
     def __marking(self,score):    #这里添加了双下划线
     if score < 0:              
　　　　 return '分数不能为负'
　　　self.score = score
     print(self.name + '同学本次考试分数为：' + str(self.score))

s1 = student('青',20)
s1.__marking(59)

#输出 报错 此时__marking已经私有化
AttributeError: 'student' object has no attribute '__marking'

#构造函数属于python特有函数，自动执行，并且只能返回None，不过它可以从外部调用；小技巧:函数名的前后都添加双下划线的时候，python不会认为它是private。

第十一节：没有什么是不能访问

class student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__score = 0  # 这里设定了实例的私有变量
    def marking(self, score):
        if score < 0:
         return '分数不能为负'
        self.__score = score
        print(self.name + '同学本次考试分数为：' + str(self.__score))
s1 = student('青', 20)
s1.__score = 1
print(s1.__score)  # 尝试输出私有变量

#输出

1  

#因为动态语言强行赋值,此时的__score并不是私有变量student_score,可以通过print(s1.__dict__)验证

 1 class student():
 2     def __init__(self, name, age):
 3         self.name = name
 4         self.age = age
 5         self.__score = 0  # 这里设定了实例的私有变量
 6     def marking(self, score):
 7         if score < 0:
 8          return '分数不能为负'
 9         self.__score = score
10         print(self.name + '同学本次考试分数为：' + str(self.__score))
11 s1 = student('青', 20)
12 s1.__score = 1
13 print(s1.__score)  # 尝试输出
14 
15 s2 = student('傻',18)
16 print(s2.__score) # 尝试输出私有变量
17 
18 #输出 报错 因为这里没有强制赋值 所以是直接想输出私有变量
19 AttributeError: 'student' object has no attribute 'student__score'
20 
21 #其实python只是把私有变量改了名字而已 __score在里面就被改为_student__socre
22 
23 class student():
24     def __init__(self, name, age):
25         self.name = name
26         self.age = age
27         self.__score = 0  # 这里设定了实例的私有变量
28     def marking(self, score):
29         if score < 0:
30          return '分数不能为负'
31         self.__score = score
32         print(self.name + '同学本次考试分数为：' + str(self.__score))
33 s1 = student('青', 20)
34 s1.__score = 1
35 print(s1.__score)  # 尝试输出
36 
37 s2 = student('傻',18)
38 print(s2._student__score) # 尝试输出私有变量
39 
40 #输出正常
41 1
42 0

第十二节:面对对象三大 特性之 继承性

#回顾之前所学内容

#类由 类的特征 行为 方法 等等组成 继承性就是为了避免我们重复地写代码

#例如 student类的父类还有human类

 1 #c5.py
 2 from c6 import Human               #标准的继承方法
 3 class student(Human):              #标准的继承方法
 4     sum = 0
 5     def __init__(self,name,age):
 6         self.name = name
 7         self.age = age
 8         self.score = 0
 9         self.__class__.sum += 1
10 
11     def do_homework(self)
12         print('english homework')
13 
14 #c6.py
15 class Human():
16     pass

#深化代码，使其有成为意义的继承

 1 #c6.py
 2 class Human():
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6 
 7     def get_name(self):
 8         print(self.name)
 9 
10 #c5.py
11 from c6 import Human             #标准的继承方法
12 class student(Human):              #标准的继承方法
13     def do_homework(self):
14         print('english homework')
15 
16 
17 s1 = student('你的青',20)
18 s1.get_name()
19 print(s1.name)
20 print(s1.age)
21 
22 #输出
23 你的青
24 你的青
25 20

#大多语言只能单继承，python的多继承功能有很大的利用空间

#c6.py
class Human():
      sum = 0
      def __init__(self,name,age):
        self.name = name
        self.age = age


      def get_name(self):
        print(self.name)

# c5.py
from c6 import Human  # 标准的继承方法
class student(Human):  # 标准的继承方法
        
        def __init__(self,school,name,age):
           self.school = school            
           Human.__init__(self,name,age)  #调用父类的构造函数 从子类中传入父类 灵活的python通过Human类调用一个实例方法时 需要加self

s1 = student('人民路','你的青',20)

print(s1.school)
print(s1.name)
print(s1.age)

#输出
人民路
你的青
20

#调用父类的构造函数还有第二种常用的方法：

#c6.py
class Human():
      sum = 0
      def __init__(self,name,age):
        self.name = name
        self.age = age


      def get_name(self):
        print(self.name)

# c5.py
from c6 import Human  # 标准的继承方法
class student(Human):  # 标准的继承方法
        
        def __init__(self,school,name,age):
           self.school = school            
           super(student,self).__init__(name,age)  #调用父类的构造函数 这种方法为常用的方法 如果父类名有改变的话不会影响到此方法

s1 = student('人民路','你的青',20)

print(s1.school)
print(s1.name)
print(s1.age)

#输出
人民路
你的青
20

#当父类和子类出现同名方法时,python会首先调用子类的方法

#如果想调用父类的方法 同样用到super函数调用父类函数

c6.py
class Human():
      sum = 0
      def __init__(self,name,age):
        self.name = name
        self.age = age


      def do_homework(self):
        print('chinese homework')

# c5.py
from c6 import Human  # 标准的继承方法
class student(Human):  # 标准的继承方法
        
        def __init__(self,school,name,age):
           self.school = school            
           super(student,self).__init__(name,age) 

        def do_homework(self):
           super(Student,self).do_homework()
           print('english homework')
    
 #调用父类的构造函数 这种方法为常用的方法 如果父类名有改变的话不会影响到此方法

s1 = student('人民路','你的青',20)

s1.do_homework()

#输出
chinese homework
english homework