python的面向对象程序设计(名词解释及实例)

类的定义

class Student:
    #定义类属性（类似于java的静态成员变量）
    country = "China"
    #构造函数
    def __init__(self,name,score):#self代表对象本身，类似于java中的this
        #声明成员变量
        self._name = name#如果是一个_代表是私有变量（实际上仍然可以访问），两个下划线的时候__，编译器会自动更改变量名
        self._score = score
        
    #setter方法
    def setName(self,name):
        self._name = nameame
    def setScore(self,score):
        if score>0 and score <100:
            self._score = score
        
    #getter方法
    def getName(self):
        return self._name
    def getScore(self):
        return self._score

创建对象

stu = Student('kehao',80)
print(type(stu))

print(stu.getName())
stu.setScore(-10)
print(stu.getScore())
stu.setScore(90)
print(stu.getScore())

print(Student.country)
print(stu.country)

<class '__main__.Student'>
kehao
80
90
China
China

继承和多态

class Animal:
    def run(self):
        print('Animal is running...')
    def sleep(self):
        print('Sleeping')
        
class Dog(Animal):
    #重载
    def run(self):
        print('Dog is running...')
    def eat(self):
        print('Eatting meats')

class Cat(Animal):
    #重载
     def run(self):
        print('Cat is running...')

dog = Dog()
dog.run()
dog.sleep()

cat = Cat()
cat.run()
cat.sleep()

Dog is running...
Sleeping
Cat is running...
Sleeping

def run(animal):
    animal.run()

animalList = [cat ,dog]
for animal in animalList:
    run(animal)

Cat is running...
Dog is running...

一些常用的函数

isinstance(a, A)这个函数是看a是不是A的实例，子类对象对于父类也是返回True

type(a)返回a的类型

dir(a)获得a的所有方法和属性

getattr(obj,a,b):获取obj的a属性，如果没有则返回默认值b

setattr(obj,a,b):设置obj的a属性为b

hasattr(obj,a):判断obj是否有a 属性

print(isinstance(cat,Animal))#判断一个
print(isinstance('a',(int,float)))#判断多个
print(isinstance('a',(int,float,str)))

True
False
True

print(type(cat))
print(type(cat) == Cat)
#types里面有很多常量值
import types
if type(run) == types.FunctionType:
    print('run is a function')
if type(abs) == types.BuiltinFunctionType:
    print('abs is builtin function')
if type(lambda x:x*x) == types.LambdaType:
    print("it's a lambda type")
if type((x for x in range(10)))==types.GeneratorType:
    print("it is generate type")

<class '__main__.Cat'>
True
run is a function
abs is builtin function
it's a lambda type
it is generate type

dir(stu) #返回一个列表，列表里是一个对象所有的属性和方法

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 '_name',
 '_score',
 'getName',
 'getScore',
 'setName',
 'setScore']

限制实例的属性

使用__slots__

__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的

除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

s = Student() # 创建新的实例
s.name = 'Michael' # 绑定属性'name'
s.age = 25 # 绑定属性'age'

s.score = 99 # 绑定属性'score'

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-54-dc0188d637e3> in <module>
----> 1 s.score = 99 # 绑定属性'score'


AttributeError: 'Student' object has no attribute 'score'

@property装饰器

负责把一个方法变成属性调用

1. getter和setter方法都为属性名
2. 将getter方法上标注@property装饰器
3. 将setter方法上标注函数名.setter装饰器

class Student1(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

s = Student1()
s.score = 60 # OK，实际转化为s.set_score(60)
s.score # OK，实际转化为s.get_score()

60

s.score = 9999#报错是因为上面的函数抛出了错误

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-68-883a7d599880> in <module>
----> 1 s.score = 9999#报错是因为上面的函数抛出了错误


<ipython-input-65-4ce4a387ef86> in score(self, value)
     10             raise ValueError('score must be an integer!')
     11         if value < 0 or value > 100:
---> 12             raise ValueError('score must between 0 ~ 100!')
     13         self._score = value


ValueError: score must between 0 ~ 100!

多重继承

class A:
    def showItself(self):
        print('A')
        
class B:
    def showItself(self):
        print('B')
        
class AB(A,B):
    pass

class BA(B,A):
    pass

如果父类函数名相同 优先调用左边的

ab = AB()
ba = BA()

ab.showItself()
ba.showItself()

A
B

调用被覆盖了的其他方法

方法1：

class AB2(A,B):
    def showItself_B(self):
        B.showItself(self)

ab2 =AB2()
ab2.showItself()
ab2.showItself_B()

A
B

方法2：

class AB3(A,B):
    def showItself_B(self):
        super(A,self).showItself()

ab3 = AB3()
ab3.showItself_B()

B

这个有点令人迷惑，为什么super(A,self).showItself()调用的却不是A的方法，而且A的父类是object，更没有这个方法

实际上这个是按照顺序来选择的，默认的super()调用的是第一个A，然后下一个是B

再python2中这个搜索顺序是深度优先搜索，而在python3中这个顺序是广度优先搜索

class A1(A):
    def showItself(self):
        print('A1')
        
class A2(A):
    def showItself(self):
        print('A2')

class A12(A1,A2):
    def showItself(self):
        super().showItself()
        super(A1,self).showItself()
        super(A2,self).showItself()

a12 = A12()
a12.showItself()

A1
A2
A

特殊方法

__str__和__repr__

用于当使用print的时候就会调用__str__方法去获取字符串

用于当使用交互模式直接输出变量的时候就会调用__repr__方法去获取字符串

class Astr1: 
    def __repr__(self):
        return "这是__repr__方法的调用"

class Astr2:
    def __str__(self):
        return "这是__str__方法的调用"

print(Astr1())
print(Astr2())

这是__repr__方法的调用
这是__str__方法的调用

Astr1()

这是__repr__方法的调用

Astr2()

<__main__.Astr2 at 0x1c5bda2af48>

__iter__和__next__

当对象需要使用for循环的时候，必须要去实现__iter__方法，返回一个迭代对象

然后迭代对象的__next__方法会被调用

class A_iter:
    a = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        A_iter.a+=1
        if A_iter.a>10:
            raise StopIteration()##终止循环
        return A_iter.a
    
a_iter = A_iter()
for i in a_iter:
    print(i,end=" ")
        

1 2 3 4 5 6 7 8 9 10 

__getitem__

__getitem__是用于取序列元素的

一般要分为数字和切片，分别处理

class A_getitem:
    def __getitem__(self,n):
        if isinstance(n,int):#索引为数字
            return n 
        if isinstance(n,slice):#索引为切片
            return [x for x in range(n.start,n.stop)]
    
a = A_getitem()
print(a[100])
print(a[10:20])

100
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

__getattr__

用于返回未定义的参数

__getattribute__与 __getattr__的区别

当每次调用属性时，python会无条件进入__getattribute__中，不论属性存在与否

而__getattr__只会在找不到属性的时候调用

class A_attr:
    def __getattribute__(self,attr):
        return attr

a = A_attr()
print(a.name)

name

__call__

将对象本身视为一个方法，调用的就是__call__

class A_call:
    def __call__(self):
        print('__call__方法被调用')

a = A_call()
a()

__call__方法被调用

判断对象是否能被作为函数调用使用callable()函数

print(callable("123"))
print(callable(a))

False
True

枚举类型

#导入枚举的包
from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

Month.Jan

<Month.Jan: 1>

本文地址：https://blog.csdn.net/qq754772661/article/details/107065325