类与面向对象

面向对象编程

OOP：面向对象的缩写
object：对象
根据生活中的对象 抽象出程序中的对象 来帮助我们完成指定的功能

类也是有大小之分 分大类和小类：谁包含的多 谁就是大类（仅限于与关联的，两种不同性质的数据是不能去进行比较的）

抽象

抽象：模拟生活中的对象 映射出程序中的类对象和实例对象
类：类型
	10   10.5 []   True ''  ()    {}	set()
	int float list bool str tuple dict set... 这些都属于python中类型
	<class 'int'> class：类型
	在python中 有很多个类型 每一种数据 表示一个类型
	在python中 不需要开发者手动去区分每一个数据是什么类型的python会自动区分

# 创建一个自定义的数据类型
	自己去创建一个类型
		步骤：
		1.确定对象
		2.找出特征和行为
		3.进行分类（因为分类很多 那么根据实际的情况来定义）
		4.使用代码在程序中实现这个类型（在程序中创建一个自定义的数据类型）
			使用公共（是所有对象都拥有的）的特征和行为组成一个类型
			特征就是属性 属性就是在代码中对特征的一个描述方式
			行为就是方法 方法就是一个函数
# 创建一个类	
一般用大驼峰或者小驼峰命名
	（大驼峰：每一个单词的首字母需要大写；小驼峰：第一个单词首字母小写 其后所跟的单词首字母大写）
	
	语法：class 类名:  类名自定义 类名要使用大驼峰/小驼峰的写法 GirlFriend
		# 创建了一个叫Teacher的自定义数据类型
		class Teacher:  # 创建了一个类型 这个类型叫做Teacher 
				pass
		
	pass：占位符
	实例方法：只属于实例对象的方法

对象的创建

对象是根据类产生的实例 
语法：对象名 = 类名()

在python中是万物皆对象 所以类也是一个对象 如果我们创建了一个类 那么我们称之为类对象
如果是根据类产生出来的对象 我们称之为 实例对象...
liu = Teacher() #Teacher是类对象 而milk是实例对象

使用实例方法：
	对象名.实例方法名()

创建实例方法：
	def 方法名(self):
		方法体

	self：表示为一个默认的参数 如果是实例对象调用这个实例方法 那么这个参数
	不需要传递数据 如果是类对象调用这个实例方法 则需要传递一个指定的
	对象才能够执行

定义实例对象的属性
	1.灵活定义
		创建了实例对象之后 使用实例对象去添加属性并赋值
		对象名.属性名 = 值

	liu = Teacher()  # 实例化对象  这个老师有什么行为 有什么特征？ milk是一个对象名
		liu.name = 'Teacher'
		liu.age = 18
		liu.sex = '男'
		liu.weight = '100'
		liu.height = '170'

	2.魔法方法/构造方法
		在创建类的时候加入

##实例
语法：
class 类名：
# 多个（≥0）类属性…
# 多个（≥0）类方法…

# 1.需求:洗衣机， 功能：能洗衣服
# 1.定义洗衣机类
class Washer():
	def wash(self):
		print('能洗衣服')

# 2.创建对象 //实例化一个对象  类似变量
# 对象名 = 类名()
haier = Washer()

# 3.验证结果
# 3.1 打印haier对象  得到内存地址
print(haier)

# 3.2 使用wash功能 --实例方法/对象方法  --- 对象名.wash()    等于调用函数
haier.wash()

属性操作

# 1.定义类
class Washer():
	# 类内部添加属性
	width = 500
	height = 800

	def wash(self):
		print('我会洗衣服')


haier = Washer()
# 类外面添加对象属性 -- 对象名.属性名 = 值
# 添加属性
# haier.width = 500
# haier.height = 800


# 获取属性 -- 对象名.属性名
print(f'haier洗衣机的宽度是{haier.width}')
print(f'haier洗衣机的高度是{haier.height}')


# self的使用
# 1.定义类
class Washer():
	def wash(self):
		print('我会洗衣服')
		# 由于打印对象和打印self得到的内存地址相同，所以self指的是调用该函数的对象  简单的说self就是这个类
		print(self)


# 2.创建对象 -- 对象名 = 类名()
haier = Washer()  # 创建一个实例对象
print(haier)  # 输出他的内存地址

haier.wash()  # 调用haier里的wash函数

print('==' * 20)  # 换行，只是为了好看
haier1 = Washer()  # 再创建一个实例对象
print(haier1)  # 输出他的内存地址
haier1.wash()  # 调用haier1里的wash函数

__init__方法

'''
魔法方法：
在Python里面，两个下划线开头 两个下划线结尾，并且在满足特定条件下自动调用的这类方法  叫做魔法方法也叫构造方法
__init__: 初始化方法
    1.调用时机：在创建对象之后，会立即调用
    2.作用：
        1.用来给对象添加属性，给对象属性一个初始值
        2.代码业务的需求，每创建一个对象，都需要执行的代码可以写__init__中
    注意点：
        如果__init__有除了self只有的参数，那么在创建对象的时候需要给额外的形参传递实参值
        __init__(self)中的self参数，不需要开发者传递，Python解释器会自动把当前的对象引用传递过去。
'''


