构造方法

属性（成员变量）的赋值

class Student:
    name = None     # 姓名
    age = None      # 年龄
    tel = None      # 手机号
    
    
stu1 = Student()
stu1.name = "张三"
stu1.age = 20
stu1.tel = "1212121211"

stu2 = Student()
stu2.name = "张四"
stu2.age = 20
stu2.tel = "1212121211"

 上面代码中，为对象的属性赋值需要依次进行，略显繁琐。

有没有更加高效的方式，能够一行代码就完成呢？

思考：Student（）

这个括号，能否像函数（方法）那样，通过传参的形式对属性赋值呢？

可以，需要使用构造方法：__init__()

构造方法

Python类可以使用：__init__()方法，称之为构造方法。

• 可以实现： 在创建类对象（构造类）的时候，会自动执行。
• 在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。

class Student:
    # 可以省略
    name = None  # 姓名
    age = None  # 年龄
    tel = None  # 手机号

    def __init__(self, name, age, tel): # 构建类时传入的参数会自动提供给__init__方法
        self.name = name                # 构建类的时侯__init__方法会自动执行
        self.age = age
        self.tel = tel
        print("Student类创建了一个对象")


stu3 = Student("李四", 30, "1212563")
print(stu3.name, stu3.age, stu3.tel)


结果：
Student类创建了一个对象
李四 30 1212563

 构造方法注意事项

• 重要的事情说三遍，构造方法名称：__init__   __init__   __init__ ， 千万不要忘记init前后都有2个下划线
• 构造方法也是成员方法，不要忘记在参数列表中提供：self
• 在构造方法内定义成员变量，需要使用self关键字

 def __init__(self, name, age, tel): # 构建类时传入的参数会自动提供给__init__方法
        self.name = name                # 构建类的时侯__init__方法会自动执行
        self.age = age
        self.tel = tel
        print("Student类创建了一个对象")

          这是因为：变量是定义在构造方法内部，如果要成为成员变量，需要用self来表示

总结：

1. 构造方法的名称是：

__init__，注意init前后的2个下划线符号

2. 构造方法的作用：

构建类对象的时候会自动运行

构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值

3. 注意事项：

构造方法不要忘记self关键字

在方法内使用成员变量需要使用self

练习：

学生信息录入

开学了有一批学生信息需要录入系统，请设计一个类，记录学生的：

姓名、年龄、地址，这3类信息

请实现：

• 通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入
• 输入完成后，使用print语句，完成信息的输出

 

 

# 创建构造方法
class Student:
    def __init__(self, i, name, age, address):
        self.name = name
        self.age = age
        self.address = address
        print(f"学生{i}信息录入完成，信息为：【学生姓名：{name}，年龄：{age}，地址：{address}】")


# 通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入
for i in range(1, 11):
    print(f"当前录入第{i}位学生信息，总共录入10位学生信息")
    name = input(f"请输入学生姓名：")
    age = input(f"请输入学生年龄：")
    address = input(f"请输入学生地址：")
    Student(i, name, age, address)
    i += 1

将学生存入字典

格式：

{ID{" 学生姓名：": name, "年龄：": age, "址地：": address}，......，ID{" 学生姓名：": name, "年龄：": age, "址地：": address}}

# 创建构造方法
class Student:
    dict = {}

    def __init__(self, i, name: str, age: int, address: str):
        self.name = name
        self.age = age
        self.address = address
        self.dict[i] = {" 学生姓名：": name, "年龄：": age, "址地：": address}
        print(f"学生{i}信息录入完成，信息为：【学生姓名：{name}，年龄：{age}，地址：{address}】")
        print(f"学生信息:{self.dict}")


# 通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入
for i in range(1, 11):
    print(f"当前录入第{i}位学生信息，总共录入10位学生信息")
    name = input(f"请输入学生姓名：")
    age = input(f"请输入学生年龄：")
    address = input(f"请输入学生地址：")
    Student(i, name, age, address)
    i += 1

其它内置方法

魔术方法

上文学习的__init__ 构造方法，是Python类内置的方法之一。 这些内置的类方法，各自有各自特殊的功能，这些内置方法我们称之为：魔术方法

 魔术方法非常多  

常用魔法方法

__str__ 字符串方法

# __str__ 字符串方法
class Student:
    def __init__(self, name, age):
        self.name = name
        self.agge = age


stu = Student("张三", 99)
print(stu)          # 结果：<__main__.Student object at 0x0000020E35E48550>
print(str(stu))     # 结果：<__main__.Student object at 0x0000020E35E48550>

 当类对象需要被转换为字符串之时，会输出如上结果（内存地址）

内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为。

# __str__ 字符串方法
# 当类对象需要被转换为字符串之时，会输出如上结果（内存地址）
# 内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为。
class Student:
    """
    方法名：__str__
    返回值：字符串
    内容：自行定义
    """
    def __init__(self, name, age):
        self.name = name
        self.agge = age

    def __str__(self):
        return f"student类对象，name={self.name}，age= {self.agge}"


