标签：__ stu1 self course day10 print OldboyStudent

面向对象程序设计

1940年以前：面向机器——二进制码、汇编
面向过程——COBOL、FORTRAN、BASIC、C 语言等
结构化程序设计——抛弃 goto 语句,采取“自顶向下、逐步细化、模块化”的指导思想。结构化程序设计本质上还是一种面向过程的设计思想,但通过“自顶向下、逐步细化、模块化”的方法,将软件的复杂度控制在一定范围内,从而从整体上降低了软件开发的复杂度。
面向对象程序设计——C++、Java、C#等

杰出人物

约翰·巴科斯，发明了Fortran。
阿兰·库珀，开发了Visual Basic。
艾兹格·迪杰斯特拉，开创了正确运用编程语言(proper programming)的框架。
詹姆斯·高斯林，开发了Oak，该语言为Java的先驱。
安德斯·海尔斯伯格，开发了Turbo Pascal、Delphi，以及C#。
葛丽丝·霍普，开发了Flow-Matic，该语言对COBOL造成了影响。
肯尼斯·艾佛森，开发了APL，并与Roger Hui合作开发了J。
比尔·乔伊，发明了vi，BSD Unix的前期作者，以及SunOS的发起人，该操作系统后来改名为Solaris。
艾伦·凯，开创了面向对象编程语言，以及Smalltalk的发起人。
Brian Kernighan，与丹尼斯·里奇合著第一本C程序设计语言的书籍，同时也是AWK与AMPL程序设计语言的共同作者。
约翰·麦卡锡，发明了LISP。
约翰·冯·诺伊曼，操作系统概念的发起者。
丹尼斯·里奇，发明了C。
比雅尼·斯特劳斯特鲁普，开发了C++。
肯·汤普逊，发明了Unix。
尼克劳斯·维尔特，发明了Pascal与Modula。
拉里·沃尔，创造了Perl与Perl 6。
吉多·范罗苏姆，创造了Python。

面向过程编程

面向过程变成的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么……

基于面向过程编程的思想编写程序好比在设计一条流水线，是一种机械式的思维方式。

优点：复杂的问题流程化、进而简单化
缺点：扩展性差

基于面向对象编程的思想编写程序，就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式。

优点：可扩展性强
缺点：编程的复杂度要高于面向过程

类和对象

类的意思：种类、分类、类别

对象是特征与技能的结合体，我可能有身高体重、而你也有身高体重，所以你会说你像我，但是你一定不会说你像阿猫阿狗。并且我和你其实就可以说成是一类，而你和选课系统不能说是一类，因此给出类的定义：类就是一系列对象相似的特征与技能的结合体。

在现实世界中：先有一个个具体存在的对象，然后随着人类文明的发展才了分类的概念，既然现实世界中有类这个概念，Python程序中也一定有类这个概念，但是在Python程序中：必须先定义类，然后调用类来产生对象。

现实世界中定义类和对象

定义对象

就拿未来我们的选课系统来讲，我们先总结一套现实世界中的学生对象：

对象1：

特征：

学校='oldboy'
姓名='耗哥'
年龄=18
性别='male'

技能：

选课

对象2：

特征：

学校='oldboy'
姓名='猪哥'
年龄=17
性别='male'

技能：

选课

对象3：

特征：

学校='oldboy'
姓名='帅翔'
年龄=19
性别='female'

技能：

选课

定义类

站在未来选课系统的角度，我们还可以总结现实世界中的学生类：

老男孩学生类：

相似的特征：

学校='oldboy'

相似的技能

选课

程序中定义类和对象

定义类

class OldboyStudent():
    school = 'oldboy'
    
    def choose_course(self):
        print('is choosing course')

print(OldboyStudent.__dict__)

{'__module__': '__main__', 'school': 'oldboy', 'choose_course': <function OldboyStudent.choose_course at 0x0000020B07BFE7B8>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}

print(OldboyStudent.__dict__['school'])

oldboy

print(OldboyStudent.__dict__['choose_course'])

<function OldboyStudent.choose_course at 0x0000020B07BFE7B8>

try:
    OldboyStudent.__dict__['choose_course']()
except Exception as e:
    print('error:',e)

error: choose_course() missing 1 required positional argument: 'self'

