python 面向对象介绍

Posted 2020-11-05 马里亚纳仰望星空

1、python 面向对象的主要特性。主要有类、对象。三大特点：封装、继承、多态。本次主要介绍内容：属性、方法、构造函数、析构函数。私有方法、私有属性。

     oop 是使用类和对象来实现对真是世界的描述。万事万物皆可为类。基于面向对象的程序使人更加容易理解的你逻辑。提高开发效率

    class 类。对具有相同属性的对象的抽象。可以理解为模板。在类中定义了这些对象共同拥有的属性和方法。（上帝创造地球的模板）

   object 对象。对象是类的实例化。一个类可以实例化多个对象。每个对象可以具有不同的属性。例如人。人与人既有共同属性。也有不同属性。

   封装。在内部调用函数。对外部是透明的（对外部不可见）。

　继承。子类可以自动继承父类的属性和方法

   多态。一个接口，多重实现。（比喻老板说开始工作，销售部开始销售工作。技术部开始的开发工作）

 

2、面向对象。类的简单定义。和对象实例化。

class  dog:
    def __init__(self,name):
        self.name =  name
    def bulk(self):
        print("wang !!!!!!! %s"%(self.name))

dog1 =dog("test1")
dog2 = dog("test2")

dog1.bulk()
dog2.bulk()

3、写代码原则。

　　一、重复代码是非常不好的行为

      二、写的代码经常变更

 

4、类初始化深入理解: 对象创建的过程。每次创建一个对象相当于开辟一块内存空间如r1。每次在调用函数时候。实际相当于将r1作为一个参数传递给类的函数

（记住：是调用类的函数。所有对象公用。并不是每个对象的内存空间都会复制这个函数体，节省内存空间）

class role :
    def __init__(self,name,wepon,life_value= 00):
        #构造函数
        #在实例化时候。做一些初始化工作
        self.name = name
        self.wepon = wepon
        self.life_value = life_value
    def get_shot(self):
        print("I got shot")

# 在内存中是完全不同的两个对象
#role("xiajinqi","fireball")
#
r1 = role("xiajinqi","fireball")
‘‘‘
r1 = role("xiajinqi","fireball")
1、申请一个内存地址r1.
2、r1传递给类role
3、role.__init__(r1,"xiajinqi","fireball") 
备注：创建一个对象。相当于开辟一块内存空间。里面会存储变量等相关值。但是（类函数并没有复制一份，只是在调用时候，
传一个对象的内存地址来做区分不同的对象。好处就是节约内存空间），
如：role.__init__(r1,"xiajinqi","fireball") ，role.__init__(r2,"xiajinqi","fireball") 

‘‘‘

内存存储图：

 

5、类变量和实例变量。 作用范围。

  当某个变量在类和实例中都存在时候。优先取实例变量

class role :
    n = 12345  #类变量，对象共享
    name = "tset"
    def __init__(self,name,wepon,life_value= 00):
        #构造函数
        #在实例化时候。做一些初始化工作
        self.name = name  #实例变量 。未某个对象所独享
        self.wepon = wepon
        self.life_value = life_value
    def get_shot(self):
        print("I got shot")


print(role.n,role.name)
r1=role("ploice1","fireball")
r2=role("ploice2","fireball")

print(r1.n,r1.name) # 当name这个变量在实例和类都存在的。值先从对象开始找。没有时候取类的变量打印值为ploice1
print(r2.n,r2.name)# 当name这个变量在对象和类种都存在的。值先从对象开始找。没有时候取类的变量打印值为ploice2
#
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
12345 tset
12345 ploice1
12345 ploice2

Process finished with exit code 0

 

6、实例化以后。变量的修改和删除增加。 特殊说明：对象可以查类变量（实例变量不存在取类变量），但是不能修改和删除类变量。类变量修改只能由自己修改

如：r1.n = 100

.如果n存在，就表示修改。如果n不存在。

 

