首页 / PYTHON / python基础之面向对象1

python基础之面向对象1

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了python基础之面向对象1，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6885字，纯文字阅读大概需要10分钟。

内容图文

一、面向对象VS面向过程

　　1、面向过程

　　　　python基础之面向对象1 - 文章图片

　　2、面向对象

　　python基础之面向对象1 - 文章图片

二、类与对象

　　1、类和对象

　　　　（1）基本概念

　　　　　　python基础之面向对象1 - 文章图片

　　　　　　　python基础之面向对象1 - 文章图片

　　　　类和对象的内存图如下：

　　　　python基础之面向对象1 - 文章图片

 

　　　　python基础之面向对象1 - 文章图片

 

　　　　python基础之面向对象1 - 文章图片

　　2、实例成员

　　　　（1）实例变量

　　　　　　python基础之面向对象1 - 文章图片

　　　　（2）实例方法：

　　　　　　python基础之面向对象1 - 文章图片

　　3、类成员：

　　　　（1）类变量

　　　　　　python基础之面向对象1 - 文章图片

　　　　　（2）类方法

　　　　　　　　python基础之面向对象1 - 文章图片

　　4、静态方法：

　　　　python基础之面向对象1 - 文章图片

 

三、基本代码：

　　　　

"""
    面向对象：考虑问题，从对象的角度出发．
    类：模板　　抽象
    对象：具体　
"""


class Wife:
    """
        老婆
    """

    # 1.数据成员 姓名　年龄　性别　．．．
    def __init__(self, name, age, sex):
        # self "自己"，调用当前方法的对象
        print(id(self))
        self.name = name
        self.age = age
        self.sex = sex

    # 2.方法成员 做饭　．．．
    def cooking(self):
        print(id(self))
        print(self.name + "做饭")


# 创建对象(实例化)
# 调用 __init__(self,name,age,sex) 方法
w01 = Wife("丽丽", 21, "女")
print(id(w01))
# 调用对象的方法 w01 将自身传入方法
w01.cooking()


w02 = Wife("芳芳", 22, "男")
w02.cooking()
print(id(w02))

# 在内存中，方法只有一份．而对象有多份．

 

"""
    实例成员
"""

# 创建实例成员，可以不在类中．（在实际项目中，仍然会在__init__方法中）
# class Wife01:
#     pass
#
#
# w01 = Wife01()
# w01.name = "丽丽"
# print(w01.name)
# print(w01.__dict__)# 此时实例变量是：{'name': '莉莉'}
#
# w01 = Wife01()
# print(w01.__dict__) # 此时实例变量是：｛｝


class Wife02:
    def __init__(self,name):
        self.name = name

w01 = Wife02("丽丽")
w01.name = "莉莉"
print(w01.__dict__)# 此时实例变量是：{'name': '莉莉'}
print(w01.name)

w01 = Wife02("丽丽")
print(w01.__dict__)# 此时实例变量是：{'name': '丽丽'}


# 创建实例成员，可以不在__init__中．（在实际项目中，仍然会在__init__方法中）
class Wife03:
    def __init__(self,name):
        self.name = name

    def fun01(self):
        self.age = 10
        print("fun01执行喽")

w01 = Wife03("丽丽")
# 通过对象调用实例方法，会自动传递对象地址．
w01.fun01()
# 通过类名调用实例方法，
Wife03.fun01(w01)
print(w01.age)

 

"""
    类成员
"""
class ICBC:
    """
        工商银行
    """
    # 类变量    相当于被大家共享的"饮水机",
    moneys = 9999999

    # 类方法
    @classmethod
    def print_total_moneys(cls):
        # print(ICBC.moneys)
        print("总行金额：",cls.moneys)

    # 实例方法
    def __init__(self,name,money):
        # 实例变量：相当于每个人的"杯子"
        self.money = money
        self.name = name
        # 从总行中，扣除当前支行的现金
        ICBC.moneys -= money

i01 = ICBC("广渠门支行",100000)
# 调用类变量
# print("总行金额：",ICBC.moneys)
# 调用类方法，此时会自动传递类名进入方法
ICBC.print_total_moneys()

i02 = ICBC("磁器口支行",100000)
# print("总行金额：",ICBC.moneys)
ICBC.print_total_moneys()

 

"""
    静态方法引入
    00   01   02    03
    10   11   12    13
    20   21   22    23

    需求：在某个元素基础上，获取每个方向，指定数量的元素．
          10               向右　　　　　３　　　　－－> 11 12  13
          21               向上　　　　　２　　　　-->11   01
          .....
"""


class Vector2:
    """
        向量
    """

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

        # #　实例方法
        # def fun01(self):
        #     pass
        #
        # # 类方法
        # @classmethod
        # def fun02(cls):
        #     pass
        #
        # # 静态方法：得不到对象地址／也得不到类名
        # @staticmethod
        # def fun03():
        #     pass


# v01 = Vector2()
# v01.fun01()# 隐式传递对象地址
#
# Vector2.fun02()# 隐式传递类名
#
# Vector2.fun03()


def right():
    return Vector2(0,1)


def up():
    return Vector2(-1,0)

# ...


# 在某个元素基础上，获取每个方向，指定数量的元素．
def get_elements(list_target, v_pos, v_dir, count):
    result = []
    for i in range(count):
        # 位置　＋＝　方向
        # 1 0        0 1   －－＞ 1 1
        # 1 1        0 1         1 2
        # 1 2        0 1         1 3
        v_pos.x += v_dir.x
        v_pos.y += v_dir.y
        result.append(list_target[v_pos.x][v_pos.y])
    return result


