Python Blog

Amazon links to buy - Amazon affliate

2020-09-11T12:50:00.003+05:30

Rokali from kitchen

NumPy Quick tutorial - Letsprogram

2020-07-08T11:57:00.003+05:30

NumPy’s main object is the homogeneous multidimensional array. It is a table of elements (usually numbers), all of the same type, indexed by a tuple of non-negative integers. In NumPy, dimensions are called axes.

For example, you can create an array from a regular Python list or tuple using the array function. The type of the resulting array is deduced from the type of the elements in the sequences.

>>>import numpy as np

>>> a = np.array([1,2,3,4])

>>>a

array([1,2,3,4])

>>>a.dtype

dtype('int64')

>>>b = np.array([1.2,2.4,3.6,7.8])

>>>b

array([1.2,2.4,3.6,7.8])

>>>b.dtype

dtype("float64")

You can change the datatype of b array as int while declaring the b array.

You can know the dimension of the array by using the shape attribute and also you can change the dimension by using the reshape method in NumPy.

When you want an array with all zeroes or all ones then you can use the method zeroes and ones.

>>> a = np.zeroes(4,dtype=float)

>>> b = np.ones(5,dtype=int)

>>>b

array([1,1,1,1,1])

>>>a

array([0.,0.,0.,0.])

Creating an array, shaping, and reshaping the array and operations on the array like transpose of the array, concatenate and array mathematics.

You can see a few examples in the file: NumPy Quick tutorial

How to plot the data by using pandas? - Letsprogram

2020-06-25T23:13:00.002+05:30

If we have large data we cannot analyze each and every value so we calculate the average of the total data. To know how data is changing like increase or decrease we have to plot a graph to understand it and again you cannot plot the whole data. pandas provides plotting your data out of the box, using the power of Matplotlib. You can pick the plot type (scatter, bar, boxplot,…) corresponding to your data.

In [1]: import pandas as pd
In [2]: import matplotlib.pyplot as plt

Data used for this tutorial :

For this tutorial, air quality data about NO2 is used, made available by openaq, and using the py-openaq package. The air_quality_no2.csv data set provides NO2 values for the measurement stations FR04014, BETR801, and London Westminster in respectively Paris, Antwerp, and London. Download the data by clicking the button Link Button

Now we have the data we should plot the data now.To have a quick visual check data

>>>air_quality.plot()
<matplotlib.axes._subplots.AxesSubplot at 0x7fbbf7dced30>

We now not used Matplotlib module by default pandas DataFrame will create a plot for each of the columns with the numeric data.

>>>air_quality["station_paris"].plot()

<matplotlib.axes._subplots.AxesSubplot at 0x7fbbf7dced30>

Till now the plots are made by the pandas module. To do these basic plotting you can use pandas plot method.

I want to visually compare the $N 0_{2}$ values measured in London versus Paris.

In [7]: air_quality.plot.scatter(x="station_london",
   ...:                          y="station_paris",
   ...:                          alpha=0.5)
   ...: 
Out[7]: <matplotlib.axes._subplots.AxesSubplot at 0x7f534481f710>

Apart from the default line the plot when using the plot function, a number of alternatives are available to plot data. Let’s use some standard Python to get an overview of the available plot methods:

In [8]: [method_name for method_name in dir(air_quality.plot)
   ...:     if not method_name.startswith("_")]
   ...: 
Out[8]: 
['area',
 'bar',
 'barh',
 'box',
 'density',
 'hexbin',
 'hist',
 'kde',
 'line',
 'pie',
 'scatter']

Note

In many development environments as well as ipython and jupyter notebook, use the TAB button to get an overview of the available methods, for example air_quality.plot. + TAB.

One of the options is DataFrame.plot.box(), which refers to a boxplot. The box method is applicable on the air quality example data:

In [9]: air_quality.plot.box()
Out[9]: <matplotlib.axes._subplots.AxesSubplot at 0x7f5344381810>

To user guide

For an introduction to plots other than the default line plot, see the user guide section about supported plot styles.

I want each of the columns in a separate subplot.
```
In [10]: axs = air_quality.plot.area(figsize=(12, 4), subplots=True)
```
Separate subplots for each of the data columns is supported by the subplots argument of the plot functions. The builtin options available in each of the pandas plot functions that are worthwhile to have a look.

To user guide

Some more formatting options are explained in the user guide section on plot formatting.

I want to further customize, extend or save the resulting plot.

In [11]: fig, axs = plt.subplots(figsize=(12, 4));

In [12]: air_quality.plot.area(ax=axs);

In [13]: axs.set_ylabel("NO$_2$ concentration");

In [14]: fig.savefig("no2_concentrations.png")

Each of the plot objects created by pandas are a matplotlib object. As Matplotlib provides plenty of options to customize plots, making the link between pandas and Matplotlib explicit enables all the power of matplotlib to the plot. This strategy is applied in the previous example:

fig, axs = plt.subplots(figsize=(12, 4))        # Create an empty matplotlib Figure and Axes
air_quality.plot.area(ax=axs)                   # Use pandas to put the area plot on the prepared Figure/Axes
axs.set_ylabel("NO$_2$ concentration")          # Do any matplotlib customization you like
fig.savefig("no2_concentrations.png")           # Save the Figure/Axes using the existing matplotlib method.

REMEMBER

The .plot.* methods are applicable on both Series and DataFrames
By default, each of the columns is plotted as a different element (line, boxplot,…)
Any plot created by pandas is a Matplotlib object.

Getting started with Pandas - Letsprogram

2020-06-14T11:00:00.001+05:30

Before you use pandas install it in your PC depending on your environment you are working. If you are using anaconda or miniconda use conda install pandas in the respective interpreter. If you use normal python IDE the download and install pandas using pip by the command pip install pandas. If you had any difficulties in installing the pandas check this link: installing pandas.

After installing it in your PC import the pandas package into your program or interpreter.

>>>import pandas as pd

pd is just an alias for pandas instead of typing the whole name and it is assumed as a standard practice.

pandas is a fast, powerful, flexible, and easy to use open-source data analysis and manipulation tool, built on top of the Python programming language.

we now know that pandas is a data manipulation tool but the question is

what kind of data do pandas handle?

When working with tabular data, such as data stored in spreadsheets or databases, Pandas is the right tool for you. Pandas will help you to explore, clean, and process your data. In Pandas, a data table is called a DataFrame.

Pandas DataFrame Representation

I want to store the data of some movies I know the name of the movie, year released, and director.

When using the Python dictionary here keys will be used as columns and values will be used as rows of the data frame.

When selecting the single column from the pandas DataFrame the result will be Series. The selecting of a single column from the python dictionary is the same as the pandas DataFrame here.

You can create a single column or Series from first.

>>>ages=pd.Series([19,16,32,29],name="age")

>>>ages

0 19

1 16

2 32

3 29

Name: age, dtype: int64

We stored the movie's information in df to get the lasted movie from all the collection of movies in the data we need to do something on the DataFrame.

>>>df["year"].max( )

2008

The latest movie was released in the year 2008. Not only max pandas will also provide you many functionalities.

If you need basic statistics of a numerical table in the DataFrame use describe( ) method. df.describe( )

Note

This is just a starting point. Similar to spreadsheet software, pandas represent data as a table with columns and rows. Apart from the representation, also the data manipulations and calculations you would do in spreadsheet software are supported by pandas. Continue reading the next tutorials to get started!

