阿里云Python训练营
TASK3-DAY2
简介
对象是类的实例。换句话说,类主要定义对象的结构,然后我们以类为模板创建对象。类不但包含方法定义,而且还包含所有实例共享的数据。
一、类与对象
1. 属性和方法组成对象
对象 = 属性 + 方法
- 封装:信息隐蔽技术
我们可以使用关键字 class 定义 Python 类,关键字后面紧跟类的名称、分号和类的实现。
演示代码如下:
class Turtle: # Python中的类名约定以大写字母开头
"""关于类的一个简单例子"""
# 属性
color = 'green'
weight = 10
legs = 4
shell = True
mouth = '大嘴'
def rabbit(self):
print('rabbit')
def bite(self):
print('咬死你')
zmt=Turtle() #创建类的对象
zmt.rabbit() #调用类里的方法
#rabbit
- 继承:子类自动共享父类之间数据和方法的机制
演示代码如下:
class MyList(list):
pass #pass 是空语句,是为了保持程序结构的完整性。
lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
lst.sort()
print(lst)
# [1, 2, 5, 7, 8, 9]
- 多态:不同对象对同一方法响应不同的行动
演示代码如下:
class Animal:
def run(self):
raise AttributeError('子类必须实现这个方法')
class Pig(Animal):
def run(self):
print('pig is walking')
class Dog(Animal):
def run(self):
print('dog is running')
def func(animal):
animal.run()
func(run())
# pig is walking
2. self是什么?
Python 的 self 相当于 C++ 的 this 指针。
演示代码如下:
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
# <__main__.Test object at 0x000000BC5A351208>
# <class '__main__.Test'>
类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称(对应于该实例,即该对象本身),按照惯例它的名称是 self。在调用方法时,我们无需明确提供与参数 self 相对应的参数。
演示代码如下:
class Ball:
def setName(self, name):
self.name = name
def kick(self):
print("my name is%s,oh shift,who kick me" % self.name)
a = Ball()
a.setName("zmt")
#my name is zmt,oh shift,who kick me
3.Python的魔法方法
据说,Python 的对象天生拥有一些神奇的方法,它们是面向对象的 Python 的一切…
如果你的对象实现了这些方法中的某一个,那么这个方法就会在特殊的情况下被 Python 所调用,而这一切都是自动发生的…
类有一个名为__init__(self[, param1, param2…])的魔法方法,该方法在类实例化时会自动调用。
演示代码如下:
class Ball:
def __init__(self, name):
self.name = name
def kick(self):
print("my name is%s,oh shift,who kick me" % self.name)
a = Ball("zgk")
a.kick()
# my name is zgk,oh shift,who kick me
4.公有和私有
在 Python 中定义私有变量只需要在变量名或函数名前加上“__”两个下划线,那么这个函数或变量就会为私有的了。
演示代码如下:
#私有变量例子:
class zmt:
_a=0 #私有变量
b=0 #公有变量
def count(self):
self._a+=1
self.b+=1
print(self.a)
zgk=zmt()
zgk.count() #1
zgk.count() #2
print(zgk.b) #2
print(zgk._a)
# AttributeError: 'JustCounter' object has no attribute '__secretCount'
#私有方法例子:
class Site:
def __init__(self, name, url):
self.name = name # public
self.__url = url # private
def __foo(self): # 私有方法
print('这是私有方法')
def foo(self): # 公共方法
print('这是公共方法')
self.__foo()
x = Site('老马的程序人生', 'www')
x.foo()
# 这是公共方法
# 这是私有方法
x.__foo()
# AttributeError: 'Site' object has no attribute '__foo'
5. 继承
Python 同样支持类的继承,派生类的定义如下所示:
class DerivedClassName(BaseClassName):
statement-1
.
.
.
statement-N
BaseClassName(基类名)必须与派生类定义在一个作用域内。除了类,还可以用表达式,基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):
statement-1
.
.
.
statement-N
如果子类中定义与父类同名的方法或属性,则会自动覆盖父类对应的方法或属性。
演示代码如下:
# 类定义
class people:
# 定义基本属性
name = ''
age = 0
# 定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
# 定义构造方法
def __init__(self, n, a, w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" % (self.name, self.age))
# 单继承示例
class student(people):
grade = ''
def __init__(self, n, a, w, g):
# 调用父类的构函
people.__init__(self, n, a, w)
self.grade = g
# 覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了,我在读 %d 年级" % (self.name, self.age, self.grade))
s = student('zmt', 10, 60, 3)
s.speak()
# zmt 说: 我 10 岁了,我在读 3 年级
Python 虽然支持多继承的形式,但我们一般不使用多继承,因为容易引起混乱。
class DerivedClassName(Base1, Base2, Base3):
statement-1
.
.
.
statement-N
需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,Python 从左至右搜索,即方法在子类中未找到时,从左到右查找父类中是否包含方法。
演示代码如下:
#这部分代码就是前面那个
# 另一个类,多重继承之前的准备
class Speaker:
topic = ''
name = ''
def __init__(self, n, t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s,我是一个演说家,我演讲的主题是 %s" % (self.name, self.topic))
# 多重继承
class Sample01(Speaker, Student):
a = ''
def __init__(self, n, a, w, g, t):
Student.__init__(self, n, a, w, g)
Speaker.__init__(self, n, t)
# 方法名同,默认调用的是在括号中排前地父类的方法
test = Sample01("zmt", 25, 80, 4, "Python")
test.speak()
# 我叫 zmt,我是一个演说家,我演讲的主题是 Python
class Sample02(Student, Speaker):
a = ''
def __init__(self, n, a, w, g, t):
Student.__init__(self, n, a, w, g)
Speaker.__init__(self, n, t)
# 方法名同,默认调用的是在括号中排前地父类的方法
test = Sample02("Tim", 25, 80, 4, "Python")
test.speak()
# zmt 说: 我 25 岁了,我在读 4 年级
6.组合
演示代码如下:
class Turtle:
def __init__(self, x):
self.num = x
class Fish:
def __init__(self, x):
self.num = x
class Pool:
def __init__(self, x, y):
self.turtle = Turtle(x)
self.fish = Fish(y)
def print_num(self):
print("水池里面有乌龟%s只,小鱼%s条" % (self.turtle.num, self.fish.num))
p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只,小鱼3条
7. 类、类对象和实例对象
类对象:创建一个类,其实也是一个对象也在内存开辟了一块空间,称为类对象,类对象只有一个。
class A(object):
pass
实例对象:就是通过实例化类创建的对象,称为实例对象,实例对象可以有多个。
8. 什么是绑定?
Python 严格要求方法需要有实例才能被调用,这种限制其实就是 Python 所谓的绑定概念。
Python 对象的数据属性通常存储在名为.__ dict__的字典中,我们可以直接访问__dict__,或利用 Python 的内置函数vars()获取.__ dict__。
演示代码如下:
class CC:
def setXY(self, x, y):
self.x = x
self.y = y
def printXY(self):
print(self.x, self.y)
dd = CC()
print(dd.__dict__)
# {}
dd.setXY(4, 5)
print(dd.__dict__)
# {'x': 4, 'y': 5}
print(CC.__dict__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY': <function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None
9. 一些相关的内置函数(BIF)
(1).
- issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
- 一个类被认为是其自身的子类。
- classinfo可以是类对象的元组,只要class是其中任何一个候选类的子类,则返回True。
演示代码如下:
class A:
pass
class B(A):
pass
print(issubclass(B, A)) # True
print(issubclass(B, B)) # True
print(issubclass(A, B)) # False
print(issubclass(B, object)) # True
(2).
- isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型,类似type()。
- type()不会认为子类是一种父类类型,不考虑继承关系。
- isinstance()会认为子类是一种父类类型,考虑继承关系。
- 如果第一个参数不是对象,则永远返回False。
- 如果第二个参数不是类或者由类对象组成的元组,会抛出一个TypeError异常。
演示代码如下:
a = 2
print(isinstance(a, int)) # True
print(isinstance(a, str)) # False
print(isinstance(a, (str, int, list))) # True
class A:
pass
class B(A):
pass
print(isinstance(A(), A)) # True
print(type(A()) == A) # True
print(isinstance(B(), A)) # True
print(type(B()) == A) # False
(3).hasattr(object, name)用于判断对象是否包含对应的属性。
演示代码如下:
class Coordinate:
x = 10
y = -5
z = 0
zmt = Coordinate()
print(hasattr(zmt, 'x')) # True
print(hasattr(zmt, 'y')) # True
print(hasattr(zmt, 'z')) # True
print(hasattr(zmt, 'no')) # False
(4).getattr(object, name[, default])用于返回一个对象属性值。
演示代码如下:
class A(object):
bar = 1
a = A()
print(getattr(a, 'bar')) # 1
print(getattr(a, 'bar2', 3)) # 3
print(getattr(a, 'bar2'))
# AttributeError: 'A' object has no attribute 'bar2'
例子:交换两数
演示代码如下:
class A(object):
def set(self, a, b):
x = a
a = b
b = x
print(a, b)
a = A()
c = getattr(a, 'set') #使A的对象a返回一个A的函数set(调用)
c(a='1', b='2') # 2 1
(4).setattr(object, name, value)对应函数 getattr(),用于设置属性值,该属性不一定是存在的。
演示代码如下:
class A(object):
bar = 1
a = A()
print(getattr(a, 'bar')) # 1
setattr(a, 'bar', 5)
print(a.bar) # 5
setattr(a, "age", 28)
print(a.age) # 28
(5).delattr(object, name)用于删除属性。
演示代码如下:
class Coordinate:
x = 10
y = -5
z = 0
t = Coordinate()
print('x = ', t.x) # x = 10
print('y = ', t.y) # y = -5
print('z = ', t.z) # z = 0
delattr(Coordinate, 'z')
print('x = ', t.x) # x = 10
print('y = ', t.y) # y = -5
# 触发错误
print('z = ', t.z)
# AttributeError: 'Coordinate' object has no attribute 'z'
(6).class property([fget[, fset[, fdel[, doc]]]])用于在新式类中返回属性值。
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
演示代码如下:
class C(object):
def __init__(self):
self.__x = None
def getx(self):
return self.__x
def setx(self, value):
self.__x = value
def delx(self):
del self.__x
x = property(getx, setx, delx, "I'm the 'x' property.")
cc = C()
cc.x = 2
print(cc.x) # 2
del cc.x
print(cc.x)
# AttributeError: 'C' object has no attribute '_C__x'