100Days100Projects - freeCodeCamp.org

The Ultimate Guide to Python: How to Go From Beginner to Pro

Sharvin Shah — Fri, 01 May 2020 16:47:40 +0000

If you have an interest in Data Science, Web Development, Robotics, or IoT you must learn Python. Python has become the fastest-growing programming language due to its heavy usage and wide range of applications.

For a beginner or a person from a non-tech background, learning Python is a good choice. The syntax is like talking and writing plain English. For example, consider this syntax which shows its resemblance to the English language.

print("Hello folks")

We will use Python3 in this tutorial as it is widely used. Most of Python's frameworks and libraries support this version.

Note: Any version above 3.5.2 supports most of the libraries and frameworks.

Index:

Introduction
Installation
Python shell
Comment
Print
Indentation
Variables
Operators
Conditional Statements
For Loops
While loops
User Input
Typecasting
Dictionaries
Lists
Tuples
Sets
Functions and Arguments
Args
keyword Arguments
Default Arguments
kwargs
Scope
Return Statement
Lambda Expression
List comprehension
OOPS concepts
Classes
Methods
Objects
Constructor
Instance attribute
Class attributes
Self
Inheritance
Super
Multiple Inheritance
Polymorphism
Encapsulation
Decorators
Exceptions
Package Import
JSON Handling

Note: The beginning of this guide is geared towards beginners. If you have intermediate experience in Python, feel free to skip ahead using the links above.

Introduction:

As per Github's octoverse, Python is the second most used language by developers in 2019.

Octoverse graph of how languages have evolved

Before learning any language, it's helpful to know how that language came into existence. Well, Python was developed by Guido van Rossum, a Dutch programmer, and was released in 1991.

Python is an Interpreted language. It uses the CPython Interpreter to compile the Python code to byte code. For a beginner, you don't need to know much about CPython, but you must be aware of how Python works internally.

The philosophy behind Python is that code must be readable. It achieves this with the help of indentation. It supports many programming paradigms like Functional and Object Oriented programming. You will understand more about these as you read through the article.

The basic question that most beginners have in mind is what a language can do. Here are some of the use-cases of Python:

Server-side development ( Django, Flask )
Data Science ( Pytorch, Tensor-flow )
Data analysis / Visualisation ( Matplotlib )
Scripting ( Beautiful Soup )
Embedded development

Note: I do not endorse any of the above-mentioned libraries or frameworks in particular. They are popular and broadly used in their respective domains.

Installation

The first step of learning any programming language is installing it. Python comes bundled with most operating systems nowadays. Use the following command in your terminal to check if Python is available:

python3 --version

You'll see the following output:

Python 3.7.0

Note that your version of Python might be different. If you have Python installed and the version is above 3.5.2 then you can skip this section.

For those who don't have Python installed, follow the steps below:

Windows User
Mac User
Linux User

Windows User:

Go to Python's official website.
Click on the download button ( Download Python 3.8.2 ) [ Note: The version may differ based on when you are reading this article ]
Go to the path where the package is downloaded and double-click the installer.
Check the box indicating to "Add Python 3.x to PATH" and then click on "Install Now".
Once done you'll get a prompt that "Setup was successful". Check again if python is configured properly using the above command.
To confirm if Python is installed and configured properly, use the command python3 --version.

Mac User:

First install xcode from the app store.
If you want to install Xcode using the terminal then use the following command:

xcode-select --install

After that, we will use the brew package manager to install Python. To install and configure brew, use the following command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

Once brew setup is done, use the following command to update any outdated packages:

brew update

Use the following command to install Python:

brew install python3

To confirm if Python is installed and configured properly, use the command python3 --version.

Linux User:

To install Python using apt, use the following command:

sudo apt install python3

To install the Python using yum, use the following command:

sudo yum install python3

To confirm if Python is installed and configured properly, use the command python3 --version.

Python shell:

The shell is one of the most useful tools you'll come across. The Python shell gives us the power to quickly test any concept before integrating it into our application.

Go to the terminal or command line prompt. Enter python3 command and you'll get the following output:

➜ python3.7
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

In this tutorial, we will learn some concepts with the help of the python3 shell which you can see above. From now on, whenever I mention go to the Python shell, it means that you have to use the python3 command.

To learn the remaining concepts we will create a file called "testing" with the extension .py. To run this file we will use the following command:

python3 testing.py

Let's go to the Python shell. Type 10 + 12 after the >>> mark. You'll get the output 22:

>>> 10 + 12
22

Commenting:

Comments make it easy to write code as they help us (and others) understand why a particular piece of code was written. Another awesome thing about comments is that they help improve the readability of the code.

# Stay Safe

When you add the above syntax, the Python interpreter understands that it is a comment. Everything after # is not executed.

You may be wondering why you should use comments. Imagine you are a developer and you have been assigned to a huge project. The project has more than a thousand lines of code. To understand how everything works you'll need to go line by line and read through all the code.

What's a better solution than that? Ah-ha! Comments. Comments help us understand why a particular piece of code was written and what it returns or does. Consider it as documentation for every piece of code.

Print:

Other than debugging tools from the editor, the thing which helps developers solve problems most often is a print statement. The print statement is one of the most underrated pieces of syntax in all of programming.

So how does it help in debugging an issue? Well, consider that you have a module and you want to check the flow of execution to understand or debug it. There are two options. Either you can use a debugger or add a print statement.

It's not always possible to use a debugger. For example, if you are using the Python shell, then a debugger is not available. In such a scenario, print helps us. Another scenario is when your application is running. You can add a print statement that will display in the logs of your application and monitor them in runtime.

Python provides a inbuilt print method with the following syntax:

print("Stay safe...")

Indentation:

Another interesting part of this language is indentation. Why? Well, the answer is simple: It makes the code readable and well-formatted. It is compulsory in Python to follow the rules of indentation. If proper indentation is not followed you'll get the following error:

IndentationError: unexpected indent

See, even the errors in Python are so readable and easy to understand. At the start, you may be annoyed by the compulsion of indentation. But with the time you'll understand that indentation is a developer's friend.

Variables:

As the name implies, a variable is something that can change. A variable is a way of referring to a memory location used by a computer program.

Well in most programming languages you need to assign the type to a variable. But in Python, you don’t need to. For example, to declare an integer in C, the following syntax is used: int num = 5;. In Python it's num = 5 .

Go to the Python shell and perform the operation step by step:

Integer: Numerical values that can be positive, negative, or zero without a decimal point.

>>> num = 5
>>> print(num)
5
>>> type(num)
<class 'int'>

As you can see here we have declared a num variable and assigned 5 as a value. Python's inbuilt type method can be used to check the type of variable. When we check the type of num we see the output . For now, just focus on the int in that output. int represents an integer.

Float: Similar an integer but with one slight difference – floats are a numerical value with a decimal place.

>>> num = 5.0
>>> print(num)
5.0
>>> type(num)
<class 'float'>

Here we have assigned a number with a single decimal to the num. When we check the type of num we can see it is float.

String: A formation of characters or integers. They can be represented using double or single quotes.

>>> greet = "Hello user"
>>> print(greet)
Hello user
>>> type(greet)
<class 'str'>

Here we have assigned a string to greet. The type of greet is a string as you can see from the output.

Boolean: A binary operator with a True or False value.

>>> is_available = True
>>> print(is_available)
True
>>> type(is_available)
<class 'bool'>

Here we have assigned a True value to is_available. The type of this variable is boolean. You can only assign True or False. Remember T and F should be capital or it will give an error as follows:

>>> is_available = true
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'true' is not defined

NoneType: This is used when we don't have the value of the variable.

>>> num = None
>>> print(num)
None
>>> type(num)
<class 'NoneType'>

Operators:

Take a look at the image below to see all the arithmetic operators available in Python:

Operators table

Let's go over the operators one by one.

Arithmetic operators

These include addition, subtraction, deletion, exponentiation, modulus, and floor division. Also the shorthand syntax for some operators.

First, we will declare two variables, a and b.

>>> a = 6 # Assignment
>>> b = 2

Let's try our basic arithmetic operations:

>>> a + b # Addition
8
>>> a - b # Subtraction
4
>>> a * b # Multiplication
12
>>> a / b # Division
3.0
>>> a ** b # Exponentiation
36

To test for other arithmetic operations let's change the value of a and b.

>>> a = 7
>>> b = 3
>>> a % b # Modulus
1
>>> a // b # Floor division
2

Shorthand arithmetic operations are also available in Python. Refer back to the image above to test them out. To print the output of the shorthand operations use the print statement.

Comparison operators

These include equal to, greater than, and less than.

>>> a = 5 # Assign
>>> b = 2 # Assign
>>> a > b # Greater than
True
>>> a < b # less then
False
>>> a == b # Equal to
False
>>> a >= 5 # Greater than or equal to
True
>>> b <= 1 # Less than or equal to
False

Logical operators

These operators include not, and, & or.

>>> a = 10
>>> b = 2
>>> a == 2 and b == 10 # and
False
>>> a == 10 or b == 10 # or
True
>>> not(a == 10) # not
False
>>> not(a == 2)
True

Conditional Statements:

As the name suggests, conditional statements are used to evaluate if a condition is true or false.

Many times when you are developing an application you need to check a certain condition and do different things depending on the outcome. In such scenarios conditional statements are useful. If, elif and else are the conditional statements used in Python.

We can compare variables, check if the variable has any value or if it's a boolean, then check if it's true or false. Go to the Python shell and perform the operation step by step:

Condition Number 1: We have an integer and 3 conditions here. The first one is the if condition. It checks if the number is equal to 10.

The second one is the elif condition. Here we are checking if the number is less than 10.

The last condition is else. This condition executes when none of the above conditions match.

>>> number = 5
>>> if number == 10:
...     print("Number is 10")
... elif number < 10:
...     print("Number is less than 10")
... else:
...     print("Number is more than 10")
...

Output:

Number is less than 10

Note: It is not compulsory to check that two conditions are equal in the if condition. You can do it in the elif also.

Condition Number 2: We have a boolean and 2 conditions here. Have you noticed how we are checking if the condition is true? If is_available, then print "Yes it is available", else print "Not available".

>>> is_available = True
>>> if is_available:
...     print("Yes it is available")
... else:
...     print("Not available")
...

Output:

Yes it is available

Condition Number 3: Here we have reversed condition number 2 with the help of the not operator.

>>> is_available = True
>>> if not is_available:
...     print("Not available")
... else:
...     print("Yes it is available")
...

Output:

Yes it is available

Condition Number 4: Here we are declaring the data as None and checking if the data is available or not.

>>> data = None
>>> if data:
...     print("data is not none")
... else:
...     print("data is none")
...

Output:

data is none

Condition Number 5: You can also use an inline if in Python. The syntax to achieve this is the following:

>>> num_a = 10
>>> num_b = 5
>>> if num_a > num_b: print("num_a is greater than num_b")
...

Output:

num_a is greater than num_b

Condition Number 6: You can also use an inline if else in Python. The syntax to achieve this is the following:

expression_if_true if condition else expression_if_false

Example:

>>> num = 5
>>> print("Number is five") if num == 5 else print("Number is not five")

Output:

Number is five

Conditional Number 7: You can also use nested if-else statements. The syntax to achieve this is the following:

>>> num = 25
>>> if num > 10:
...     print("Number is greater than 10")
...     if num > 20:
...             print("Number is greater than 20")
...     if num > 30:
...             print("Number is greater than 30")
... else:
...     print("Number is smaller than 10")
...

Output:

Number is greater than 10
Number is greater than 20

Condition Number 8: You can also use the and operator in a conditional statement. It states if condition1 and condition2 both are true then execute it.

