Python Notes

This is my notes that I made while learning to code in
Python

Python is a high-level, interpreted, interactive and object-oriented scripting language. Python is designed to be highly readable. It uses English keywords frequently where as other languages use punctuation, and it has fewer syntactical constructions than other languages.
Python can be used for:
- Web Development (Server-Side)
- Software Development
- Mathematics
- System Scripting

🔴 1. Variables

Variables are containers for storing data values.
Unlike other programming languages, Python has no command for declaring a variable. eg:

x = 5
y = "Hello, World!"
print(x)
print(y)

Output:

5
Hello, World!

Variable Names:
- A variable name must start with a letter or the underscore character.
- A variable name cannot start with a number.
- A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ ).
- Variable names are case-sensitive (age, Age and AGE are three different variables).
- The variable name must not contain any special characters like !, @, #, $, % etc.
- A variable name cannot be any of the Python keywords

🔴 2. Comments

Comments can be used to explain Python code.
Comments can be used to make the code more readable. eg:

# This is a comment
print("Hello, World!")

Output:

Hello, World!

Multi Line Comments

""" This is a comment
written in
more than just one line """
print("Hello, World!")

Output:

Hello, World!

🔴 3. Concatanation

To combine both text and a variable, Python uses the + character: eg:

x = "awesome"
print("Python is " + x)

Output:

Python is awesome

You can also use the + character to add a variable to another variable: eg:

x = "Python is "
y = "awesome"
z = x + y
print(z)

Output:

Python is awesome

🔴 Data Types

In programming, data type is an important concept.
Variables can store data of different types, and different types can do different things.
Python has the following data types built-in by default, in these categories:
- Text Type: str
- Numeric Types: int, float, complex
- Sequence Types: list, tuple, range
- Mapping Type: dict
- Set Types: set, frozenset
- Boolean Type: bool
- Binary Types: bytes, bytearray, memoryview
- None Type: NoneType
Setting data types:

x = "Hello World" # str
x = 20 # int
x = 20.5 # float
x = 1j # complex
x = ["apple", "banana", "cherry"] # list
x = ("apple", "banana", "cherry") # tuple
x = range(6) # range
x = {"name" : "John", "age" : 36} # dict
x = {"apple", "banana", "cherry"} # set
x = frozenset({"apple", "banana", "cherry"}) # frozenset
x = True # bool
x = b"Hello" # bytes
x = bytearray(5) # bytearray
x = memoryview(bytes(5)) # memoryview
x = None # NoneType

Setting the Specific Data Type:

x = str("Hello World") # str
x = int(20) # int
x = float(20.5) # float
x = complex(1j) # complex
x = list(("apple", "banana", "cherry")) # list
x = tuple(("apple", "banana", "cherry")) # tuple
x = range(6) # range
x = dict(name="John", age=36) # dict
x = set(("apple", "banana", "cherry")) # set
x = frozenset(("apple", "banana", "cherry")) # frozenset
x = bool(5) # bool
x = bytes(5) # bytes
x = bytearray(5) # bytearray
x = memoryview(bytes(5)) # memoryview

🔴 4. Numbers

There are three numeric types in Python:
- int
  - Int, or integer, is a whole number, positive or negative, without decimals, of unlimited length.
- float
  - Float, or "floating point number" is a number, positive or negative, containing one or more decimals.
- complex
  - Complex numbers are written with a "j" as the imaginary part.
Variables of numeric types are created when you assign a value to them: eg:
```
x = 1 # int
y = 2.8 # float
z = 1j # complex
```
Note: You cannot convert complext numbers into another number type.
Random Number:

import random
print(random.randrange(1, 10))

Output:

🔴 5. Casting

There may be times when you want to specify a type on to a variable. This can be done with casting.
Casting in python is therefore done using constructor functions:
- int()
- float()
- str()

Integers:

x = int(1) # x will be 1
y = int(2.8) # y will be 2
z = int("3") # z will be 3

Floats:

x = float(1) # x will be 1.0
y = float(2.8) # y will be 2.8
z = float("3") # z will be 3.0
w = float("4.2") # w will be 4.2

Strings:

