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'>
>>>