class role :
    n = 12345  #类变量，对象共享
    name = "tset"
    def __init__(self,name,wepon,life_value= 00):
        #构造函数
        #在实例化时候。做一些初始化工作
        self.name = name  #实例变量 。未某个对象所独享
        self.wepon = wepon
        self.life_value = life_value
    def get_shot(self):
        print("I got shot")


print(role.n,role.name)

r1=role("ploice1","fireball")
r2=role("ploice2","fireball")
r1.n=‘11111‘  # 相当于实例r1自己给自己创建了一个变量n,r1.n=n。。因此不会改变类变量
print(r1.n) #
print(r2.n)#  # 类变量依旧不能变
print(role.n)
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
12345 tset
11111
12345
12345

7、类变量修改。类变量修改只能由类自己修改。所有实例都无法直接修改类变量。

     并且类变量修改的影响范围为:实例对象中没有改变量，需要调用类变量的实例将受到影响。

class role :
    n = 12345  #类变量，对象共享
    name = "tset"
    def __init__(self,name,wepon,life_value= 00):
        #构造函数
        #在实例化时候。做一些初始化工作
        self.name = name  #实例变量 。未某个对象所独享
        self.wepon = wepon
        self.life_value = life_value
    def get_shot(self):
        print("I got shot")


print(role.n,role.name)

r1=role("ploice1","fireball")
r2=role("ploice2","fireball")
r1.n=‘11111‘  # 相当于实例r1自己给自己创建了一个变量n,r1.n=n。。因此不会改变类变量
print(r1.n) #

# 修改类变量
role.n = 88888
print(r2.n)
print(role.n)

E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
12345 tset
11111
88888
88888

Process finished with exit code 0

8、类变量的作业。例如：国际字段默认为中国。有少量人国际其他国际。所有未中国国际的人可以共用一个内存空间。从而节省内存。

 

9、析构函数。在实例销毁、结束时候执行。通常用于关闭数据库连接的打开的临时文件关闭等

class role :
    n = 12345  #类变量，对象共享
    name = "tset"
    def __init__(self,name,wepon,life_value= 00):
        #构造函数
        #在实例化时候。做一些初始化工作
        self.name = name  #实例变量 。未某个对象所独享
        self.wepon = wepon
        self.life_value = life_value

    def get_shot(self):
        print("I got shot")

    def __del__(self):
        print("ha game over")


# 程序执行结束后。自动调用
r1=role("ploice1","fireball")
r1.get_shot()
r2=role("ploice1","fireball")
r2.get_shot()


E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
I got shot
I got shot
ha game over
ha game over

python 内存回收机制。当变量销毁时候。会自动回收

class role :
    n = 12345  #类变量，对象共享
    name = "tset"
    def __init__(self,name,wepon,life_value= 00):
        #构造函数
        #在实例化时候。做一些初始化工作
        self.name = name  #实例变量 。未某个对象所独享
        self.wepon = wepon
        self.life_value = life_value

    def get_shot(self):
        print("I got shot")

    def __del__(self):
        print("ha game over")


# 程序执行结束后。自动调用
r1=role("ploice1","fireball")
r1.get_shot()
del r1
r2=role("ploice1","fireball")
r2.get_shot()

E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
I got shot
ha game over
I got shot
ha game over

Process finished with exit code 0

 

 

10、类的继承。简单实用

class People :
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s eat" %(self.name))

    def sleep(self):
        print("%s sleep" % (self.name))

class Man(People):
     def game(self):
         print("%s game" % (self.name))

     def sleep(self):
         print("%s man is sleep" % (self.name))  # 覆盖

     def eat(self):
         People.eat(self)  # 先调用父类。然后执行自己的函数体
         print("%s eat" % (self.name))  # 重构





man1 =Man("xiajinqi","19")
man1.sleep()  # 继承父类。
man1.game()   # 玩游戏。自己的类
man1.eat()  #重构

11、多继承和新式类。继承顺序。从左到右。

