一、创建类和对象

面向对象是一种编程方式,此编程方式的实现是基于对  和 对象 的使用

类是一个模板,模板中包装了多个“函数”供使用(可以讲多函数中公用的变量封装到对象中)

对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数

def Dog(name,type):

    def call(dog):

        print("这是一条%s,名字叫%s"%(dog['type'],dog['name']))

    def eat(dog):

        print("%s正在啃骨头"%dog['type'])

    def init(name,type):

        dog_dcit={'name':name,'type':type,'call':call,'eat':eat}

        return dog_dcit

    res=init(name,type)

    return res

d1=Dog('小狗',"中华田园犬")

d1['call'](d1)
d1['eat'](d1)

面向对象设计

类的成员可以分为三大类:字段(类变量)、方法(动态属性)和属性(静态属性)

1、类的语法

在python3.0 中有两种写法,一种是经典类还有一种是新式类

经典类和新式类的区别:继承方法上的区别,分为广度优先和深度优先两种继承策略

class Dog:                           #经典类,类名后不加括号

    def __init__(self,name):   #构造函数

          self.name=name

    def bulk(self):
print('%s,汪汪'%self.name) d1 = Dog("小红") #初始化一个类 构造一个对象 self相当于d1 Dog(d1,"小红")
d2 = Dog("小明") d1.bulk()
d2.bulk()

经典类

class Dog(object):                #新式类,类名后加括号(object)

    def __init__(self,name):   #构造函数

          self.name=name

    def bulk(self):
print('%s,汪汪'%self.name) d1 = Dog("小红") #初始化一个类 构造一个对象 self相当于d1 Dog(d1,"小红")
d2 = Dog("小明") d1.bulk()

新式类

2、类变量、方法和属性

类变量:在类中定义的变量class Role(object): #定义类

    num=123               #类变量,大家都可以调用
num_list=[] def __init__(self, name, role, weapon, life_value=100, money=15000): #构造函数 在实例化时做一些类的初始化的工作 self.name = name #self.name 赋给实例 实例变量(静态属性) 作用域就是实例本身
self.role = role
self.weapon = weapon
self.__life_value = life_value #私有属性前面要加两个下划线__来定义,私有属性只可以在方法里面调用
self.money = money def __del__(self): #析构函数 实例或者对象消亡或者程序结束时才调用
#在实例释放或销毁的时候自动执行,通常用于做一些收尾工作
#如:关闭一些数据库连接,打开的临时文件
print("%s 彻底死了。。。。"%self.name) def shot(self):
print("shooting...") def got_shot(self): #定义类的方法(功能)也叫作动态属性
print("ah...,I got shot...") def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name)) #方法里的self self.name 相当于r1.name def show_life(self): print("life %s"%self.__life_value) #私有属性 只可以在内部方法里调用 def __get_weapon(self): #定义私有方法 在定义方法名前加两个下划线,私有方法也是只能在类方法中被调用
print('私有方法') Role_dict=Role.__dict__ # 查看类的属性字典 print(Role_dict)
#输出:{'__module__': '__main__', 'num': 123, 'num_list': [], '__init__': <function Role.__init__ at 0x10ed6c290>, '__del__': <function Role.__del__ at 0x10ed6c320>, 'shot': <function Role.shot at 0x10ed6c710>, 'got_shot': <function Role.got_shot at 0x10ed6c7a0>, 'buy_gun': <function Role.buy_gun at 0x10ed6c830>, '_Role__get_weapon': <function Role.__get_weapon at 0x10ed6c8c0>, 'show_life': <function Role.show_life at 0x10ed6c950>, '__dict__': <attribute '__dict__' of 'Role' objects>, '__weakref__': <attribute '__weakref__' of 'Role' objects>, '__doc__': None} r1 = Role('Alex', 'police', 'AK47') # 生成一个角色 (初始化一个类,造了一个对象) 把一个类变成一个具体对象的过程叫实列化
# Role(r1,'Alex','police','AK47') r1.name=name 是这样实例的
#Role(r1,'Alex','police','AK47') self.name 相当于 r1.name # print(r1.__dict__) #查看实例的属性字典
#输出:{'name': 'Alex', 'role': 'police', 'weapon': 'AK47', '_Role__life_value': 100, 'money': 15000} r2 = Role('Jack', 'terrorist', 'B22') # 生成一个角色
r1.buy_gun('AK-47')
r2.buy_gun('加特林') r1.n=456
print(r1.n) #输出是456 互不影响 r3=Role('lucy','artist','AK47')
print(r3.n) #输出是123 在实例r1中值被修改 但是在实例r3中不影响,互相独立 只是类在实例化对象时 都独自开辟了一块内存 Role.n=789
print(r1.n,r3.n) #输出 r1.n是456不是789 因为r1.n已经被实例化过r3.n是789