How to read and write data

I had a CSV file with data I had to read it to pandas DataFrame. pandas gave read_csv( ) method to the operations on the file. pandas also support the other file formats like SQL, Excel, JSON, etc. each have a method with the prefix

read_*( )

If you want to read first n columns use the head( ) method or to read last n columns use tail( ) method. The code written in the above program requires a titanic.csv file. Download the titanic.csv file.

You can get the datatypes details of all Series in the DataFrame by the attribute dtypes in the pandas.

You read the data from a CSV file to pandas DataFrames now you have to extract the data as your useful format. While read_*( ) methods read the data to_*( ) extract the data from the pandas. To know more about the reading and writing methods check this link: pandas_methods.

>>>titanic.to_excel('titianic.xlsv', sheet_name="passengers")

>>> titanic.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB

If you want to know more than datatypes then we use info( ) method on the DataFrame. It provides you index value, Exact RAM used to hold the DataFrame as well. We can know the missing value numbers in the File. The info method is used to know the technical information about the data.

Get paid to share your links!

Modules in Python - Letsprogram

2020-06-11T11:44:00.002+05:30

We use functions to decrease the number of lines in the program and of course reusability. But any functions can be used in the same program but not outside. If you quit your interpreter the definitions you made are lost. Therefore, if you want to write a somewhat longer program, you are better off using a text editor to prepare the input for the interpreter and running it with that file as input instead. This is known as creating a script.

Generally, developers handling with larger programs will split into multiple files for easy use. And also to use a function in another file instead of copying several times into each program we use scripting.

Python support this it has a way to put functions or definitions in an interactive instance of an interpreter called a module. We all know we import some modules into our programs by importing that module means we are importing some definitions which make our work fast and easier. Python has many modules.

The module is just a normal python file like any other with ends with .py extension. modules name is available for the value of global variable __name__.

>>>import pandas as p

>>>p.__name__

'pandas'

Create a file named prime.py in the current directory you are working and enter the following codes.

Now enter the Python interpreter and import this module with the following command:

>>>import prime.py

Now you had imported the definitions written in the prime.py file into your program without using the function names.

>>>prime.PRIME(3)

'prime'

>>>prime.evenodd(2)

'even'

prime.__name__

'prime'

If you use any function many times in your program you can change the name by

>>>even = prime.evenodd

>>>even(3)

'odd'

A module can contain executable statements as well as function definitions. These statements are intended to initialize the module. They are executed only the first time the module name is encountered in an import statement. (They are also run if the file is executed as a script.)

Each module has its own private symbol table, which is used as the global symbol table by all functions defined in the module. Thus, the author of a module can use global variables in the module without worrying about accidental clashes with a user’s global variables. On the other hand, if you know what you are doing you can touch a module’s global variables with the same notation used to refer to its functions, modname.itemname.

Modules can import other modules. It is customary but not required to place all import statements at the beginning of a module (or script, for that matter). The imported module names are placed in the importing module’s global symbol table.

There is an another way to import all the definitions from the module.

>>>from pandas import *

This imports all the names except those starting with _. In most cases, programmers don't use those functions.

Note that in general the practice of importing * from a module or package is frowned upon since it often causes poorly readable code. However, it is okay to use it to save typing in interactive sessions.

Sometimes we do not require every definition in the module if we imported very large modules which means your program has many statements to run which may decrease your program efficiency. so, to avoid that there is another way to import a module.

For efficiency reasons, each module is only imported once per interpreter session. Therefore, if you change your modules, you must restart the interpreter – or, if it’s just one module you want to test interactively, use importlib.reload(), e.g. import importlib; importlib.reload(modulename).

>>>from pandas import Series

>>>from pandas import DataFrame as df

When a module prime is imported then python interpreter searches in the built-in modules first then it checks a file name prime.py in a list of directories given by sys.path. The directories like current, default, or directory names with the same syntax as shell variable path.

To load a module speedily python caches the module in __pycache__ directory under the named module.version.pyc where the version indicates the format of the compiled file. For Example, base_embed.cpython-38.pyc is the compiled file to load the modules fastly. __pycache__ is available in the \Python38Lib\site-packages\ in this place.

Python checks the modification date of the source against the compiled version to see if it’s out of date and needs to be recompiled. This is a completely automatic process. Also, the compiled modules are platform-independent, so the same library can be shared among systems with different architectures.

Python does not check the cache in two circumstances. First, it always recompiles and does not store the result for the module that’s loaded directly from the command line. Second, it does not check the cache if there is no source module. To support a non-source (compiled only) distribution, the compiled module must be in the source directory, and there must not be a source module.

We discussed some of the standard modules in previous posts. The virtual environment is also discussed in the previous posts

To use a module we need to know the functions or statements in that module. To know that use dir( ) built-in function which gives you the name of all the strings. import the module into your interpreter and use dir(modulename) to get all the methods. This is not only for modules and you can know about any object by using this function.

Packages are the way of structuring the Python's module namespace by using the dotted module names.

Here is a possible structure for a package.

Data Structures in Python - Letsprogram

2020-06-08T10:06:00.001+05:30

This post discusses some things you have learned about already in more detail and adds some new things as well.

Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple. List, the range is also the sequence data types. For data structures use sequence data types. Sets and dictionary are also sequence data types.

Lists

The list is a versatile data type and can be changed if you apply operations on it because the list is a mutable object.

Here are some methods of list-objects.

list.append(x)

Add an item to the end of a list. You can also add the element by

>>> a[len(a):] = [x]

We discussed this kind of operation in the previous post of lists.

list.insert(i,x)

Adding an element x at i ^th position. i is the index of the list, list.insert(0,x) means inserting the element x at first place. list.insert(len(a),x) means same as list.append(x).

list.remove(x)

It will remove the first item with value x and raises the ValueError if there is no such value in the list.

list.pop([i])

Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.). The statement del can also pop the last element from the list.

>>>del a[len(a)]

list.clear()

Removes all the elements from the list. same as del a[:].The del statement can also be used to remove slices from a list or clear the entire list (which we did earlier by assignment of an empty list to the slice).

>>>del a[2:4]

>>>del a #clears all the list

list.count(x)

Counts number of times x value is repeated in the list.

list.sort(key=None,reverse=False)

Sort the items of the list in place. There is a sorted() method that takes the list as an argument.

list.reverse()

Reverses the elements in the list.

list.copy()

Returns a shallow copy of the list. Equivalent to a[ : ]

You can use a list as stacks. It is also possible to use a list as a queue, where the first element added is the first element retrieved (“first-in, first-out”); however, lists are not efficient for this purpose. While appends and pops from the end of the list are fast, doing inserts or pops from the beginning of a list is slow (because all of the other elements have to be shifted by one).

To implement a queue use collections.deque which was designed for fast appends and pops.

List Comprehensions

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable or to create a subsequence of those elements that satisfy a certain condition.

>>>squares=[ ]

>>>for x in range(10):

squares.append(x*x)

>>>squares

[0,1,4,9,16,25,36,49,64,81]

Note that this creates (or overwrites) a variable named x that still exists after the loop completes. We can calculate the list of squares without any side effects using:

>>>squares=[x**2 for x in range(10) ]

>>>squares=list(map(lambda x : x**2 range(10)))

