DEV Community: hebaShakeel

If Else Statements in Python

hebaShakeel — Wed, 23 Aug 2023 06:13:57 +0000

email = input("Enter your email id:" )
password = input("Enter your password:" )

if email == "superpython@gmail.com" and password == "1234":
---print("Welcome")
elif email == "superpython@gmail.com" and password != "1234":
---print("Incorrect password")
---password = input("Enter password again")
---if password == "1234":
------print("Finally correct")
---else:
------print("Still incorrect")
else:
---print("Incorrect credentials")

Operators in Python

hebaShakeel — Wed, 23 Aug 2023 05:52:32 +0000

Operators are used to perform operations on variables and values. Python has following operators:

Arithmetic Operators

x = 5
y = 2
print(x + y)
o/p = 7

print(x - y)
o/p = 3

print(x * y)
o/p = 10

print(x / y)
o/p = 2.5

print(x % y)
o/p = 1

print (x ** 2) power of op
o/p = 25

print ( x // 2) performs integer division
o/p = 2

Comparison Operators

print(x > y)
o/p = True

print(x < y)
o/p = False

print(x >= y)
o/p = True

print(x <= y)
o/p = False

print(x == y)
o/p = False

print(x != y)
o/p = True

Logical Operators

x = True
y = False

print(x or y)
o/p = True

print(x and y)
o/p = False

print(not x)
o/p = False

print(not y)
o/p = True

Bitwise Operators

They work on binary values

x = 2
y = 3

print(x & y)
o/p = 2

binary of 2 = 010
binary of 3 = 011
performing bitwise and on 010 and 011, we get 010 (2 in decimal)

print(x | y)
o/p = 3
performing bitwise or on 010 and 011, we get 011 (3 in decimal)

print (x >> 2)
o/p = 0

print (y << 3)
o/p = 24

print (~x) # 1s complement
o/p = -3

Assignment Operators

a = 3
print (a)
o/p = 3

a += 3
o/p = 6

a =- 3
o/p = 3

a *= 3
o/p = 9

a &= 3

a++ and ++a does not exist in Python. Using this generates a Syntax Error.

Identity Operators

Checks if 2 variables are on the same memory location.

a = 3
b = 3

print (a is b)
o/p = True

a = [1,2,3]
b = [1,2,3]

print(a is b)
o/p = False

print(a is not b)
o/p = True

Membership Operator

x = "Delhi"

print("D" in x)
o/p = True

print ("D" not in x)
o/p = False

x = [1,2,3]
print(5 in x)
o/p = False

Literals in Python

hebaShakeel — Tue, 22 Aug 2023 17:22:15 +0000

Literal is a raw data given in a variable. There are various types of literals:

Numeric Literals

a = 0b1010 -> Binary literals
b = 100 -> Decimal literals
c = 0o1010 -> Octal literals
d = 0x1010 -> Hexadecimal literals
float_1 = 10.5
float_2 = 1.5e2 (1.5 * 10 to the power 2)
float_3 = 1.5e-3 (1.5 * 10 to the power -3)

String Literals

string = 'I am Heba'
strings = "I am Heba"

multiline = """This is a multiline string. """

Boolean Literals

a = True + 4
o/p = 5

b = False + 10
o/p = 10

Special Literals

a = None
This is useful when we want to declare a variable that doesn't have to be assigned a value at the moment.

Taking user input in Python and Type Conversion

hebaShakeel — Tue, 22 Aug 2023 17:09:31 +0000

-- input(prompt = "Enter your name: ")
or
-- input("Enter your name: ")

Whenever we take user input using the input function, then the user input is always returned in string format. This is because string is a universal format. It can hold other data types. The vice-versa is not true.

To check the datatype of a variable, we use the type() function as follows:

-- type([1,2,3,4])
output : list

To convert the datatype of a variable, we perform Type-Conversion .

Types of Type-Conversion:

Implicit: Python automatically performs type conversion behind the scenes.
Explicit:

Eg: int(4.5)
o/p : 4

Eg: float(4)
o/p : 4.0

Eg: str(4)
o/p : '4'

Eg: bool(4)
o/p : True

Eg: list('Hello')
o/p : ['H','e','l','l','o']

Type conversion is not a permanent operation.

Program to add two numbers:

first_num = int(input("Enter 1st number: "))
second_num = int(input("Enter 2nd number: "))

result = first_num + second_num
print(result)

Keywords and Identifiers in Python

hebaShakeel — Tue, 22 Aug 2023 15:04:59 +0000

Keywords

Python is a case sensitive programming language.

A keyword is a word that is reserved by a program because the word has a special meaning. Keywords can be commands or parameters. Every programming language has a set of keywords that cannot be used a variable name.

Python has 33 keywords:

import keyword
print(keyword.kwlist)

This prints all the keywords in Python.

Identifiers

A Python identifier is a name used to identify a variable, function, class, module or other object.

Rules for setting identifiers:

can only start with an alphabet or _

name = "Heba"
_name = "Heba"
1name = "Heba" ---Invalid
name1 = "Heba"

Followed by 0 or more letter, _ and digits

first_name = "Heba"
first-name = "Heba" ---Invalid

Keywords cannot be used as identifiers

Variables in Python

hebaShakeel — Tue, 22 Aug 2023 14:52:36 +0000

Declaring a variable

name = "Omair"
print(name)

To create a variable, there is no need to declare it in Python. It can be created at the time of use. There is also no need to specify the data type of the variable while creating it. This is called Dynamic Typing.

Static Typing refers to specifying the data type of the variable when declaring them.

name = 4
print(name)

In Python, a variable is not bound to any datatype. This feature is called as Dynamic Binding.

Special Syntax

To declare multiple variables in a single line

a = 5; b= 3; c = 5
a, b, c = 2, 3, 4
a = b = c = 6

Data Types in Python

hebaShakeel — Tue, 22 Aug 2023 14:38:33 +0000

Python supports 3 categories of data types:

Basic Types -integer, float, complex, boolean and string
Container Types - List, tuples, sets and dictionary
User-defined Types - Classes

Integer

print(4)

Floats

print(4.5)

Boolean

print(True)

Complex

print(4+5j)

Strings

print('Mumbai')
print("Mumbai")

List

print([1,2,3,4,5])

Tuple

print((1,2,3,4,5))

Sets

print({1,2,3,4,5})

Dictionaries

print({"Name": "Heba", "Age" : 30, "gender": "Male"})

Check if the Kth bit it set!

hebaShakeel — Sun, 19 Jun 2022 15:34:31 +0000

Example 1:
n= 5
k = 1
binary representation of 5 : 101
1st bit from right is set
therefore output = YES

Example 2:
n = 8
k = 2
binary representation of 8 : 1000
2nd bit from right is not set
therefore output = NO

Solution using Left Shift operator:

Solution using Right Shift Operator:

Finding Divisors of a Number

hebaShakeel — Sat, 18 Jun 2022 17:10:02 +0000

Ok so now your interviewer asks you to write a program to find all the divisors of a number. What would be your solution.
Example:
if NUM = 6
Divisors of 6 are 1 2 3 6.

NAIVE SOLUTION:

Time Complexity : Θ(n)
Space Complexity: O(1)

EFFICIENT SOLUTION:

Time Complexity : Θ(√n)
This solution does not print the divisors in sorted order.

To print in sorted order:

Time Complexity : Θ(√n)
Space Complexity : O(1)

Do you have a better solution in mind?
Do share in the comments!

Computing power

hebaShakeel — Fri, 17 Jun 2022 18:33:44 +0000

Ok so your interviewer asks you write a function to find the power of a number. We have all used Math.pow() in JAVA, pow() function in C/C++, but have you wondered how to compute the power without using these????

Let's find out.

Example:
x = 2
y = 3
Output = 8 ( 2 to the power 3 = 2 *2 *2)

Naive Solution: Time Complexity = O(n)

Output:

Recursive Solution:
Time Complexity = θ(logn)
Space Complexity = θ(logn)

Output:

It has recursive function calls which will take space in function call stack. It also has overhead for function call in return.

Can you think of a better solution?
How about an Iterative solution?
Do share your views in the comments.

Best Code to check if number is Prime

hebaShakeel — Thu, 16 Jun 2022 03:44:52 +0000

C Program

You can try the code using the following link:
Code

1NF and 2NF

hebaShakeel — Mon, 14 Jun 2021 18:17:24 +0000

Normalization: It is a way to reduce/minimize data redundancy (repetition of data). It can be achieved by splitting the table into many tables.

First Normal Form (1NF):
-> It is the property of converting ER Diagram into the Relational Database.
-> The Relational Database is implicitly in 1NF.
-> All attributes should be atomic [ only one value in a tuple is allowed].

Example

Here, SMobile has multiple values which are not allowed. They have to be taken individually.

Approach-1

This approach creates a lot of redundancy in the table. Therefore it is not a suitable approach.

Approach-2

This approach also has redundancy but less when compared to the previous Approach. This is because the tables have now been split into two.

Prime Attributes(Key):
Those attributes which participate in the Candidate key.
Example 1
R(ABCD), CKs: {A, BD}
Therefore PA = {A,B,D}

Example 2
R(ABCDEFG), CKs: {AB, BC, CD, F}
Therefore PA = {A,B,C,D,F}

Non-Prime Attributes(Non-Key):
Those attributes which do not participate in Candidate Key.
Example 1
R(ABCD), CKs: {A, BD}
Therefore NPA = {C}

Example 2
R(ABCDEFG), CKs: {AB, BC, CD, F}
Therefore NPA = {E,G}

Partial Dependency:
If subset of any Candidate Key derives a non-key attribute.

Example
R(ABCD) FDs : {AB->CD, B->D}
CK => {AB}
B->D, B is a subset of AB and it derives non-key, therefore it is a partial dependency.

Second Normal Form (2NF):
=> If a relation 'R' is in 1NF (and)
=> If every non-prime attribute is fully dependent on any complete CK (or) No Partial Dependency exists.

Allowed in 2NF:
=> Non-Prime determines Non-Prime
=> Non-Prime determines Prime
=> Prime determines Prime

Not-Allowed in 2NF:
=> Prime determines Non-Prime