国内有一档很火的相亲节目，不知你看过没？相亲环节大概是这样的：台上站着一排美女，每个美女面前都有一个唯一编号(如NO.1)。一男的从电梯里出来，然后面向1至11号美女对象，面向对象。然后男的经过一番秀(背景秀、才艺秀、印象秀等）之后，美女用按灯的方法，决定男的去留。

不知你注意到没，相亲的人，是同一类人，都是未婚的人，都是光棍，都是单身狗。

在面向对象编程语言(C++、Java、C#、Python等)中，就是把相同性质(都是单身狗)的事物归成一类，再从类中实例化到那个对象(如：1号美女)，美其名曰面向对象编程。

面向对象，让零散的函数成为整体，它将现实世界的事物抽象成对象，描叙其在整个解决问题的步骤中的行为，贴近现实生活中对事物的描述，更有利于人们对复杂系统进行分析、设计和编程。

8.1 类和对象

面向对象中，类和对象是两个非常重要的角色。类是对具有相同特性和行为的对象的抽象，如单身狗。在Python语言中，类使用class关键字+类名+冒号：结尾的方式创建。类名用大写字母开头。类的实例化(具体化)就是对象，如1号美女。

# 定义单身狗类class SingleDog:    def __init__(self, num):        self.num = num    # 按下灯    def push(self):        print("%d号美女灭灯" % self.num)        return True# 对象1：1号美女singleDog = SingleDog(1)singleDog.push()# 对象2：2号美女singleDog = SingleDog(2)singleDog.push()

输出结果

1号美女灭灯2号美女灭灯

不知你明白了，单身狗程序员。

8.2 实例方法

在类里，定义方法时，如果第一个参数是self，表示这个方法为实例方法。实例方法，只能通过对象和.的方式进行调用。

以__init__命名的方法，是类的构造方法，它有且只能有一个，默认为：__init__()。

有构造就有析构，析构方法是以__del__命名的。默认为:__del__()，它经常用来释放资源，如断开数据库连接。

# 定义一个类class Product:    # 产品编号    num = 168168# 构造方法    def __init__(self):        print("创建时调用")    # 实例方法    def get_num(self):        return self.num    # 析构方法    def __del__(self):        print("销毁时调用")# 实例化并调用方法p = Product()print(p.get_num())

输出结果

创建时调用168168销毁时调用

静态方法，通过类名和.直接调用，不需要创建对象。方法里，不用self参数。用@staticmethod装饰器声明。当然，用实例对象也是可以调用的。

# 定义一个订单类class Order:    # 静态方法    @staticmethod    def get_title():        return "好大一个单"# 实例化并调用方法order = Order()print(order.get_title())# 直接用类名调用print(Order.get_title())

输出结果

好大一个单好大一个单

类方法，在Python中使用较少，类方法传入的第一个参数为cls，是类本身。类方法可以通过类名或实例名调用。类方法@classmethod装饰器和cls参数声明。

# 定义一个客户类class Customer:    # 类方法    @classmethod    def get_name(cls):        return "西门吹水"# 实例化并调用方法c = Customer()print(c.get_name())# 直接用类名调用print(Customer.get_name())

输出结果

西门吹水西门吹水

实例方法第一个参数永远是self，类方法第一个参数永远是 cls，而静态方法没有任何必选参数。

静态方法不会访问到class 本身 ，它只是一个函数，没有访问对象和它的内部(属性和其他方法)，而实例方法会访问self，类方法会访问 cls。

实例方法只能被实例对象访问。而静态方法、类方法既可被类访问，也可以被实例对象访问。

# 类里的各种方法class Employee:    # 构造方法    def __init__(self, name, address):        self.name = name        self.address = address    # 实例方法    def get_address(self):        return self.address    # 静态方法    @staticmethod    def get_name():        return "西门吹水"    # 类方法    @classmethod    def get_age(cls):        return 38# 析构方法def __del__(self):    print("释放资源")# 实例化c = Employee("程序员", "今日头条：老陈说编程")# 静态方法print(Employee.get_name())# 实力方法print(c.get_address())# 直接用类名调用print(Employee.get_age())

输出方法

西门吹水今日头条：老陈说编程38

数据封装是面向对象编程的一个重要特点，它通过限制访问，对数据进行保护。封装，即是在类内部，将某些不想被外部访问或调用的部分内容隐藏起来，如若外部要调用，只能通过公开的接口进行。Python语言没有private、protected这些关键字, 它用双下划线__表示私有类型(private)的属性或方法。以单下划线_开头的表示的是protected 类型的属性和方法。

# 定义一个员工类class Employee:    # 私有属性    __age = 18    # 私有属性    __address = "广东"    # 公有属性    phone = 12345678910    def __init__(self, name):        self.name = name    # 公有方法    def get_age(self):        return self.__age    # 公有方法    def get_name(self):        return self.name    # 私有方法    def __get_address(self):        return self.__addresse = Employee("王二麻子")print(e.phone)print(e.get_name())print(e.get_age())# 私有属性和方法不可调用# print(e.__age())# print(e.__get_address())

其实Python并没有真正的私有属性或方法，通过对象._类名__私有属性名或对象._类名__私有方法名，就可以访问私有属性或私有方法。

# 定义一个员工类class Employee:    # 私有属性    __name = "酷哥"    # 私有方法    def __get_age(self):        return 18e = Employee()# 私有属性或方法都可以访问print(e._Employee__name)print(e._Employee__get_age())

输出结果

酷哥18

Python语言中没有NULL值，有None值。Nono不是空，也不是0。它也是一种数据类型NoneType。判断一个对象是否为None值，可通过is进行。

# None值n = Noneprint(n)print(type(n))if n is None:    print("对象不存在")else:    print("对象存在")# --not is 为反过来的判断—if n is not None:    print("对象存在")else:    print("对象不存在")

输出结果

None<class 'NoneType'>对象不存在对象不存在

即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

class ClassName(基类):

# 类定义class People:    # 定义基本属性    name = ''    age = 0    # 私有属性，体重(公斤)    __weight = 0    # 定义构造方法    def __init__(self, n, a, w):        self.name = n        self.age = a        self.__weight = w    def speak(self):        print("%s说:我%d岁。" % (self.name, self.age))# 单继承示例class Teacher(People):    grade = ''    def __init__(self, n, a, w, g):        # 调用父类的构函        People.__init__(self, n, a, w)        self.grade = g    # 覆写父类的方法    def speak(self):        print("%s说: 我%d岁了，我在教%d年级" % (self.name, self.age, self.grade))s = Teacher('marry', 30, 65, 6)s.speak()

输出结果

marry说: 我30岁了，我在教6年级

请注意，请注意，Python可支持多继承，语法是：class ClassName(基类1, 基类2, 基类3):

8.9 方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。可用super() 函数调用父类(超类)的方法。

# 定义父类class Parent:    def m(self):        print('调用父类方法')class Child(Parent):  # 定义子类    def m(self):        print('调用子类方法')c = Child()  # 子类实例c.m()  # 子类调用重写方法super(Child, c).m()

输出结果

调用子类方法调用父类方法

判断两个标识符是否引用同一个对象时,可以用is进行比较，还可以用相反的方式，is not进行比较。is 跟 == 的区别是：is用于判断两个变量是否引用同一个对象，==是比较两个变量的值是否相等。可通过id()函数获得对象引用地址。

# 定义父类class Parent:    def m(self):        print('调用父类方法')class Child(Parent):  # 定义子类    def m(self):        print('调用子类方法')p = Parent()c = Child()     # 子类实例print(c is p)# 数组a = (5, 6, 8)b = aprint(id(a), id(b))print(a is b)print(a, "==", b)print(a == b)

输出结果

False140317976246976 140317976246976True(5, 6, 8) == (5, 6, 8)True

好了，有关面向对象的内容，老陈讲完了，如果觉得对你有所帮助，希望老铁能转发点赞，让更多的人看到这篇文章。你的转发和点赞，就是对老陈继续创作和分享最大的鼓励。

一个当了10年技术总监的老家伙，分享多年的编程经验。想学编程的朋友，可关注今日头条：老陈说编程。我将分享Python，前端(小程序)和App方面的编程知识。关注我，没错的。

8.11 枚举类型

枚举语法跟类差不多，放在一起学习效果更好。 枚举(Enum)跟整型一样，是一种数据类型。它是一系列常量的集合，通常用于表示某些特定的有限集合，如月份、星期、状态、性别(男、女、不男不女)等，当一个变量有几种可能取值的时候，定义为枚举类型。

1. 枚举定义

枚举是不可变类型，一旦定义创建，其成员的值不可改变，名称不可重复，通过class关键字和继承Enum类进行定义。定义时若出现成员的值相同，那只有第一个有效，其语法结构为：

class 枚举名(Enum):

成员名1 = 值1

成员名x = 值n

# ---引入枚举类---from enum import Enumclass Colors(Enum):    red = 1    orange = 2    yellow = 3    green = 4    red_alias = 1print(Colors(1))

输出结果

Colors.red

2. 整型枚举

枚举成员的值支持多种数据类型，如字符串、布尔或整型等，如要指定为整型，可继承IntEnum类。注意，就算指定为IntEnum,其成员的值照样可以为字符串等，但在获取成员的值时，会进行自动转换，如果转换失败，会报错。当然，既然指定为整型了，就不要故意指定为字符串等了。

# ---引入枚举类---from enum import Enum, IntEnum# 字符串枚举class Gender(Enum):    Male = "男"    Female = "女"    Unknown = "保密"    print(Gender.Male.value)# 整型枚举class Number(IntEnum):    One = 1    Two = 2    # 会自动转为整型    Three = "3"print(Number.Three.value)

输出结果

男3

3. 唯一值

如果要限制定义枚举时，不能定义相同值的成员。可以使用装饰器@unique进行限制。如若出现相同值，运行时会报错。

# 引入枚举类和唯一装饰器from enum import Enum, unique@uniqueclass Weekday(Enum):    Sun = 0    Mon = 1    Tue = 2    Wed = 3    Thu = 4    Fri = 5    Sat = 6print(Weekday.Sat.value)

输出结果

6

4. 枚举取值

枚举可通过成员获取它的名称和值，可通过名称或值获取成员。

# 引入枚举类和唯一装饰器from enum import Enum, unique@uniqueclass Months(Enum):    Jan = 1    Feb = 2    Mar = 3    Apr = 4    May = 5    Jun = 6    Jul = 7    Aug = 8    Sep = 9    Oct = 10    Nov = 11    Dec = 12# 通过成员获取名称和值print(Months.Jan.name, Months.Jan.value)# 通过名称和值获取成员print(Months["Feb"], Months(2))

输出结果

Jan 1Months.Feb Months.Feb

5. 枚举遍历

通过for循环遍历枚举成员时，如若出现成员的值相同时，只获取第一个成员。当然，如果要遍历所有成员的话，得用特殊的方式获取，就是通过__menbers__属性。

# ---引入枚举类---from enum import Enumclass Colors(Enum):    red = 1    orange = 2    yellow = 3    green = 4    red_alias = 1# 获取成员名称，值相等的,只获取第一个for color in Colors:    print(color.name)# 获取所有成员名称for color in Colors.__members__:    print(color)

输出结果

redorangeyellowgreenredorangeyellowgreenred_alias

6. 枚举比较

枚举成员不可以比较大小，但可以通过is、is not 和==、！=进行同性或等值比较。

# ---引入枚举类---from enum import Enumclass Colors(Enum):    red = 1    orange = 2    yellow = 3    green = 4    red_alias = 1# is 判断result = Colors.red is Colors.redprint(result)# is not判断result = Colors.red is not Colors.greenprint(result)# ==比较值是否相等result = Colors.red == Colors.red_aliasprint(result)# !=比较值是否不相等result = Colors.red != Colors.greenprint(result)

输出结果

TrueTrueTrueTrue

7. 类中枚举

枚举可以定义在类里，并可通过类名和枚举名进行调用。

# ---引入枚举类---from enum import Enumclass Plane:    def __init__(self, color):        self.color = color    # 类的成员    class Colors(Enum):        Red = 1        Orange = 2        Yellow = 3        Green = 4        Blue = 5plane = Plane(Plane.Colors.Blue.value)print(plane.color)

输出结果

5

好了，有关枚举类型的内容，老陈讲完了，如果觉得对你有所帮助，希望老铁能转发点赞，让更多的人看到这篇文章。你的转发和点赞，就是对老陈继续创作和分享最大的鼓励。

一个当了10年技术总监的老家伙，分享多年的编程经验。想学编程的朋友，可关注今日头条：老陈说编程。我将分享Python，前端(小程序)和App方面的编程知识。关注我，没错的。

#Python##Python编程从入门到实践##程序员#