A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses that follow it.

List Comprehensions can have complex expressions and nested functions. We can also use nested list comprehensions.

Tuples

As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression). It is not possible to assign to the individual items of a tuple, however, it is possible to create tuples that contain mutable objects, such as lists.

Though tuples may seem similar to lists, they are often used in different situations and for different purposes. Tuples are immutable, and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of namedtuples). Lists are mutable, and their elements are usually homogeneous and are accessed by iterating over the list.

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective.

>>>empty = ( )

>>>singleton = 'Python',

>>>len(empty)

>>>len(singleton)

In above code, singleton tuple takes python value into it but observes there is a comma when defining the tuple.

The statement t = 12345, 54321, 'hello!' is an example of tuple packing: the values 12345, 54321 and 'hello!' are packed together in a tuple. The reverse operation is also possible

>>>x, y, z = t

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignments is really just a combination of tuple packing and sequence unpacking.

Sets

Python also includes a data type for sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Curly braces or the set() function can be used to create sets. Note: To create an empty set you have to use, not {};

Similarly to list comprehension, set comprehension is also possible.

Dictionary

Another useful data type built into Python is the dictionary. Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys since lists can be modified in place using index assignments, slice assignments, or methods like append() and extend().

It is best to think of a dictionary as a set of key: value pairs, with the requirement that the keys are unique (within one dictionary). A pair of braces creates an empty dictionary: {}. Placing a comma-separated list of key: value pairs within the braces add initial key: value pairs to the dictionary; this is also the way dictionaries are written on output.

The main operations on a dictionary are storing a value with some key and extracting the value given the key. It is also possible to delete a key: value pair with del. If you store using a key that is already in use, the old value associated with that key is forgotten. It is an error to extract a value using a non-existent key.

Performing list(d) on a dictionary returns a list of all the keys used in the dictionary, in insertion order (if you want it sorted, just use sorted(d) instead). To check whether a single key is in the dictionary, use the in keyword.

dict() constructor is used to create a dictionary directly from key-value pairs. In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions. When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments

Difference between Shallow Copy and Deep Copy - LetsProgram

2020-06-06T12:52:00.004+05:30

Before discussing the types of copying first we have to discuss the memory occupied by the datatypes in the system. We know that integer occupies 4 bytes, string occupies 4 bytes and float occupies 8 bytes. But what will python do when we have the same value stored with different variables will it allocate two spaces in the memory. id(variable_name) will give the number allocated to memory in the system.

>>>x = 3

>>>y = x

>>>print(id(x),id(y))

140709828469200 140709828469200

The output id's of x and y are the same which means x and y are allocated in the same space. Python not created a different memory location for the new variable y which has the same value as x.However, unlike "real" pointer like those in C and C++, things change, when we assign a new value to y. In these cases, y will receive a separate memory location.

In python, assignment operations will not create a new object but they create a link between the variable and the object. When = operation is used user thinks a new object is created but it only creates a new variable that shares the reference of the original object. Sometimes, the user will work with the list (mutable objects) he will do many operations to it. sometimes a user wants copies that users can modify without automatically modifying the original at the same time, in order to do that we create copies of objects.

This module does not copy types like module, method, stack trace, the stack frame, file, socket, window, array, or any similar types. It does “copy” functions and classes (shallow and deeply), by returning the original object unchanged;

In python, there are two ways to copy.

Deep Copy
Shallow Copy

Deep Copy

In a deep copy, an object is copied into another object. It means that any changes made to the copy of the object are not observed in the original object. In python deep copy is done by using deepcopy() method from the copy module.

>>>copy.deepcopy(x[,memo])

will return the deep copy of x

>>>import copy

>>>list1 = [ 1,2,3]

>>>list2 = copy.deepcopy(list1)

>>>print(id(list1) , id(list2))

2638568131392 2638561816448

A deep copy constructs a new object and then insert the copies of

original into the new object recursively.

Two problems often exist with deep copy operations that don’t exist with shallow

copy operations:

Recursive objects (compound objects that, directly or indirectly, contain a reference to themselves) may cause a recursive loop.
Because deep copy copies everything it may copy too much, such as data that is intended to be shared between copies.

The deepcopy() function avoids these problems by:

keeping a memo dictionary of objects already copied during the current copying pass; and
letting user-defined classes override the copying operation or the set of components copied

When we change the copy of the original object there will be no change in the original object.

Shallow Copy

A shallow copy means creating a new object and connecting the references with the original object. The copying process does not recurse and therefore won’t create copies of the child objects themselves. In the case of shallow copy, a reference of the object is copied in other objects. It means that any changes made to a copy of the object do reflect in the original object. In python, this is implemented using the “copy()” function.

>>>copy.copy(x)

This will return the shallow copy of x

>>>import copy

>>>list1 = [1,2,3,4,5]

>>>list2 = copy.copy(list1)

>>> print(id(list1),id(list2))

3027379129216 3027372888128

Even both the original and new objects are referring to the same values but the id's of both objects are different. This tells us both the objects are occupying different spaces in the memory.

The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):

A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.
A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

RegEx in Python - Letsprogram

2020-06-02T11:31:00.002+05:30

Regular expressions (called REs, or regexes, or regex patterns) are essentially a tiny, highly specialized programming language embedded inside Python and made available through the re module. Using this little language, you specify the rules for the set of possible strings that you want to match; this set might contain English sentences, or e-mail addresses, or TeX commands, or anything you like. You can then ask questions such as “Does this string match the pattern?”, or “Is there a match for the pattern anywhere in this string?”. You can also use REs to modify a string or to split it apart in various ways.

A RegEx or Regular Expression is a sequence of characters to search for a pattern.

RegEx is used to check if a string had any specified pattern in it.

Python had a RegEx module called re which is used to work for regular Expressions. Import the re module into the python.

>>>import re

Regex Functions

re module had a set of functions that deal with regular expressions.

Function	Description
findall	Returns a list containing all the matches.
search	Returns a Match object if there is any match in the string.
split	Returns a list where the string has been split at every match.
sub	Replaces one or many strings.
finditer	Find all substrings where the RE matches and returns them as an Iterator
match	Determine if the RE matches at the beginning of the string.

MetaCharacters

MetaCharacters are the characters that have special meaning in the RegEx.

Character	Description	Example
[ ]	A set of characters	"[a-m]"
\	Signals a special sequence (can also be used to escape special characters)	"\d"
.	Any character (except newline character)	"he..o"
^	Starts with	"^hello"
$	Ends with	"world$"
*	Zero or more occurrences	"aix*"
+	One or more occurrences	"aix+"
{ }	Exactly the specified number of occurrences	"al{2}"
\|	Either or	"falls\|stays"
( )	Capture and Group