>>> num = 10
>>> if num > 5 and num < 15:
...     print(num)
... else:
...     print("Number may be small than 5 or larger than 15")
...

Output:

As our number is between 5 and 15 we get the output of 10.

Condition Number 9: You can also use the or operator in a conditional statement. It states that if either condition1 or condition2 is true then execute it.

>>> num = 10
>>> if num > 5 or num < 7:
...     print(num)
...

Output:

Are you confused because the value of num is 10 and our second condition states that num is less than 7? So why do we get the output as 10? It's because of the or condition. As one of the conditions matches, it will execute it.

For Loops:

Another useful method in any programming language is an iterator. If you have to implement something multiple times, what will you do?

print("Hello")
print("Hello")
print("Hello")

Well, that's one way to do it. But imagine you have to do it a hundred or a thousand times. Well, that's a lot of print statements we have to write. There's a better way called iterators or loops. We can either use a for or while loop.

Here we are using the range method. It specifies the range until which the loop should be repeated. By default, the starting point is 0.

>>> for i in range(3):
...     print("Hello")
...

Output:

Hello
Hello
Hello

You can also specify the range in this way range(1,3).

>>> for i in range(1,3):
...     print("Hello")
...

Output:

Hello
Hello

"Hello" is only printed two times as we have specified the range here. Think of the range as Number on right - Number on left.

Well, you can also add an else statement in the for loop.

>>> for i in range(3):
...     print("Hello")
... else:
...     print("Finished")

Output:

Hello
Hello
Hello
Finished

See our loop iterated 3 times ( 3 - 0 ) and once that is done it executed the else statement.

We can also nest a for loop inside another for loop.

>>> for i in range(3):
...     for j in range(2):
...             print("Inner loop")
...     print("Outer loop")
...

Output:

Inner loop
Inner loop
Outer loop
Inner loop
Inner loop
Outer loop
Inner loop
Inner loop
Outer loop

As you can see the inner loop print statement executed two times. After that outer loop print statement executed. Again the inner loop executed two times. So what is happening here? If you are confused then consider this to solve it:

Our Interpreter comes and sees that there is a for loop. It goes down again and checks there is another for loop.
So now it will execute the inner for loop two times and exit. Once it's finished it knows that outer for loop has instructed it to repeat two more times.
It starts again and sees the inner for loop and repeats.

Well, you can also choose to pass a certain for loop condition. What does pass mean here? Well whenever that for loop will occur and the Interpreter sees the pass statement it won't execute it and will move to the next line.

>>> for i in range(3):
...     pass
...

You will not get any output on the shell.

While loops:

Another loop or iterator available in Python is the while loop. We can achieve some of the same results with the help of a while loop as we achieved with the for loop.

>>> i = 0
>>> while i < 5:
...     print("Number", i)
...     i += 1
...

Output:

Number 0
Number 1
Number 2
Number 3
Number 4

Remember whenever you use a while loop it's important that you add an increment statement or a statement that will end the while loop at some point. If not then the while loop will execute forever.

Another option is to add a break statement in a while loop. This will break the loop.

>>> i = 0
>>> while i < 5:
...     if i == 4:
...             break
...     print("Number", i)
...     i += 1
...

Output:

Number 0
Number 1
Number 2
Number 3

Here we are breaking the while loop if we find the value of i to be 4.

Another option is to add an else statement in while loop. The statement will be executed after the while loop is completed.

>>> i = 0
>>> while i < 5:
...     print("Number", i)
...     i += 1
... else:
...     print("Number is greater than 4")
...

Output:

Number 0
Number 1
Number 2
Number 3
Number 4
Number is greater than 4

The continue statement can be used to skip the current execution and to proceed to the next.

>>> i = 0
>>> while i < 6:
...     i += 1
...     if i == 2:
...             continue
...     print("number", i)
...

Output:

number 1
number 3
number 4
number 5
number 6

User Input:

Imagine you are building a command-line application. Now you have to take the user input and act accordingly. To do that you can use Python's inbuilt input method.

The syntax to achieve this is as follows:

variable = input(".....")

Example:

>>> name = input("Enter your name: ")
Enter your name: Sharvin

When you use the input method and press enter, you'll be prompted with the text that you enter in the input method. Let's check if our assignment is working or not:

>>> print(name)
Sharvin

There it is! It is working perfectly. Here Sharvin is of the type string.

>>> type(name)
<class 'str'>

Let's try one more example where we will assign an integer rather than a string and check the type.

>>> date = input("Today's date: ")
Today's date: 12
>>> type(date)
str'>

Are you confused? We entered an integer 12 and it's still giving us its type as a string. It's not a bug. It's how input is intended to work. To convert the string to integer we will use typecasting.

Typecasting:

We saw that the input method returns a string for the integer also. Now if we want to compare this output with another integer then we need a way to convert it back to an integer.

>>> date_to_int = int(date)
>>> type(date_to_int)
<class 'int'>

Here we took the date that we have declared above in the User input section and converted it into the integer using the Python's inbuilt int method. This is called typecasting.

Basically you can do the following conversion with the help of typecasting:

integer to string: str()
string to integer: int()
integer to float: float()

Note: Conversion from float to integer is also possible.

>>> type(date)
<class 'str'>

# Converting from string to float
>>> date_to_float = float(date)
>>> type(date_to_float)
<class 'float'>

# Converting from float to string
>>> date_to_string = str(date_to_float)
>>> type(date_to_string)
<class 'str'>

# Converting from float to integer
>>> date_to_int = int(date_to_float)
>>> type(date_to_int)
<class 'int'>

Dictionaries:

Imagine you want to store some user details. So how can you store these details? Yes, we can use variable to store them as follows:

>>> fname = "Sharvin"
>>> lname = "Shah"
>>> profession = "Developer"

To access this value we can do the following:

>>> print(fname)
Sharvin

But is this an elegant and optimized way to access it? The answer is no. To make it more friendly, let's store the data in a key-value dictionary.

What is a dictionary? A dictionary is a collection that is unordered and mutable ( i.e. it can be updated ).

Following is the format of the dictionary:

data = {
    "key" : "value"
}

Let's understand the dictionary further by an example:

>>> user_details = {
...     "fname": "Sharvin",
...     "lname": "Shah",
...     "profession": "Developer"
... }

How to access a value in a dictionary

We can access the value inside a dictionary in two ways. We will take a look at both and then debug them to find out which is better.

Method 1: To access the value of fname key from user_details dictionary we can use the following syntax:

>>> user_details["fname"]
'Sharvin'

Method 2: We can also access the value of fname key from user_details dictionary using get.

>>> user_details.get("fname")
'Sharvin'

I know method 1 looks easier to understand. The problem with it occurs when we try to access the data that is not available in our dictionary.

>>> user_details["age"]
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'age'

We get a KeyError which indicates that the key is not available. Let's try the same scenario with method 2.

>>> user_details.get("age")

We do not get anything printed in our console. Let's debug it further to know why this happened. Assign a variable age to our get operation and we will print it in our console.

>>> age = user_details.get("age")
>>> print(age)
None

So when get doesn't find the key it sets the value to None. Because of this, we do not get any error. Now you may be wondering which one is right. Most of the time using method 2 makes more sense, but for some strict checking conditions, we need to use method 1.

How to check if a key exists

You may be wondering how to check if the dictionary has a particular key or not in it. Python provides the built-in method keys() to solve this issue.

>>> if "age" in user_details.keys():
...     print("Yes it is present")
... else:
...     print("Not present")
...

We will get the following output:

Not present

What if we want to check if the dictionary is empty or not? To understand this let's declare an empty dictionary as follows:

>>> user_details = {}

When we use if-else on a dictionary directly it either returns true if data is present or false if empty.

>>> if user_details:
...     print("Not empty")
... else:
...     print("Empty")
...

Output:

Empty

We can also use Python's inbuilt method bool to check if the dictionary is empty or not. Remember bool returns False if the dictionary is empty and True if it is filled.

>>> bool(user_details)
False

>>> user_details = {
...     "fname" : "Sharvin"
... }
>>> bool(user_details)
True

How to update the value of an existing key

So now we know how to get a particular key and find if it exists – but how do you update it in the dictionary?

Declare a dictionary as follows:

>>> user_details = {
...     "fname":"Sharvin",
...     "lname": "Shah",
...     "profession": "Developer"
... }

To update the value use the following syntax:

>>> user_details["profession"] = "Software Developer"
>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

Updating a value of key in dictionary is same as assigning a value to the variable.

How to add a key-value pair

The next question is how to add a new value to the dictionary? Let's add an age key with a value of 100.

>>> user_details["age"] = "100"
>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer', 'age': '100'}

As you can see a new key-value is added in our dictionary.

How to remove a key-value pair

To remove a key-value from the dictionary, Python provides an inbuilt method called pop.

>>> user_details.pop("age")
'100'

>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

This removes the age key-value pair from the user_details dictionary. We can also use a del operator to delete the value.

>>> del user_details["age"]

>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

The del method can also be used to delete complete dictionary. Use the following syntax to delete complete dictionary del user_details.

How to copy a dictionary

A dictionary cannot be copied in a traditional way. For example, you cannot copy value of dictA to dictB as follows:

dictA = dictB

To copy the values you need to use the copy method.

>>> dictB = user_details.copy()

>>> print(dictB)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

Lists:

Imagine you have a bunch of data that is not labeled. In other words, each piece of data doesn't have a key that defines it. So how will you store it? Lists to the rescue. They are defined as follows:

data = [ 1, 5, "xyz", True ]

A list is a collection of random, ordered, and mutable data (i.e., it can be updated).

How to access list elements

Let's try to access the first element:

>>> data[1]
5

Wait what happened here? We are trying to access the first element but we are getting the second element. Why?

Indexing of the list begins from zero. So what do I mean by this? The indexing of the position of the elements begins from zero. The syntax to access an element is as follows:

list[position_in_list]

To access the first element we need to access it as follows:

>>> data[0]
1

You can also specify a range to access the element between those positions.

>>> data[2:4]
['xyz', True]

Here, the first value represents the start while the last value represents the position until which we want the value.

How to add an item to a list

To add an item in the list we need to use the append method provided by python.

>>> data.append("Hello")

>>> data
[1, 5, 'abc', True, 'Hello']

How to change the value of an item

To change the value of an item, use the following syntax:

>>> data[2] = "abc"

>>> data
[1, 5, 'abc', True]

How to remove an item from a list

To remove an item from a list we can use the Python's inbuilt remove method.

>>> data.remove("Hello")
>>> data
[1, 5, 'abc', True]

How to loop through a list

We can also loop through the list to find a certain element and operate on it.

>>> for i in data:
...     print(i)
...

Output:

1
5
abc
True

How to check if an item exists or not

To check if a particular item exists or not in list we can use if loop as follows:

>>> if 'abc' in data:
...     print("yess..")
...
yess..

How to copy list data

To copy list data from one list to another we need to use copy method.

>>> List2 = data.copy()
>>> List2
[1, 5, 'abc', True]

How to check the length of a list

We can also check the length of list using Python's inbuilt len method.

>>> len(data)
4

How to join two lists

To join two list we can use the + operator.

>>> list1 = [1, 4, 6, "hello"]
>>> list2 = [2, 8, "bye"]
>>> list1 + list2
[1, 4, 6, 'hello', 2, 8, 'bye']

What happens if we try to access a element position which is not available in the list? We get a list index out of range error in such a condition.

>>> list1[6]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

Tuples:

The tuple is a data type which is ordered and immutable (i.e. data cannot be changed).

Let's create a tuple:

>>> data = ( 1, 3 , 5, "bye")
>>> data
(1, 3, 5, 'bye')

How to access a tuple element

