构造方法

属性（成员变量）的赋值

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)