x = str("s1") # x will be 's1'
y = str(2) # y will be '2'
z = str(3.0) # z will be '3.0'

🔴 6. Strings

Strings in python are surrounded by either single quotation marks, or double quotation marks.
str is the data type for strings in python.
You can display a string literal with the print() function:

print("Hello")
print('Hello')

Output:

Hello
Hello

Assigning a string to a variable:

a = "Hello"
print(a)

Output:

Hello

Multiline Strings:

a = """This is a multiline string,
come back, I still miss you,
but whocares,
hahaha"""
print(a)

Output:

This is a multiline string,
come back, I still miss you,
but whocares,
hahaha

Strings are Arrays:

a = "Hello, World!"
print(a[1])

Output:

Slicing:

b = "Hello, World!"
print(b[2:5])

Output:

llo

Negative Indexing:

b = "Hello, World!"
print(b[-5:-2])

Output:

orl

String Length:

a = "Hello, World!"
print(len(a))

Output:

String Methods:
- strip() - Removes any whitespace from the beginning or the end
- lower() - Returns the string in lower case
- upper() - Returns the string in upper case
- replace() - Replaces a string with another string
- split() - Splits the string into substrings if it finds instances of the separator
- capitalize() - Converts the first character to upper case
- casefold() - Converts string into lower case
- center() - Returns a centered string
- count() - Returns the number of times a specified value occurs in a string
- encode() - Returns an encoded version of the string
- endswith() - Returns true if the string ends with the specified value
- expandtabs() - Sets the tab size of the string
- find() - Searches the string for a specified value and returns the position of where it was found
- format() - Formats specified values in a string
- index() - Searches the string for a specified value and returns the position of where it was found
- isalnum() - Returns True if all characters in the string are alphanumeric
- isalpha() - Returns True if all characters in the string are in the alphabet
- isdecimal() - Returns True if all characters in the string are decimals
- isdigit() - Returns True if all characters in the string are digits
- isidentifier() - Returns True if the string is an identifier
- islower() - Returns True if all characters in the string are lower case
- isnumeric() - Returns True if all characters in the string are numeric
- isprintable() - Returns True if all characters in the string are printable
- isspace() - Returns True if all characters in the string are whitespaces
- istitle() - Returns True if the string follows the rules of a title
- isupper() - Returns True if all characters in the string are upper case
- join() - Joins the elements of an iterable to the end of the string
- ljust() - Returns a left justified version of the string
- lstrip() - Returns a left trim version of the string
- maketrans() - Returns a translation table to be used in translations
- partition() - Returns a tuple where the string is parted into three parts
- rfind() - Searches the string for a specified value and returns the last position of where it was found
- rindex() - Searches the string for a specified value and returns the last position of where it was found
- rjust() - Returns a right justified version of the string
- rpartition() - Returns a tuple where the string is parted into three parts
- rsplit() - Splits the string at the specified separator, and returns a list
- rstrip() - Returns a right trim version of the string
- splitlines() - Splits the string at line breaks and returns a list
- startswith() - Returns true if the string starts with the specified value
- swapcase() - Swaps cases, lower case becomes upper case and vice versa
- title() - Converts the first character of each word to upper case
- translate() - Returns a translated string
- zfill() - Fills the string with a specified number of 0 values at the beginning
Check String:
- isalnum() - Returns True if all characters in the string are alphanumeric
- isalpha() - Returns True if all characters in the string are in the alphabet
- isdecimal() - Returns True if all characters in the string are decimals
- isdigit() - Returns True if all characters in the string are digits
- isidentifier() - Returns True if the string is an identifier
- islower() - Returns True if all characters in the string are lower case
- isnumeric() - Returns True if all characters in the string are numeric
- isprintable() - Returns True if all characters in the string are printable
- isspace() - Returns True if all characters in the string are whitespaces
- istitle() - Returns True if the string follows the rules of a title
- isupper() - Returns True if all characters in the string are upper case
String Format:
- format() - Formats specified values in a string
- capitalize() - Converts the first character to upper case
- casefold() - Converts string into lower case
- center() - Returns a centered string
- count() - Returns the number of times a specified value occurs in a string
- encode() - Returns an encoded version of the string
- endswith() - Returns true if the string ends with the specified value
- expandtabs() - Sets the tab size of the string
- find() - Searches the string for a specified value and returns the position of where it was found
- index() - Searches the string for a specified value and returns the position of where it was found
- join() - Joins the elements of an iterable to the end of the string
- ljust() - Returns a left justified version of the string
- lower() - Converts a string into lower case
- lstrip() - Returns a left trim version of the string
- maketrans() - Returns a translation table to be used in translations
- partition() - Returns a tuple where the string is parted into three parts
- replace() - Returns a string where a specified value is replaced with a specified value
- rfind() - Searches the string for a specified value and returns the last position of where it was found
- rindex() - Searches the string for a specified value and returns the last position of where it was found
- rjust() - Returns a right justified version of the string
- rpartition() - Returns a tuple where the string is parted into three parts
- rsplit() - Splits the string at the specified separator, and returns a list
- rstrip() - Returns a right trim version of the string
- split() - Splits the string at the specified separator, and returns a list
- splitlines() - Splits the string at line breaks and returns a list
- startswith() - Returns true if the string starts with the specified value
- strip() - Returns a trimmed version of the string
- swapcase() - Swaps cases, lower case becomes upper case and vice versa
- title() - Converts the first character of each word to upper case
Check if a certain phrase or character is present in a string
```
txt = "God is watching."
x = "NOT" in txt
print(x)
```
Output:
```
False
```