We can access elements in the tuple the same way as we access them in a list:

>>> data[3]
'bye'

We can access the index range as follows:

>>> data[2:4]
(5, 'bye')

How to change a tuple's value

If you are thinking wait – how can we change the value of tuple, then you are right my friend. We cannot change the value of tuple as it is immutable. We get the following error if we try to change the value of a tuple:

>>> data[1] = 8
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

There's a workaround available to change the value of a tuple:

>>> data = ( 1, 3 , 5, "bye")
>>> data_two = list(data) # Convert data to list
>>> data_two[1] = 8 # Update value as list is mutable
>>> data = tuple(data_two) # Convert again to tuple
>>> data
(1, 8, 5, 'bye')

All other methods that we have seen in the list are applicable for the tuple also.

[ Note: Once a tuple is created a new value cannot be added in it. ].

Sets:

Sets are another data type in Python which are unordered and unindexed. Sets are declared as follows:

>>> data = { "hello", "bye", 10, 15 }
>>> data
{10, 15, 'hello', 'bye'}

How to access a value

As sets are unindexed we cannot directly access the value in a set. Thus to access the value in the set you need to use a for loop.

>>> for i in data:
...     print(i)
...

10
15
hello
bye

How to change a value

Once the set is created, values cannot be changed.

How to add an item

To add an item to the set python provides an inbuilt method called add.

>>> data.add("test")
>>> data
{10, 'bye', 'hello', 15, 'test'}

How to check length

To check the length of the set we use the len method.

>>> len(data)
5

How to remove an item

To remove an item use the remove method:

>>> data.remove("test")
>>> data
{10, 'bye', 'hello', 15}

Functions and Arguments:

Functions are a handy way to declare an operation that we want to perform. With the help of functions, you can separate logic according to the operation.

Functions are a block of code that helps us in the reusability of the repetitive logic. Functions can be both inbuilt and user-defined.

To declare a function we use the def keyword. Following is the syntax of the functions:

>>> def hello_world():
...     print("Hello world")
...

Here we are declaring a function which, when called, prints a "Hello world" statement. To call a function we use the following syntax:

>>> hello_world()

We will get the following output:

Hello world

Remember that the () brackets in a function call means to execute it. Remove those round brackets and try the call again.

>>> hello_world

You'll get the following output:

When we remove the round brackets from the function call then it gives us a function reference. Here above as you can see the reference of function hello_world points to this memory address 0x1083eb510.

Consider you have to perform an addition operation. You can do it by declaring a and b and then performing the addition.

>>> a = 5
>>> b = 10
>>> a + b
15

This is one way to go. But now consider that the value of a and b have changed and you need to do it again.

>>> a = 5
>>> b = 10
>>> a + b
15
>>> a = 2
>>> b = 11
>>> a + b
13

This still looks doable. Now imagine we need to add a set of two numbers a hundred times. The numbers within the set are different for every calculation. That's a lot to do. Don't worry – we have a function at our disposal to solve this issue.

>>> def add(a,b):
...     print(a+b)
...

Here we are adding a and b as a compulsory argument to the add function. To call this function we will use the following syntax:

>>> add(10,5)

Output:

See how easy it is to define a function and use it? So what happens if we don't pass an argument?

>>> add()
Traceback (most recent call last):
  File "", line 1, in 
TypeError: add() missing 2 required positional arguments: 'a' and 'b'

Python throws a TypeError and informs us that the function requires two arguments.

Can you guess what will happen if we pass a third argument?

>>> add(10,5,1)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: add() takes 2 positional arguments but 3 were given

Well, Python will inform us that we have passed 3 arguments but there are only 2 positional arguments.

So what can we do when we don't know how many arguments a function can take? To solve this issue we use args and kwargs.

Args:

When you don't know how many arguments will be passed to the function, use args and kwargs (kwargs are discussed below).

To pass n number of arguments to a function we use args. We add a * in front of the argument.

Remember when you attach a * in front, you will be receiving a tuple of arguments.

>>> def add(*num):
...     print(num)
...

Here *num is an instance of args. Now when we call the function add we can pass in n number of arguments and it won't throw a TypeError.

>>> add(1,2,3)
(1, 2, 3)

>>> add(1,2,3,4)
(1, 2, 3, 4)

Now to perform the addition operation we will use the Python's builtin function sum

>>> def add(*num):
...     print(sum(num))
...

Now when we call the add function we will get the following output:

>>> add(1,2,3) # Function call
6
>>> add(1,2,3,4) # Function call
10

Keyword Arguments:

There are times when we don't know the order of the arguments that will be passed to our function when it's called. In such a scenario we use keyword arguments because you can pass them in any order in your call and our function will know the value. Take a look at this example:

>>> def user_details(username, age):
...     print("Username is", username)
...     print("Age is", age)
...

Let's call this function as follows:

>>> user_details("Sharvin", 100)

We will get the following output:

Username is Sharvin
Age is 100

Well this looks correct, but imagine if we called our function in this way:

>>> user_details(100, "Sharvin")

We will get the following output:

Username is 100
Age is Sharvin

This does not look right. What happened is username took the value of 100 while age took the value of "Sharvin". In scenarios like this where we don't know the order of arguments we can use keyword arguments when calling the function:

>>> user_details(age=100, username="Sharvin")

Output:

Username is Sharvin
Age is 100

Default Argument:

Suppose there is a condition where we are not sure if a particular argument will get a value or not when the function is called. In such a scenario we can use Default arguments as follows:

>>> def user_details(username, age = None):
...     print("Username is", username)
...     print("Age is", age)
...

Here we are assigning a None to our age argument. If we don't pass a second argument while calling the function it will take None as a default value.

Let's call the function:

>>> user_details("Sharvin")

Output:

Username is Sharvin
Age is None

If we pass in the second argument it will override None and use it as the value.

>>> user_details("Sharvin", 200)
Username is Sharvin
Age is 200

But what will happen if we assign the first argument in our function as default and the second as a compulsory argument? Go to the Python shell and try this out:

>>> def user_details(username=None, age):
...     print("Username is", username)
...     print("Age is", age)
...

You'll get the following error:

  File "", line 1
SyntaxError: non-default argument follows default argument

Remember: All compulsory arguments must be declared first and then the default argument must be declared.

kwargs:

There can be a situation where you don't know how many keyword arguments will be passed into the function. In such a scenario we can use Kwargs.

To use kwargs we put ** in front of the argument.

Remember: When you attach a ** in front, you will be receiving a dictionary of arguments.

Let's understand this by example. We will declare a function which accepts username as it's argument with ** in front of it.

>>> def user(**username):
...     print(username)
...

When we call the user function as follows we will receive a dictionary.

>>> user(username1="xyz",username2="abc")

Output:

{'username1': 'xyz', 'username2': 'abc'}

So what's happening here? It looks the same as args, right?

No, it's not. In args, you cannot access a particular value by its name as it is in the form of a tuple. Here we get the data in the form of a dictionary so we can easily access the value.

Consider this example:

>>> def user(**user_details):
...     print(user_details['username'])
...

Let's call our function:

>>> user(username="Sharvin",age="1000")

And you'll get the following output:

Sharvin

Scope:

A scope defines where a variable or function is available. There are two types of scope in Python: Global and Local.

Global Scope

A variable or function created in the main body of Python code is called a global variable or function and is part of the global scope. For example:

>>> greet = "Hello world"
>>> def testing():
...     print(greet)
...
>>> testing()
Hello world

Here the variable greet is available globally because it is declared in the body of the program.

Local Scope

A variable or function created inside a function is called a local variable or function and is part of the local scope:

>>> def testing():
...     greet = "Hello world"
...     print(greet)
...
>>> testing()
Hello world

Here greet is created inside the testing function and is only available there. Let's try to access it in our main body and see what happens:

>>> print(greet)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'greet' is not defined

Remember: Restart the Python console by pressing ctrl + d and starting the shell again by using the python3 command before testing the code above. The first example has you declare the greet variable in the global scope meaning it will still be available in memory when you run the second example.

As greet is not available globally we get the error that it is not defined.

Return Statement:

Until now our functions are pretty simple. They are receiving data, processing it, and printing them. But in the real world, you need a function to return output so that it can be used in different operations.

To achieve this, return statements are used. Remember, return statements are only part of functions and methods. The syntax for the return statement is quite easy.

>>> def add(a, b):
...     return a + b
...
>>> add(1,3)
4

Instead of printing our addition, we are returning the output. The value of the returned output can also be stored in a variable.

>>> sum = add(5,10)
>>> print(sum)
15

Lambda Expression:

Consider a situation where you don't want to perform much computation in a function. In such a situation writing a full-fledged function doesn't make sense. To solve this we use a lambda expression or lambda function.

So what is a lambda expression? It is an anonymous function and they are restricted to a single expression. The lambda expression can take n number of arguments.

The syntax for lambda expression is:

variable = lambda arguments: operation

Let's understand it more by example:

>>> sum = lambda a: a + 10

Here we have declared a variable sum which we are using to call the lambda function. a represents the argument that is passed to that function.

Let's call our function:

>>> x(5)
15

List comprehension:

Consider a situation where you want a list of squares. Normally you'll declare a squares list and then in a for loop you'll square out the numbers.

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Well this is doable, but we can achieve this in a single line with the help of list comprehension.

There are two ways to achieve this. Let's understand both of them.

>>> squares = list(map(lambda x: x**2, range(10)))
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Here we are using list constructor to build a list and inside that lambda function which squares out the number. Another way to achieve the same result is as follows:

>>> squares = list(x**2 for x in range(10))
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

I prefer this way because it is easier to more concise and easier to understand.

What about when we have a condition where we want a set of two numbers that are the same? Well, we need to write two for loops and one if loop.

Let's see how that will look:

>>> num_list = []
>>> for i in range(10):
...     for j in range(10):
...             if i == j:
...                     num_list.append((i,j))
...
>>> num_list
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]

That's a lot of work. And in terms of readability it's hard to understand.

Let's use list comprehension to achieve the same result.

>>> num_list = list((i,j) for i in range(10) for j in range(10) if i == j)

>>> num_list
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]

See how easy it is to get the same output in a single expression? Well, that's the power of list comprehension.

OOP concepts:

Python is a multi-paradigm programming language. It means Python can use different approaches to solve a problem. One of the paradigms is procedural or functional programming. It structures the code like a recipe – a set of steps in the form of functions and code blocks.

Another approach to solving the problem is by creating classes and objects. This is known as object-oriented oriented programming. An object is a collection of data (variables) and methods that act on those data. And classes are a blueprint for each object.

The important thing to understand in object-oriented programming is that objects are at the center of the paradigm – they not only represent the data but also the structure of the program.

You can choose the paradigm that best suits the problem at hand, mix different paradigms in one program, and/or switch from one paradigm to another as your program evolves.

Advantages of object oriented programming

Inheritance: This is one of the most useful concepts in OOP. It specifies that the child object will have all the properties and behavior of the parent object. Thus Inheritance allows us to define a class that inherits all the methods and properties from another class.
Polymorphism: To understand polymorphism let’s divide the word into two parts. The first part "poly" means many and "morph" means to form or shape. Thus polymorphism means one task can be performed in many different ways.

For example, you have a class animal, and all animals speak. But they speak differently. Here, the “speak” behavior is polymorphic and depends on the animal. So, the abstract “animal” concept does not actually “speak”, but specific animals (like dogs and cats) have a concrete implementation of the action “speak”.

Polymorphism means the same function name or method name being used for different types.

Encapsulation: In object-oriented programming you can restrict access to methods and variables – we can make the methods and variables private. This can prevent the data from being modified by accident and is known as encapsulation.

