Python 面向对象类

核心概念：类，实例，属性，方法
类：模板，如人类
实例：用模板造出的对象，如貂蝉
属性：是特征
方法：是行为

属性是静态的，方法是动态的，属性是描述有什么特征，方法是说这个类可以干什么，属性不用带括号，方法必须带括号，方法不需要print，属性需要print

面向过程就是直接写函数，c语言就是面向过程，java是面向对象，python二者都可

1、最简单的类

# 类就是一个模板，创建一个狗类
class Dog:
	pass    # 空的类

d1 = Dog()   # 创建第1个实例，实例就是类名加括号
d2 = Dog()  # 创建第二个实例

d1.name = '大黄'  # 赋予属性

print(d1.name)  #访问一个属性就是用.
print(d2.name)

2、在__init__中给类加上属性

class Dog:

	# 构造方法
	def __init__(self, name, height, blood, power): # 传给属性,在一个类里面，类的一个方法第一参数必须加上self
		self.name = name  # 赋值给自己，给当前创建好的实例
		self.height = height
		self.blood = blood
		self.power = power


d1 = Dog('大黄', 0.7, 10, 3)   # 创建第1个实例，实例就是类名加括号，传入参数，第一个self不用传
d2 = Dog('二狗', 0.5, 10, 4)  # 创建第2个实例


print(d1.name, d1.height, d1.blood, d1.power)  #访问一个属性就是用.
print(d2.name)

3、self和默认属性，以及修改属性

class Dog:

	# 构造方法
	def __init__(self, name, height, power): # 传给属性,在一个类里面，类的一个方法第一参数必须加上self
		self.name = name  # 赋值给自己，给当前创建好的实例
		self.height = height
		self.power = power
		self.blood = 10    # 有些属性不一定要传进来，可以在模板里面直接创建好


d1 = Dog('大黄', 0.7, 3)   # 创建第1个实例，实例就是类名加括号，传入参数，第一个self不用传
d2 = Dog('二狗', 0.5, 4)  # 创建第2个实例


print(d1.name, d1.height, d1.blood, d1.power)  #访问一个属性就是用.
print(d2.blood)

# 4、访问属性和修改属性
d2.blood = 9  # 修改属性直接用赋值语句
print(d2.blood) # 属性不用带括号

print(id(d1))  #访问内存地址
print(id(d2))

4、添加和使用方法

class Dog:

	# 构造方法
	def __init__(self, name, height, power): # 传给属性,在一个类里面，类的一个方法第一参数必须加上self
		self.name = name  # 赋值给自己，给当前创建好的实例
		self.height = height
		self.power = power
		self.blood = 10    # 有些属性不一定要传进来，可以在模板里面直接创建好

	#添加方法，所有类里面的参数必须要有self
	def bark(self):
		print(f'我是{self.name}，身高{self.height}，血量{self.blood}，攻击力{self.power}') # self就指代当前的变量

	def attack(self, dog2): #传入被攻击的那条狗
		dog2.blood = dog2.blood - self.power # 血量减去攻击力的参数


d1 = Dog('大黄', 0.7, 3)   # 创建第1个实例，实例就是类名加括号，传入参数，第一个self不用传
d2 = Dog('二狗', 0.5, 4)  # 创建第2个实例

# 不用print，因为自身带了print
d2.bark() # 调用方法时，也是用实例名字.方法名字再带上括号
d1.attack(d2) # d1攻击d2
d2.bark()

5、通过方法改变属性的值

class Dog:

	# 构造方法
	def __init__(self, name, height, power): # 传给属性,在一个类里面，类的一个方法第一参数必须加上self
		self.name = name  # 赋值给自己，给当前创建好的实例
		self.height = height
		self.power = power
		self.blood = 10    # 有些属性不一定要传进来，可以在模板里面直接创建好

	#添加方法，所有类里面的参数必须要有self
	def bark(self):
		print(f'我是{self.name}，身高{self.height}，血量{self.blood}，攻击力{self.power}') # self就指代当前的变量

	def attack(self, dog2): #传入被攻击的那条狗
		dog2.reduce_blood(self.power)

	def reduce_blood(self, reduce_value):  #减少的血量
		if reduce_value > self.blood:    # 减少的血量大于自身的血量
			self.blood = 0
		else:
			self.blood = self.blood - reduce_value