通过OldboyStudent.dict['choose_course']尝试访问OldboyStudent类中名为choose_course的属性，但是由于该属性不存在，所以会引发KeyError异常。

异常被捕获，并执行except代码块中的逻辑。

在except代码块中，使用print('error:', e)输出异常的消息。这里的e是KeyError异常对象，print函数会输出异常的消息，显示为error: 'choose_course'，其中'choose_course'是引发异常的键名。

print(OldboyStudent.school)

oldboy

OldboyStudent.choose_course(111)

is choosing course

print(OldboyStudent.choose_course)

<function OldboyStudent.choose_course at 0x0000020B07BFE7B8>

打印OldboyStudent类的choose_course属性。但是由于类中没有名为choose_course的属性，所以引发了AttributeError异常。最终，我们捕获了异常并打印出错误消息。错误消息表明'OldboyStudent'对象没有choose_course属性。

OldboyStudent.__dict__['choose_course']

<function __main__.OldboyStudent.choose_course(self)>

OldboyStudent.country='China'

OldboyStudent.__dict__['country']

'China'

OldboyStudent.country='CHINA'

OldboyStudent.__dict__['country']

'CHINA'

del OldboyStudent.school

print(OldboyStudent.__dict__)

{'__module__': '__main__', 'choose_course': <function OldboyStudent.choose_course at 0x0000020B07BFE7B8>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None, 'country': 'CHINA'}

定义对象

调用类即可产生对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例

class OldboyStudent():
    school = 'oldboy'
    def choose_course(self):
        print('is choosing course')
stu1=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
print(stu1.school)

oldboy

stu2=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
print(stu2.school)

oldboy

stu3=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
stu3.choose_course()

is choosing course

定制对象独有特征

class OldboyStudent:
    school = 'oldboy'
    
    def choose_course(self):
        print('is choosing course')
        
stu1 = OldboyStudent()
stu2 = OldboyStudent()
stu3 = OldboyStudent()

OldboyStudent.school = 'OLDBOY'

print(stu1.school)

OLDBOY

print(stu2.school)

OLDBOY

具体定制对象独有特征

对象本质类似于类，也是一个名称空间，但是对象的名称空间存放对象独有的名字，而类中存放的是对象们共有的名字。因此我们可以直接为对象单独定制名字。

stu1.name = 'tank'
stu1.age = 18
stu1.gender = 'male'

print(stu1.name,stu1.age,stu1.gender)

tank 18 male

try:
    print(stu2.name,stu2.age,stu2.gender)
except Exception as e:
    print(e)

'OldboyStudent' object has no attribute 'name'

stu2.name = 'sean'
stu2.age = 19
stu2.gender = 'female'

print(stu2.name, stu2.age, stu2.gender)

sean 19 female

属性查找

首先从自身查找，没找到往类中找，类中没有则会报错。即对象的属性查找顺序为：自身--》类--》报错

类定义阶段定制属性

def init(obj,x,y,z):
    obj.name = x
    obj.age = y
    obj.gender = z
    
init(stu1,'tank1',181,'male1')
print(stu1.name,stu1.age,stu1.gender)

tank1 181 male1

init(stu2,'sean1',191,'female1')
print(stu2.name,stu2.age,stu2.gender)

sean1 191 female1

使用上述方法虽然让我们定制属性更简单，但是还是太麻烦了，如果可以在实例化对象的时候自动触发定时属性，那就更方便了，因此可以使用类的__init__方法。

class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, gender):
        """调用类的时候自动触发"""
        self.name = name
        self.age = age
        self.gender = gender
        print('*' * 50)

    def choose_course(self):
        print('is choosing course')


try:
    stu1 = OldboyStudent()
except Exception as e:
    print(e)

__init__() missing 3 required positional arguments: 'name', 'age', and 'gender'

stu1 = OldboyStudent('nick', 18, 'male')

**************************************************

print(stu1.__dict__)

{'name': 'nick', 'age': 18, 'gender': 'male'}

对象属性查找顺序

属性查找

先从对象自己的名称空间找，没有则去类中找，如果类也没有则报错

