April 1, 2022 by Phu Nguyen

# The complete guide for Python and Django-Part1 Python – 2022 The complete guide for Python and Django-Part1 Python – is an article many of you are most interested in today !! Today, let’s InApps.net learn The complete guide for Python and Django-Part1 Python – in today’s post !

## Read more about The complete guide for Python and Django-Part1 Python – at Wikipedia

You can find content about The complete guide for Python and Django-Part1 Python – from the Wikipedia website

Note: In this tutorial, we will be using Python3 instead of Python2. The reason for this choice is that Python2 is slowly getting deprecated from the development world and the developers are developing new libraries strictly for the use with Python3.

Starting with Python3

Content:

1. Installation
2. DataTypes
3. Comparison operators
4. Control flow:
1. IF ELIF and ELSE statements
2. WHILE
3. FOR loop statements
5. Functions
6. Object-Oriented Programming
1. Installations:

Mac installation: https://docs.python-guide.org/starting/install3/osx/

Linux Installation: https://docs.python-guide.org/starting/install3/linux/

Windows Installation: https://docs.python.org/3/using/windows.html#installation-steps

In Python 3, there is effectively no limit to how long an integer value can be. Of course, it is constrained by the amount of memory your system has, as are all things, but beyond that an integer can be as long as you need it to be:

``a = 123123123123123123123123123123123123123``

Notice that we don’t have to specify the type of the variable ‘a’ in the above code. type of the variable will be dynamically handled by python on the basis of the value being stored in the variable.

Floating Point:

The `float` type in Python designates a floating-point number. `float` values are specified with a decimal point. Optionally, the character `e` or `E` followed by a positive or negative integer may be appended to specific scientific notation:

``````a=2.513
print( type(a) )``````

In the above code, the last line will print ‘float’ , which is the type of variable ‘a’.

Complex:

We need to import “cmath” to use this data type.

Let us look at the code below and try to understand how it works.

``````#importing cmath
import cmath

#initialising the variable 'z' with the value '2+3i'
z=complex(2,3)

#accessing the real part of variable 'z'
print("real part of z is: " + ,end="")
print(z.real)

#accessing the imag part of 'z'
print("imaginary part of z is: " + ,end="")
print(z.imag)

``````

Sets:

Sets represent the mathematical notion of sets. Sets are mutable, iterable and don’t have any duplicate value. Python provides us, along with ‘set’ datatype, the mathematical functions associated with the sets such as intersection, union, difference, etc.

Let us look at the following code to understand the sets better.

``````#creating a set 'mySet' with values 1, 2 , and 3
mySet = set([1, 2, 3])

print("mySet")
print(mySet)

#creating another set with the name 'anotherSet'
anotherSet = set([3,4,5])

union_of_sets = mySet.union(anotherSet)

#this will print {1, 2, 3, 4 ,5 ,6}
print(union_of_sets)

intersection_of_sets = mySet.intersect(anotherSet)

#this will print the set {3}
print(intersection_of_sets)

difference_of_two_sets = mySet.difference(anotherSet)

#this will print {1, 2 , 6}
print(difference_of_sets)

``````

Dictionary:

In Python, a Dictionary can be created by placing a sequence of elements within curly {} braces, separated by ‘comma’. Dictionary holds a pair of values, one being the Key and the other corresponding pair element being its `Key:value`. Values in a dictionary can be of any datatype and can be duplicated, whereas keys can’t be repeated and must be immutable.

``````# Creating an empty Dictionary
Dict = {}
print("Empty Dictionary: ")
print(Dict)

# Adding elements into the dictionary
Dict = 'alpha'
Dict = 1

#this will print { 2: 'alpha'  , 3: 1}
print(Dict)

# Updating existing Key's Value
Dict = 'Welcome'

the following line will print { 2: 'welcome'  , 3: 1}
print(Dict)

# Adding Nested Key value to Dictionary
Dict = {'Nested' :{'1' : 'Life', '2' : 'Geeks'}}
print(Dict) ``````

List:

Read More:   Choose Best Game Engine in 2022

A list is created by placing all the items (elements) inside a square bracket [ ], separated by commas.

It can have any number of items and they may be of different types (integer, float, string etc).

``````
# creating a empty list
my_list = []

my_list = [1, 2, 3]

#overwriting the privious list [1 , 2 ,3 ] with the new list [1,"Hello",3.4]
my_list = [1, "Hello", 3.4]

my_list.append(5)

#now the new list is [1,"Hello",3.4, 5]
print (my_list)

my_list = ['a','b','c','d','e']

# Output: e
print(my_list[-1])

# Output: a
print(my_list[-5])``````

Negative indexing:

Tuple:

A tuple in Python is similar to a list. The difference between the two is that we cannot change the elements of a tuple once it is assigned whereas, in a list, elements can be changed. In other words, tuples are immutable.

A tuple is created by placing all the items (elements) inside parentheses(), separated by commas. The parentheses are optional, however, it is a good practice to use them.

A tuple can have any number of items and they may be of different types (integer, float, list, string, etc.). Let us look at the following code to understand tuples in a better way:

