Python类和对象

Python是一种面向对象语言，有其三大特性，封装，继承，多态

一.

1.类

具有相同属性和行为特征的对象的集合

class Car:
    name="car"  #对象

    #初始化方法
    def __init__(self,brand=None):
        self.brand=brand

    def printCar(self):
        print(self)

2.对象

对象是类的实例，具有类的属性和方法

c=Car("奥迪") #实例化对象
c.printCar() #调用方法

3.创建对象方法

    def __new__(cls, *args, **kwargs):
        print("创建对象")
        return object.__new__(cls,args)

在Python中，在创建对象的时候调用__new__方法，并执行初始化__init__方法

如果，初始化方法有参数，__new__方法return时，args必须也对应加上

4.转化字符串方法(ToString):

输出时，默认调用__str__方法

    def __str__(self):
        return "这辆%s的品牌是%s"%(self.name,self.brand)

5.自动销毁方法(析构）

在使用del 删除对象或对象使用完毕时，垃圾回收自动销毁对象

    def __del__(self):
        print("对象销毁了")

二.继承（Python支持多继承）

1.语法: class Student(object）

继承条件下调用父类的属性或方法:

1>父类类名.属性

2>super([父类类名，self]).__init__(self,属性)

3>父类类名.__init__（属性)

2.多继承

class C(A,B)

查找顺序: 参数A写在前，就先从A类中查找属性或方法，如果A中有，就执行A的属性或方法

如果A中没有，就去B中找，执行B的

拓展:

首先，B和C两个类都必须继承自D，A类又继承自B、C,那么执行A的属性或方法会涉及到

广度优先和深度优先

当声明D类时，如果继承Object，子类则为新生类，反之，为经典类

当类为经典类是，按照深度优先

当类为新生类时，按照广度优先

课堂案例:

1.单例模式

#单例
class SingleObject:
    __instance=None
    def __new__(cls, *args, **kwargs):
        if cls.__instance ==None:
            cls.__instance=object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance
a=SingleObject()
b=SingleObject()
print(id(a),id(b))

2.对象排序

#对象排序
class Car:
    def __init__(self,brand=None,price=None):
        self.brand=brand
        self.price=price
    def __str__(self):
        return "汽车的品牌{0},价格{1}".format(self.brand,self.price)
list=[Car('宝马',3000000),Car('奥迪',4000000),Car('奔驰',3500000),Car('英菲尼迪',100000000)]
list.sort(key=lambda x:x.brand.encode("gbk"))
for i in list:
    print(i)
print("==========按价格排序=========")
list.sort(key=lambda x:x.price)
for i in list:
    print(i)

key = lambda x: x.price
print(key(list[1]))

猜你喜欢