SQL (Structured Query Language) is the cornerstone of modern data management and manipulation.

What is SQL and what are its main components?

• SQL (Structured Query Language) is a domain-specific language used to manage and manipulate relational databases. Its main components include:
• DDL (Data Definition Language): Used to define and modify the structure of database objects like tables, indexes, and views (e.g., CREATE, ALTER, DROP).
• DML (Data Manipulation Language): Used to manipulate data within the database, including querying, inserting, updating, and deleting data (e.g., SELECT, INSERT, UPDATE, DELETE).
• DCL (Data Control Language): Used to control access to data within the database (e.g., GRANT, REVOKE).
• TCL (Transaction Control Language): Used to manage transactions within the database (e.g., COMMIT, ROLLBACK).

Explain the different types of SQL joins.

• INNER JOIN: Returns only the rows that have matching values in both tables.
• LEFT JOIN (or LEFT OUTER JOIN): Returns all rows from the left table, and the matched rows from the right table. If there is no match, NULL values are returned for the right table.
• RIGHT JOIN (or RIGHT OUTER JOIN): Returns all rows from the right table, and the matched rows from the left table. If there is no match, NULL values are returned for the left table.
• FULL JOIN (or FULL OUTER JOIN): Returns all rows from both tables, with NULL values for unmatched rows.

What is normalization and why is it important in databases?

Normalization is the process of organizing data in a database to reduce redundancy and dependency by breaking large tables into smaller, related tables. It helps maintain data integrity, reduces storage space, and minimizes update anomalies. Normalization is essential for efficient database design and ensures that the database schema is flexible and scalable.

What is Denormalization ?

Denormalization is the opposite of Normalization. Where as denormalization is a technique used to access the data from higher to lower form of the database. Where the redundant data is added to speedup complex queries by joining the multiple table

What is an index in SQL and why is it used?

An index is a data structure that improves the speed of data retrieval operations on a database table at the cost of additional space and slower writes. It is used to quickly locate rows in a table based on the values of one or more columns. Indexes are crucial for optimizing query performance, especially for large datasets, by reducing the number of rows that need to be scanned during query execution.

Explain the ACID properties in database transactions.

• ACID stands for Atomicity, Consistency, Isolation, and Durability, which are the four key properties that ensure the reliability and integrity of database transactions:
• Atomicity: Ensures that a transaction is treated as a single, indivisible unit of work, either fully completed or fully aborted.
• Consistency: Ensures that a transaction brings the database from one consistent state to another consistent state, preserving data integrity and constraints.
• Isolation: Ensures that the execution of transactions is isolated from one another, preventing interference and ensuring that transactions appear to execute serially.
• Durability: Ensures that once a transaction is committed, its effects are permanently saved and survive system failures, ensuring data persistence.

What is a subquery and how is it different from a join?

A subquery is a query nested within another query and enclosed within parentheses. It can be used to retrieve data from one or more tables and can be used in SELECT, INSERT, UPDATE, or DELETE statements. A subquery can return a single value, a single row, multiple rows, or even a table. In contrast, a join is used to combine rows from two or more tables based on a related column between them.

Explain the difference between GROUP BY and HAVING clauses.

The GROUP BY clause is used to group rows that have the same values into summary rows, typically used with aggregate functions like SUM, COUNT, AVG, etc. The HAVING clause, on the other hand, is used to filter the results of a GROUP BY clause based on specified conditions applied to the grouped data. While the WHERE clause filters rows before grouping, the HAVING clause filters groups after grouping.

How do you handle NULL values in SQL queries?

NULL values in SQL queries can be handled using functions like IS NULL, IS NOT NULL, COALESCE, or IFNULL to check for NULL values in columns or expressions. Additionally, you can use the CASE statement to handle NULL values conditionally in SELECT queries or use the NULLIF function to replace NULL values with a specified default value.

Explain the difference between a clustered and a non-clustered index.

A clustered index determines the physical order of data rows in a table based on the indexed column(s). Each table can have only one clustered index, and it directly affects the order of data storage on disk. In contrast, a non-clustered index does not affect the physical order of data rows and stores a separate data structure containing pointers to the actual data rows.

What is a primary key and why is it important?

• A primary key is a unique identifier for each record in a table. It ensures that each row in the table is uniquely identifiable and provides a reference point for relationships between tables. Primary keys enforce entity integrity and help maintain data consistency.

What is a foreign key and how is it used?

