python 类和对象 经常用吗_python中类和对象的使用

1.类方法和静态方法

类中的方法分为：对象方法，类方法，静态方法

1.对象方法

a.直接声明在类中

b.有默认参数self的函数

c.通过对象调用 对象.对象方法()

2.类方法

a.在声明前添加 @classmethod

b.默认参数 cls ， 调用的时候不需要传参，系统会自动将调用当前类方法的类传给cls

cls最终指向的是一个类，类可以做的事情，cls都可以做

c.通过类来调用，类.类方法()

3.静态方法

a.在声明前添加 @staticmethod

b.没有默认参数

c.通过类调用 类.静态方法()

4.怎么选择对象方法，类方法，静态方法

什么时候使用对象方法：

当实现函数的功能需要用到对象的属性的时候使用对象方法

什么时候使用类方法：

当实现函数的功能不需要用到对象的属性，但需要使用类的时候使用类方法

什么时候使用静态方法：

实现函数的功能不需要使用对象的属性，也不需要类的时候就使用静态方法

class Person():

#类的字段

num = 123

def __init__(self,name):

self.name = name

#对象方法

def eat(self, food):

print('%s在吃%s'%(self.name,food))

#类方法

@classmethod

def destroy(cls):

print('人类在破坏环境')

#可以通过cls创建对象

p1 = cls('小花')

#可以用cls调用类的字段

print(cls.num)

#可以通过cls调用类相关方法

p1.eat('面包')

#静态方法

@staticmethod

def hit_animal():

print('殴打小朋友')

Person.destroy() #cls = Person

Person.hit_animal()

#练习 声明一个数学类，属性：pi 功能 球俩数和，求圆的面积

class Math:

pi = 3.1415926

@staticmethod

def sum_(num1,num2):

return num1 + num2

@classmethod

def area(cls,r):

return cls.pi * r**2

print(Math.sum_(1,2))

print(Math.area(2))

2.私有化

2.1.私有化

在类中可以通过在属性名前，或者方法名前加两个,(注意：结尾不能以_结尾)，那么这个属性和方法就会变成私有的属性和方法

私有的属性和方法，在类的外部不能使用

class Person:

__num = 100

def __init__(self):

self.name = '张三'

def __show_message(self):

print('名字：',self.name)

print(Person.__num)

def func1(self):

self.__show_message()

p1 = Person()

2.2.私有化原理

python中没有真正的私有化，不能从访问权限上控制属性和方法的使用，只是在名字前有两个下划线 __ 但是没有以 __ 结尾的名字前再加了一个_’类名‘，导致不能通过原属性和方法进行访问

3.对象属性的getter和setter

3.1.getter和setter

如果希望在获取对象属性之前要做点儿别的事情，就给这个属性添加getter；

如果希望在给对象属性赋值之前做点儿别的事情，就给这个属性添加setter

3.2.给对象属性添加getter

a.属性命名的时候，属性名前加_; 例如：self._age = 0

b.声明一个函数，函数的名字是属性名(不要下划线),不需要额外参数,有返回值；并且函数前使用@property修饰。

这个函数的返回值就是获取属性的结果

例如：

@property

def age(self):

return 年龄相关值

c.当需要获取属性的时候通过对象.不带下划线的属性；例如：对象.age

3.3.给对象属性添加setter

想要给对象属性添加setter，必须先给它添加getter

a.属性命名的时候，属性名前加_; 例如：self._age = 0

b.声明一个函数，函数的名字是属性名(不要下划线)，需要一个额外的参数,不用返回值;

并且函数前使用@getter名.setter修饰

例如:

@age.setter

def age(self, value):

self._age = value

c.当需要给属性赋值的时候，通过对象.不带下划线的属性来赋值；例如: 对象.age = 100

class Person:

def __init__(self, name='小红'):

self.name = name

self._age = 60

self.sex = '男'

# 这儿的age函数就是属性_age的getter方法

@property

def age(self):

if self._age < 1:

return '婴儿'

elif self._age < 18:

return '未成年'

elif self._age < 50:

return '中年'

else:

return '老年'

# 这儿的age函数就是属性_age的setter

@age.setter

def age(self, value):

if not isinstance(value, int):

print('年龄必须是整数!!!!')

raise ValueError

if not (0 <= value <= 100):

print('年龄超出范围!!!!')

raise ValueError

self._age = value

p1 = Person()

# print(p1.age) # 希望取到的不是年龄值，而是年龄对应的阶段

# p1.age = '12' # 存 0

# p1.age = '100' # 150

# 这儿实质是在调用_age的getter方法

print(p1.age)

# 这儿实质是在调用_age的setter方法: p1.age(80)

p1.age = 80

# 练习：声明一个时间类，有一个属性是以秒的形式保存时间

# 不断的输入时间，以'XX:XX'的形式输入。输入多少个时间就保存多少个时间对象。知道输入end为止

class Time:

def __init__(self):

self._second= 0

@property

def second(self):

return self._second

# '01:11 - 71'

@second.setter

def second(self, value: str):

times = value.split(':')

self._second = int(times[0])*60 + int(times[1])

补充：打印自己声明的类的对象的时候，默认打印的是：

如果不希望以默认的方式去打印对象，可以实现__ repr __魔法方法。打印对象的时候就会打印这个方法的返回值

