一、面向对象oop
-----------------------------------------------------
1.类
用来描述具有相同的属性和方法的对象的集合。
它定义了该集合中每个对象所共有的属性和方法。
对象是类的实例。
2.类变量
类变量在整个实例化的对象中是公用的。
类变量定义在类中且在函数体之外。
类变量通常不作为实例变量使用。
3.数据成员
类变量或者实例变量用于处理类及其实例对象的相关的数据。
4.方法重写
如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
5.实例变量
定义在方法中的变量,只作用于当前实例的类。
6.继承
即一个派生类(derived class)继承基类(base class)的字段和方法。
继承也允许把一个派生类的对象作为一个基类对象对待。
例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(Dog是一个Animal)。
7.实例化
创建一个类的实例,类的具体对象。
8.对象
通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
二、类、方法和变量
----------------------------------------------
1.区分实例变量和类变量
类中定义的是类变量,相当于静态变量
方法中self定义的是实例变量
2.删除成员
del d1.name
3.类的内置函数
print(hasattr(d1,"age")) # 判断指定实例是否有指定成员
setattr(d1,"name",'xxx') # 给成员赋值set操作
print(getattr(d1,"name")) # 取成员值 get操作
delattr(emp1,'age') # 删除指定的成员
4.内置类属性
Dog.__dict__ //类属性,字典类型。
Dog.__doc__ //文档字符串
Dog.__name__ //类名
Dog.__module__ //类所在模块
Dog.__bases__ //所有父类构成的元组
5.析构函数
__del__:
xxx
销毁对象时调用:
d1 = None
del d1
6.代码展示
# -*- encoding=utf-8 -*-
# 创建一个类
class Dog:
#类变量,类似于静态成员。可以直接通过类访问
name = "dahuang"
#定义构造函数
def __init__(self):
Dog.name = "xiaohuang"
self.name = "jing8"
print("new a Dog, name is " + Dog.name + ": " + self.name)
#定义方法[self首参]
def watch(self,str):
#实例变量
self.name = str;
print("watch..." + str)
#定义方法
def add(self,a,b):
return a + b
#定义析构函数
def __del__(self):
print("执行析构函数!")
# new Dog
d1 = Dog()
# 访问变量
print(d1.name)
print(Dog.name)
# 调用函数
d1.watch("tom"); #方法中,对实例的变量进行赋值操作
print(d1.name) #访问的是实例的变量
print(Dog.name) #访问的是类的变量
print(d1.add(1,2))
# del d1.name #删除成员
print(hasattr(d1,"age")) #判断指定对象是否含有指定的成员
# 内置方法
setattr(d1,"name",'xxx') # 给成员赋值set操作
print(getattr(d1,"name")) # 取成员值 get操作
# 内置字段
print(Dog.__dict__)
print(Dog.__doc__)
print(Dog.__name__)
print(Dog.__module__)
print(Dog.__bases__)
# 销毁d1对象,调用析构函数
del d1
# d1 = None
7.定义私有方法
如果一个函数前面加'__'两个下划线修饰,那么就是私有方法。只能在对象内部调用、外部无法访问
class Cat:
name2 = "";
age2 = 0;
def __init__(self,name2,age2):
self.name2 = name2;
self.age2 = age2;
# 私有方法只能在内部访问
self.__eatFish();
def catchMouse(self):
print("抓老鼠")
# 定义私有方法
def __eatFish(self):
print(self.name2 + "爱吃鱼")
cat = Cat("tom",12);
cat.__eatFish() # 错误,没有成员__eatFish
8.定义静态方法
class DogCat(Dog,Cat):
def staticFunc(args): #静态方法
print("我是静态方法,使用类名打点调用")
print("我是静态方法,实例打点调用,是错误的")
9.定义实例方法
class DogCat(Dog,Cat):
def catchMouse(self):
print("我不会抓老鼠")
print("实例打点调用")
print("类打点调用,但是必须传入实例对象充当self")
10.类的成员和方法类似,分为静态成员,实例成员和私有成员
__name = "tom" # 表示私有成员,在实例内部使用self.__name进行调用
类中定义的name = "tom" # 表示静态成员 Dog.name 调用的是类成员name,定义在类中的
函数中定义的name = "tom" # 表示实例成员 d1.name 调用的是对象d1的name,一般是在函数中给出的
三、继承
------------------------------------------------------
1.特点
a.支持多重继承
b.子类的构造__init__,不会自动调用父类的__init__,需要自己在子类的init中显示调用父类的init,并传递self参数
c.调用父类方法,使用父类名做前缀,还要携带self参数
d.查找方法线本类,在父类
2.如果有多个父类,那么至少需要显示调用其中一个带参的构造函数
3.方法重写
4.代码演示
class Cat:
name2 = "";
age2 = 0;
def __init__(self,name2,age2):
self.name2 = name2;
self.age2 = age2;
self.__eatFish();
def catchMouse(self):
print("抓老鼠")
def __eatFish(self):
print(self.name2 + "爱吃鱼")
class DogCat(Dog,Cat):
__happy = "xxx";
def __init__(self):
Dog.__init__(self,"tom"); #显示调用父类的构造函数
Cat.__init__(self,"tom",22); #显示调用父类的构造函数
def run(self):
Dog.watch(self,"lalala") #子类调用父类的方法
print("running...")
def catchMouse(self): #子类重写父类的方法
print("我不会抓老鼠" + self.__happy)
def staticFunc(args): #静态方法
print("我是静态方法,使用类名打点调用")
print("我是静态方法,实例打点调用,是错误的")
# cat= Cat("tom",12);
# cat.__eatFish();
dc = DogCat()
# dc.watch("ttt")
dc.catchMouse()
# dc.run()
DogCat.staticFunc("");
DogCat.catchMouse(dc)
Python基础(三)--- Python面向对象oop,类、方法和变量,继承
猜你喜欢
转载自blog.csdn.net/xcvbxv01/article/details/83992718
今日推荐
周排行