A foreign key is a column or a set of columns in a table that establishes a relationship with a primary key or a unique key in another table. It enforces referential integrity by ensuring that values in the foreign key column(s) correspond to values in the referenced primary key column(s) in the related table.

Explain the difference between UNION and UNION ALL operators.

The UNION operator is used to combine the results of two or more SELECT queries into a single result set, removing duplicate rows. The UNION ALL operator, on the other hand, also combines the results of multiple SELECT queries but retains all rows, including duplicates, from each query result.

What is a trigger and when would you use it?

A trigger is a special type of stored procedure that automatically executes in response to certain database events, such as INSERT, UPDATE, or DELETE operations on a table. Triggers are used to enforce business rules, maintain data integrity, and automate tasks such as auditing or logging changes to data.

Explain the difference between a clustered and a non-clustered index.

A clustered index determines the physical order of data rows in a table based on the indexed column(s). Each table can have only one clustered index, and it directly affects the order of data storage on disk. In contrast, a non-clustered index does not affect the physical order of data rows and stores a separate data structure containing pointers to the actual data rows.

What is a self-join and how is it used?

A self-join is a type of join where a table is joined with itself. It is used to combine rows from the same table based on a related column or condition within the table. Self-joins are useful for hierarchical or recursive queries, such as finding managers and their direct reports in an employee table.

What is the difference between a view and a table?

A table is a database object that stores data in rows and columns, while a view is a virtual table derived from one or more tables or views. Unlike tables, views do not store data themselves; instead, they represent the result set of a predefined SQL query. Views provide a way to simplify complex queries, enforce security, and abstract data access.

Explain the purpose of the COMMIT and ROLLBACK statements.

The COMMIT statement is used to permanently save the changes made by a transaction to the database, making them visible to other transactions. The ROLLBACK statement, on the other hand, is used to undo the changes made by a transaction and restore the database to its state before the transaction began. COMMIT and ROLLBACK statements are essential for ensuring transactional consistency and integrity.

Type of Normalization in detail

We have 4 types of Normalization

1. First Normal Form [1NF] 2. Second Normal Form [2NF] 3. Third Normal Form [3NF] 4. Boyce Codd Normal Form [BCNF]

First Normal Form [1NF] :- Each table cell should have a single value. So, Basically all the records must be unique

Second Normal Form[2NF] :- To use Second Normal Form it should satisfy 1st Normal Form and Should also have single column Primary Key.

Third Normal Form [3NF] :- To use Third Normal Form It should satisfy 2nd Normal Form and Must Not have any transitive functional dependency [Every Attribute should be dependent on Primary key because there should no partial dependency of the data]

Boyce Codd Normal Form [BCNF] :- If your Database is in 3rd Normal Form, Then there would be some scenarios where anomalies would be present. If you have more than one candidate key then BCNF comes into picture, Where you divide your table further, So that there would be only one candidate key present.

What is Entity-Relationship ?

Data Model Entity Relation data Model is based on the Notion of real-word Entities and relationship between them. Note:- Notion:- Notion is an all in one relationship, Where you can write, Plan, Collaborate and get organized Entity :- An Entity is an easily recognizable living or non-living real word object Ex:- Student, Customer, Product. Relationship :- Relationship is an association between two entities. Ex:- A Customer Buys a Product

What is Schemas and explain type of Schemas

A database Schema is a skeleton structure that represents the logical view of the database. It defines its entities and relationship between them. — The Database Schema is categorized into 2 types

1. Physical Schema 2. Logical Schema

Physical Schema :- Physical Schema represents actual storage of the data Logical Schema :- Logical Schema represents the logical constraints, That need to be applied to the data stored It may define Integrity constraints, Views and Table.

What are Views in MySQL ?

View is a virtual table that do not store any data of their own but display the data stored in other tables. You will not have to create complex queries involving joins repeatedly Views helps in data security. You can use view to show only authorized information to the user and hide the sensitive information

Introduction

