DEV Community: Cheruto

Python For Everyone: Mastering Python The Right Way

Cheruto — Fri, 04 Mar 2022 15:13:27 +0000

I have recently been reading 'Atomic Habits' by James Clear. In the book, James has a captivating style of breaking down the formation of Habits. One particular example is how if we constantly improve our habits by 0.1% daily, in a year we will be 37 times better at the skill.
That is just by merely improving 0.1%, what about 1% 10% 50%; the possibilities are limitless.
This very similar to Mastery of anything and in our case, Mastery of Python. We can only get better if we aim to practice and improve daily even if it's just by 0.1% #NoZeroDays. In this article, I will recommend a few resources that may be helpful in achieving this mastery.

The Zen Of Python

We can not truly become masters at Python without viewing the Zen of Python. Type import this on your command line and run it.

>>> import this
'''
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
'''

This Zen will give the basic guiding rules for learning and even mastering Python.
No matter what Python Path you intend to pursue, mastery of the basic concepts will be very vital to help you build a strong foundation in Python and allow you to code The Pythonic Way.

Dear Python Sensei, Here are a few tips to kickstart your journey:

Set Your Goals

Setting goals is effective in helping us accomplish a lot. Before beginning your journey, determine what you hope to accomplish. Are you working towards Web Development, focus on learning Frameworks eg. Django. If it is in Data Analysis mastery of libraries such as Pandas, numpy etc. will be instrumental.
Recursively breaking down your goals to Monthly, weekly chunks is also very important. In something as basic as a coding session, write down what you hope to achieve within the coding session. A SMART goal is Specific, Measurable, Achievable, Realistic and within a TimeFrame eg. make a number guessing game, with concepts learnt, within my first 4 weeks.

Resources For Setting Goals:

Pen and Paper - Write down your goals
Pomodoro Timers: Time-blocking and Focus Mode helps block out chunks of time interspersed with rest to focus on the matter at hand, that is coding.
Version control Systems eg. Github, Bitbucket, Gitbucket help in version control of your code and generally storage of your code. It can also serve as a visual reminder of the progress you make eg. on Github there is a monitoring system that shows how many days you are active on the platform.

Finding A Community

Sticking to a habit is not solely based on 'Motivation' alone; some days you just don't feel like it. A community/accountability partner will be paramount in keeping you in check and challenging you to be better.
Such communities can be on social media platforms eg. r/python and r/learnpython, these platforms have a lot of people looking to learn python like you.
Tags like #100DaysOfCode on Twitter and other platforms allow different programmers to share their progress journeys during the sacred 100 days of code.

Stick To A Few Beneficial Resources

The internet has been very revolutionary in every sense. In terms of learning it has granted us access to a ton of resources at our fingertips. I can literally just type 'Harvard Python Course' and get access to the CS50 course on edx.
All these resources can suck as into a 'Learning rabbit hole'. Jumping from one exciting resource to another. My advice; Set and focus on your goal, identify a suitable course that helps you in the pursuit of your goal. Break the course down to manageable chunks and follow through with it.

Pro Tip: Select a well structured course like those on Free Code Camp. A well-structured course saves on time and resources otherwise wasted scouring the internet.

You don't have to finish the course, just stick with it until you've achieved your goal.
Take Notes: > I hear and I forget. I see and I remember. I do and I understand. During a lesson write down short keywords. After the lesson try and recall what you learnt during lesson. If you are not a fan of writing down on paper(which I strongly root for), use Notion, a very easy, convenient and resourceful note-taking application.

The Last and Ultimate Python Secret!!

CODE!!

Even if you follow tutorials and code as the instructor goes through the concept, you still have to put in the hours. Start with as little time as you like and work your way up. Constant Coding and dedication is the biggest difference between a Beginner and Master.
I appreciate that you are still reading this article, but after quickly liking this article, please click on some of the resources I have shared- the resources are all free to use and will be of great help to you.
Don't be scared of bugs or being stuck on a problem. The world has millions of developers, your problem isn't as bad as it seems just google it. Platforms like Stack Overflow exist for this sole purpose. In this Journey, Google Is Your Best Friend

Day 1 of Coding
Creating a Hello World Program

Download Python
Open your command line. Use the (Win + R) shortcut. Write cmd and press enter.
On the command line, switch to the python terminal by typing py C:\Users\user>py
On the Python terminal, print Hello World

>>> print("Hello World!!")
Hello World!!

You are now ready for the greatness.

Install your Favourite Text Editor. Here are a few examples: Visual Studio, Atom, SublimeText.

Concepts To Learn at Every Stage from Basic to Advanced

Basic
Most of them are in My First article ever

Intermediate

