What does the at symbol do in Python

Question

I m looking at some Python code which used the   symbol  but I have no idea what it does  I also do not know what to search for as searching Python docs or Google does not return relevant results when the   symbol is included

User · Answer

In Python 3 5 you can overload   as an operator  It is named as   matmul    because it is designed to do matrix multiplication  but it can be anything you want  See PEP465 for details   This is a simple implementation of matrix multiplication   class Mat list       def   matmul   self  B           A   self         return Mat   sum A i  k  B k  j  for k in range len B                        for j in range len B 0      for i in range len A      A   Mat   1 3   7 5    B   Mat   6 8   4 2     print A   B    This code yields     18  14    62  66

User · Answer

If you are referring to some code in a python notebook which is using Numpy library  then   operator means Matrix Multiplication  For example   import numpy as np def forward xi  W1  b1  W2  b2       z1   W1   xi   b1     a1   sigma z1      z2   W2   a1   b2     return z2  a1

User · Answer

What does the    at        symbol do in Python   In short  it is used in decorator syntax and for matrix multiplication   In the context of decorators  this syntax    decorator def decorated function           this function is decorated      is equivalent to this   def decorated function           this function is decorated     decorated function   decorator decorated function    In the context of matrix multiplication  a   b invokes a   matmul   b  - making this syntax   a   b   equivalent to   dot a  b    and   a    b   equivalent to   a   dot a  b    where dot is  for example  the numpy matrix multiplication function and a and b are matrices   How could you discover this on your own      I also do not know what to search for as searching Python docs or Google does not return relevant results when the   symbol is included    If you want to have a rather complete view of what a particular piece of python syntax does  look directly at the grammar file  For the Python 3 branch      grep -C 1     cpython Grammar Grammar   decorator      dotted name        arglist        NEWLINE decorators  decorator  -- testlist star expr   test star expr        test star expr          augassign           -                                   amp                                  lt  lt        gt  gt                     -- arith expr  term        -   term   term  factor                         factor   factor        -       factor   power   We can see here that   is used in three contexts    decorators an operator between factors an augmented assignment operator   Decorator Syntax   A google search for  decorator python docs  gives as one of the top results  the  Compound Statements  section of the  Python Language Reference   Scrolling down to the section on function definitions  which we can find by searching for the word   decorator   we see that    there s a lot to read  But the word   decorator  is a link to the glossary  which tells us      decorator      A function returning another function  usually applied as a function transformation using the  wrapper syntax  Common   examples for decorators are classmethod   and staticmethod         The decorator syntax is merely syntactic sugar  the following two   function definitions are semantically equivalent   def f               f   staticmethod f    staticmethod def f                     The same concept exists for classes  but is less commonly used there    See the documentation for function definitions and class definitions   for more about decorators    So  we see that   foo def bar        pass   is semantically the same as   def bar        pass  bar   foo bar    They are not exactly the same because Python evaluates the foo expression  which could be a dotted lookup and a function call  before bar with the decorator     syntax  but evaluates the foo expression after bar in the other case    If this difference makes a difference in the meaning of your code  you should reconsider what you re doing with your life  because that would be pathological    Stacked Decorators  If we go back to the function definition syntax documentation  we see     f1 arg   f2 def func    pass       is roughly equivalent to  def func    pass func   f1 arg  f2 func      This is a demonstration that we can call a function that s a decorator first  as well as stack decorators  Functions  in Python  are first class objects - which means you can pass a function as an argument to another function  and return functions  Decorators do both of these things   If we stack decorators  the function  as defined  gets passed first to the decorator immediately above it  then the next  and so on   That about sums up the usage for   in the context of decorators   The Operator     In the lexical analysis section of the language reference  we have a section on operators  which includes    which makes it also an operator      The following tokens are operators           -                                                 lt  lt        gt  gt        amp                           lt         gt         lt         gt                      and in the next page  the Data Model  we have the section Emulating Numeric Types     object   add   self  other  object   sub   self  other   object   mul   self  other   object   matmul   self  other   object   truediv   self  other   object   floordiv   self  other                These methods are called to implement the binary arithmetic operations     -                       And we see that   matmul   corresponds to    If we search the documentation for  matmul  we get a link to What s new in Python 3 5 with  matmul  under a heading  PEP 465 - A dedicated infix operator for matrix multiplication       it can be implemented by defining   matmul        rmatmul      and     imatmul     for regular  reflected  and in-place matrix multiplication     So now we learn that    is the in-place version   It further explains      Matrix multiplication is a notably common operation in many fields of   mathematics  science  engineering  and the addition of   allows   writing cleaner code   S    H   beta - r  T   inv H   V   H T     H   beta - r        instead of   S   dot  dot H  beta  - r  T          dot inv dot dot H  V   H T    dot H  beta  - r      While this operator can be overloaded to do almost anything  in numpy  for example  we would use this syntax to calculate the inner and outer product of arrays and matrices    gt  gt  gt  from numpy import array  matrix  gt  gt  gt  array   1 2 3    T   array   1 2 3    array   1  2  3           2  4  6           3  6  9     gt  gt  gt  array   1 2 3      array   1 2 3    T array   14     gt  gt  gt  matrix  1 2 3   T   matrix  1 2 3   matrix   1  2  3            2  4  6            3  6  9     gt  gt  gt  matrix  1 2 3     matrix  1 2 3   T matrix   14      Inplace matrix multiplication      While researching the prior usage  we learn that there is also the inplace matrix multiplication  If we attempt to use it  we may find it is not yet implemented for numpy    gt  gt  gt  m   matrix  1 2 3    gt  gt  gt  m    m T Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError  In-place matrix multiplication is not  yet  supported  Use  a   a   b  instead of  a    b     When it is implemented  I would expect the result to look like this    gt  gt  gt  m   matrix  1 2 3    gt  gt  gt  m    m T  gt  gt  gt  m matrix   14

