Python的面向对象

一、编程思想
　　编程思想类似于武术流派，没有最牛，打败敌人才是好武功，对于程序员来说实现功能才是好的编程思想。
编程思想分类
    面向过程：
        核心思想是在“过程”二字
        过程的核心思想就是将程序流程化
        过程是“流水线”，用来分步骤解决问题的
    面向对象：
        核心思想是“对象”二字
        对象是什么？
            对象就是“容器”，用来盛放东西，盛放（数据+功能）
            对象就是（数据+功能的集合体）
        对象的核心思想就是将程序“整合”。

二、类与对象

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

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

　　所以，如果说对象是用来存放数据与功能的容器，那么类则是用来存放多个对象相同的数据与功能的容器。 

对象与类的图解：

 　　在程序中，必须要事先定义类，然后再调用类产生对象（调用类拿到的返回值就是对象）。产生对象的类与对象之间存在关联，这种关联指的是：对象可以访问到类中共有的数据与功能，所以类中的内容仍然是属于对象的，类只不过是一种节省空间、减少代码冗余的机制，面向对象编程最终的核心仍然是去使用对象。

三、面向对象编程

        一、现实生活中：
            1、先找出现实生活中的对象。
            2、然后总结归纳处现实生活中的类。
        对象
        类：种类分类

        stu_school = 'oldboy'
        stu_id = 001
        stu_name = 'lsj'
        stu_age = 18
        每一个学生都这么存储，很占空间，所以把共有的存到一个类中
        把特有的给每人

        二、程序中：
            1、先定义类
            2、后调用类产生对象（调用类的过程又称之为实例化）

1、类的定义与实例化

我们以开发一个清华大学的选课系统为例，来简单介绍基于面向对象的思想如何编写程序

　　面向对象的基本思路就是把程序中要用到的、相关联的数据与功能整合到对象里，然后再去使用，但程序中要用到的数据以及功能那么多，如何找到相关连的呢？我需要先提取选课系统里的角色：学生、老师、课程等，然后显而易见的是：学生有学生相关的数据于功能，老师有老师相关的数据与功能，我们单以学生为例

# 学生的数据有
学校
名字
年龄
性别

# 学生的功能有
选课

详细划分
# 学生1：
    数据:
        学校=清华大学
        姓名=李刚
        性别=男
        年龄=28
    功能：
        选课

# 学生2：
    数据:
        学校=清华大学
        姓名=丽丽
        性别=女
        年龄=18
    功能：
        选课

# 学生3：
    数据:
        学校=清华大学
        姓名=牛某某
        性别=男
        年龄=38
    功能：
        选课

我们可以总结出一个学生类，用来存放学生们相同的数据与功能

# 学生类
    相同的特征:
        学校=清华大学
    相同的功能：
        选课

基于上述分析的结果，我们接下来需要做的就是在程序中定义出类，然后调用类产生对象

class Student: # 类的命名应该使用“驼峰体”

    school='清华大学' # 数据

    def choose(self): # 功能
        print('%s is choosing a course' %self.name)

类体最常见的是变量的定义和函数的定义，但其实类体可以包含任意Python代码，类体的代码在类定义阶段就会执行，
因而会产生新的名称空间用来存放类中定义的名字，可以打印Student.__dict__来查看类这个容器内盛放的东西

>>> print(Student.__dict__)
{..., 'school': '清华大学', 'choose': <function Student.choose at 0x1018a2950>, ...}

调用类的过程称为将类实例化，拿到的返回值就是程序中的对象，或称为一个实例

>>> stu1=Student() # 每实例化一次Student类就得到一个学生对象
>>> stu2=Student()
>>> stu3=Student()

如此stu1、stu2、stu3全都一样了（只有类中共有的内容，而没有各自独有的数据），想在实例化的过程中就为三位学生定制各自独有的数据：
姓名，性别，年龄，需要我们在类内部新增一个__init__方法,如下

