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、类属性的持久性
类属性相当于一个静态变量,独立于实例