module_modulenotfounderror - CSDN
精华内容
参与话题
  • module是干什么的?

    千次阅读 2012-11-07 09:22:16
    以前一直搞不太清楚module是干什么的? 我们公司到底干什么的? 前几天听同事说,IC公司只是一个CPU+MAC层程序控制GPIO口,需要添加射频部分,也就是信号的发送与接收那些硬件的东西,就是电源+天线。 这就是...
    以前一直搞不太清楚module是干什么的? 我们公司到底干什么的?
    前几天听同事说,IC公司只是一个CPU+MAC层程序控制GPIO口,需要添加射频部分,也就是信号的发送与接收那些硬件的东西,就是电源+天线。
    这就是module厂商的工作。
    不过,IC厂商慢慢把这些都做了,所以module厂商没落了。
    添加射频部分,需要各种电容电感的配合,最后才能决定信号最好的,这个是个很复杂的东西,需要的设备也很昂贵,反复的测试,真的是经验为大!
    2012.11.07
    展开全文
  • Python——模块(Module)和包(Package)

    万次阅读 多人点赞 2018-01-30 17:21:01
    1. 模块(Module) 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。 为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含...

    本文绝大部分内容转载至:廖雪峰官方网站

    1. 模块(Module)

    在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。

    为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的代码就相对较少,很多编程语言都采用这种组织代码的方式。在Python中,一个.py文件就称之为一个模块(Module)

    使用模块有什么好处?

    最大的好处是大大提高了代码的可维护性。其次,编写代码不必从零开始。当一个模块编写完毕,就可以被其他地方引用。我们在编写程序的时候,也经常引用其他模块,包括Python内置的模块和来自第三方的模块

    使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中,因此,我们自己在编写模块时,不必考虑名字会与其他模块冲突。但是也要注意,尽量不要与内置函数名字冲突

    你也许还想到,如果不同的人编写的模块名相同怎么办?为了避免模块名冲突,Python又引入了按目录来组织模块的方法,称为包(Package)

    举个例子,一个abc.py的文件就是一个名字叫abc的模块,一个xyz.py的文件就是一个名字叫xyz的模块。

    现在,假设我们的abcxyz这两个模块名字与其他模块冲突了,于是我们可以通过包来组织模块,避免冲突。方法是选择一个顶层包名,比如mycompany,按照如下目录存放:

    mycompany
    ├─ __init__.py
    ├─ abc.py
    └─ xyz.py

    引入了包以后,只要顶层的包名不与别人冲突,那所有模块都不会与别人冲突。现在,abc.py模块的名字就变成了mycompany.abc,类似的,xyz.py的模块名变成了mycompany.xyz

    请注意,每一个包目录下面都会有一个__init__.py的文件,这个文件是必须存在的,否则,Python就把这个目录当成普通目录,而不是一个包。__init__.py可以是空文件,也可以有Python代码,因为__init__.py本身就是一个模块,而它的模块名就是mycompany。

    类似的,可以有多级目录,组成多级层次的包结构。比如如下的目录结构:

    mycompany
     ├─ web
     │  ├─ __init__.py
     │  ├─ utils.py
     │  └─ www.py
     ├─ __init__.py
     ├─ abc.py
     └─ xyz.py

    文件www.py的模块名就是mycompany.web.www

    Notes: 自己创建模块时要注意命名,不能和Python自带的模块名称冲突。例如,系统自带了sys模块,自己的模块就不可命名为sys.py,否则将无法导入系统自带的sys模块。

    2. 使用模块

    Python本身就内置了很多非常有用的模块,只要安装完毕,这些模块就可以立刻使用。

    我们以内建的sys模块为例,编写一个hello的模块:

    #!/usr/bin/env python3 
    # -*- coding: utf-8 -*-
    
    ' a test module '
    
    __author__ = 'Michael Liao'
    
    import sys
    
    def test():
        args = sys.argv   # argv参数用列表存储命令行的所有参数
        if len(args)==1:  # 当列表长度为1时即只有一个参数时
            print('Hello, world!')
        elif len(args)==2: # 当命令行有两个参数时
            print('Hello, %s!' % args[1])
        else:
            print('Too many arguments!')
    
    if __name__=='__main__':
        test()

    第1行和第2行是标准注释,第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行,第2行注释表示.py文件本身使用标准UTF-8编码;

    第4行是一个字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

    第6行使用__author__变量把作者写进去,这样当你公开源代码后别人就可以瞻仰你的大名;

    以上就是Python模块的标准文件模板,当然也可以全部删掉不写,但是,按标准办事肯定没错。

    后面开始就是真正的代码部分。

    你可能注意到了,使用sys模块的第一步,就是导入该模块:

    import sys

    导入sys模块后,我们就有了变量sys指向该模块,利用sys这个变量,就可以访问sys模块的所有功能。

    sys模块有一个argv变量,list存储了命令行的所有参数argv至少有一个元素,因为第一个参数永远是该.py文件的名称,例如:

    运行python3 hello.py获得的sys.argv就是['hello.py'],注意这里python3不算是参数;

    运行python3 hello.py Michael获得的sys.argv就是['hello.py', 'Michael]

    最后,注意到这两行代码:

    if __name__=='__main__':
        test()

    当我们在命令行运行hello模块文件时,Python解释器把一个特殊变量__name__置为__main__,而如果在其他地方导入该hello模块时,if判断将失败,因此,这种if测试可以让一个模块通过命令行运行时执行一些额外的代码,最常见的就是运行测试

    我们可以用命令行运行hello.py看看效果:

    $ python3 hello.py
    Hello, world!
    $ python hello.py Michael
    Hello, Michael!

    如果启动Python交互环境,再导入hello模块:

    >>> import hello
    >>>

    导入时,没有打印Hello, word!,因为没有执行test()函数。

    调用hello.test()时,才能打印出Hello, word!

    >>> hello.test()
    Hello, world!
    展开全文
  • JS设计模式(一)-MODULE(模块模式)

    千次阅读 2018-07-23 10:24:46
    在JavaScript中Module模式模拟了类的概念,用闭包封装了"私有"状态和方法。 Module(模块)模式 通常能够帮助我们清晰地分离和组织项目中的代码单元 js中实现模块的方法 1》对象字面量表示法 2》...

    JavaScript模块是用于保持代码块之间相互独立而普遍使用的设计模式。对于熟悉面向对象语言的人来说,模块是JavaScript的"类"。在JavaScript中Module模式模拟了类的概念,用闭包封装了"私有"状态和方法。

    Module(模块)模式

    通常能够帮助我们清晰地分离和组织项目中的代码单元

    js中实现模块的方法

    1》对象字面量表示法

    2》Module模式

    3》AMD模式

    4》CommonJS模块

    5》ECMAScript Harmony模块

    Module模式某种程度上是基于对象的字面量

    9.2.1对象字面量

    在对象字面量表示法中,一个对象被描述为一组包含在大括号{}中、以逗号分隔的name/value对。对象内的名称可以是字符串或标识符,后面跟着一个冒号。对象中最后的一个name/value对的后面不用加逗号,如果加逗号将会导致出错。

    Var myObjectLiteral={

    variableKey:variableValue;

    functionKey:function(){

    //

    }

    };

    对象字面量不需要使用new运算符进行实例化,但不能用在一个语句的开头,因为开始的可能被解读为一个块的开始。在对象的外部,新成员可以使用如下赋值语句添加在字面量上,如:

    myModule.property="some Value";

    使用对象字面量有助于封装和组织代码,Module模式仍然使用对象字面量,但只是作为一个作用域函数的返回值。

    复制代码

       var myModule={
            myProperty:"somevalue",
            //对象字面量可以包含属性和方法
            //例如,可以声明模块的配置对象
            myConfig:{
                useCaching:true,
                language:"en"
            },
            //基本方法
            myMethod:function(){
                console.log("myMethod");
            },
            //根据当前配置输出信息
            myMethod2:function(){
                console.log("caching is:" + (this.myConfig.useCaching) ? "enabled":"disabled");
            },
            //重写当前配置
            myMethod3:function(newConfig){
                if(typeof newConfig==="object"){
                    this.myConfig=newConfig;
                    console.log(this.myConfig.language);
                }
            }
        };
        myModule.myMethod();
        myModule.myMethod2();//打印出来的是enabled,没有加上前面的字符串
        myModule.myMethod3({
            language:"fr",
            useCaching:false
        });

    复制代码

    9.2.2Module(模块)模式

    Module模式最初被定义为一种在传统软件工程中为类提供私有和公有封装的方法。

    在js中,Module模式用于进一步模拟类的概念,通过这种方式,能够使一个单独的对象用于公有/私有方法和变量,从而屏蔽来自全局作用域的特殊部分。产生的结果是:函数名与在页面上其他脚本定义的函数冲突的可能性降低。

    模块模式的模板

    复制代码

    var myNamespace=(function(){
        //私有计数器变量
        var myPrivateVar=0;
        //记录所有参数的私有函数
        var myPrivateMethod=function(foo){
            console.log(foo);
        }
        return{
            //公有变量
            myPublicVar:"foo",
            //调用私有变量和方法的公有函数
            myPublicFunction:function(bar){
                //增加私有计数器值
                myPrivateVar++;
                //传入bar调用私有方法
                myPrivateMethod(bar);
            }
        };
    })();

    复制代码

    9.2.2.1 私有

    Module模式使用闭包封装“私有”状态和组织。它提供了一种包装混合公有/私有方法和变量的方式,防止其泄露至全局作用域,并与别的开发人员的接口发生冲突。通过该模式,只需返回一个公有API,而其他的一切则都维持在私有闭包里 。

    这为我们提供了一个屏蔽处理底层时间逻辑的整洁解决方案,同时只暴露一个接口供应用程序的其他部分使用。该模式除了返回一个对象而并不是函数之外,非常类似于一个立即调用的函数表达式。

    应该指出的是,在js中没有正真意义上的“私有”,因为js没有访问修饰符,因此我们使用函数作用域来模拟这个概念。在Module模式内:闭包声明的变量和方法只在该模式内部可用。但在返回对象上定义的变量和方法,则对外部使用者都是可用的。

    复制代码

        var basketModule=(function(){
            //私有
            var basket=[];
            function doSomethingPrivate(){
                console.log("private");
            }
            function doSomethingElsePrivate(){
                //
            }
            //返回一个暴露出的公有对象
            return{
                //添加item到购物车
                addItem:function(values){
                    basket.push(values);
                },
                //获取购物车里的item数
                getItemCount:function(){
                    return basket.length;
                },
                //私有函数的公有形式别名,
                // doSomething:doSomethingPrivate自动调用doSomethingPrivate函数
                doSomething:doSomethingPrivate,
                //获取购物车里所有item的价格总值
                getTotal:function(){
                    var itemCount=this.getItemCount(),total=0;
                    while(itemCount--){
                        total+=basket[itemCount].price;
                    }
                    return total;
                }
            };
        })();
    
        //basketModule返回了一个拥有公用API的对象
        basketModule.addItem({
            item:"bread",
            price: 0.5
        });
        basketModule.addItem({
            item:"butter",
            price:0.3
        });
        console.log(basketModule.getItemCount());
        console.log(basketModule.getTotal());
        //会打印一个private和一个undefined,原因不明
        console.log(basketModule.doSomething());
        console.log(basketModule.basket);

    复制代码

     

    basket模块的优点:

     

    1》只有模块自身才能享有拥有私有函数的自由,因为它只会暴露我们输出的API。

     

    2》鉴于函数往往已声明并命名,在试图找到哪些函数抛出异常时,这将使得在调试器中显示调用堆栈变得更容易。(没感觉)

     

    3》根据环境,还可以让我们返回不同 的函数

     

    9.2.2.3 示例

    复制代码

        /**
         * counter的存在被局限在模块的闭包内,唯一能访问其作用域的代码是return中的2个函数
         */
        var testModule=(function(){
            var counter=0;
            return{
                incrementCounter:function(){
                    return ++counter;
                },
                resetCounter:function(){
                    console.log("counter value prior to reset "+counter);
                    counter=0;
                }
            };
        })();
        //增加计数器
        testModule.incrementCounter();
        //检查并重置计数器
        testModule.resetCounter();

    复制代码

     

    复制代码

    //引入混入
        var myModule=(function(jQ,_){
            function privateMethod1(){
                jQ(".container").html("test");
            }
            return{
                publicMethod:function(){
                    privateMethod1();
                }
            };
        //引入JQuery和Underscore
        })(jQuery,_);

    复制代码

     

    我们用立即执行函数(Immediately-Invoked-Function-Expressions (IIFE)) 创建私有空间,防止其泄露全局作用域。其样子如下:

    var myGirlfriend = (function() {
    
      // 定义私有变量或方法
      var name = '小郑';
    
      var _kiss = function() {
        console.log('吻');
      }
    
      var _smile = function() {
        console.log('微笑');
      }
    
      return {
        // 暴露给公有的变量或方法
        simle: _smile,
        name: name
      }
    
    })();
    
    console.log(myGirlfriend.name); 
    myGirlfriend.simle();
    
    console.log(myGirlfriend._simle);
    console.log(myGirlfriend._kiss);
    
    /**
     * 结果:
     *     小美
     *     微笑
     *     undefined
     *     undefined
    */
    

    在Module模式内,由于闭包的存在,声明的变量和方法只在模式内部可用,但在返回的对象上定义的变量和方法,在对外部也可用。如上面例子:其他人可以知道我的女朋友的名字,也可以看到我女朋友微笑,但不可以吻我女朋友。

    Module模式的优缺点:

    优点:

    • 实现代码的封装模块化
    • 实现私有化变量和方法

    缺点:

    • 无法应用私有变量,造成无法对私有变量进行单元测试
    • 当我们想改可见性时,实际上要修改每一个曾经使用过该成员的地方。

    这里只举例了一种简单Module的设计模式,从Module模式上还衍生出Revealing Module(揭示模块)模式、Singleton(单例)模式。这些模式都很有使用价值,不同当我们的系统中出现了它们,则表示我们能需要评估我们的设计,例如Singleton的存在往往表明系统中的模块要么是系统紧密耦合,要么是其逻辑过于分散在代码库的多个部分中。



    作者:内孤
    链接:https://www.jianshu.com/p/03c5b939e5d4
    來源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • 终于讲清楚了nodejs中exports和module.exports的区别

    万次阅读 多人点赞 2018-09-06 15:06:39
    module.exports 对象是由模块系统创建的。在我们自己写模块的时候,需要在模块最后写好模块接口,声明这个模块对外暴露什么内容,module.exports 提供了暴露接口的方法。 1、返回一个JSON Object var app = { ...

    module.exports 对象是由模块系统创建的。在我们自己写模块的时候,需要在模块最后写好模块接口,声明这个模块对外暴露什么内容,module.exports 提供了暴露接口的方法。

    1、返回一个JSON Object

    var app = {
        name: 'app',
        version: '1.0.0',
        sayName: function(name){
            console.log(this.name);
        }
    }
    module.exports = app;
    •  

    这种方法可以返回全局共享的变量或者方法。
    调用方法:

    var app = require('./app.js');
    app.sayName('hello');//hello
    •  

    或者这样用:

    var func1 = function() {
       console.log("func1");
    };
    
    var func2 = function() {
       console.log("func2");
    };
    
    exports.function1 = func1;
    exports.function2 = func2;
    •  

    调用方法为:

    var functions = require("./functions");
    functions.function1();
    functions.function2();
    •  

    2、返回一个构造函数

    CLASS.js:

    var CLASS = function(args){
         this.args = args;
    }
    module.exports = CLASS;
    •  

    调用:

    var CLASS = require('./CLASS.js');
    varc = new CLASS('arguments');
    •  

    3、返回一个实例对象:

    //CLASS.js
    var CLASS = function(){
        this.name = "class";
    }
    CLASS .prototype.func = function(){
        alert(this.name);
    }
    module.exports = new CLASS();
    •  

    调用:

    var c = require('./CLASS.js');
    c.func();//"class"

     

    exports和module.exports

    可是这两种使用起来到底有什么区别呢???

    看了很多文章,长篇大论,始终没有讲清楚区别,自己也是看了很多,终于搞清楚了,给大家分享一下

    根据使用方法来说

    通常exports方式使用方法是:

    exports.[function name] = [function name]

    moudle.exports方式使用方法是:

    moudle.exports= [function name]

    这样使用两者根本区别是

    **exports **返回的是模块函数

    **module.exports **返回的是模块对象本身,返回的是一个类

    使用上的区别是
    exports的方法可以直接调用
    module.exports需要new对象之后才可以调用

    二话不说,撸代码!

    1. exports方式

    先创建一个exports_mode.js

    var sayHello = function(){    console.log('hello')
    }
    exports.sayHello = sayHelloconsole.log(exports); 
    console.log(module.exports);

    然后写一个test.js调用下试试看

    var exports_mode = require('./exports_mode')
    exports_mode.sayHello()

    输出:

     

    exports_mode.png

    发现此时exports和module.exports对象输出的都是一个sayHello方法,
    为什么module.exports也有exports方法了,简单点理解就是

    exports是module.exports的一个引用,exports指向的是module.exports

    我们来验证下,在exports_mode.js最后一行添加一句代码

    var sayHello = function(){    console.log('hello')
    }
    exports.sayHello = sayHelloconsole.log(exports); 
    console.log(module.exports); 
    console.log(exports === module.exports);

    结果输出.png

    发现console.log(exports === module.exports)返回的是true,
    说明exports和module.exports是同一个对象

    下来看看

    2. module.exports方式

    首先创建module_exports_mode.js

    var sayHello = function(){    console.log('hello')
    }module.exports = sayHelloconsole.log(module.exports); 
    console.log(exports); 
    console.log(exports === module.exports);

    然后测试一下

    var module_export_mode = require('./module_exports_mode')
    module_export_mode.sayHello()

    控制台输出.png

    发现输出报错了!

    为什么呢,因为我们的调用方式错了,一开始就说到了

    **module.exports **返回的是模块对象本身

    正确的调用

    var module_export_mode = require('./module_exports_mode')new module_export_mode()

    控制台输出.png

     

    同时我们可以看到,输出的module.exports对象内容就是一个[Function],在javascript里面是一个类

    使用这样的好处是exports只能对外暴露单个函数,但是module.exports却能暴露一个类

    我们把module_exports_mode.js扩展一下

    var xiaoming = function(name){    this.name = name    this.sayHello = function(){        return 'hello '+this.name
        }    this.sayGoodBye = function(){        return 'goodbye '+this.name
        }
    }module.exports = xiaomingconsole.log(module.exports); 
    console.log(exports); 
    console.log(exports === module.exports);

    然后测试

    var xiaoming = require('./module_exports_mode')var xiaoming = new xiaoming('Lucien')console.log(xiaoming.sayHello())console.log(xiaoming.sayGoodBye())

    控制台输出.png

    使用方法和javascript的类创建对象一毛一样

    exports.[function name] = [function name]
    moudle.exports= [function name]

    以上就是这两种方式的使用区别。


    等等,还没完。。。

    上面有提到

    exports是module.exports的一个引用,exports指向的是module.exports

    也就是说exports的方法module.exports也是一定能完成的

    exports.[function name] = [function name]
    moudle.exports= [function name]

    所以,在使用上

    ** moudle.exports.[function name]   = [function name] **
    **  是完全和 **
    ** exports.[function name] = [function name]  **
    **  相等的   **

    但是我们通常还是推荐使用exports.[function name],各司其职,代码逻辑清晰

     

    exports、module.exports 和 export、export default 到底是咋回事

    前言

    难得有空,今天开始重新规范的学习一下node编程。
    但是引入模块我看到用 require的方式,再联想到咱们的ES6各种export 、export default

    阿西吧,头都大了....

    头大完了,那我们坐下先理理他们的使用范围。

    require: node 和 es6 都支持的引入
    export / import : 只有es6 支持的导出引入
    module.exports / exports: 只有 node 支持的导出

    这一刻起,我觉得是时候要把它们之间的关系都给捋清楚了,不然我得混乱死。话不多少,咱们开干!!

    node模块

    Node里面的模块系统遵循的是CommonJS规范。
    那问题又来了,什么是CommonJS规范呢?
    由于js以前比较混乱,各写各的代码,没有一个模块的概念,而这个规范出来其实就是对模块的一个定义。

    CommonJS定义的模块分为: 模块标识(module)、模块定义(exports) 、模块引用(require)

    先解释 exports 和 module.exports
    在一个node执行一个文件时,会给这个文件内生成一个 exportsmodule对象,
    module又有一个exports属性。他们之间的关系如下图,都指向一块{}内存区域。

    exports = module.exports = {};复制代码

     

    内存结构示意图

    内存结构示意图

     

    那下面我们来看看代码的吧。

    //utils.js
    let a = 100;
    
    console.log(module.exports); //能打印出结果为:{}
    console.log(exports); //能打印出结果为:{}
    
    exports.a = 200; //这里辛苦劳作帮 module.exports 的内容给改成 {a : 200}
    
    exports = '指向其他内存区'; //这里把exports的指向指走
    
    //test.js
    
    var a = require('/utils');
    console.log(a) // 打印为 {a : 200}复制代码

    从上面可以看出,其实require导出的内容是module.exports的指向的内存块内容,并不是exports的。
    简而言之,区分他们之间的区别就是 exports 只是 module.exports的引用,辅助后者添加内容用的。

    用白话讲就是,exports只辅助module.exports操作内存中的数据,辛辛苦苦各种操作数据完,累得要死,结果到最后真正被require出去的内容还是module.exports的,真是好苦逼啊。

    其实大家用内存块的概念去理解,就会很清楚了。

    然后呢,为了避免糊涂,尽量都用 module.exports 导出,然后用require导入。

    ES中的模块导出导入

    说实话,在es中的模块,就非常清晰了。不过也有一些细节的东西需要搞清楚。
    比如 export 和 export default,还有 导入的时候,import a from ..,import {a} from ..,总之也有点乱,那么下面我们就开始把它们捋清楚吧。

    export 和 export default

    首先我们讲这两个导出,下面我们讲讲它们的区别

    1. export与export default均可用于导出常量、函数、文件、模块等
    2. 在一个文件或模块中,export、import可以有多个,export default仅有一个
    3. 通过export方式导出,在导入时要加{ },export default则不需要
    4. export能直接导出变量表达式,export default不行。

    下面咱们看看代码去验证一下

    testEs6Export.js

    'use strict'
    //导出变量
    export const a = '100';  
    
     //导出方法
    export const dogSay = function(){ 
        console.log('wang wang');
    }
    
     //导出方法第二种
    function catSay(){
       console.log('miao miao'); 
    }
    export { catSay };
    
    //export default导出
    const m = 100;
    export default m; 
    //export defult const m = 100;// 这里不能写这种格式。复制代码

    index.js

    //index.js
    'use strict'
    var express = require('express');
    var router = express.Router();
    
    import { dogSay, catSay } from './testEs6Export'; //导出了 export 方法 
    import m from './testEs6Export';  //导出了 export default 
    
    import * as testModule from './testEs6Export';//as 集合成对象导出
    
    
    
    /* GET home page. */
    router.get('/', function(req, res, next) {
      dogSay();
      catSay();
      console.log(m);
      testModule.dogSay();
      console.log(testModule.m); // undefined , 因为  as 导出是 把 零散的 export 聚集在一起作为一个对象,而export default 是导出为 default属性。
      console.log(testModule.default); // 100
      res.send('恭喜你,成功验证');
    });
    
    module.exports = router;

     

    展开全文
  • 什么是module 以及如何写一个module

    千次阅读 2006-01-16 13:09:00
  • module

    2019-03-22 06:00:00
    新闻 管理 ...在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。...为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的...
  • IDEA 导入多个Module,多个Module在同一个Project 下显示

    万次阅读 多人点赞 2017-08-24 15:19:48
    使用IDEA 过程中遇到的问题,我想一一记录下来并希望对后面使用IDEA时遇此问题的人到有所帮助。  1、打开IDEA , 点击右上角 File ---> Project Structure (快捷键:Ctrl + Alt + Shift + S)     ...
  • angular 模块 @NgModule的使用及理解

    千次阅读 2019-03-19 15:50:16
    @NgModule 的重要作用 在 Angular 中,NgModule 有以下几个重要的作用: NgModule 最根本的意义是帮助开发者组织业务代码,开发者可以利用 NgModule 把关系比较紧密的组件组织到一起,这是首要的。...
  • 前言:pytorch中对于一般的序列模型,直接使用torch.nn.Sequential类及可以实现,这点类似于keras,但是更多的时候面对复杂的模型,比如:多输入多输出、多分支...一、torch.nn.Module类概述 个人理解,pytorch不...
  • vb的module 和class module 有什么区别?

    万次阅读 2007-07-03 13:46:00
    标准模块与类模块的比较 在数据存储方式上,类不同于标准模块。标准模块的数据不可能多于一份。这意味着若程序中某个部分改动了标准模块的公共变量,随后程序的其它部分读取该变量会得到该值。 相反,类模块数据则...
  • IntelliJ IDEA 中 Project 和 Module 的概念及区别

    万次阅读 多人点赞 2017-03-23 20:29:04
    在 IntelliJ IDEA 中,没有类似于 Eclipse 工作空间(Workspace)的概念,而是提出了Project和Module这两个概念。接下来,就让咱们一起看看 IntelliJ IDEA 官方是如何描述两者的吧!对于 Project,IntelliJ IDEA 是...
  • Go module的介绍及使用

    万次阅读 多人点赞 2018-08-31 18:46:32
    Go1.1.1版本发布(2018-08-24发布)已经过去几天,从官方的博客中看到,有两个比较突出的特色,一个就是今天讲的module,模块概念。目前该功能还在试验阶段,有些地方还需要不断的进行完善。不过可以先尝尝鲜,感受下...
  • 问题描述: Anaconda3安装tensorflow,安装完anaconda后,在prompt中activate tensorflow,进入"python"环境下,"import tensorflow as tf"报错: 但是在(base)模式中“conda list"...
  • 3.7版本需要一个新的包libffi-devel,安装此包之后再次进行编译安装即可。 #yum install libffi-devel -y #make install 若在安装前移除了/usr/bin下python的文件链接依赖,此时yum无法正常使用,需要自己下载...
  • Failed to compile../src/components/1-模板语法/test.vueModule not found: Error: Can't resolve 'less-loader' in 'D:\vue\myVue\myVue\src\components\1-模板语法' @ ./src/components/1-模板语法/test.vue 4:2-...
  • 前言:前面介绍了如何自定义一个模型——通过继承nn.Module类来实现,在__init__构造函数中申明各个层的定义,在forward中实现层之间的连接关系,实际上就是前向传播的过程。 事实上,在pytorch里面自定义层也是...
  • TensorFlow报错:AttributeError: module ‘tensorflow._api.v1.train’ has no attribute 'SummaryWriter’等 分析:版本更新,方法调用方式改变 解决方式: 报错 原方法 更改后方法 ...
  • 问题:确保将调用的模块与被调用的模块放在同一目录下,但仍出现ModuleNotFoundError: No module named ‘XXX’。 Python会在以下路径中搜索它想要寻找的模块: 程序所在的文件夹 标准库的安装路径 操作系统...
  • 由于重新装了一个系统,很多环境配置要重新配置。在想run 一个项目时,出现下面的...Module build failed: Error: Cannot find module 'node-sass' at Function.Module._resolveFilename (internal/modules/cjs/...
  • JS错误Uncaught SyntaxError: Cannot use import statement outside a module< 分析及解决方法 错误信息: 错误分析: HTML 网页中,浏览器通过 script 标签加载 JavaScript 脚本。由于浏览器脚本的默认语言是 ...
1 2 3 4 5 ... 20
收藏数 1,085,594
精华内容 434,237
关键字:

module