class Student:
    school='清华大学'

    #该方法会在对象产生之后自动执行，专门为对象进行初始化操作，可以有任意代码，但一定不能返回非None的值
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

    def choose(self): 
        print('%s is choosing a course' %self.name)

然后我们重新实例出三位学生

>>> stu1=Student('李建刚','男',28)
>>> stu2=Student('王大力','女',18)
>>> stu3=Student('牛嗷嗷','男',38)

单拿stu1的产生过程来分析，调用类会先产生一个空对象stu1，然后将stu1连同调用类时括号内的参数一起传给Student.__init__(stu1,’李建刚’,’男’,28)

def __init__(self, name, sex, age):
    self.name = name  # stu1.name = '李建刚'
    self.sex = sex    # stu1.sex = '男'
    self.age = age    # stu1.age = 28

会产生对象的名称空间，同样可以用__dict__查看

>>> stu1.__dict__
{'name': '李建刚', 'sex': '男', 'age': 28}

至此，我们造出了三个对象与一个类，对象存放各自独有的数据，类中存放对象们共有的内容

 

 

存的目的是为了用，那么如何访问对象或者类中存放的内容呢？

2 属性访问

2.1 类属性与对象属性

在类中定义的名字，都是类的属性，细说的话，类有两种属性：数据属性和函数属性，可以通过__dict__访问属性的值，
比如Student.__dict__[‘school’]，但Python提供了专门的属性访问语法

>>> Student.school # 访问数据属性，等同于Student.__dict__['school']
'清华大学'
>>> Student.choose # 访问函数属性，等同于Student.__dict__['choose']
<function Student.choose at 0x1018a2950>
# 除了查看属性外，我们还可以使用Student.attrib=value(修改或新增属性),用del Student.attrib删除属性。

操作对象的属性也是一样

>>> stu1.name # 查看，等同于obj1.__dict__[‘name']
'李建刚'
>>> stu1.course=’python’ # 新增，等同于obj1.__dict__[‘course']='python'
>>> stu1.age=38 # 修改，等同于obj1.__dict__[‘age']=38
>>> del obj1.course # 删除，等同于del obj1.__dict__['course']

2.2 属性查找顺序与绑定方法

对象的名称空间里只存放着对象独有的属性，而对象们相似的属性是存放于类中的。对象在访问属性时，会优先从对象本身的__dict__中查找，未找到，则去类的__dict__中查找

类中定义的变量是类的数据属性，是共享给所有对象用的，指向相同的内存地址

# id都一样
print(id(Student.school)) # 4301108704

print(id(stu1.school)) # 4301108704
print(id(stu2.school)) # 4301108704
print(id(stu3.school)) # 4301108704

类中定义的函数是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数

Student.choose(stu1) # 李建刚 is choosing a course
Student.choose(stu2) # 王大力 is choosing a course
Student.choose(stu3) # 牛嗷嗷 is choosing a course

但其实类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同

print(id(Student.choose)) # 4335426280

print(id(stu1.choose)) # 4300433608
print(id(stu2.choose)) # 4300433608
print(id(stu3.choose)) # 4300433608

绑定到对象的方法特殊之处在于，绑定给谁就应该由谁来调用，谁来调用，就会将’谁’本身当做第一个参数自动传入（方法__init__也是一样的道理）

stu1.choose()  # 等同于Student.choose(stu1)
stu2.choose()  # 等同于Student.choose(stu2)
stu3.choose()  # 等同于Student.choose(stu3)

绑定到不同对象的choose技能，虽然都是选课，但李建刚选的课，不会选给王大力，这正是”绑定“二字的精髓所在。

#注意：绑定到对象方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但命名为self是约定俗成的。

Python中一切皆为对象，且Python3中类与类型是一个概念，因而绑定方法我们早就接触过

#类型list就是类
>>> list
<class 'list'>

#实例化的到3个对象l1,l2,l3
>>> l1=list([1,2,3])
>>> l2=list(['a','b','c'])
>>> l3=list(['x','y'])