Check if a certain phrase or character is NOT present in a string

txt = "Saturn is my favourite planet."
x = "Earth" not in txt
print(x)

Output:

True

String Concatenation:

a = "Hello"
b = "World"
c = a + b
print(c)

Output:

HelloWorld

String Format:

age = 36
txt = "My name is John, and I am {}"
print(txt.format(age))

Output:

My name is John, and I am 36

Escape Character:
- To insert characters that are illegal in a string, use an escape character.
- An escape character is a backslash \ followed by the character you want to insert.
- An example of an illegal character is a double quote inside a string that is surrounded by double quotes:
```
txt = "We are the so-called \"Vikings\" from the north."
print(txt)
```
Output:
```
We are the so-called "Vikings" from the north.
```

🔴 7. Booleans

Booleans represent one of two values: True or False.
In programming you often need to know if an expression is True or False.

🔴 8. Python Operators

Operators are used to perform operations on variables and values.
Python divides the operators in the following groups:
- Arithmetic operators
- Assignment operators
- Comparison operators
- Logical operators
- Identity operators
- Membership operators
- Bitwise operators
Arithmetic Operators:
- + - Addition
- - - Subtraction
- * - Multiplication
- / - Division
- % - Modulus
- ** - Exponentiation
- // - Floor division
Assignment Operators:
- = - x = 5
- += - x += 3
- -= - x -= 3
- *= - x *= 3
- /= - x /= 3
- %= - x %= 3
- //= - x //= 3
- **= - x **= 3
- &= - x &= 3
- |= - x |= 3
- ^= - x ^= 3
- >>= - x >>= 3
- <<= - x <<= 3
Comparison Operators:
- == - Equal
- != - Not equal
- > - Greater than
- < - Less than
- >= - Greater than or equal to
- <= - Less than or equal to
Logical Operators:
- and - Returns True if both statements are true
- or - Returns True if one of the statements is true
- not - Reverse the result, returns False if the result is true
Identity Operators:
- is - Returns True if both variables are the same object
- is not - Returns True if both variables are not the same object
Membership Operators:
- in - Returns True if a sequence with the specified value is present in the object
- not in - Returns True if a sequence with the specified value is not present in the object
Bitwise Operators:
- & - AND
- | - OR
- ^ - XOR
- ~ - NOT
- << - Zero fill left shift
- >> - Signed right shift

🔴 9. Lists

Lists are used to store multiple items in a single variable.
Lists are created using square brackets:

thislist = ["apple", "banana", "cherry"]
print(thislist)

Output:

['apple', 'banana', 'cherry']

List Items:
- List items are ordered, changeable, and allow duplicate values.
- List items are indexed, the first item has index [0], the second item has index [1] etc.