Comprehensions
Data Structures
Lambda Functions
Files I/0
Inheritance and OOP
Dunder Methods

Advanced
1.Frameworks(Django, Flask, etc.)
2.Decorators and Generators
3.Multithreading and Processing
4.Testing
5.Complex Libraries

Looking Forward To Hearing from You. If you are a more experienced programmer, please leave some of your tips and tricks with us on the comment section.
Looking Forward to hearing Your Thoughts.

Introduction to Data Structures

Cheruto — Sun, 20 Feb 2022 19:58:35 +0000

A Data Structure is a special format of organizing, processing, retrieving and storing data. They may not be discussed mainly but they are very vital in our systems today.
Today we will focus on the basic data structures that are our unsung heroes of our systems today. Here is a link to an article that has more general information on What are Data Structures

1. Lists

Lists contain multiple values in an ordered sequence. Values inside the lists are called items and are comma-separated.. - - The lists are zero-indexed hence the first value in a list is usually at index O. Indices are used for item retrieval.
When a list is created all the elements are stored contiguously in memory(the memory allocated for a list is within the same location)

>>> pets = ["cats","dogs","rabbit","parrot"]
>>> pets[0]
'cats'
>>> pets[-1]
'parrot'
>>> pets[1:3]
['dogs', 'rabbit']
>>> pets[:3]
['cats', 'dogs', 'rabbit']
>>> pets[2:]
['rabbit', 'parrot']

List Methods

Append - this method adds an item to the end of the list
Insert - inserts an item at a particular index
Delete - deletes an item at a particular index
Remove - deletes the item passed

If there are 2 or more instances of the same item, the first instance is usually deleted
Sorting - ordering of items in a list
Lists are sorted according in ascending order
Alphabetical lists are sorted in "ASCIIbetical Order", that is uppercase letters then lowercase letters later
Lists with multiple data types cannot be sorted
The reverse() method orders the items in the list in descending order

>>> pets.append("monkey")
>>> pets
['cats', 'dogs', 'rabbit', 'parrot', 'monkey']
>>> pets.insert(1,"hamster")
>>> pets
['cats', 'hamster', 'dogs', 'rabbit', 'parrot', 'monkey']

>>> del pets[0]
>>> pets
['hamster', 'dogs', 'rabbit', 'parrot', 'monkey']
>>> pets.remove("dogs")
>>> pets
['hamster', 'rabbit', 'parrot', 'monkey']

>>> pets.sort()
>>> pets
['hamster', 'monkey', 'parrot', 'rabbit']
>>> pets.reverse()
>>> pets
['rabbit', 'parrot', 'monkey', 'hamster']

2.Tuples

They are very similar to lists but are immutable(hence we cannot add, remove or change them in any way). This can be advantageous as python is able to run them faster than lists.
They are formed using ( )
I higlighted, key differences between lists and tuples in my previous blog post.

pets = ('rabbit', 'parrot', 'monkey', 'hamster')
>>> pets[0]
'rabbit'

>>> pets.add('cats')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'add'

