1 2 3 4

面向对象的基础

面向对象

1.面向对象的定义

1.1什么是面向对象?
面向对象是一门编程思想。

1.2面向过程的编程思想:
-核心是'过程'二字,过程指的是解决问题的步骤,即现做什么后做什么?基于该编程思想来编写程序,就好比在设计一条工厂的流水线,一种机械的思维方式。

​ -优点:将复杂的问题流程化,进而简单化。

​ -缺点:其一发而动全身,程序的可扩展性差。

注意:编程思想仅仅是一门思想,与任何技术没有关系。

1.3面向对象的编程思想:

​ 注意:要将自己当作一个上帝。

​ 核心是“对象”二字,对象指的是“特征与技能”的结合体。

​ 基于该编程思想编写程序,就好比在创造世界,一种上帝式的思维方式。

​ -优点:可扩展性高

​ -缺点:编写程序的复杂程度比面向过程高

1.4如何产生对象?

​ 1.41什么是类?

​ 类指的是类型、类别

​ 1.42 在 两种角度去看待:

​ -现实世界中:

​ -先有一个个对象,经过社会文明的发展,随之总结出类

​ 对象是实际存在的,而类抽象产生的

​ -在程序:

​ -必须现有类,再通过“调用类,产生对象”

1.5如何定义类:

​ -如何写类,并产生对象:

​ -先从现实的世界中通过一个个对象总结出类;

​ -然后在定义类,后调用类产生对象

比如选课系统:

-选课的学生类

​ -学生对象一:

​ 特征:

​ -姓名:王一

​ -性别:male

​ -年龄:26

​ -学校:oldboy

​ 技能:

​ -技术:python

​ -学习:learn

​ -选课:course

​ -学生对象二:

​ 特征:

​ -姓名:张三

​ -性别:male

​ -年龄:29

​ -学校:oldboy

​ 技能:

​ -技术:python

​ -学习:learn

​ -选课:course

1.6定义类的语法:

​ class:关键字:帮助你产生类。

​ class类的名字:

​ 类一些列对象相同的特征与技能的结合体

​ -对象之间的相同的特征:

​ -学校

​ school = 'oldboy'

​ -对象之间相同的技能:

​ -python

​ def python():

​ pass

​ -learn

​ def learn()"

​ pass

​ -course

​ def course():

​ pass

	## 2.class 类名

class 类名:

​ 特征

​ 技能

​ -定义类名的规范:

​ -驼峰命名法

def foo():函数名指的是函数的内存地址

print(foo) # <function foo at 0x000001CDFF119048>

# 定义老男孩学生类
class OldboyStudent:  # 类名指向的是类的内存地址
    # 学生相同的特征
    # 在类中的特征 也称之为 “属性” attribute
    school = 'oldboy'

    # 学生相同的技能
    # 注意: 在类内部定义函数,会默认有一个参数self
    def learn(self):  # self此时当做一个形参
        print('learning....')
print(OldboyStudent)  # <class '__main__.OldboyStudent'>

#查看名称空间
 
类.__dict__   对象.__dict__
class OldboyStudent():
    school = 'oldboy'
    def learn(self):
        print('from the world')

print(OldboyStudent)

print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)
>>>>>>>>>>>>
<class '__main__.OldboyStudent'>#####类的函数对象

{'__module__': '__main__', 'school': 'oldboy', 'learn': <function  OldboyStudent.learn at 0x000001F80EC20158>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}######这个类的名称空间

oldboy ######这个是school的打印结果

<function OldboyStudent.learn at 0x000001F80EC20158>######这个函数的learn的内存地址

from the world  ######这个是给函数传参得到的一个打印结果
class OldboyStudent():
    school = 'oldboy'
    def learn(self):
        print('from the world')

p = OldboyStudent
# print(OldboyStudent)
# 类提供一种特殊获取名字的方式  “类名.名字” 的方式
#查
print(p.school)
#改
p.school = 'oldgirl'
print(p.school)
#删
>>>>>>>>>>>>>
oldboy
oldgirl


#删
del p.school
print(p.school)
>>>>>>>>>>

Traceback (most recent call last):
  File "E:/working/111.py", line 61, in <module>
    print(p.school)
AttributeError: type object 'OldboyStudent' has no attribute 'school'
######删除了 再去打印 会报错