#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操作绑定方法l1.append(4),就是在往l1添加4,绝对不会将4添加到l2或l3
>>> l1.append(4) #等同于list.append(l1,4)
>>> l1
[1,2,3,4]
>>> l2
['a','b','c']
>>> l3
['x','y']

3.3 小结

在上述介绍类与对象的使用过程中，我们更多的是站在底层原理的角度去介绍类与对象之间的关联关系，如果只是站在使用的角度，我们无需考虑语法“对象.属性"中”属性“到底源自于哪里，只需要知道是通过对象获取到的就可以了，所以说，对象是一个高度整合的产物，有了对象，我们只需要使用”对象.xxx“的语法就可以得到跟这个对象相关的所有数据与功能，十分方便且解耦合程度极高。

自学课程以及代码
对于类的使用：先定义再调用类产生对象

# 一、先定义类（存放共有的）
# 类名：驼峰体
# 类体代码在定义时候就运行了，下面的结果是：=====================>
# 类是对象相似数据与功能的集合体
# 所以类中最常见的是变量与函数的定义，但是类体中其实是可以包含任意其他代码
# 注意：类中体内代码实在类定义阶段就会立即执行，会产生类的名称空间，也就是说类的名称空间是在定义阶段产生的。

class Student:
    # 类的意义：1、存放共有的数据+功能
    # 变量的定义
    stu_school = 'oldboy'  # stu_school变量名-->产生名称空间

    # 学生的功能
    # 功能的定义
    def tell_stu_info(stu_obj):  # tell_stu_info函数名
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    # 修改学生信息
    def set_info(stu_obj,x,y,z):
        """修改学生信息"""
        stu_obj['stu_name'] = x
        stu_obj['stu_age'] = y
        stu_obj['stu_gender'] = z
    print('=======类体代码在定义阶段就已经运行========>')

# 取值
# print(Student.__dict__)
# # {'__module__': '__main__', 'stu_school': 'oldboy', 'tell_stu_info': <function Student.tell_stu_info at 0x0000015F5ED56F70>, 'set_info': <function Student.set_info at 0x0000015F5ED69040>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
# print(Student.__dict__['stu_school'])   # oldboy
# print(Student.__dict__['tell_stu_info']) # <function Student.tell_stu_info at 0x00000136AC8E6F70>

# 优化上面的取值如下：属性有两种：数据属性+函数属性
# # 1、访问数据属性
# print(Student.stu_school)  # oldboy
# # 2、访问函数属性
# print(Student.tell_stu_info)  # <function Student.tell_stu_info at 0x000001331DCA6F70>

# 二、再调用类产生对象
# 1、对象与类相关联如下
stu1_obj=Student()  # Student是一个类，()的含义是是这个类产生一个对象，返回一个值给=前的变量名stu1_obj
stu2_obj=Student()
stu3_obj=Student()

print(stu1_obj.__dict__)  # 运行结果是：{}
print(stu2_obj.__dict__)  # 运行结果是：{}
print(stu3_obj.__dict__)  # 运行结果是：{}

# 学生一，传值方法一
stu1_obj.__dict__['stu_name'] = 'lsj' 
stu1_obj.__dict__['stu_age'] = 18  
stu1_obj.__dict__['stu_gender'] = 'male'

print(stu1_obj.__dict__)  # 运行结果是：{'stu_name': 'lsj', 'stu_age': 18, 'stu_gender': 'male'}

# 向类中加入数据
Student.x = 111
print(Student.__dict__)
# {'__module__': '__main__', 'stu_school': 'oldboy', 'tell_stu_info': <function Student.tell_stu_info at 0x000001BBF1E39040>, 
# 'set_info': <function Student.set_info at 0x000001BBF1E390D0>, '__dict__': <attribute '__dict__' of 'Student' objects>,
# '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'x': 111}

# 学生一优化传值方法一
stu1_obj.stu_name = 'lsj'
stu1_obj.stu_age = 18
stu1_obj.stu_gender = 'male'
print(stu1_obj.__dict__)
# 运行结果如是：{'stu_name': 'lsj', 'stu_age': 18, 'stu_gender': 'male'}

