Python

Data types are the categorization of data items representing the kind of value that tells what operations can be performed on a particular data.

Following are the standard or built-in data type of Python:

• String
• Number
• Dictionary
• List
• Tuple

Strings In Python

Strings can be defined as sequential collections of characters. This means that the individual characters that make up a string are in a particular order from left to right. A string that contains no characters, often referred to as the empty string, is still considered to be a string. It is simply a sequence of zero characters and is represented by ‘’ or “” (two single or two double quotes with nothing in between).

Useful functions and methods of String-

List In Python

A list is a sequential collection of Python data values, where each value is identified by an index. The values that make up a list are called its elements. Lists are similar to strings, which are ordered collections of characters, except that the elements of a list can have any type and for any one list, the items can be of different types.

There are several ways to create a new list. The simplest is to enclose the elements in square brackets ( [ and ]).

Useful functions and methods of list-

Tuples In Python

A tuple, like a list, is a sequence of items of any type. The printed representation of a tuple is a comma-separated sequence of values, enclosed in parentheses. In other words, the representation is just like lists, except with parentheses () instead of square brackets [].

One way to create a tuple is to write an expression, enclosed in parentheses, that consists of multiple other expressions, separated by commas.

The key difference between lists and tuples is that a tuple is immutable, meaning that its contents can’t be changed after the tuple is created.

Useful functions and methods of Tuples-

Dictionaries In Python

Data can sometimes be organized more usefully by associating a key with the value we are looking for. A sort of direct look up of a value in Python is done with an object called a Dictionary. Dictionaries are a different kind of collection. They are Python’s built-in mapping type. A map is an unordered, associative collection. The association, or mapping, is from a key, which can be of any immutable type, to a value which can be any Python data object. 

Python has a set of built-in methods that you can use on dictionaries.

A file is some information or data which stays in the computer storage devices. Different kinds of files are music files, video files, text files. Python gives you easy ways to manipulate these files. The Python programs that you write are stored as text files. We can create these files in any of a number of ways. For example, we could use a text editor to type in and save the data. We could also download the data from a website and then save it in a file. Regardless of how the file is created, Python will allow us to manipulate the contents.In Python, we must open files before we can use them and close them when we are done with them. As you might expect, once a file is opened it becomes a Python object just like all other data.Data files can be stored in two ways- Text and Binary

The functions and methods that can be used to open and close files are-

Using A Text File