The first metacharacters we’ll look at are `[` and `]`. They’re used for specifying a character class, which is a set of characters that you wish to match. Characters can be listed individually, or a range of characters can be indicated by giving two characters and separating them by a `'-'`. For example, `[abc]` will match any of the characters `a`, `b`, or `c`; this is the same as `[a-c]`, which uses a range to express the same set of characters. If you wanted to match only lowercase letters, your RE would be `[a-z]`.
Metacharacters are not active inside classes. For example, `[akm$]` will match any of the characters `'a'`, `'k'`, `'m'`, or `'$'`; `'$'` is usually a metacharacter, but inside a character class, it’s stripped of its special nature.
You can match the characters not listed within the class by complementing the set. This is indicated by including a `'^'` as the first character of the class. For example, `[^5]` will match any character except `'5'`. If the caret appears elsewhere in a character class, it does not have special meaning. For example: `[5^]` will match either a `'5'` or a `'^'`.
Perhaps the most important metacharacter is the backslash, `\`. As in Python string literals, the backslash can be followed by various characters to signal various special sequences. It’s also used to escape all the metacharacters so you can still match them in patterns; for example, if you need to match a `[` or `\`, you can precede them with a backslash to remove their special meaning: `\[` or `\\`.
Some of the special sequences beginning with `'\'` represent predefined sets of characters that are often useful, such as the set of digits, the set of letters, or the set of anything that isn’t whitespace.
Regular expressions are compiled into pattern objects, which have methods for various operations such as searching for pattern matches or performing string substitute. `re.compile()` also accepts an optional flags argument, used to enable various special features and syntax variations. We’ll go over the available settings later, but for now, a single example will do:
>>>p=re.compile('ab*',re.IGNORECASE)

Special Sequence

A special sequence is \ followed by one of the characters below. Which have a special meaning to it.

Char	Description	Example
\A	Returns a match if the specified characters are at the beginning of the string	"\AThe"
\b	Returns a match where the specified characters are at the beginning or at the end of a word (the "r" in the beginning is making sure that the string is being treated as a "raw string")	r"\bair" r"air\b"
\B	Returns a match where the specified characters are present, but NOT at the beginning (or at the end) of a word (the "r" in the beginning is making sure that the string is being treated as a "raw string")	r"\Bair" r"air\B"
\d	Returns a match where the string contains digits (numbers from 0-9)	"\d"
\D	Returns a match where the string DOES NOT contain digits	"\D"
\s	Returns a match where the string contains a white space character	"\s"
\S	Returns a match where the string DOES NOT contain a white space character	"\S"
\w	Returns a match where the string contains any word characters (characters from a to Z, digits from 0-9, and the underscore _ character)	"\w"
\W	Returns a match where the string DOES NOT contain any word characters	"\W"
\Z	Returns a match if the specified characters are at the end of the string	"spain\Z"

>>>import re

>>>p=re.compile("[a-z]+")

>>>p

re.compile('[a-z]+')

>>>str="what is what ?"

>>>p.match(str)

<re.Match object; span=(0, 4), match='what'>

Now you can query the match object for information about the matching string. Match object instances also have several methods and attributes; the most important ones are:

Method/Attribute	Purpose
group	Return the string matched by the RE
start	Return the starting position of the match
end	Return the ending position of the match
span	Return a tuple containing the (start, end) positions of the match

>>> m = p.match(str)

>>> m.group()

'what'

>>> m.start()

>>> m.end()

>>> m.span()

(0, 4)

group() returns the substring that was matched by the RE. start() and end() return the starting and ending index of the match. span() returns both start and end indexes in a single tuple. Since the match() method only checks if the RE matches at the start of a string, start() it will always be zero. However, the search() method of patterns scans through the string, so the match may not start at zero in that case.

>>>p = re.compile(r'\d+')

>>>p.findall("on day 12 i spend 50 rupees")

["12","50"]

findall() has to create the entire list before it can be returned as the result. The finditer() the method returns a sequence of match object instances as an iterator

With the help of metacharacters and special sequences, we can do RegEx operations easily.

Standard library modules in Python - Letsprogram

2020-05-31T15:55:00.002+05:30

In python, there are some packages installed. These will come by default when you are downloading the software. There are many of them you can see the list here:

Module index.

Here we discuss some of the modules which are very useful to a programmer now.

PageContents

Modules of python that are discussed in this post.

Operating System Interface
Command-line Arguments
Regular Expression
Maths
Internet Access
Dates and Times
Data Comprehension

Operating System Interface

Python can also interact with the operating system you are using. For a different operating system, different python software will be available so there is no problem in accessing the python.

The os module will provide dozens of commands to interact with the operating system.

If you want to write or read files you can use open() method, manipulate paths using os.path module, create a file, or a directory using shutil module.

All the functions in this module will raise OSError in case of invalid or inaccessible file or path names.

>>>import os

>>>os.getcwd()

'C:\\python38'

>>>os.chdir('\system\files\')

>>>os.system('mkdir programs')

getcwd() will give you the current working directory of the system. chdir() will change you the path of the current directory. system() will be used as a shell you can give any commands.

For file and directory management tasks shutil module will provide you an interface which is easy to use.

>>>import shutil

>>>shutil.copyfile('data.db','archive.db')

'archive.db'

>>>shutil.move('/users/programs','Python38')

'Python38'

Be sure you use import os style instead of from os import *. This will make os.open() from shadowing the built-in function open() which are different.

To know all the module functions use the command dir(os) and to know the module's docstring use the command help(os).

Command-line Arguments

Common utility scripts often need to process command-line arguments. These arguments are stored in the sys module’s argv attribute as a list. For instance the following output results from running python demo.py one two three at the command line:

>>> import sys

>>>print(sys.argv)

['demo.py','one','two','three']

The argparse module provides a more sophisticated mechanism to process command line arguments. The following script extracts one or more filenames and an optional number of lines to be displayed:

When run at the command line with python top.py --lines=5 alpha.txt beta.txt, the script sets args.lines to 5 and args.filenames to ['alpha.txt', 'beta.txt'].

Regular Expression

The re module provides regular expression tools for advanced string processing. For complex matching and manipulation, regular expressions offer succinct, optimized solutions:

>>>import re

>>>re.findall(r'bd[a-z]*',

"Follow the blog for more updates")

['Follow','for']

>>>re.sub(r'(\b[a-z]+) \1', r'\1',

'cat in the the hat')

'cat in the hat'

When only simple capabilities are needed, string methods are preferred because they are easier to read and debug:

>>>"Tickets for two".replace('two','us')

'Tickets for us'

Maths

The math module gives access to the underlying C library functions for floating-point math:

>>>import math

>>>math.cos(math.pi/4)

0.707016

>>>math.log(1024,2)

The random module provides tools for making random selections and The statistics module calculates basic statistical properties (the mean, median, variance, etc.) of numeric data:

The SciPy project has many other modules for numerical computations.

Internet Access

There are a number of modules for accessing the internet and processing internet protocols. Two of the simplest are urllib.request for retrieving data from URLs and smtplib for sending mail:

Dates and Times

The datetime module supplies classes for manipulating dates and times in both simple and complex ways. While date and time arithmetic is supported, the focus of the implementation is on efficient member extraction for output formatting and manipulation. The module also supports objects that are timezone aware.

Data Comprehension

Common data archiving and compression formats are directly supported by modules including: zlib, gzip, bz2, lzma, zipfile and tarfile.

>>> import zlib

>>> s = b'witch which has which witches wrist watch'

>>> len(s)

>>> t = zlib.compress(s)

>>> len(t)

>>> zlib.decompress(t)

b'witch which has which witches wrist watch'

>>> zlib.crc32(s)

226805979

Virtual environment and Packages - Letsprogram

2020-05-29T17:14:00.006+05:30

The virtual environment is a good practice for coding applications. Python applications use packages and modules which are not from the standard library. Sometimes an application needs a specific version of the package or module to repair a bug. This means it may not be possible for one Python installation to meet the requirements of every application. If application A needs version 1.x of a particular module but application B needs version 2.y, then the requirements are in conflict, and installing either version 1.x or 2.y will leave one application unable to run.

Here we use a virtual environment self-contained directory tree that contains a Python installation for a particular version of Python, plus several additional packages. each application, you can use a different virtual environment and make your work easier.

Create a Virtual Environment

If you are using Python3 then you will already have venv in your system otherwise you should install it by using the pip command in the shell

python -m pip install virtualenvwrapper-win

Create a directory where you want to work with

mkdir foldername

create a virtual environment there by running venv module as a script with the directory module.

mkvirtualenv name

This will create a virtual environment with a name as 'name'. After creating the environment you can work specifically on your application.

Note: When you restart your shell your virtual environment will be closed you have to restart it with the respective command to again start your virtual environment.

Manage packages using pip

You can install, upgrade, and also remove the packages using pip command. By default, pip will install the packages from the python index. pip can also be used to search the packages from the python index, it will give you package name and version with it.

pip has many commands like install, uninstall, freeze, search, etc.(Go through the installing pip for more information)

pip install django
pip install django == 3.0.6
pip install --upgrade django

If the package is already installed in your system it shows that requirements are satisfied and you can update the version also.

pip uninstall followed by the package name will uninstall that package.

pip list will tell you the number of packages in the virtual environment.

pip show followed by the package name will tell you the features of the package.

pip show Django

Name: Django

Version: 3.0.6

Summary: A high-level Python Web framework that encourages rapid development and clean, pragmatic design.

Home-page: https://www.djangoproject.com/

Author: Django Software Foundation

Author-email: foundation@djangoproject.com

License: BSD

Location: c:\users\balus\envs\django\lib\site-packages

Requires: sqlparse, pytz, asgiref

Required-by: django-urls

pip has many more options you can go through installing pip and get more info. You can also create a package.

Iterators and Generators in python - Letsprogram

2020-05-28T10:26:00.002+05:30

Iterators

When we talk about iteration we may remember like i++ where i value iterates under a condition or Objects can be looped over for statement.

>>>nums = [1,2,3,4]

>>>for num in nums:

print(num)

The for loop just acts as an iterator. But there is another way we can use it is iter method

>>>it = iter(nums)

>>>print(it)

<list_iterator object at 0x000001DBB1A70190>

>>>print(it.__next__())

When you look at the above code by using the __next__() method for iterator object it is printing the value in the nums list. Again after using this method, it is printing the next value in the list, not the first one it is like it holds the previous value or index of the list. You can iterate by also using the next method.

>>>print(next(it))

This style of access is clear, concise, and convenient. The use of iterators pervades and unifies Python. Behind the scenes, the for statement calls iter() on the container object. The function returns an iterator object that defines the method __next__() which accesses elements in the container one at a time. When there are no more elements, __next__() raises a StopIteration exception which tells the for loop to terminate.

>>>next(it)

Traceback (most recent call last):

File "<pyshell#7>", line 1, in <module>

next(it)

StopIteration

See the mechanism of iterators with an example by a class

Generators

Generators are used to create iterators. These are powerful tools to build an iterator. They are just like normal functions but instead of using a return statement here, the yield is used whenever it returns a value.

Each time next() is called on it. Generator remembers the last value executed and resumes where it left off.

>>> def reverse(data):

for index in range(len(data)-1,-1,-1):

yield data[index]

>>> for char in reverse('golf'):

print(char)

Anything that can be done by using generators can also be done by using iterators in class. In the above program in iterators, we had to define the __iter__() and __next__() method but in generators, there is no need to define them. When generators terminate they also raise StopIteration and they save program states these features make it easy to create iterators with no more effort than writing a regular function.

Some simple generators can be coded succinctly as expressions using a syntax similar to list comprehensions but with parentheses instead of square brackets. These expressions are designed for situations where the generator is used right away by an enclosing function. Generator expressions are more compact but less versatile than full generator definitions and tend to be more memory friendly than equivalent list comprehensions.

generator expressions

Connecting python to database - Letsprogram

2020-05-25T10:08:00.002+05:30

Python is used in database applications. When discussing famous databases some are MySQL, Oracle, Microsoft SQL Server and etc.

The database is very useful to store the information so we connect the database with the programming language. In our case, it is the python to connect database with any programming language we should install a related driver given by the database company

In this case, we gonna take MySQL as our database but to connect the database to our programming language it should be in our system or the server. If you do not have any database in your system download the MySQL installer

After, installing the MySQL database in your system then install the MySQL driver. python needs the MySQL driver to access the MySQL database and it is the same in any other database case we should install related drivers to access the related database.

The driver which we should use to access the database is "MySQL connector" to install MySQL connector use pip command in the prompt.

pip install mysql-connector

After the command execution, the MySQL connector is downloaded and installed.

import mysql.connector

If this line is executed in the python interpreter then it was successfully installed.

After importing the driver into your program then we have to connect with the database by using the method connect() from the MySQL-connecter it takes parameters like username, password, IP address and database name.

db = mysql.connector.connect(

host="localhost",

user="python",

passwd="1234"

database="databasename")

To know more about the MySQL connector for python check this link: https://dev.mysql.com/doc/relnotes/connector-python/

Here are two small programs on how to access the database with python

execute statement takes the SQL commands used in the respective database.

Lambda functions in python - Letsprogram

2020-05-23T10:27:00.004+05:30

We have built-in functions in python and we can create a user-defined function as well by using the keyword def and the function name. We use the function names because it is easy to call the function again. What if we never give the function a name?

It becomes anonymous this function is called anonymous function or lambda. Anonymous functions are created when the function is very small like one expression. These anonymous functions are created by using the keyword called lambda.

In python, we can use a function to call another function. Because in python everything is considered an object. Lambda functions can be used wherever function objects are used. Like nested function definitions, lambda functions can reference variables from the containing scope:

>>>def increase(n):

return lambda a:a+n

>>>fun = increase(20)

>>>fun(10)

>>>fun(0)

Lambda function can take multiple arguments as well

>>> f = lambda a,b : a*b

>>>print(f(3,2))

The main point you should understand here is lambda is a function.

>>>type(lambda x:x+1)

<class function>

Note: Use anonymous function when it is required for a short amount of scope

When you defined a normal function instead of lambda function you have to allocate the space for the function name and scope will be throughout the function if it not defined in the class. When you use a lambda function instead of the normal user-defined function then you do not have to waste the memory and its scope will be small not the entire program.

To read any python programming books check this link

Functions in python(def) - Letsprogram

2020-05-22T14:09:00.001+05:30

Before discussing functions first of all why function?

Whenever you want to repeat multiple lines of codes many times then you have to use functions because it reduces the memory consumption, the length of the code, speed of the process.

In python defining a function is done with the keyword called def. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line and must be indented.

Example :

def fib(n):

"""Print the Fibonacci series up to n """

a,b = 0,1

while a<n :

print(a, end="")

a,b = b,a+b

This is an example of a function in python.

The first statement of the function body can optionally be a string literal; this string literal is the function’s documentation string. It’s good practice to include docstrings in code that you write, so make a habit of it.

Defining the function will never give you the output instead you have to make a function call then the function will execute.

>>fib(n)

Coming from other languages, you might object that fib is not a function but a procedure since it doesn’t return a value. In fact, even functions without a return statement do return a value. The value is None it is actually a built-in value. In interpreter mode, you cannot see the None value by the just function call.

>>fib(0)

>>print(fib(0))

None

Actually, we can give the function name to another value. This serves as a general renaming mechanism or aliasing. The value of the function name have a type that is recognized by the interpreter as a user-defined function.

>>> fib

<function fib at 0x000001CD6AE25430>

>>> f=fib

>>> f

<function fib at 0x000001CD6AE25430>

By the above example, you may understand that even after giving function name to another value the value also has the same type.

Arguments in functions

The argument is a value that is sent to the function when you are calling the function.

Parameters are variables that are listed when defining a function.

You have to give the same number of arguments as listed in the function definition.

For example, the function fib is taking only one argument but you gave it three arguments then you will get an error.

Arbitrary Arguments: If you do not know how many arguments that will be passed into your function, add a * before the parameter name in the function definition. By putting **before a parameter then it can accept a dictionary into it.

>>>def function(**dic):

print("my name is",dic(name))

>>>function(fname="max",lname="Payne")

my name is max

Keyword Arguments: You can give the argument value with the key in this way the order in which you are giving the value is not important.

def example(bool,try=4,message="Please try again!"):

while True:

ok=input(prompt)

if ok in ('y','ye','yes',1,'True'):

return True

if ok in('no','n',0,'False'):

return False

try=try-1

if try<0:

raise ValueError("Invalid Response")

print(message)

You can call this function in many ways like :

example('no')

example("Python Blog",2)

example("True",4,"Come on,only yes or no")

There are three possibilities to call the function example because of default arguments.

Function calls in the file are valid.

But all the function calls below are invalid.

parrot()

parrot(voltage=5.0,'dead')

parrot(110,voltage=220)

parrot(actor="IronMan")

User-defined Exceptions in python - Letsprogram

2020-05-20T21:35:00.004+05:30

Prerequisite - This post is an extension for the exception handling.

In python, all exceptions must be instances of any class that derives from the BaseException.Two exception classes that are not related via subclassing are never equivalent, even if they have the same name.

The Built-in exceptions can be subclassed to define new exceptions. To define User-defined exceptions it can be done by inheriting the Exception class or one of its subclass.

When you try to create a new module we create many functions and classes in it. A user may not know all about it, to alert the user when there is an exception but Built-in exceptions are not suitable then user-defined functions have to be created. When creating a module that can raise several distinct errors, a common practice is to create a base class for exceptions defined by that module, and subclass that to create specific exception classes for different error conditions:

Output:

Exception occurred : Not Allowed

Here class Error is inheriting the Exception class and other classes are inheriting the Error class. This is a small practice used in python.

Standard modules will define their own exceptions to report errors that define in their own functions.

To define a user-defined exception first you may have to know about all the built-in exceptions and their hierarchy.

BaseExeption

-----SystemExit

-----KeyboardInterrupt

-----GeneratorExit

-----Exception

|----StopIteration

|----StopAsyncIteration

|----ArithemeticError

+---FloatingpointError

+---OverflowError

+---ZeroDivisionError

|----AssertionError

|----AttributeError

|----BufferError

|----EOFError

|----ImportError

| +-- ModuleNotFoundError

+-- LookupError

| +-- IndexError

| +-- KeyError

+-- MemoryError

+-- NameError

| +-- UnboundLocalError

+-- OSError

| +-- BlockingIOError

| +-- ChildProcessError

| +-- ConnectionError

| | +-- BrokenPipeError

| | +-- ConnectionAbortedError

| | +-- ConnectionRefusedError

| | +-- ConnectionResetError

| +-- FileExistsError

| +-- FileNotFoundError

| +-- InterruptedError

| +-- IsADirectoryError

| +-- NotADirectoryError

| +-- PermissionError

| +-- ProcessLookupError

| +-- TimeoutError

+-- ReferenceError

+-- RuntimeError

| +-- NotImplementedError

| +-- RecursionError

+-- SyntaxError

| +-- IndentationError

| +-- TabError

+-- SystemError

+-- TypeError

+-- ValueError

| +-- UnicodeError

| +-- UnicodeDecodeError

| +-- UnicodeEncodeError

| +-- UnicodeTranslateError

+-- Warning

+-- DeprecationWarning

+-- PendingDeprecationWarning

+-- RuntimeWarning

+-- SyntaxWarning

+-- UserWarning

+-- FutureWarning

+-- ImportWarning

+-- UnicodeWarning

+-- BytesWarning

+-- ResourceWarning

When you learn about the Built-in exceptions you can create the user-defined exceptions easily. If the exception you wanted to create is somewhat related to here you can use it to inherit in your exception class.

class NetworkError(Warning):

def __init__(self,arg):

self.args=arg

try:

raise NetworkError("No Internet")

except NetworkError as e:

print(e.args)

Output :

('N', 'o', ' ', 'I', 'n', 't', 'e', 'r', 'n', 'e', 't')

I created an exception class called NetworkError it is not a built-in function I inherited Warning class it may or may not suit here with the context but you can inherit the Exception class or the class which inherit the Exception class. When your exception is related to the system the use OSError exception class.

Multiple Inheritance in Python - Letsprogram

2020-05-19T12:22:00.003+05:30

Python supports a form of multiple inheritance as well. When a derived class has two or more parent class then it is exhibiting multiple inheritance. The syntax for multiple inheritance is :

class DerivedClass(base1,base2,base3):

<statement 1>

<statement n>

Python searches for attributes inherited from the parent class as left-right not searching in the same class twice.

Learn more about inheritance .

In multiple inheritance there in some cases it may exhibit diamond relationships where at least one of the parent class is accessed through multiple ways from the bottom-most class.

Let's take an example where a diamond relationship exists.

suppose there is a method name add in the class "Base1". Base2 and Base 3 class inherit from Base1 class if there is an overridden method add in the Base2 and Base3 then ambiguity arises which of the method add should we inherit into the class "Derived".

If the "Base2" class has no method add then it will check in Base3 class whether it has add method or not.

When every class defines the same method as having the same number of arguments than to use the base class method use the class name to access the method.

The output of the above code has one problem associated with it, the method m of Class1 is called twice. Python provides a solution to the above problem with the help of the super() function.

The super function will come to a conclusion about which method to execute by an order.

Inheritance in Python - Letsprogram

2020-05-17T19:01:00.003+05:30

Inheritance is the process of getting the features from a base class to the derived class.

when you are defining the derived class make sure the base class name is in the scope.

class DerivedClass(modname.BaseClass):

<Statement 1>

<Statement n>

When the base class you want to inherit is in another module you use its module name to use.

When an object is created for the derived class and looking for an attribute first python looks into the DerivedClass and then into the BaseClass.

Derived classes may override methods of their base classes. Because methods have no special privileges when calling other methods of the same object, a method of a base class that calls another method defined in the same base class may end up calling a method of a derived class that overrides it. (For C++ programmers: all methods in Python are effectively virtual.)

An overriding method in a derived class may, in fact, want to extend rather than simply replace the base class method of the same name. There is a simple way to call the base class method directly just call:

BaseClass.method(self, arguments)

Python has two built-in functions that work with inheritance :

1) isinstance( )

This method is used to check an instance type: suppose isinstance(obj,int)

It returns true if obj is the object of the class int or obj.__class__ is int.

2) issubclass( )

This method is used to check the class inheritance: suppose

issubclass(bool, int). It returns true if bool is a subclass of int. Which is true.

Python also supports multiple inheritances. Which means it has two or more base classes. you can think of the search for attributes inherited from a parent class as depth-first, left-to-right, not searching twice in the same class where there is an overlap in the hierarchy.

In a class hierarchy with single inheritance, super can be used to refer to parent classes without naming them explicitly, thus making the code more maintainable. This use closely parallels the use of super in other programming languages.

The second use case is to support cooperative multiple inheritances in a dynamic execution environment. This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance. This makes it possible to implement “diamond diagrams” where multiple base classes implement the same method. Good design dictates that this method has the same calling signature in every case.

Dynamic ordering is necessary because all cases of multiple inheritances provide one or more diamond relationships. To keep the base classes from being accessed more than once, the dynamic algorithm linearizes the search order in a way that preserves the left-to-right ordering specified in each class, that calls each parent only once, and that is monotonic.

Python Class and Object - Letsprogram

2020-05-17T11:00:00.007+05:30

Python is an Objective Oriented Programming i.e; it follows objective oriented principles. Class is one of the principles of objective programming. Almost everything in python is an Object.

A Class bundles both data and functions together. 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.

Python Class follows inheritance and multiple base classes. A derived class can override base class methods. And a method can call the base class method with the same name.

Class is a blueprint for an object. Class never occupies memory in the system, the memory is occupied by the object. An object follows the rules defined in the class.

We can do aliasing in python which is multiple names (in multiple scopes) that can be bound to a single object.

SYNTAX for Class :

class ClassName:

<statement 1>

<statement n>

In general, statements may be functions or variables. When you create a class definition a new namespace is created where all assignments of local variables go into this new namespace. We discuss namespaces in another post.

class object supports two kinds of operations

Instantiation
attribute references

class example:

""" A simple Example class """

i=2020

def f(self):

return "Hello"

def __init__(self,a,b):

self.a = a

self.b = b

consider the above class, then example.i, example.f are valid attribute references

Class attributes can also be assigned so that you can change the value of I from the class example.

class instantiation uses the function notation if any parameters are required you can give it.

x = example(20,30)

You are giving the class object to the local variable x. Here, it takes parameters because of the constructor.

when a class defines an __init__() method, class instantiation invokes this method automatically for newly created class instances. __init__( ) method may take arguments for better operations in that case class instantiation takes the arguments and give to the __init__( ) method.

We discussed earlier that almost everything in python is an object to know the type of the object use type(object) or object.__class__

-----> methods from the same class call the other methods in the class by using self argument :

class book:

def __init__(self):

self.data=[]

def add(x):

self.data.append(x)

def addtwice(x)

self.add(x)

When addtwice() function accessed through an object then it will call add function from the same class.

Error Handling in Python

2020-05-16T11:00:00.017+05:30

There are two types of errors :

Syntax Errors
Exceptions

Syntax Errors occur due to invalid syntax in the program which can be avoided by practice and experience. But, the main problem is an exception that occurs at run-time execution even if the program is syntactically correct.

>>> 18*(2/0)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ZeroDivisionError: division by zero

>>> "Pythonblog"+2020

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: Can't convert 'int' object to str implicitly

Exceptions are different types and the type in printed in the output. ZeroDivisionError,TypeError,NameError are some exception names.Those are built-in exceptions. User-defined exceptions also exist. The names of exceptions are built-in but not reserved keywords.

When an exception occurs in the program the remaining program will stop executing it.

f = open("filename.txt","a")

f.write("Testing the file")

print("Succesfully written into a file ")

f.close()

When the error occurred at first line by invalid filename then remaining lines of code will not execute further.

How to handle the exception

When an exception occurs in the program it will terminate. To stop this we use a few keywords like try, except, raise, and finally.

In the above example, we add a string and a number to not takes place in that situation we have to place a condition that should be an integer.

while True:

try:

x = int(input("Enter any number"))

break

except (ValueError,RuntimeError):

print("Sorry,Only integers are allowed")

First, try clause (or) block is executed after executing this clause then if an exception occurs except clause with the type matches the exception name after the except keyword is executed by skipping the try block. If not except clause is not executed.

try, except clause have an optional else clause which, when present will follow all except clause. when it doesn't raise any error then it will execute else clause.

raise statement is used to force an exception to occur.

If you don't want the exception to be handled re-raise the exception.

>>>try:

raise NameError(pythonblog)

except NameError as n:

print(n.args,"Not defined")

raise

"pythonblog" Not defined

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

NameError: pythonblog

finally

finally, clause runs whether the try statement produces an exception. finally runs after executing all try blocks.

If an exception occurs while executing a try clause then an exception may be handled by the except clause if not then the exception is re-raised after executing the finally block.

>>>try:

raise KeyboardInterrupt

finally:

print("Python blog")

Python blog

KeyboardInterrupt
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

The error raised after executing the finally block.

To know more about user-defined exceptions you need to know about class and inheritance.

You can check the official python documentation about errors and exceptions.

Program: Using try and except clause to find the age greater than 18

Operation on files using Python

2020-05-15T11:00:00.020+05:30

To do any operations on the files we need to open the file first. The open() method is used to returns the file object and it takes two arguments

f = open("file_name",'mode')

The first argument is a string containing the filename. The second argument is another string containing a few characters describing the way in which the file will be used. To open the file for reading mode=" r ", opening the file for writing mode = " w"

when opened in writing mode if the file already exists then it will rewrite the content, to avoid this use mode = " a " this will add the content at the end of the file. The special mode 'rU' is the "Universal" option for text files where it's smart about converting different line-endings so they always come through as a simple '\n'. The mode is optional because when the mode is omitted " r " will be taken as the mode.

Methods for File objects

read()

To read file contents call f.read(size) which reads size data and returns string in textmode and bytes object in binary mode.

readline()

It will read a single line from the file and a newline character (\n) is left at the end of the string but only for the last line, it will be not printed.

readlines()

If you want to read all the lines of a file in a list you can also use list(f) it will also gives you the same output.

write(string)

f.write(string) writes the contents of string to the file, returning the number of characters written.

To write any other types in your files you have to convert them into strings.

tuple = ( "PythonBlog", 13 )

a = str(tuple)

f.write(a)

tell()

tell function will return the position of the pointer where your object is pointed to the file

seek(offset, whence)

To change the object's position we use the seek method. To move x values forward take offset value as x.

It is good practice to use the with keyword when dealing with file objects. The advantage is that the file is properly closed after its suite finishes, even if an exception is raised at some point. Using with is also much shorter than writing equivalent try-finally blocks.

with open("Pythonblog.txt") as f :

read_data = f.read()

If with is not used make sure f.close() is used in the program so that the file will be closed.

Python also uses JSON module to store the data.

write a program to print the longest word in the file?

win10toast package in python

2020-05-14T15:30:00.001+05:30

You can use this package to handle notifications for the system

The package is available in PyPI download the package using pip command :

pip install win10toast

Make sure you had pip in your system to check it is available or not use the command

pip -- version in the command line if it is available in your system you can proceed with the first command, If not try installing pip by this link.

After installing the win10toast package

Import the package into your program there are many classes in this package like ToastNotifier, CreateWindow, DestroyWindow, UpdateWindow, load image ...etc

We use ToastNotifier class this class had 3 methods in it

notification_active
on_destroy
show_toast

1) notification_active() :