# 学生二
stu2_obj.stu_name = 'lili'
stu2_obj.stu_age = 19
stu2_obj.stu_gender = 'female'
print(stu2_obj.__dict__)
# 运行结果是：{'stu_name': 'lili', 'stu_age': 19, 'stu_gender': 'female'}

思考一个问题，上面学生一、学生二，我就要重复定义两遍，如果全班有100人我就要重复上面的定义100次。

为对象定制自己独有的属性
问题1：代码重复
问题2：属性的查找顺序

# 解决问题一：
# 解决方案一：
def init(obj,x,y,z):
    # 初始化
    obj.stu_name = x  # 等同于stu2_obj.stu_name = stu_name
    obj.stu_age = y
    obj.stu_gender = z

init(stu1_obj,'lsj',18,'male')
print(stu1_obj.__dict__)  # {'stu_name': 'lsj', 'stu_age': 18, 'stu_gender': 'male'}

init(stu2_obj,'lili',19,'female')
print(stu2_obj.__dict__)  # {'stu_name': 'lili', 'stu_age': 19, 'stu_gender': 'female'}

对象的精髓在整合

# encoding=utf-8
# auther：lsj

# 针对解决方案一，没有体现对象的精髓-->整合，也就是整合程度不高
# 我要经初始化部分也整合到一起
# 解决问题一：
# 解决方案二：

# 一、先定义类（存放共有的）
class Student:
    # 类的意义：1、存放共有的数据+功能
    # 变量的定义
    stu_school = 'oldboy'

    # 将初始化的内容加入到类中进行整合
    # 调用类产生一个对象，产生对象后初始化了init功能，所以直接在类中加入init功能
    # （死记硬背一定要会）如何在调用类的时候底层能够自动的调用init功能？这样省去了调用的功能，使用__init__
    # __init__会在类调用阶段执行改功能

    # 空对象，'lsj',18,'male'
    def __init__(obj,x,y,z):
        obj.stu_name = x  # 空对象.stu_name = 'lsj'
        obj.stu_age = y  # 空对象.stu_age = 18
        obj.stu_gender = z  # 空对象.stu_gender = 'male'

    # 学生的功能
    # 功能的定义
    def tell_stu_info(stu_obj):  # tell_stu_info函数名
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    # 修改学生信息
    def set_info(stu_obj,x,y,z):
        """修改学生信息"""
        stu_obj['stu_name'] = x
        stu_obj['stu_age'] = y
        stu_obj['stu_gender'] = z
    print('=======类体代码在定义阶段就已经运行========>')

# 二、再调用类产生对象
# 调用类的过程又称之为实例化
# stu1_obj=Student()  # 思考__init__()明明是需要4个参数，为什么提示的是需要3个函数？
# TypeError: __init__() missing 3 required positional arguments: 'x', 'y', and 'z'
# python底层自己已经传入了一个参数，也就传入了一个stu_obj

# stu2_obj=Student()  # 语法规定的：Student.__init__(空对象)
stu3_obj=Student('lsj',18,'male')  # 传参'lsj',18,'male'，传参时参数必须一一对应
print(stu3_obj)  # <__main__.Student object at 0x00000214352144F0>
print(stu3_obj.__dict__)  # {'stu_name': 'lsj', 'stu_age': 18, 'stu_gender': 'male'}

# 调用类的过程又称之为实例化，发生了三件事
# 1、先产生一个空对象
# 2、python会自动调用类中的init方法，将空对象以及调用类时括号内传入的参数一同传给init方法
# 3、返回初始化完的对象

# 总结__init__方法
# 1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
# 2、__init__内应该存放的是为对象初始化属性的功能，但是是可以存放任意其他代码的，想要在类调用时就立刻执行的代码都可以放到该方法内。
# 3、调用类造一个空对象并返回，init方法必须返回None

 类中属性的查找与绑定关系

