[root@kube method]# cat demo2.py 
class Person:
    pass

print(dir(Person))   #使用dir 函数查看内建属性
[root@kube method]# py demo2.py 
[‘__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__‘]
[root@kube method]# 

1.__init__方法使用与功能：
  1.用来构造初始化函数,用来给类的实例进行初始化属性，所以可以不需要返回值
  2.在创建类的实例时系统自动调用
  3.自定义类如果不定义的话，默认调用父类object的，同理继承也是，子类若无，调用父类，若有，调用自己的
class Student(object):
    def __init__(self,name):
        self.name = name
        print("这是__init__方法")
 
s = Student("tom")  
‘‘‘
这是__init__方法

2.__new__方法使用与功能
  1.__new__功能：用所给类创建一个对象，并且返回这个对象。
  2.因为是给类创建实例，所以至少传一个参数cls,参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
  3.在类实例化时内部创建类实例的函数，并且返回这个实例，所以它是类实例时最先被调用的方法，一般不要人为定义该方法。
  4.因为要创建实例返回实例，所以要有返回值。return父类__new__出来的实例，或者直接是object的__new__出来的实例   
 
 
class Student(object):
    def __init__(self,name):
        self.name = name
        print("这是__init__方法")
 
    def __new__(cls, *args, **kwargs):
        print("这是__new__方法")
        return object.__new__(cls)
 
s = Student("tom")
‘‘‘结果如下：注意__new__的执行顺序在__init__之前
这是__new__方法
这是_init__方法
‘‘‘
 
3.__init__和__new__使用的联系
  1.__init__第一个参数是self，表示需要初始的实例，由python解释器自动传入，而这个实例就是这个__new__返回的实例
#那么理解就是在类实例化的过程中需要先通过__new__  进行实列化返回一个实例，然后这个实例再有 __init__进行实例初始化

[root@kube method]# cat demo5.py 
#coding:utf-8

class test:
    def __new__(cls,name,age):    #先通过__new__ 内置属性定义实列，然后交给 init 初始化实例，如果__new__ 没有完成后面就不会进行
        if 0 < age < 50:
            return object.__new__(cls)
        else:
            return None

    def __init__(self,name,age):
        
        print(‘__init__ age:‘, age)

a = test(‘aaa‘,30)
b = test(‘aaifffa‘,100)
[root@kube method]# py demo5.py 
__init__ age: 30
[root@kube method]# 

3.__init__和__new__使用的联系
  1.__init__第一个参数是self，表示需要初始的实例，由python解释器自动传入，而这个实例就是这个__new__返回的实例
  2.然后 __init__在__new__的基础上可以完成一些其它初始化的动作
 
class Student(object):
    def __init__(self,name):
        self.name = name
        print("这是__init__方法")
 
    def __new__(cls, *args, **kwargs):
        print("这是__new__方法")
        id =object.__new__(cls)
        print(id) #打印这个__new__创建并返回的实例在内存中的地址
        return id
s1 = Student("JACK")
print(s1)
‘‘‘
这是__new__方法
<__main__.Student object at 0x000001EC6C8C8748>
这是__init__方法
<__main__.Student object at 0x000001EC6C8C8748>
‘‘‘
 

[root@kube method]# cat demo6.py 
class Item:
    def __init__ (self, name, price):
        self.name = name
        self.price = price
# 创建一个Item对象，将之赋给im变量
im = Item(‘鼠标‘, 29.8)
# 打印im所引用的Item对象
print(im)
print(im.__repr__)
[root@kube method]# py demo6.py 
<__main__.Item object at 0x7f7628881290>
<method-wrapper ‘__repr__‘ of Item object at 0x7f7628881290>
[root@kube method]# 

[root@kube method]# cat demo7.py 
#coding:utf-8

class Apple:
    def __init__(self,color,weight):
        self.color = color
        self.weight = weight
    def __repr__(self):
        return ‘Apple class‘+self.color+str(self.weight)

a = Apple(‘red‘,8.88)
print(a)
[root@kube method]# py demo7.py 
Apple classred8.88
[root@kube method]# 
#__repr__() 是一个非常特殊的方法，它是一个“自我描述”的方法，该方法通常用于实现这样一个功能：当程序员直接打印该对象时，系统将会输出该对象的“自我描述”信息，用来告诉外界该对象具有的状态信息。

