Forem: aabidsofi19

Python Anti-pattern you should avoid .

aabidsofi19 — Sun, 24 Jul 2022 12:59:19 +0000

Python Antipattern : Impure(IO) Default Arguments

One of most liked features of python functions is default arguments . We use them
every day . But there is gotcha that you need to take care .

Function default arguments are evaluated at module load time rather than function invocation time .
Which helps with perfomance benefits when the default arguments are static and deterministic .

So if your function is non-deterministic or has side-effects, you could run into trouble.
As the example shows, the printed time is frozen; it was set once when the code was first evaluated.


# Antitpattern and  buggy
def current_datetime(dt = datetime.datetime.now()):
    print(dt)

>>> current_datetime()
2021-10-09 16:09:43.009959
>>> current_datetime()
2021-10-09 16:09:43.009959

# do this instead 

def current_datetime(dt=None) :
  if dt is None :
    dt = datetime.datetime.now()
  print(dt)

current_datetime()
>> 2022-07-24 16:07:16.435203
current_datetime()
>> 2022-07-24 16:08:16.635203

Books to Advance Your Python Skills

aabidsofi19 — Sat, 18 Jun 2022 06:52:54 +0000

If you have stumbled to this post .. I can bet you love python ... And when you love
something you should take care of it . in this small blog post i have compiled a
list of books that have helped me become a better python programmer .

Note : The list is not in any particular order and there are no affliate links
either :) .

We all agree with the fact that python is an easy to learn language . But the
best thing that I have noticed while coding in python is how well it does a job
of hiding the unnecessary abstraction yet providing the programmer with the
most control .

In this section I have listed the books that will help you better understand
python . Which will help you to make better decisions next time working on something
whether it is which datastructure should I use or in which way the code will be
more maintainable ..

Lets dive in :

1. Fluent Python - by Luciano Ramalho .

If you want to become more productive with python and you can choose
only one book .. This is it .

Written by Luciano Ramalho . This book will open the multiverse of python for
you .

I bet on this that you will get an Aha .. moment reading every single page of
it .. summing in its own title it will make you fluent in python . and will
help you make smarter decisions next time you are writing python.

It is nicely structured , starting with easier to get topics and progressively
going to more advanced topics like metaprogramming and concurrency .

Who it is not for :

If are a programmer who has just started with python . This book won't serve the
purpose best and will just make the journey a little harder .

2. Programming Python -by Mark Lutz .

Another Gem . This book serves a an indepth guide to python and how to use it
for different usecases. Rather than being a book only about the language
sematics this book does a good job at making usecases of python sound and clear
.

This book is divided into sections like Introduction to python , Gui
Programming , Web Programming ,etc .

I love this book mostly because it has helped me to understand the vastness of
the python ecosystem . And giving an eagles eye view of different domains with python.

3. Python Cookbook

This book has a recipe for everything python . David Beazley is a well renowed
name in the python community . And Python Cookbook is his masterpiece.

This is not a book of tricks but a guide to solve problem in pythonic manner .
David does a good job of not only explaining the solution but also having a
openended discussion about the drawbacks and edgecases ..

I have already read it 2 -3 times yet and continuoly look for day to day python
problems in it .. I never upsets :)

4. Robust Python

Writing code at industry level scale is no fun and games . Your code is going
to get changed and bashed a lot and surely is not immune to bugs .
And nothing can stop it .

Writing clean code and refactoring is one the most important skills to write
scalable and better .

This book just helps you to write better python . This book also throws light
at the modern python features and best practices.

Recommended for everyone who wants to write more maintainable code and survive
the software onslaught .

Thats it .. there are a lot of other good books also but I personally think these are the
best in the business . comment down which books you are going to read and
which have helped you in past . :)

How and when to use slots in python

aabidsofi19 — Thu, 05 May 2022 05:33:18 +0000

Each python object has a _dict_ attribute which is a dictionary containing
all other attributes. E.g. when you type self.attr python is actually doing
self.dict['attr'].

As you can imagine using a dictionary to store attribute takes some extra space
& time for accessing it.

What if you already knew which attributes your class is going to have . Then
using _dict_ to store attributes doesn't seem to be a good idea as we don't
need the dynamic nature of dicts .

This is where slots come to rescue .

What are slots in python

_slots_ is a class variable which allows us declare the attributes of a
class explicitly and denying the creation of _dict_ and
_weakref_ for object instances .

The expected attributes can be assigned to _slots_ as a string, iterable,
or sequence of strings with variable names used by instance .

Space saved by not having a _dict_ can be significant . Slots also
improve the attribute lookup speed .

Usage of slots

Python utilises a considerably more compact internal representation for
instances when you define _slots_. Instead of a dictionary, each instance
is created around a small fixed-sized array, similar to a tuple or list.