List Items - Data Types:

List items can be of any data type:

list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]

A list can contain different data types:

list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]
list4 = ["apple", 5, True, "banana", "cherry"]

type():
- From Python's perspective, lists are defined as objects with the data type 'list':
```
mylist = ["apple", "banana", "cherry"]
print(type(mylist))
```
Output:
```
<class 'list'>
```

🔴 10. Tuples

Tuples are used to store multiple items in a single variable.
A tuple is a collection which is ordered and unchangeable.
Tuples are written with round brackets.

thistuple = ("apple", "banana", "cherry")
print(thistuple)

Output:

('apple', 'banana', 'cherry')

Tuple Items:
- Tuple items are ordered, unchangeable, and allow duplicate values.
- Tuple items are indexed, the first item has index [0], the second item has index [1] etc.

Tuple Items - Data Types:

Tuple items can be of any data type:

tuple1 = ("apple", "banana", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)

A tuple can contain different data types:

tuple1 = ("apple", "banana", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)
tuple4 = ("apple", 5, True, "banana", "cherry")

type(): - From Python's perspective, tuples are defined as objects with the data type 'tuple':
```
  mytuple = ("apple", "banana", "cherry")
  print(type(mytuple))
```
Output:
```
  <class 'tuple'>
```

🔴 11. Sets

Sets are used to store multiple items in a single variable.
A set is a collection which is both unordered and unindexed.
Sets are written with curly brackets.

thisset = {"apple", "banana", "cherry"}
print(thisset)

Output:

{'apple', 'banana', 'cherry'}

Set Items:
- Set items are unordered, unchangeable, and do not allow duplicate values.
- Set items are indexed, the first item has index [0], the second item has index [1] etc.

Set Items - Data Types:

Set items can be of any data type:

set1 = {"apple", "banana", "cherry"}
set2 = {1, 5, 7, 9, 3}
set3 = {True, False, False}

A set can contain different data types:

set1 = {"apple", "banana", "cherry"}
set2 = {1, 5, 7, 9, 3}
set3 = {True, False, False}
set4 = {"apple", 5, True, "banana", "cherry"}

type(): - From Python's perspective, sets are defined as objects with the data type 'set':
```
  myset = {"apple", "banana", "cherry"}
  print(type(myset))
```
Output:
```
  <class 'set'>
```

🔴 12. Dictionaries

Dictionaries are used to store data values in key:value pairs.
A dictionary is a collection which is ordered*, changeable and does not allow duplicates.
Dictionaries are written with curly brackets, and have keys and values.

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

Output:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

Dictionary Items:
- Dictionary items are ordered, changeable, and does not allow duplicates.
- Dictionary items are indexed, the first item has index [0], the second item has index [1] etc.

Dictionary Items - Data Types:

Dictionary items can be of any data type:

thisdict = {
  "brand": "Ford",
  "electric": False,
  "year": 1964,
  "colors": ["red", "white", "blue"]
}

type(): - From Python's perspective, dictionaries are defined as objects with the data type 'dict':

  mydict = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 1964
  }
  print(type(mydict))

Output:

  <class 'dict'>

🔴 13. If...Else

Python supports the usual logical conditions from mathematics:
- Equals: a == b
- Not Equals: a != b
- Less than: a < b
- Less than or equal to: a <= b
- Greater than: a > b
- Greater than or equal to: a >= b

a = 33
b = 200
if b > a:
  print("b is greater than a")

Output:

b is greater than a

Elif:
- The elif keyword is pythons way of saying "if the previous conditions were not true, then try this condition".

a = 33
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")

Output:

a and b are equal

Else:
- The else keyword catches anything which isn't caught by the preceding conditions.

a = 200
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

Output:

a is greater than b

Short Hand If:
- If you have only one statement to execute, you can put it on the same line as the if statement.

if a > b: print("a is greater than b")

Output:

a is greater than b

Short Hand If...Else:
- If you have only one statement to execute, one for if, and one for else, you can put it all on the same line.

a = 2
b = 330
print("A") if a > b else print("B")

Output:

And:
- The and keyword is a logical operator, and is used to combine conditional statements.

