Introduction
Python is one of the popular and general programming languages which is used in every domain.
Let's do a walkthrough on all the important aspects of this language, focusing more on the code snippets.
Compiler
Converting high-level language (Python code) to low-level language (Byte-code). One of the main advantages it does is syntax checks.
Variables
Python is a dynamic-typed language, so we can change the type of variable at a given point. For example:-
def main():
x = 20
print("First :", x)
x = "Twenty two"
print("Second :", x)
is_check = False
is_none = None
main()
"""
Output
First: 20
Second: Twenty two
"""
Some advanced data structures are as follows List | Set | Dict | Tuples.
- List, Sets and Dict are mutatable data-structure.
lst = [1, 2, 3, 5, 8]
unqiue_set = {2, 3, 2, 4}
new_dict = {"first": 1}
tu = (1, 2, 3)
Conditional statement
The main conditional keywords are if, elif and else.
def main():
x = 10
y = 20
z = "check"
if x and y or not y and x:
print("First")
elif c in z:
print("Second")
else:
print("Third")
Looping
Here we are using range function which would start from 0 to 4 in the below example.
def main():
count = 0
for i in range(0, 5):
count += 1
print(i)
while count < 10:
print(count)
count += 1
List Comprehension
lst = [i for i in range(1, 11) if i % 2 == 0]
Exceptions
def main():
try:
a = 10 / 0
except Exception as e:
print("Exception due to various logging: ", e)
finally:
print("Completion")
main()
Scope
x = 1
def main():
x = 0
print(x) # 0
main()
print(x) # 1
value = 0
def main():
# this is bad practice!!!
# asking compiler update value in the global level,
# basically this is best example of side-effect
global value
value = 5
print(value) # 0
main()
print(value) # 5
Sorting
lst = [2, 3,10, 5]
list.sort(reverse=True) # mutate the original list
sorted(list, reverse=True) # return sorted list
Modules and Packages
__name__ is a special variable that provides the current execution file like "__main__". The imported modules are not considered as main, only the one which is the entry point of execution.
# functions.py
def foo():
print("Foo")
# main.py
import functions as f
# OR `from functions import foo`
# OR `from functions import *` -> to access everything from the file, bad
# practice.
if __name__ == "__main__":
f.foo()
# code/__init__.py -> This file make it a package
print("Init")
# code/abc.py
print("ABC")
# code/def.py
print("DEF")
# main.py
import code.abc # this will print the Initi and then ABC once
if __name__ == "__main__":
print("main")
# code/__init__.py
import code.abc
import code.def
# code/abc.py
print("ABC")
# code/def.py
print("DEF")
# main.py
import code # prints both ABC and DEF once.
- If the file is in the same package we can use
from . import abc.
File
file = open("file.txt", "r") # reading mode
print(file.read())
file.close() # close the file always to keep memory leak
# OR
# context-manager `with`, it automatically close it.
with open("file.txt", "r") as file:
print(file.read())
readLine = file.readline() # create list of string spliting buy new-line
print(readLine)
print(readLine[0].strip()) # strip removes white-space and \n
when using w mode or known as write mode allows writing data in the file, One key thing to remember is when using this mode if the already exists then it would be overridden by the code.
a append mode adds the file cursor at the very last line of the file, and doesn't override. r+ mode reads + write. Using file.seek(0) moves the cursor to the beginning of the file.
Argument and Keyword arguments
Python provides a special operator to unlock unlimited arguments passing to a function.
def tail(*args, **kwargs):
print(args, kwargs)
tail([1, 2, 3], {"k": 2, "b": 3})
Lambda Functions
Inline functions or Arrow functions (coming from JS world), are used mostly with map or filter methods.
func = lambda x, y, z=0: x + y + z
print(func(1, 2))
lst = [1, 2, 3, 4, 5]
new_lst = map(lambda x: x**2, lst)
print(list(new_list))
filter_lst = filter(lambda y: y % 2 == 0, list)
Function closures
The function can be passed as an argument in another function (First call function).
def foo(x):
return x ** 2
def boo(func, y):
result = func(y)
return result
print(boo(foo, 12))
Iterator
Everything that can be looped over is iterators, like list .
x = [1, 2, 3]
x_iter = iter(x) # or x.__iter__() are the same things
print(next(x_iter)) # 1 or we can use like x_iter.__next__()
print(next(x_iter)) # 2
print(next(x_iter)) # 3
Creating custom iterators
class Numbers:
def __init__(self, num, num2, num3):
self.num = num
self.num2 = num2
self.num3 = num3
def __iter__(self):
return NumberIterator(self.num, self.num2, self.num3)
class NumberIterator:
def __init__(self, one, two, three):
self.one = one
self.two = two
self.three = three
self.current = 0
def __next__(self):
self.current += 1
if self.current == 1:
return self.one
elif self.current == 2:
return self.two
elif self.current == 3:
return self.three
else:
raise StopIteration
nums = Numbers(1,2, 3)
for val in nums:
print(value)
Generator
Same as the Iterator. Used in modern programming, iterators are more legacy ways of doing things.
def gen():
yield 1
yield 2
yield 3
itr = gen() # Generator object
next(itr) # 1
next(itr) # 2
next(itr) # 3
for i in itr:
print(i)
"""
Why this is optimal then regular fib, because in that case would have be required
to store it in the list which would keep track of all the data, while
in this way we are just concerned with last value.
"""
def fib(n):
last = 1
second_last = 1
current = 3
while current <= n:
num = last + second_last
yield num
second_last = last
last = num
current += 1
for i in fib(10):
print(i)
Threads and Processes
Process: This is just a program that is executed by the operating system.
Thread: It is what makes of process, it's part of the process, multiple threads make a process.
For example, if you have 6 cores then 6 processes or instructions can run at the same time in parallel.
There is a new tech called Hyper-threading, which is logical core and physical core. One physical core is broken into multiple logical cores which means every logical core is capable of executing instructions at the same time.
Global interpreter Lock
At a time only one thread would be using the interpreter, everything else would be locked. This is specific to Python, that's why you cannot have parallelism in Python. Lock <=> Mutex.
from threading import Thread, Lock
from time import sleep
def run(log_str, lock: Lock):
lock.acquire() # waiting mode
sleep(1)
print(log_str)
lock.release() # released mode
lock = Lock() # thread2 won't be executed until acquire is not released
thread1 = Thread(target=run, args=("run 1", lock))
thread2 = Thread(target=run, args=("run 2", lock))
# Execute the thread callback
thread1.start()
thread2.start()
Asynchronous Execution
From the later version of the python, we have the introduction of async in the language which provides a single-threaded concurrency approach to execution.
import asyncio
async def population():
await asyncio.sleep(1)
print("population")
async def main():
print("main") #1
await asyncio.sleep(2) #2 await is required in case of async
task = asyncio.create_task(population()) # will continue with next line of code
print("main end") #3
await task #4 wait until async is not completed
# this function is required in order to start the async entry point
asyncio.run(main())
Conclusion
As we conclude, may these insights foster a deeper appreciation for Python's capabilities, propelling developers into a world where their imaginations become the blueprint for innovation.