• In this project I’ve simulated a business problem resolution to a hardware company in India.
• Is a company which supplies computer hardware and peripherals to many clients across India.(like Excel store , Nomad store etc.

Business Issue

• The sales director is facing a lot of challenges such as:
• The marketing is growing dynamically and then he’s struggling in terms of tracking the sales, needing more accurate insights about the company sales, and then take the necessary decisions.

Aims Grid

Solution
Create a simple and informative dashboard about the company sales.

I used SQL queries in MySQL Workbench to take a look into the data and Power BI for ETL and visualizations to create the insights.

Overview

• After a quick data exploration in MySQL, here are some initial findings:
• The database contains 5 tables: customers, date, markets, products, and transactions;
• There are 17 markets, 279 products, and 38 customers;
• The observation period is from January 2018 to June 2020;
• Most of the transactions data are in INR currency, but we have 2 records in U$ currency.
• And we got Paris and New York on the “sales markets” table. We’re going to deal with it in the ETL process.

ETL (Extract, Transform, Load)

Once I know the basic features of the data I have to work with, I imported the MySQL database into Power BI to do the necessary transformations and end up with a simple, reliable, and useful dashboard

Data Modeling Step
We got five tables and we need to ensure that the tables are correctly connected.

TABLES CONNECTED
[sales transactions] — main table
 — sales customers > connected by “customer code” column;
 — sales date> connected by “date” column;
 — sales products > connected by “product code” column;
 — sales markets > connected by “market code” column.

Measures Created
“Revenue” and “Sales Qty” measures to get the sum of each column instantly in the dashboard.

Filtering
Once the company is operating only in India, Infiltered out “Paris” and “New York” in the sales markets table by unchecking the “(blank)” field in the “zone” column.

Cleaning and adding new column
-The “sales amount” column has -1 and 0 values. I removed them in this case so we can see only the actual sales numbers on the dashboard (sometimes “0” means promotional sales and giveaways, but to know that, we should have further information, which is not the case of this project).

• I find out that the “currency” column (sales transactions table) have 2 USD currency values, 2 of them with hidden characters, so i had to include an argument into the conditional formula, in order to create a new column called “Actual_sales”, where it converts the USD currency value into INR currency value.

After all the analysis and transformation, my data is reliable enough to build the dashboard.

Summary

The dashboard shows all the main information about the company sales, such as Revenue, Sales Quantity, Revenue and Sales by Market, Revenue Trend, Top5 Customers and Top 5 Products.
It can be filtered by YEAR and MONTH inside the observation period, so the sales director can have a deeper and quick view of the sales to support his decision making process.

Ans: An operator is used to perform operations between two values or variables

Different type of Operators in Python

1. Arithmetic Operator
2. Assignment Operator
3. Comparison Operator (Relational Operator)
4. Logical Operator
5. Membership Operator
6. Identity Operator
7. Bitwise Operator

Arithmetic Operator: Arithmetic operators are used to perform arithmetic operations between variables

1. Addition (+)
2. Subtraction (-)
3. Multiplication (*)
4. Division (/)
5. Modulus (%)
6. Exponentiation (**)
7. Floor Division(//)

Comparison Operators [Relationship Operator]

Comparison Operators are used to compare two values and Output of Comparison operator is always an Boolean value

Type of Comparison Operators

1. Equal-to (==)
2. Not Equal-to (!=)
3. Greater Than (>)
4. Less Than (<)
5. Greater Than or Equal-to (>=)
6. Less Than or Equal-to (<=)

Logical Operators

Logical Operators are used to combine conditional statements Will first understand what is conditional statements before going to logical operators.
Type of Conditional Statement in Python: Basically we have 3 Conditional Statements in Python

1. if
2. elif
3. else

if True:
print(‘we are doing great’)
else:
print(‘worst’)

we are doing great

x = 20
y = 25

# Conditional Statement
if x == y:
print(‘Equal’)
elif x > y:
print(‘Greater’)
else:
print(‘Smaller’)

Smaller

Type of Logical Operators:

1. and (Logical and)
2. or (Logical or)
3. not (Logical not)

Identity Operators

Identity operators are used to compare objects

1. is → returns True if both variables are same object
2. is not — -> returns Trueif both variables are not same object

list1 = [10,20,30]
list2 = [10,20,30]
list3 = list1
# Is operator # It prints True because it is storing in same memory location
list3 is list1

True

# Now will check for memory location
print(‘Memory Location for list1 =’,id(list1))
print(‘Memory Location for list2 =’,id(list2))
print(‘Memory Location for list3 =’,id(list3))

if id(list1) == id(list2):
print(‘List1 mand list2 store in same memory location’)
elif id(list2) == id(list3):
print(‘List2 and list3 store in same memory location’)
elif id(list1) == id(list3):
print(‘List1 and list3 store in same memory location’)

Memory Location for list1 = 1728733038016
Memory Location for list2 = 1728733030912
Memory Location for list3 = 1728733038016
List1 and list3 store in same memory location

Membership Operators

Membership Operators are used to check if the certain value is present in a list

1. in
2. not in

list1 = [2,4,23,5]
a=19
a in list1 # it will check if 19 is present in list1 or not if it is not present it return False else it prints True

False

Bitwise Operators

Bitwise operators are used to compare binary numbers

Type of Bitwise Operators

1. Bitwise AND (&) — Sets each bit to 1 if both bits are 1
2. Bitwise OR (|) — Sets each bit to 1 if one of the bits is 1
3. Bitwise XOR (^) — Sets each bit to 1 if only one of the bits is 1
4. Bitwise NOT (~) — Inverts all bits
5. Left Shift (<<) — Shift left by pushing in zeros from the right and let the leftmost bits fell off
6. Right Shift (>>) — shift right by pushing copies of the leftmost bit by adding zero

# Example for bit wise and(&) operator
print(bin(10))
print(bin(12))

0b1010
0b1100

What is Functions

A function is a block of code which only runs when it is called.

Why do we use function

We use function to Re-usability of code, and Minimizes redundancy (repeating the same code again and again)

Steps involved in a function

1. You will be defining a function
2. You will be calling a function

Type of function

1. Built in function
2. user defined function

def greet():
print(‘welcome’)
greet()

welcome

Types of Arguments in Python

1. Formal Arguments
2. Actual Arguments
3. Position Argument
4. Keyword Argument
5. Default Argument
6. Variable length Argument
7. Keyword variable length argument

Example:

# Default Argument
def info(name, age=18):
print(‘Name =’,name)
print(‘Age =’,age)
info(‘Salman’)
info(‘Jagruti’,23)

Name = Salman
Age = 18
Name = Jagruti
Age = 23

what is Lambda Function

A lambda function is an anonymous function (i.e., defined without a name) that can take any number of arguments but, unlike normal functions, evaluates and returns only one expression.

example1:

# Add 10 to argument a, and return the result:
x = lambda a : a + 10
print(x(5))

example2:

name=’kiran’
upper_case=lambda name:name
print(name. upper())

KIRAN

Why Use Lambda Functions?

The power of lambda is better shown when you use them as an anonymous function inside another function. Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:

def myfunc(n):
return lambda a:a*n
mydoubler = myfunc(2)
mydoubler(11)

22

Now will Perform Map in Lambda Function

Map in Python is a function that works as an iterator to return a result after applying a function to every item of an iterable

Syntax

map(func,*iterables) -> * varaiable number of elements iteration¶

# Now will square the number using lambda function
num = [2,4,6,8,10]
square_output = list(map(lambda x:x**2,num))
square_output

[4, 16, 36, 64, 100]

It is General purpose ,High level Interpreted language with easy syntax.

Created by Guido van Rossum in 1989.

Why Python is Popular?

• It is easy syntax & high level features.
• Open source language ,it is free for any body to use.
• Used for many applications like ,Web applications ,Artificial Intelligence , Machine Learning ,Mobile app server side etc..
• Huge Libraries or Modules that can used to obtain solution.

Lets get Started.

Variables.

Variables are reserved memory location that stores the data.

Rules for variable names

• Name can’t start with numbers
• Name can’t contain space ,use _(under score)instead
• Name can’t contain any of the special characteristic(@,$,%)
• It’s a best practice that the names is always better to write in lowercase.
• Avoid using Python built-in-keys.

In other programming languages like C, C++, and Java, you will need to declare the type of variables but in Python you don’t need to do that. Just type in the variable and when values will be given to it, then it will automatically know whether the value given would be an int, float, or char or even a String.

# Python program to declare variables

my Number = 4

print(my Number)

my Number ="hello world"

print(my Number)

4
helloworld

See, how simple is it, just create a variable and assign it any value you want and then use the print function to print it.

You can connect a different value with a previously assigned variable very easily through simple reassignment.

Example 1:

Data Scientist = Trainer = Programmer = “Ganesh”
print(‘Data Scientist =’,Data Scientist)
print(‘Trainer =’,Trainer)
print(‘Programmer =’,Programmer)

DataScientist = Ganesh
Trainer = Ganesh
Programmer = Ganesh

Example 2:

Name, Age, Gender = ‘Ganesh’,45,’Male’
print(‘Name =’,Name)
print(‘Age =’,Age)
print(‘Gender =’,Gender)

Name = Ganesh
Age = 45
Gender = Male

Python Data Types.

Data types are the classification or categorization of data items. It represents the kind of value that tells what operations can be performed on a particular data. Since everything is an object in Python programming, data types are classes and variables are instances (objects) of these classes. The following are the built-in data types in Python.

How type() Function Works in Python?

In the given example, we are printing the type of variable x. We will determine the type of an object in Python.

Python

x = 10

print(type(x))

Output

<class 'int'>

Data Types in Python.

1. String

str: String type for storing text (e.g., "Hello, World!").

list -We create a list by placing elements inside [], separated by comma(e.g.,{112, 114, 116, 118, 115})
2. Numeric
1. Integer- int: Integer type (e.g., 5, -10).
2. Float- float: Floating-point type (e.g., 3.14, -2.7).
3. Boolean-bool: Represents truth values, either True or False.
4. None
5. Collection
1. List-
2. Tuple- my tuple = (1, 2, 3, “hello”)
3. Dictionary-dict: Collection of key-value pairs (e.g., {"name": "John", "age": 25}).
4. Set-set: Unordered collection of unique elements (e.g., {1, 2,3}).

Creating a String

To create a string in Python you need to use either single quotes or double quotes.

For example:

# Single quotes
‘hello’

'hello'

# Double quotes
“String built with double quotes”

'String built with double quotes'

We can use a print statement to print a string.

print(‘Hello World 1’)
print(‘Hello World 2’)
print(‘Use \n to print a new line’)

# \n (backward slash n)is used to print in next line
print(‘\n’)
print(‘See what I mean?’)

String Basics

We can also use a function called len() to check the length of a string!.

Python’s built-in len() function counts all of the characters in the string, including spaces and punctuation.

Example: len(‘Hello\’ World’)

12

String Indexing

We know strings are a sequence, which means Python can use indexes to call parts of the sequence. Let’s learn how this works.

In Python, we use brackets [] after an object to call its index. We should also note that indexing starts at 0 for Python. Let's create a new object called s and then walk through a few examples of indexing.

# Assign s as a string
s = ‘Hello World’

# Print the object
print(s)

Hello World

Let’s start indexing!

# Show first element (in this case a letter)
s[0]

'H'

s[2]

'l'

We can use a : colon to perform slicing which grabs everything up to a designated point.

For example: s[1:]

'ello World'

# Note Indexing does not affects the original data
s

'Hello World'

We can also use negative indexing to go backwards.

# Last letter (one index behind 0 so it loops back around)
s[-1]

'd'

String Properties

It’s important to note that strings have an important property known as immutability. This means that once a string is created, the elements within it can not be changed or replaced.

For example: s

'Hello World'

# Concatenate strings!
s + ‘ I love my India!’

'Hello WorldI love my India!'

string function

Name=’India’
print(Name)

India

# Replace String
# The replace() method replaces a string with another string

Name = ‘Varun’
print(Name. Replace(‘v’, ’t’))

tarun

Booleans

Python comes with Booleans (with predefined True and False displays that are basically just the integers 1 and 0). It also has a placeholder object called None. Let’s walk through a few quick examples of Booleans.

# Set object to be a boolean
a = True

type(a)

bool

Lists

Earlier when discussing strings we introduced the concept of a sequence in Python. Lists can be thought of the most general version of a sequence in Python. Unlike strings, they are mutable, meaning the elements inside a list can be changed!

In this section we will learn about:

1.) Creating lists
2.) Indexing and Slicing Lists
3.) Basic List Methods
4.) Nesting Lists
5.) etc..