``````# Empty tuple
myTuple = ()
print(myTuple)  # Output: ()

# Tuple having integers
myTuple = (1, 2, 3)
print(myTuple)  # Output: (1, 2, 3)

# tuple with mixed datatypes
myTuple = (1, "Hello", 3.4)
print(myTuple)  # Output: (1, "Hello", 3.4)

# nested tuple
myTuple = ("mouse", [8, 4, 6], (1, 2, 3))

# Output: ("mouse", [8, 4, 6], (1, 2, 3))
print(myTuple)``````

A tuple can also be created without using parentheses. This is known as tuple packing. For instance:

``````my_tuple = "Hello", 1.2, 6
print(my_tuple)   # Output: "hello", 1.2, 6 ``````

Tuple unpacking is also possible

``````my_tuple = "Hello", 1.2, 6

# unpacking the tuple
a, b, c = my_tuple

print(a)      # 3
print(b)      # 4.6
print(c)      # dog ``````

Strings:

Strings are arrays of bytes representing Unicode characters. However, Python does not have a character data type, a single character is simply a string with a length of 1. Square brackets can be used to access elements of the string.

Slicing in a string:

``````String1 = "PythonIsFun"

print(String1)

# Printing 3rd to 12th character  using slicing
print("nSlicing characters from 3-12: ")
print(String1[3:12])

# Printing characters between
# 3rd and 2nd last character
print("nSlicing characters between " +
"3rd and 2nd last character: ")
print(String1[3:-2]) ``````

Boolean

The bool() method is used to return or convert a value to a Boolean value i.e., True or False, using the standard truth testing procedure.

``````x=1
y=2
z=bool(x==y) #this statement will assign False to z as x is not equal to y

x=True
print( bool(x)) #this statement will print 'True' as x is true

x=None
print( bool(x)) #this statement will print 'False' as x is None

x={}
print( bool(x)) #this statement will print 'False' as x is None``````
``````#using bool() to find if the number is less than 5 or not
num=7
if(bool(num<5)):
print('num is less than 5')
else:
print('num is not less than 5')``````

3. Comparison Operator/Relational Operators

Comparison operators are used to compare the two values and establish a relationship between them. The expression always evaluates to True or False.

These are the following types of comparison operators used in Python3:

• == (equal to)
• != (not equal to)
• < (less than)
• > (greater than)
• >= (greater than or equal to)
• <= (less than or equal to)
```a = 21
b = 10

# '==' operator
if ( a == b ):
print ("a is equal to b")
else:
print ("a is not equal to b")

# '!=' operator
if ( a != b ):
print ("a is not equal to b")
else:
print ("a is equal to b")

# '<' operator
if ( a < b ):
print ("a is less than b" )
else:
print ("a is not less than b")

# '>' operator
if ( a > b ):
print ("a is greater than b")
else:
print ("a is not greater than b")

#swapping of values
a,b = b,a

# '<=' operator
if ( a <= b ):
print ("a is either less than or equal to  b")
else:
print ("a is neither less than nor equal to  b")

# '>=' opeartor
if ( b >= a ):
print ("b is either greater than  or equal to b")
else:
print ("b is neither greater than  nor equal to b")```

4. Control Flow

Read More:   Top 12 React Dev Tools For 2022

(a) IF ELIF ELSE

Syntax:

``````if expression:
statement(s)
elif expression:
statement(s)
else:
statement(s)``````

We can add as many elif as we want in-between if and else block. The count of elif blocks can also be zero. In that case, the else block will immediately follow the if block.

The following code illustrates the use of if elif and else

``````amount = int(input("Enter amount: "))

if amount<1000:
discount = amount*0.05
print ("Discount",discount)
elif amount<5000:
discount = amount*0.10
print ("Discount",discount)
else:
discount = amount*0.15
print ("Discount",discount)

print ("Net payable:",amount-discount)``````

Output:

``````Enter amount: 3000
Discount 300.0
Net payable: 2700.0``````

(b) WHILE LOOP

In Python, `while` loops are constructed like so:

``````while [a condition is True]:
[do something]``````

The something that is being done will continue to be executed until the condition that is being assessed is no longer true.

Here is the code to illustrate the use of a while loop:

``````count = 0
while (count < 3):
print(count)
count = count + 1``````

Output:

``````0
1
2``````

(c) FOR LOOP

Syntax:

```for iterator_var in sequence:
statements(s)```

Let us look at the following code to see understand the for loop better:

``````s = "HelloWorld"
for i in s :
print(i) ``````

Output:

``````H
e
l
l
o
W
o
r
l
d``````

Here is another piece of code to traverse the dictionary

``````print("nDictionary traversal")
d = dict()
d['first'] = 100
d['second'] = 200
for i in d :
print("%s  %d" %(i, d[i]))``````

Output:

```first  100
second  200```

5. Functions

A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing.

Here is a syntax to declare a function:

``````def function_name( parameters ):
#some statements
return [expression] #the return statement is optional``````

For example, let us create a simple function which computes the sum of two values which are passed to it (as a parameter). We will name that function ‘sum’.

