Generics templates in python

Question

How does python handle generic template type scenarios   Say I want to create an external file  BinaryTree py  and have it handle binary trees  but for any data type     So I could pass it the type of a custom object and have a binary tree of that object   How is this done in python

User · Answer

If you using Python 2 or want to rewrite java code. Their is not real solution for this. Here is what I get working in a night: https://github.com/FlorianSteenbuck/python-generics I still get no compiler so you currently using it like that:

class A(GenericObject):
    def __init__(self, *args, **kwargs):
        GenericObject.__init__(self, [
            ['b',extends,int],
            ['a',extends,str],
            [0,extends,bool],
            ['T',extends,float]
        ], *args, **kwargs)

    def _init(self, c, a, b):
        print "success c="+str(c)+" a="+str(a)+" b="+str(b)

TODOs

Compiler
Get Generic Classes and Types working (For things like <? extends List<Number>>)
Add super support
Add ? support
Code Clean Up

User · Answer

Actually now you can use generics in Python 3 5   See PEP-484 and typing module documentation  According to my practice it is not very seamless and clear especially for those who are familiar with Java Generics  but still usable

User · Answer

Look at how the built-in containers do it   dict and list and so on contain heterogeneous elements of whatever types you like   If you define  say  an insert val  function for your tree  it will at some point do something like node value   val and Python will take care of the rest

User · Answer

The other answers are totally fine   One does not need a special syntax to support generics in Python Python uses duck typing as pointed out by Andr     However  if you still want a typed variant  there is a built-in solution since Python 3 5  Generic classes  from typing import TypeVar  Generic  T   TypeVar  T    class Stack Generic T        def   init   self  - gt  None            Create an empty list with items of type T         self items  List T            def push self  item  T  - gt  None          self items append item       def pop self  - gt  T          return self items pop        def empty self  - gt  bool          return not self items    Construct an empty Stack int  instance stack   Stack int    stack push 2  stack pop   stack push  x            Type error  Generic functions  from typing import TypeVar  Sequence  T   TypeVar  T          Declare type variable  def first seq  Sequence T   - gt  T      return seq 0   def last seq  Sequence T   - gt  T      return seq -1    n   first  1  2  3      n has type int   Reference  mypy documentation about generics

User · Answer

After coming up with some good thoughts on making generic types in python  I started looking for others who had the same idea  but I couldn t find any   So  here it is   I tried this out and it works well   It allows us to parameterize our types in python    class List  type         def   new   type ref  member type            class List list                def append self  member                   if not isinstance member  member type                       raise TypeError  Attempted to append a   0   to a   1   which only takes a   2    format                          type member    name                            type self    name                            member type   name                                                list append self  member           return List    You can now derive types from this generic type   class TestMember          pass  class TestList List TestMember         def   init   self           super     init       test list   TestList   test list append TestMember    test list append  test     This line will raise an exception   This solution is simplistic  and it does have it s limitations   Each time you create a generic type  it will create a new type   Thus  multiple classes inheriting List  str   as a parent would be inheriting from two separate classes   To overcome this  you need to create a dict to store the various forms of the inner class and return the previous created inner class  rather than creating a new one   This would prevent duplicate types with the same parameters from being created   If interested  a more elegant solution can be made with decorators and or metaclasses

User · Answer

Fortunately there has been some efforts for the generic programming in python    There is a library   generic  Here is the documentation for it  http   generic readthedocs org en latest   It hasn t progress over years   but you can have a rough idea how to use  amp  make your own library   Cheers

User · Answer

Python uses duck typing  so it doesn t need special syntax to handle multiple types   If you re from a C   background  you ll remember that  as long as the operations used in the template function class are defined on some type T  at the syntax level   you can use that type T in the template   So  basically  it works the same way    define a contract for the type of items you want to insert in the binary tree  document this contract  i e  in the class documentation  implement the binary tree using only operations specified in the contract enjoy   You ll note however  that unless you write explicit type checking  which is usually discouraged   you won t be able to enforce that a binary tree contains only elements of the chosen type

User · Answer

Here s a variant of this answer that uses metaclasses to avoid the messy syntax  and use the typing-style List int  syntax   class template type       def   new   metacls  f           cls   type   new   metacls  f   name                        f   f                 qualname     f   qualname                   module     f   module                   doc     f   doc                      cls   instances              return cls      def   init   cls  f      only needed in 3 5 and below         pass      def   getitem   cls  item           if not isinstance item  tuple               item    item           try              return cls   instances item          except KeyError              cls   instances item    c   cls  f  item              item repr              join repr i  for i in item                    c   name     cls   name     item repr             c   qualname     cls   qualname     item repr             c   template     cls             return c      def   subclasscheck   cls  subclass           for c in subclass mro                if getattr c     template     None     cls                  return True         return False      def   instancecheck   cls  instance           return cls   subclasscheck   type instance        def   repr   cls           import inspect         return   lt template   r  gt   format             format              cls   module    cls   qualname    str inspect signature cls  f   1 -1               With this new metaclass  we can rewrite the example in the answer I link to as    template def List member type       class List list           def append self  member               if not isinstance member  member type                   raise TypeError  Attempted to append a   0   to a   1   which only takes a   2    format                      type member    name                        type self    name                        member type   name                                        list append self  member      return List  l   List int    l append 1     ok l append  one      error   This approach has some nice benefits  print List      lt template    main   List member type   gt  print List int       lt class    main   List  lt class  int  gt   10   gt  assert List int  is List int  assert issubclass List int   List     True

User · Answer

Since python is dynamically typed  this is super easy   In fact  you d have to do extra work for your BinaryTree class not to work with any data type     For example  if you want the key values which are used to place the object in the tree available within the object from a method like key   you just call key   on the objects   For example   class BinaryTree object        def insert self  object to insert           key   object to insert key     Note that you never need to define what kind of class object to insert is   So long as it has a key   method  it will work   The exception is if you want it to work with basic data types like strings or integers   You ll have to wrap them in a class to get them to work with your generic BinaryTree   If that sounds too heavy weight and you want the extra efficiency of actually just storing strings  sorry  that s not what Python is good at

User · Answer

Because Python is dynamically typed  the types of the objects don t matter in many cases  It s a better idea to accept anything   To demonstrate what I mean  this tree class will accept anything for its two branches   class BinaryTree      def   init   self  left  right           self left  self right   left  right   And it could be used like this   branch1   BinaryTree 1 2  myitem   MyClass   branch2   BinaryTree myitem  None  tree   BinaryTree branch1  branch2

[python] Generics/templates in python?

Examples related to python

Examples related to templates

Examples related to generic-programming