Python打卡十四——类

Python打卡（十四）

1、简单的类结构和构造函数

'''
    类中的函数必须使用self参数，并且次参数必须位于第一位
    注意：
    1、构造函数固定格式为__init__(self)
    2、创建对象，我们需要定义构造函数__init__()方法。构造方法用于执行“实例对象的初始化工
       作”，即对象创建后，初始化当前对象的相关属性，无返回值。
    3、如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参
       的__init__方法，系统不创建默认的__init__方法。
    4、在使用类似 s1 = Student("任嘉伦",31) 的语句后系统会自动调用__new__()函数和__init__()
       两个函数，但是__new__()函数无需自己定义
'''
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def see_age(self):
        print("该生姓名为{0},年龄为{1}".format(self.name,self.age))

s1 = Student("任嘉伦",31)
s1.see_age()

运行结果：

该生姓名为任嘉伦,年龄为31

2、实例属性和实例方法

'''
    实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：
    1. 实例属性一般在__init__()方法中通过如下代码定义：
        self.实例属性名 = 初始值
    2. 在本类的其他实例方法中，也是通过 self 进行访问：
        self.实例属性名
    3. 创建实例对象后，通过实例对象访问：
        obj01 = 类名() #创建对象，调用__init__()初始化属性
        obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

    实例方法：（从属于实例属性）
    a = Student()
    a.say_score() ——————> 解释器翻译为：Student.say_score(a)
'''
class Student:
    def __init__(self,name,age):
        self.name = name       #name和age均为示例属性
        self.age = age
    def see_age(self):         #see_age为实例方法
        print("该生姓名为{0},年龄为{1}".format(self.name,self.age))

s1 = Student("任嘉伦",31)
s1.see_age()

s1.salary = 3000  #创建完对象之后可以为该对象增加实例属性
print(s1.salary)

Student.see_age(s1)   #与s1.see_age()结果一致

s2 = Student("肉骨茶",21)
print(s2.salary)   #s2对象没有salary属性，因为类这个模具中并未定义salary属性

运行结果：

该生姓名为任嘉伦,年龄为31
3000
该生姓名为任嘉伦,年龄为31
Traceback (most recent call last):
  File "D:/Python/project/studyPython/Object_Oriented/shilishuxing.py", line 31, in <module>
    print(s2.salary)   #s2对象没有salary属性，因为类这个模具中并未定义salary属性
AttributeError: 'Student' object has no attribute 'salary'

其他操作：

'''
其他操作：
    1. dir(obj)可以获得对象的所有属性、方法
    2. obj.__dict__ 对象的属性字典
    3. pass 空语句
    4. isinstance（对象,类型） 判断“对象”是不是“指定类型”
'''

print(dir(s1))
print(s2.__dict__)

class Man:
    pass

print(isinstance(s1,Student))
print(isinstance(s1,Man))

运行结果：

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'salary', 'see_age']
{'name': '肉骨茶', 'age': 21}
True
False

3、类对象、类属性、类方法

（1）类对象

'''
    类对象是针对模具本身来说的，当解释器执行class语句时，就会创建一个类对象
    一个类只有一个类对象
'''
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_age(self):
        print("{0}的年龄是{1}".format(self.name,self.age))

stu2 = Student
s1 = Student("任嘉伦",31)
s1.say_age()
s2 = stu2("肉骨茶",21)
s2.say_age()

运行结果：

任嘉伦的年龄是31
肉骨茶的年龄是21

（2）类属性

'''
    类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。
    类属性的定义方式：
        class 类名：
            类变量名= 初始值
    在类中或者类的外面，我们可以通过：“类名.类变量名”来读写
'''

class Student:
    company = "BaiDu"  # 类属性
    count = 0  # 类属性

    def __init__(self, name, score):
        self.name = name  # 实例属性
        self.score = score
        Student.count = Student.count + 1

    def say_score(self):  # 实例方法
        print("我的公司是：", Student.company)
        print(self.name, '的分数是：', self.score)

s1 = Student('张三', 80)  # s1 是实例对象，自动调用__init__()方法
s1.say_score()
s2 = Student('李四', 90)
s3 = Student('王五', 20)
s4 = Student('赵柳', 150)
print('一共创建{0}个 Student 对象'.format(Student.count))

运行结果：

我的公司是： BaiDu
张三 的分数是： 80
一共创建4个 Student 对象