``````def sum(x , y):
ans=x+y
return ans``````

Calling the defined function

We can call the defined function, like the above , as follows:

``````result = sum(4, 5) # the function 'sum' will return 9 which will be stored in
# the variable 'result'
print(result)      # this statement will print '9'``````

Output:

``9``

6. Object-Oriented Programming / OOP

To understand OOP, we need to understand what is class and object.

Classes are like a blueprint or a prototype that you can define to use to create object.

We define classes by using the `class` keyword, similar to how we define functions by using the `def` keyword.

Read More:   How To Create A Design Proposal According To User Needs - 2022

Syntax:

``````class Class_name:
# statements to define data members and methods of this class ``````

Let us create an empty class ‘Person’ for now.

``````class Person():
pass``````

Important terms related to Class:

• The Constructor Method: This is the method that executes first when we create a new instance of that class. We always have to name this function as ‘__init__‘.
``````class Person():
def __init__(self):
print('This is the constructor method')``````
• Self: The argument to the __intit__ () functions is the keyword ‘`self`‘, which is a reference to objects that are made based on this class. To reference instances (or objects) of the class, `self` will always be the first parameter, but it need not be the only one.
• Methods: Method is a special kind of function that is defined within a class. A class can have any number of methods. __init__() is also one of the methods.
• Attributes: Attributes are data stored inside a class or instance and represent the state or quality of the class or instance. In short, attributes store information about the instance.

Let us add two attributes ‘name’ and ‘age’ to our class ‘Person’. We can do that using the __init__() function. Here is the code:

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

Now, as the __init__() function is receiving ‘name’ and ‘age’ attribute, it becomes compulsory to pass the name and age while creating the instance /object ‘Person’ object. This is how we can create an object of class Person

``````#Creating the Person 'p' with the name 'Susan' and age 22
p=Person('Susan' , 22)
print(p.name)
print(p.age)``````

As we can notice from the above code, we can access the attributes associated with the object using the . operator.

Let us now add a method to our class ‘Person’ which increments the age of that person by one.

We will call that method ‘IncreaseAge()’.

``````class Person():
def __init__(self, name , age):
self.name=name
self.age=age
def IncrementAge(self ):
self.age= self.age+1;

p=Person('Susan' , 22)
print('The age before calling the method IncrementAge')
print(p.age)

print('The age after calling the method IncrementAge')
p.IncrementAge();
print(p.age)``````

Output:

``````The age before calling the method IncrementAge
22
The age after calling the method IncrementAge
23``````

Inheritance in classes

Inheritance is one of the mechanisms to achieve the same. In inheritance, a class (usually called superclass or Base Class) is inherited by another class (usually called subclass or Derived Class). The subclass adds some attributes to a superclass.

Let us understand it by extending our Person class by creating a Student class. A student is also a person with a name and the age but also has some additional properties such as roll number.

So basically, the Student class will inherit the ‘name’ and ‘age’ attribute from its base class which is Person.

This is the code to illustrate the concept of inheritance:

``````class Person():
def __init__(self, name , age):
self.name=name
self.age=age
def IncrementAge(self ):
self.age= self.age+1;

#the Student class inherits the Person class
class Student(Person):
def __init__(self,name , age ,RollNo ):
Person.__init__(self , name , age)
self.rollNumber= RollNo

print("student's information")

print(s.rollNumber)
print(s.name)
print(s.age)
s.IncrementAge()
print(s.age)
``````

Output:

``````student's information
123
10
11
``````

Notice that, the Student class has acquired the ‘name’ and ‘age’ property from the Person class. The ‘IncrementAge()‘ method can also be used with the Student object.

Source: InApps.net

## List of Keywords users find our article on Google:

 python django 2022- a complete guide python django 2022 – a complete guide django 2022 python
Rate this post

### Let’s create the next big thing together!

Coming together is a beginning. Keeping together is progress. Working together is success.

Let’s talk

## Recommended

September 23, 2023 by Julie Nguyen

## A Detailed Guide to Outsourcing Mobile App Development Successfully in 2023 (Part II)

July 14, 2023 by Phu Nguyen

## Mobile App UX Design: A Quick Introduction (2023)

June 27, 2023 by Phu Nguyen

## 9 Practical Tips to Choose a Mobile App Development Company for 2023

June 24, 2023 by Phu Nguyen

## Future of Mobile App Development: AI-driven Trends and Technologies

February 10, 2023 by Phu Nguyen

## How much does app development cost?

January 31, 2023 by Tam Ho

## App Builder Vs Mobile App Development Company – Which’s better?

December 22, 2022 by Phu Nguyen

## How To Learn Android Programming – Step By Step in 2023

December 21, 2022 by Phu Nguyen

## How to Develop Android App With Python – Best Tool and IDEs Recommendation

December 14, 2022 by Phu Nguyen

## Flutter vs React Native For App Development – Which one to choose?

October 27, 2022 by Phu Nguyen

## Learn Android App Development – How to start?

### Get a custom Proposal

`Success. Downloading...`