SYNTAX : ToastNotifier().notification_active()

This method returns whether an active notification shown in the system or not

1
2
3

from win10toast import ToastNotifier
toast = ToastNotifier()
toast.notification_active()

Output:

False

2) on_destroy() :

SYNTAX : ToastNotifier().on_destroy(hwnd,msg,wparam,lparam)

This method cleans after the notification ended 4 parameters are required

for the on_destroy method.

3) show_toast() :

SYNTAX : show_toast(title,msg,icon_path,duration,threaded)

1
2
3

from win10toast import ToastNotifier
toast = ToastNotifier()
toast.show_toast("Instagram","Follow pythonblog for more updates",duration=20)

OUTPUT :

Notification will be seen in the system

String Operations in Python - Letsprogram

2020-05-04T15:22:00.003+05:30

To know basic operations with strings in python : check this post

Strings can be concatenated (glued together) with the + operator, and repeated with * . You can concatenate strings by operators like + and *

Strings can be indexed with subscript starts from 0.

Example : var[0],var[1]

if ,

var = "Python Blog" then var[0] = P , var[10] = g

Note that since -0 is the same as 0, negative indices start from -1.

In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain substring.

Note how the start is always included, and the end always excluded. This makes sure that s[:i] + s[i:] is always equal to s

Slice indices have useful defaults; an omitted first index defaults to zero, an omitted second index defaults to the size of the string being sliced.

