Python之路，第十七篇：Python入门与基础17

python3  面向对象编程

面向对象编程

什么是对象？

一切皆对象；

面向对象是思想：

描述思想的语言有：C++/Java/Python/Swift/C#

两个概念：

类  class

对象 object  /  实例 ( instance )

示例：

a = int(100)

b = str("hello")

类的创建语法：

class    类名[ ( 继承列表 ) ]：

‘‘’  类文档字符串  ‘’’

实例方法（类内的函数method）定义

类变量（class  variable）            定义

类方法（@classmethod）           定义

静态方法（@staticmethod）       定义

注：[ ] 的内容可以省略

类的作用：

1，可以用类来创建对象（实例）；

2， 类内定义的变量和方法能被此类所创建的所有实例共同拥有；

3， 类通常用来创建具有共同属性的对象（实例）；

 class Dog:
     pass
 Dog
 <class 'Dog'>
 dir()
 ['Dog', '__builtins__', 'l', 'sys']
 dog1 = Dog()
 dog1
 <Dog object at 0x0000000003D4E278>
 dog1.kinds = "京巴"
 dog1.color = "白色"
 print(dog1.kinds, dog1.color)
 京巴 白色
 dog1.age = 3
 dir(dog1)
 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'color', 'kinds']

实例创建的表达式：

类名（[创建传参]）

作用： 创建一个类的实例对象并返回实例；

实例说明：

1， 实例有自己的作用域和名字空间，可以为实例添加变量（属性）；

2，实例可以调用类中的方法；

3， 实例可以访问类中的类变量；

实例变量：

调用语法： 实例。变量名

在模块中调用： 模块名。实例。变量名

 class Dog:
     def infos(self):
         print("狗的种类：", self.kinds,"狗的颜色", self.color)

 dog1 = Dog()
 dog1.kinds = "京巴"
 dog1.color = "白色"
 dog1.infos()  #狗的种类： 京巴 狗的颜色 白色

实例方法：

语法：

class  类名（继承列表）：

def   实例方法名（self, 形式参数1， 形式参数2.。。。）:

'''文档字符串'''

语句。。。

说明：

1， 实例方法是实质是函数，是定义在类内的函数；

2，实例方法属于类的属性；

3， 实例方法的第一个参数代表调用这个实例方法的对象，一般命名为“self”；

4， 实例方法如果没有return语句，则返回None

 class Dog:
     "这是一个小动物定义，这种动物属于犬科"
     def say(self):
         print("旺！。。。")

 import dog
 dog1 = dog.Dog()
 dog1.say()  #旺！。。。

实例方法的调用语法：

实例。实例方法名（调用参数）

或

类名。实例方法名（实例。调用参数）

dog.Dog.say(dog1)

 class Dog:
     "这是一个小动物定义，这种动物属于犬科"
     def say(self):
         print("旺！。。。")

     def eat(self, that):
         "为狗进食，同时在food属性记住吃的什么"
         print("小狗正在吃：",that)
         self.food = that

     def food_info(self):
         """显示小狗进食的信息"""
         print('小狗吃的是：',self.food)

     def run(self, speed):
         print("吃了",self.food,"的小狗以",speed, "公里/小时的速度奔跑")

 dog1 = Dog()
 dog1.say()  #用对象来调用
 Dog.say(dog1)  #用类来调用
 #
 dog1.eat("骨头")
 print(dog1.food)  #骨头
 dog1.food_info()   #小狗吃的是：骨头
 #创建第二个小狗对象
 dog2 = Dog()
 dog2.say()       #旺！。。。
 dog2.eat("狗粮") #小狗正在吃： 狗粮
 dog2.food_info() #小狗吃的是： 狗粮
 #
 dog1.run(20)  #吃了 骨头 的小狗以 20 公里/小时的速度奔跑
 dog2.run(30)  #吃了 狗粮 的小狗以 30 公里/小时的速度奔跑

练习1;

 class Human:

     def setName(self, n):
         '''添加和修改姓名'''
         self.name = n

     def setAge(self, a):
         '''添加和修改年龄'''
         self.age = a

     def infos(self):
         '''显示人的信息'''
         print("姓名：",self.name,"年龄：",self.age)

 p1 = Human()
 p1.setName("张三")
 p1.setAge(20)
 p1.infos()
 #
 p2 = Human()
 p2.setName("李四")
 p2.setAge(21)
 p2.infos()
 #姓名： 张三 年龄： 20
 #姓名： 李四 年龄： 21

构造方法：

作用：创建对象时初始化实例变量

语法：def  __init__(self [ 形式参数列表 ])：

语句。。。

