Python第五天学习

python函数基础
2019-05-25
--张伯羽

---

1.面向对象是一种编写代码的思维方式
2.类就是一种抽象，
3.User类，把用户相关信息抽象到一起
4.类名采用驼峰结构，首字母大写
5.类由属性和方法组成，属性表示了类的特点，方法规定了这个累的功能
程序（类）　＝　数据结构（属性） ＋ 算法（方法，行为）
6.函数定义在类里的时候，成为方法
类－>实例：实例是类的具体化
7.self指的是当前对象（方法的调用者）

---

1.类和实例的声明

class Cat:
    # 分配内存
    def __new__(cls, *args, **kwargs):
        print('__new__')
        return super().__new__(cls)
    # 构造方法，该方法会在创建对象（实例）的时候，自动调用
    def __init__(self, color, name):
        self.color = color
        self.name = name
    def catch_Rat(self):
        print(self.name + '抓到了老鼠')
# 创建一个实例
tom = Cat('Blue', 'Tom')
tom.catch_Rat()

__new__
Tom抓到了老鼠

实例化对象：
１，分配内存出来,用双下划线new()方法来处理的
２，初始化值,用双下划线init()方法来处理

• 属性私有化

1,两个下划线开头　
2,自己约定，单下划线
双下划线为什么能够隐藏变量？双下划线dict里面装的是实例的所有属性,双下划线开头的属性或被名称转换：_类名+属性名

# 属性私有化
# 1,两个下划线开头　2,自己约定，单下划线
# 双下划线为什么能够隐藏变量？__dict__里面装的是实例的所有属性,双下划线开头的属性或被名称转换：_类名+属性名
class Student:
    """
    学生类
    """
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def set_name(self, name):
        if not len(name) < 3:
            self.__name = name

    def get_name(self):
        return self.__name

    # 默认是get的
    @property
    def age(self):
        print('年龄')
        return self.__age

    @age.setter
    def age(self, age):
        print("---------------")
        if age > 0 and age < 100:
            self.__age = age


s = Student("恩菲尔德", 20)
# 提供了get(),set()方法
print(s.get_name())
s.set_name('卡尔卡诺')
print(s.get_name())
s.age = 50
print(s.age)

恩菲尔德
卡尔卡诺
---------------
年龄
50

---

• 类也是对象

self,属性名：实例属性
在类里直接定义的属性称为类属性，类属性由所有对象共享

class User:
    num = 1
    def __init__(self, name):
        self.name = name
        User.num += 1

    def print_name(self):
        print(self.name, User.num)

    @classmethod
    def create_user(cls, name, age):
        print(cls)
        user = cls(name)
        user.age = age
        return user

    @staticmethod
    def sum(a, b):
        return a+b

    def __str__(self):
        # return self.name
        _str = ""
        for k,v in self.__dict__.items():
            _str += str(k)
            _str += ':'
            _str += str(v)
            _str += ','
        return _str
u = User('zz')
u.print_name()
User.num += 1
u.print_name()

zz 2
zz 3

• @classmethod 修饰的方法是类方法，类方法可以通过类名调用，类方法必须有一个类型参数：cls

u2 = User.create_user('zz', 20)
print(u2.name)
print(u2.age)

zz
20

• @staticmethod　修饰的方式，是静态方法，通过类名可以访问，当作普通函数就行，写工具类很好用

print(User.sum(2, 3))

us = u.create_user('ss', 21)
print(us.age)
print(us.sum(6, 6))
# 类方法也可以通过实例调用
print(us)

5

21
12

---

2.模拟游戏 —— 打怪

一个玩家，一个怪，回合制游戏

import random as rm
# 角色类
class Sprite:
    def __init__(self,name):
        # 血量，名字和攻击力
        self.blood = 1000
        self.power = 300
        self.name = name

    def attack(self, monster):
        # 攻击伤害和结果
        minus = rm.randrange(self.power - 250, self.power + 100)
        if monster.has_living():
            monster.minus_blood(minus)
        print(monster.name + ':' + str(monster.blood))

    def minus_blood(self, num):
        # 剩余血量
        self.blood -= num

    def has_living(self):
        # 判断是否生还
        if self.blood > 0:
            return True
        return False

m = Sprite('米狄尔')
h = Sprite('灰烬')

while m.has_living() and h.has_living():
    m.attack(h)
    h.attack(m)

if m.has_living():
    print('You Die')
else:
    print('获胜')

灰烬:633
米狄尔:609
灰烬:572
米狄尔:481
灰烬:182
米狄尔:131
灰烬:-65
米狄尔:-95
获胜

---

3.类的继承

python　支持夺继承，继承内容与继承顺序相关
所有的类，都默认继承object类

class A:
    def __init__(self):
        self.name = 'A'
    def print_test(self):
        print('AAAAA')

class B:
    def __init__(self):
        self.name = 'B'

class C(A,B):
    name = 'C'
    def __init__(self):
        super().__init__()
        self.age = 20
c = C()
print(c.name)
print(c.age)
# 调用属性或方法的查找顺序
# print(c.__mro__)

A
20

4.组合优于继承

class D:
    def __init__(self):
        self.a = A()

    def print_test(self):
        self.a.print_test()
        print("DDDDD")

d = D()
d.print_test()

AAAAA
DDDDD

• 鸭子类型 像即一类

class programmer:
    def dowork(self):
        print('biancheng')

class Mananger:
    def dowork(self):
        print('guanli')

employ = Mananger()
employ.dowork()

print(isinstance(c,B))
print(issubclass(B,A))

guanli
True
False