python-类

1、类

#新式类(后面会跟一个参数，用于单继承或者多继承的父类)
class MyNewObject(object):
    pass#pass表示不执行任何操作但是在语法上需要一行语句

#经典类（没有继承任何其他父类）
class MyNewObject:
    pass

2、类的实例化（实例对象的独有属性）

#类的实例化（函数调用的形式）
if __name__ == '__main__':
    myFirstObject = MyNewObject1()
    #实例对象的属性，而非类的属性
    #对于实例对象的独有属性实质上是动态的
    #这里只是借用了类的名称空间而已
    myFirstObject.x = 1
    myFirstObject.y = 2
    result = myFirstObject.x + myFirstObject.y
    print(result)

3、类的方法

调用方法的途径：

1、定义类和fangfa

2、实例化对象

3、通过实例调用方法

#类的方法
class MyClassWithMethod(object):
    #对于类中的方法都有self参数，这个参数代表实例对象本身
    #调用的时候不用传递
    def printFoo(self):
        print("you invoked printFoo")

if __name__ == '__main__':
     MyObj =  MyClassWithMethod()
     #self参数不用传递
     MyObj.printFoo()

4、类的实例化（定义构造器方法）

class student(object):
    #实例化对象的时候对init是一种隐式的调用
    def __init__(self,n,a):
        self.name = n
        self.age = a
        print("实例化对象",self.name)
    def update(self,a):
        self.age = a
        print("修改方法：",self.name)

if __name__ == '__main__':
    #自动调用init方法
    s1 = student('tom',12)
    s2 = student('jerry',34)
    print(s1.name)
    print(s1.age)
    #调用update
    s1.update(23)
    print(s1.age)
'''实例化对象 tom
实例化对象 jerry
tom
12
修改方法： tom
23
'''

5、使用子类

#定义student的子类
class student_1(student):
    def __init__(self,name,age,phone):
        #调用父类的构造方法
        student.__init__(self,name,age)
        #添加父类没有的属性方法
        self.phone = phone
    def updatePhone(self,phone):
        self.phone = phone
if __name__ == '__main__':
    ss1 = student_1('cr',13,12345)
    print(ss1.phone)
    ss1.updatePhone(111)
    print(ss1.phone)

实例化对象 cr
12345
111

6、类的数据属性

#类的数据属性（相当于静态变量，属于类，可以直接通过类访问，不用实例化）
#与类进行绑定，不依赖任何实例
class Object1(object):
    foo = 100

if __name__ == '__main__':
    print(Object1.foo)
    Object1.foo  +=1
    print(Object1.foo)
'''100
101'''

7、类中的方法都要通过实例对象来调用，否则都会调用失败，

8、查看类的属性方法

#查看类的属性方法
class Object1(object):
    foo = 100
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def fun1(self,c):
        self.b = c
if __name__ == '__main__':
    l = dir(Object1)
    print(l)
    '''['__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__', 'foo', 'fun1']
'''
    dict = Object1.__dict__
    print(dict)
    '''{'__module__': '__main__', 'foo': 100, '__init__': <function Object1.__init__ at 0x0000024ADCDD4840>, 'fun1': <function Object1.fun1 at 0x0000024ADCDD48C8>, '__dict__': <attribute '__dict__' of 'Object1' objects>, '__weakref__': <attribute '__weakref__' of 'Object1' objects>, '__doc__': None}
'''

9、解构器的使用（当实例化对象的引用次数为0的时候，清除该对象）

class P(object):
    def __del__(self):
        pass

class C(P):
    def __init__(self):
        print("实例化对象")
    def __del__(self):
        P.__del__(self)
        print("删除构造器")


if __name__ == '__main__':
    c1 = C()
    print(id(c1))
    c2 = c1
    print(id(c2))
    c3 = c1
    print(id(c3))
    del c1
    print("==")
    del c2
    print("==")
    del c3
    print("==")


'''
实例化对象
2759825420752
2759825420752
2759825420752
==
==
删除构造器
==


'''

10、使用默认参数构建构造器（实例化对象的时候，默认参数可以修改）

class HotelRoomCalc(object):
    def __init__(self,rt,sales=0.085,rm=0.1):
        self.salesTax = sales;
        self.roomTax = rm
        self.roomRate = rt

    def calcTotal(self,days = 1):
        daily = round((self.roomRate*(1+self.roomTax+self.salesTax)),2)
        return float(days)*daily

if __name__ == '__main__':
    #创建实例
    c1 = HotelRoomCalc(299)
    #日租金
    total = c1.calcTotal()
    print(total)
    #两天的租金
    total_2 = c1.calcTotal(2)
    print(total_2)
    #新创建的实例，修改默认参数
    c2 = HotelRoomCalc(189,0.086,0.058)
    totalDaily = c2.calcTotal()
    print(totalDaily)
    totalDaily2 = c2.calcTotal(2)
    print(totalDaily2)
'''
354.31
708.62
216.22
432.44
'''

11、从实例中访问类属性

'''
从实例中访问类变量的步骤是先访问实例的变量
然后访问类的变量
'''
if __name__ == '__main__':
    foo = Foo()
    #通过实例访问类变量
    print(foo.x)
    #这里是创建了一个实例变量
    foo.x = 0
    #再次访问类变量
    print(Foo.x)
    #再次访问x,这里访问的是实例的变量而不是类的变量
    print(foo.x)
    #删除实例属性
    del foo.x
    #又可以访问到类属性
    print(foo.x)
'''
1.5
1.5
0
1.5
'''

12、类属性为字典类型（可变模型）

点击打开链接

class Foo(object):
    x = {'teacher':'tome'}
if __name__ == '__main__':
    foo = Foo()
    #访问类属性
    print(foo.x)
    #添加实例属性（修改类属性）
    foo.x['student'] = 'kang'
    #访问实例属性
    print(foo.x)
    #访问类属性
    print(Foo.x)

'''
{'teacher': 'tome'}
{'teacher': 'tome', 'student': 'kang'}
{'teacher': 'tome', 'student': 'kang'}
'''

这里的实例属性由于没有遮蔽类属性，不能被删除掉

13、类属性的持久性

类属性相当于一个静态变量，独立于实例