#增
p.new_student = 'david'
print(p.new_student)
>>>>>>>>>>
david

重点

-函数的名称空间:

​ 在函数调用时产生,函数调用结束后销毁

-类的名称空间:

​ 在定义阶段,会将类中的所有的名字,仍进类的名称空间中。

3.对象的调用

-调用类产生对象

​ 类名+()调用类产生的对象

​ 类的名称空间在定义时产生,对象的名称空间在调用时产生。

​ 调用类产生的对象的过程称之为类的实例化,对象称之为类的一个实例

class Student:
    school = 'oldboy'#特征
    def learn(self):  #这个是技能 函数就是方法
        print(self)
        print('from the world')
Student.learn(123)####打印的是结果
>>>>>>>>>>
123
from the world


class Student:
    school = 'oldboy'#特征
    def learn(self):  #这个是技能 函数就是方法
        print(self)
        print('from the world')

stu1 = Student()#####调用类产生的对象
stu2 = Student()#####调用类产生的对象

print(stu1)
print(stu1.school)
print(stu1.learn)

print('='*50)
print(stu2)
print(stu2.school)
print(stu2.learn)
>>>>>>>>>>>>>>>>>>>>>>>>>>
<__main__.Student object at 0x0000020A3B6AECF8> ###这个是类的对象地址
oldboy #####打印的结果
<bound method Student.learn of <__main__.Student object at 0x0000020A3B6AECF8>>######这个是打印的是一种方法
==================================================
<__main__.Student object at 0x0000020A3B6AEE48>
oldboy
<bound method Student.learn of <__main__.Student object at 0x0000020A3B6AEE48>>
####综上类产生的2个对象 内存地址是不一样的



4.对象的绑定

由对象来调用类内部的函数,称之为对象的绑定方法

1.会将对象当做第一个参数传入。******

2.若对象的绑定方法中还有其他参数,会一并传入。

class Student:
    school = 'oldboy'
    def learn(self):
        print(self)
        print('from the world')
stu1 = Student()  ###得到一个对象
stu1.name = 'david'
stu1.sex = 'male'
stu1.age = 20
print(stu1.name,stu1.sex,stu1.age)
>>>>>>>>>>>>>>>
david male 20

注意:

想要在调用类时,为对象传入对象独有的特征:

__init__(self, name, sex, age):  # name---> tank ,  sex---> male,  age----> 17

调用类发生的事情:此时会产生一个对象 obj = Foo(david,20)

1.产生一个空对象的名称空间

2.自动触发内容__init__方法的执行

3会将对象本身当作第一个参数,以及调用括号内的所有参数并传给__init__

调用时,会将对象当作第一个参数,与括号内的所有参数一并传入__init__ ()

-凡是在类内部定义的--开头或者结尾的方法都有特殊的意义

在类内部的定义方法:在调用类时触发,会将对象当作第一个参数,与括号内的所有参数一并传入__init__ ()

class Student:
    school = 'oldboy'
    def __init__(self,name,sex,age):#####name ==david  age == 20  sex ==male
        self.name = name  ###把形参的的具体值,赋值给对象self的属性变量name,这个name可以是任意的,可以是my_name   也可以是self.my_name = name  打印出来的结果是要这么打印                                                                                                                    print(stu1.my_name)    下面的age  sex同理

        self.sex = sex
        self.age = age

    def learn(self):
        print(self)
        print('from the world')

stu1 = Student('david','male',20)
print(stu1.name)
print(stu1.sex)
print(stu1.age)
>>>>>>>>>>>>>
david
male
20

5.对象名称空间的查找顺序

1.对象的属性,会先去找对象自己的;

2.若对象没有,回去找类的;

3.若类没有,则会报错。

