Python学习-面向对象
2018-07-13 本文已影响101人
残阳夕露
查看所有Python相关学习笔记
面向对象
- 面向对象知识点汇总：
1. 获取属性：
> 1-实例对象.属性 --- . 是调用的意思
> 2-类属性(静态属性)---这个属性是属于所有类的对象
1-对象.属性
2-类.属性
2. 初始化方法===构造方法--```def ____init__(self):```
> 作用：只要创建实例，就会被调用
3. self--本身--->指实例的本身--->t1 --t1 = Tiger(200)
> 可以改其他字符 ---但不建议改--->规范
4. 实例方法：
> 定义：def tell(self):----self 是具体的调用实例
> 作用：每个实例个体都有自己的输出
5. 静态方法==类方法
@staticmethod 修饰，没有self
6. from random import randint #取随机---
> 要点：游戏-每一次的弹出的房间号是随机的
2-randint(0,2)可以取： 0，1，2 闭区间
7. 计算游戏时间：time.time()---秒
8. 继承：
class SouthTiger(Tiger,WonTiger):#括号内是 多个或一个父类名
9. 子类对象调用父类被重写的方法：
super(SouthTiger,h1).roar()
- 面向对象
- 静态属性
- 实例属性(self)
- 静态方法(@staticmethod)(可以访问静态属性：类名.属性）(不可以访问实例属性）
- 实例方法(self)（可以访问实例属性：self.属性）
- 类方法(cls)（@classmethod)(不可以访问实例属性）(使用较少，基本不用）
class Tiger: '老虎' classname = 'tiger'#静态属性 def __init__(self,weight = 200):#实例属性 self.weight = weight def tellWeight(self):#实例方法 print( f'my weight is {self.weight}') def roar(self): print('wow!!!') self.weight -= 5 @staticmethod # 静态方法 def roar2(): print(Tiger.classname) - 对象的继承
class SubClassName (ParentClass1[,ParentClass2]): passclass NeTiger(Tiger): '继承虎' color = 'red' classname= 'dongbei tiger' def __init__(self,weight=200): Tiger.__init__(self,weight) #调用父类的初始化方法 @staticmethod def jump(): print('两米高')
类和对象
对象对象 = 属性 + 方法
Python中的类名约定以大写字母开头
Python中的函数名约定以小写字母开头
面向对象简介OO=Object Oriented
- 封装 信息隐蔽技术
- 继承 继承是子类自动共享父类之间数据和方法的机制
# Mylist继承了list的方法和属性
class Mylist(list):
pass
list2 = Mylist()
list2.append(5)
print(list2)
# 执行结果
[5]
- 多态
名字一样，实现不一样
class A:
def fun(self):
print('我是A')
class B:
def fun(self):
print('我是B')
a = A()
b = B()
a.fun()
b.fun()
# 执行结果
我的A
我的B
面向对象编程
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
- self是什么？
Python的self相当于C++的this指针
同一个类可以生成无数个对象，self相当于门牌号
class Ball:
def setName(self,name):
self.name = name
def kick(self):
print('我叫%s,该死的，谁踢我...' % self.name)
a = Ball()
a.setName('球A')
b = Ball()
b.setName('球B')
c = Ball()
c.setName('土豆')
a.kick()
c.kick()
# 执行结果
我叫球A,该死的，谁踢我...
我叫土豆,该死的，谁踢我...
- 构造方法
__init__(self,param1,param2...)Python的魔法方法
class Ball:
def __init__(self,name='qiu'):
self.name = name
def kick(self):
print('我叫%s,该死的，谁踢我...' % self.name)
a = Ball('球A')
b = Ball()
c = Ball('土豆')
a.kick()
b.kick()
c.kick()
# 执行结果
我叫球A,该死的，谁踢我...
我叫qiu,该死的，谁踢我...
我叫土豆,该死的，谁踢我...
- 公有和私有
伪私有
在Python中定义私有变量只需要在变量名或函数名前加上“”两个下划线，那么这个函数或变量就变为私有的了
私有后必须使用内部方法调用或通过'类名_变量名'来访问
class Person:
__name = '测试'
def getName(self):
return self.__name
p = Person()
a = p.getName()
print(a)
# 执行结果
测试
测试
继承
单继承
class DerivedClassName(BaseClassName):
pass
BaseClassName 被继承的类：基类、父类、超类
- 子类可以调用父类方法
class Parent:
def hello(self):
print('正在调用父类的方法')
class Child(Parent):
pass
p = Parent()
p.hello()
c = Child()
c.hello()
# 执行结果
正在调用父类的方法
正在调用父类的方法
- 子类重写了父类的方法，将会覆盖掉父类的方法
# 例一：
class Parent:
def hello(self):
print('正在调用父类的方法')
class Child(Parent):
def hello(self):
print('正在调用子类的方法')
p = Parent()
p.hello()
c = Child()
c.hello()
# 执行结果
正在调用父类的方法
正在调用子类的方法
# 例二
import random as r
class Fish:
def __init__(self):
self.x = r.randint(1,10)
self.y = r.randint(1,10)
def move(self):
self.x -= 1
print('我的位置是：',self.x,self.y)
class Goldfish(Fish):
pass
class Carp(Fish):
pass
class Shark(Fish):
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print('吃货的梦想就是天天有的吃！！！')
else:
print('太撑了，吃不下了！')
print('调用父类.......................')
fish = Fish()
fish.move()
fish.move()
print('子类未重写，可调用父类的move.....')
goldfish = Goldfish()
goldfish.move()
goldfish.move()
print('子类已重写，不可调用父类的move...')
shark = Shark()
shark.eat()
shark.eat()
# shark.move() # AttributeError: 'Shark' object has no attribute 'x'
# 执行结果
调用父类.......................
我的位置是： 7 2
我的位置是： 6 2
子类未重写，可调用父类的move.....
我的位置是： 2 9
我的位置是： 1 9
子类已重写，不可调用父类的move...
吃货的梦想就是天天有的吃！！！
太撑了，吃不下了！
- 重写父类方法是想继续保持父类方法不被覆盖，可以采用以下两种方法
- 调用未绑定的父类方法（需要使用父类的名字）
import random as r class Fish: def __init__(self): self.x = r.randint(1,10) self.y = r.randint(1,10) def move(self): self.x -= 1 print('我的位置是：',self.x,self.y) class Goldfish(Fish): pass class Carp(Fish): pass class Shark(Fish): def __init__(self): self.hungry = True Fish.__init__(self) # 调用未绑定的父类方法 def eat(self): if self.hungry: self.hungry = False print('吃货的梦想就是天天有的吃！！！') else: print('太撑了，吃不下了！') shark = Shark() shark.move() # 执行结果 我的位置是： 9 6 # move方法调用成功- 使用super函数（不用给出任何父类的方法）
import random as r class Fish: def __init__(self): self.x = r.randint(1,10) self.y = r.randint(1,10) def move(self): self.x -= 1 print('我的位置是：',self.x,self.y) class Goldfish(Fish): pass class Carp(Fish): pass class Shark(Fish): def __init__(self): self.hungry = True super().__init__() # 使用super def eat(self): if self.hungry: self.hungry = False print('吃货的梦想就是天天有的吃！！！') else: print('太撑了，吃不下了！') shark = Shark() shark.move() # 执行结果 我的位置是： 7 5
多继承，既可以调用父类1的方法也可以调用父类2的方法
class Base1:
def foo1(self):
print('我的foo1，我未Base1代言')
class Base2:
def foo2(self):
print('我的foo2，我未Base2代言')
class C(Base1,Base2):
pass
c = C()
c.foo1()
c.foo2()
# 执行结果
我的foo1，我未Base1代言
我的foo2，我未Base2代言
组合
把类和实例化放到一个新的类里
把没有继承关系的类放到一起
补充：Mix-in
class Trutle:
def __init__(self,x):
self.num = x
class Fish:
def __init__(self,x):
self.num = x
class Pool:
def __init__(self,x,y):
self.trutle = Trutle(x)
self.fish = Fish(y)
def print_num(self):
print('水池总共有乌龟%d只，小鱼%d只' %(self.trutle.num,self.fish.num))
pool = Pool(4,5)
pool.print_num()
# 执行结果
水池总共有乌龟4只，小鱼5只
类、类对象、实例对象
- 属性的名字跟方法名相同，属性会覆盖方法
- 不要试图在一个类里面定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展
- 用不同的词性命名，如属性名用名词，方法名用动词
什么是绑定self
Python严格要求方法需要有实例才能被调用，这种限制其实就是Python所谓的绑定概念。
实例化后，即使删除类，原来实例化的对象任然有效