As a result of using slots, you can no longer add new attributes to
instances;
you are limited to the attribute names given in the _slots_ specifier.( You
can get around this by adding _dict_ to the _slot_ . The dict will only
initialized when a dynamic attribute is added ) .

Example showing usage of slots :


# A email class with out using slots

class Email :
  def __init__(self,subject,to,message) :
    self.subject = subject
    self.message = message
    self.to = to


class EmailWithSlots :

  __slots__ = ('subject','to','message')

  def __init__(self,subject,to,message) :
    self.subject = subject
    self.message = message
    self.to = to


email = EmailWithSlots('test','me@gmail.com','testing slots')

email.subject
# >> test

email.__dict__  # cant access __dict__ because its not created


# AttributeError                            Traceback (most recent call last)
# <ipython-input-40-b95667a7fb92> in <module>
#  ----> 1 email.__dict__
#
#AttributeError: 'EmailWithSlots' object has no attribute '__dict__'

email.from = "aabid@gmail.com" # cant add an atribute that not in __slots__

# ---------------------------------------------------------------------------
# AttributeError                            Traceback (most recent call last)
# <ipython-input-42-87651e4df821> in <module>
# ----> email.from = "aabid@gmail.com"
#
#AttributeError: 'EmailWithSlots' object has no attribute 'from'

Pros And Cons of slots

Pros

using _slots_ has faster attribute access .
_slots_ reduces memory usage

Cons

Fixed attributes ( You can get around this by adding _dict_ to the _slots_ . The dict will only initialized when a dynamic attribute is added )
_slots_ are implemented at the class level by creating descriptors for each variable name. As a result, class attributes cannot be used to set default values for instance variables defined by _slots_; otherwise, the class attribute would overwrite the descriptor assignment.

Inheritance with slots .

Working with slots and Inheritance is a little tricky and need to be taken care
of . Here is How :

The _slots_ defined on parent class are automatically accessible to the child .

   class BaseClass :
       __slots__ = ['x','y','z']


   class Inherited(BaseClass) :
        pass


   Inherited.__slots__

   #>> ['x', 'y', 'z']

If the subclass doesn't specify slots ( empty or new ) . The subclass will get _dict_ and _weakref_ attributes in addition to slots from parent

   class BaseClass :
       __slots__ = ['x','y','z']


   class Inherited(BaseClass) :
        pass

   class InheritedWithSlots(BaseClass) :
      __slots__ = ()

   Inherited.__slots__
   #>> ['x', 'y', 'z']

   Inherited.__dict__
   #>> {}

   InheritedWithSlots().__dict__
   # AttributeError

Nonempty _slots_ does not work for classes derived from “variable-length” built-in types such as int, bytes and tuple.


# this works fine because we are not using any additional slots in subclass
class MyInt(int):
    __slots__ = ()

# This will panic because we are adding non-empty slots .
class NewInt(int) :
    __slots__ = (x,y)

#TypeError: nonempty __slots__ not supported for subtype of 'int'

You can also use multiple inheritance with slots . But only one parent can
have non empty _slots_. Otherwise a typeerror is raised .


#lets have three slotted base classes

class foo:
  __slots__ = ("x","y")

class bar :
  __slots__ = ("a","b")

class baz :
   __slots__=()

# this will raise TypeError as we are inheriting from two classes
# with nonempty slots
class foobar(foo,bar) :
  pass

#>>TypeError: multiple bases have instance lay-out conflict

# This shall work as only one of the inherited class has nonempty slots

class FooBaz(foo,bar) :
  pass

Conclusion :

_slots_ allow us to explicitly state which instance variables to expect in
the object

Which gives us following benefits

Faster Attribute Access
Saves Memory

A typical use case

For classes that primarily serve as simple data structures, you can often greatly reduce
the memory footprint of instances by adding the _slots_ attribute to the
class definition.

When slots is a bad idea .

Avoid them when you want to perform _class_ assignment with another class that doesn't have them (and you can't add them) unless the slot layouts are identical. (I am very interested in learning who is doing this and why.)
Avoid them if you want to subclass variable length builtins like long, tuple, or str, and you want to add attributes to them.
Avoid them if you insist on providing default values via class attributes for instance variables.

Thanks , for reading till end Happy coding ..

Tips for Writing Fast and Idiomatic Python

aabidsofi19 — Sat, 23 Apr 2022 06:30:22 +0000

Orignally posted at https://www.aabidsofi.com/posts/tips-for-writing-fast-and-idiomatic-python/

"Python tricks" is a tough one, cuz the language is so clean.
E.g., C makes an art of confusing pointers with arrays and strings, which leads
to lotsa neat pointer tricks; APL mistakes everything for an array, leading to
neat one-liners; and Perl confuses everything period, making each line a joyous adventure ;-)