与 __init__() 方法对应的是 __del__() 方法，__init__() 方法用于初始化 Python 对象，而 __del__() 则用于销毁 Python 对象，即在任何 Python 对象将要被系统回收之时，系统都会自动调用该对象的 __del__() 方法。

当程序不再需要一个 Python 对象时，系统必须把该对象所占用的内存空间释放出来，这个过程被称为垃圾回收（GC，Garbage Collector），Python 会自动回收所有对象所占用的内存空间，因此开发者无须关心对象垃圾回收的过程。
Python 采用自动引用计数（ARC）方式来回收对象所占用的空间，当程序中有一个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 1；当程序中有两个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 2，依此类推，如果一个对象的引用计数变成了 0，则说明程序中不再有变量引用该对象，表明程序不再需要该对象，因此 Python 就会回收该对象。

大部分时候，Python 的 ARC 都能准确、高效地回收系统中的每个对象。但如果系统中出现循环引用的情况，比如对象 a 持有一个实例变量引用对象 b，而对象 b 又持有一个实例变量引用对象 a，此时两个对象的引用计数都是 1，而实际上程序已经不再有变量引用它们，系统应该回收它们，此时 Python 的垃圾回收器就可能没那么快，要等专门的循环垃圾回收器（Cyclic Garbage Collector）来检测并回收这种引用循环。

当一个对象被垃圾回收时，Python 就会自动调用该对象的 __del__ 方法。需要说明的是，不要以为对一个变量执行 del 操作，该变量所引用的对象就会被回收，只有当对象的引用计数变成 0 时，该对象才会被回收。因此，如果一个对象有多个变量引用它，那么 del 其中一个变量是不会回收该对象的。

[root@kube method]# cat demo8.py 
class Item:
    def __init__ (self, name, price):
        self.name = name
        self.price = price
    # 定义析构函数
    def __del__ (self):
        print(‘del删除对象‘)
# 创建一个Item对象，将之赋给im变量
im = Item(‘鼠标‘, 29.8)
x = im   # ①
# 打印im所引用的Item对象
del im
print(‘--------------‘)
[root@kube method]# py demo8.py 
--------------
del删除对象
[root@kube method]# 

[root@kube method]# cat demo9.py 
class Item:
    def __init__ (self, name, price):
        self.name = name
        self.price = price
    def info ():
        pass
# 创建一个Item对象，将之赋给im变量
im = Item(‘鼠标‘, 29.8)
print(im.__dir__())  # 返回所有属性（包括方法）组成列表
print(‘----------------------------------------------------------------‘)
print(dir(im))  # 返回所有属性（包括方法）排序之后的列表
[root@kube method]# py demo9.py 
[‘name‘, ‘price‘, ‘__module__‘, ‘__init__‘, ‘info‘, ‘__dict__‘, ‘__weakref__‘, ‘__doc__‘, ‘__repr__‘, ‘__hash__‘, ‘__str__‘, ‘__getattribute__‘, ‘__setattr__‘, ‘__delattr__‘, ‘__lt__‘, ‘__le__‘, ‘__eq__‘, ‘__ne__‘, ‘__gt__‘, ‘__ge__‘, ‘__new__‘, ‘__reduce_ex__‘, ‘__reduce__‘, ‘__subclasshook__‘, ‘__init_subclass__‘, ‘__format__‘, ‘__sizeof__‘, ‘__dir__‘, ‘__class__‘]
----------------------------------------------------------------
[‘__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__‘, ‘info‘, ‘name‘, ‘price‘]
[root@kube method]# 

[root@kube method]# cat demo10.py 
#coding:utf-8

class Item:
    def __init__(self, name ,price):
        self.name = name
        self.price = price
im = Item(‘computer‘,10000)

print(im.__dict__)
print(im.__dict__[‘name‘])

im.__dict__[‘name‘] = ‘鼠标‘
print(im.__dict__[‘name‘])

[root@kube method]# py demo10.py 
{‘name‘: ‘computer‘, ‘price‘: 10000}
computer
鼠标
[root@kube method]# 

在动态检查对象是否包含某些属性（包括方法〉相关的函数有如下几个：
hasattr(obj, name)：检查 obj 对象是否包含名为 name 的属性或方法。
getattr(object, name[, default])：获取 object 对象中名为 name 的属性的属性值。
setattr(obj, name, value，/)：将obj 对象的 name 属性设为 value。

