面向对象程序设计（Object Oriented Programming，OOP）的思想主要针对大型软件设计而提出，它使得软件设计更加灵活，能够很好地支持代码复用和设计复用，并且使得代码具有更好的可读性和可扩展性。Python完全采用了面向对象程序设计的思想，是真正面向对象的高级动态编程语言，完全支持面向对象的基本功能。因此，掌握面向对象程序设计思想至关重要。

1.面向对象概念

在面向对象编程中，最重要的两个概念就是类和对象（也称为实例）。

对象是某个具体存在的事物，例如，一个名叫“Jack”的学生就是一个对象。

与对象相比，类是抽象的，它是对一群具有相同特征和行为的事物的统称。例如，学校的学生，其特征包括“学号”“姓名”“性别”等，其行为包括“选课”“上课”“考试”等。

类即类别/种类，是面向对象分析和设计的基石，如果多个对象有相似的数据与功能，那么该多个对象就属于同一种类。

有了类的好处是：我们可以把同一类对象相同的数据与功能存放到类里，而无需每个对象都重复存一份，这样每个对象里只需存自己独有的数据即可，极大地节省了空间。所以，如果说对象是用来存放数据与功能的容器，那么类则是用来存放多个对象相同的数据与功能的容器

2.类的定义和对象的产生

1类的定义

面向对象程序设计思想是把事物的特征和行为包含在类中。其中，事物的特征作为类中的变量，事物的行为作为类的方法，而对象是类的一个实例。定义类的基本语法格式如下：

class 类名:
    类体

注意：

（1）类名的首字母一般需要大写，如Car。

（2）类体一般包括变量的定义和方法的定义。

（3）类体相对于class关键字必须保持一定的空格缩进。

#定义类
class Car:	
    price = 150000		#定义价格变量
    def run(self):		#定义行驶方法
        print(‘车在行驶中……‘)

2.创建类的对象

在Python中，创建对象的语法格式如下：

对象名 = 类名()

创建完对象后，可以使用它来访问类中的变量和方法，具体方法是：

对象名.类中的变量名
对象名.方法名([参数])

例：为前面定义的Car类创建一个car_1对象，并访问类中的变量和方法。

class Car:	
    price = 150000		#定义价格变量
    def run(self):		#定义行驶方法
        print(‘车在行驶中……‘)
car_1 = Car()		#创建一个对象，并用变量car_1保存它的引用
car_1.run()		#调用run()方法
print(‘车的价格是：‘,car_1.price)	#访问类中的变量

程序运行效果

3.self参数

类的所有方法都必须至少有一个名为self的参数，并且必须是方法的第1个参数。

在Python中，由同一个类可以生成无数个对象，当一个对象的方法被调用时，对象会将自身的引用作为第一个参数传递给该方法，那么Python就知道需要操作哪个对象的方法了。

注意：

在类的方法中访问变量时，需要以self为前缀，但在外部通过对象名调用对象方法时不需要传递该参数。

例：self的使用。

class Car:	
    def colour(self,col):			#定义赋值颜色方法
        self.col=col				#赋值
    def show(self):				#定义显示颜色方法
        print(‘The color of the car is %s.‘%self.col)	#输出颜色
car_1 = Car()				#创建对象car_1
car_1.colour(‘red‘)				#调用方法
car_2 = Car()				#创建对象car_2
car_2.colour(‘white‘)			#调用方法
car_1.show()				#调用方法
car_2.show()				#调用方法

程序运行结果：

4.构造方法 __ init __ ()

构造方法的固定名称为__ init __ ()，当创建类的对象时，系统会自动调用构造方法，从而实现对对象进行初始化的操作。

例：使用构造方法。

#定义类
class Car:
#构造方法
    def __init__(self):
        self.wheelNum = 4
        self.colour = ‘蓝色‘
#方法
    def run(self):
        print(‘{}个*的{}车在行驶中……‘.format(self.wheelNum, self.colour))
BMW = Car()				#创建对象
BMW.run()				#调用方法

程序运行结果：

例：使用带参构造方法。

#定义类
class Car:
#构造方法
    def __init__(self,wheelNum,colour):
        self.wheelNum = wheelNum
        self.colour = colour