Lists are constructed with brackets [ ] and commas separating every element in the list.

Let’s go ahead and see how we can construct lists!

# Assign a list to an variable named my_list
my_list = [1,2,3]

We just created a list of integers, but lists can actually hold different object types such as int,float, string, boolean objects, etc which makes it heterogeneous

my_list = [‘A string’,23,100.232,’o’,True]
my_list

['A string', 23, 100.232, 'o', True]

Indexing and Slicing

Indexing and slicing work just like in strings. Let’s make a new list to remind ourselves of how this works:

my_list = [‘one’,’two’,’three’,4,5,True]

type(my_list)

list

Let’s go ahead and explore some more special methods for lists:

# Create a new list
list1 = [1,2,3]

Use the append method to permanently add an item to the end of a list:

# Append
list1.append(‘append me!’)

# Show
list1

[1, 2, 3, 'append me!']

Use pop to “pop off” an item from the list. By default pop takes off the last index, but you can also specify which index to pop off. Let’s see an example:

list1.pop()

'append me!'

Nesting Lists

A great feature of Python data structures is that they support nesting. This means we can have data structures within data structures. For example: A list inside a list.

Let’s see how this works!

# Let’s make three lists
lst_1=[1,2,3]
lst_2=[4,5,6]
lst_3=[7,8,9]

