python魔法方法：__init__( )
1、__init__()方法称为构造方法，__init__()方法的魔力体现在只要实例化一个对象，这个方法就会在对象被创建时自动调用。
2、实例化对象时是可以传入参数的，这些参数会自动传入__init__()方法中，可以通过重写这个方法来自定义对象的初始化操作
总结：__init__()方法是一个特殊的方法，在对象实例化时会被调用，__init__()方法的作用是初始化
例1：
class Myclass:
i = 123
def __init__(self,friend):
self.friend = friend
def func(self,myself): #带有参数的类方法
self.myself = myself
return self.myself +"say hello to " + self.friend
use_class = Myclass("xiaoming")
print("调用类的属性：",use_class.i)
print("调用类的方法:", use_class.func("xiaohong"))
#上面代码的输出结果为：
#调用类的属性： 123
#调用类的方法: xiaohongsay hello to xiaoming
1、在python中定义类时没有定义__init__( )方法，则在类实例化时系统会自动调用默认的构造方法(无参数的__init__( )方法)，另外__init__( )方法可以有参数，参数通过__init__( )传递到类的实例化操作上
2、一个类中可以定义多个构造方法(__init__( ))，但是实例化类时只会实例化最后的构造方法，即后面的构造方法会覆盖前面的构造方法，并且需要根据最后一个构造方法的形式进行实例化(参数与最后一个构造方法的参数一致)。因此一个类中最好只定义一个构造方法
3、初始化实例包括：定义和初始化实例属性或调用类的一些方法。
4、构造方法可以带有除self外的其它各种参数（关键字参数、默认参数、用元组收集参数、用字典收集关键字参数等），可以在实例化类时，传入对应的实参。
拓展：
类的方法定义
def fun_name(self,...);
Pass
1、其中的参数self代表类的实例，在调用方法时由系统自动提供
2、方法定义时必须指明self参数
3、self表示类实例
类的方法的调用：与普通的函数调用类似
1、类的内部调用：self.<方法名>(参数列表)，或类名.方法名(参数列表）
2、在类的外部调用：<实例名>.<方法名>(参数列表)。
注意：以上两种调用方法中，提供的参数列表中都不用包括self。
例2：
class Num:
def eat(self,name):
self.name = name
print("mmm and %s" % self.name)
def speed(self):
self.eat("nn") #类中访问方法：self.方法名
#Num.eat(self,"nn") #类中访问方法：类名.方法名（self)
num = Num()
num.speed()
例2：
class Washer:
def __init__(self):
self.water = 0
self.scour = 0
def add_water(self, water):
print('Add water:', water)
self.water = water #等号左边的表示实例的属性，右边是方法的形参
def add_scour(self, scour):
self.scour = scour
print('Add scour:', self.scour)
def start_wash(self):
print('Start wash...')
if __name__ == '__main__':
w = Washer()
w.add_water(10)
w.add_scour(2)
w.start_wash()
#上面代码的输出结果为：
#Add water: 10
#Add scour: 2
#Start wash...
注：
1、这段代码中有self，water，scour三个参数，这个self表示对象本身(谁调用，就表示谁)。语法上，类中的方法的第一个参数都是self，这是和普通方法区别的地方。这里self.water = water和self.scour = scour表示实例对象的属性：将外部传来的water和scour，赋值给了实例对象的water和scour属性(只是将形参的名字定义来跟实例属性名一致)
例2_1：
class Car():
def __init__(self,color_1,brand_1):
self.color = color_1
self.brand = brand_1
def one_car(self):
print("品牌：%s,颜色：%s" % (self.brand,self.brand))
car = Car("黑色","奔驰")
car.one_car()
#可以看出其实形参名可以不跟实例属性名一致，只是说一致时要方便点
#品牌：奔驰,颜色：奔驰
2、上面例子中self.water = 0和self.scour = 0为实例对象的默认参数，跟函数的默认参数含义差不多，只是说这种默认参数不能通过外部传入参数进行修改：每个实例的值都为0
例3：
class Washer:
def __init__(self, water=10, scour=2):
self.water = water
self.scour = scour
def set_water(self, water):
self.water = water
def set_scour(self, scour):
self.scour = scour
def add_water(self):
print('Add water:', self.water)
def add_scour(self):
print('Add scour:', self.scour)
def start_wash(self):
self.add_water()
self.add_scour()
print('Start wash...')
if __name__ == '__main__':
wb = Washer(100, 10)
wb.set_water(50)
wb.set_scour(5)
wb.start_wash()
#上面代码的输出结果为：
#Add water: 50
#Add scour: 5
#Start wash...
注：上面例子中water=10, scour=2为默认参数，默认值为10和2：且这种写法也支持外部传入实参(self.water = water,self.scour = scour)，当外部传入实参时，就用外部传入的参数，外部未传入实参时，就用默认值
例4：
class Num_add():
a = 1 #定义在类中但在函数体外的变量为类变量
def __init__(self):
self.x = 4 #这里的self.x,self.y就是实例变量
self.y = 3
def add(self):
print(self.x + self.y)
number = Num_add()
number.add()
#上面代码的输出结果为：7
注：这是定义了两个变量x和y，并赋给实例self.x和self.y，在后面的所有函数中如果要用到这个两个变量，都需要通过self.x的写法来调用，并且函数的参数列表必须带有self，并且把实例传了进去。否则调用就会报错。
例5：
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def Introduce(self):
#在函数内部访问自己的属性和方法
print("我叫%s，今年%d岁" % (self.name, self.age))
p = Person("hao",20)
p.Introduce()
#上面代码的输出结果为：我叫hao，今年20岁
注：在类的内部，访问自己的属性和方法，都需要通过self，self就是外部对象在类内部的表示
备注：
class Count():
def __init__(self,a,b):
self.a = int(a)
self.b = int(b)
def Add(self,c):
sum = self.a + self.b + c
return sum
count = Count(1,2)
print(count.Add(3))
#6
上面例子中：__init__方法初始了a,b两个变量（属性），在类中的其他方法可以使用self.属性名调用这些参数(a,b)，也可以拥有自己的参数(c)并直接调用
类补充
例1：定义一个类
class Car():
"""这是一个汽车类"""
brand = "宝马"
color = "红色"
def run(self,s):
print("当前行驶速度：%s KM/S"% s)
#print(self.__class__)
car = Car()
#调用类属性(调用类属性时，最好不要中这种方式)
print("品牌：%s,颜色：%s" % (car.brand,car.color))
#调用类方法
car.run(50)
"""
品牌：宝马,颜色：红色
当前行驶速度：50 KM/S
#<class '__main__.Car'>
"""
注：
1、定义好类后，首先需要创建一个类的实例(实例化类后才能使用)：python只需要类名+（）就可以实例化一个类car = Car()
2、使用点(.)来调用属性和方法
3、self代表当前实例，而self.__class__就是Car类
类变量
1、上面例子中像brand、color这类变量叫做类变量，是所有类实例共享的变量：类变量定义在类中但是不属于任何函数
2、虽然可以向上面例子中那样使用类实例来访问并修改类变量，但是不建议这么做，因为当某一个类实例修改了类变量后，可能会对其他类实例的使用造成影响。正确的用法是"类名.属性"的方式访问类的属性
例2：
class Car():
"""这是一个汽车类"""
brand = "宝马"
color = "红色"
def run(self,s):
print("当前行驶速度：%s KM/S"% s)
a = Car()
b = Car()
print(a.brand,id(a.brand))
print(b.brand,id(a.brand))
"""
宝马 2620619371744
宝马 2620619371744
"""
注：可见两个实例的brand属性所指向的内存地址是相同的，这就意味着如果修改了Car.brand，那么实例a和实例b的brand值都会发生变化
例2_1：
Car.brand = "奔驰"
a = Car()
b = Car()
print(a.brand,id(a.brand))
print(b.brand,id(a.brand))
"""
奔驰 2276323505616
奔驰 2276323505616
"""
实例变量
1、类变量表示所有实例都拥有的属性(每个实例的属性都一致)，那对于每个实例都不一样的属性(每个实例独有的属性)该怎么表示呢？对于这种类型的属性，可以使用实例变量来储存
2、实例变量是定义在方法(__init__)中的变量，只能用于当前类的实例
例3：
class Car():
"""这是一个汽车类"""
def __init__(self,brand,color):
self.brand = brand
self.color = color
def run(self,s):
print("当前行驶速度：%s KM/S"% s)
def print_car(self):
print("品牌：%s,颜色：%s" % (self.brand,self.color))
car_A = Car("宝马","红色")
car_A.print_car()
car_B = Car("奔驰","黑色")
car_B.print_car()
print(car_A.brand)
print(car_B.color)
"""
品牌：宝马,颜色：红色
品牌：奔驰,颜色：黑色
宝马
黑色
"""
注：
1、实例变量表示：每个实例独有的属性，需要定义在__init__方法中
2、方法__init__()叫做构造函数，每当实例化一个类时都会执行这个函数，通常会在这个函数里面为实例属性进行初始化
3、存在构造函数时，在实例化类时就必须传入实例变量的实参：car_A = Car("宝马","红色")，当然如果方法中存在参数，那在调用类的方法时也必须传入实参
4、在类中调用实例属性时为：self.属性名，在类外调用实例属性时为：实例名.属性名
拓展：
class Employee(object):
"""所有员工的基类"""
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1#修改类变量的值
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
#创建Employee类的第一个对象
emp1 = Employee("Zara", 2000)
emp1.displayEmployee()
print("Total Employee %d" % Employee.empCount)
#创建 Employee 类的第二个对象
emp2 = Employee("Manni", 5000)
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)
# 添加一个 'age' 属性
emp1.age = 7#增加实例属性
# 修改 'age' 属性
emp1.age = 8
# 删除 'age' 属性
print("emp1年龄为：",emp1.age)
emp2.age = 9
print("emp2年龄为：",emp2.age)
"""
Name : Zara , Salary: 2000
Total Employee 1
Name : Manni , Salary: 5000
Total Employee 2
emp1年龄为： 8
emp2年龄为： 9
"""
总结
__init__方法
1、实例属性是在__init__方法中定义的：表示各个实例所独有的
2、__init__方法中第一个参数始终是self：代表当前具体的实例
3、__init__方法定义格式为：
class Studeng():
def __init__(self,name,score):
self.name = name
self.score = score
4、上面示例的意思为：把外部参数name的值(形参)传递给具体实例的name属性(也算是一个形参吧，只是实例属性名与外部形参名一致)，用self将属性绑定到具体的实例上，明确当前属于哪个实例
self参数
1、self参数是实例对象在类内部的表示(即：self表示实例对象)
2、类方法在定义时，第一个参数始终是self参数：告诉python当前是哪个实例在调用方法
3、在类中调用实例属性时，格式为self.属性名：告诉python当前是哪个实例在调用属性(该属性属于哪个实例)
————————————————
版权声明：本文为CSDN博主「不怕猫的耗子A」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_39314932/article/details/80721822