3、类属性的增删查改

class Chinese:

    country="China"

    def __init__(self,name):

        self.name=name

    def play_ball(self,ball):

        print("%s 正在打 %s"%(self.name))

    def sayWord(self,word):
print("%s 说 %s"%(self.name,word)) # 查看类的属性
print(Chinese.country) # 修改类的属性
Chinese.country ="Japan"
p1=Chinese("allen") print(Chinese.country,p1.country) # 删除类的属性
# del Chinese.country
# print(Chinese.country) # 会报错 # 增加类的属性
Chinese.language = "汉语"
p2=Chinese("lucy")
print(Chinese.country,p2.country,p2.language)
print(Chinese.__dict__) # 函数属性的增删改查 def learning(self,course): print("%s is learning %s"%(self.name,course)) Chinese.learn=learning p3=Chinese("Lily") p3.learn("france")

类属性的增删改查

class Chinese:

    country="China"

    def __init__(self,name):

        self.name=name

    def play_ball(self,ball):

        print("%s 正在打 %s"%(self.name,ball))

    def sayWord(self,word):
print("%s 说 %s"%(self.name,word)) # 查看实例的属性
p1=Chinese("allen")
print(p1.name)
print(p1.play_ball) # 增加实例的属性
p1.age = 18
print(p1.__dict__) # 修改实例的属性
p1.age = 19 print(p1.__dict__)

实例属性的增删改查

4、类的组合

class Head:
pass class Foot:
pass class Body:
pass class Person:
def __init__(self,id_num,name): self.id_num=id_num
self.name=name
self.head=Head() # 实例化一个Head类
self.body=Body() # 实例化一个Body类
self.foot=Foot() # 实例化一个Foot类 p=Person("","allen") print(p.__dict__)

组合

class School:
def __init__(self,name,address): self.name=name
self.address=address def academy(self):
print("%s学校的地址是%s"%(self.name,self.address)) class Course:
def __init__(self,course_name,school):
self.course_name=course_name self.school=school s1=School("山东大学","济南")
s2=School("北京大学","北京")
s3=School("深圳大学","深圳") msg="""
1.山东大学
2.北京大学
3.深圳大学
""" while True:
print(msg)
schoolInfo={"":s1,"":s2,"":s3}
choice=input("请选择学校:")
courseName=input("请输入课程名:")
c1=Course(courseName,schoolInfo[choice]) print("课程%s属于%s"%(c1.course_name,c1.school.name))

示例-选课系统

二、面向对象三大特性

面向对象三大特性:封装、继承和多态

1、继承

继承概念的实现方式主要有2类:实现继承、接口继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力;
Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法);
在python2中 经典类是按深度优先来继承的 新式类是按广度优先来继承的;在python3中 经典类和新式类都是按广度优先来继承的。
class A(object):                   #基类
def __init__(self):
print("A") class B(A):
# def __init__(self): # B继承A 单继承
# print("B")
pass class C(A):
# def __init__(self): # C继承A
# print("C")
pass class D(B,C):
#def __init__(self): #D继承B和C 多继承
# print("D")
pass a=D()

继承

子类继承了父类的所有属性。子类自定义的属性如果和父类的属性重名了,那就直接调用自己的属性,不再调用父类的属性。

1.1、继承顺序

Python2中的类如果继承了多个类,那么其寻找方法的方式有两种,分别是:深度优先和广度优先

  • 当类是经典类时,多继承情况下,会按照深度优先方式查找
  • 当类是新式类时,多继承情况下,会按照广度优先方式查找

Python3中统一都是新式类,都是广度优先查找。

class A(object):
def test(self):
print('from A') class B(A):
def test(self):
print('from B') class C(A):
def test(self):
print('from C') class D(B):
# def test(self):
# print('from D')
pass class E(C):
def test(self):
print('from E') class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test() # 查找顺序:F --> D --> B --> E --> C --> A

python3新式类广度优先继承

python到底是如何实现继承的,对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表。

例如:

print(F.__mro__)   #打印mro列表

