摘录Ruby编程语言：
module Functional
def compose(f)
if self.respond_to?(:arity) && self.arity == 1
lambda {|*args| self[f[*args]] }
else
lambda {|*args| self[*f[*args]] }
end
end
alias * compose
end
class Proc; include Functional; end
class Method; include Functional;
浏览 4提问于2014-09-03得票数 3
回答已采纳
有什么区别
module A
def self.included(klass)
puts klass
end
end
和
module A
include ActiveSupport::Concern
included do
puts self
end
end
哪一个更好，什么时候使用？
浏览 7提问于2013-12-19得票数 3
回答已采纳
__new__ (双下划线)和_new_ (单下划线)有什么区别？我不能理解。
请看下面的代码。它使用双下划线__new__函数，但不起作用：
class B(object):
def __new__(cls,*a,**b):
ne = object.__new__(cls,*a,**b)
setattr(ne,"created at",datetime.datetime.now())
return ne
def __init__(self,x,y):
print("initteyiz
浏览 2提问于2014-02-13得票数 0
1回答
下面两个类之间有什么区别吗？我知道inplace是什么(您不需要执行x = function(x)，而是只需要function(x)来修改x，如果inplace是True)。但是在这里，因为我们return self.conv(x)，这不重要，对吗？
class ConvBlock(nn.Module):
def __init__(
self,
in_channels,
out_channels,
down=True,
use_act=True,
**kwargs
):
浏览 3提问于2022-04-02得票数 1
回答已采纳
extend self和module_function是两种ruby方法，因此您可以调用模块上的方法，如果包含该模块，还可以调用该方法。
这些方法的最终结果之间有什么区别吗？
浏览 0提问于2010-03-01得票数 47
回答已采纳
在Crystal中，有两种不同的方法可以实现类似的结果：
创建一个类..。
class Service
def self.get
# ...
end
end
或扩展self的模块
module Service
extend self
def get
# ...
end
end
两者都可以通过get通过Service.get调用方法。
但是什么时候使用类或模块呢？水晶的类和模块有什么区别？
浏览 0提问于2018-05-06得票数 7
回答已采纳
模块中的“扩展自我”和module_function :name_of_method有什么区别？
示例：
module Foo
def bar
puts 'hi from bar'
end
def buu
puts 'hi from buu'
end
extend self
end
对比
module Foo
def bar
puts 'hi from bar'
end; module_function :bar
def buu
puts 'hi from buu'
浏览 3提问于2014-09-18得票数 0
2回答
在用法上有什么区别吗？
class Helper
class << self
# ...
end
end
和
module Helper
class << self
# ...
end
end
什么时候你会使用一个而不是另一个呢？
浏览 0提问于2012-04-06得票数 7
回答已采纳
1回答
CNN特征提取
、、、、
class ResNet(nn.Module):
def __init__(self, output_features, fine_tuning=False):
super(ResNet, self).__init__()
self.resnet152 = tv.models.resnet152(pretrained=True)
#freezing the feature extraction layers
for param in self.resnet152.parameters():
param.requires_grad = f
浏览 1提问于2021-08-22得票数 0
回答已采纳
1回答
下面两个例子有什么区别吗？是否有可能因为方法名称而在第二个示例中获得方法冲突？模块中的方法不是自动“封装”在这个模块中吗？
示例1
module ImageUtils
def self.preview(image)
#do something
end
end
示例2
module ImageUtils
def preview(image)
#do something
end
end
如果我将所有内容放入模块Foo中的类ImageUtils中，这有什么区别呢？
浏览 6提问于2014-09-09得票数 2
回答已采纳
假设我在app/lib中有一个解析器模块(app/lib)
module Parsers
class XMLParser
def self.parse
"Parsing XML...."
end
end
class TXTParser
def self.parse
"Parsing TXT...."
end
end
end
我见过一些人这样叫他们：
@parse_xml = ::Parsers::XMLParser.p
浏览 0提问于2019-06-02得票数 1
回答已采纳
我从来没有想到过Python2.7的2.7的继承是如此的反人类.为什么下面的代码会给我一个TypeError？
>>> class P:
... def __init__(self, argp):
... self.pstr=argp
...
>>> class C(P):
... def __init__(self, argp, argc):
... super.__init__(self,argp)
... self.cstr=argc
...
>>> x=C("
浏览 2提问于2014-01-11得票数 13
回答已采纳
有时我会看到这样的代码：
module Elite
module App
def app
'run app'
end
end
module Base
def base
'base module'
end
end
class Application
include Elite::Base #Include variant A
include ::Elite::App #Incl
浏览 1提问于2012-05-11得票数 1
回答已采纳
我使用的是requireJS 2.x。我发现有些教程(和官方文档)有时会使用
requirejs.config({ [...] });
requirejs(["module"]) ...
有时
require.config({ [...] });
require(["module"]) ...
这两个函数(require和requirejs)之间有什么区别吗？我在文档中找不到任何关于这方面的信息。:(
浏览 1提问于2012-11-28得票数 82
回答已采纳
我需要具有单例行为的类。
使用Singleton模块有什么区别...
require 'singleton'
class X
include Singleton
def set_x(x)
@x = x
end
def test
puts @x
end
end
X::instance.set_x('hello')
X::instance.test
使用类方法和类实例变量的...and？
class X
def self.set_x(x)
@x = x
e
浏览 4提问于2011-09-12得票数 0
回答已采纳
我正在尝试创建一个模块，它包含nn.Parameters()的某些层。如果我按以下方式初始化该层-
self.W = nn.Parameter(torch.randn(4,4), requires_grad=True).double()
然后，该层不显示在模块参数中注册。
但是，这个初始化是有效的-
self.W = nn.Parameter(torch.FloatTensor(4,4), requires_grad=True)
完整的例子-
class TestNet(nn.Module):
def __init__(self):
super(TestNet, sel
浏览 4提问于2022-11-14得票数 0
回答已采纳
嗨！返回模块或this有什么区别？
当我返回this时，返回模块和获取实例是不同的
在这种情况下，const obj和this.obj有什么区别？
let module = function (value) {
const obj = {};
// or
this.obj = {};
this.title = function (value) {
this.obj.title = value
return this;
}
// or
module.title = function (value) {
浏览 2提问于2021-03-03得票数 1
回答已采纳
这里有一个关于实例变量的Python新手问题。
考虑以下Python2.7类定义：
class Foo(object):
a = 1
def __init__(self):
self.b = 2
def __repr__(self):
return "%s" % self.__dict__
现在，当我创建Foo实例时，Foo.__dict__包含b，但不包含a。
>>> x=Foo()
>>> x
{'b': 2}
>>> dir(x
浏览 1提问于2012-05-12得票数 3
回答已采纳
1回答
选择者与动作斯威夫特4
、、、
斯威夫特的新手。下面有两个片段：
NotificationCenter.default.addObserver(self,
selector:#selector(ViewController.notificationReceived),
name: Notification.Name(rawValue: name), object: nil)
@objc func notificationReceived(notification:Notification){
let x = notification.userInfo!
print("\(x[&#
浏览 14提问于2017-06-30得票数 13
在Python中，理论上，哪种方法在test1和test2之外应该更快(假设x的值相同)。我试过使用%timeit，但是没有什么区别。
import numpy as np
class Tester():
def __init__(self):
self.x = np.arange(100000)
def test1(self):
return np.sum(self.x * self.x )
def test2(self,x):
return np.sum(x*x)
浏览 3提问于2013-11-03得票数 2
回答已采纳
有什么区别？
module Logging
def self.log
if @logger.nil?
@logger = Logger.new STDOUT
end
@logger
end
end
这个呢？
class Logging
def self.log
if @logger.nil?
@logger = Logger.new STDOUT
end
@logger
end
end
他们两人似乎都在做同样的事情。我为什么要选择一个而不是另一个？
浏览 3提问于2016-07-16得票数 6
回答已采纳
2回答
我希望你做得很好。我是Ruby的新手，我并不真正理解setter方法和带有参数的方法之间的区别。例如，假设我有以下代码：
module Popy
def self.friend
@friend
end
def self.friend=(new_friend)
@friend = new_friend
end
end
据我所知，使用称为“朋友”的setter方法，我设置了Popy的“朋友”。但是如果我把这个方法放进去，有什么区别呢？
def self.friend!(new_friend)
@friend = new_friend
end
我
浏览 7提问于2022-10-24得票数 1
这两种方法有什么区别吗？option1：
class a(object):
def __init__(self):
self.x = 123
self.y = 345
option2：
class a(object):
x = 123
y = 345
这两种选择有什么不同吗？提前谢谢。
浏览 4提问于2015-07-12得票数 2
回答已采纳
3回答
class Test {
public function __construct() {
self::runTest();
Test::runTest();
}
public static function runTest() {
echo "Test running";
}
}
// echoes 2x "Test running"
new Test();
self::runTest()和Test::runTest()有什么区别吗？如果是这样，我应该使用哪一个？
在类内调用方法
浏览 1提问于2013-01-21得票数 2
回答已采纳
我看到某些模块列出了它们的依赖项，前缀为drupal:，而其他模块则没有。
在以下方面有什么区别：
name: Core
type: module
core: 8.x
dependencies:
- block
和
name: Core
type: module
core: 8.x
dependencies:
- drupal:block
注意drupal:前面的额外前缀block。
浏览 0提问于2018-07-18得票数 0
回答已采纳
@property (nonatomic, weak) id a;
@property (nonatomic, weak) id sa;
我有两个弱属性。该数组将在复制后释放。但是NSString没有被释放。我不知道有什么区别。为什么不释放字符串？
查看代码和输出：
{ NSMutableString *sa = [NSMutableString alloc initWithString:@" sa "]；NSMutableArray *array = NSMutableArray arrayWithObject:@"aaa"；self.a .a=数组复制；
浏览 1提问于2017-04-23得票数 9
回答已采纳
1回答
使用一个事件控件和两个事件控件的始终块之间有什么区别？
module test;
logic a,b;
initial
begin
a = 0;
a = 1;
a=0;
a=1;
end
always@(posedge a)
// @(posedge a)
b = a;
initial $monitor(b); // uncommenting @(posedge a) results to 'x'. Otherwise results to '1&
浏览 2提问于2018-02-14得票数 1
1回答
也许您可以定义一个属性并将其分配给如下所示的对象：
a = property(lambda self: getattr(self, "_a"), lambda self, x: setattr(self, "_a", x+1))
b = type("B", (object,), {"a": a, "_a": None})
结果，调用b.a = 2将覆盖该属性。
这就是我试图用倾斜物体复制的东西。
class B:
_a = None
@property
def a(self):
浏览 2提问于2016-12-05得票数 3
1回答
我正在学习Python教程-
class Pizza(object):
@staticmethod
def mix_ingredients(x, y):
return x + y
def cook(self):
return self.mix_ingredients(self.cheese, self.vegetables)
>>> Pizza().cook is Pizza().cook
False
>>> Pizza().mix_ingredients is Pizza.mix_ingredi
浏览 7提问于2014-11-27得票数 1
回答已采纳
child类继承自parent类。在child的构造函数中，我正在通过反复调用在parent中定义的成员函数foo()来初始化一个list-type成员变量xs。结果是，如果我通过显式循环并追加foo()返回的每个值来初始化foo()，那么一切都正常。
然而，如果我试图在列表理解中做同样的事情，我就会遇到一个奇怪的错误。为什么会发生此错误？在这种情况下，列表理解和显式循环有什么区别？
工作代码的MWE：
class parent(object):
def __init__(self):
self.x = 5
def foo(self, a):
浏览 1提问于2015-07-01得票数 8
回答已采纳
3回答
在模块中使用扩展自
、、、、
在投票赞成 结束之前，我想说我的问题真的很简单(在上面提到的问题中没有提出)。
有两个模块，一个使用extend self定义模块方法，另一个定义mixin方法。
module A
extend self
def module_a_meth
"Called module_a_meth"
end
end
module B
def module_b_meth
"Called module_b_meth"
end
end
有一个类，其中我同时使用了include和extend这些模块：
class Test
include A
浏览 6提问于2015-04-21得票数 4
回答已采纳
如果可能的重写在实现期间没有被标记为重写，有没有办法检查类方法是重写还是从基类继承的？ class Super(object):
def method(self, x, y):
v = x + y
return v
class Sub1(Super):
def method(self, x, y):
v = x + y + 10 # the calcs are irrelevant, not a reliable way to determine if inherited
return v
class Sub2(Super):
def ownM
浏览 20提问于2021-07-17得票数 0
1回答
我有几个基于nn.module的类，我希望在这些类之间传输数据。具体来说，我需要从第一个类获取数据，并将其添加到第二个类中的一个变量中。然后，将第二类中的合并数据添加到第三类。我的问题是，如何能够基于父类和子类的关系来完成这个过程？此外，欢迎其他解决办法。
下面是一个简单的例子：
class A(nn.Module):
def __init__(self, in, out):
super(A, self).__init__()
self.a=function(.....)
def forward(self, x):
浏览 6提问于2022-04-11得票数 1
假设模块是包含的，而不是扩展的，那么模块实例变量和类变量有什么区别呢？
我看不出两者有什么不同。
module M
@foo = 1
def self.foo
@foo
end
end
p M.foo
module M
@@foo = 1
def self.foo
@@foo
end
end
p M.foo
我一直在模块中使用@ as @@，最近我看到其他代码也在模块中使用@@。然后我想我可能用错了。
因为我们不能实例化一个模块，所以对于一个模块，@和@@之间必须没有区别。我说错了吗？
为了回答一些关于评论和帖子的问题，我还测试了以下内容。
modu
浏览 0提问于2012-09-11得票数 9
回答已采纳
我目前知道如何生成类和对象的三种方法。
方法1(这个可怕的东西)：
;(function(global) {
let module = global.player1 = {};
module.x = 0;
module.y = 0;
module.tick = function() { /* Do stuff */ }
module.show = function(g) {
g.fillRect(module.x, module.y, 16, 16);
}
})(this);
方法2(类ES6)：
class CPlayer {
constructor()
浏览 5提问于2017-11-28得票数 1
回答已采纳
class Adder:
def __call__(self, x, y):
return x + y
add1 = Adder()
def add2(x, y):
return x + y
除了类型以外，add1和add2还有什么区别？
浏览 1提问于2018-02-19得票数 4
回答已采纳
1回答
为了用torch.nn.utils.prune l1_unstructured、radom_unstructured方法实现l1规范、非结构化、分层剪枝，我有一个玩具LeNet-300-100密集神经网络。
class LeNet300(nn.Module):
def __init__(self):
super(LeNet300, self).__init__()
# Define layers-
self.fc1 = nn.Linear(in_features = 28 * 28 * 1, out_features =
浏览 15提问于2022-11-08得票数 1
回答已采纳
例如，以下(愚蠢的)示例将在vscode中引发错误：
class Something:
def __init__(self, x):
self.x = x
def something_else(self, y) -> Something:
return Something(self.x + y)
在这里看到：
其中，mypy script.py将不返回任何错误。
我不知道这里有什么区别，但我更希望类型优先，因为这是我用来捕获类型错误的方法。
浏览 9提问于2022-04-10得票数 0
2回答
两个例子；
class Foo1:
something = 0
def __init__(self, n):
self.something = n
和
class Foo2:
def __init__(self, n):
self.something = n
这两个阶层似乎都有相同的行为：
x = Foo1(42)
y = Foo2(36)
print x.something
# will print 42
print y.something
# will print 36
但是在类Foo1中，变量self.something (在构造函
浏览 5提问于2014-10-30得票数 1
回答已采纳
1回答
这是我的测试程序：
module Foo
@@bar1 = "1" # static property of the module?
class << self # open static section
@bar2 = "2" # property in static section, should be static property?
def func1 # static function
puts "bar1: #{@@bar1}"
puts "bar2: #{@
浏览 4提问于2016-07-04得票数 2
1回答
是否有一种方法(最好使用模块)来了解函数是否有所需数量的参数？
例如，如果用户界面允许用户插入python表达式--例如"sum(x)“，但是用户错误地输入了"sum()”，那么有什么方法可以在运行时之前验证该表达式呢？
我已经在符号树的每个节点上调用了ast.dump，但是这些符号上的信息似乎不足以进行这种分析？
例如：
#own debug code added to ast.py
def visit(self, node):
print(dump(node),True, False)
method = 'visit_' + node.__class
浏览 2提问于2014-09-26得票数 2
回答已采纳
使用JavaScript和<script type=module>在HTML中加载<script type=module>文件有什么区别？
浏览 0提问于2018-07-19得票数 23
回答已采纳
我有一门课是这样的：
#!/usr/bin/env python
class Foo:
def __init__(self, x):
self.x = x
def bar(self):
self.bar1_out = self.x + 5
self.bar2_out = self.x + 1
return (self.bar1_out,self.bar2_out)
def qux(self,myvalue = None):
first, second = myvalue or self.ba
浏览 2提问于2014-03-31得票数 8
回答已采纳
3回答
当我阅读Django票证和拉出请求时，我发现它们有以下更改：
他们希望得到一个关于页码的范围，并从
return range(1, self.num_pages + 1) # 1
至：
return six.moves.range(1, self.num_pages + 1) # 2
然后：
return list(six.moves.range(1, self.num_pages + 1)) # 3
我搞不懂1和3之间有什么区别？为什么不只是这个，和3有什么区别吗？
return list(range(1, self.num_pages + 1)) # 4
浏览 1提问于2014-08-05得票数 2
回答已采纳
既然self是指在其中调用instance_eval的对象，那么在instance_eval块中使用self进行方法定义有什么区别吗？
Z.instance_eval do
def x
end
def self.y
end
end
> Z.x
=> nil
> Z.y
=> nil
鉴于自我指的是Z，自我似乎是多余的。
浏览 2提问于2018-08-13得票数 2
回答已采纳
1回答
我在同一个文件夹中有两个py文件(IDE Pycharm)：
module1.py包含：
def test_func():
return "test_func"
class test_class(object):
def __init__(self):
self._test = test_func()
driver.py包含：
from module1 import test_class
obj = test_class()
print obj._test
我原以为driver.py会失败，因为类实例化要求test_func()在作用域中。
令
浏览 3提问于2015-11-30得票数 1
回答已采纳
ip与Sanic请求的remote_addr属性之间有什么区别？
源代码
@property
def ip(self):
"""
:return: peer ip of the socket
"""
if not hasattr(self, "_socket"):
self._get_address()
return self._ip
@property
def remote_addr(self):
"""Attempt to return
浏览 8提问于2020-04-14得票数 1
回答已采纳
定义了两个方法来设置映射的可见部分：和。两者都有非常相似的描述，行为(据我所知)都是一样的。
这两种方法有什么区别？
更让人困惑的是，示例应用程序在其中一种方法中使用了这两种方法：
...
[self.map setVisibleMapRect:MKMapRectMake(newCenterPoint.x, newCenterPoint.y, self.currentSpan.latitudeDelta, self.currentSpan.longitudeDelta)];
[self.map setRegion:region];
...
浏览 2提问于2015-04-17得票数 2
回答已采纳
我有所有这些类都非常相似，除了它们的covar_module。我想知道我是否可以创建一个通用的超类，它拥有所有的属性和函数，而子类只有covar_module。我是python的新手，所以我不知道synthax会是什么样子。 class RbfGP(ExactGP, GPyTorchModel):
_num_outputs = 1 # to inform GPyTorchModel API
def __init__(self, train_X, train_Y):
# squeeze output dim before passing train_Y to
浏览 17提问于2020-07-15得票数 0
我想使用Beautiful来解析html文件。
首先我做了：
from bs4 import BeautifulSoup
但我犯了错误：
from bs4 import BeautifulSoup
ImportError: No module named bs4
所以我做了：
import BeautifulSoup
一切都很顺利。我的问题是:从BeautifulSoup导入和直接导入的bs4之间有什么区别？bs4是python > 2.7的内置库吗？
然后我做了：
data = url.openUrl("http://emma-watson.net")
self.sou
浏览 3提问于2014-07-24得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
