1  super(Embedding, self).__init__()

1 self.weight = Parameter(torch.Tensor(num_embeddings, embedding_dim))

 1 class Parameter(Variable):
 2     """A kind of Variable that is to be considered a module parameter.
 3 
 4     Parameters are :class:`~torch.autograd.Variable` subclasses, that have a
 5     very special property when used with :class:`Module` s - when they‘re
 6     assigned as Module attributes they are automatically added to the list of
 7     its parameters, and will appear e.g. in :meth:`~Module.parameters` iterator.
 8     Assigning a Variable doesn‘t have such effect. This is because one might
 9     want to cache some temporary state, like last hidden state of the RNN, in
10     the model. If there was no such class as :class:`Parameter`, these
11     temporaries would get registered too.
12 
13     Another difference is that parameters can‘t be volatile and that they
14     require gradient by default.
15 
16     Arguments:
17         data (Tensor): parameter tensor.
18         requires_grad (bool, optional): if the parameter requires gradient. See
19             :ref:`excluding-subgraphs` for more details.
20     """
21     def __new__(cls, data=http://www.mamicode.com/None, requires_grad=True):
22         return super(Parameter, cls).__new__(cls, data, requires_grad=requires_grad)
23 
24     def __repr__(self):
25         return ‘Parameter containing:‘ + self.data.__repr__()

 1 class O(object):
 2     def __init__(self, *args, **kwargs):
 3         print "init"
 4         super(O, self).__init__(*args, **kwargs)
 5 
 6     def __new__(cls, *args, **kwargs):
 7         print "new", cls
 8         return super(O, cls).__new__(cls, *args, **kwargs)
 9 
10     def __call__(self,  *args, **kwargs):
11         print "call"
12       
13     oo = O()
14     print "________"
15     oo()  

1 new
2 init
3 ________
4 call

 1 class Conv2d(_ConvNd):
 2     r"""Applies a 2D convolution over an input signal composed of several input
 3     planes.
 5     """
 6 
 7     def __init__(self, in_channels, out_channels, kernel_size, stride=1,
 8                  padding=0, dilation=1, groups=1, bias=True):
 9         kernel_size = _pair(kernel_size)
10         stride = _pair(stride)
11         padding = _pair(padding)
12         dilation = _pair(dilation)
13         super(Conv2d, self).__init__(
14             in_channels, out_channels, kernel_size, stride, padding, dilation,
15             False, _pair(0), groups, bias)
16 
17     def forward(self, input):
18         return F.conv2d(input, self.weight, self.bias, self.stride,
19                         self.padding, self.dilation, self.groups)

 1 def _ntuple(n):
 2     def parse(x):
 3         if isinstance(x, collections.Iterable):
 4             return x
 5         return tuple(repeat(x, n))
 6     return parse
 7 
 8 _single = _ntuple(1)
 9 _pair = _ntuple(2)
10 _triple = _ntuple(3)
11 _quadruple = _ntuple(4)

 1 def two_dim(y):
 2     def one_dim(x):
 3         return x*x + y
 4     return one_dim
 5     
 6 one_dim_plus_one = two_dim(1)
 7 
 8 print(one_dim_plus_one)     # 对象地址 <function two_dim.<locals>.one_dim at 0x0000012F6DBFCB70>
 9 print(one_dim_plus_one(2))  # 5
10 print(one_dim_plus_one(3))  #10
11 
13 # f = x*x+y
14 # g1 = f(x,1)
15 f = lambda x,y:x*x+y
16 g1 = lambda x:f(x,1) # x*x+1
17 
18 print(g1)       # f(x,1)的地址?
19 print(g1(3))    # 10

1 if isinstance(x, collections.Iterable):
2       return x
3 return tuple(repeat(x, n))

1 x = ‘hello‘
2 print(_quadruple(x))        # ‘hello‘是可迭代对象，输出‘hello‘
3 
4 x = 2                       # 2不是可迭代对象，输出(2,2,2,2)
5 print(_quadruple(x))

1 isinstance(obj, class_or_tuple, /)

1 a = Notebook()
2 isinstance(a, Notebook)       # True
3 
4 class Test(Notebook):pass
5 issubclass(Test, Notebook)      # True

1 def forward(self, input):
2      return F.conv2d(input, self.weight, self.bias, self.stride,
3                   self.padding, self.dilation, self.groups)

 1 # Convolutions
 2 ConvNd = torch._C._functions.ConvNd
 3 
 4 def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1,
 5            groups=1):
 6     """Applies a 2D convolution over an input image composed of several input
 7     planes.
 8 
 9     See（参考） :class:`~torch.nn.Conv2d` for details and output shape.
10     """
11     f = ConvNd(_pair(stride), _pair(padding), _pair(dilation), False,
12                _pair(0), groups, torch.backends.cudnn.benchmark, torch.backends.cudnn.enabled)
13     return f(input, weight, bias)

 1 # AttributeError: ‘Child‘ object has no attribute ‘data‘
 2 class Parent:
 3     def __init__(self):
 4         self.data =http://www.mamicode.com/12"color: #008080"> 5         
 6 class Child(Parent):
 7     def __init__(self):
 8         pass
 9         super().__init__()
10         
11 a = Child()
12 print(a.data)
13 
14 
15 # 12
16 class Parent:
17     def __init__(self):
18         self.data =http://www.mamicode.com/12"color: #008080">19         
20 class Child(Parent):
21     def __init__(self):
22         
23         super().__init__()
24                
25 a = Child()
26 print(a.data)
27 
28 
29 # 12
30 class Parent:
31     def __init__(self):
32         self.data =http://www.mamicode.com/12"color: #008080">33         
34 class Child(Parent):
35     def __init__(self):
36         self.data = http://www.mamicode.com/25"color: #008080">37         super().__init__()       
38         
39 a = Child()
40 print(a.data)
41 
42 
43 # 25
44 class Parent:
45     def __init__(self):
46         self.data =http://www.mamicode.com/12"color: #008080">47         
48 class Child(Parent):
49     def __init__(self):
50         
51         super().__init__()
52         self.data = http://www.mamicode.com/25"color: #008080">53         
54 a = Child()
55 print(a.data)

1 def search(self, filter):
2     return [note for note in self.notes if note.match(filter)]

1 def search(self, filter):
2     temp = []
3     for note in self.notes:
4         if note.match(filter):
5             temp.append(note)
　　　　return temp

 1 f = [x for if for if for for if]
 2 # 等价于
 3 temp_list = []
 4 for st:
 5     if st:
 6         ...
 7           if:
 8             temp_list.append(x)
 9 f = temp_list
10 
11 #
12 f = []
13 for st:
14      if st:
15          ...
16           if:
17             f.append(x)
18 
19 # x*y for x in range(1,10) for y in range(1,10)
20 a = []
21 for x in range(1,10):
22     for y in range(1,10):
23         a.append(x*y)

 1 var = 13
 2 
 3 def test():
 4     global var 
 5     var = 12
 6     print(var)
 7     
 8 # print(var)
 9 var = 25
10 test()