First, we will understand classes, objects, and constructors. Then after that, we will look into the above properties again. If you already know about classes, objects, and constructors, feel free to skip ahead.

Classes:

There are primitive data structures available in Python, for example, numbers, strings, and lists. These can all be used for simple representations like name, place, cost, and so on.

But what if we have more complex data? If there is a pattern in the repetition of the properties of that data, what can we do?

Suppose we have 100 different animals. Every animal has a name, age, legs, etc. What if we want to add other properties to each animal, or one more animal gets added to that list? To manage such a complex scenario we need classes.

According to the official Python documentation:

Classes provide a means of bundling data and functionality together. Creating a new class creates a new type of object, allowing new instances of that type to be made.

Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state.

Syntax of class:

class ClassName:

    -1>
    .
    .
    .

We use class keyword to define a class. We will define a class Car.

class Car:
    pass

Methods:

Methods look the same as functions. The only difference is that methods are dependent on an object. A function can be invoked by name while methods need to be invoked by using their class reference. They are defined inside the class.

In our example, let's create two methods. One is an engine and another is a wheel. These two methods define the parts available in our car.

The below program will give us a better idea of classes:

>>> class Car:
...     def engine(self):
...             print("Engine")
...

>>> Car().engine()
Engine

Here we are calling the engine method by using the Car() reference.

To summarize, the class provides a blueprint of what should be defined but it does not provide any real content. The Car class above defines the engine but it will not state what a specific car’s engine is. It is specified by the object.

Objects:

The object is an instance of the class. Let’s consider the above example of a car. Here Car is our class and toyota is the object of the car. We can create multiple copies of the object. Every object must be defined using the class.

The syntax for creating an object is:

toyota = Car()

Let’s consider our Car example to understand objects a bit better:

class Car:

    def engine(self):
        print("Engine")

    def wheel(self):
        print("Wheel")

toyota = Car()

The above toyota = Car() is a class object. Class objects support two kinds of operations: attribute references and instantiation.

Class instantiation uses function notation. The instantiation operation (“calling” a class object) creates an empty object.

Now we can call different methods from our class Car using the object toyota that we have created. let’s call the method engine and wheel.

Open your editor and create a file named mycar.py. In that file copy the code below:

class Car:

    def engine(self):
        print("Engine")

    def wheel(self):
        print("Wheel")

if __name__ == "__main__":
    toyota = Car()
    toyota.engine()
    toyota.wheel()

Save the above code. Now let's take a closer look at our program.

Here we are creating a toyota object with the help of Car class. The toyota.engine() is a method object. What exactly happens when a method object is called?

In the call toyota.engine() doesn't take any argument but if you see the method declaration we can see that it takes a self argument.

You may be confused about why it is not throwing an error. Well whenever we use a method object, the call toyota.engine() is converted to Car.engine(toyota). We will understand more about the self in the upcoming section.

Run the program using the following command.

python mycar.py

You'll get the following output:

Engine
Wheel

Constructor:

The __init__ method is the constructor method in Python. The constructor method is used to initialize the data.

Go to the Python shell and enter this example:

>>> class Car():
...     def __init__(self):
...             print("Hello I am the constructor method.")
...

When we will call our class we will get the following output:

>>> toyota = Car()
Hello I am the constructor method.

Note: You will never have to call the init() method – it gets called automatically when you create a class instance.

Instance attributes:

All the classes have objects and all the objects have attributes. Attributes are the properties. We use __init__() method to specify an object’s initial attribute.

Let’s consider our car example:

class Car():
    def __init__(self, model): 
        self.model = model  #instance attribute

In our example, each Car() has a specific model. Thus instance attributes are unique data to each instance.

Class attributes:

We saw that instance attributes are specific to each object but class attributes are the same for all the instances. Let us look at the example of the car with the help of class attributes.

class Car():

    no_of_wheels = 4 #class attribute

So each car can have different models but all the cars will have only 4 wheels.

Self:

Now let’s understand what self means and how we use it in object-oriented programming. self represents the instance of a class. By using the self keyword we can access the data initialized in the constructor and methods of a class.

Let's look at an example of how self can be used. Let’s create a method named brand under our class Car.

Inside that __init__ method, we will pass a model by passing our car’s model name when we are instantiating our object. This name can be accessed anywhere in the class, for example self.model in our case.

Go to the file named mycar.py and replace old code with this code:

class Car(): 

  def __init__(self, model): 
    self.model = model

  def brand(self): 
    print("The brand is", self.model)  

if __name__ == "__main__":
  car = Car("Bmw")
  car.brand()

Now when we run our above program using the following command:

python mycar.py

We will get the following output:

The brand is Bmw

Note: self is a convention and not a real Python keyword. self is an argument in a method and we can use another name in place of it. But it is recommended to use self because it increases the readability of your code.

Inheritance:

Inheritance refers to when a class inherits the property of another class.

The class from which properties are inherited is called the base class. The class which inherits the property of another class is called the derived class.

Inheritance can be defined as a parent and child relationship. The child inherits the properties of the parent. Thus making the child a derived class while parent is a base class. Here the term property refers to attributes and methods.

The syntax for a derived class definition looks like this:

class DerivedClassName(BaseClassName):
    -1>
    .
    .
    .

It’s important to note that child classes override or extend the attributes and behaviors of parent class methods. This is to say that child classes inherit all of the the attributes and behaviors of their parents – but they're also able to specify different behavior to follow.

The most basic type of class is an object, which generally all other classes inherit as their parent. Let’s modify our previous example to understand how inheritance works.

We will create a base class named vehicle:

class Vehicle:
    def __init__(self, name):
        self.name = name

    def getName(self):
        return self.name

We have created a class Vehicle and instantiated a constructor with self.name which we are using in getName method. Whenever this method will be called, it will return the name that has been passed when an object is instantiated for that class.

Now let’s create a child class Car:

class Vehicle:
    def __init__(self, name):
        self.name = name

    def getName(self):
        return self.name

class Car(Vehicle):
  pass

Car is a child class of Vehicle. It inherits all the method and attributes of parent class.

Now let’s use methods and attribute from the Vehicle class in our child class Car.

class Vehicle:

    def __init__(self, name, color='silver'):
        self.name = name
        self.color = color

    def get_name(self):
        return self.name

    def get_color(self):
        return self.color

class Car(Vehicle):
  pass

audi = Car("Audi r8")
print("The name of our car is", audi.get_name(), "and color is", audi.get_color())

Let's understand what we have done here.

We have declared a class named Vehicle with a constructor that takes name as an argument while color has a default argument.

We have two methods inside it. get_name returns name while get_color returns the color. We have instantiated an object and passed the car name.

One thing you'll notice here that we are using base class methods in our child class declaration.

Run the above program using the following command:

python mycar.py

Output:

The name of our car is Audi r8 and color is silver

We can also override a parent method or attribute. In the above example, we have defined our vehicle color has silver. But what if the color of our car is black?

Now for every child class, we can’t make changes in the parent class. There comes the overriding functionality.

class Vehicle:

    def __init__(self, name, color='silver'):
        self.name = name
        self.color = color

    def get_name(self):
        return self.name

    def get_color(self):
        return self.color

class Car(Vehicle):

    def get_color(self):
        self.color = 'black'
        return self.color