a = 200
b = 33
c = 500
if a > b and c > a:
  print("Both conditions are True")

Output:

Both conditions are True

Or:
- The or keyword is a logical operator, and is used to combine conditional statements.

a = 200
b = 33
c = 500
if a > b or a > c:
  print("At least one of the conditions is True")

Output:

At least one of the conditions is True

Nested If:
- You can have if statements inside if statements, this is called nested if statements.

x = 41
if x > 10:
  print("Above ten,")
  if x > 20:
    print("and also above 20!")
  else:
    print("but not above 20.")

Output:

Above ten,
and also above 20!

🔴 14. While Loops

With the while loop we can execute a set of statements as long as a condition is true.

i = 1
while i < 6:
  print(i)
  i += 1

Output:

The break Statement:
- With the break statement we can stop the loop even if the while condition is true.

i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1

Output:

1
2
3

The continue Statement:
- With the continue statement we can stop the current iteration, and continue with the next.

i = 0
while i < 6:
  i += 1
  if i == 3:
    continue
  print(i)

Output:

The else Statement:
- With the else statement we can run a block of code once when the condition no longer is true.

i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")

Output:

1
2
3
4
5
i is no longer less than 6

🔴 15. For Loops

A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

Output:

apple
banana
cherry

Looping Through a String:

for x in "banana":
  print(x)

Output:

b
a
n
a
n
a

The break Statement:
- With the break statement we can stop the loop before it has looped through all the items.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
  if x == "banana":
    break

Output:

apple
banana

The continue Statement:
- With the continue statement we can stop the current iteration of the loop, and continue with the next.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)

Output:

apple
cherry

The range() Function:
- To loop through a set of code a specified number of times, we can use the range() function.

for x in range(6):
  print(x)

Output:

The range() Function:
- The range() function defaults to 0 as a starting value, however it is possible to specify the starting value by adding a parameter: range(2, 6), which means values from 2 to 6 (but not including 6):

for x in range(2, 6):
  print(x)

Output:

The range() Function:
- The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3):

for x in range(2, 30, 3):
  print(x)

Output:

Else in For Loop:
- The else keyword in a for loop specifies a block of code to be executed when the loop is finished.

for x in range(6):
  print(x)
else:
  print("Finally finished!")

Output:

0
1
2
3
4
5
Finally finished!

Nested Loops:
- A nested loop is a loop inside a loop.
- The "inner loop" will be executed one time for each iteration of the "outer loop".

adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y)

Output:

red apple
red banana
red cherry
big apple
big banana
big cherry
tasty apple
tasty banana
tasty cherry

🔴 16. Functions

A function is a block of code which only runs when it is called.
You can pass data, known as parameters, into a function.
A function can return data as a result.

def my_function():
  print("Hello from a function")

my_function()

Output:

Hello from a function

Arguments:
- Information can be passed into functions as arguments.

def my_function(fname):
  print(fname + " Kumar")

my_function("Rahul")
my_function("Rohit")
my_function("Raj")

Output:

Rahul Kumar
Rohit Kumar
Raj Kumar

Number of Arguments:
- By default, a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less.

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Rahul", "Kumar")

Output:

Rahul Kumar

Arbitrary Arguments, *args:
- 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.

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")

Output:

The youngest child is Linus

Keyword Arguments:
- You can also send arguments with the key = value syntax.

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

Output:

The youngest child is Linus

Arbitrary Keyword Arguments, **kwargs:
- If you do not know how many keyword arguments that will be passed into your function, add two asterisk: ** before the parameter name in the function definition.

def my_function(**kid):
  print("His last name is " + kid["lname"])

my_function(fname = "Aditya", lname = "Raj")

Output:

His last name is Raj

Default Parameter Value:
- The following example shows how to use a default parameter value.

def my_function(country = "India"):
  print("I am from " + country)

my_function("Sweden")
my_function("Norway")
my_function()
my_function("Brazil")

Output:

I am from Sweden
I am from Norway
I am from India
I am from Brazil

Passing a List as an Argument:
- You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function.

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]
my_function(fruits)

Output:

apple
banana
cherry