For non-negative indices, the length of a slice is the difference of the indices, if both are within bounds. For example, the length of word[1:3] is 2.Attempting to use an index that is too large will result in an error.

Suppose a Variable var is holding a string in python we can apply operations on var so that it can be concatenated but you cannot the value of

var

 once you had declared to it.This is know as immutable. Strings are immutable in nature so,that we cannot slice a variable like

var.

But we all know that python is famous for modules and packages. Everything in python is considered as an object, Python gives you predefined functions for strings to do some operations

NOTE: Object has properties of a class or predefined datatype. That is class has functions in it so that objects can access those functions.

There is also no mutable string type, but str.join() or io.StringIO can be used to efficiently construct strings from multiple fragments.

Strings may also be created from other objects using the str constructor. Like
var = str("Python Blog") give you the string.

class str(object=b'', encoding='utf-8', errors='strict') returns the String object. str takes an object, encoding, and errors as inputs. encoding and errors are optional,class str(object='')
If they are not given the values then str(object) returns object.__str__() which is informal way to print the string.

Introduction to the python - Letsprogram

2020-05-01T12:38:00.004+05:30

Basic concepts in python

Comments in Python start with the hash character, #, and extend to the end of the physical line.

A comment may appear at the start of a line or following whitespace or code, but not within a string literal. A hash character within a string literal is just a hash character. Since comments are to clarify code and are not interpreted by Python, they may be omitted when typing in examples.