d1 = Dog('大黄', 0.7, 3)   # 创建第1个实例，实例就是类名加括号，传入参数，第一个self不用传
d2 = Dog('二狗', 0.5, 4)  # 创建第2个实例

# 可以改变属性的值
# d1.blood = d1.blood - 4
# d1.blood = d1.blood - 4
# d1.blood = d1.blood - 4 # 连续减里面可能为负
# d1.bark() #bark里面只有self的话，调用不用给参数

d1.reduce_blood(4)
d1.reduce_blood(4)
d1.reduce_blood(4)
d1.bark()

6、类属性

a.整个类只有一份，所有的实例都共享这一份
b.可以通过类名或者实例名访问类属性，访问的都是同一个
c.修改属性需要通过类名
d.因为通过实例名就会创建一个同名的实例变量
e.实例变量和类变量同名时，使用实例变量有限使用的是实例变量

类方法：可以通过类名调用，也可以通过实例名调用

类方法和实例方法的区别：
1、类方法不能访问实例变量，可以访问类变量
2、类方法需要加上@classmethod,第一参数必须是class (cls)

静态方法：
1.需要使用@staticmethod
2.不需要传入实例或者类作为第一个参数

class Dog:
	# num_of_dogs = 0 #类属性
	dogs = []  #用来保存所有狗的列表

	# 类方法    
	@classmethod   # 加标注，类方法
	def num_of_dogs(cls):
		return len(cls.dogs)  #帮我们数一下数组里有多少个

	@classmethod
	def biggest(cls):
		max_height = -1
		for d in cls.dogs:
			if d.height > max_height:
				max_height = d.height
		return max_height

	@staticmethod  #静态方法
	def intro():
		print("Dog is human's best friend")

	# 构造方法——实例方法，添加实例属性，做其他的初始化工作
	def __init__(self, name, height, power): # 传给属性,在一个类里面，类的一个方法第一参数必须加上self
		self.name = name  # 赋值给自己，给当前创建好的实例
		self.height = height
		self.power = power
		self.blood = 10    # 有些属性不一定要传进来，可以在模板里面直接创建好
		# Dog.num_of_dogs = Dog.num_of_dogs + 1
		Dog.dogs.append(self)  #将刚刚创建的这条狗self放进去
		print(f'{self.name}出生了，汪汪')

	#添加方法，所有类里面的参数必须要有self
	def bark(self):
		print(f'我是{self.name}，身高{self.height}，血量{self.blood}，攻击力{self.power}') # self就指代当前的变量

	def attack(self, dog2): #传入被攻击的那条狗
		dog2.reduce_blood(self.power)

	def reduce_blood(self, reduce_value):  #减少的血量
		if reduce_value > self.blood:    # 减少的血量大于自身的血量
			self.blood = 0
		else:
			self.blood = self.blood - reduce_value

d1 = Dog('大黄', 0.7, 3)   # 创建第1个实例，实例就是类名加括号，传入参数，第一个self不用传
d2 = Dog('二狗', 0.5, 4)  # 创建第2个实例

# d1.num_of_dogs = 10 #给d1创建了一个实例属性，当实例属性和类属性相同时，通过实例访问，优先访问的是实例属性
# Dog.num_of_dogs = 8
print(Dog.num_of_dogs())#访问类属性，通过类名访问
print(d1.num_of_dogs())  #通过实例访问类属性
print(d2.biggest())  #通过实例访问类属性

Dog.intro()
d1.intro()

7、类的继承和super

