类和实例
class Animal(object):...
所有的类最终都继承自object类。
类是具有相同方法和属性的一组对象的集合。
class Animal(object):
pass
animal = Animal()
>>> animal = Animal() # 创建一个实例对象
>>> animal
<__main__.Animal at 0x1030a44d0>
animal = Animal(args)
>>> animal = Animal('dog1') # 传入参数 'dog1'
>>> animal.name # 访问对象的 name 属性
'dog1'
def __init__(self, name):...
class Animal(object):
def __init__(self, name): #初始化方法
self.name = name
def greet(self):
print 'Hello, I am %s.' % self.name
dog1.greet()
>>> dog1 = Animal('dog1')
>>> dog1.name
'dog1'
>>> dog1.greet()
Hello, I am dog1.
self.__name=name
访问控制
_a表示不要随意访问这个变量，虽然可以直接访问
__name外部不可直接访问
__name__特殊变量，可直接访问
class Animal(object):
def __init__(self, name):
self.__name = name
def greet(self):
print 'Hello, I am %s.' % self.__name
----------------------------
>>> dog1 = Animal('dog1')
>>> dog1.__name # 访问不了
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-206-7f6730db631e> in <module>()
----> 1 dog1.__name
AttributeError: 'Animal' object has no attribute '__name'
>>> dog1.greet() # 可以访问
Hello, I am dog1.
获取对象信息
type(obj)
isinstance(obj, class)
>>> dog1 = Animal('dog1')
>>> type(dog1) #获取对象类型
__main__.Animal
>>> isinstance(dog1, Animal)#对象是否为对应类型
True
hasattr(obj, attr)
getattr(obj, attr[, default])
setattr(obj, attr, value)
>>> hasattr(dog1, 'name')#对象是否有对应属性
True
>>> hasattr(dog1, 'x')
False
>>> hasattr(dog1, 'greet')#对象是否有对应方法
True
>>> getattr(dog1, 'name')#获取属性值
'dog1'
>>> getattr(dog1, 'greet')#获取方法
<bound method Animal.greet of <__main__.Animal object at 0x10c3564d0>>
>>> getattr(dog1, 'x')
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-241-42f5b7da1012> in <module>()
----> 1 getattr(dog1, 'x')
AttributeError: 'Animal' object has no attribute 'x'
>>> getattr(dog1, 'x', 'xvalue')#没有该属性时默认返回xvalue
'xvalue'
>>> setattr(dog1, 'age', 12)#设置属性值
>>> dog1.age
12
dir(obj)
#获取所有 方法名和属性 列表
>>> dir(dog1)
['__class__',
'__delattr__',
'__dict__',
'__doc__',
'__format__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'age',
'greet',
'name']
继承
class Dog(Animal):
子类可以在父类基础上覆盖和添加方法
class Animal(object):
def __init__(self, name):
self.name = name
def greet(self):
print 'Hello, I am %s.' % self.name
class Dog(Animal):
def greet(self):
print 'WangWang.., I am %s. ' % self.name
#结果
>>> animal = Animal('animal') # 创建 animal 实例
>>> animal.greet()
Hello, I am animal.
>>>
>>> dog = Dog('dog') # 创建 dog 实例
>>> dog.greet()
WangWang.., I am dog.
class Dog(Animal):
def greet(self):
print 'WangWang.., I am %s. ' % self.name
def run(self):
print 'I am running.I am running'
#结果
>>> dog = Dog('dog')
>>> dog.greet()
WangWang.., I am dog.
>>> dog.run()
I am running
多态
obj.method()
多态不同的对象对同一消息作出不同的响应
class Animal(object):
def __init__(self, name):
self.name = name
def greet(self):
print 'Hello, I am %s.' % self.name
class Dog(Animal):
def greet(self):
print 'WangWang.., I am %s.' % self.name
class Cat(Animal):
def greet(self):
print 'MiaoMiao.., I am %s' % self.name
def hello(animal):
animal.greet()
#结果
>>> dog = Dog('dog')
>>> hello(dog)
WangWang.., I am dog.
>>>
>>> cat = Cat('cat')
>>> hello(cat)
MiaoMiao.., I am cat
类方法
@classmethod=>cls.method()
上面都是通过实例来调用方法，Python 提供了@classmethod装饰器让我们也可以用类调用方法。
class A(object):
bar = 1
@classmethod
def class_foo(cls): #参数cls是class A(object):类本身
print 'Hello, ', cls
print cls.bar #我们可以直接调用类的方法
>>> A.class_foo() # 直接通过类来调用方法
Hello, <class '__main__.A'>
1
静态方法
@staticmethod=>cls.method()
某些不改变类和实例状态，但又和类有关系的方法。我们用@staticmethod来装饰。
class A(object):
bar = 1
@staticmethod
def static_foo(): #静态方法无cls参数，可以写到类外面，但这将不利于 代码的组织 和 命名空间的整洁
print 'Hello, ', A.bar
>>> a = A()
>>> a.static_foo()
Hello, 1
>>> A.static_foo()
Hello, 1
定制类和魔法方法
常见魔法方法(特殊方法)
__new__
__str__ , __repr__
__iter__
__getitem__ , __setitem__ , __delitem__
__getattr__ , __setattr__ , __delattr__
__call__
def __new__(cls):...=>obj=Class()
def __init__(self):...
__new__在__init__之前执行，我们可用此方法控制实例的创建过程。
class A(object):
_dict = dict()
def __new__(cls): # 类方法
if 'key' in A._dict:
print "EXISTS"
return A._dict['key']
else:
print "NEW"
return object.__new__(cls)
def __init__(self): # 实例方法
print "INIT"
A._dict['key'] = self
# 结果
>>> a1 = A()
NEW
INIT
>>> a2 = A()
EXISTS
INIT
>>> a3 = A()
EXISTS
INIT
def __str__(self)：...=>print(obj)
__str__可用于备注类的详细信息
class Foo(object):
def __init__(self, name):
self.name = name
def __str__(self): # 在打印对象时自动调用
return 'Foo object (name: %s)' % self.name
>>> print Foo('ethan') # 使用 print
Foo object (name: ethan)
>>>
>>> str(Foo('ethan')) # 使用 str
'Foo object (name: ethan)'
>>>
>>> Foo('ethan') # 直接显示
<__main__.Foo at 0x10c37a490>
def __repr__(self):...=>obj()
上面直接显示时还是默认信息，如果我们想让直接显示的也是备注的详细信息
class Foo(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Foo object (name: %s)' % self.name
def __repr__(self):
return 'Foo object (name: %s)' % self.name
>>> Foo('ethan')
'Foo object (name: ethan)'
或
class Foo(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Foo object (name: %s)' % self.name
__repr__ = __str__
def __iter__(self):...=>for i in obj:...
def __next__(self):...
让实例可用于for循环
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1
def __iter__(self): # 返回迭代器对象本身
return self
def next(self): # 返回容器下一个元素
self.a, self.b = self.b, self.a + self.b
return self.a
>>> fib = Fib()
>>> for i in fib:
... if i > 10:
... break
... print i
...
1
1
2
3
5
8
# -*- coding: utf-8 -*-
# @Time : 2021/6/18 21:33
# @Author : HUGBOY
# @File : HelloYoutube.py
# @Software: PyCharm
class fiber(object):
def __init__(self):
self.a, self.b = 0, 1
def __iter__(self):
return self
def __next__(self):
self.a, self.b = self.b, self.a + self.b
return self.a
f = fiber()
for i in f:
print(i, end="~")
if i >= 100:
break
# 结果
D:pythonpython.exe E:/PYTHON/Basics/Fun/HelloYoutube.py
1~1~2~3~5~8~13~21~34~55~89~144~
Process finished with exit code 0
def __getitem__(self):...=>obj[n]/obj[a:b]
实现用obj[n]方法来获取实例的值，如fiber数列。
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in xrange(n):
a, b = b, a + b
return a
>>> fib = Fib()
>>> fib[0], fib[1], fib[2], fib[3], fib[4], fib[5]
(1, 1, 2, 3, 5, 8)
# -*- coding: utf-8 -*-
# @Time : 2021/6/18 21:33
# @Author : HUGBOY
# @File : HelloYoutube.py
# @Software: PyCharm
class fiber(object):
def __getitem__(self, n):
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a
itemf = fiber()
print(itemf[0], itemf[6], itemf[10])
#结果
D:pythonpython.exe E:/PYTHON/Basics/Fun/HelloYoutube.py
0 8 55
Process finished with exit code 0
在上面的基础上实现分片slics
# -*- coding: utf-8 -*-
# @Time : 2021/6/18 21:33
# @Author : HUGBOY
# @File : HelloYoutube.py
# @Software: PyCharm
class sFiber():
def __getitem__(self, n):
if isinstance(n, int): #判断参数n是否为 int 类型
a, b = 0, 1
for i in range(n+1):
a, b = b, a + b
if i == n:
return a
if isinstance(n, slice):#判断参数n是否为 slice对象 类型
a, b = 0, 1
start, stop = n.start, n.stop
lis = []
for i in range(stop+1):
a, b = b, a + b
if i >= start:
lis.append(a)
return lis
sf = sFiber()
print(sf[2:9], sf[2], sf[9])
# 结果
D:pythonpython.exe E:/PYTHON/Basics/Fun/HelloYoutube.py
[2, 3, 5, 8, 13, 21, 34, 55] 2 55
Process finished with exit code 0
def __setitem__(self):...=>obj['key']=value/len(obj)
def __delitem__(self):...=>del obj['key']
类似def __getitem__(self):...获取值，它们分别用于设置值，删除值
class Point(object):
def __init__(self):
self.coordinate = {}
def __str__(self):
return "point(%s)" % self.coordinate
def __getitem__(self, key):
return self.coordinate.get(key)
def __setitem__(self, key, value):
self.coordinate[key] = value
def __delitem__(self, key):
del self.coordinate[key]
print 'delete %s' % key
def __len__(self):
return len(self.coordinate)
__repr__ = __str__
# 结果
>>> p = Point()
>>> p['x'] = 2 # 对应于 p.__setitem__('x', 2)
>>> p['y'] = 5 # 对应于 p.__setitem__('y', 5)
>>> p # 对应于 __repr__
point({'y': 5, 'x': 2})
>>> len(p) # 对应于 p.__len__
2
>>> p['x'] # 对应于 p.__getitem__('x')
2
>>> p['y'] # 对应于 p.__getitem__('y')
5
>>> del p['x'] # 对应于 p.__delitem__('x')
delete x
>>> p
point({'y': 5})
>>> len(p)
1
def __getattr__(self):...=>obj.x
当我们获取某个属性不存在时，会报错
class Point(object):
def __init__(self, x=0, y=0):
self.x = x
self.y = y
>>> p = Point(3, 4)
>>> p.x, p.y
(3, 4)
>>> p.z
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-547-6dce4e43e15c> in <module>()
----> 1 p.z
AttributeError: 'Point' object has no attribute 'z'
用__getattr__方法防止报错
class Point(object):
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __getattr__(self, attr):
if attr == 'z':#访问z,返回0，如果访问其他的如w会默认返回None
return 0
>>> p = Point(3, 4)
>>> p.z
0
还可以加入异常处理
def __getattr__(self, attr):
if attr == 'z':
return 0
raise AttributeError("Point object has no attribute %s" % attr)
def __setattr__(self):...=>obj.x=value
def __delattr__(self):...=>del obj.x
class Point(object):
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __getattr__(self, attr):
if attr == 'z':
return 0
raise AttributeError("Point object has no attribute %s" % attr)
def __setattr__(self, *args, **kwargs):
print 'call func set attr (%s, %s)' % (args, kwargs)
return object.__setattr__(self, *args, **kwargs)
def __delattr__(self, *args, **kwargs):
print 'call func del attr (%s, %s)' % (args, kwargs)
return object.__delattr__(self, *args, **kwargs)
>>> p = Point(3, 4)
call func set attr (('x', 3), {})
call func set attr (('y', 4), {})
>>> p.z
0
>>> p.z = 7
call func set attr (('z', 7), {})
>>> p.z
7
>>> p.w
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 8, in __getattr__
AttributeError: Point object has no attribute w
>>> p.w = 8
call func set attr (('w', 8), {})
>>> p.w
8
>>> del p.w
call func del attr (('w',), {})
>>> p.__dict__
{'y': 4, 'x': 3, 'z': 7}
def __call__(self):...=>callable(obj)
一般用obj.method()调用对象，我们也可以用callable()直接在实例本身上调用
class Point(object):
def __init__(self, x, y):
self.x, self.y = x, y
def __call__(self, z):
return self.x + self.y + z
# 结果
>>> p = Point(3, 4)
>>> callable(p) # 使用 callable 判断对象是否能被调用
True
>>> p(6) # 传入参数，对实例进行调用，对应 p.__call__(6)
13 # 3+4+6
slots 魔法
obj.new_x=value
给实例绑定新的属性和方法
class Point(object):
def __init__(self, x=0, y=0):
self.x = x
self.y = y
>>> p = Point(3, 4)
>>> p.z = 5 # 绑定了一个新的属性
>>> p.z
5
>>> p.__dict__
{'x': 3, 'y': 4, 'z': 5}
def __slots__(self):...=>obj.some_x=value
限制绑定的属性
class Point(object):
__slots__ = ('x', 'y') # 只允许使用 x 和 y
def __init__(self, x=0, y=0):
self.x = x
self.y = y
>>> p = Point(3, 4)
>>> p.z = 5
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-648-625ed954d865> in <module>()
----> 1 p.z = 5
AttributeError: 'Point' object has no attribute 'z'
注意：子类只有使用slots魔法后才会继承父类的slots元组,组成tuple=child_slots_tuple+father_slots_tuple
@property=>obj.method
@method.setter=>obj.method=value
被@property装饰器，装饰过的方法可以当做属性来用
class Exam(object):
def __init__(self, score):
self._score = score
@property
def score(self):
return self._score
@score.setter
def score(self, val):
if val < 0:
self._score = 0
elif val > 100:
self._score = 100
else:
self._score = val
>>> e = Exam(60)
>>> e.score
60
>>> e.score = 90
>>> e.score
90
>>> e.score = 200
>>> e.score
100
也可以不用@score.setter赋值装饰器
class Exam(object):
def __init__(self, score):
self._score = score
@property
def score(self):
return self._score
>>> e = Exam(60)
>>> e.score
60
>>> e.score = 200 # score 是只读属性，不能设置值
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-676-b0515304f6e0> in <module>()
----> 1 e.score = 200
AttributeError: can't set attribute