python面向对象知识点

1.面向对象编程模式

（1）万物皆对象

对象：独立存在或作为目标的事物

对象的特性：

独立性（最重要的特性）：对象都存在清晰的边界，终点在于划分边界

功能性：对象都能表现出一些功能，操作或行为

交互性：对象之间存在及交互，如：运算和继承

为什么万物皆对象？

python语言中所有数据类型都是对象，函数是对象，模块是对象

python所有类都继承与最基础类object

python语言中数据类型的操作功能都是类方法的体现

（2）面向对象编程思想

面向对象编程的概念：

OOP：面向对象编程，一种编程思想，重点在于高抽象的复用代码

OOP把对象当做程序的基本单元，对象包含数据和操作数据的函数

OOP本质是把问题抽象为以对象为中心的计算机程序

OOP在较大规模或复杂项目中十分有用，OOP可以提高协作产量

OOP最主要的价值就在于代码复用

OOP只是一种编程方式，并非解决问题的高级方法

面向过程VS面向对象：

面向过程：以解决问题的过程步骤作为核心编写程序的方式

面向对象：以问题对象构建和应用为核心编程程序的方式

所有OOP能解决的问题，面向过程都能解决

（3）面向对象的三个特征

封装：属性和方法的抽象，用数据和操作数据的方法来形成逻辑对象

继承：代码复用的高级抽象，用对象之间的继承关系来形成代码复用

继承分为：基类，派生类，子类，父类，超类，重载

多态：方法灵活性的抽样，让对象的操作更加灵活，更多复用代码

（4）python面向对象术语概述

类：逻辑抽象和产生对象的模板，一组变量和函数的特定编排

对象：具体表达数据及操作的实体，相当于程序中的“变量”

对象具体分为：类对象和实例对象

类对象：Class Object，维护每个python类基本信息的数据结构

实例对象：instance Object python类实例后产生的对象，简称：对象

类对象全局只有一个，而实例对象可以有很多个

实例化：从类到对象的过程，所有“对象”都源于某个类

属性：存储数据的“变量”，包括类属性，实例属性

方法：操作数据的“函数“ ,包括:类方法，实例方法，自由方法，静态方法，保留方法，无论什么方法都是一个函数，只不过是定义在了类中。

三个特性：封装，继承，多态

命名空间：程序元素作用域的表达

构造和析构：生成对象和删除对象的过程

继承分为：基类，派生类，子类，父类，超类，重载

 

 

（5）python面向对象实例入门

 

class Prodect():
    def __init__(self,name):
        self.name=name
        self.labelPrice=0
        self.realPrice=0

c=Prodect("电脑")
d=Prodect("打印机")
e=Prodect("投影仪")

c.labelPrice,c.realPrice=2000,1000
d.labelPrice,d.realPrice=3000,1000
e.labelPrice,e.realPrice=2000,1000
s1,s2=0,0
for i in [c,d,e]:
    s1+=i.labelPrice
    s2+=i.realPrice
print("标签价格：%d,进价：%d"%(s2,s1))

　　

 

总结：

 2.python类的构建：

 

 

实验理解的代码：

1.实例属性只能通过对象名来进行访问，不能通过类名访问。

class myClass():
    i=str(123456)
    def f(self):
        return "hello!"

x=myClass()
print(myClass.i)
print(myClass.i[2])
print(myClass.f())#实例属性只能通过对象进行访问，即通过x来访问，所以此处会报错
print("myClass 类属性i为：",x.i)
print(x.i[2])
print("muClass 类的方法为：",x.f())

　　

2.第二个例子：

import os
import time
class studentn:
    def __init__(self,idx):
        self.idx=idx
    def runx(self):
        print(self.idx)
        time.sleep(1)

a=studentn('a')
a.runx()

3.第三个例子

#定义一个Car类
class Car:
    def infor(self):
        print("I am a Car")
#定义完类之后就可以接着实例化对象,通过对象名.成员
car=Car()
car.infor()

#可以使用内置方法isinstance()来测试一个对象是否为某个类的实例
print("测试car是否为Car的实例：",isinstance(car,Car))

4.第四个例子：

class Car:
    price=1000   #定义类属性，类属性属于类，可以通过类名或对象名访问
    def __init__(self,c):
        self.color=c  #定义实例属性，实例属性属于实例，只能通过对象名访问
car1=Car("red")
car2=Car("Blue")
print(car1.color,Car.price)  #查看实例属性和类属性的值
Car.price=11000  #修改类属性
Car.name='QQ'  #动态增加类属性
car1.color="Yellow"
print(car1.color,Car.price,car1.name)
print(car2.color,Car.price,car2.name)

5.第五个例子：

class Person(object):
    def __init__(self,name):
        assert isinstance(name,str),'name nust be string'
        self.name=name
    def sing(self):
        print(self.name+' can sing.')
    def walk(self):
        print(self.name+' can walk.')
    def eat(self):
        print(self.name+' can eat.')