[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

 1.2、子类中调用父类的方法 

class People(object):
def __init__(self, name, age):
self.name = name
self.age = age def eat(self):
print("%s is eating" % self.name) def sleep(self):
print("%s is sleeping" % self.name) def print_tab(self):
print("%s 今年 %s" % (self.name, self.age)) class Relation(object): def make_friend(self, obj):
print("%s is making friends with %s" % (self.name, obj.name)) class Man(Relation, People): # 继承Relation,和People两个基类 def __init__(self, name, age, money):
People.__init__(self, name, age) # 重构经典类写法
# super(Man,self).__init__(name,age) # 新式写法
self.money = money def drink(self):
print("%s is drinking %s" % (self.name, self.money)) def sleep(self): # 基类中也有sleep()方法
People.sleep(self) # 重构基类中sleep()方法后 先调用基类的sleep()方法 再调用自己的方法 如果不重构,就调用自己的sleep()方法
print("man is sleeping") class Women(People, Relation): # 继承Relation,和People两个基类 def get_birth(self):
print("%s is making face" % self.name) m1 = Man("Jim", 20, 100)
m1.drink()
m1.sleep()
m1.eat()
w1 = Women("lucy", 20)
w1.get_birth() m1.make_friend(w1)
# -*-coding:utf-8-*-

class school(object):

    def __init__(self,name,addr):
self.name=name
self.addr=addr
self.students=[]
self.teachers=[] def enroll(self,stu_obj):
print('为%s学员办理注册手续'%stu_obj.name)
self.students.append(stu_obj) class SchoolMember(object):
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex class Teacher(SchoolMember): def __init__(self,name,age,sex,salary,course):
super(Teacher,self).__init__(name,age,sex)
self.salary=salary
self.course=course def tell(self):
print("""-------info of Teacher:---------
name:%s
age:%s
sex:%s
salary:%s
course=%s
""" % (self.name, self.age, self.sex, self.salary, self.course)) def teach(self):
print("%s is teaching course[%s]"%(self.name,self.course)) class Student(SchoolMember): def __init__(self,name,age,sex,stu_id,grade):
super(Student,self).__init__(name,age,sex)
self.stu_id=stu_id
self.grade=grade def tell(self):
print("""-------info of student:---------
name:%s
age:%s
sex:%s
stu_id:%s
grade=%s
""" % (self.name, self.age, self.sex, self.stu_id, self.grade)) def pay(self,account):
print("%s paid account:$%d"%(self.name,account)) school1=school('北京大学','北京') teacher1=Teacher('李老师',30,'男',5000,'Linux')
teacher2=Teacher('陈老师',23,'女',3000,'PHP') student1=Student('小明',23,'女',1001,'python')
student2=Student('小露',25,'女',1002,'python') teacher1.tell() student1.tell() school1.enroll(student1) print(school1.students) school1.students[0].pay(5000)

示例

2、多态

多态指的是一类事物有多种形态,指出了对象如何通过他们共同的属性和动作来操作及访问,而不需要考虑他们具体的类。

一种接口,多种实现 python 不直接支持多态,可以间接实现

class Animal(object):
def __init__(self, name): # Constructor of the class
self.name = name # def talk(self): # Abstract method, defined by convention only
# raise NotImplementedError("Subclass must implement abstract method")
@staticmethod
def func(obj): # 一个接口,多种形态
obj.talk() class Cat(Animal):
def talk(self):
print('%s: 喵喵喵!' % self.name) class Dog(Animal):
def talk(self):
print('%s: 汪!汪!汪!' % self.name) c1 = Cat('小晴')
d1 = Dog('李磊') Animal.func(c1)
Animal.func(d1)

多态

 3、封装

1、封装的特性:双下划线__开头(私有属性和私有方法),类内部可以调用,外部不可调用。

注意: 双下划线开头在外部不能被调用是因为被类重新命名了,其实在外部是可以被调用的。

class Role:
num = 123 # 类变量,大家都可以调用
num_list = []
__info="角色"
def __init__(self, name, role, weapon, life_value=100, money=15000): self.name = name # self.name 赋给实例 实例变量(静态属性) 作用域就是实例本身
self.role = role
self.weapon = weapon
self.__life_value = life_value # 私有属性前面要加两个下划线__来定义,私有属性只可以在方法里面调用
self.money = money def shot(self):
print("shooting...") def got_shot(self):
print("ah...,I got shot...",self.__info) def __get_weapon(self): # 定义私有方法 在定义方法名前加两个下划线,私有方法也是只能在类方法中被调用
print('私有方法',self.__info) r=Role("Jim","武器","ak47")
#print(r.__info) 这样是调用不到的,因为它被类重新命名为_Role__info了
print(Role.__dict__)
#双下划线开头在外部不能被调用是因为被类重命名了
print(r._Role__info) # 私有属性这样就可以调用了
r._Role__get_weapon() # 私有方法这样可以被调用

封装-私有属性和方法

Python全栈开发之6、面向对象的更多相关文章

  1. 战争热诚的python全栈开发之路

    从学习python开始,一直是自己摸索,但是时间不等人啊,所以自己为了节省时间,决定报个班系统学习,下面整理的文章都是自己学习后,认为重要的需要弄懂的知识点,做出链接,一方面是为了自己找的话方便,一方 ...

  2. python全栈开发之OS模块的总结

    OS模块 1. os.name()      获取当前的系统 2.os.getcwd      #获取当前的工作目录 import os cwd=os.getcwd() # dir=os.listdi ...

  3. Python全栈开发之14、Javascript

    一.简介 前面我们学习了html和css,但是我们写的网页不能动起来,如果我们需要网页出现各种效果,那么我们就要学习一门新的语言了,那就是JavaScript,JavaScript是世界上最流行的脚本 ...

  4. Python全栈开发之1、输入输出与流程控制

    Python简介 python是吉多·范罗苏姆发明的一种面向对象的脚本语言,可能有些人不知道面向对象和脚本具体是什么意思,但是对于一个初学者来说,现在并不需要明白.大家都知道,当下全栈工程师的概念很火 ...

  5. Python全栈开发之MySQL(二)------navicate和python操作MySQL

    一:Navicate的安装 1.什么是navicate? Navicat是一套快速.可靠并价格相宜的数据库管理工具,专为简化数据库的管理及降低系统管理成本而设.它的设计符合数据库管理员.开发人员及中小 ...

  6. Python全栈开发之9、面向对象、元类以及单例

    前面一系列博文讲解的都是面向过程的编程,如今是时候来一波面向对象的讲解了 一.简介 面向对象编程是一种编程方式,使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” ...

  7. Python全栈开发之7、面向对象编程进阶-类属性和方法、异常处理和反射

    一.类的属性 1.@property属性 作用就是通过@property把一个方法变成一个静态属性 class Room: def __init__(self,name,length,width,he ...

  8. python全栈开发之路

    一.Python基础 python简介 python数据类型(数字\字符串\列表) python数据类型(元组\字典) python数据类型(集合) python占位符%s,%d,%r,%f prin ...

  9. Python全栈开发之MySQL(三)视图,存储过程触发器,函数,事务,索引

    一:视图 1:什么是视图? 视图是指存储在数据库中的查询的SQL语句,具有简单.安全.逻辑数据独立性的作用及视点集中简化操作定制数据安全性的优点.视图包含一系列带有名称的列和行数据.但是,视图并不在数 ...

随机推荐

  1. npm 镜像地址配置

    1.查询当前镜像地址 npm get registry 2.修改镜像地址 npm config set registry http://registry.npm.taobao.org/ 原始镜像地址( ...

  2. CSS实现太极效果

    这个伪元素的位置对齐还妹搞明白 需要再研究研究   <html> <head> <title>taiji</title> <style> b ...

  3. js+下载文件夹

    一.此方法火狐有些版本是不支持的 window.location.href = 'https://*****.oss-cn-**.aliyuncs.com/*********'; 二.为了解决火狐有些 ...

  4. Linux进程通信之文件

    父子进程共享打开的文件描述符------使用文件完成进程间通信. /*** fork_share_fd.c ***/ #include <stdio.h> #include <uni ...

  5. 【MAC工具】手机抓包工具之 —— whistle

    本文链接:https://blog.csdn.net/weixin_42534940/article/details/88783455安装参考: https://github.com/avwo/whi ...

  6. 6.使用Feign实现声明式REST调用

                        使用Feign实现声明式REST调用 6.1. Feign简介 Feign是一个声明式的REST客户端,它的目的就是让REST调用更加简单. Feign提供了H ...

  7. 在docker 安装gitlab

    一.Centos 7 上安装 官方文档:https://docs.docker.com/install/linux/docker-ce/centos/ 1.安装环境      yum install  ...

  8. linux基础技巧

    命令行颜色显示: \[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\0 ...

  9. dts是如何来描述iommu与PCI(e)之间的关系?

    1. 在一颗树的根下每个PCI(e)设备被它的请求id(AKA RID)独一无二的标识,一个请求ID由三部分组成,总线号,设备号和功能号,如: Bits [15:8] 是总线号 Bits [7:3]是 ...

  10. Rsync数据同步工具及sersync同步工具

    Rsync简介 Rsync英文全称Remote synchronization,从软件的名称就可以看出来,Rsync具有可使本地和远程两台主机之间的数据快速复制同步镜像,远程备份的功能,这个功能类似s ...