#方法
    def run(self):
        print(‘{}个*的{}车在行驶中……‘.format(self.wheelNum, self.colour))
BMW = Car(4,‘红色‘)			#创建对象
Audi = Car(4,‘白色‘)			#创建对象
BMW.run()				#调用方法
Audi.run()				#调用方法

程序运行结果：

例：用面向对象程序设计思路编写程序，模拟学生选课，每选一门课程，将课程名加入到学生的所选课程中，同时将课程的学分累加到学生的总学分中。

#定义学生类
class Stu:
    #构造方法定义学生属性
    def __init__(self,num,name,credit,course):
        self.num = num
        self.name = name
        self.credit  = credit
        self.course = course
    #定义学生选课方法
    def choose(self,c):
        self.credit+=c.credit
        self.course.append(c.name)
#定义课程类
class Cou:
 #构造方法定义课程属性
    def __init__(self,num,name,credit):
        self.num = num
        self.name = name
        self.credit  = credit
stu_1 = Stu(‘201801‘,‘Jack‘,0,[])  #创建学生1
stu_2 = Stu(‘201802‘,‘Tom‘,3,[‘Math‘]) #创建学生2
cou_1 = Cou(‘01‘,‘Python‘,3)      #创建课程1
cou_2 = Cou(‘02‘,‘C‘,4)       #创建课程2
stu_1.choose(cou_1)       #调用方法实现学生1选课程1
stu_2.choose(cou_2)       #调用方法实现学生2选课程2
#输出各学生信息
print(‘学号:‘,stu_1.num,‘姓名:‘,stu_1.name,‘总学分:‘,stu_1.credit,‘所选课程‘,stu_1.course)
print(‘学号:‘,stu_2.num,‘姓名:‘,stu_2.name,‘总学分:‘,stu_2.credit,‘所选课程‘,stu_2.course)

程序运行结果：

3.属性的操作

class Student():
    # 定义属性
    school = ‘SH‘
    # country = ‘Chinese‘
    # 当调用类的时候，会自动调用的函数, 初始化方法 （********）
    def __init__(stu_obj, name, age, gender, courese=None):
        # stu_obj   => stu1
        if courese is None:
            courese = []
        stu_obj.name = name  # stu1.__dict__[‘name‘] = ‘egon‘
        stu_obj.age = age,  # stu1.__dict__[‘age‘] = 18
        stu_obj.gender = gender  # stu1.__dict__[‘gender‘] = ‘male‘
        stu_obj.courese = courese  # stu1.__dict__[‘gender‘] = ‘male‘

    def choose_course(stu_obj, course):
        # stu_obj => stu
        # stu_dic[‘courses‘].append(course)
        stu_obj.courese.append(course)

        """
        stu_obj = {‘name‘: ‘egon‘, ‘age‘: (18,), ‘gender‘: ‘male‘, ‘courese‘: []}
        """
        print("%s选课成功 %s" % (stu_obj.name, stu_obj.courese))


stu = Student(‘egon‘, 18, ‘male‘)
stu1 = Student(‘egon1‘, 18, ‘male‘)

# print(stu.__dict__)
# 类属性的查找
# print(Student.__dict__[‘school‘])

# 查
# print(Student.school)

# 增加
# Student.country = ‘Chinese‘


# 修改
# Student.school = ‘BJ‘

# 删除
# del  Student.school
# Student.choose_course(stu, ‘python‘)
# Student.choose_course(stu1, ‘linux‘)
# print(Student.choose_course)


# print(Student.__dict__)

# 对象的属性查找
# print(stu.__dict__)
# print(stu.name)
# print(stu.age)
# print(stu.gender)
#
# stu.name = ‘xxx‘
# print(stu.name)
# print(stu.__dict__)
# stu.school = ‘xxxxxxx‘
# print(stu.__dict__)
# print(stu.school)

# 类中的方法类可以调用，但是推荐对象来调用，对象来调用，把对象本身当成第一个参数传递给函数的第一个参数
stu.choose_course(‘python‘) # stu.choose_course(stu, ‘python‘)
stu1.choose_course(‘linux‘) # stu.choose_course(stu, ‘python‘)

15.面向对象程序设计入门