# Make a list of lists to form a matrix
matrix = [lst_1,lst_2,lst_3]

# Show
matrix

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

We can again use indexing to grab elements, but now there are two levels for the index. The items in the matrix object, and then the items inside that list!

extend

Many times people find the difference between extend and append to be unclear. So note:

append: appends whole object at end:
extend: extends list by appending elements from the iterable:

x = [1, 2, 3]
x.append([4, 5,3])
print(x)

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

x = [1, 2, 3]
x.extend([4, 5, 3])
print(x)

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

index

index() will return the index of whatever element is placed as an argument. Note: If the element is not in the list an error is raised.

list1

[1, 2, 3, 4]

list1.index(1)

0

insert

insert() takes in two arguments: insert(index,object) This method places the object at the index supplied. For example:

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

[1, 2, 3, 4]

# Place a letter at the index 2
list1.insert(2,’inserted’)

list1

[1, 2, 'inserted', 3, 4]

pop

You most likely have already seen pop(), which allows us to "pop" off the last element of a list. However, by passing an index position you can remove and return a specific element.

element = list1.pop(1) # pop the second element

list1

[1, 'inserted', 3, 4]

remove

The remove() method removes the first occurrence of a value. For example:

list1

[1, 'inserted', 3, 4]

list1.remove(‘inserted’)

