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
<class '__main__.User'>
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
