• 1009 面向对象编程


    面向对象编程

    指的是一种编程思想

    1.面向过程编程

    核心是'过程'两字,基于流程编写程序

    优点: 逻辑清晰,使复杂问题简单化

    缺点: 可扩展性差

    2.面向对象编程

    核心是"对象"两个字,对象指的是特征与技能的结合体

    基于该编程思想编写程序,类似于上帝造人,为每个类定义.

    优点: 可扩展性高

    缺点: 编写程序的复杂程度远高于面向过程思想

    理解为一个模板,通过他创建出无数个具体实例.

    对象

    类本身不能直接使用,通过类创建出的实例--对象.才能使用.

    类似于图纸与产品的关系,图纸(类)不能直接使用,通过图纸创造产品(对象)才能使用

    属性

    类中的所有变量称为属性.(变量名)

    方法

    类中的所有函数称之为方法,和函数不同是,类方法至少要包含一个self参数.类方法无法单独使用,只能个类的对象一起使用.

    先定义类,创建类的实例对象,通过实例对象实现特定的功能

    类的定义

    类的组成由1.类名 2. 类的属性(一组数据) 3. 类的方法(要实现的功能)

    class 类名():
        #属性
        a = xx
        #方法
        def 方法名(self):
            pass
    
    # 类的实例化/对象
    t = 类名()
    # 使用类里面的方法
    t.方法名()
    # 往类里面添加属性
    t.name = "张三" 
    

    定义类时发生的事:

    ​ 1.类在定义时,会产生一个空的名称空间

    ​ 2.把类内部的所有名字,扔到类的名称空间中

    类名会指向类的名称空间, 类名.__dict__可以查看类名称空间中所有名字

    class empty:
        pass
    # 这是一个空类
    
    class person:
        '''定义了一个person类'''
        
        hair = 'black'
        # 定义了一个类属性
        
    	def say(self,content):  # (self参数特殊意义)
            # 定义了一个say方法
            print(content)
    

    类的修改

    通过'' 类名+.+ 属性/方法'' 的方式对类内部进行修改

    .对指向类内存的名称空间,从而获取名字

    class old:
        school = 'oldboy'
    
    # 增
    old.name = 'tank'
    print(old.name)   # tank
    # 删
    del old.name
    print(old.name)  # 报错,
    # 改
    old.school = 'oldgirl'
    print(old.school)  # oldgirl
    # 查
    print(old.school)  # oldgirl
        
    

    __init__(self)类构造方法

    创建类时,可以手动添加__init__()方法,这是一个特殊的类实例方法,称为构造方法(或构造函数),

    数据的初始化,不需要调用,当创建了一个对象时既自动调用了该方法。

    __init__()方法可以包含多个参数,但必须包含一个名为self的参数
    且必须是第一个参数
    # 注意,如果开发者没有为该类定义任何构造方法,那么 Python 会自动为该类创建一个只包含 self 参数的默认的构造方法。
    

    创建一个名为san的person类对象,调用时自动触发执行了构造方法

    class person:
        def __init__(self):
            print('调用构造方法')
      
    san = person()
    # 运行输出
    调用构造方法
    

    构造方法可以传入多个参数,self不需要主动传参,self 就是对象本身

    谁调用这个对象,self就指向谁。
    如果使用了self.变量名,同一个类里面的方法都可以使用。

    class person:
    	def __init__(self,name,age):
    		print(' "名字是:",name, "年龄为:"')
        
    # 创建张三对象,并传递参数给构造函数
    zhangsan = person("张三",20)
    
    # 执行输出为     名字是:张三, 年龄为:20
    

    对象的创建和使用

    class语句只能创建一个类,无法创建类的对象,如果想要使用创建好的类,必须手动创建类的对象,这个过程称为类的实例化

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

    class person:
        school = 'oldbay'
        # 若init有其他参数,创建对象时必须传参
    	def __init__(self,name,age):
    		print(' "名字是:",name, "年龄为:"')
        def student():
            pass
    # 创建张三对象,并传递参数给构造函数
    zhangsan = person("张三",20)
    zhagsan.school()    # 可以调用属性
    zhangsan.student()	# 可以调用函数方法
    
    # 执行输出为     名字是:张三, 年龄为:20
    

    名称空间的产生

    1.类的名称空间在定义类阶段就已经产生了

    2.对象的名称空间,在调用类时产生

    调用类时发生的事情

    1. 首先产生了一个空的对象,产生'对象的名称空间
    2. 会自动触发__init__
    3. 会把对象以及括号内的参数一并传给__init__函数

    对象添加特征

    self 就是对象本身

    class old:
        def __init__(self,x,y):
            print(x,y)
           
    stu = old('nick',18)
    # 运行  nick 18
    
    '''方式1'''
    stu.name = 'nick'  # 对象的赋值方式
    print(stu.name)  
    #  nick
    
    '''方法2'''  *****
    class old:
        def __init__(self,x,y):
            self.name = x   # 在__init__内部添加属性
            self.age = y
           
    stu = old('nick',18)  #  可以在调用时传入不同参数
    print(stu.name)    # nick
    

    对象与类的查找顺序

    对象 ==> 类 ==> 报错

    1. 对象属性,若对象本身有,则优先查找对象自己的
    2. 若对象本身没有,则去类里面找,若类没有,则报错.

    对象绑定方法的特殊之处

    类内部的函数主要是给对象用的:

    1. 由类来调用类内部的函数,该函数只是一个普通的函数,需要传入指定数量的参数.
    2. 由对象来调用称之为对象的绑定方法,不同的对象调用该绑定方法,则会将不同的对象传入该绑定方法中
    3. 对象的绑定方法是由对象来调用的,特殊之处就是把对象当做第一个参数传入该方法中.
    class Old:
        school = 'oldboy'
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def lenarn (self):
            print('请输入密码')
    
    # 1.用类来调用函数,函数有几个参数,需传几个参
    Old.lenarn(123)    # 请输入密码
    
    # 2.用对象来调用类中函数,不需要传参(会将对象当做self传入)绑定方法.
    stu = Old('nick',20)
    stu.lenarn()   # 请输入密码
    

    对象之间与类的方法功能是一样

    一切皆对象

    八大数据类型都是类,python中一切皆对象.

    self用法

    class Dog:
        def __init__(self):
            print("正在执行构造方法")
        # 定义一个jump()实例方法
        def jump(self):
            print("正在执行jump方法")
    

    python中要求,类方法中(构造方法,实例方法)中至少包含一个参数,但没有规定此函数的名称,约定俗成使用self.

    作用:

    同一个类可以产生多个对象,当某个对象调用类方法时,该对象会把自身的引用作为第一个参数传给该方法

    python会自动绑定类方法的第一个参数指向调用该方法的对象.

    对于构造方法来说,self参数(第一个参数)代表该构造方法正在初始化的对象
    

    因此,程序在调用实例方法和构造方法时,不需要为第一个参数传值。

    人狗大作战

    '''制作一个互相攻击的游戏'''
    
    class people:
        def __init__(self,name,aggr,life):
            self.name = name
            self.aggr = aggr
            self.life = life
        def skill(self,dog):
            if dog.life  <= 0:
                return True
            dog.life -= self.aggr
            print(f'''
            人{self.name}攻击狗{dog.name}
            狗受伤{self.aggr}
            狗还剩血量{dog.life}
            ''')
    
    
    class dog:
        def __init__(self,name,dog_type,aggr,life):
            self.name = name
            self.dog_type = dog_type
            self.aggr = aggr
            self.life = life
    
        def skill(self,people):
            if people.life <= 0:
                return True
            people.life -= self.aggr
            if people.life <0:
                return '''f'
            {self.name}狗攻击{people.name}人
            人受到{self.aggr}点伤害
            游戏结束
            '''''
            print(f'''
            {self.name}狗攻击{people.name}人
            人受到{self.aggr}点伤害
            人还剩{people.life}血量
            ''')
    
    p = people('AAA',100,500)
    D =dog('旺财','哈士奇',200,700)
    
    while True:
        flag = D.skill(p)
        if flag:
            break
        flag = p.skill(D)
        if flag:
            break
    
    
  • 相关阅读:
    斯坦福【概率与统计】课程笔记(〇):前言
    斯坦福【概率与统计】课程笔记(二):从EDA开始
    dot
    左移右移
    树莓派系统烧写+网络配置
    windows上面捕获声卡数据
    python1
    继续进销存系统
    base64编码
    DES原理
  • 原文地址:https://www.cnblogs.com/fwzzz/p/11644167.html
Copyright © 2020-2023  润新知