class OldboyStudent:
    school = 'oldboy'
    count = 0
    aa = 10

    def __init__(self, x, y, z):  #会在调用类时自动触发
        self.name = x  # stu1.name='耗哥'
        self.age = y  # stu1.age=18
        self.sex = z  # stu1.sex='male'
        OldboyStudent.count += 1
        #         self.count += 5
        self.aa = 1

    def choose_course(self):
        print('is choosing course')

print(OldboyStudent.count)

类属性 school：这是一个类级别的属性，被所有 OldboyStudent 类的实例对象共享。在这个例子中，school 被赋值为字符串 'oldboy'。

类属性 count：这是另一个类级别的属性，用于记录 OldboyStudent 类的实例对象的数量。初始值为 0。

类属性 aa：这是另一个类级别的属性，被所有 OldboyStudent 类的实例对象共享。在这个例子中，aa 被赋值为 10。

init 方法：这是一个特殊方法，在创建 OldboyStudent 类的实例对象时会自动调用。它接受 x、y 和 z 作为参数，并将它们分别赋值给实例对象的属性 self.name、self.age 和 self.sex。在这个例子中，init 方法还对类属性 count 进行了递增操作 OldboyStudent.count += 1，表示创建了一个新的对象。另外，它还为实例对象的属性 self.aa 赋值为 1。

choose_course 方法：这是一个普通的实例方法，用于表示学生正在选择课程。

在这个类中，school 和 count 是类级别的属性，可以通过类名来访问，例如 OldboyStudent.school 和 OldboyStudent.count。而 name、 age、 sex 和 aa 是实例级别的属性，需要通过对象来访问，例如 stu1.name、 stu1.age、 stu1.sex 和 stu1.aa。

注意，在 init 方法中，你可以使用 self.name、 self.age、 self.sex 和 self.aa 来引用实例对象的属性，而使用 OldboyStudent.count 或 OldboyStudent.aa 来引用类属性。

该类定义了一个简单的构造方法和一个方法，可以创建 OldboyStudent 类的实例对象，并通过实例对象来访问和修改实例属性。

请注意，当你创建 OldboyStudent 类的实例对象时，init 方法将会被自动调用，并且传入的参数值将被用来初始化实例对象的属性。

stu1 = OldboyStudent('nick', 18, 'male')
print(stu1.count)

stu2 = OldboyStudent('sean', 17, 'male')
print(stu2.count)

stu3 = OldboyStudent('tank', 19, 'female')
print(stu3.count)

print(OldboyStudent.count)

print(stu1.name)

nick

由于上述修改的是类属性，类属性的count已经被修改为3，所以其他实例的count都为3

print(stu1.count)

print(stu2.count)

print(stu3.count)

由于aa是私有属性，因此stu们都会用自己私有的aa，不会用类的aa

print(stu1.__dict__)

{'name': 'nick', 'age': 18, 'sex': 'male', 'aa': 1}

print(stu2.__dict__)

{'name': 'sean', 'age': 17, 'sex': 'male', 'aa': 1}

print(stu3.__dict__)

{'name': 'tank', 'age': 19, 'sex': 'female', 'aa': 1}

对象的绑定方法

class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.sex = gender

    def choose_course(self):
        print(f'{self.name} choosing course')

    def func(self):
        print('from func')

类名称空间中定义的数据属性和函数属性都是共享给所有对象用的
对象名称空间中定义的只有数据属性，而且是对象所独有的数据属性

类使用对象的绑定对象

stu1 = OldboyStudent('nick', 18, 'male')
stu2 = OldboyStudent('sean', 17, 'male')
stu3 = OldboyStudent('tank', 19, 'female')

print(stu1.name)
print(stu1.school)

nick
oldboy

类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个

print(OldboyStudent.choose_course)

<function OldboyStudent.choose_course at 0x000002DEDCA832F0>

try:
    OldboyStudent.choose_course(123)
except Exception as e:
    print(e)

is choosing course

对象使用对象的绑定方法

类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的，
绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入

print(id(stu1.choose_course))
print(id(stu2.choose_course))
print(id(stu3.choose_course))
print(id(OldboyStudent.choose_course))

3156207784456
3156207762440
3156207784456
3156208005872

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

3156207789592
3156207789592
3156207789592

print(id(stu1.name), id(stu2.name), id(stu3.name))

3156208430920 3156208429296 3156208431032