# 一、先定义类（存放共有的）
class Student:
    # 类的意义：1、存放共有的数据+功能
    # 变量的定义
    stu_school = 'oldboy'

    # 空对象，'lsj',18,'male'
    def __init__(obj,x,y,z):
        obj.stu_name = x  # 空对象.stu_name = 'lsj'
        obj.stu_age = y  # 空对象.stu_age = 18
        obj.stu_gender = z  # 空对象.stu_gender = 'male'

    # 学生的功能
    # 功能的定义
    def tell_stu_info(stu_obj):  # tell_stu_info函数名
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    # 修改学生信息
    def set_info(stu_obj,x,y,z):
        """修改学生信息"""
        stu_obj['stu_name'] = x
        stu_obj['stu_age'] = y
        stu_obj['stu_gender'] = z
    print('=======类体代码在定义阶段就已经运行========>')

stu1_obj=Student('lsj',18,'male')  # 传参'lsj',18,'male'
stu2_obj = Student('lili',19,'female')
stu3_obj = Student('tianjiang',17,'female')

# 类中存放的是对象共有的数据与功能
# 一、类可以访问：
#   1、类的数据属性
# 查找顺序：先从对象找，在去类里找
# print(stu1_obj.stu_school) # oldboy
#   2、类的函数属性
# print(Student.tell_stu_info)  # <function Student.tell_stu_info at 0x00000211614990D0>
# print(Student.set_info)  # <function Student.set_info at 0x0000021161499160>

# 二、类中的东西是给对象用的
# 1、类的数据属性是共享给所有对象用的，大家访问的地址是一样的。
print(stu1_obj.stu_name)   # lsj
print(stu1_obj.stu_age)    # 18
print(stu1_obj.stu_gender) # male

print("=====================================")
# print(id(stu1_obj.stu_school))  # 1822175088432
# print(id(stu2_obj.stu_school))  # 1822175088432
# print(id(stu3_obj.stu_school))  # 1822175088432
# 由此可见：类中的id相同
# 验证修改类中的stu_school的变量
# Student.stu_school = "OLDBOY"  # 赋值操作
# print(Student.stu_school)  # OLDBOY
# print(stu1_obj.stu_school) # OLDBOY
# print(stu2_obj.stu_school) # OLDBOY
# print(stu3_obj.stu_school) # OLDBOY
print("=====================================")
# 赋值给对象里的stu1_obj.stu_school一个值'OLDBOY'
# stu1_obj.stu_school = 'OLDBOY'  # 赋值操作
# print(Student.stu_school)  # oldboy
# print(stu1_obj.stu_school) # OLDBOY
# print(stu2_obj.stu_school) # oldboy
# print(stu3_obj.stu_school) # oldboy

# 类的数据属性实例，统计学生人数
# 一、先定义类（存放共有的）
class Student:
    # 类的意义：1、存放共有的数据+功能
    # 变量的定义
    stu_school = 'oldboy'
    # 统计学生人数
    count = 0
    # 空对象，'lsj',18,'male'
    def __init__(obj,x,y,z):
        Student.count += 1  # 每实例化一次都会调用一次init，在这里统计
        obj.stu_name = x  # 空对象.stu_name = 'lsj'
        obj.stu_age = y  # 空对象.stu_age = 18
        obj.stu_gender = z  # 空对象.stu_gender = 'male'

    # 学生的功能
    # 功能的定义
    def tell_stu_info(stu_obj):  # tell_stu_info函数名
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    # 修改学生信息
    def set_info(stu_obj,x,y,z):
        """修改学生信息"""
        stu_obj['stu_name'] = x
        stu_obj['stu_age'] = y
        stu_obj['stu_gender'] = z
    print('=======类体代码在定义阶段就已经运行========>')

stu1_obj=Student('lsj',18,'male')  # 传参'lsj',18,'male'
stu2_obj = Student('lili',19,'female')
stu3_obj = Student('tianjiang',17,'female')

print(stu1_obj.count)  # 3
print(stu2_obj.count)  # 3
print(stu3_obj.count)  # 3# 类的函数属性