class People:
    school = 'oldboy'
    def __init__(self,name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def learn(self):
        print('from the world')
p_obj = People('david','male',20)
print(p_obj.name)####找自己属性的name
print(p_obj.school) ######自己的属性没有,去类中寻找
# print(p_obj.jason)
print(p_obj.__dict__)  #####这个是内存地址
p_obj.school = '中国'
print(p_obj.__dict__)######内存地址中包括了'school': '中国'  
print(People.__dict__)######'school': 'oldboy'
print(p_obj.school)
>>>>>>>>>>>>>>>>>>>
david

oldboy

{'name': 'david', 'sex': 'male', 'age': 20}

{'name': 'david', 'sex': 'male', 'age': 20, 'school': '中国'}

{'__module__': '__main__', 'school': 'oldboy', '__init__': <function People.__init__ at 0x000002096C710268>, 'learn': <function People.learn at 0x000002096C7101E0>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

中国

6.在python中一切皆是对象

# l1 ---> list对象
# l1 = list([1, 2, 3])
# dict()
# tuple((1, 2, 3))
# float
# str
# set
# bool
# enumerate
# bytes
# filter
以上的举例说明 一切皆是对象
python3中,8大数据类型都是类
定义数据类型的值时,内部自动调用响应的类,然后产生对象
# 4.类中数据属性(类中的变量): 类中属性是给对象使用的,对象引用类中的属性,指向的都是类中同一个内存地址。
# 5.类中的方法(类中的函数): 类中的方法是给对象使用的,
# 由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入
# 6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找

# 7.对象绑定方法的特殊之处:
''
类内部的函数
    1.由对象来调用,会将对象当做第一个参数传入。******
    2.若对象的绑定方法中还有其他参数,会一并传入。
    3.由类来调用,就是一个普通的函数,函数需要几个参数,就传入几个参数
#人狗大战
class People:
    def __init__(self,name,life, arg):
        self.name = name
        self.life = life
        self.arg = arg
    def bite(self,dog_obj):
        print(f'人{self.name}开始咬狗{dog_obj.name}')
        if dog_obj.life <= 0:
            print('狗已经挂了')
            return True
        else:
            dog_obj.life -= self.arg
            print(f'狗的生命值减掉{self.arg},还剩余狗的血量是{dog_obj.life}')

class Dog:
    def __init__(self,name, life, dog_type,arg):
        self.name = name
        self.life = life
        self.dog_type = dog_type
        self.arg = arg

    def bite(self,p_obj):
        print(f'狗{self.name}开始咬人了{p_obj.name}')
        if p_obj.life <= 0:
            print('人已经挂了')
            return True
        else:

            p_obj.life -= self.arg
            print(f'人的生命值减掉{self.arg},还剩余人的血量是{p_obj.life}')






p1 = People('aa',3000,1000)
d1 = Dog('bb',6000,'哈士奇',1000)


while True:
    res1 = d1.bite(p1)
    if res1:
        break
    res2 = p1.bite(d1)
    if res2:
        break
>>>>>>>>>>>>>>>>>>>
狗bb开始咬人了aa
人的生命值减掉1000,还剩余人的血量是2000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是5000
狗bb开始咬人了aa
人的生命值减掉1000,还剩余人的血量是1000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是4000
狗bb开始咬人了aa
人的生命值减掉1000,还剩余人的血量是0
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是3000
狗bb开始咬人了aa
人已经挂了

#人狗大战
class People:
    def __init__(self,name,life, arg):
        self.name = name
        self.life = life
        self.arg = arg
    def bite(self,dog_obj):
        print(f'人{self.name}开始咬狗{dog_obj.name}')
        if dog_obj.life <= 0:
            print('狗已经挂了')
            return True
        else:
            dog_obj.life -= self.arg
            print(f'狗的生命值减掉{self.arg},还剩余狗的血量是{dog_obj.life}')

class Dog:
    def __init__(self,name, life, dog_type,arg):
        self.name = name
        self.life = life
        self.dog_type = dog_type
        self.arg = arg

    def bite(self,p_obj):
        print(f'狗{self.name}开始咬人了{p_obj.name}')
        if p_obj.life <= 0:
            print('人已经挂了')
            return True
        else:

            p_obj.life -= self.arg
            print(f'人的生命值减掉{self.arg},还剩余人的血量是{p_obj.life}')






p1 = People('aa',3000,1000)
d1 = Dog('bb',6000,'哈士奇',1000)
lag = True
while flag:

    res2 = p1.bite(d1)
    if res2:
        flag = False
>>>>>>>>>>>>>>>>>>>>>>>
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是5000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是4000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是3000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是2000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是1000
人aa开始咬狗bb
狗的生命值减掉1000,还剩余狗的血量是0
人aa开始咬狗bb
狗已经挂了

posted @ 2019-11-26 14:34  ^更上一层楼$  阅读(126)  评论(0编辑  收藏  举报