User · Answer

What does the    at        symbol do in Python      symbol is a syntactic sugar python provides to utilize decorator  to paraphrase the question  It s exactly about what does decorator do in Python   Put it simple decorator allow you to modify a given function s definition without touch its innermost  it s closure   It s the most case when you import wonderful package from third party  You can visualize it  you can use it  but you cannot touch its innermost and its heart      Here is a quick example  suppose I define a read a book function on Ipython  In  9   def read a book                return  I am reading the book             In  10   read a book   Out 10    I am reading the book      You see  I forgot to add a name to it  How to solve such a problem  Of course  I could re-define the function as   def read a book        return  I am reading the book   Python Cookbook     Nevertheless  what if I m not allowed to manipulate the original function  or if there are thousands of such function to be handled   Solve the problem by thinking different and define a new function    def add a book func       def wrapper            return func      Python Cookbook      return wrapper   Then employ it   In  14   read a book   add a book read a book  In  15   read a book   Out 15    I am reading the book  Python Cookbook    Tada  you see  I amended read a book without touching it inner closure  Nothing stops me equipped with decorator   What s about     add a book def read a book        return  I am reading the book    In  17   read a book   Out 17    I am reading the book  Python Cookbook     add a book is a fancy and handy way to say read a book   add a book read a book   it s a syntactic sugar  there s nothing more fancier about it

User · Answer

This code snippet   def decorator func      return func   decorator def some func        pass   Is equivalent to this code   def decorator func       return func  def some func        pass  some func   decorator some func    In the definition of a decorator you can add some modified things that wouldn t be returned by a function normally

User · Answer

Decorators were added in Python to make function and method wrapping  a function that receives a function and returns an enhanced one  easier to read and understand  The original use case was to be able to define the methods as class methods or static methods on the head of their definition  Without the decorator syntax  it would require a rather sparse and repetitive definition   class WithoutDecorators  def some static method        print  this is static method   some static method   staticmethod some static method   def some class method cls       print  this is class method   some class method   classmethod some class method    If the decorator syntax is used for the same purpose  the code is shorter and easier to understand   class WithDecorators       staticmethod     def some static method            print  this is static method         classmethod     def some class method cls           print  this is class method     General syntax and possible implementations  The decorator is generally a named object   lambda expressions are not allowed  that accepts a single argument when called  it will be the decorated function  and returns another callable object   Callable  is used here instead of  function  with premeditation  While decorators are often discussed in the scope of methods and functions  they are not limited to them  In fact  anything that is callable  any object that implements the  call   method is considered callable   can be used as a decorator and often objects returned by them are not simple functions but more instances of more complex classes implementing their own   call  method   The decorator syntax is simply only a syntactic sugar  Consider the following decorator usage    some decorator def decorated function        pass   This can always be replaced by an explicit decorator call and function reassignment   def decorated function        pass decorated function   some decorator decorated function    However  the latter is less readable and also very hard to understand if multiple decorators are used on a single function  Decorators can be used in multiple different ways as shown below   As a function  There are many ways to write custom decorators  but the simplest way is to write a function that returns a subfunction that wraps the original function call    The generic patterns is as follows   def mydecorator function       def wrapped  args    kwargs             do some stuff before the original           function gets called         result   function  args    kwargs            do some stuff after function call and           return the result         return result       return wrapper as a decorated function     return wrapped   As a class  While decorators almost always can be implemented using functions  there are some situations when using user-defined classes is a better option  This is often true when the decorator needs complex parametrization or it depends on a specific state   The generic pattern for a nonparametrized decorator as a class is as follows   class DecoratorAsClass      def   init   self  function           self function   function      def   call   self   args    kwargs             do some stuff before the original           function gets called         result   self function  args    kwargs            do some stuff after function call and           return the result         return result   Parametrizing decorators  In real code  there is often a need to use decorators that can be parametrized  When the function is used as a decorator  then the solution is simple   a second level of wrapping has to be used  Here is a simple example of the decorator that repeats the execution of a decorated function the specified number of times every time it is called   def repeat number 3      Cause decorated function to be repeated a number of times   Last value of original function call is returned as a result  param number  number of repetitions  3 if not specified     def actual decorator function       def wrapper  args    kwargs           result   None         for   in range number               result   function  args    kwargs          return result     return wrapper return actual decorator   The decorator defined this way can accept parameters    gt  gt  gt   repeat 2      def foo            print  foo        gt  gt  gt  foo   foo foo   Note that even if the parametrized decorator has default values for its arguments  the parentheses after its name is required  The correct way to use the preceding decorator with default arguments is as follows    gt  gt  gt   repeat       def bar            print  bar        gt  gt  gt  bar   bar bar bar   Finally lets see decorators with Properties   Properties  The properties provide a built-in descriptor type that knows how to link an attribute to a set of methods  A property takes four optional arguments  fget   fset   fdel   and doc   The last one can be provided to define a docstring that is linked to the attribute as if it were a method  Here is an example of a Rectangle class that can be controlled either by direct access to attributes that store two corner points or by using the width   and height properties   class Rectangle      def   init   self  x1  y1  x2  y2           self x1  self y1   x1  y1         self x2  self y2   x2  y2      def  width get self           return self x2 - self x1      def  width set self  value           self x2   self x1   value      def  height get self           return self y2 - self y1      def  height set self  value           self y2   self y1   value      width   property           width get   width set          doc  rectangle width measured from left            height   property           height get   height set          doc  rectangle height measured from top             def   repr   self           return                      format              self   class     name                self x1  self y1  self x2  self y2         The best syntax for creating properties is using property as a decorator  This will reduce the number of method signatures inside of the class and make code more readable and maintainable  With decorators the above class becomes   class Rectangle      def   init   self  x1  y1  x2  y2           self x1  self y1   x1  y1         self x2  self y2   x2  y2       property     def width self              rectangle height measured from top            return self x2 - self x1       width setter     def width self  value           self x2   self x1   value       property     def height self              rectangle height measured from top            return self y2 - self y1       height setter     def height self  value           self y2   self y1   value