Tim Peters

Python is praised for its readability. This makes it a good first language, and
a popular choice for scripting and prototyping.

In this post, we will look at some techniques that will make your Python
code more readable and idiomatic. I am no mere an expert in python , these tips
have helped me a lot in writing good python and I hope these will help you also
in the same . If you have any more ideas , we would love to discuss them in
comment section below ..

Tip 1. When there is recurring setup and tear down you should use a Context Manager so that you can use with statement

Whenever working with external resources like files and database which involves
setup of resource , checking for any exceptions and then finally closing the
resource (tear down ) , rather than using the naive the naive approach of use try
, except and finally pattern use Context Managers .

Most times when your are working databases , locks and files the standard
library provides the context managers which can be used through the with
statement . Lets take the trivial example of reading from a file


# non pythonic way

try :
  file  = open("text.txt")
  lines = files.readlines()
except Exception as e:
  print(e)
finally :
  file.close()


# pythonic way much concise, and less bug prone

with open('text.txt') as f :
    f.readlines()

As you can see we no longer need to setup the file and close it . This way is
not only short but also conveys the business logic properly. We don't have
to do the setup and tear down ourselves which makes the code less error prone

The Session class of the request module implements the enter and exit
methods and can be used as a context manager when you need to preserve cookies
between requests, want to make multiple requests to the same host or just want
to keep TCP connection alive.


import requests
  with requests.Session() as sess:
     sess.request(method=method, url=url)

Tip 2. Stop adding strings manually use str.join instead .

String objects are immutable in python and any concatenation operation creates a
new string, copies the old string character by character and then appends the
new string to be concatenated.

Lets suppose we have a list of names that we need to concatenate into a single string
separated by commas.

The naive approach for doing this is :


names = ["aabid","john","doe","mathew"]
new_string=""

for name in names :

   new_string.append(name+",")

While this approach seems to be pretty straightforward . But as I told you above
that strings being immutable in python the above algorithm has a quadratic
runtime which will create problems if the length of names becomes large.

But don't worry there is a better , easier , and more pythonic way to achieve
this with a linear runtime and that is the str.join() .

str.join() takes an iterable as an argument and returns a string which is a
concatenation of all the string objects in the iterable.


names = ["aabid","john","doe","mathew"]

new_string = ",".join(names)

Tip 3. Take advantage of magic methods ( dunder methods ) to your best

If you have used Classes in python . You would have also used the
init() method to initialize the class state which is a dunder or magic
method . magic methods have a double underscore as prefix as suffix thats why
they are also called dunder methods

Python uses the word "magic methods", because those methods really performs magic for you program. One of the biggest advantages of using Python's magic methods is that they provide a simple way to make objects behave like built-in types. That means you can avoid ugly, counter-intuitive, and nonstandard ways of performing basic operators.

Lets suppose we have a class Stack ( which implements the Stack LIFO
datastructure ) and we want ours know the number of items in the stack or
length . If you are coming from java or any other language . I might think
of adding getLength() method to achieve the same .


class Stack :

    # basic  implementation
    ...

    def getLength(self) :
        pass

The implementation is quite simple but our users need to remember the
getLength function .

There is a more pythonic way of getting the length of sequences and you know
its len() . To implement the len() method for our class we will use the
dunder len() method . remember that dunder methods should not be called
directly from code but the interpreter calls them underneath . in this the
builtin len() .


class Stack :

    # basic implementation

    ...

    def __len__(self) :

        return len(self.items)

foo = Stack()

# now we can use len to check the no of items in Stack foo

length = len(foo)

Tip 4. Don't Create getters and setters use @property decorator

Suppose you have a class Book which has fields author and name. You want the
field to be read only so that your users will not change the author of a book .

One way to do this by storing the author in a private variable and defining a
method getAuthor() to retrieve it .


# non pythonic

class Book :
    def __init__(self,name,author):
        self.name = name
        self.__author = author

    def getAuthor(self) :
        return self.__author


book1 = Book("Clean Code" , "Uncle Bob" )

book.getAuthor()

# >> Uncle Bob

While the above works completely fine . But there is a better way , using the
@property decorator.

Python provides us with a built-in @property decorator which makes usage of
getter and setters much easier in Object-Oriented Programming.

By default methods decorated with @property are read only can be accessed with
using the object.property notation


# pythonic way using @property decorators

class Book :
    def __init__(self,name,author):
        self.name = name
        self.__author = author

    @property
    def author(self) :
        return self.__author


book1 = Book("Clean Code" , "Uncle Bob" )

print(book.author)

# >> Uncle Bob