Return Values:
- To let a function return a value, use the return statement.

def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

Output:

15
25
45

The pass Statement:
- function definitions cannot be empty, but if you for some reason have a function definition with no content, put in the pass statement to avoid getting an error.

def myfunction():
  pass

🔴 17. Lambda

A lambda function is a small anonymous function.
A lambda function can take any number of arguments, but can only have one expression.

x = lambda a : a + 10
print(x(5))

Output:

Lambda functions can take any number of arguments:

x = lambda a, b : a * b
print(x(5, 6))

Output:

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

Output:

Why Use Lambda Functions?
- The power of lambda is better shown when you use them as an anonymous function inside another function.

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11))
print(mytripler(11))

Output:

22
33

🔴 18. Arrays

Arrays are used to store multiple values in one single variable.

cars = ["Ford", "Volvo", "BMW"]

Access the Elements of an Array:
- You refer to an array element by referring to the index number.

x = cars[0]

Modify the value of the first array item:

cars[0] = "Toyota"

The Length of an Array:
- Use the len() method to return the length of an array (the number of elements in an array).

x = len(cars)

Looping Array Elements:
- You can use the for in loop to loop through all the elements of an array.

for x in cars:
  print(x)

Adding Array Elements:
- You can use the append() method to add an element to an array.

cars.append("Honda")

Removing Array Elements:
- You can use the pop() method to remove an element from the array.

cars.pop(1)

Array Methods:
- append() - Adds an element at the end of the list
- clear() - Removes all the elements from the list
- copy() - Returns a copy of the list
- count() - Returns the number of elements with the specified value
- extend() - Add the elements of a list (or any iterable), to the end of the current list
- index() - Returns the index of the first element with the specified value
- insert() - Adds an element at the specified position
- pop() - Removes the element at the specified position
- remove() - Removes the first item with the specified value
- reverse() - Reverses the order of the list
- sort() - Sorts the list

🔴 19. Classes/Objects

Python is an object oriented programming language.
Almost everything in Python is an object, with its properties and methods.
A Class is like an object constructor, or a "blueprint" for creating objects.

class MyClass:
  x = 5

Create an Object:
- Now we can use the class named MyClass to create objects.

p1 = MyClass()
print(p1.x)

Output:

The __init__() Function:
- The examples above are classes and objects in their simplest form, and are not really useful in real life applications.
- To understand the meaning of classes we have to understand the built-in __init__() function.
- All classes have a function called __init__(), which is always executed when the class is being initiated.
- Use the __init__() function to assign values to object properties, or other operations that are necessary to do when the object is being created.

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

Output:

John
36

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

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("John", 36)
p1.myfunc()

Output:

Hello my name is John

The self Parameter:
- The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class.

class Person:
  def __init__(mysillyobject, name, age):
    mysillyobject.name = name
    mysillyobject.age = age

  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc()

Output:

Hello my name is John

Modify Object Properties:
- You can modify properties on objects like this:

p1.age = 40

Delete Object Properties:
- You can delete properties on objects by using the del keyword:

del p1.age

Delete Objects:
- You can delete objects by using the del keyword:

del p1

🔴 20. Inheritance

Inheritance allows us to define a class that inherits all the methods and properties from another class.
Parent Class:
- The class being inherited from is called the parent class.

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

x = Person("John", "Doe")
x.printname()

Output:

John Doe

Child Class:
- The class that inherits from another class is called the child class.

class Student(Person):
  pass

Use the super() Function:
- The super() function is used to give access to methods and properties of a parent or sibling class.

class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

x = Student("Aditya", "Raj")
x.printname()

Output:

Aditya Raj

Add Properties:
- Add a property called graduationyear to the Student class.

class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

x = Student("Aditya", "Raj", 2027)

Add Methods:
- Add a method called welcome to the Student class.

class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

  def welcome(self):
    print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)

x = Student

🔴 21. User Input

Python allows for user input.

username = input("Enter username:")
print("Username is: " + username)

Output:

Enter username: Aditya
Username is: Aditya

aditya8Raj/python

ErrorLooks like something went wrong!

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

Error
Looks like something went wrong!

Packages