【我要学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

本文链接：https://www.cnblogs.com/tqing/p/10592234.html