list01 = [
    ["00", "01", "02", "03"],
    ["10", "11", "12", "13"],
    ["20", "21", "22", "23"],
]

#  10               向右　　　　　３　　　　－－> 11 12  13
# re01 = get_elements(list01,Vector2(1,0),Vector2(0,1),3)
#  21               向上　　　　　２　　　　-->11   01
# re02 = get_elements(list01,Vector2(2,1),Vector2(-1,0),2)


# 10               向右　　　　　３　　　　－－> 11 12  13
re01 = get_elements(list01,Vector2(1,0),right(),3)
print(re01)
re02 = get_elements(list01,Vector2(2,1),up(),2)
print(re02)

 

 

五、实例：

　　练习1

　　

"""
    (1)学生student是一个类，具有姓名，年龄等数据；
    具有学习study，工作work等行为。
    对象：悟空同学，28岁。
          八戒同学，29岁。

"""
class Student:
    """
        学生类
    """
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def study(self):
        print(str(self.age) + "学习")

    def work(self):
        print(self.name+"工作")

# s01 悟空对象的地址
s01 = Student("悟空",28)
s02 = Student("八戒",29)

# 通过对象地址，调用对象方法，会自动传递对象地址．
s01.study()
s02.work()

　　练习2：

　　

"""
    练习：
"""

class Enemy:
    """
        敌人
    """
    def __init__(self,name = "",hp = 0,atk = 0.0,atk_speed = 0.0):
        self.name = name
        self.hp = hp
        self.atk = atk
        self.atk_speed = atk_speed

    def print_self(self):
        print(self.name,self.hp,self.atk,self.atk_speed)


# 1. 在控制台中输入３个敌人，存入列表．
# 2. 将敌人列表输出（调用print_self）到控制台

# e01 = Enemy("zs",100,1000,5)
# list_enemy = []
# for i in range(3):
#     e = Enemy()
#     e.name = input("请输入姓名：")
#     e.hp = int(input("请输入血量："))
#     e.atk = float(input("请输入攻击力："))
#     e.atk_speed = float(input("请输入攻击速度："))
#     list_enemy.append(e)
#
# for item in list_enemy:
#     item.print_self()

# 练习３：定义函数，在敌人列表中，根据姓名查找敌人对象．
# e01 = Enemy("zs",100,10,2)
# e02 = Enemy("ls",200,5,3)
# e03 = Enemy("ww",300,8,5)
#
# list_enemy = [e01,e02,e03]

def get_enemy_for_name(list_enemy,name):
    # 遍历敌人列列表
    for item in list_enemy:
        # 如果有指定名称的敌人对象
        if item.name == name:
            # 则返回对象地址
            return item

list01 = [
    Enemy("zs",100,10,2),
    Enemy("ls", 200, 5, 3),
    Enemy("ww",300,8,5)
]

re = get_enemy_for_name(list01,"ls")

if re != None:
    re.print_self()
else:
    print("没有找到")

　　练习3：

　　

"""
    二维列表工具
"""


class Vector2:
    """
        向量
    """

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    # 将函数转移到类中，就是静态方法．
    @staticmethod
    def right():
        return Vector2(0, 1)

    @staticmethod
    def up():
        return Vector2(-1, 0)

    @staticmethod
    def left():
        return Vector2(0, -1)

    @staticmethod
    def down():
        return Vector2(1, 0)

    @staticmethod
    def right_up():
        return Vector2(-1, 1)


class DoubleListHelper:
    """
        二维列表助手类
            定义：在开发过程中，所有对二维列表的常用操作．
    """

    @staticmethod
    def get_elements(list_target, v_pos, v_dir, count):
        result = []
        for i in range(count):
            v_pos.x += v_dir.x
            v_pos.y += v_dir.y
            result.append(list_target[v_pos.x][v_pos.y])
        return result


# 测试．．．．．．．．．．．．．
list01 = [
    ["00", "01", "02", "03"],
    ["10", "11", "12", "13"],
    ["20", "21", "22", "23"],
]

# 10               向右　　　　　３　　　　－－> 11 12  13
re01 = DoubleListHelper.get_elements(list01, Vector2(1, 0), Vector2.right(), 3)
print(re01)

# 练习１：在二维列表中，获取23位置，向左，３个元素．
re02 = DoubleListHelper.get_elements(list01, Vector2(2, 3), Vector2.left(), 3)
# 练习２：在二维列表中，获取02位置，向下，２个元素．
re02 = DoubleListHelper.get_elements(list01, Vector2(0, 2), Vector2.down(), 2)
# 练习３：在二维列表中，获取20位置，右上，２个元素．
re02 = DoubleListHelper.get_elements(list01, Vector2(2, 0), Vector2.right_up(), 2)
print(re02)

　　练习4：

　　

"""
    练习：　对象计数器　
        　创建老婆类(名字...)，随意实例化对象．
    　　　统计老婆数量（定义方法）
        　画出内存图
"""

class Wife:
    # 计数器
    count = 0

    @classmethod
    def get_count(cls):
        return Wife.count

    def __init__(self,name):
        # 实例变量
        self.name = name
        # 统计
        Wife.count += 1

w01 = Wife("王超")
w02 = Wife("马汉")
# 通过类名，访问类方法
print(Wife.get_count())

　　

 

 

 

　　　　

内容总结

以上是互联网集市为您收集整理的python基础之面向对象1全部内容，希望文章能够帮你解决python基础之面向对象1所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/832454.html

来源：【匿名】