User · Answer

Example  class Pizza object       def   init   self           self toppings           def   call   self  topping             When using   instance of pizza  before a function definition           the function gets passed onto  topping           self toppings append topping         def   repr   self           return str self toppings   pizza   Pizza     pizza def cheese        return  cheese   pizza def sauce        return  sauce   print pizza     cheese    sauce     This shows that the function method class you re defining after a decorator is just basically passed on as an argument to the function method immediately after the   sign   First sighting  The microframework Flask introduces decorators from the very beginning in the following format   from flask import Flask app   Flask   name      app route      def hello        return  Hello World     This in turn translates to   rule            view func   hello   They go as arguments here in  flask app py  def add url rule self  rule  endpoint None  view func None    options       pass   Realizing this finally allowed me to feel at peace with Flask

User · Answer

An   symbol at the beginning of a line is used for class  function and method decorators  Read more here  PEP 318  Decorators Python Decorators The most common Python decorators you ll run into are   property  classmethod  staticmethod If you see an   in the middle of a line  that s a different thing  matrix multiplication  See this answer showing the use of   as a binary operator

User · Answer

symbol is also used to access variables inside a plydata   pandas dataframe query  pandas DataFrame query  Example   df   pandas DataFrame   foo    1 2 15 17    y   10 df  gt  gt  query  foo  gt   y     plydata df query  foo  gt   y     pandas

User · Answer

Starting with Python 3 5  the     is used as a dedicated infix symbol for MATRIX MULTIPLICATION  PEP 0465 -- see https   www python org dev peps pep-0465

User · Answer

To say what others have in a different way   yes  it is a decorator   In Python  it s like    Creating a function  follows under the   call  Calling another function to operate on your created function   This returns a new function   The function that you call is the argument of the    Replacing the function defined with the new function returned    This can be used for all kinds of useful things  made possible because functions are objects and just necessary just instructions

User · Answer

Python decorator is like a wrapper of a function or a class  It   s still too conceptual  def function decorator func       def wrapped func              Do something before the function is executed         func             Do something after the function has been executed     return wrapped func  The above code is a definition of a decorator that decorates a function  function decorator is the name of the decorator  wrapped func is the name of the inner function  which is actually only used in this decorator definition  func is the function that is being decorated  In the inner function wrapped func  we can do whatever before and after the func is called  After the decorator is defined  we simply use it as follows   function decorator def func        pass  Then  whenever we call the function func  the behaviours we   ve defined in the decorator will also be executed  EXAMPLE   from functools import wraps  def mydecorator f        wraps f      def wrapped  args    kwargs           print  quot Before decorated function quot          r   f  args    kwargs          print  quot After decorated function quot          return r     return wrapped   mydecorator def myfunc myarg       print  quot my function quot   myarg     return  quot return value quot   r   myfunc  asdf   print r  Output       Before decorated function     my function asdf     After decorated function     return value

User · Answer

It indicates that you are using a decorator  Here is Bruce Eckel s example from 2008

[python] What does the "at" (@) symbol do in Python?

Examples related to python

Examples related to syntax

Examples related to python-decorators