下面程序示范了通过以上函数来动态操作 Python 对象的属性：

[root@kube method]# cat demo11.py 
class Comment:
    def __init__ (self, detail, view_times):
        self.detail = detail
        self.view_times = view_times
    def info ():
        print("一条简单的评论，内容是%s" % self.detail)
       
c = Comment(‘疯狂Python讲义很不错‘, 20)
# 判断是否包含指定的属性或方法
print(hasattr(c, ‘detail‘)) # True
print(hasattr(c, ‘view_times‘)) # True
print(hasattr(c, ‘info‘)) # True
# 获取指定属性的属性值
print(getattr(c, ‘detail‘)) # ‘疯狂Python讲义很不错‘
print(getattr(c, ‘view_times‘)) # 20
# 由于info是方法，故下面代码会提示：name ‘info‘ is not defined
#print(getattr(c, info, ‘默认值‘))
# 为指定属性设置属性值
setattr(c, ‘detail‘, ‘天气不错‘)
setattr(c, ‘view_times‘, 32)
# 输出重新设置后的属性值
print(c.detail)
print(c.view_times)
[root@kube method]# py demo11.py 
True
True
True
疯狂Python讲义很不错
20
天气不错
32
[root@kube method]# 

[root@kube method]# cat demo12.py 
# 定义一个字符串
hello = "Hello";
# "Hello"是str类的实例，输出True
print(‘"Hello"是否是str类的实例: ‘, isinstance(hello, str))
# "Hello"是object类的子类的实例，输出True
print(‘"Hello"是否是object类的实例: ‘, isinstance(hello, object))
# str是object类的子类，输出True
print(‘str是否是object类的子类: ‘, issubclass(str, object))
# "Hello"不是tuple类及其子类的实例，输出False
print(‘"Hello"是否是tuple类的实例: ‘, isinstance(hello, tuple))
# str不是tuple类的子类，输出False
print(‘str是否是tuple类的子类: ‘, issubclass(str, tuple))
# 定义一个列表
my_list = [2, 4]
# [2, 4]是list类的实例，输出True
print(‘[2, 4]是否是list类的实例: ‘, isinstance(my_list, list))
# [2, 4]是object类的子类的实例，输出True
print(‘[2, 4]是否是object类及其子类的实例: ‘, isinstance(my_list, object))
# list是object类的子类，输出True
print(‘list是否是object类的子类: ‘, issubclass(list, object))
# [2, 4]不是tuple类及其子类的实例，输出False
print(‘[2, 4]是否是tuple类及其子类的实例: ‘, isinstance([2, 4], tuple))
# list不是tuple类的子类，输出False
print(‘list是否是tuple类的子类: ‘, issubclass(list, tuple))
[root@kube method]# py demo12.py 
"Hello"是否是str类的实例:  True
"Hello"是否是object类的实例:  True
str是否是object类的子类:  True
"Hello"是否是tuple类的实例:  False
str是否是tuple类的子类:  False
[2, 4]是否是list类的实例:  True
[2, 4]是否是object类及其子类的实例:  True
list是否是object类的子类:  True
[2, 4]是否是tuple类及其子类的实例:  False
list是否是tuple类的子类:  False
[root@kube method]# 

[root@kube method]# cat demo13.py 
#coding:utf-8

class A:
    pass
class B(A):
    pass
class C(A):
    pass
#类的 __bases__ 属性查看该类的直接父类
print(‘类A 的所有父类:‘,A.__bases__)
print(‘类B 的所有父类:‘,B.__bases__)
print(‘类C 的所有父类:‘,C.__bases__)
#类的 __subclasses_() 方法。查看该类的所有直接子类

print(‘类A 的子类：‘,A.__subclasses__())
print(‘类B 的子类：‘,B.__subclasses__())
[root@kube method]# py demo13.py 
类A 的所有父类: (<class ‘object‘>,)
类B 的所有父类: (<class ‘__main__.A‘>,)
类C 的所有父类: (<class ‘__main__.A‘>,)
类A 的子类： [<class ‘__main__.B‘>, <class ‘__main__.C‘>]
类B 的子类： []
[root@kube method]#