精华内容
下载资源
问答
  • 相信大家在很多场合特别是写神经网络的代码的时候都看到过下面的这种代码: ... def __init__(self): super(Net, self).__init__() # 输入图像channel:1;输出channel:6;5x5卷积核 self.conv1 = nn.C

    相信大家在很多场合特别是写神经网络的代码的时候都看到过下面的这种代码:

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class Net(nn.Module):
    
        def __init__(self):
            super(Net, self).__init__()
            # 输入图像channel:1;输出channel:6;5x5卷积核
            self.conv1 = nn.Conv2d(1, 6, 5)
            self.conv2 = nn.Conv2d(6, 16, 5)
            # an affine operation: y = Wx + b
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            # 2x2 Max pooling
            x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
            # 如果是方阵,则可以只使用一个数字进行定义
            x = F.max_pool2d(F.relu(self.conv2(x)), 2)
            x = x.view(-1, self.num_flat_features(x))
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    

    大家可能刚开始会有点疑惑的是下面的这三行代码是干什么用的,要看懂这三行代码需要了解三个东西:

    • self参数
    • __ init__ ()方法
    • super(Net, self).init()
      接下来就为大家逐一讲解一下。
     def __init__(self):
     super(Net, self).__init__()
     def forward(self, x):
    
    self参数

    self指的是实例Instance本身,在Python类中规定,函数的第一个参数是实例对象本身,并且约定俗成,把其名字写为self,也就是说,类中的方法的第一个参数一定要是self,而且不能省略
    我觉得关于self有三点是很重要的:

    1. self指的是实例本身,而不是类
    2. self可以用this替代,但是不要这么去写
    3. 类的方法中的self不可以省略

    首先第一点self指的是实例本身,而不是类

    class Person():
        def eat(self):
            print(self)
    
    Bob=Person()
    Bob.eat()
    print(Person)
    

    在这里插入图片描述
    看输出的结果我们可以看到,self指的是实例

    第二点self可以用this替代,但是不要这么去写,其实我理解self就相当于Java中的this,我们试着换一下

    class Person():
        def eat(this):
            print(this)
    
    Bob=Person()
    Bob.eat()
    print(Person)
    

    在这里插入图片描述
    是没有报错的,但是大家还是按照规范用self
    第三点类的方法中的self不可以省略,看下面的代码,pycharm自动提示需要参数self。
    在这里插入图片描述

    __ init__ ()方法

    在python中创建类后,通常会创建一个 __ init__ ()方法,这个方法会在创建类的实例的时候自动执行。 __ init__ ()方法必须包含一个self参数,而且要是第一个参数

    比如下面例子中的代码,我们在实例化Bob这个对象的时候, __ init__ ()方法就已经自动执行了,但是如果不是 __ init__ ()方法,比如说eat()方法,那肯定就只有调用才执行

    class Person():
        def __init__(self):
            print("是一个人")
        def eat(self):
            print("要吃饭" )
    Bob=Person()
    

    在这里插入图片描述
    再比如说下面的代码,如果 __ init__ ()方法中还需要传入另一个参数name,但是我们在创建Bob的实例的时候没有传入name,那么程序就会报错, 说我们少了一个__ init__ ()方法的参数,因为__ init__ ()方法是会在创建实例的过程中自动执行的,这个时候发现没有name参数,肯定就报错了

    class Person():
        def __init__(self,name):
            print("是一个人")
            self.name=name
        def eat(self):
            print("%s要吃饭" %self.name)
    
    Bob=Person()
    Bob.eat()
    

    在这里插入图片描述
    传入了Bob之后就不会了,而且eat方法也可以使用name这个参数。

    class Person():
        def __init__(self,name):
            print("是一个人")
            self.name=name
        def eat(self):
            print("%s要吃饭" %self.name)
    
    Bob=Person('Bob')
    Bob.eat()
    

    在这里插入图片描述
    这样我们其实就比较清晰的知道什么东西需要在__ init__ ()方法中定义了,就是希望有一些操作是在创建实例的时候就有的时候,比如说下面的这个代码,其实就应该把money这个量定义在__ init__ ()方法中,这样就不需要在执行eat()方法后再执行qian()方法。或者说我们写神经网络的代码的时候,一些网络结构的设置,也最好放在__ init__ ()方法中。

    class Person():
        def __init__(self,name):
            print("是一个人")
            self.name=name
        def eat(self,money):
            print("%s要吃饭" %self.name)
            self.money=money
        def qian(self):
            print("花了%s元" %self.money)
    
    Bob=Person('Bob')
    Bob.eat(12)
    Bob.qian()
    
    super(Net, self).init()

    python中的super(Net, self).init()是指首先找到Net的父类(比如是类NNet),然后把类Net的对象self转换为类NNet的对象,然后“被转换”的类NNet对象调用自己的init函数,其实简单理解就是子类把父类的__init__()放到自己的__init__()当中,这样子类就有了父类的__init__()的那些东西。

    回过头来看看我们的我们最上面的代码,Net类继承nn.Module,super(Net, self).init()就是对继承自父类nn.Module的属性进行初始化。而且是用nn.Module的初始化方法来初始化继承的属性。

    class Net(nn.Module):
    
        def __init__(self):
            super(Net, self).__init__()
            # 输入图像channel:1;输出channel:6;5x5卷积核
            self.conv1 = nn.Conv2d(1, 6, 5)
    

    也就是说,子类继承了父类的所有属性和方法,父类属性自然会用父类方法来进行初始化。
    当然,如果初始化的逻辑与父类的不同,不使用父类的方法,自己重新初始化也是可以的。比如:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
     
    class Person(object):
        def __init__(self,name,gender,age):
            self.name = name
            self.gender = gender
            self.age = age
     
    class Student(Person):
        def __init__(self,name,gender,age,school,score):
            #super(Student,self).__init__(name,gender,age)
            self.name = name.upper()  
            self.gender = gender.upper()
            self.school = school
            self.score = score
     
    s = Student('Alice','female',18,'Middle school',87)
    print s.school
    print s.name
    
    展开全文
  • Python super().__init__()测试及理解

    万次阅读 多人点赞 2019-02-24 13:20:17
    Python3 super().__init__()含义 测试一、我们尝试下面代码,没有super(A, self).__init__()时调用A的父类Root的属性和方法(方法里不对Root数据进行二次操作) class Root(object): def __init__(self): self.x=...

    Python super().__init__()含义(单继承,即只有一个父类)

    测试一、我们尝试下面代码,没有super(A, self).__init__()时调用A的父类Root的属性方法(方法里不对Root数据进行二次操作)

    class Root(object):
        def __init__(self):
            self.x= '这是属性'
    
        def fun(self):
        	#print(self.x)
            print('这是方法')
            
    class A(Root):
        def __init__(self):
            print('实例化时执行')
    
    test = A()		#实例化类
    test.fun()	#调用方法
    test.x		#调用属性
    
    

    下面是结果:

    Traceback (most recent call last):
    实例化时执行
    这是方法
      File "/hom/PycharmProjects/untitled/super.py", line 17, in <module>
        test.x  # 调用属性
    AttributeError: 'A' object has no attribute 'x'
    

    可以看到此时父类的方法继承成功,可以使用,但是父类的属性却未继承,并不能用

    测试二、我们尝试下面代码,没有super(A,self).__init__()时调用A的父类Root的属性方法(方法里Root数据进行二次操作)

    class Root(object):
        def __init__(self):
            self.x= '这是属性'
    
        def fun(self):
        	print(self.x)
            print('这是方法')
            
    class A(Root):
        def __init__(self):
            print('实例化时执行')
    
    test = A()		#实例化类
    test.fun()	#调用方法
    test.x		#调用属性
    
    

    结果如下

    Traceback (most recent call last):
      File "/home/PycharmProjects/untitled/super.py", line 16, in <module>
        test.fun()  # 调用方法
      File "/home/PycharmProjects/untitled/super.py", line 6, in fun
        print(self.x)
    AttributeError: 'A' object has no attribute 'x'
    

    可以看到此时报错和测试一相似,果然,还是不能用父类的属性

    测试三、我们尝试下面代码,加入super(A, self).__init__()时调用A的父类Root的属性方法(方法里Root数据进行二次操作)

    class Root(object):
        def __init__(self):
            self.x = '这是属性'
    
        def fun(self):
            print(self.x)
            print('这是方法')
    
    
    class A(Root):
        def __init__(self):
            super(A,self).__init__()
            print('实例化时执行')
    
    
    test = A()  # 实例化类
    test.fun()  # 调用方法
    test.x  # 调用属性
    
    

    结果输出如下

    实例化时执行
    这是属性
    这是方法
    

    此时A已经成功继承了父类的属性,所以super().__init__()的作用也就显而易见了,就是执行父类的构造函数,使得我们能够调用父类的属性。

    上面是单继承情况,我们也会遇到多继承情况,用法类似,但是相比另一种Root.__init__(self),在继承时会跳过重复继承,节省了资源。

    还有很多关于super的用法可以参考
    super的使用

    展开全文
  • __init__

    千次阅读 2018-07-29 11:19:41
    1__init__ 监听对象创建完成 增加属性 用于初始化一个实例,控制这个初始化的过程 实例级别的方法 2. str 监听打印对象 return “返回值可以返回字符串” 3.new 通常用于控制生成一个新实例的过程。 类级别的...

    __init__方法

    __init__()方法,在创建一个对象时默认被调用,不需要手动调用
    __init__(self)中的self参数,不需要开发者传递,python解释器会自动把当前的对象引用传递过去
    
    在类内部获取 属性 和 实例方法,通过self获取;
    在类外部获取 属性 和 实例方法,通过对象名获取。
    
    如果一个类有多个对象,每个对象的属性是各自保存的,都有各自独立的地址;
    但是实例方法是所有对象共享的,只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。
    
    class Cat:
        - 创建init方法      参数
        def __init__(self, name, age):
            self.name = name(增加实例)
            self.age = age
    
        def __str__(self):   - 对init方法调用
            return "%s的年龄%d" % (self.name, self.age)
            
        def sing(self):  - 创建方法
            print("猫在唱歌")
        def dance(self):
            print("猫在跳舞")
    
    tom = Cat("老王的猫", 40)  - 创建对象
    tom.sing()   - 调用对象中的方法
    tom.dance()
    print(tom)
    
    
    >> 输出结果
    >> 猫在唱歌
    >> 猫在跳舞
    >> 老王的猫的年龄7
    

    1__init__ 监听对象创建完成 增加属性
    用于初始化一个实例,控制这个初始化的过程 实例级别的方法
    2. str 监听打印对象 return “返回值可以返回字符串”
    3.new 通常用于控制生成一个新实例的过程。 类级别的方法

    ###1.创建对象 2.调用__init__方法 3.返回对象的引用

    class House(object):
    
        - 初始化对象.` __init__() 方法,用来做变量初始化 或 赋值 操作`
        - 创建完对象后会自动被调用
        def __init__(self, new_name, new_age):
            print('-------------------------------------')
            self.name = new_name   #实例变量
            self.age = new_age
    
        def introduce(self):
    	    - 实例方法
            print('%s的年龄:%d' % (self.name, self.age))
            - 通过那个对象调用哪个方法,此事self指向哪个对象
    
    	
    	-  对init方法调用
    	- 方法需要 return 一个数据,并且只有self一个参数,当在类的外部 print(对象) 则打印这个数据
        def __str__(self):
            return "%s的年龄%d" % (self.name, self.age)
    
    
    
    - 创建一个对象 # 给赤兔添加两个属性
    chitu = House('chitu', 30)
    
    - 调用对象指向方法
    chitu.introduce()
    
    - 如果没有__str__ 则默认打印 对象在内存的地址。
    - 当类的实例化对象 拥有 __str__ 方法后,那么打印对象则打印 __str__ 的返回值。
    - print(chitu)
    
    - 创建对象, 的卢添加两个属性
    dilu = House('dilu', 88)
    dilu.introduce()
    
    #print(dilu)
    

    输出结果

    -------------------------------------
    chitu的年龄:30
    -------------------------------------
    dilu的年龄:88
    

    这里写图片描述

    #str()方法

    当使用print输出对象的时候,默认打印对象的内存地址。
    如果类定义了__str__(self)方法,那么就会打印从在这个方法中 return 的数据
    __str__方法通常返回一个字符串,作为这个对象的描述信息
    
    展开全文
  • 一篇带你搞懂Python3 中的 def __init__

    千次阅读 多人点赞 2020-12-25 20:25:13
    在学习python-100-days时,在面向对象编程基础的那一块,封装一个class时,突然出现def __init__的方法,刚开始时,对他的理解很模糊,为什么定义一个类需要用到def __init__。 于是翻找了一些资料,大概就是两种...

    在学习python-100-days时,在面向对象编程基础的那一块,封装一个class时,突然出现def __init__的方法,刚开始时,对他的理解很模糊,为什么定义一个类需要用到def __init__

    于是翻找了一些资料,大概就是两种定义方式如下:
    

    第一种定义方式如下:

    class Student(object):
    
        # __init__是一个特殊方法用于在创建对象时进行初始化操作
        # 通过这个方法我们可以为学生对象绑定name和age两个属性
        def __init__(self, name, age):
            self.name = name
            self.age = age
    

    上面这一种,是在学习python-100-days时,里面的一种定义方式。里面是包含两个参数 nameage。在实例的时候,必须要传入这两个参数的值进去。

    stu = Student() # 报错
    

    如果上面直接实例它的话就会报错:TypeError missing 2 required positional arguments: 'name' and 'age'

    正常情况下,我们应该传入参数:

    stu = Student('大冰', 19) # 正常实例
    

    然后我们可以利用__dict__方法查看对象的属性。

    print(stu.__dict__) # 打印出: {'name': '大冰', 'age': 19}
    

    或者我们可以直接给__init__方法设置一个默认参数,然后直接实例就不会报错了。

    def __init__(self, name = '周星星', age = 12):
    	self.name = name
    	self.age = age
    
    stu = Student() # 不会报错,正常实例
    

    第二种定义方式如下:

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

    以第一种的区别,这种定义方式时,没有形参的。但是它已经指定nameage都是 None, 相当于这两个参数已经赋值,不过是None

    这种形式是可以直接实例对象,然后再给对象里的属性赋值:

    stu = Student() # 正常实例
    """查看stu对象的属性是什么状态"""
    print(stu.__dict__) # 打印出:{'name': None, 'age': None}
    

    然后再来重新给对象的属性赋值:

    stu.name = '陈冠希'
    stu.age = 16
    

    以上就是__init__方法定义的一些区别。

    那么为什么在class中 要定义__init__方法呢?因为他是一个初始化方法,没有初始化的话,实例后的对象,用__dict__方法查看对象里面的属性将是空的。

    展开全文
  • python之super()与__init__()

    千次阅读 2019-02-16 15:25:52
    super()与__init__()   一、概述 __init__()一般用来创建对象的实例变量,或一次性操作。super()用于调用父类的方法,可用来解决多重继承问题。 单继承中,super()和__init__()功能类似,主要区别:1)使用...
  • python中super().__init__()

    万次阅读 多人点赞 2020-03-01 21:55:12
    super().__init__() 1、子类构造函数调用super().__init__()1.1、第一个直接继承父类,可以调用name1.2、第二个继承自父类,覆盖初始化化def init,增加属性age,不能调用name属性1.3、第三个继承自父类,覆盖...
  • 深入理解Python中的 __new__ 和 __init__

    千次阅读 2018-09-17 09:19:15
    理解 __new__ 和 __init__ 的区别 Python中两种类的定义方式 分析不同的Case 老式类中的__new__ 和 __init__ 新式类中的 __new__ 和 __init__ 参考资料 本文为译文,原文链接:...
  • 用super来调用__init__的方式,设计得当的话,可以使得每个类的__init__恰好被调用一次,supr()方式中,最重要的是__init__参数传递的问题,下面提供了一个比较好的解决方案 解决方案: &amp;nbsp; &amp;nbsp; ...
  • Python package里的__init__.py的简析和用法说明
  • python模块中__init__.py的作用

    万次阅读 多人点赞 2018-03-05 14:22:26
    实验一:不包含__init__.py 实验二:A中包含__init__.py 实验三:A.A_A中也包含__init__.py 进阶 基本概念 概念 解释 import 即导入,方式就是在import位置将代码文件拷贝过去。 模块 python...
  • Python中的__init__与__main__

    千次阅读 2017-08-16 09:39:08
    目录结构 sound/ Top-level package  __init__.py Initialize the sound package  __main__.py  formats/ Subpackage for file format con
  • 详细解读Python中的__init__()方法

    千次阅读 2019-03-19 11:38:21
    init()方法意义重大的原因有两个。 第一个原因是在对象生命周期中初始化是最重要的一步,每个对象必须正确初始化后才能正常工作。 第二个原因是init()参数值可以有多种形式。 在我们接触init()方法之前,无论如何,...
  • Python 中__init__函数以及参数self

    万次阅读 多人点赞 2019-02-23 17:29:36
    1)class类包含: 类的属性:类中所涉及的变量 类的方法:类中函数 2) __init函数(方法) 1、带有两个下划线开头的函数是声明该属性为私有,不能在类地外部被使用或...3、init函数(方法)的第一个参数必须是sel...
  • 这种形式在__init__方法中,只有一个self,指的是实例本身,包含两个属性,name, score。它允许定义一个空的结构,当新数据来时,可以直接添加。实例化时,需要实例化之后,再进行赋值。 class Game:# 定义Game类 ...
  • 其中__init__.py内容如下: __all__ = ['cpca', 'regulate'] 然后在外面文件夹建立了一个test.py准备使用这个包 发现导入遇到了一些问题 在test.py中只用import导入会报错找不到 import address ...
  • python def __init__(self, name等多参数), def __init__(self)

    万次阅读 多人点赞 2018-10-08 20:19:22
    __init__(self) 初始化,__new__实例化方法,两者执行的顺序,先有实例,才能初始化。 之前一直对__init__(self)里面的参数很迷茫,一会这个地方看到别人这么写,一会看到别人那么写,自己也不知道,到底怎么回事,...
  • 好文不应该被埋没,应该被更多的人所熟知!!! ...相信大家在很多场合特别是写神经网络的代码的时候都看到过下面的这种代码: import torch import torch.nn as nn ... def __init__(self): super(Net
  • Python __init__()方法

    千次阅读 2020-10-27 15:53:50
    定义类的时候,若是添加__init__方法,那么在创建类的实例的时候,实例会自动调用这个方法,一般用来对实例的属性进行初使化。比如: class testClass: def init(self, name, gender): #定义 __init__方法,这里有三...
  • Package内的__main__.py和__init__.py

    千次阅读 2018-08-11 00:03:52
    1 概念 ...(1) 如果你希望 python 将一个文件夹作为 Package 对待,那么这个文件夹中必须包含一个名为 __init__.py 的文件,即使它是空的。 (2) 如果你需要 python 将一个文件夹作为 Package 执行...
  • Python __init__.py 文件使用

    千次阅读 2019-05-02 19:50:19
    __init__.py的主要作用是: 1. Python中package的标识,不能删除 2. 定义__all__用来模糊导入 3. 编写Python代码(不建议在__init__中写python模块,可以在包中在创建另外的模块来写,尽量保证__init__.py简单) ...
  • python __init__.py 随记

    千次阅读 2018-03-23 11:58:21
    最近在学写python package init.py 随手记一下 在创建package的时候在文件夹下会出现一个init.py 的文件 init.py 文件的作用是将文件夹变为一个Python模块,Python 中的每个模块的包中,都有init.py 文件。 ...
  • 关于def __init__(self)的一些知识点

    千次阅读 2021-03-22 20:32:12
    关于def __init__(self)的一些知识点 胖二十斤等189人 def __init__(self)在Python里面很常见, Python中的self 在Python中的类Class的代码中,常看到函数中的第一个参数,都是self。以及Class中的函数里面,...
  • Python中__init__的用法和理解

    万次阅读 多人点赞 2018-09-23 16:35:25
    在Python中定义类经常会用到__init__函数(方法),首先需要理解的是,两个下划线开头的函数是声明该属性为私有,不能在类的外部被使用或访问。而__init__函数(方法)支持带参数类的初始化,也可为声明该类的属性...
  • '__gt__','__hash__', '__init__', '__init_subclass__', '__le__', '__lt__','__cmodule__', '__ne__', '__new__', '__reduce__', '__reduce_ex__','__repr__', '__setattr__', '__sizeof__', '__str__', '__...
  • Instance attribute *** defined outside __init__

    千次阅读 2021-03-08 09:58:59
    原因:实例属性***在初始化外定义__ python中,类的定义包含__init__函数,该函数内部定义相关的属性 例: class fruits(object): def __init__(self,size,number): self.size = size self.num = number def fun1...
  • python的def __init__( ):函数

    千次阅读 2020-04-13 15:54:31
    1. def __init__(self): 这种形式在__init__方法中,只有一个self,指的是实例的本身,但是在方法的类部,包含两个属性:name、year。它允许定义一个空的结构,当新数据来时,可以直接添加。实例化时,需要实例化之后...
  • python def __init__(self,。。)

    千次阅读 2020-09-05 20:11:32
    init()方法 定义类 class Car: # 移动 def move(self): print('车在奔跑...') # 鸣笛 def toot(self): print("车在鸣笛...嘟嘟..") 创建一个对象,并用变量BMW来保存它的引用 BMW = Car() BMW.color = '黑色...
  • Python的Object基类的__init__方法

    千次阅读 2017-06-19 20:02:30
    Python的Object基类的__init__方法 Python的__init__方法是用来初始化的实例的,是在__new__()方法执行后但是还没有return的情况下执行的__init__()方法。__new__()方法是用来创建实例的。这个__init__类似于构造...
  • 使用Python写过面向对象的代码的同学,可能对 __init__ 方法已经非常熟悉了,__init__ 方法通常用在初始化一个类实例的时候。例如:     这样便是__init__最普通的用法了。但__init__其实不是实例化一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,291,633
精华内容 1,316,653
关键字:

__init__