list1

[1, 3, 4]

Delete

del can be used to delete a single index of a list, a slice of a list, or the complete list.

list3=[1,4,6,2,6,1] # deleting perticular element in a list using index
del list3[1]

list3

[1, 6, 2, 6, 1]

Clear

clear will remove the element that are present in the list
The list still remains, but it has no content

lis = [1,2,3,4]
lis.clear()
print(lis)

[]

reverse

As you might have guessed, reverse() reverses a list. Note this occurs in place! Meaning it affects your list permanently.

list2.reverse()

list2

[3, 4, 2, 1]

sort

The sort() method will sort your list in place:

list2=[1,4,3,2]
list2

[1, 4, 3, 2]

Tuples

In Python tuples are very similar to lists, however, unlike lists they are immutable meaning they can not be changed. You would use tuples to present things that shouldn’t be changed, such as days of the week, or dates on a calendar.

In this section, we will get a brief overview of the following:

1.) Constructing Tuples
2.) Basic Tuple Methods
3.) Immutability
4.) When to Use Tuples

You’ll have an intuition of how to use tuples based on what you’ve learned about lists. We can treat them very similarly with the major distinction being that tuples are immutable.

Constructing Tuples

The construction of a tuples use () Parentheses with elements separated by commas. For example:

m=(‘India’,3,True)

type(m)

tuple

m

('India', 3, True)

for i in m:
print(i)

India
3
True

for index,values in enumerate(m):
print(index,’ — — →’,values)

0 ------> India
1 ------> 3
2 ------> True

Basic Tuple Methods

Tuples have built-in methods, but not as many as lists do.

Immutability

It can’t be stressed enough that tuples are immutable. Because of this immutability, tuples can’t grow. Once a tuple is made we can not add to it.

When to use Tuples

You may be wondering, “Why bother using tuples when they have fewer available methods?” To be honest, tuples are not used as often as lists in programming, but are used when immutability is necessary. If in your program you are passing around an object and need to make sure it does not get changed, then a tuple becomes your solution. It provides a convenient source of data integrity.

You should now be able to create and use tuples in your programming as well as have an understanding of their immutability.

Up next Files!

Dictionaries

This section will serve as a brief introduction to dictionaries and consist of:

1.) Constructing a Dictionary
2.) Accessing objects from a dictionary
3.) Nesting Dictionaries
4.) Basic Dictionary Methods

A Python dictionary consists of a key and then an associated value.

Constructing a Dictionary

Let’s see how we can construct dictionaries to get a better understanding of how they work! Make a dictionary with {}(curly brasis) and : to signify a key and a value

Syntax