# 继承优先级，先执行自己的构造方法，再去调用Relation
#class Poeple： 经典类
class People(object) :   #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s eat" %(self.name))

    def sleep(self):
        print("%s sleep" % (self.name))

class Relation(object):
    def make_friends(self):  # obj
        print("make  %s"%(self.name))

class Man(People,Relation):  # 新式类鞋码
    def __init__(self, name, age, money):
        super(Man, self).__init__(name, age)
        self.money = money


    def game(self):
         print("%s game" % (self.name))

    def sleep(self):
         print("%s man is sleep" % (self.name))  # 覆盖

    def eat(self):
         People.eat(self)  # 先调用父类。然后执行自己的函数体
         print("%s eat" % (self.name))  # 重构





man1 =Man("xiajinqi","19",‘10000‘)

man1.make_friends()


E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
make fir xiajinqi

Process finished with exit code 0

 

12、类的继承顺序。广度优先

class shoool(object):
    def __init__(self,addr,name):
        self.addr = addr
        self.name = name
        self.students = []
        self.teacher = []

    def  en_roll(self,obj_student):
        self.students.append(obj_student)
        print("注册学员 %s"  %(obj_student.name))
    def  hire(self,obj_teacher):
        self.teacher.append(obj_teacher)
        print("注册学员 %s" % (obj_teacher.name))

class school_member(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def tell(self):
        pass


class student(school_member):
    def __init__(self,name,age,grade):
        super(student,self).__init__(name,age)
        self.grade = grade

    def tell(self):
        print(‘‘‘
        name:
        age:
        garde:
        ‘‘‘%(self.name,self.age,self.garde))


class teacher(school_member):
    def __init__(self, name,age,salary):
        super(teacher, self).__init__(name,age)
        self.salary = salary

    def tell(self):
        print(‘‘‘
        name:
        age:
        salary:
        ‘‘‘ % (self.name, self.age, self.salary))


shoool1 = shoool("北京","老男孩")
student1 = student("test1","22","一班")
student2 = student("test2","22","二班")

teacher1 = teacher("teacher1","33","2000000")
teacher2 = teacher("teacher2","33","2000000")

shoool1.en_roll(student1)
shoool1.en_roll(student2)

shoool1.hire(teacher1)
shoool1.hire(teacher2)


# 打印所有注册老师

for student in shoool1.students :
    print(student.name)


for teacher in shoool1.teacher :
    print(teacher.name)

 

 

13、多态.可以实现。统一接口多种实现。

class am(object):
    def __init__(self,name):
        print("name %s" %(name))

    # 接口
    def am(obj):
        obj.talk()


class dog(am):
    def talk(self):
        print("wangwang")

class cat(am):
    def talk(self):
        print("miaomiao")

dog1 = dog("test1")
cat2 = cat("test1")
am.am(cat2)

 

14课后练习题目：

角色：学校、学员、课程、讲师
要求：
1、创建北京、上海学校
2、创建linux/python/C++ 3个课程 linxu/python 在北京开。C++在上海开。
3、课程包含。周期、价格。通过学校创建课程。
4、通过学校创建班级。班级关联课程、讲师
5、创建学员时，选择学校。关联班级
6、创建讲师角色时要选择学校
7、提供角色接口
7、1 学员视图，可以注册。交学费。选择班级
7、2 讲师视图。讲师可以管理自己的班级。上课选择班级。查看班级学员列表。修改所管理学员的成绩
7/3 管理视图。创建讲师、创建班级、创建课程
7/4上面所有操作通过pickel序列化保存到文件。

 

以上是关于python 面向对象介绍的主要内容，如果未能解决你的问题，请参考以下文章

python 面向对象介绍

python（23）- 面向对象简单介绍

Python面向对象-11.继承介绍

Python基础-第六天-面向对象编程

python之路之前没搞明白4面向对象（封装）

python------面向对象介绍之多态实例