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

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

#类 = 面向对象

#类 最基本作用：封装

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

class student( ):
    name = ' '
    age = 0
    
    def print_file():
        pass

#类的实例化

 s = student()

#调用类方法

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

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

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

#方法和函数的区别

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

方法：设计层面的称谓

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

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

#类中的变量

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

体现类的封装性

第三节：类与对象 c3.py

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

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

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

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

class student( ):
    name = ' '
    age = 0
    def do_homework(slef):
         print('homework')        

#print_file 打印档案行为属于student主体明显不太适合 ，做作业的方法属于student方法没毛病

class printer():    
    def print_file(self):   
       print('name:' + self.name)   
       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 报错

class student():
    sum1 = 0 

    def __init__(self,name,age):
        self.name = name
        self.age = age
        
        print(student.sum1) #在实例方法内访问类变量方法一
        print(self.__class__.sum1) #在实例方法内访问类变量方法二

#输出

0 
0

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

#类变量的作用

#实例方法操作类变量

class student():
    sum1=0
    
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__class__.sum1 += 1
        print("当前班级学生总数：" + str(self.__class__.sum1))

s1 = student('小帅哥',18)
s2 = student('小仙女',18)
s1 = student('你的青',19)

#输出
当前班级学生总数：1
当前班级学生总数：2
当前班级学生总数：3

#如何定义一个类方法

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))

s1 = student('小帅哥', 18)
student.plus_sum()
s2 = student('小仙女', 18)
student.plus_sum()
s1 = student('你的青', 19)
student.plus_sum()

#输出
当前班级学生总数：1
当前班级学生总数：2
当前班级学生总数：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():
    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)  # 尝试输出

s2 = student('傻',18)
print(s2.__score) # 尝试输出私有变量

#输出 报错 因为这里没有强制赋值 所以是直接想输出私有变量
AttributeError: 'student' object has no attribute 'student__score'

#其实python只是把私有变量改了名字而已 __score在里面就被改为_student__socre

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)  # 尝试输出

s2 = student('傻',18)
print(s2._student__score) # 尝试输出私有变量

#输出正常
1
0

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

#回顾之前所学内容

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

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

#c5.py
from c6 import Human               #标准的继承方法
class student(Human):              #标准的继承方法
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.score = 0
        self.__class__.sum += 1

    def do_homework(self)
        print('english homework')

#c6.py
class Human():
    pass

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

#c6.py
class Human():
    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 do_homework(self):
        print('english homework')


s1 = student('你的青',20)
s1.get_name()
print(s1.name)
print(s1.age)

#输出
你的青
你的青
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