Once you have a file “object”, the thing returned by the open function, Python provides three methods to read data from that object. The read() method returns the entire contents of the file as a single string (or just some characters if you provide a number as an input parameter. The readlines method returns the entire contents of the entire file as a list of strings, where each item in the list is one line of the file. The readline method reads one line from the file and returns it as a string. The strings returned by readlines or readline will contain the newline character at the end.

Using A Binary File

Inserting/Appending a record in a binary file Inserting or appending a record into a binary file requires importing pickle module into your program followed by dump() method to write onto the file.

Basic syntax of inserting a record in the binary file-

import pickle
fh=open([file name enclosed in “”],[method of execution in ‘’])
pickle.dump([record to insert],fh)

Reading the contents from binary file student uses load() method of pickle module. It is used to read the object from the opened file. The syntax for this is given by the statement—    

object = pickle.load(file)

Once the contents are read, it gets stored inside the object.

Random Access In Files Using TELL() And SEEK()

seek()

seek() function is used to change the position of the file handle (file pointer) to a given specific position. File pointer is like a cursor, which defines from where the data has to be read or written in the file. Python file method seek() sets the file’s current position at the offset. This argument is optional and defaults to 0, which means absolute file positioning. Other values are: 1, which signifies seek is relative (may change) to the current position, and 2, which means seek is relative to the end of file. There is no return value. The reference point is defined by the “from_what” argument. It can have any of the three values: 0: sets the reference point at the beginning of the file, which is by default. 1: sets the reference point at the current file position. 2: sets the reference point at the end of the file. seek() can be done in two ways:

• Absolute Positioning

• Relative Positioning

Absolute referencing using seek() gives the file number on which the file pointer has to position itself. The syntax for seek() is:   

f.seek(file_location)  #where f is the file pointer

tell()

tell() returns the current position of the file read/write pointer within the file.

The syntax for tell() is :

f.tell()      #where f is file pointer

When you open a file in reading/writing mode, the file pointer rests at 0th byte. When you open a file in append mode, the file pointer rests at the last byte.

Using a CSV file

CSV is a simple flat file in a human readable format which is extensively used to store tabular data, in a spreadsheet or database. A CSV file stores tabular data (numbers and text) in plain text.

Files in the CSV format can be imported to and exported from programs that store data in tables, such as Microsoft Excel or OpenOffice Calc. CSV stands for “comma separated values”. Thus, we can say that a comma separated file is a delimited text file that uses a comma to separate values. Each record consists of fields separated by commas (delimiter). Each line of the file is called a record. Thus, CSV organizes data into a structured form and, hence, the proper and systematic organization of this large amount of data is done by CSV. Since CSV file formats are of plain text format, it makes it very easy for website developers to create applications that implement CSV.

Reading from a CSV file is done using the reader object. The CSV file is opened as a text file with Python’s built-in open() function, which returns a file object. This creates a special type of object to access the CSV file (reader object), using the reader() function. The reader object is an iterable that gives us access to each line of the CSV file as a list of fields. File methods for reading are – read, readline, and readlines, which simply iterate over the file object itself – will work on CSV files. You can also use next() directly on it to read the next line of the CSV file, or you can treat it like a list in a for loop to read all the lines of the file (as lists of the file’s fields).

To write to a CSV file in Python, we can use the csv.writer() function. The csv.writer() function returns a writer object that converts the user’s data into a delimited string. This string can later be used to write into CSV files using the writerow() function. In order to write to a CSV file, we create a special type of object to write to the CSV file “writer object”, which is defined in the CSV module, and which we create using the writer() function. The writerow() method allows us to write a list of fields to the file. The fields can be strings or numbers or both. Also, while using writerow(), you do not need to add a new line character

The __init__() Function

To understand the meaning of classes it is important to understand the built-in function  __init__().

All classes have a function called __init__(), which is always executed when the class is being initiated. The __init__() function is called automatically every time the class is being used to create a new object.

Create a class named Person, use the __init__() function to assign values for name and age:

Object Methods

Objects can also contain methods. Methods in objects are functions that belong to the object.

Let us create a method in the Person class. Insert a function that prints a greeting, and execute it on the p1 object:

Modify Object Properties

You can modify properties on objects like this:

map(func, [...])

The expected output of this would be a map object with a memory position.

Lets take an example that applies the function square() to a list of integers which returns a list of squared numbers from our original list.

def square(number):
    return number*number

Writing the code without using map()

def square(number):
    return number*number

numbers = [1,2,3,4,5]
squared_numbers = []

for number in numbers:
    squared = square(number)
    squared_numbers.append(squared)

Writing the code using map()

def square(number):
    return number*number

numbers = [1,2,3,4,5]
squared_numbers = map(square, numbers)

filter(func, [...])

The function passed to filter() must return a boolean (True or False)

The expected output of this would be a filter object with a memory position.

Lets take an example that applies the function even() to a list of integers. The objective here is to get a list that only contains even numbers.

def odd(number):
    if (number  % 2) != 0:
        return True
    return False

Writing code without using filter()

def odd(number):
    if (number % 2) != 0:
        return True
    return False

numbers = [1,2,3,4,5]

odd_numbers = []
for number in numbers:
    if odd(number):
        odd_numbers.append(number)

Writing code with filter()

def odd(number):
    if (number % 2) != 0:
        return True
    return False

numbers = [1,2,3,4,5]
odd_numbers = filter(odd, numbers)

Zip

Python’s zip() function combines elements of 2 lists with matching indexes into an interable of tuples.

zip() will take an undefined number of arguments where each argument is an iterable to zip.

zip([...], [...], [...], ...)

The expected output of this would be a zip object containing tuples of the same-index element of each iterable with a memory position..

Let’s take the above 2 examples combined to create a list of even numbers with their respective squared results.

def even(number):
    if (number % 2) == 0:
        return  True
    return  False

def square(number):
    return number*number

numbers = [1,2,3,4,5]
even_numbers = filter(even, numbers)
even_numbers_squared = map(square, even_numbers)

Writing code without zip()

...
even_numbers = [2,4]
even_numbers_squared = [4, 8]
combined = []
even_numbers_index = 0
for number  in even_numbers:
    squared = even_numbers_squared[even_numbers_index]
    squared_tuple = (number, squared)
    combined.append(squared_tuple)

Writing code with zip()

...
even_numbers = [2,4]
even_numbers_squared = [4, 8]
zipped_result = zip(even_numbers, even_numbers_squared)

Using zip() we can combine values with matching indexes from multiple lists without creating a buffer list or iterating with a for loop.