首页 > 编程语言> 文章详细

python基础之面向对象1

2019-04-14 14:44:12 阅读：335 来源： 互联网

标签：__ name python self 基础面向对象 print Vector2 def

一、面向对象VS面向过程

　　1、面向过程

　　2、面向对象

二、类与对象

　　1、类和对象

　　　　（1）基本概念

　　　　类和对象的内存图如下：

　　2、实例成员

　　　　（1）实例变量

　　　　（2）实例方法：

　　3、类成员：

　　　　（1）类变量

　　　　　（2）类方法

　　4、静态方法：

三、基本代码：

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


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())

标签：__,name,python,self,基础,面向对象,print,Vector2,def
来源： https://www.cnblogs.com/yuxiangyang/p/10705065.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

python基础之面向对象1