stu = Student("张三", 99)
print(stu)          # 结果：student类对象，name=张三，age= 99
print(str(stu))     # 结果：student类对象，name=张三，age= 99

 __lt__ 小于符号比较方法

 直接对2个对象进行比较是不可以的，但是在类中实现__lt__方法，即可同时完成：小于符号 和 大于符号 2种比较

# __it__ 字符串方法
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __lt__(self, other):
        """
        方法名：__lt__
        传入参数：other，另一个类对象
        返回值：True 或 False
        内容：自行定义

        比较大于符号的魔术方法是：__gt__
        不过，实现了__lt__，__gt__就没必要实现了

        """
        return self.age < other.age


stu1 = Student("张三", 99)
stu2 = Student("李四", 52)
print(stu1 < stu2)  # 结果：False
print(stu1 > stu2)  # 结果：True

 __le__ 小于等于比较符号方法

魔术方法：__le__可用于：<=、>=两种比较运算符上。

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

    def __le__(self, other):
        """
        方法名：__le__
        传入参数：other，另一个类对象
        返回值：True 或 False
        内容：自行定义


        >=符号实现的魔术方法是：__ge__
        不过，实现了__le__，__ge__就没必要实现了
        """
        return self.age <= other.age


stu1 = Student("张三", 99)
stu2 = Student("李四", 52)
print(stu1 <= stu2)  # 结果：False
print(stu1 >= stu2)  # 结果：True

 __eq__，比较运算符实现方法

 

# __eq__ 小于等于比较符号方法
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        """
        方法名：__eq__
        传入参数：other，另一个类对象
        返回值：True 或 False
        内容：自行定义
        """
        return self.age == other.age


stu1 = Student("张三", 99)
stu2 = Student("李四", 52)
print(stu1 == stu2)  # 结果：False

•  不实现__eq__方法，对象之间可以比较，但是是比较内存地址，也即是：不同对象==比较一定是False结果。
• 实现了__eq__方法，就可以按照自己的想法来决定2个对象是否相等了。

总结：

方法	功能
__init__	构造方法，可用于创建类对象的时候设置初始化行为
__str__	用于实现类对象转字符串的行为
__lt__	用于2个类对象进行小于或大于比较
__le__	用于2个类对象进行小于等于或大于等于比较
__eq__	用于2个类对象进行相等比较

魔术方法索引
二元操作符：

+    object.__add__(self, other)
-    object.__sub__(self, other)
*    object.__mul__(self, other)
//    object.__floordiv__(self, other)
/    object.__div__(self, other)
%    object.__mod__(self, other)
**    object.__pow__(self, other[, modulo])
<<    object.__lshift__(self, other)
>>    object.__rshift__(self, other)
&    object.__and__(self, other)
^    object.__xor__(self, other)
|    object.__or__(self, other)

扩展二元操作符： 

+=    object.__iadd__(self, other)
-=    object.__isub__(self, other)
*=    object.__imul__(self, other)
/=    object.__idiv__(self, other)
//=    object.__ifloordiv__(self, other)
%=    object.__imod__(self, other)
**=    object.__ipow__(self, other[, modulo])
<<=    object.__ilshift__(self, other)
>>=    object.__irshift__(self, other)
&=    object.__iand__(self, other)
^=    object.__ixor__(self, other)
|=    object.__ior__(self, other)

 一元操作符：

-    object.__neg__(self)
+    object.__pos__(self)
abs()    object.__abs__(self)
~    object.__invert__(self)
complex()    object.__complex__(self)
int()    object.__int__(self)
long()    object.__long__(self)
float()    object.__float__(self)
oct()    object.__oct__(self)
hex()    object.__hex__(self)
round()    object.__round__(self, n)
floor()    object__floor__(self)
ceil()    object.__ceil__(self)
trunc()    object.__trunc__(self)

 比较函数：

<    object.__lt__(self, other)
<=    object.__le__(self, other)
==    object.__eq__(self, other)
!=    object.__ne__(self, other)
>=    object.__ge__(self, other)
>    object.__gt__(self, other)

 类的表示、输出：

str()    object.__str__(self) 
repr()    object.__repr__(self)
len()    object.__len__(self)
hash()    object.__hash__(self) 
bool()    object.__nonzero__(self) 
dir()    object.__dir__(self)
sys.getsizeof()    object.__sizeof__(self)

 类容器：

len()    object.__len__(self)
self[key]    object.__getitem__(self, key)
self[key] = value    object.__setitem__(self, key, value)
del[key] object.__delitem__(self, key)
iter()    object.__iter__(self)
reversed()    object.__reversed__(self)
in操作    object.__contains__(self, item)
字典key不存在时    object.__missing__(self, key)
 

链接：

引用（Python中最全魔术方法整理）