stu1.choose_course()

nick choosing course

stu2.choose_course()

sean choosing course

stu3.choose_course()

tank choosing course

补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self

stu1.func()

from func

stu2.func()

from func

类和数据类型

类与数据类型

python3中统一了类与类型的概念，类就是类型

class Foo:
    pass

obj = Foo()
print(type(obj))

<class '__main__.Foo'>

lis = [1,2,3]
lis2 = [4,5,6]

print(type(lis))

<class 'list'>

lis和lis2都是实例化的对象，因此lis使用append方法和lis2无关

lis.append(7)
print(lis)

[1, 2, 3, 7]

print(lis2)

[4, 5, 6]

list.append()方法原理

class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.sex = gender

    def choose_course(self, name):
        print(f'{name} choosing course')


stu1 = OldboyStudent('nick', 18, 'male')

stu1.choose_course(1)  # OldboyStudent.choose_course(stu1, 1)

1 choosing course

OldboyStudent.choose_course(stu1, 1)

1 choosing course

lis = [1, 2, 3]  # lis = list([1,2,3])
print(type(lis))

<class 'list'>

lis.append(4)  # list.append(lis,4)
print(lis)

[1, 2, 3, 4]

list.append(lis, 5)
print(lis)

[1, 2, 3, 4, 5]

对象的高度整合

没有对象

以未来我们要连接数据库举例，如果没有面向对象的思想，我们只要想要使用一个方法，就必须得这样做

import pymysql  # 连接mysql的三方库，可以pip3 install pymysql安装


def exc1(host, port, db, charset, sql):
    conn = pymysql.connect(host, port, db, charset)
    conn.execute(sql)
    return xxx


def exc2(proc_name):
    conn = pymysql.connect(host, port, db, charsett)
    conn.call_proc(sql)
    return xxx


exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t1')
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t2')
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t3')
exc1('1.1.1.1', 3306, 'db1', 'utf-8', 'select * from t4')

由于host、port、db、charset可能是固定不变的，sql一直在变化，因此我们通过上述的方法实现不同的sql语句，非常麻烦，因此我们可以改用默认形参

def exc1(sql, host='1.1.1.1', port=3306, db='db1', charset='utf-8'):
    conn = pymysql.connect(host, port, db, charset)
    conn.execute(sql)
    return xxx

exc1('select * from t1')
exc1('select * from t2')
exc1('select * from t3')
exc1('select * from t4')

虽然是用默认参数简化了操作，但是对于不同引用的对象，参数并不是一成不变的，或者我们需要对exc2方法进行修改，这是非常麻烦的，因此可以考虑使用面向对象

有对象

有了面向对象之后，对于上述的例子，我们可以这样做

import pymysql


class Foo:
    def __init__(self, host, port, db, chartset):
        self.host = host
        self.port = port
        self.db = db
        self.charset = chartset

    def exc1(self, sql):
        conn = pymysql.connect(self.host, self.port, self.db, self.charset)
        conn.execute(sql)
        return xxx

    def exc2(self, proc_name):
        conn = pymysql.connect(self.host, self.port, self.db, self.charsett)
        conn.call_proc(sql)
        return xxx


obj1 = Foo('1.1.1.1', 3306, 'db1', 'utf-8')
obj1.exc1('select * from t1')
obj1.exc1('select * from t2')
obj1.exc1('select * from t3')
obj1.exc1('select * from t4')

obj2 = Foo('1.1.1.2', 3306, 'db1', 'utf-8')
obj2.exc1('select * from t4')

对于上述发生的现象，我们可以总结对象其实就是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）

标签：__,stu1,self,course,day10,print,OldboyStudent
From： https://www.cnblogs.com/qingchuan/p/17596797.html

day10

面向对象程序设计

类和对象

现实世界中定义类和对象

定义对象

定义类

程序中定义类和对象

定义类

定义对象

定制对象独有特征

具体定制对象独有特征

属性查找

类定义阶段定制属性

对象属性查找顺序

属性查找

对象的绑定方法

对象的绑定方法

类使用对象的绑定对象

对象使用对象的绑定方法

类和数据类型

类与数据类型

list.append()方法原理

对象的高度整合

没有对象

有对象

相关文章

赞助商

阅读排行