# this is the first comment                                             
spam = 1  # and this is the second comment                              
          # ... and now a third!                                        
text = "# This is not a comment because it's inside quotes."            

Let’s try some basic Python commands. Start the interpreter and wait for the python prompt, >>>.

Numbers

The equal sign (=) is used to assign a value to a variable. Afterward, no result is displayed before the next interactive prompt. In Python, we need no to define the variable before using it. But If a variable is not “defined” (assigned a value), trying to use it will give you an error

Using (/) gives you float value of remainder using (//) gives integer value of the remainder.

In addition to int and float, Python supports other types of numbers, such as Decimal and Fraction. Python also has built-in support for complex numbers and uses the j or J suffix to indicate the imaginary part (e.g. 3+5j).

All concepts have an example given below

Strings

( \ ) is used to escape quotes in a string.

You can use raw strings by adding an r before the first quote it makes sure to ignore the meaning of ( \n ).

Strings can be concatenated (glued together) with the + operator, and repeated with *

Two or more strings beside each other are concatenated automatically.

All concepts have an example given below

How to install python in your computer

2020-04-30T14:59:00.000+05:30

Before you start, you will need Python on your computer.

Check whether you already have an up to date version of Python installed by entering python in a command-line window. If you see a response from a Python interpreter it will include a version number in its initial display.

When you use python --version it displays version when you use the only python it opens the python shell in the command line. If it is showing you the version then it means you had the python in your system.

Generally, any Python 3.x version will do, As of now, the latest version is 3.8.2 when I wrote this post. Python makes every attempt to maintain backward compatibility within major Python versions. Python 2.x and Python 3.x are intentionally not fully compatible. If python starts a Python 2.x interpreter, try entering python3 and see if an up to date version is already installed.

Go to the Python downloads page and download your relatable file according to the operating system, no of bits, and use of python for your work.

On Windows, you have a choice between 32-bit (labeled x86) and 64-bit (labeled x86-64) versions, and several flavors of the installer for each. The Python core team thinks there should be a default you don't have to stop and think about, so the yellow download button on the main download page gets you the "x86 executable installer" choice. This is actually a fine choice: you don't need the 64-bit version even if you have 64-bit Windows, the 32-bit Python will work just fine.

NOTE: Check whether you are downloading 64 bit or 32 bit to your windows system.

After downloading your executable file install the python in your system. You can go with the installation flow normally it is easy.

You will get python shell, manuals, modules, and IDLE of python. Yow may use any other Python IDE's like Pycharm, anaconda, Visual code any other you prefer.IDE makes the work environment good and fast.

Why python is so famous

2020-04-30T14:06:00.000+05:30

Python is an easy programming language whether you are a first-time programmer or you have experienced in many other programming languages.

Python is a high level, interpreted, and general-purpose programming language. Python came into the market before Java(1995) in the year 1991(first release) by Guido van Rossum. Python code is very easy to read with its notable significant whitespace.

Python is the easiest language available in the market and Python had the largest community here, They make programming more effective. Many Big companies use python as the main language or support language like Google, Youtube, Dropbox, and yahoo.

The reason behind it is there is a huge number of libraries available in the market, many companies and developers are using it and it can be implemented in many areas. When a huge set of libraries are involving it makes our work speed this is one of the reasons why Python is chosen over other languages.

Python is used in ML, AI, Blockchain ..etc. and Frameworks like Django are very famous in web technology nowadays.

It is worth to learn python.

Some of Python's notable features:

Uses an elegant syntax, making the programs you write easier to read.
It is an easy-to-use language that makes it simple to get your program working. This makes Python ideal for prototype development and other ad-hoc programming tasks, without compromising maintainability.
It comes with a large standard library that supports many common programming tasks such as connecting to web servers, searching text with regular expressions, reading, and modifying files.
Python's interactive mode makes it easy to test short snippets of code. There's also a bundled development environment called IDLE.
It is easily extended by adding new modules implemented in a compiled language such as C or C++.
It can also be embedded into an application to provide a programmable interface.
Runs anywhere, including Mac OS X, Windows, Linux, and Unix, with unofficial builds also available for Android and iOS.
It is free software in two senses. It doesn't cost anything to download or use Python, or to include it in your application. Python can also be freely modified and re-distributed because while the language is copyrighted it's available under an open-source license.