#不带默认值的传参
 1.定义类  ---  class 类名():#()加不加都行
	class Dog:
		def __init__(self, name, age):
			print('我是__init__方法，我被调用了')
			# 对象.属性名 = 值
			self.name = name
			self.age = age
	
	
	dog = Dog('大黑', 1)  # 创建Dog的实例对象
	print(dog.name)  # 输出dog的name属性
	
	dog1 = Dog('大黄', 2)  # 创建Dog的实例对象
	print(dog1.name)  # 输出dog1的name属性


# 定义一个用户类 ，用户名和密码是这个类的属性
# 1.实例化两个用户，分别有不同的用户名和密码
# 2.设计一个方法  ，修改密码
	class User:
		def __init__(self, username, password):
			self.username = username  # 增加属性
			self.password = password  # 增加属性
			print(f'用户名：{self.username},密码:{self.password}')
	
		def reset_password(self, password_new):
			self.password = password_new  # 把password改成password_new
			print(f'用户名：{self.username},密码:{password_new}')
	
	
	A = User('lisi', 12345)  # 使用User类，写入一个list和123456
	B = User('zhangsan', 12345)  # 使用User类，写入一个zhangsan和123456
	A.reset_password(12347)  # 使用User类的reset_password函数，把password改成password_new
	
	#带默认值的传参：
		class Dog1():
		    def __init__(self, name='小黑', age=5, sex='公', weight=100, color='黑色'):#(小黑，5，公，100，黑色都为默认值)
		        self.name = name
		        self.sex = sex
		        self.age = age
		        self.weight = weight
		        self.color = color
		  dog2=Dog1()
		  print(dog.name)

私有权限

# 子类无法继承父类的私有属性和私有方法
# 设置私有权限方法：在属性名和方法名 前面 加两个下划线__
# 私有无法在外部被直接调用
# print(实例名._父类名__属性名/方法名)  # 在外部访问，不建议使用
 1.师傅类 ， 属性和方法
	class Master(object):
	    def __init__(self):
	        self.kongfu = '煎饼配方'
	
	    def make_cake(self):
	        print(f'运用{self.kongfu}制作煎饼')
	
	
	class Prentice(Master):
	    def __init__(self):
	        self.kongfu = '独创煎饼配方'
	        self.__money = 2000000
	
	    def info_print(self):
	        self.__money = 20000
	        print(self.__money)
	

 2.徒孙类
	class Tusun(Prentice):
	    pass
	
	daqiu = Prentice()
	daqiu.info_print()
	# 在日常开发中，不要使用这种方式
		print(daqiu._Prentice__money)
	
		xiaoqiu = Tusun()
	# 子类无法继承父类的私有属性和私有方法
		print(xiaoqiu.kongfu)
	
	
		xiaoqiu.info_print()


案例
	class Women:
	    def __init__(self, name):
	        self.name = name
	        # 设置私有属性：在属性名前面加两个下划线
	        self.__age = 18
	
	    def __secret(self):
	        print("我的年龄是 %d" % self.__age)

    # 内部获取私有属性 ，推荐
    def get(self):
        print(self.__age)


	xiaofang = Women('小芳')
	# 私有属性 外部不能直接访问
	# print(xiaofang.__age)
	# 私有方法，外部不能直接调用
	# xiaofang.__secret()

	# 外部间接访问私有属性，但是不推荐
	print(xiaofang._Women__age)
	xiaofang.get()

自定义装饰器

'''
装饰器：不改变原有函数，对函数的功能进行增加，本质是一个闭包函数

使用装饰器：@名字

装饰器使用过程:
给cat()加上装饰器
调用cat()
实际上是调用装饰器upgrade()，并且把cat()函数作为参数传入 f = cat()
调用装饰器返回函数
drilling()
print('钻火圈')
f() --> cat() -->print('抓老鼠')
'''

定义装饰器

def upgrade(f):
    def drilling(*args):
        print('钻火圈')
        f(args[0], args[1], args[2])  # 回调函数

return drilling  # 闭包

使用装饰器

	@upgrade
	def cat(name, age, sex):
	    print('抓老鼠')
	    print(name, age, sex)
	
	
	def dog():
	    print('看家')
	
	
	cat('汤姆', 1, 'famle')

内置装饰器

内置装饰器：Python自己写好的装饰器，我们可以直接使用
# @property  # 方法可以向属性一样调用
# @staticmethod  # 静态方法 不需要去传入任何的参数
# @classmethod  # 类方法 把你自动传入的实例化对象变成是自动传入类  原本输出实例对象的内存地址，现输出类别和类名
class Person():
    def __init__(self, name):
        self.name = name

    @property  # 方法可以向属性一样调用
    def play(self):
        print(self.name + 'paly')

    @staticmethod  # 静态方法 不需要去传入任何的参数
    def eat():
        print('吃饭')

    @classmethod  # 类方法 把你自动传入的实例化对象变成是自动传入类
    def sleep(cls):
        print(f'{cls}睡觉')


a = Person('阿')
print(a.name)
a.play
a.eat()
a.sleep()