>>> del pets[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

#it can also be defined with a comma after the last item to explicitly declare them as tuples
>>> pets = ('rabbit', 'parrot', 'monkey', 'hamster',)
>>> type(pets)
<class 'tuple'>

3. Dictionaries

They are unordered data structures that store items in (Key:Value) pairs. They are defined using { } or using the **dict() **constructor.

>>> pets_colour = {'cat':'white','horse':'dark','dog':'golden'}
>>> pets_colour(cat)
>>> myfriends_age = {'Chao':21,'Too':19,'Rono':40,'Juma':32}
>>> myfriends_age
{'Chao': 21, 'Too': 19, 'Rono': 40, 'Juma': 32}

Dictionary Methods

These methods can be used in for loops to retrieve the specified elements.
dictionaryName.keys() - is used to retrieve the keys used in the dictionary
dictionaryName.values() - is used to retrieve the values used in the dictionary
dictionaryName.items() - is used to retrieve both the values and keys in the dictionary

myfriends_age = {'Chao':21,'Too':19,'Rono':40,'Juma':32}

>>> for age in myfriends_age.values():
...     print(age)
...
21
19
40
32


>>> for name in myfriends_age.keys():
...     print (name)
...
Chao
Too
Rono
Juma


>>> for name,age in myfriends_age.items():
...     print(f"{name} is {age} years old")
...
Chao is 21 years old
Too is 19 years old
Rono is 40 years old
Juma is 32 years old

4. Sets

They are unordered(they can be saved and retrieved in whatever order and cannot be referenced by an id or key) collection of items, unchangeable and only allow unique items(hence no repetition of values).
To create a new set, we use the set() constructor, the curly braces { } are too ambiguous and may create a dictionary instead

#creating a set using curly braces { }
odd_numbers = {1, 3, 5, 7, 9}
#check set membership
9 in odd_numbers
#results in True

#creating a set using a set constructor
>>> odd_numbers = set((1,3,5,7,9))
>>> odd_numbers
{1, 3, 5, 7, 9}

#inserting elements into the set
>>> odd_numbers.add(11)
>>> odd_numbers  
{1, 3, 5, 7, 9, 11}      

#adding a duplicate value does not change the set
odd_numbers.add(3)
odd_numbers
 {1, 3, 5, 7, 9, 11}    

#length of the set
len(odd_numbers)
6

#Removing an item
>>> odd_numbers.remove(5)
>>> odd_numbers
{1, 3, 7, 9}
>>> odd_numbers.discard(7)
>>> odd_numbers
{1, 3, 9}
>>> odd_numbers.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 5
>>> odd_numbers.discard(5)
>>> odd_numbers
{1, 3, 7, 9}

#delete entire set
del odd_numbers

Frozen Sets are immutable versions of sets. We can not insert or delete from them but rather query them.

>>> odd_numbers = frozenset({1, 3, 5, 7, 9, 11}) 
>>> odd_numbers.add(13)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

These frozensets are hashable and can be used as dictionary keys.

>>> odd_numbers ={ frozenset({1, 3, 5, 7, 9, 11}):"These are Odd Numbers"}
>>> odd_numbers[frozenset({1, 3, 5, 7, 9, 11})]
'These are Odd Numbers'

5. Queues

Queues function just like real-life queues observing the FIFO(First In First Out) principle. Items enqueued into the queue first are usually *dequeued * first.
They are implemented using either lists(they can be quite slow) or inbuilt Queue module(especially used with parallel programming due to the resource locks) or the deque module from collections(for general use)

#Using Lists
>>> my_queue = []
>>> my_queue.append(1)
>>> my_queue.append(2)
>>> my_queue.append(3)
>>> my_queue
[1, 2, 3]
>>> my_queue.pop(0)#pop at index 0
1
>>> my_queue
[2, 3]

#using the queue module
>>> from queue import Queue  
>>> my_queue = Queue()
# We use .put() to insert value and .get() to pop the first one.
>>> my_queue = Queue()
>>> my_queue.put(1)
>>> my_queue.put(2)
>>> my_queue.put(3)
>>> print(list(my_queue.queue))
[1, 2, 3]
>>> my_queue.get()
1
>>> print(list(my_queue.queue))
[2, 3]

#Using collections.deque
>>> from collections import deque
>>> my_queue = deque()
>>> my_queue.append("Me")
>>> my_queue.append("Myself")
>>> my_queue.append("I")
>>> my_queue
deque(['Me', 'Myself', 'I'])
>>> my_queue.popleft()
'Me'
>>> my_queue
deque(['Myself', 'I'])

6. Stacks

They are data structures that implement the LIFO(Last In First Out) principle of accessing, inserting or deleting items. Items are *push*ed (inserted into the stack) and *pop*ped(removed from the stack) at the top of the stack (hence does not allow random retrieval like arrays and lists)
They can be implemented using Lists or deque module from collections

>>> my_stack = []
>>> my_stack.append("I")
>>> my_stack.append("love")
>>> my_stack.append("Python")
>>> my_stack
['I', 'love', 'Python']
>>> my_stack.pop()
'Python'
>>> my_stack
['I', 'love']


#using deque
>>> from collections import deque
>>> my_stack = deque()
>>> my_stack.append("I")
>>> my_stack.append("love")
>>> my_stack.append("Python")
>>> my_stack
deque(['I', 'love', 'Python'])
>>> my_stack.pop()
'Python'

7. Linked Lists

** Whew! This is a whole topic but I'll skim over the basics here.

Linked lists is a data structure that contains a chain of nodes in different parts of memory that are linked to each other.
There are different types of linked lists(singly and doubly). Singly linked lists can be traversed in only one direction - left to right while doubly linked lists can be traversed left to right and right to left.
Each node contains its own data value and a memory address that references to the memory location of the next node.

Creating a Node - create a node class with the data and next variables.

>>> class Node:
...   # constructor
...   def __init__(self, data, next=None):
...     self.data = data
...     self.next = next
...
>>> # Create a single node
>>> first = Node(3)
>>> print(first.data)
3

Create a Linked List

The first element in the Linked List is the head of the list.

class LinkedList():
    def __init__(self):
        self.head = None

Linking nodes within the list

new_node = Node(data)
head.next = new_node

There is a lot to cover within Linked Lists, I won't cover majority of it here since this post is getting too long.

Data structures are very vital and if you want to work in FAANG companies, mastery of this structures will come in handy.
This is just the tip of the iceberg. Advanced structures like graphs in Dijkstra's Algorithm are used in Google Maps for distance estimations.
A very important part of data structures is their Memory and Time Complexities. These complexities dictate the advantage of one structure over another for different use cases.

In the meantime, let me know in the comments section where the data structures above can be fundamental.

Introduction to Modern Python

Cheruto — Mon, 14 Feb 2022 10:35:29 +0000

Introduction

You most probably know why and are now scouring the internet for Zen advice on how to go about the language. Well, Same here.
We will discuss the absolute basics and I will link some resources(and cheatsheets) that will be be helpful in learning the Language. I will discuss Primitive Data Types, Math Operands and inbuilt data Structures.

Data Types

1. Strings

Strings are usually alphanumeric characters enclosed in "" or ' '. They can be manipulated in a variety of ways through: Concatenation, Replication, Slicing and a variety of other methods(convert to upper, lower and replacing or iterating through the characters)

x = 'Python'
y = 'Developer'
#string Concatenation
x + y # returns PythonDeveloper
#string Replication
x * 3 # returns PythonPythonPython

len(x) # length of string -- in this case 6
x[0] #returns first letter - p
x[-1]#returns the last letter - n
x[0:3]#returns characters from within the specified range -- pyt

name = f 'I am a {x }{y}' # returns I am a python developer 
x.upper()    #converts to uppercase PYTHON
x.lower()    #converts to uppercase python
x.title()    #converts to titlecase Python
x.strip()    #removes first and last character and returns the string
x.find(“p”)  #finds index of passed character within the string
x.replace(“a”, “b”) #replaces the first passed character with the second one
“a” in x      #find character within the string

2. Numeric - These values can wither be integers, floats or complex numbers
3. Boolean - These is either True or False. It can be used mainly for comparison operations and conditional statements.
4. Special- None

a = 1       # integer
b = 1.1     # float
c = 1 + 2j  # complex number (a + bi)
d = “a”     # string
e = True    # boolean (True / False)
b = ()      #an empty list evaluates to None

Math Operands

Mathematical Operands enable the performance of mathematical operations within our program.
Just like ordinary mathematics, the operands appear in order of precedence as listed below: (*) ()(/)(//)(%) (+)(-) in that order.

2 ** 3     #returns the exponent = 8
2 * 3      # returns 6
12 / 2     #returns 4
24 // 5    #returns 4
24 % 5     #returns the remainder that is 4
28 + 3     #returns 31
28 - 3     #returns 25

Data Structures

1. Lists

Lists contain a collection of items. They are very similar to arrays, however the only difference is that list can store different data type elements while arrays only store elements of a similar data type
They are defined using [] or list() constructor

list1 = ['potatoes',59, 8.5, 'sugar']
list2 = list(('potatoes',59, 8.5, 'sugar'))

2. Tuples

They are an immutable(hence they cannot be changed or modified once declared) and unordered data structures that store a collection of items. They are defined using ()

tuple1 = ('potatoes',59, 8.5, 'sugar')
len(tuple1) # returns 4 that is the number of items in the tuple
del tuple1 # to delete the entire tuple

Difference Between Tuples and Lists

Lists are defined using [] while tuples are defined using ()
Lists are mutable(can be changed and modified) while tuples are immutable
Tuples are more memory efficient and execute faster than lists.

3. Dictionaries

Dictionaries are data structures that store items as key:value pairs. They are defined using {}
Using the keys and values different items within the dictionary can be accessed

my_dict = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
my_dict[0] # returns the first item in the dictionary

4. Sets

Sets are unordered data structures that store unique elements_(No duplicates Allowed!!)_. They are defined using {}

my_set = {5, 4, 6, 7}

VARIABLES AND CONSTANTS
Variables are place-holders that serve to reference items. CONSTANTS are values that once declared remain the same and cannot be changed within the scope of the program.
Rules that Governs naming a variable.

It can be only one word(No spaces between the words please)
It can use only letters, numbers, and the underscore (_) character.
It can’t start with a number. CONSTANTS are usually declared in uppercase letters.

Comments
Python comments are preceded with a #. For multiple lines, you can learn a shorthand command for commenting, eg. Ctrl + K + C in VSCode.

#this is a CONSTANT
CONSTANT = 5
#this are variables
myName = 'Developer X'
my_age = 15

Beginner Friendly CheatSheets

Programming with Mosh : https://programmingwithmosh.com/python/python-3-cheat-sheet/
Official Python Cheatsheet : https://www.pythoncheatsheet.org/