my_dict = {‘key1’:’value1',’key2':’value2'} in dictionary always you are fetching the values from key rather than indexing

my_dict = {‘key1’:’value1',’key2':’value2'}

# Call values by their key
my_dict[‘key2’]

'value2'

Its important to note that dictionaries are very flexible in the data types they can hold. For example:

my_dict = {‘key1’:123,’key2':[12,23,33],’key3':[‘item0’,’item1',’item2']}

# Let’s call items from the dictionary
my_dict[‘key3’]

['item0', 'item1', 'item2']

We can affect the values of a key as well. For instance:

my_dict[‘key1’]

123

We can also create keys by assignment. For instance if we started off with an empty dictionary, we could continually add to it:

# Create a new dictionary
d = {}

type(d)

dict

# Create a new key through assignment
d[‘animal’] = ‘Dog’
d

{'animal': 'Dog'}

Nesting with Dictionaries

Hopefully you’re starting to see how powerful Python is with its flexibility of nesting objects and calling methods on them. Let’s see a dictionary nested inside a dictionary:

# Dictionary nested inside a dictionary nested inside a dictionary
d = {‘key1’:{‘nestkey’:{‘subnestkey’:’value’},’nestkey2':[1,2,3]}}
d[‘key1’][‘nestkey2’][1]

2

A few Dictionary Methods

There are a few methods we can call on a dictionary. Let’s get a quick introduction to a few of them:

# Create a typical dictionary
d = {‘key1’:[1,23,56],’key2':2,’key3':3}

# Method to return a list of all keys
d.keys()

dict_keys(['key1', 'key2', 'key3'])

# Method to grab all values
d.values()

dict_values([[1, 23, 56], 2, 3])

Sets

Sets are an unordered collection of unique elements. We can construct them by using the set() function. Let’s go ahead and make a set to see how it works

# Declaire the set
x = set()
# We add to sets with the add() method
x.add(1)
#Show
x

{1}

Note the curly brackets. This does not indicate a dictionary! Although you can draw analogies as a set being a dictionary with only keys.

We know that a set has only unique entries. So what happens when we try to add something that is already in a set?

# Add a different element
x.add(2)
#Show
x

{1, 2}

Notice how it won’t place another 1 there. That’s because a set is only concerned with unique elements! We can cast a list with multiple repeat elements to a set to get the unique elements. For example:

# Create a list with repeats
list1 = [1,1,2,2,3,4,5,6,1,1]
print(list1)

[1, 1, 2, 2, 3, 4, 5, 6, 1, 1]

copy

returns a copy of the set. Note it is a copy, so changes to the original don’t effect the copy.
Will Learn More about copy (There are 3 types of copy)

1. ‘Normal copy’
2. ‘Shallow copy’
3. ‘Deep copy’

s = {1,2,3}
sc = s.copy()
sc

{1, 2, 3}

difference

difference returns the difference of two or more sets. The syntax is:

set1.difference(set2)

For example:

# Difference
set1 = {2,4,5,6}
set2 = {5,6,7,8}
set1.difference(set2) # It print only those data which are present in set1 and that are not present in set2

{2, 4}

difference_update

difference_update syntax is:

set1.difference_update(set2)

the method returns set1 after removing elements found in set2

s1 = {1,2,3}

s2 = {1,4,5}

s1.difference_update(s2)

s1

{2, 3}

discard

Removes an element from a set if it is a member. If the element is not a member, do nothing.

s

{1, 2, 3, 4}

s.discard(2)
s

{1, 3}

intersection and intersection_update

Returns the intersection of two or more sets as a new set.(i.e. elements that are common to all of the sets.)

Union

union will print you the unique records from both the variable

print(s1,s2)
s1.union(s2)
s1.add(3)
print(‘s1 =’,s1)
print(‘s2 =’,s2)

{1, 2, 3} {1, 2, 4}
s1 = {1, 2, 3}
s2 = {1, 2, 4}

symmetric_difference

symmetric difference will print non common records from both the variables.

print(‘s1=’,s1)
print(‘s2=’,s2)

s1= {1, 2, 3}
s2= {1, 2, 4}

s1.symmetric_difference(s2)

{3, 4}

isdisjoint

This method will return True if two sets have a null intersection.

s1 = {1,2}
s2 = {1,2,4}
s3 = {5}
s1.isdisjoint(s2)

False

s1 = {1,2}
s2 = {1,2}
s1.issubset(s2)

True