This doesn't end here , what if the requirements change in future and your are
allowed to mutate the author only if its the name starts with a "S" ( sounds
silly but makes a good example )

The non pythonic approach would be to create a setAuthor() method and validate
the input in it. But there is a better approach in python and thats the
property.setter decorator . which allows you to mutate a property .


class Book :
    def __init__(self,name,author):
        self.name = name
        self.__author = author

    @property
    def author(self) :
        return self.__author

    @author.setter
    def author(self,value):
        # business logic
        ....

book1 = Book("Clean Code" , "Sebastian" )

book.author

# >> Sebastian

book.author = Seb

Tip 5. Use repr for beautiful debugging experience

According to the official documentation, repr is used to compute the
“official” string representation of an object and is typically used for
debugging.

Lets create a person class and define a repr method for it which will return
a string representation for the object .Ideally, the representation should be
information-rich and could be used to recreate an object with the same value.


class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        rep = f'Person( "{self.name}" , {self.age}  )'
        return rep


# Let's make a Person object and print the results of repr()

person = Person("John", 20)
print(person)

#>>  Person("John", 20 )

Tip 6. Use Custom Exceptions properly

Creating custom exception in python is pretty easy . But that doesn't mean you
should be creating them everywhere.

Only Create a custom exception when you have a complex error . Like
suppose you have a cart object which a checkout method. You don't want the
checkout to work if the cart is empty so , creating a Exception CartEmpty makes
a sense here .

Don't suffix the exception name with Exception . I have seen a lot of people (
including me ) naming their exceptions like CartEmptyException . This
doesn't make any sense . Keep it simple CartEmpty .

You don't need a custom exception every time . There are about 137 exceptions in
python . Take advantage of these .

Tip 7. Don't fear using built ins

Python is a powerful programming language with many built-in features that allow you to do more with less code. For example, the range() function allows you to create a list of numbers easily, and the len() function returns the length of a string or list.

In addition, Python has a number of libraries that you can use to simplify tasks such as data analysis and machine learning. The SciPy library, for example, provides modules for linear algebra, optimization, integration, and more.

Python also has a rich collection of complex datastructures like heap , priory
queues , dequeue , queue , orderedDict , and many more . Rather than reinventing
the wheel try to take advantage of these . These are way more optimized and fast
than you would create yourself

Tip 8. Use Comprehensions in place of loops .

List comprehensions are a Pythonic way to create lists. They are more concise
and readable than for loops, which is why they should be used in place of native
for loops.

The syntax for list comprehensions is:

[ expression for item in sequence if condition ]

Here is an example of a list comprehension that creates the list of even numbers between 0 and 10:


  [ x for x in range(10) if x%2==0]

Tip 9. Use multiple variable assignment any unpacking

Pythons multiple assignment feature is a nice perk that most programming languages lack. In its simplest form, it looks like this:


a = b = "something"

This is nice because it shortens and simplifies code. However, I rarely get to use it. A more practical option is unpacking iterables into multiple variables:

some_list = ["value1", "value2"]
first, second = some_list

This is a better option than assigning values to each variable using indices

Another important use-case of multiple variable assignment is swapping variables
without using a temporary variable .

# swapping a variable using a temporary  variable

x= 10
y =20

temp = x
x= y
y=temp

print(x)
# >> 20

print(y)
# >>10


# swapping variables using multiple assignment

x,y = 10,20

x,y = y,x

This solution is way more concise and easy to understand

Thanks for reading till end . I would love to hear about the tips and hacks
you use to improve your code .

Best Opensource HTML / Vue Template for Developer Portfolio

aabidsofi19 — Fri, 01 Oct 2021 08:32:58 +0000

Minimal and Modern theme for Portfolios . Created using vuejs and vuetify . The template is completely free , opensource .

Give it a star 🌟 on Github if you find it useful.

GitHub Repo https://github.com/aabidsofi19/neva-portfolio-template

Check out the live demo https://neva-portfolio-vue.netlify.app

Link to docs https://www.aabidsofi.com/docs/neva-portfolio-vue/

The template is best fit for developers and designers wanting to showcase their portfolio to the mighty web audience

Fully Responsive on Mobile Devices

The template has been crafted with love using Vuejs, Vuex, and Vuetify.
The template follows a component-based design so, is easy to customize for both developers and people not familiar with code.

The template has been specially crafted to be simple to customize for people not familiar with code.

The installation process is pretty simple and won’t take more than 10 minutes. So let’s begin.

Hav’nt installed the template yet,clone the repo now.

The template has been licensed under the MIT license. Which means you are not bound for any type of credit. But surely giving one in your footer will be helpful and appreciated a lot.

Star the repo on Github and follow me. It means a lot ❤️.