# 一、先定义类（存放共有的）
class Student:
    # 类的意义：1、存放共有的数据+功能
    # 变量的定义
    stu_school = 'oldboy'
    # 统计学生人数
    count = 0
    # 空对象，'lsj',18,'male'
    def __init__(obj,x,y,z):
        Student.count += 1  # 每实例化一次都会调用一次init，在这里统计
        obj.stu_name = x  # 空对象.stu_name = 'lsj'
        obj.stu_age = y  # 空对象.stu_age = 18
        obj.stu_gender = z  # 空对象.stu_gender = 'male'

    # 学生的功能
    # 功能的定义：展示学生信息
    # def tell_stu_info(stu_obj):  # tell_stu_info函数名
    #     print('学生信息：名字：%s 年龄：%s 性别：%s' %(
    #         stu_obj['stu_name'],
    #         stu_obj['stu_age'],
    #         stu_obj['stu_gender']
    #     ))  # 优化前的运行结果：TypeError: 'Student' object is not subscriptable
    # 优化展示学生信息功能
    def tell_stu_info(stu_obj):  # tell_stu_info函数名
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj.stu_name,
            stu_obj.stu_age,
            stu_obj.stu_gender
        ))
    # 修改学生信息
    # def set_info(stu_obj,x,y,z):
    #     """修改学生信息"""
    #     stu_obj['stu_name'] = x
    #     stu_obj['stu_age'] = y
    #     stu_obj['stu_gender'] = z
    # 优化后的修改学生信息
    def set_info(stu_obj,x,y,z):
        """修改学生信息"""
        stu_obj.stu_name = x
        stu_obj.stu_age = y
        stu_obj.stu_gender = z
    print('=======类体代码在定义阶段就已经运行========>')

stu1_obj=Student('lsj',18,'male')  # 传参'lsj',18,'male'
stu2_obj = Student('lili',19,'female')
stu3_obj = Student('tianjiang',17,'female')

# 类中存放的是对象共有的数据与功能
# 一、类可以访问：
#   1、类的数据属性
# 查找顺序：先从对象找，在去类里找
# print(stu1_obj.stu_school) # oldboy
#   2、类的函数属性
# print(Student.tell_stu_info)  # <function Student.tell_stu_info at 0x00000211614990D0>
# print(Student.set_info)  # <function Student.set_info at 0x0000021161499160>

# 2、类的函数属性是绑定给对象用的，但是不同的对象就是不同的绑定方法，内存地址各不相同。
# 类调用自己的函数属性必须严格按照函数的用法来

print(Student.tell_stu_info)
print(Student.set_info)
# 传入stu1_obj
Student.tell_stu_info(stu1_obj) #优化前的运行结果： TypeError: 'Student' object is not subscriptable
# 优化后的运行结果：学生信息：名字：lsj 年龄：18 性别：male
# Student.tell_stu_info(stu2_obj) # 学生信息：名字：lili 年龄：19 性别：female
# Student.tell_stu_info(stu3_obj) # 学生信息：名字：tianjiang 年龄：17 性别：female

print("============================================")
# 设置学生信息
Student.set_info(stu1_obj,'lsjjjj',19,'malemale') # 优化前运行结果：TypeError: set_info() missing 3 required positional arguments: 'x', 'y', and 'z'
Student.tell_stu_info(stu1_obj)  # 学生信息：名字：lsjjjj 年龄：19 性别：malemale

# 注意：1、是要看到self就当他没有，应为已经当对象传入
# 2、绑定给谁就是在操作谁

l1 = [1,2,3]  # l = list([1,2,3])
l2 = [4,5,6]

l1.append(7)
print(l1)  # [1, 2, 3, 7]
list.append(l1,8)  # 效果同上 def append(self, *args, **kwargs)
print(l1)  # [1, 2, 3, 7, 8]

四、补充软软件质量属性

　　在开发软件的时候不能就可扩展性一方面就是用面向对象编程，要根据其性能、可能一致性等方面综合考虑。