class Dog:

	# 构造方法
	def __init__(self, name, height, power): # 传给属性,在一个类里面，类的一个方法第一参数必须加上self
		self.name = name  # 赋值给自己，给当前创建好的实例
		self.height = height
		self.power = power
		self.blood = 10    # 有些属性不一定要传进来，可以在模板里面直接创建好

	#添加方法，所有类里面的参数必须要有self
	def bark(self):
		print(f'我是{self.name}，身高{self.height}，血量{self.blood}，攻击力{self.power}') # self就指代当前的变量

#牧羊犬
class Sheepdog(Dog):  #继承了Dog
	def __init__(self, name, height, power, num_of_sheep):
		#super就是在类里面引用父类
		super().__init__(name, height, power)  #父类需要这几个参数，self不用传
		self.num_of_sheep = num_of_sheep 

		#给子类添加方法
	def protect(self):
		print('我开始保护小羊了')

	# 若父类里也有同名方法，则优先调取子类里面的
	def bark(self):
		print('我是牧羊犬，我骄傲')
		super().bark()   #还想要父类里这句话就用super调用

#警犬
class PoliceDog(Dog):
	def __init__(self, name, height, power, ability):  #定义构造方法
		super().__init__(name, height, power)
		self.ability = ability

	def detect(self):
		print('我可以抓坏蛋了')

#宠物犬
class  PetDog(Dog):
	def __init__(self, name, height, power, price):
		super().__init__(name, height, power)
		self.price = price

	def sing(self):
		print('我超级可爱啊')

sd = Sheepdog('牧羊犬1', '0.6', 4, 5)
pd = PoliceDog('警犬2', 0.8, 5, 8) 
petd = PetDog('柴犬', 0.3, 4, 5)
print(sd.name)
print(sd.blood)  #调用了父类里面的
sd.bark()  #继承bark方法
sd.protect()
pd.bark()
pd.detect()
petd.bark()
petd.sing()

8、模块、类、引入

import dog

pd = dog.PetDog('小可爱', 0.2, 1, 988)
print(pd.price)
pd.bark()

9、继承标准库中的类-Turtle

继承标准库中的类，让其画一个圆圈

import turtle as t

class MyTurtle(t.Turtle):

	def big_circle(self):
		#定义圈的颜色和大小
		self.color('red')
		self.circle(100)

s = t.Screen()  #创建一个窗口
t = MyTurtle()
t.big_circle()

s.mainloop()  # 让窗口等着我，而不是代码执行完就结束

10、其他实例作为属性

新创建了一个方法狗窝，需要给宠物狗加进去

import dog

house = dog.DogHouse('9527')
pd = dog.PetDog('小可爱', 0.2, 1, 988, house)
print(pd.price)
pd.bark()

11、用isintance来判断实例

#判定狗的类型
def dog_type(self):
	if isinstance(self, SheepDog):  # isinstance是python自带的函数，用来判断当前的实例是不是SheepDog,是的话就返回牧羊犬
		return '牧羊犬'
	elif isinstance(self, PoliceDog):
		return '警犬'
	else:
		return '宠物狗'

练习题

class Car:
	def __init__(self, name, brand):
		self.name = name
		self.brand = brand

	def show(self):
		print(f'汽车名{self.name},汽车品牌{self.brand}')

	def run(self):
		print(f'汽车{self.name}跑起来了')

car = Car('小草', '宝马') #实例


print(car.name, car.brand)
car.show() #调用方法
car.run()

class Car:
	def __init__(self, name, brand, max_people):
		self.name = name
		self.brand = brand
		self.max_people = max_people
		self.number_of_people = 0
		
	def set_people(self, number):
		if number < self.max_people:
			self.number_of_people = number
		else:
			self.number_of_people = self.max_people

	def increase_people(self):
		if self.number_of_people < self.max_people:
			self.number_of_people += 1
			print(f'{self.number_of_people}名乘客在车上')
		else:
			print(self.max_people),print('满了')

	def reduce_people(self):
		if self.number_of_people > 0:
			self.number_of_people -= 1
			print(f'{self.number_of_people}名乘客在车上')
		else:
			print('车上')

car = Car('和谐号', '动车', 100)
car.set_people(50)

car.increase_people()
car.reduce_people()