这个函数的返回值必须是字符串

def __repr__(self):

return '时间:'+ str(self.second)

"""

10:20 -> time.秒 = 620

1:20 -> time.秒 = 80

"""

# times = []

# while True:

# value = input('时间:')

# if value == 'end':

# break

# # 创建对象，并且将输入的内容赋给时间

# t = Time()

# t.second = value

# times.append(t)

#

# print(times)

class Student:

def __init__(self, name, age):

self.name = name

self.age = age

# def __repr__(self):

# return '[' + self.__class__.__module__+'.'+\

# self.__class__.__name__+' object at '+ hex(id(self))+']'

def __repr__(self):

# return 'name:%s, age:%d' % (self.name, self.age)

return str(self.__dict__)[1:-1]

stu1 = Student('小明', 29) # >>__main__.Student object at 0x1077a9550<<

stu2 = Student('小🌺', 18) # name:小🌺, age:18

print(stu1, stu2)

4.类的继承

4.1.继承

python中的类支持继承，并且支持多继承。

python中默认情况是继承自object(object是python中所有类的基类)

a.什么是继承

一个类可以继承另外一个类，继承者我们叫子类，被继承者叫父类。继承就是让子类直接拥有父类中的内容

b.可以继承哪些内容

所有的属性和方法都可以继承

class Person(object):

num = 61

# 注意：__slots__对应的值不会被继承

__slots__ = ('name', 'age', 'sex')

def __init__(self):

self.name = '张三'

self.age = 0

self.sex = '男'

def show_message(self):

print('%s你好吗?' % self.name)

# Student类继承自Person类

class Student(Person):

pass

# 创建学生对象

stu1 = Student()

# 对象属性可以继承

print(stu1.name, stu1.age, stu1.sex)

# 类的字段可以继承

print(Student.num)

# 对象方法可以继承

stu1.show_message()

p1 = Person()

# p1.color = '黄色'

stu1.color = '白色'

print(stu1.color)

5.子类-添加方法

子类除了拥有从父类继承下来的属性和方法，还拥有属于自己的属性和方法

5.1.在子类中添加方法

a.添加一个新的方法

直接在子类中声明其他的方法;

添加后子类可以调用自己的方法也可以调用父类的方法，但是父类不能调用子类的方法

b.重写父类的方法: 重新实现父类的方法

完全重写 - 覆盖父类的功能 - 直接在子类中重新实现父类的方法

部分重写 - 保留父类的功能，添加新的功能 - 在子类中实现父类方法的时候通过super()去调用父类的方法，

再添加新的功能

注意：a.可以子类的方法中通过super()去调用父类的方法

super(类, 对象)- 获取对象中父类的部分(要求对象是这个指定的类的对象)

b.静态方法中不能使用super()

c.类中方法的调用过程

通过对象或者类调用方法的时候，先看当前类中是否声明过这个方法，如果声明过就直接调用当前类对应的方法;

如果当前类中没有声明过，会去找父类中有没有声明过这个方法，声明过就调用父类的方法;

如果父类中也没有声明过，就去找父类的父类...以此类推，直到object中也没有声明过，程序才会崩溃

class Person:

# 类的字段

num = 61

# 对象属性

def __init__(self):

self.name = '张三'

self.age = 0

self.sex = '男'

def fun1(self):

print('Person的对象方法')

# 方法

def show_message(self):

print('%s,你好吗？' % self.name)

@staticmethod

def info():

print('我是人类')

class Student(Person):

def study(self):

print('%s在学生' % self.name)

@classmethod

def message(cls):

super().info()

print('我是学生!')

# 完全重写

@staticmethod

def info():

print('我是学生！！！')

# 保留父类的功能

def show_message(self):

super().show_message()

print('我去上学~')

super().fun1()

# Student.info()

6.子类-添加属性

6.1.添加类的字段

直接在子类中添加新的字段

6.2.添加对象属性

继承对象属性是通过继承父类的init方法继承下来的

如果想要在保留父类继承下来的对象属性的前提下，添加新的对象属性，

需要在子类的init方法中，通过super()去调用父类的init方法

class Person:

num = 61

def __init__(self, name):

self.name = name

self.age = 0

class Student(Person):

number = 100

def __init__(self, name):

super().__init__(name)

self.study_id = '001'

print(Student.number, Student.num)

stu1 = Student('小明')

print(stu1.name, stu1.age, stu1.study_id)

# 练习：

# 声明一个动物类，有属性：年龄，颜色，类型。

# 要求创建动物对象的时候类型和颜色必须赋值，年龄可以赋值也可以不赋值

# 声明一个猫类，有属性:年龄，颜色，类型, 爱好

# 要求创建猫对象的时候，颜色必须赋值，年龄和爱好可以赋值也可以不赋值，类型不能赋值

class Aniaml:

def __init__(self, type, color, age=0):

self.type = type

self.color = color

self.age = age

class Cat(Aniaml):

def __init__(self, color, age=0, hobby=''):

super().__init__('猫科', color, age)

self.hobby = hobby

an1 = Aniaml('犬科', '黄色')

an2 = Aniaml('犬科', '黄色', 10)

cat1 = Cat('白色')

cat2 = Cat('灰色', 3)

cat3 = Cat('灰色', hobby='睡觉')

cat4 = Cat('灰色', 3, '睡觉')