说明：1， 构造方法名必须为 __init__ 不可改变；

2， 在一个类中只能有一个__init__构造方法（有多个时，最后一个起作用）

3，构造方法会在实例创建时自动调用，且将实例自身通过第一个参数self传入__init__方法；

4，构造方法如果没有return语句，则返回self自身；

 class Dog:
     def __init__(self, k, c):
         self.kinds = k
         self.color = c
 #        return self

 #    def __init__(self, *args):
 #        pass

     def setKinds(self, k):
         self.kinds = k

     def setColor(self, c):
         self.color = c

     def infos(self):
         print("狗的种类：", self.kinds,"狗的颜色:", self.color)

 dog1 = Dog("京巴","黄色")
 dog1.infos() #狗的种类： 京巴 狗的颜色: 黄色

析构方法：

语法： class 类名：

def   __del__(self ):

pass

作用：1，构造方法会在对象销毁时被自动调用

2，python语言不建议在对象销毁时做任何事，因为此方法的调用时间难以确定；

 class Dog:
     def __init__(self, k, c):
         self.kinds = k
         self.color = c

     def __del__(self):
         print("内存释放，数据清除")

     def setKinds(self, k):
         self.kinds = k

     def setColor(self, c):
         self.color = c

     def infos(self):
         print("狗的种类：", self.kinds,"狗的颜色:", self.color)

 dog1 = Dog("京巴","黄色")
 dog1 = Dog("aaa","white") #内存释放，数据清除
 dog1 = None  #内存释放，数据清除
 del   dog1  #内存释放，数据清除

练习2

 class Car:
     def __init__(self, x, y, z ):
         self.brand = x
         self.model = y
         self.color = z

     def car_it(self, x, y, z):
         self.brand = x
         self.model = y
         self.color = z

     def run(self, s):
         self.speed = s

     def change_color(self, z):
         self.color = z

     def infos(self):
         print("(颜色)",self.color ,"(品牌)",self.brand,"(型号)",self.model,"正在以",self.speed,"km/h的速度行驶。")

 #
 a4 = Car("奥迪","A4","红色")
 a4.run(160)
 a4.infos()
 #(颜色) 红色 (品牌) 奥迪 (型号) A4 正在以 160 km/h的速度行驶。

 a4.change_color("黑色")
 a4.run(200)
 a4.infos()
 #(颜色) 黑色 (品牌) 奥迪 (型号) A4 正在以 200 km/h的速度行驶。

预置实例属性：

__dict__属性：

每一个对象（实例）都有一个__dict__属性；

__dict__属性绑定一个存储在此实例自身属性的字典；

 dog1 = Dog()
 print(dog1.__dict__)
 {'color':'white', 'kinds':'京巴'}
 dog1.__dict__

__doc__属性：

用于保存类的文档字符串，用于help（）中显示，实例的文档字符串和类的文档字符串相同；

 dog1 = Dog
 help(Dog)
 help(dog1)
 dog1.__doc__

__class__属性

__class__属性绑定创建此对象（实例）的类对象（类实例）；

作用：1， 可以借助于此属性来创建同类的实例；

2， 可以借助于此属性来访问类变量

 import dog
 dog.dog1
 dog.dog1.infos()
 dog.dog1.__class__
 <class 'dog.Dog'>

 dog2 = dog2.dog1.__class__( "大型犬"， "黄色" )

 dog2.infos()

 品种： "大型犬" 颜色 "黄色"

  #===
 L=[1,2,3]
 L.__class__
 <class 'list'>
 L.__class__(range(10))
 [0,1,2,3,4,5,6,7,8,9]
 list(range(10))

__module__属性

绑定此实例所属的模块；

在主模块中，此值为‘__main__’

不在主模块中，此值为模块名；

 class Human:
        pass

 h1 = human()
 h1.__module__
 #'__main__'

类变量

1，是指在类class 内定义的变量， 此变量属于类，不属于此类的对象（实例）

2，类变量， 可以通过该类直接使用；

3，类变量，可以通过类的实例直接调用

4， 类变量可以通过此类的对象的__class__属性间接访问；

 class Human:
     home = "地球"
     def __init__(self, name):
         self.name = name

 #print(home) #错的
 print(Human.home) #地球
 h1 = Human("张三")
 print(h1.home) #访问类对象
 h1.home = "火星"  #为此类添加了实例属性
 print(h1.home) #火星  访问实例属性
 print(Human.home) #????    访问类属性 #地球

 class Human:
     home = "地球"
     def __init__(self, name):
         self.name = name

 #print(home) #错的
 print(Human.home) #地球
 h1 = Human("张三")
 print(h1.home) #访问类对象
 h1.home = "火星"  #为此类添加了实例属性
 print(h1.home) #火星  访问实例属性
 print(Human.home) #????    访问类属性 #地球
 #
 print(h1.__class__.home)  # 间接访问类变量  # 地球
 #
 h1.__class__.home = "月球"
 print(Human.home) #月球
 #
 h2 = Human("张三")
 print(h2.home)  #月球