audi = Car("Audi r8")
print("The name of our car is", audi.get_name(), "and color is", audi.get_color()

As you can see in the above program, I have not instantiated a constructor. The reason behind this is that our child class Car is only using attributes from the Vehicle class and it is already inheriting them. So in such a scenario, there is no need to re-instantiate these attributes.

Now when we run the above program we will get the following output:

The name of our car is Audi r8 and color is black

Super:

super() returns a temporary object of the superclass that then allows us to call that superclass’s methods.

Calling the previously built methods with super() saves us from needing to rewrite those methods in our subclass, and allows us to swap out superclasses with minimal code changes. Thus super extends the functionality of the inherited method.

Let’s extend our car example using super(). We will instantiate a constructor with brand_name and color in the parent class, Vehicle. Now we will call this constructor from our child class (Car) using super. We will create a get_description method which is returning self.model from Car class and self.brand_name, self.color from the Vehicle class.

class Vehicle:

    def __init__(self, brand_name, color):
        self.brand_name = brand_name
        self.color = color

    def get_brand_name(self):
        return self.brand_name

class Car(Vehicle):

    def __init__(self, brand_name, model, color):  
        super().__init__(brand_name, color)       
        self.model = model

    def get_description(self):
        return "Car Name: " + self.get_brand_name() + self.model + " Color:" + self.color

c = Car("Audi ",  "r8", " Red")
print("Car description:", c.get_description())
print("Brand name:", c.get_brand_name())

When we run the above program we get following output:

Car description: Car Name: Audi r8 Color: Red
Brand name: Audi

Multiple Inheritance:

When a class inherits the method and attributes from multiple parent class then it is called multiple inheritance. This allows us to use the property from multiple base classes or parent classes in a derived or child class.

The general syntax of multiple Inheritance is as follows:

class DerivedClassName(Base1, Base2, Base3):
    -1>
    .
    .
    .

Let’s extend our vehicle example using the multiple inheritance property. Here in this example, we will create 3 classes i.e. Vehicle, Cost and Car

The classes Vehicle and Cost will be the Parent class. A Vehicle class represents the general property while the Cost class represents its pricing.

As Car has a general property and cost will have two parent classes. Thus we will inherit multiple parent classes.

class Vehicle:

    def __init__(self, brand_name):
        self.brand_name = brand_name

    def get_brand_name(self):
        return self.brand_name


class Cost:        

    def __init__(self, cost):
        self.cost = cost

    def get_cost(self):
        return self.cost


class Car(Vehicle, Cost):    

    def __init__(self, brand_name, model, cost): 
        self.model = model 
        Vehicle.__init__(self, brand_name) 
        Cost.__init__(self, cost) 

    def get_description(self):
        return self.get_brand_name() + self.model + " is the car " + "and it's cost is " + self.get_cost()

c = Car("Audi ",  "r8", "2 cr")
print("Car description:", c.get_description())

Here you will find one thing in the above program that is different from all the other programs in this tutorial. I have used Vehicle.__init__(self, brand_name) in the constructor of Car class. This is one way of calling attributes from the parent class. Another was is super which I have explained above.

When we run the above program we will get the following output:

Car description: Audi r8 is the car and it's cost is 2 cr

Though it can be used effectively, multiple inheritance should be done with care so that our programs do not become ambiguous and difficult for other programmers to understand.

Polymorphism:

The word polymorphism means having many forms. In programming, polymorphism means same function name (but different signatures) being uses for different types.

Let’s extend our car program using polymorphism. We will create two classes, Car and Bike. Both the classes have common method or function, but they are printing different data. The program is pretty self-explanatory:

class Car: 

    def company(self): 
        print("Car belongs to Audi company.")

    def model(self): 
        print("The Model is R8.") 

    def color(self): 
        print("The color is silver.") 

class Bike: 

    def company(self): 
        print("Bike belongs to pulsar company.") 

    def model(self): 
        print("The Model is dominar.") 

    def color(self): 
        print("The color is black.") 

def func(obj): 
    obj.company() 
    obj.model() 
    obj.color() 

car = Car() 
bike = Bike() 

func(car) 
func(bike)

When we run the above code we will get the following output:

Car belongs to Audi company.
The Model is R8.
The color is silver.
Bike belongs to pulsar company.
The Model is dominar.
The color is black.

Encapsulation:

In most object-oriented programming, we can restrict access to methods and variables. This can prevent the data from being modified by accident and is known as encapsulation.

Let’s use encapsulation in our car example. Now imagine we have a super-secret engine. In the first example, we will hide our engine using a private variable. In the second example, we will hide our engine using a private method.

Example 1:

class Car:

  def __init__(self): 
    self.brand_name = 'Audi '
    self.model = 'r8'
    self.__engine = '5.2 L V10'

  def get_description(self):
        return self.brand_name + self.model + " is the car"

c = Car()
print(c.get_description)
print(c.__engine)

In this example self.__engine is a private attribute. When we run this program we will get the following output.

Audi r8 is the car
AttributeError: 'Car' object has no attribute '__engine'

We get an error that Car object doesn't have _engine because it is a private object.

Example 2:

We can also define a private method by adding __ in front of the method name. Following is the example of how we can define a private method.

class Car:

  def __init__(self):
      self.brand_name = 'Audi '
      self.model = 'r8'

  def __engine(self):
      return '5.2 L V10'

  def get_description(self):
      return self.brand_name + self.model + " is the car"


c = Car()
print(c.get_description())
print(c.__engine())

In this example def __engine(self) is a private method. When we run this program we will get the following output.

Audi r8 is the car
AttributeError: 'Car' object has no attribute '__engine'

Now suppose we want to access the private attribute or method we can do it in the following way:

class Car:

  def __init__(self):
      self.brand_name = 'Audi '
      self.model = 'r8'
      self.__engine_name = '5.2 L V10'

  def __engine(self):
      return '5.2 L V10'

  def get_description(self):
      return self.brand_name + self.model + " is the car"


c = Car()
print(c.get_description())
print("Accessing Private Method: ", c._Car__engine()) 
print("Accessing Private variable: ", c._Car__engine_name)

The output of the following program is:

Audi r8 is the car
Accessing Private Method:  5.2 L V10
Accessing Private variable:  5.2 L V10

Encapsulation gives you more control over the degree of coupling in your code. It allows a class to change its implementation without affecting other parts of the code.

Decorator:

Imagine you have to extend the functionality of multiple functions. How will you do that?

Well, one way is you can make functional calls and in that function, you can handle it. Making changes in 30 to 40 function calls and remembering where to place the call is a messy task. But the more elegant way provided by Python is with decorators.

What is a decorator? A decorator is a function that takes a function and extends its functionality without modifying it explicitly. Well, I understand if you are still confused about what decorators are. Don't worry – we have a tool named example to explain it.

Let's try an example to understand the decorator. There are two ways to write a decorator.

Method 1

We declare a decorator function and in the arguments of the function we expect the function to be passed as an argument. Inside that, we write a wrapper function where operations are carried out and it is returned.

>>> def my_decorator(func):
...     def wrapper():
...             print("Line Number 1")
...             func()
...             print("Line Number 3")
...     return wrapper
...
>>> def say_hello():
...     print("Hello I am line Number 2")
...

To call the function we assign the decorator with say_hello as an argument.

>>> say_hello = my_decorator(say_hello)

We can also check the reference using say_hello. We will get the output that tells us it has been wrapped by the my_decorator function.

.wrapper at 0x10dc84598>

Let's call our say_hello function:

>>> say_hello()
Line Number 1
Hello I am line Number 2
Line Number 3

See the magic the line "Hello I am line Number 2" gets printed in between Line Number 1 and 3 because the function call gets executed there.

Method 1 is clunky, and because of that many people prefer a different approach.

Method 2

Here our decorator declaration remains same but we change how the call is assigned to that decorator. Whichever function requires that decorator wraps itself with @decorator_name.

>>> def my_decorator(func):
...     def wrapper():
...             print("Line Number 1")
...             func()
...             print("Line Number 3")
...     return wrapper
...
>>> @my_decorator
... def say_hello():
...     print("Hello I am line Number 2")
...
>>> say_hello()

Output is the same:

Line Number 1
Hello I am line Number 2
Line Number 3

A decorator is a powerful tool and it is used in the following development scenarios of an application:

Setup logger
Setup configuration
Setup Error catching
Extending common functionality for all function and classes

Exceptions:

When we were learning various syntax we came across various errors. Those errors occurred because of the syntax. But in a real-world application, errors (or commonly known as bugs) not only occur due to syntax issues but also because of network errors or some other cause.

To handle these issues we use Try - Except. In try block, we write the expression that we want to be executed, while in except block we catch the error. The Try-Except block looks as follows:

try:
    expression
except:
    catch error

Let's understand this by an example:

>>> try:
...     print(value)
... except:
...     print("Something went wrong")
...

Here we are trying to print the value variable but it is not defined. So we get the following output:

Something went wrong

You may be thinking that the line "something went wrong" is not that helpful. So how can we know what went wrong here?

We can print the exception and use it to find out what went wrong. Let's test this in our example:

>>> try:
...     print(value)
... except Exception as e:
...     print(e)
...

And the result is:

name 'value' is not defined

Whoa! That's magic. It is notifying me that 'value' is not defined.

Python also provides a tool named raise. Suppose you don't want a certain condition to occur and if it occurs you want to raise it. In such condition you can use raise. Consider the example below:

>>> i = 5
>>> if i < 6:
...     raise Exception("Number below 6 are not allowed")
...

The output we get is as follows:

Traceback (most recent call last):
  File "", line 2, in 
Exception: Number below 6 are not allowed

There are many sub-types of Exceptions, so I recommend that you go through the Python Documentation to understand them.

Package Import:

You have learned the basics of Python and now you are all ready to build awesome applications. But hold on – we are still missing some important topics.

Without package import, you will be forced to write everything in one single file. Imagine what a mess it will be.

Create two files named main.py and hello.py. Remember both file needs to be in the same directory.

Under hello.py copy paste the following code:

def say_hello():
    print("Hello world")

Under main.py copy paste the following code:

import hello

if __name__ == "__main__":
    hello.say_hello()

In hello.py we have declared a say_hello() function which prints "Hello world". In main.py you'll see an import statement. We are importing the hello module and calling the say_hello() function from that module.

Run our program using the following command:

➜ python main.py

Output:

Hello world

Now let's understand how to import a module which is in another directory.

Let's create a directory named "data" and move our hello.py inside that directory.

Go to the main.py and change the previous import statement.

from data import hello

if __name__ == "__main__":
    hello.say_hello()

There are two ways to import from a directory.

Method 1: from data import hello
Method 2: import data.hello

I prefer method 1 because of its readability. You can choose whichever method looks better to you.

Let's run our application using the following command:

➜ python main.py

And an error occurs. Wait why did this happen? We did everything right. Let's go through the error:

Traceback (most recent call last):
  File "main.py", line 1, in 
    from data import hello
ImportError: No module named data

Well Python is telling us that it doesn't recognize a module named data. To solve this issue create a __init__.py inside data directory. Leave the file blank and run the program again and you'll get the following output:

Hello world

Well python by default does not treat a directory as a module. To inform Python to treat a directory as a module, __init__.py is required.

JSON Handling:

If you have worked previously with web development or app development you may be aware that all the API calls take place in JSON format. While JSON looks similar to a dictionary in Python, remember that it's very different.

To handle JSON, Python provides an inbuilt json package. To use this package we need to import it as follows:

import json

This library provides two methods which help us in handling the JSON. Let's understand them one by one.

JSON loads:

If you have a JSON string and want to convert it back to a dictionary you need to use the loads method. Go to the Python shell and copy-paste the following code:

>>> import json
>>> json_string = '{ "user_name":"Sharvin", "age":1000}' #JSON String
>>> type(json_string)
<class 'str'>
>>> data = json.loads(json_string)
>>> type(data)
<class 'dict'>
>>> data
{'user_name': 'Sharvin', 'age': 1000}

JSON dumps:

Now let's convert our data back to the JSON string format using the dumps method.

>>> jsonString = json.dumps(data)
>>> type(jsonString)
<class 'str'>
>>> jsonString
'{"user_name": "Sharvin", "age": 1000}'

To learn more about JSON Manipulation, go through the Python Documentation.

That's it!

And we're done! I hope you now understand the basics of Python. Congratulations! That's a huge achievement.

Feedback is welcomed. Also if you want to learn about any other topic you can tweet the topic name on Twitter and include my Twitter handle. [ @sharvinshah26 ]

Feel free to connect with me on Twitter and Github.

How to Set Your Future Self Up for Success with Good Coding Habits

Colby Fayock — Thu, 16 Apr 2020 14:45:00 +0000

Think before you code. You have the power to make your future self's life Heaven on Earth or a living hell.

In this article we'll explore what kinds of things you can do to make it a little easier on your future self.

Revisiting "prior art"

We've all been there. Six months into a project, you're trying to squash a bug, and what you find is shocking. You might be asking yourself, "who would write this kind of code?"

So you dig through your git commit history using git log -p filename.js showing changes for a specific file, trying to see who would come up with something like that. And then your heart drops – you're the one who wrote it!

Tituss Burgess shocked

This is a common scenario for any developer, experienced or new. If you haven't hit that scenario, I promise if you stick with coding long enough, you will.

Becoming more conscious about our coding habits

That six month reflection point is inevitable. That's a lot of time which you've most likely been using to work on other parts of the project or another project completely. Chances are, you've leveled up which has changed the way you write code.

On the other hand, sometimes it takes stepping outside of the code to see the bigger picture and get a better look at how all the pieces fit together. We can naturally dig ourselves too deep into a solution and can become a little narrowly focused as we work to solve those challenges.

But either way, while part of the code journey will simply be gaining more experience and learning more about your craft, there are other small habits you can get used to early on that will help you down the road.

So let's jump in.

Improving the readability of your code

What is the challenge?

Part of the fun about our craft is there are a ton of ways you can do the same thing. Think an if statement is too many lines? Well we can write it ternary style!

// Example ternary statement
const isFreezing = temperature <= 32 ? true : false;

But sometimes this takes a toll on the readability of your code. While it might seem like it looks nice and super clean on one line, imagine that as that ternary gets more complex, someone will have to spend more time understanding what it means.

const minutes = 30;
const cookie = {
  color: 'black'
};

const cookieStatus = minutes > 20 ? cookie.color === 'black' ? 'burned' : 'done' : 'not done';

What can we do better?

Now I would imagine most of us can figure out what cookieStatus is in this example (spoilers: burned). But think about the time you spent figuring it out. Whether an extra 1s or 2s, it forces you to spend additional cognitive energy to read through the code.

On the other hand:

const minutes = 30;
const cookie = {
  color: 'black'
};
let cookieStatus;

if ( minutes <= 20 ) {
  cookieStatus = 'not done';
} else if ( cookie.color === 'black' ) {
  cookieStatus = 'burned';
} else {
  cookieStatus = 'done';
}

No, it may not be as clean or clever as the 1-line ternary statement, but the next time you visit it, the less you'll have to think about what the answer is.

It's also going to make it that much easier for bugs to creep up and get past your code reviewers when all of your code changes are in a 1-line git diff.

And yes, this is a simple example. But imagine this in a real world scenario with important business logic where you could run into these situations frequently.

Say you need to add another condition – that ternary is just going to keep getting more complex! You're just making it more difficult to debug or extend, where the if statements can continue on in an easily readable way.

For what it's worth, ternaries and other shortcuts can be simple and effective in code, but don't abuse that effectiveness and end up making things more difficult.

Keeping things consistent

What is the challenge?

We all have our favorite way to code. Though I'd argue not including a semicolon at the end of your JavaScript is just completely wrong, you might prefer to write your code the wrong way without them.

// Jim's code style

function MyComponent() {
  function handleOnClick() {
    alert('Click!')
  }
  return (
    <button onClick={handleOnClick}>My Buttonbutton>
  )
}

// Creed's code style

const MyComponent = () => <button onClick={() => alert('Click!')}>My Buttonbutton>;

But it's not always about what you prefer. When working with a team, chances are, everyone's opinion on how code should look is slightly different. You might agree about the semi-colon, but disagree about whitespace.

And no one is wrong (except for the non-semi-coloners)! There are valid arguments to most code styles, whether for or against, but the solution isn't for everyone to write their code their own way.

What can we do better?

Keeping code consistent is important to maintain code health. A typical goal is to "make the codebase look like one person wrote it."

The point isn't that one person gets their way, it's that the team came to a conclusion about a set of rules they would use that everyone would follow. Having this consistency provides less cognitive overhead as people work through the code. It gives everyone the ability to know what to expect when reading the code.

Errors from linting code

And achieving this doesn't need to be hard. There are tools that can simply check for these inconsistencies like Eslint for Javascript. And even better, there is another level of tools like Prettier that will fix it for you!

Commenting your code

What is the challenge?

Keeping up with commenting your code is an important way to put context to complex logic. As much as we all want our code to be self-documenting, that's rarely the case.

Too often we find ourselves dealing with a block of code that just doesn't make sense. And even if it makes sense on its own, we might not be able to figure out how it fits in to the rest of the application.

What can we do better?

By providing a good set of comments, you're setting up the next person who touches that code to have a better understanding of what the code is doing before they make a change.

// DONT CHANGE - WILL STOP MAKING MONEY

const shouldMakeMoney = true;

function makeMoney() {
  if ( shouldMakeMoney ) {
    return noMoney;
  }
  return moreMoney;
}

While this is a silly example, it brings up a real world case. Businesses are increasingly dependent on being able to maintain a reliable website to make money. Whether this is as an ecommerce business or an ad giant, these websites rely on business logic that determine things like cost, taxes, discounts, and other math related things we tend to not want to think about, but could make or break a business on the internet.

But it's not all about the company you work for. Touching old code can be scary. It's even scarier when no one on your team was around when it was written, so no one knows what it does!

Patton Oswalt hands over mouth

While you might not be the next person who touches that code, try to help out your future friend who's tackling the next ticket involving that code. Because there's also a good chance you will be that person and you'll wish you remembered how it worked.

Documenting your solutions

What is the challenge?

Documentation is similar to commenting your code, but from a different perspective. Documentation and commenting are both about finding ways to describe a solution in a human-readable way that will ultimately give more context. But documentation is more about the overall solution rather than the implementation details.

Having a high performing application is everyone's goal. But how did we get there? There's a realistic chance that someone will have to be working on the same project you are like onboarding a new team member. How will they be able to maintain that high performance if they don't know how it works?

What can we do better?

Whether it's introducing that new team member to the project or trying to share knowledge with another project team, documentation is an important part of maintaining a project. It helps keep everyone on the same page so we all confidently know what we're working towards.

For example, if we're still working with our ecommerce project with our business logic, there will be rules that the code needs to implement. While commenting might give details inline about how the rules were implemented, the documentation would define those rules.

/**
 * DOCUMENTATION
 * Order Total >= 25: Discount %10
 * Order Total >= 50: Discount %15
 * Order Total >= 100: Discount %20
 * Order Total >= 75: Free Shipping
 */

const orderSubTotal = 84.00;
let orderTotal = orderSubTotal;

// If the order total is under 75, apply shipping discount

if ( orderTotal < 75 ) {
  orderTotal = addShipping(orderTotal);
}

// If the order total reaches a threshold, apply given discount

if ( orderTotal >= 100) {
  orderTotal = applyDiscount(orderTotal, .2);
} else if ( orderTotal >= 50 ) {
  orderTotal = applyDiscount(orderTotal, .15);
} else if ( orderTotal >= 25 ) {
  orderTotal = applyDiscount(orderTotal, .1);
}

This is a minimal example, but we can see the difference between the rules at the top and how we apply them. The documentation should clearly explain what the rules are, but it shouldn't care about how those rules were implemented.

On the other hand, the comments might not care about what the rules are, but need to implement them in an efficient and logical way. We should be able to update the code with the business rules, such as changing the top level discount tier from $100 to $80, without having to rework the code.

But documentation is much more than business rules – it's providing a way for anyone to understand your work from a higher level. This could include anything from architectural diagrams to the theory behind your core algorithm.

While maybe code isn't the best place for details like this to live, it's really important information that can help instill confidence in your project and give others an opportunity to understand more about the work.

Creating effective Pull Requests

What is the challenge?

Pull requests (or merge requests) are a core part of any development team's project lifecycle. It provides a way to package and present your code in a consumable way for your peers to review and understand your work.

There's a lot that can go into a pull request from a single commit to the entirety of the next version of your website. That's a lot of context to expect someone to understand by reading through the commits alone.

What can we do better?

Pull requests don't need to be an art. There should be one primary goal of the preparation you put into it – providing context into your changes. At a minimum, it should answer the questions of "what" and "why".

We can even use tools like pull request templates to push us in the right direction. Define an outline of what you want explained and chances are, people will follow that outline. This helps avoid the 1-line "closes [ticket]" description or even worse, an empty description.

With my projects, I hope to have a few questions answered before I dive into a code review:

What is the change?
What does it impact?
How do I reproduce or test the change?

Just a few details around the change set can provide much needed context for those reviewing your code. It's easy to look at code, but it's harder to understand it without knowing how it fits into the bigger picture.

Hardening your code with tests

What is the challenge?

Tests are a way to ensure your code runs the same way each time. Being able to prove that the same input will always have the same output will help provide you and your team with a higher level of confidence that your application won't come crashing down with the next small change.

Without them, we're left with human error, where no matter how good your QA Engineer is (shoutout to my testers out there), something will always slip through. And that's not to say your tests will always catch every problem, but we can use the tools available to help prevent it.

What can we do better?

Where comments are a way of providing the context of how something works, test are a way to ensure they work. Providing test cases that are repeatable helps enforce that.

function applyDiscount(value, discount) {
  const discountAmount = value * discount;
  return value - discountAmount;
}

expect(applyDiscount(10, .1)).toEqual(.9);
expect(applyDiscount(532151235, .1054)).toEqual(476062494.831);

If I fudge the math on our applyDiscount function above, there's a high probability that the test would fail (never say never).

But testing doesn't need to be hard. There are many tools out there that help from different perspectives. For example, you might use Jest to run your unit tests or add Enzyme on top to test your React components. But you can also bring in Cypress as an integration test solution that will work like a robot clicking through your application to make sure all the components actually work together.

There's also different methodologies of testing. While you probably see most teams write their tests after they have a working solution, some people swear by test-driven development. They might write their tests first where the code has to pass the tests rather than the other way around. This is a great way to define the requirements of the code before diving right in.

Whatever the method, capture the points that are most likely to break or the functions that add the most business value. You'll be helping to prevent a potential business loss or even simpler, a headache.

What can we learn from this?

That might be a lot to digest, but they're important points to consider as you grow as a developer. Starting these habits early in your career will help you naturally build these skills and work that way by default.

And if you're late in your career, it's never too late to start. We should all want to strive to be the best developer we can be and do our best to help make our teammate's lives easier, as we're all in this together.

Looking for more to learn?

What’s your advice for growing as a developer?

Share with me on Twitter!

How I built 100 Projects in 100 Days

freeCodeCamp — Fri, 27 Dec 2019 11:17:27 +0000

By Florin Pop

I finished the #100Days100Projects challenge ? In this article I’m going to cover my experience doing this challenge and I’m also going to answer some of the questions that I received on Twitter about this.

It will be an “ask and answer” type of article, so I hope you enjoy it! ?

What is this challenge about?

The main purpose of this challenge is to build a project every single day for 100 days in a row. You can read more about the rules here. (Note: there is also an easier variant: #30Days30Projects, in case you are interested for something lighter ?)

I started this challenge on 17 September 2019 and finished on 25 December 2019.

What projects have you built during the challenge?

In the last project (#100) I added all the projects that I’ve built during the challenge, so if you want to check them out click here.

All of the projects were web based - frontend mostly (HTML, CSS, JavaScript), and some of them had a little bit of NodeJS for the backend.

I used all sorts of APIs, some JS libraries (ReactJS, p5js - for working with the canvas), but most of the projects were done with Vanilla JS and CSS.

How do you come up with so many ideas?

Apparently a lot of people have asked me this question over these 100 days.

It’s simple: I am a genius. ?

Just kidding ?... I’m far from being that.

The truth is that I gathered a lot of resources over the past year because I needed inspiration for my articles, videos, etc, and I’ve used them to get inspiration for these projects also.

Also, doing this creative process over and over and over, you end up eventually getting ideas from all the things around you. There are some projects that I did because I saw a need in my day-to-day life (Drink Water app, Random Picker Visualizer, Countdown, Password Generator, etc…).

Let’s not forget also that some of the projects were suggested by my followers. (Thank you guys ?)

The resources that I’ve used mostly for inspiration:

Did you have a plan for a longer period of time or did you do it spontaneously?

Out of the 100 projects, I think that only 2 or 3 were “planned” beforehand - like a day before. ?

The rest of them were just done spontaneously.

But I wouldn’t recommend doing that. It’s much better to have things planned out - it gets rid of the headache you might get when you have to come up with an idea right away.

Why did you do it?

I LOVE CHALLENGES! ?

As simple as that.

I love pushing my limits and this challenge looked like one that could do that (and it did!). Also, I’ve noticed that if I publicly announce that I’m doing something, I end up actually doing it - maybe because of the shame that I would feel if I fail. I don’t know. Haven’t failed a challenge yet. ?

The first challenge I did was a 365 days of running challenge. I publicly declared on Facebook that I was going to do it and I posted a picture daily with me after my runs. This gave me the strength to finish it (actually ended up doing 422 days). I couldn’t fail my followers, right? ?

And on the other hand, I knew that if I was going to post daily I would inspire others. I wanted to show people that even ordinary people like us can do stuff if we set our minds to it. We have a powerful mind, we just don’t use it at its full capacity!

Yes. I am an ordinary guy. Nothing special here. So if I did it, you can do it too!

How much work did it take to create a project?

Some of the projects I did in under 30 minutes, a couple took me 6-8 hours and 1 or 2 I had to “postpone” to the 2nd day because I couldn’t finish them. Although I postponed these projects to the next day, I recreated them from scratch - only using the gained knowledge. This turned out to be a good way to get "unstuck". Just redo it from scratch.

I would say that I needed around 1-1.5 hours on average per day. This includes: idea + execution + social media.

Keep in mind that I’ve been coding since 2013, so maybe someone with less experience would need a little more time, but it really depends on the project difficulty.

What motivated you to keep going?

As I mentioned above, I think that the shame of failing kept me moving, considering that I publicly committed to the challenge. I can’t fail my audience!

I had a \$25 “punishment fee” which I would have to pay for the failing days, but I don’t think that I ever thought about it after I started.

I added the money aspect because I knew that it would be engaging for people to have it and some of them would want me to fail (sneaky you! ?) so they would check in daily - which ended up giving me a small boost of views on my posts ?.

What have you learned during the challenge?

I’ve learned a couple of things:

Learned how to “sketch” and plan a project structure
Learned and played around with some technology and APIs that I haven’t used before
Learned more about CSS properties (positioning, animation, etc)
Learned more on how to work with the JS DOM API

It ended up helping me solidify my vanilla JS and CSS skills!

What would you do differently?

One thing that I’ve noticed is that there were more simpler projects that I initially planned. I expected to have more apps with multiple functionalities, but considering the fact that this challenge wasn’t the only thing that I had going, I ended up doing more simple projects (like just a design implementation with HTML/CSS, no JavaScript).

If I would ever do this challenge again, I would either:

Do fewer days (30 or 50) or
Focus 100% on the challenge (no more client work or other projects, etc)

This way I could do more “sophisticated” apps.

Nevertheless, I’m happy with the projects that I’ve done considering the given situation.

Also, I ended up spending a lot of time posting on social media (Twitter, LinkedIn, Facebook, Instagram - for which I created a new image every time).

Maybe a good system to “share everywhere” would help to speed up the process.

Don’t get me wrong, posting on SM is important and I wouldn’t drop it, but I would speed it up if possible.

Should people do this challenge?

If you want a good challenge. Yes.
If you want to learn new things. Yes.
If you want to create engagement with your audience. Yes.

Should you do 100 days? Depends.
Do you have the time? Then do it. Otherwise I would only do the 30 days variant.

What’s next for you?

Another challenge. ?

For 2020 I’m planning to go all-in on YouTube so I’m going to start the year with a 31 days 31 videos challenge (more about it coming soon). I want to have a solid backlog of videos for my YouTube channel, so this challenge goes very well for that.

Who knows… maybe I’ll keep doing it if everything goes well.

Subscribe if you want to follow my progress! ?

Conclusion

If you have any other questions, let me know and I’ll be happy to answer and update the article!

I hope this was helpful for you!

Thank you for reading! ?

Why You Should Use SVG Images: How to Animate Your SVGs and Make Them Lightning Fast

Oleh Romanyuk — Tue, 26 Nov 2019 14:51:07 +0000

Why Are We Using SVG?

The web development sector is growing at a rapid pace, and SVG (scalable vector graphics) images are becoming more popular. As vector images, SVGs are composed of mathematical equations that define the positioning and color of lines and curves which make up graphic shapes and text in XML format. SVGs are used for icons, logos, graphic designs, and fonts.

Using SVGs is an easy choice once you consider the advantages they offer. For a client, you get superb quality on any device. For us as developers, there are even more reasons to use SVG.

Let's discuss some of the benefits of SVG now.

1. Text-based format

SVG elements contain text, which greatly improves the accessibility of a website. But the main advantage is that this text is indexed by search engines. And a user can find an SVG file via Google.

2. Scalability

The quality of SVG images does not depend on the resolution. Unlike images of other formats or icon fonts, SVGs look perfectly sharp on any device with any screen size. Scalability also means that if you use the same image throughout the website but in different sizes, you use a single SVG. You do not have to create multiple copies of it as in the case of PNG. Instead, you embed the same image and define the size of it directly in SVG code.

3. High performance

If you prioritize performance, you should use SVG. With SVG, there is no need for an HTTP request to load in an image file. The page loads faster as it has no files to download. Faster loading time translates into better webpage performance and higher search engine ranking. In turn, it improves user experience.

4. Small file size

The size of simple SVG files is defined by the colors, layers, gradients, effects, and masks that it contains. The size of a PNG or any other raster graphics file is defined by the number of pixels that it consists of. The larger a PNG image is, the heavier it gets in size. This is not the case for SVG icons, though. Also, SVGs can be optimized, and I will tell how later in this article.

5. Numerous editing and animating opportunities

Unlike raster images, vector images can be edited both in special vector drawing programs and directly in a text editor. You can also edit colors or sizes of SVG icons directly via CSS. As for animating SVGs, it can be done with the help of SMIL, Web Animations API, WebGL, or CSS animation. Scroll down to learn more about CSS animation of SVG images.

6. Integration with HTML, XHTML, and CSS

SVG was designed “to integrate with and extend other prominent open Web platform technologies, such as X/HTML, CSS, and Javascript”, according to W3C. So, unlike different image formats, this format can be easily integrated with other documents and technologies.

7. W3C Document Object Model support

There is growing community support for SVG. The World Wide Web Consortium (W3C) has always claimed that the Internet cannot do without vector images. This organization basically created the SVG format, and they actively support it nowadays.

What Are the Inconveniences of SVG?

The large number of small parts makes the use of the SVG format irrational. The more parts an image consists of, the heavier it grows in size.

For example, here are two SVG maps of the United States. The second one is slightly more detailed than the first one. But the higher level of detail cost almost a fivefold increase in file size – 33 KB compared to 147 KB. If this map was not monochromatic, the increase would be much greater.

If the picture is linear and contains a few colors – SVG is a solution. However, if the details matter and there are a lot of them, PNG or JPEG may be more suitable.

Also note that SVG cannot be used for photographs. If you use a photograph on your website, SVG is not the best option. You definitely should go with a raster image format.

How to Optimize SVG Images

When rendering a vector format, we have to write some extra SVG code. The end result should be optimized using different services. Most often, for optimizing SVG, I use a Node.js tool SVGO. It is quite easy to use, and there is no need to upload the images to other websites.

Example of SVG optimization using SVGO

How to Animate SVG

SVG graphics on the web can be animated in a number of ways:

SMIL, which is the native SVG animation specification
Web Animations API, which is a native JavaScript API allowing you to create more complex sequential animations without loading any external scripts
WebGL
CSS animation

Let’s consider the last one.

CSS animation is used in order to avoid overloading your service with big libraries for animating icons and loaders.

To see the example of SVG check the animated yolk, the graphic design of which was initially drawn in Sketch.

As you can see here, I use Keyframe Animation Syntax for animation. It is implemented by setting the initial position of an element by id (0%), transition (50%) and final position (100%). To achieve smooth animation, initial and final values are equal.

Here are some benefits of using the CSS approach to SVG animation:

You do not need an external library.
Preprocessors (like Sass or Less) allow you to create variables.
You can use onAnimationEnd and some other animation hooks with native JavaScript.
This approach is easy to use for responsive web design development because you can modify your animation with media queries.

The downsides of using CSS animation are the following:

You cannot produce some complex physics effects, which would make the animation more realistic.
A lot of recalculation needs to be done if you adjust timing.
CSS and SVG graphics on mobile sometimes require strange hacks.

For Example

Still, we can make some interesting projects with the help of simple and trivial CSS animation. For example, I have made a simple game-video using HTML, CSS, and a little bit of JavaScript. All the SVGs were drawn in Sketch. The objective of this game is to save the princess. In any situation, just click. You can find the project at my GitHub.

To Wrap Up

SVGs are a great image format to go with. They are scalable, lightweight, text-based, and efficient. They are easy to edit, animate, and integrate. Importantly, they are supported by almost any browser except Internet Explorer 8 and Android 2.3.

While learning to work with scalable vector graphics images may take you some time, it is an investment that will pay off considering the benefits of SVG.

Do you have an idea for a software project?

My company KeenEthics is a team of experienced web application developers. In case you need a free estimate of a similar project, feel free to get in touch.

You can read more of similar articles on my Keen Blog. Allow me to suggest you read The Value of User Testing or 7 Cases When You Should Not Use Docker.

P.S.

Also, I would like to say "thank you" to Maryna Yanul for coauthoring this article as well as the readers for making it to the end!

The original article posted on KeenEthics blog can be found here: A Fresh Perspective at Why, When, and How to Use SVG.

How to Create a Random Meal Generator

freeCodeCamp — Sun, 22 Sep 2019 22:00:00 +0000

By Florin Pop

Last week I decided to take on a new challenge. I called it: The #100Days100Projects Challenge.

The purpose of the challenge is to create one project every single day. Think of it as a next step for the #100DaysOfCode challenge.

A project can be either:

an app
a component
a website
a game
a library and so on...

The programming language used is also not important, but I need to complete the project by 11:59 PM (my time), otherwise I'm "punishing" myself by giving away $5 for 5 people ($25 total) - first 5 people who point it out on Twitter that I missed the deadline. ?

If you want to join, you can read more about this challenge and the other variants it has here.

Note: you don't have to give away $5 if you fail, just set some other "punishment" for yourself. Also, there are other variants with less days (7Days7Projects and 30Days30Projects) if you don't feel like taking on the 100Days challenge.

For the first project in the #100Days100Projects I thought about working with a public API in order to get some data that would be displayed in a webpage - an usual thing to do with an API.

For that I chose to use TheMealDB's public API in order to get some random meals by pressing a button. Something straightforward! ?

Check out the live version of what we're going to build in this article over on CodePen:

As always let's start at the beginning:

The HTML

<div class="container">
    <div class="row text-center">
        <h3>
            Feeling hungry?
        h3>
        <h5>Get a random meal by clicking belowh5>
        <button class="button-primary" id="get_meal">Get Meal ?button>
    div>
    <div id="meal" class="row meal">div>
div>

We have a little text, but the two most important parts are:

the #get_meal button and
the #meal div

We're going to use the button to make a request to the API. This will send back some data that we're going to put into the #meal div which acts as a container - in this case.

Usually after the HTML I'll go right into the CSS. But we don't yet have the entire markup as it will be populated in the JavaScript section, so that's what we're going to do next.

The JavaScript

As mentioned above, we need the button and that container div:

const get_meal_btn = document.getElementById('get_meal');
const meal_container = document.getElementById('meal');

Next, before we dive more into the code, let's see what the API is going to return. For that please open the following URL: https://www.themealdb.com/api/json/v1/1/random.php.

As you can see from the URL, we are getting a random meal from this API (refresh to see the randomness). When we're making a GET request to that endpoint (like accessing it from the browser), it sends back a JSON response, which we can parse in order to retrieve the data we want.

The data looks something like this:

{
    meals: [
        {
            idMeal: '52873',
            strMeal: 'Beef Dumpling Stew',
            strDrinkAlternate: null,
            strCategory: 'Beef',
            strArea: 'British',
            strInstructions: 'Long description',
            strMealThumb:
                'https://www.themealdb.com/images/media/meals/uyqrrv1511553350.jpg',
            strTags: 'Stew,Baking',
            strYoutube: 'https://www.youtube.com/watch?v=6NgheY-r5t0',
            strIngredient1: 'Olive Oil',
            strIngredient2: 'Butter',
            strIngredient3: 'Beef',
            strIngredient4: 'Plain Flour',
            strIngredient5: 'Garlic',
            strIngredient6: 'Onions',
            strIngredient7: 'Celery',
            strIngredient8: 'Carrots',
            strIngredient9: 'Leek',
            strIngredient10: 'Swede',
            strIngredient11: 'Red Wine',
            strIngredient12: 'Beef Stock',
            strIngredient13: 'Bay Leaf',
            strIngredient14: 'Thyme',
            strIngredient15: 'Parsley',
            strIngredient16: 'Plain Flour',
            strIngredient17: 'Baking Powder',
            strIngredient18: 'Suet',
            strIngredient19: 'Water',
            strIngredient20: '',
            strMeasure1: '2 tbs',
            strMeasure2: '25g',
            strMeasure3: '750g',
            strMeasure4: '2 tblsp ',
            strMeasure5: '2 cloves minced',
            strMeasure6: '175g',
            strMeasure7: '150g',
            strMeasure8: '150g',
            strMeasure9: '2 chopped',
            strMeasure10: '200g',
            strMeasure11: '150ml',
            strMeasure12: '500g',
            strMeasure13: '2',
            strMeasure14: '3 tbs',
            strMeasure15: '3 tblsp chopped',
            strMeasure16: '125g',
            strMeasure17: '1 tsp ',
            strMeasure18: '60g',
            strMeasure19: 'Splash',
            strMeasure20: '',
            strSource:
                'https://www.bbc.co.uk/food/recipes/beefstewwithdumpling_87333',
            dateModified: null
        }
    ];
}

Basically we get back an array of meals, but with only one item in it - the randomly generated one. And this item has all the data we want to showcase in our little application. Things like:

meal name (under strMeal)
meal caterogy (under strCategory)
meal image (under strMealThumb)
a youtube video with the recipe (under strYoutube)
the ingredients and the measures (under strIngredientsX and strMeasureX - X representing the nth ingredient and it's measure).This is a little bit awkward as I would expect here to have an array with this information, but they choose to add it as object props. On well... ? The important thing to note is that there are a maximum of 20 ingredients / measures, although they aren't all filled in - some of them might be empty so we need to account for that.

Now that we have the button we're going to add an event listener for the click event. Inside we're going to make a request to the API:

get_meal_btn.addEventListener('click', () => {
    fetch('https://www.themealdb.com/api/json/v1/1/random.php')
        .then(res => res.json())
        .then(res => {
            createMeal(res.meals[0]);
        })
        .catch(e => {
            console.warn(e);
        });
});

We're using the fetch API to do the request. We just have to pass in the url of the API we want to make a GET request to, and we're going to get back a promise.

Once this is resolved we have a response (res). This res isn't yet in the state we want it to be, so we're going to call the .json() method on it. Then finally we have the beautiful object. Yay! ?

As mentioned above, the API returns the meals array but only with an item in it. So we're going to pass that item (at index 0) into our createMeal function, which we'll define next.

I'm going to paste the entire block of code below and we're going to go into detail afterwards, so hold on for a second. ?

const createMeal = meal => {
    const ingredients = [];

    // Get all ingredients from the object. Up to 20
    for (let i = 1; i <= 20; i++) {
        if (meal[`strIngredient${i}`]) {
            ingredients.push(
                `${meal[`strIngredient${i}`]} - ${meal[`strMeasure${i}`]}`
            );
        } else {
            // Stop if there are no more ingredients
            break;
        }
    }

    const newInnerHTML = `
        
            
                ${meal.strMealThumb}" alt="Meal Image">
                ${
                    meal.strCategory
                        ? `Category: ${meal.strCategory}
`
                        : ''
                }
                ${meal.strArea ? `Area: ${meal.strArea}
` : ''}
                ${
                    meal.strTags
                        ? `Tags: ${meal.strTags
                                .split(',')
                                .join(', ')}
`
                        : ''
                }
                Ingredients:
                
                    ${ingredients.map(ingredient => `${ingredient}
`).join('')}
                
            
            
                ${meal.strMeal}
                ${meal.strInstructions}
            
        
        ${
            meal.strYoutube
                ? `
        
            Video Recipe
            
                ${meal.strYoutube.slice(-11)}">
                
            
        
`
                : ''
        }
    `;

    meal_container.innerHTML = newInnerHTML;
};

Basically the entire function's purpose is to get the JSON response, parse it, and transform it into an HTML component. For that we need to do a couple of things, as the data is not yet formated exactly the way we want it to be.

First, we're getting all the ingredients and their measures. As mentioned above there are a maximum of 20 ingredients, but they are separated into their own properties in the object like: strIngredient1, strIngredient2, etc... (I still don't know why they did that, but... ?).

So, we're creating a for loop which goes from 1 to 20 and checks if the meal has that corresponding ingredient-measure pair. If it does, we're putting it into the ingredients array. If there aren't any more ingredients we're stopping the for loop with a break condition.

Next, we're creating the newInnerHTML string which is going to hold the entire HTML markup. In it we are parsing the remaining properties that we want to be displayed.

Note that some of the properties might not be available. So for that we're using the ternary operator to check if we have the data to display the corresponding tag. If we don't have it then we're returning an empty string and nothing will be displayed on the page. The category and the area are examples of these type of properties.

The tags are coming in a string divided by a comma like: 'tag1,tag2,tag3'. So we need to split it by that comma, and join it back by a comma and a space as it looks nicer ('tag1, tag2, tag3' ❤️). Or at least for me does. ?

To show the ingredients, we're mapping over the array and we're creating an

for each ingredient/measure pair. At the end we're joining the array back to form a string. (This is something you would do in ReactJS but without the joining part ?).

There is also a Youtube video string (maybe) which is returning the URL of the video. But in order for us to embed the video in the page we need to extract the video ID only. For that we're using .slice(-11) to get the last 11 characters of the string as this is where the ID is hiding ?.

And finally, we're setting this entire newInnerHTML to be the meal_container's innerHTML -> this will populate that div with all this information!

This entire process will repeat every time we're pressing the Get Meal button.

The CSS

The last part is to style it a little bit, right? ?

For the CSS I wanted to use something new so I tried out the SkeletonCSS library. It's useful if you have a small project and don't want to get overwhelmed with all those classes, as it only has a couple of them that take care of some basic styling (the button for example) and the responsive part.

@import url('https://fonts.googleapis.com/css?family=Muli&display=swap');

* {
    box-sizing: border-box;
}

body {
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    padding: 30px 0;
    min-height: calc(100vh - 60px);
}

img {
    max-width: 100%;
}

p {
    margin-bottom: 5px;
}

h3 {
    margin: 0;
}

h5 {
    margin: 10px 0;
}

li {
    margin-bottom: 0;
}

.meal {
    margin: 20px 0;
}

.text-center {
    text-align: center;
}

.videoWrapper {
    position: relative;
    padding-bottom: 56.25%;
    padding-top: 25px;
    height: 0;
}

.videoWrapper iframe {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
}

You can see that the CSS is pretty simple. The only part that's worth mentioning is the .videoWrapper CSS declaration. This makes sure that the YouTube embed is responsive. (Got this from CSS-Tricks - thanks guys! ?)

Conclusion

And voilà! We're done! ?

You should now know how to use a public API to get some data which you can then insert on the page easily! Well done! ?

This is the first project I did for the #100Days100Projects challenge. You can check out what other projects I've built and what are the rules of the challenge (if you might want to join) by clicking here.

You can read more of my articles on www.florin-pop.com.

Happy Coding! ?

How to use video as a background in React Native

freeCodeCamp — Mon, 15 Apr 2019 21:02:58 +0000

By Said Hayani

In this post, we are going to create a **backgroundVideo** in React Native. If you have just started with React Native check out my article What you need to know to start building mobile apps with React Native.

Demo: Peleton Home Screen

Background video can add a nice effect to the UI of an app. They may be helpful also if you want to display, for example, ads or send a message to the user, like we’ll do here.

You will need some basic requirements. To get started, you must have the react-native environment setup. That means you have:

react-native-cli installed
Android SDK; if you have a mac you won’t need that, just Xcode

Getting started

First things first, let’s bootstrap a new React Native app. In my case I’m using react-native-cli. So in your terminal run:

react-native init myapp

This should install all the dependencies and packages to run your React Native app.

Next step is to run and install the app on the simulator.

For iOS:

react-native run-ios

This should open up the iOS simulator.

On Android:

react-native run-android

You may have some trouble with Android. I recommend that you use Genymotion and the Android emulator or check out this friendly guide to set up the environment.

First what we are going to do is clone the Peleton app’s home screen. We are using [**react-native-video**](https://github.com/react-native-community/react-native-video) for video streaming, and [**styled-component**](https://www.styled-components.com/docs/basics#react-native) for styling. So you have to install them:

Yarn:

yarn add react-native-video styled-components

npm -i react-native-video styled-components --save

Then you need to link react-native-video because it contains native code — and for **styled-components** we don’t need that. So simply run:

react-native link

You don’t have to worry about the other things, just focus on the Video Component. First, import Video from react-native-video and start using it.

import import Video from "react-native-video";
  <Video
source={require("./../assets/video1.mp4")}
style={styles.backgroundVideo}
muted={true}
repeat={true}
resizeMode={"cover"}
rate={1.0}
ignoreSilentSwitch={"obey"}
/>

Let’s break it down:

source: the path to the source video. You can use the URL instead:

source={{uri:"https://youronlineVideo.mp4"}}

style: the costume style we want to give to the video, and the key to making the background video
resizeMode: in our case it is cover; you can try also contain or stretch but this won’t give us what we want

And other props are optional.

Let’s move to the important part: placing the video in the background position. Let’s define the styles.

// We use StyleSheet from react-native so don't forget to import it
//import {StyleSheet} from "react-native";
const { height } = Dimensions.get("window");
const styles = StyleSheet.create({
backgroundVideo: {
height: height,
position: "absolute",
top: 0,
left: 0,
alignItems: "stretch",
bottom: 0,
right: 0
}
});

What did we do here?

We gave the video a position :absolute and we give it the window height of the device. We used the Dimensions from React Native to ensure that the video is taking up the whole hight — top:0, left:0,bottom:0,right:0 — so that the video takes up all the space!

The entire code:

import React, { Component, Fragment } from "react";
import {
  Text,
  View,
  StyleSheet,
  Dimensions,
  TouchableHighlight
} from "react-native";
import styled from "styled-components/native";
import Video from "react-native-video";
const { width, height } = Dimensions.get("window");
export default class BackgroundVideo extends Component {
  render() {
    return (
      <View>
        <Video
          source={require("./../assets/video1.mp4")}
          style={styles.backgroundVideo}
          muted={true}
          repeat={true}
          resizeMode={"cover"}
          rate={1.0}
          ignoreSilentSwitch={"obey"}
        />

        <Wrapper>
          <Logo
            source={require("./../assets/cadence-logo.png")}
            width={50}
            height={50}
            resizeMode="contain"
          />
          <Title>Join Live And on-demand classesTitle>
          <TextDescription>
            With world-class instructions right here, right now
          TextDescription>
          <ButtonWrapper>
            <Fragment>
              <Button title="Create Account" />
              <Button transparent title="Login" />
            Fragment>
          ButtonWrapper>
        Wrapper>
      View>
    );
  }
}

const styles = StyleSheet.create({
  backgroundVideo: {
    height: height,
    position: "absolute",
    top: 0,
    left: 0,
    alignItems: "stretch",
    bottom: 0,
    right: 0
  }
});

// styled-component

export const Wrapper = styled.View`
  justify-content: space-between;
  padding: 20px;
  align-items: center;
  flex-direction: column;
`;
export const Logo = styled.Image`
  max-width: 100px;
  width: 100px;
  height: 100px;
`;
export const TextDescription = styled.Text`
  letter-spacing: 3;
  color: #f4f4f4;
  text-align: center;
  text-transform: uppercase;
`;
export const ButtonWrapper = styled.View`
  justify-content: center;
  flex-direction: column;
  align-items: center;
  margin-top: 100px;
`;
export const Title = styled.Text`
  color: #f4f4f4;
  margin: 50% 0px 20px;
  font-size: 30;
  text-align: center;
  font-weight: bold;
  text-transform: uppercase;
  letter-spacing: 3;
`;
const StyledButton = styled.TouchableHighlight`
 width:250px;
 background-color:${props => (props.transparent ? "transparent" : "#f3f8ff")};
 padding:15px;
border:${props => (props.transparent ? "1px solid #f3f8ff " : 0)}
 justify-content:center;
 margin-bottom:20px;
 border-radius:24px
`;
StyledTitle = styled.Text`
  text-transform: uppercase;
  text-align: center;
  font-weight: bold;
  letter-spacing: 3;
  color: ${props => (props.transparent ? "#f3f8ff " : "#666")};
`;

export const Button = ({ onPress, color, ...props }) => {
  return (
    <StyledButton {...props}>
      <StyledTitle {...props}>{props.title}StyledTitle>
    StyledButton>
  );
};

Also, you can make this component reusable by doing the following:

<View>
<Video
source={require("./../assets/video1.mp4")}
style={styles.backgroundVideo}
muted={true}
repeat={true}
resizeMode={"cover"}
rate={1.0}
ignoreSilentSwitch={"obey"}
/>
{this.props.children}
View>

And you can use it with other components:

That’s pretty much it. Thank you for reading!

_Photo by [Unsplash](https://unsplash.com/photos/wQZSl60DGDM?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="_blank" title="">David Boca on Learn more about React Native: