- 面向对象是一种编写代码的思维方式：程序是由什么构成 程序由一个一个对象组成
- 类：其实是一种抽象，
- User类：把用户相关信息抽象到一起
- 类名采用驼峰结构，并且首字母大写
- 类由属性和（方法）行为来组成 属性表示了这个类的特点，（方法）行为规定了这个类的功能
- 程序（类）= 数据结构（属性）+算法（方法、行为）
- 函数定义在类里的时候，称为方法
- 类->实例：类的具体化
- self 具体实例 指的是当前对象（方法的调用者）
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()
- 实例化（创建）对象的过程：1、分配内存出来(new) 先调用new方法 2、初始化值(init)
- 私有属性
print(tom.name) #可直接访问
tom.name = 'JiaFeiCat' #可进行修改
print(tom.name)
- 属性私有化
- 1.两个下划线开头 2. 自己约定_单下划线
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
@property #默认是get的
def age(self):
print("年龄")
return self.__age
@age.setter
def age(self,age):
if age>0 and age<100:
self.__age = age
s = Student("zhangsan",20)
#提供了get、set方法
print(s.get_name())
s.set_name("lisi")
print(s.get_name())
s.age = 50
print(s.age)
- 类也是对象
- self.函数名： 实例属性
- 在类里直接定义属性，称为类属性，类属性由所有对象共享
class User:
num = 0
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) #cls当前类名
user.name = name
user.age = age
return user
@staticmethod
def sum(a,b):
return a + b
def __str__(self):
_str = ""
for k,v in self.__dict__.items():
_str +=str(k)
_str += ":"
_str += str(v)
_str += ","
return _str
u = User("zs")
u.print_name()
u1 = User("ls")
u1.print_name()
User.num += 1
u1.print_name()
u2 = User.create_user('zs',20)
print(u2.age)
print(u2.name)
print(User.sum(2,3))
u3 = u1.create_user('zs',20)
print(u3.age)
print(u3.sum(6,6))
print(u3)
- @classmethod 修饰的方法是类方法，类方法可以通过类名调用，类方法必须有一个类型参数cls.类方法也可以通过实例调用
- @staticmethod 修饰的方式是静态方法，通过类名可以访问。当作普通函数就行。写工具类挺好,静态方法也可以通过实例调用
#模拟一个游戏，有一个怪兽（monster），还有一个玩家（hero）
import random as rn
class hero:
def __init__(self):
self.blood = 100
self.power = 12
def attack (self,monster):
mius = rn.randrange(self.power-5,self.power+5)
def mius_blood(self, num):
self.blood -= num
class monster:
def __init__(self,blood,power):
self.blood = 100
self.power = 10
def attack (self,hero):
mius = rn.randrange(self.power - 5, self.power + 5)
def mius_blood(self,num):
self.blood -=num
import random as rn
class Sprite:
def __init__(self,name):
self.blood = 100
self.power = 12
self.name = name
def attack (self,monster):
mius = rn.randrange(self.power-5,self.power+5)
if monster .has_living():
monster.mius_blood(mius)
print(monster.name +":" +str(monster.blood))
def mius_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(m.name+"获得胜利")
if h.has_living():
print(h.name+"获得胜利")
#Python支持多继承，继承内容与继承顺序相关
#所有的类，都会默认继承object（内置的类）类
class A:
def __init__(self):
self.name = 'A'
@classmethod
def print_test(self):
print("AAAAAAAAAA")
class B:
def __init__(self):
self.name = 'B'
class C(B,A):
def __init__(self):
super().__init__() #先调用被继承类里面东西
self.age = 20 #定义自己类里面的东西
def print_test(self):
super().print_test()
print("BBBBBBBBBBB")
c = C() #代码副用
print(c.name)
print(c.age)
#调用属性或方法的查找顺序
print(C.__mro__)
c.print_test()
#组合优于继承
class D:
def __init__(self):
self.a = A()
def print_test(self):
self.a.print_test()
print("DDDDDDD")
d=D()
d.print_test()
class E:
def test(self):
pass
class F:
def test(self):
pass