类的__slots__属性

作用：1，限定一个类创建的实例只能有固定的实例属性，不允许对象添加列表以外的实例属性；

2， 防止用户因为错写属性名儿发生程序错误

说明：  __slots__属性是一个列表，里边的值是字符串含有__slots__属性的类所创建的实例对象没有__dict__属性，即，此实例不用字典来存储属性；

 class Student:

     __slots__ = ["name","age","score"]

     def __init__(self, n, a ,s):
         self.name, self.age, self.score = n, a, s

 s1 = Student("xixi",  20, 90)
 print(s1.score) #
 s1.score = 92
 print(s1.score) #
 #s1.Score = 100 #注意 score 和Score 不同 #AttributeError: 'Student' object has no attribute 'Score' #y因为有__slots__属性而报错
 print(s1.score) #

对象的属性管理：

函数：

getattr(object, name[, default]) -> value

说明： 从一个对象得到对象的属性，getattr（x，‘ y ’）等同于x.y ; 当属性不存在时，如果给出default参数，则返回default，如果没有给出default则产生一个AttributeERROR错误；

hasattr(object, name) -> bool

说明：用给定的name返回对象obj是否有此属性，此做法可以避免getattr() 函数引发错误；

setattr(object, name, value)

说明：给对象object的名为name的属性设置相应的值，set（x， ‘ y ’， v）等同于x.y = v ;

delattr(object, name)

说明：删除对象obj的name属性，delattr（x，‘ y ’） 等同于del  x.y ;

 >>> class Myclass:
     pass

 >>> obj = Myclass()
 >>> dir(obj)
 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
 >>> obj.__class__
 <class '__main__.Myclass'>
 >>> obj.a1 = 100
 >>> obj.__dict__
 {'a1': 100}
 >>> setattr(obj, 'a2', 200)
 >>> obj.__dict__
 {'a2': 200, 'a1': 100}
 >>> hasattr(obj, 'a1')
 True
 >>> hasattr(obj, 'a2')
 True
 >>> hasattr(obj, 'a3')
 False
 >>> getattr(obj, 'a1')
 100
 >>> getattr(obj, 'a2')
 200
 >>> getattr(obj, 'a3')
 Traceback (most recent call last):
   File "<pyshell#15>", line 1, in <module>
     getattr(obj, 'a3')
 AttributeError: 'Myclass' object has no attribute 'a3'
 >>> getattr(obj, 'a3', 0)
 0
 >>> obj.__dict__
 {'a2': 200, 'a1': 100}
 >>> delattr(obj, 'a1')
 >>> obj.__dict__
 {'a2': 200}
 >>> del obj.a2
 >>> obj.__dict__
 {}
 >>> 

用于类的函数：

isinstance(obj , 类或类的元组)      返回这个对象obj是否为某个类或某些类的对象， 如果是返回True， 否则返回False ；

type（obj）      返回对象的类型；

 class A:
     pass

 a = A()
 def  fn(x):
     #我们不知道x绑定是什么类型？
     if isinstance(x,A):
         print('x是一个A类型的对象')
     elif isinstance(x, int):
         print("x为整数")

 fn(1) #x为整数
 fn(a) #x是一个A类型的对象
 fn([1,2,3])
 if type(a) == A:
     print("a是A类型的对象")

 ##############
 >>> class A:
     pass

 >>> a = A()
 >>> isinstance(a, int)
 False
 >>> isinstance(a, A)
 True
 >>> isinstance(a, str)
 False
 >>> isinstance(a, (str, int, bool))
 False
 >>> isinstance(a, (str, int, bool, A)
        )
 True
 >>> type(a)
 <class '__main__.A'>
 >>> type(a) == A
 True
 >>> type(a)
 <class '__main__.A'>
 >>> type(a)()  #A()
 <__main__.A object at 0x00000000036D1D68>
 >>> type(1)
 <class 'int'>
 >>> type('q')
 <class 'str'>
 >>> type('1+1j')
 <class 'str'>
 >>> type((1))
 <class 'int'>
 >>> type((1,))
 <class 'tuple'>
 >>> type({})
 <class 'dict'>
 >>> type({1,2,3})
 <class 'set'>
 >>> type({'a':1,'b':2,'c':3})
 <class 'dict'>
 >>>