内存分析：

（3）类方法

'''
    类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：
    @classmethod
    def 类方法名(cls [，形参列表]) ：
        函数体
    要点如下：
    1. @classmethod 必须位于方法上面一行
    2. 第一个 cls 必须有；cls 指的就是“类对象”本身；
    3. 调用类方法格式：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传值。
    4. 类方法中访问实例属性和实例方法会导致错误
    5. 子类继承父类方法时，传入 cls 是子类对象，而非父类对象
'''
class Student:

    company = "BaiDu"

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_score(self):  # 实例方法
        print("我的公司是：", Student.company)
        print(self.name, '的年龄是：', self.age)

    @classmethod
    def printcompany(cls):
        print(cls.company)
        #print(self.name) #类方法中访问实例属性和实例方法会导致错误
        #print(self.say_score())   #类方法中访问实例属性和实例方法会导致错误

Student.printcompany()
s1 = Student("ll",23)
Student.say_score(s1)

运行结果：

BaiDu
我的公司是： BaiDu
ll 的年龄是： 23

（4）静态方法（与本类无关的函数）

'''
    Python 中允许定义与“类对象”无关的方法，称为“静态方法”。
    “静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。

    静态方法通过装饰器@staticmethod 来定义，格式如下：
    @staticmethod
    def 静态方法名([形参列表]) ：
        函数体

    要点如下：
    1. @staticmethod 必须位于方法上面一行
    2. 调用静态方法格式：“类名.静态方法名(参数列表)”。
    3. 静态方法中访问实例属性和实例方法会导致错误

'''
class Student:
    company = "SXT" # 类属性

    @staticmethod
    def add(a, b): # 静态方法
        print("{0}+{1}={2}".format(a,b,(a+b)))
        return a+b

Student.add(20,30)

运行结果;

20+30=50

4、析构方法

'''
        __del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象
    占用的资源，例如：打开的文件资源、网络连接等。

    Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用__del__方法。

    我们也可以通过 del 语句删除对象，从而保证调用__del__方法。

    系统会自动提供__del__方法，一般不需要自定义析构方法。
'''

class Test:

    def __del__(self):
        print("释放对象{0}".format(self))

t1 = Test()
t2 = Test()
del t2
print("程序结束")

运行结果：

释放对象<__main__.Test object at 0x000002174F7D5A48>
程序结束
释放对象<__main__.Test object at 0x000002174F7D28C8>

5、可调用对象

'''

    定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。

'''
class Salary:

    def __call__(self, salary):
        print("算工资啦!!!")
        yearsalary = salary * 12
        daysalary = salary // 22.75
        hoursalary = daysalary // 8

        return dict(yearsalary=yearsalary,monthsalary=salary,daysalary=daysalary,hoursalary=hoursalary)

s = Salary()
print(s(30000))

运行结果：

算工资啦!!!
{'yearsalary': 360000, 'monthsalary': 30000, 'daysalary': 1318.0, 'hoursalary': 164.0}

6、Python中的方法没有重载

'''

        在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含 3个
    部分：方法名、参数数量、参数类型。

        Python 中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由
    可变参数控制。因此，Python 中是没有方法的重载的。定义一个方法即可有多种调用方式，相
    当于实现了其他语言中的方法的重载。

        如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。

        建议：不要使用重名的方法！Python 中方法没有重载。

'''
#在Python中定义多个同名方法，只有最后一个方法有效

class Person:

    def say_hi(self):
        print("Hello!")

    def say_hi(self,name):
        print("Hello {0}!".format(name))

p1 = Person()
#p1.say_hi()     #不带参数报错：  TypeError: say_hi() missing 1 required positional argument: 'name'
p1.say_hi("任嘉伦")

运行结果：

Hello 任嘉伦!

7、方法的动态性

'''
    Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。
'''
class Person:
    def work(self):
        print("好好上班，挣钱养家！！！")

def play_game(self):
    print("事都干完啦！还玩？还玩？还玩？")

def work2(s):
    print("工作做完啦！！")

p1 = Person()
p1.work()
#p1.play_game()  #此时p1没有play_game()这个方法属性   AttributeError: 'Person' object has no attribute 'play_game'
Person.play = play_game
Person.work = work2
p = Person()
p.play()
p.work()

运行结果：

好好上班，挣钱养家！！！
事都干完啦！还玩？还玩？还玩？
工作做完啦！！