zhang=Person('zhang')
zhang.sing()
zhang.walk()
zhang.eat()

#这种和上面一个例子的功能是一样的，是动态分配的。
import types
class Person(object):
    def __init__(self,name):
        assert isinstance(name,str),'name nust be string'
        self.name=name
def sing(self):#没有写入Person类中，所以下面的zhao.sing()结果会出现“用户不具有这种行为”的错误，然后我们可以通过types动态增加
    print(self.name+" can sing.")
def walk(self):
    print(self.name+" can walk.")
def eat(self):
    print(self.name+" can eat.")
zhao=Person('zhao')
zhao.sing=types.MethodType(sing,zhao)#动态新增用户行为sing
zhao.walk=types.MethodType(walk,zhao)
zhao.eat=types.MethodType(eat,zhao)
zhao.sing()
zhao.walk()
zhao.eat()
print("删除用户行为：")
del zhao.eat
print("删除成功")
zhao.eat()#再使用这个功能就没有了。说明删除成功

2020-05-20：补充一下今天所学

1.类对象class object

类定义完之后,默认生成一个类对象，每个类唯一对应一个类对象，用于存储这个类的基本信息。类对象是type实例，表达为type类型。类对象内直接包含的语句会被执行，因此，一般不会在类定义中直接包含语句

class Demo:
    "This is a demo for python class"
    print("Hello")
    pass
#print(Demo.__doc__)#类描述方法
#print(type(Demo))
#cn=Demo()
#print(type(cn))　　

运行结果：

 

 可以看到只是仅仅定义了一个类，里面写了一个输出函数，以运行他就直接运行处来结果了，所以一般不要再类中直接定义语句

2.

#类对象：类对象的属性，由所有实例对象所共享，类对象的值所有的又可以使用和修改
#实例对象：实例对象的属性，有各实例对象所独享。

 

class demo:
    count=0  #类属性，只包含在类中，不在函数中，直接在类中定义或赋值。访问类属性：类名.属性名或对象名.属性
    def __init__(self,name,age):#定义了一个类，同时生成了一个类对象
        self.name=name#实例属性，在类的内部，对象名.属性名
        self.age=age
        demo.count+=1
dc1=demo("老王",45)#用这个类生成了两个实例对象
dc2=demo('老李',51)
print("总数："demo.count)
print(dc1.name,dc2.name)

 

 

 3.类的方法：

#类的方法有5种
#1.实例方法：实例对象的方法，有各实例对象独享，最常用的形式
#2.类方法：类对象的方法，有所有实例对象共享
#3.自由方法：类中的一个普通函数，由类对象所在的命名空间管理，类对象独享
#4.静态方法：类中的一个普通函数，有类对象和实例对象共享
#5.保留方法：由双下滑开始和结束的方法，保留使用，如__len__()

#1.实例方法举例
class Demo:
    def __init__(self,name):
        self.name=name
    def lucky(self):
        s=0
        for c in self.name:
            s+=ord(c)%100
        return s
dc1=Demo("老王")
dc2=Demo("老李")
print(dc1.name,"的幸运数字是：",dc1.lucky())
print(dc2.name,"的幸运数字是：",dc2.lucky())

 

 

 

#2类方法：


#类方法至少包含一个参数，表示类对象，建议用cls，@classmethod是装饰器，
#类方法定义所必须，类方法只能操作类属性和其他方法，不能操作实例方法,类方法调用可以使用类名或对象名
#2.类方法举例：
class demo:
    count=0
    def __init__(self,name):
        self.name=name
        demo.count+=1
    @classmethod
    def getChrCount(cls):
        s="零一二三四五六七八九十多"
        return s[demo.count]
dc1=demo("老王")
dc2=demo('老王')
print(dc1.getChrCount())
print(demo.getChrCount())

 

 

 

 

#3.自由方法:就是类中的普通函数，理解为定义在类命名空间的函数，也可以定义在类外，习惯不同
#自由方法不要要self或cls这类参数，可以没有参数
#自由方法只能操作类属性，不能操作实例属性和实例方法
#自由方法的使用只能使用类名
class demo:
    count=0
    def __init__(self,name):
        self.name=name
        demo.count+=1
    def foo():
        demo.count*=100
        return demo.count
dc1=demo('老王')
print(demo.foo())

 

 

#4静态方法:在自由方法的基础上增加一个装饰器@staticmethod,调用方法类名.方法名 或对象名.方法名
class demo:
    count=0
    def __init__(self,name):
        self.name=name
        demo.count+=1
    @staticmethod
    def foo():
        demo.count*=100
        return demo.count
dc1=demo('老王')
print(demo.foo())
print(dc1.foo())

 

 

#5保留方法，有特殊含义，保留方法一般都有参数self eg:__len__
class demo:
    count=0
    def __init__(self,name):
        self.name=name
        demo.count+=1
    def __len__(self):
        return len(self.name)
dc1=demo('老王')
print(len(dc1))