python笔记 类 有待完善

python笔记 类

好记性不如烂笔头，学习从摘抄开始！

(1)定义类

注意：
1.所有的类名要求首字母大写，
2.多个单词使用驼峰式命名，例:SetUp

格式：

class <类名>:
	#定义类属性
	<属性1>
	<属性2>

	#定义对象属性  参数是可选的，可以有参数，也可以没有参数
	def __init__(self,<参数1>,<参数2>,...):
		self.<属性1>
		self.<属性2>
		
	# 定义实例方法
	def <方法名>(self,<参数1>,<参数2>,...):
		pass
	
	# 定义类方法
	@classmethod
	def <类方法名>(cls,<参数1>,<参数2>):
		pass

	# 定义静态方法
	@staticmethod
	def <静态方法名>():
		pass

例子：

class Person:
	#定义类属性
    num = 10

    # 定义对象属性
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    # 定义实例方法
    def f1(self):
        print(self.name, self.age, self.sex)

    # 定义类方法
    @classmethod
    def f2(cls):
        print('测试类方法...')

    # 定义静态方法
    @staticmethod
    def f3():
        print('测试静态方法...')

(2)类属性 和 对象属性

注意：
1.类属性可以不依赖与对象而存在，
2.类属性可以通过类来访问，也可以通过对象来访问
3.对象属性只能通过对象来访问

class Person:
    # 定义类属性
    num = 10

    # 定义对象属性
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

# 通过类来访问类属性
ans = Person.num
print(ans)

# 创建对象
p1 = Person('jack', 13, 'boy')

# 通过对象来访问类属性
ans = p1.num
print(ans)

# 通过对象来访问对象属性
ans = p1.name
print(ans)

结果：

10
10
jack

(3)实例方法

格式：

class <类名>:
	#定义实例方法 参数是可选的，可以有参数，也可以没有参数
	def <方法名>(self,<参数1>,<参数2>,...):
		<方法内容>

(4)类方法

注意：
1.类方法定义需要依赖装饰器@classmethod，且使用关键字 cls 作为函数的参数
2.类方法中只可以使用类属性，无法调用对象属性
3.不依赖于对象，无需创建对象也可以调用类方法：<类名>.<类方法名>

class <类名>:
	# 定义类方法
	@classmethod
	def <方法名>(cls):
		<方法内容>

(5)静态方法

注意：
1.静态方法的定义需要装饰器@staticmethod
2.静态方法是无需传递类似于实例方法和类方法中的 self cls 等参数
3.只可以使用类属性，无法调用对象属性
4.不依赖于对象，无需创建对象也可以调用类方法：<类名>.<类方法名>

class <类名>:
	# 定义类方法
	@staticmethod
	def <方法名>(cls):
		<方法内容>

(6)实例方法、类方法、静态方法的比较：

方法	实例方法	类方法	静态方法
装饰器	无	@classmethod	@staticmethod
必要的参数	self	cls	无
调用方式	通过对象名调用	通过对象名和类名调用	通过对象名和类名调用
是否依赖对象	依赖	不依赖	不依赖
是否可以继承	可以继承	可以继承	不可以继承
可以访问的属性	类属性和对象属性	类属性	类属性

(7)魔术方法

魔术方法就是一个类中的方法，和普通方法唯一不同的是，普通方法需要调用，而魔术方法是在特定时刻自动触发。

1.__init__方法

作用：初始化对象属性

2.__new__方法

To be continued …

3.__call__方法
触发时机：在对象后加上()，将其当成函数使用的时候，会默认调用此函数中的内容

例子：

class Person:
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('测试 __call__')
        
p1 = Person('jack')
p1()

结果：

测试 __call__

4.__del__方法

触发时机：当对象地址没有被引用时，系统自动执行
作用：释放对象地址，回收内存空间

例子

class Person:
    def __init__(self, name):
        self.name = name
        
    def __del__(self):
        print('对象已被销毁')
        
p1 = Person('jack')
p2 = p1
# 此时p1和p2共同指向同一个对象的地址

print(p1.name)
print(p2.name)

del p1
del p2
#此时没有对象执行对象地址，python解释器会自动执行__del__释放内存

结果：

jack
jack
对象已被销毁

5.__str__方法

触发时机:当打印对象时"print(<对象名>)"，自动触发
返回值：必须是字符串类型

例子：

class Person:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return '测试 __str__'

p1 = Person('jack')
print(p1)

结果：

测试 __str__

(8)私有化：

注意：
1.格式：self.__<属性名>
2.就是将属性私有化，访问范围仅仅限于类中
3.需要定义set和get方法
优点：
1.隐藏对象的属性不被外部随意修改
2.通过类中的函数修改，可以控制修改属性的操作，

例子1：私有化对象属性

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def set_age(self, age):
        if age > 0 and age < 100:
            self.__age = age
        else:
            print('{}不在输入范围'.format(age))

    def get_age(self):
        return self.__age

stu1 = Student('jack', 23)

ans = stu1.get_age()
print('age:', ans)

stu1.set_age(125)
ans = stu1.get_age()
print('age:', ans)

stu1.set_age(25)
ans = stu1.get_age()
print('age:', ans)

结果：

age: 23
125不在输入范围
age: 23
age: 25

例子2：私有化+装饰器

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    @property  #返回属性值
    def age(self):
        return self.__age

    @age.setter #对属性从新赋值
    def age(self, age):
        if age > 0 and age < 100:
            self.__age = age
        else:
            print('{}不在输入范围'.format(age))

stu1 = Student('jack', 23)

print('age:', stu1.age)

stu1.age = 125
print('age:', stu1.age)

stu1.age = 25
print('age:', stu1.age)

结果：

age: 23
125不在输入范围
age: 23
age: 25

(9)继承：

注意：父类中私有的属性，子类无法继承

格式：

class：<父类名>：
	def __init__(self,<参数1>,<参数2>,...):
		<父类属性>
		
class <子类名>(父类名):
	def __init__(self,<参数1>,<参数2>,...):
		super().__init__(<参数1>,<参数2>,...)
		<子类新增的属性>

例子:

# 父类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        print('name:{} age:{}'.format(self.name, self.age))


# 子类
class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

    def func2(self):
        print('school:{}'.format(self.school))

stu = Student('jack', 12, '第一中学')
stu.func()
stu.func2()

结果：

name:jack age:12
school:第一中学

(10)多继承

To be continued…

(11)多态：

To be continued

(12)单例：

To be continued