# Python Basics-1

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1696102719094/cadb7435-762e-4648-a3af-5b256612bf00.jpeg align="center")

## Python Basics

### Why Python?

Ans:

1. Huge community support, easy to understand and implement.
    
2. Libraries make your life easy; there is a library for literally everything.
    
3. Jobs, freelancing, different roles, automation, and endless opportunitiesUnderstand variables and data types.
    

# Variables are containers for storing data values.

```python
x = 5
y = "John"
print(x)
print(y)
```

Variables do not need to be declared with any particular *type*, and can even change type after they have been set.

```python
x = 4       # x is of type int
x = "Sally" # x is now of type str
print(x)
```

## Casting

If you want to specify the data type of a variable, this can be done with casting.

```python
x = str(3)    # x will be '3'
y = int(3)    # y will be 3
z = float(3)  # z will be 3.0
```

## Get the Type

You can get the data type of a variable with the `type()` function.

```python
x = 5
y = "John"
print(type(x))
print(type(y))
```

## Multi Words Variable Names

Variable names with more than one word can be difficult to read.

There are several techniques you can use to make them more readable:

## Camel Case

Each word, except the first, starts with a capital letter:

```python
myVariableName = "John"
```

## Pascal Case

Each word starts with a capital letter:

```python
MyVariableName = "John"
```

## Snake Case

Each word is separated by an underscore character:

```python
my_variable_name = "John"
```

## Many Values to Multiple Variables

Python allows you to assign values to multiple variables in one line:

```python
x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)
```

## One Value to Multiple Variables

And you can assign the *same* value to multiple variables in one line:

```python
x = y = z = "Orange"
print(x)
print(y)
print(z)
```

## Unpack a Collection

If you have a collection of values in a list, tuple etc. Python allows you to extract the values into variables. This is called *unpacking*.

```python
fruits = ["apple", "banana", "cherry"]
x, y, z = fruits
print(x)
print(y)
print(z)
```

## Global Variables

Variables that are created outside of a function (as in all of the examples above) are known as global variables.

Global variables can be used by everyone, both inside of functions and outside.

```python
x = "awesome"

def myfunc():
  print("Python is " + x)

myfunc()
```

If you create a variable with the same name inside a function, this variable will be local, and can only be used inside the function. The global variable with the same name will remain as it was, global and with the original value.

Create a variable inside a function, with the same name as the global variable.

```python
x = "awesome"

def myfunc():
  x = "fantastic"
  print("Python is " + x)

myfunc()

print("Python is " + x)
```

## The global Keyword

Normally, when you create a variable inside a function, that variable is local, and can only be used inside that function.

To create a global variable inside a function, you can use the `global` keyword.

If you use the `global` keyword, the variable belongs to the global scope:

```python
def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)
```

Also, use the `global` keyword if you want to change a global variable inside a function.

To change the value of a global variable inside a function, refer to the variable by using the `global` keyword:

```python
x = "awesome"

def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)
```

# Python Data Types

## Built-in 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:

<table><tbody><tr><td colspan="1" rowspan="1"><p>Text Type:</p></td><td colspan="1" rowspan="1"><p><code>str</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>Numeric Types:</p></td><td colspan="1" rowspan="1"><p><code>int</code>, <code>float</code>, <code>complex</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>Sequence Types:</p></td><td colspan="1" rowspan="1"><p><code>list</code>, <code>tuple</code>, <code>range</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>Mapping Type:</p></td><td colspan="1" rowspan="1"><p><code>dict</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>Set Types:</p></td><td colspan="1" rowspan="1"><p><code>set</code>, <code>frozenset</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>Boolean Type:</p></td><td colspan="1" rowspan="1"><p><code>bool</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>Binary Types:</p></td><td colspan="1" rowspan="1"><p><code>bytes</code>, <code>bytearray</code>, <code>memoryview</code></p></td></tr><tr><td colspan="1" rowspan="1"><p>None Type:</p></td><td colspan="1" rowspan="1"><p><code>NoneType</code></p></td></tr></tbody></table>

## Getting the Data Type

You can get the data type of any object by using the `type()` function:

Print the data type of the variable x:

```python
x = 5
print(type(x))
```

## Setting the Data Type

In Python, the data type is set when you assign a value to a variable:

| Example | Data Type |  |
| --- | --- | --- |
| 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

If you want to specify the data type, you can use the following constructor functions:

| Example | 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 |  |

# Python Numbers/

There are three numeric types in Python:

* `int`
    
* `float`
    
* `complex`
    

Variables of numeric types are created when you assign a value to them:

```python
x = 1    # int
y = 2.8  # float
z = 1j   # complex
```

To verify the type of any object in Python, use the `type()` function:

```python
print(type(x))
print(type(y))
print(type(z))
```

## Int

Int, or integer, is a whole number, positive or negative, without decimals, of unlimited length.

Integers:

```python
x = 1
y = 35656222554887711
z = -3255522

print(type(x))
print(type(y))
print(type(z))
```

## Float

Float, or "floating point number" is a number, positive or negative, containing one or more decimals.

Floats:

```python
x = 1.10
y = 1.0
z = -35.59

print(type(x))
print(type(y))
print(type(z))
```

Float can also be scientific numbers with an "e" to indicate the power of 10.

Floats:

```python
x = 35e3
y = 12E4
z = -87.7e100

print(type(x))
print(type(y))
print(type(z))
```

## Complex

Complex numbers are written with a "j" as the imaginary part:

Complex:

```python
x = 3+5j
y = 5j
z = -5j

print(type(x))
print(type(y))
print(type(z))
```

## Type Conversion

You can convert from one type to another with the `int()`, `float()`, and `complex()` methods:

Convert from one type to another:

```python
x = 1    # int
y = 2.8  # float
z = 1j   # complex

#convert from int to float:
a = float(x)

#convert from float to int:
b = int(y)

#convert from int to complex:
c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))
```

## Random Number

Python does not have a `random()` function to make a random number, but Python has a built-in module called `random` that can be used to make random numbers:

Import the random module, and display a random number between 1 and 9:

```python
import random

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

## Strings are Arrays

Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.

However, Python does not have a character data type, a single character is simply a string with a length of 1.

Square brackets can be used to access elements of the string

Get the character at position 1 (remember that the first character has the position 0):

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

## Looping Through a String

Since strings are arrays, we can loop through the characters in a string, with a `for` loop.

Loop through the letters in the word "banana":

```python
for x in "banana":
  print(x)
```

## String Length

To get the length of a string, use the `len()` function.

The `len()` function returns the length of a string:

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

## Check String

To check if a certain phrase or character is present in a string, we can use the keyword `in`.

Check if "free" is present in the following text:

```python
txt = "The best things in life are free!"
print("free" in txt)
```

Use it in an `if` statement:

Print only if "free" is present:

```python
txt = "The best things in life are free!"
if "free" in txt:
  print("Yes, 'free' is present.")
```

## Check if NOT

To check if a certain phrase or character is NOT present in a string, we can use the keyword `not in`.

Check if "expensive" is NOT present in the following text:

```python
txt = "The best things in life are free!"
print("expensive" not in txt)
```

Use it in an `if` statement:

print only if "expensive" is NOT present:

```python
txt = "The best things in life are free!"
if "expensive" not in txt:
  print("No, 'expensive' is NOT present.")
```

# Python - Slicing Strings

You can return a range of characters by using the slice syntax.

Specify the start index and the end index, separated by a colon, to return a part of the string.

Get the characters from position 2 to position 5 (not included):

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

## Slice From the Start

By leaving out the start index, the range will start at the first character:

Get the characters from the start to position 5 (not included):

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

## Slice To the End

By leaving out the *end* index, the range will go to the end:

Get the characters from position 2, and all the way to the end:

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

## Negative Indexing

Use negative indexes to start the slice from the end of the string:

Get the characters:

From: "o" in "World!" (position -5)

To, but not included: "d" in "World!" (position -2):

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

## Upper Case

The `upper()` method returns the string in upper case:

```python
a = "Hello, World!"
print(a.upper())
```

## Lower Case

The `lower()` method returns the string in lower case:

```python
a = "Hello, World!"
print(a.lower())
```

## Replace String

The `replace()` method replaces a string with another string:

```python
a = "Hello, World!"
print(a.replace("H", "J"))
```

# Python - String Concatenation

To concatenate, or combine, two strings you can use the + operator.

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

### Example

To add a space between them, add a `" "`:

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

# Python - String Methods

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

| Method | Description |
| --- | --- |
| [capitalize()](https://www.w3schools.com/python/ref_string_capitalize.asp) | Converts the first character to upper case |
| [casefold()](https://www.w3schools.com/python/ref_string_casefold.asp) | Converts string into lower case |
| [center()](https://www.w3schools.com/python/ref_string_center.asp) | Returns a centered string |
| [count()](https://www.w3schools.com/python/ref_string_count.asp) | Returns the number of times a specified value occurs in a string |
| [encode()](https://www.w3schools.com/python/ref_string_encode.asp) | Returns an encoded version of the string |
| [endswith()](https://www.w3schools.com/python/ref_string_endswith.asp) | Returns true if the string ends with the specified value |
| [expandtabs()](https://www.w3schools.com/python/ref_string_expandtabs.asp) | Sets the tab size of the string |
| [find()](https://www.w3schools.com/python/ref_string_find.asp) | Searches the string for a specified value and returns the position of where it was found |
| [format()](https://www.w3schools.com/python/ref_string_format.asp) | Formats specified values in a string |
| format\_map() | Formats specified values in a string |
| [index()](https://www.w3schools.com/python/ref_string_index.asp) | Searches the string for a specified value and returns the position of where it was found |
| [isalnum()](https://www.w3schools.com/python/ref_string_isalnum.asp) | Returns True if all characters in the string are alphanumeric |
| [isalpha()](https://www.w3schools.com/python/ref_string_isalpha.asp) | Returns True if all characters in the string are in the alphabet |
| [isascii()](https://www.w3schools.com/python/ref_string_isascii.asp) | Returns True if all characters in the string are ascii characters |
| [isdecimal()](https://www.w3schools.com/python/ref_string_isdecimal.asp) | Returns True if all characters in the string are decimals |
| [isdigit()](https://www.w3schools.com/python/ref_string_isdigit.asp) | Returns True if all characters in the string are digits |
| [isidentifier()](https://www.w3schools.com/python/ref_string_isidentifier.asp) | Returns True if the string is an identifier |
| [islower()](https://www.w3schools.com/python/ref_string_islower.asp) | Returns True if all characters in the string are lower case |
| [isnumeric()](https://www.w3schools.com/python/ref_string_isnumeric.asp) | Returns True if all characters in the string are numeric |
| [isprintable()](https://www.w3schools.com/python/ref_string_isprintable.asp) | Returns True if all characters in the string are printable |
| [isspace()](https://www.w3schools.com/python/ref_string_isspace.asp) | Returns True if all characters in the string are whitespaces |
| [istitle()](https://www.w3schools.com/python/ref_string_istitle.asp) | Returns True if the string follows the rules of a title |
| [isupper()](https://www.w3schools.com/python/ref_string_isupper.asp) | Returns True if all characters in the string are upper case |
| [join()](https://www.w3schools.com/python/ref_string_join.asp) | Joins the elements of an iterable to the end of the string |
| [ljust()](https://www.w3schools.com/python/ref_string_ljust.asp) | Returns a left justified version of the string |
| [lower()](https://www.w3schools.com/python/ref_string_lower.asp) | Converts a string into lower case |
| [lstrip()](https://www.w3schools.com/python/ref_string_lstrip.asp) | Returns a left trim version of the string |
| [maketrans()](https://www.w3schools.com/python/ref_string_maketrans.asp) | Returns a translation table to be used in translations |
| [partition()](https://www.w3schools.com/python/ref_string_partition.asp) | Returns a tuple where the string is parted into three parts |
| [replace()](https://www.w3schools.com/python/ref_string_replace.asp) | Returns a string where a specified value is replaced with a specified value |
| [rfind()](https://www.w3schools.com/python/ref_string_rfind.asp) | Searches the string for a specified value and returns the last position of where it was found |
| [rindex()](https://www.w3schools.com/python/ref_string_rindex.asp) | Searches the string for a specified value and returns the last position of where it was found |
| [rjust()](https://www.w3schools.com/python/ref_string_rjust.asp) | Returns a right justified version of the string |
| [rpartition()](https://www.w3schools.com/python/ref_string_rpartition.asp) | Returns a tuple where the string is parted into three parts |
| [rsplit()](https://www.w3schools.com/python/ref_string_rsplit.asp) | Splits the string at the specified separator, and returns a list |
| [rstrip()](https://www.w3schools.com/python/ref_string_rstrip.asp) | Returns a right trim version of the string |
| [split()](https://www.w3schools.com/python/ref_string_split.asp) | Splits the string at the specified separator, and returns a list |
| [splitlines()](https://www.w3schools.com/python/ref_string_splitlines.asp) | Splits the string at line breaks and returns a list |
| [startswith()](https://www.w3schools.com/python/ref_string_startswith.asp) | Returns true if the string starts with the specified value |
| [strip()](https://www.w3schools.com/python/ref_string_strip.asp) | Returns a trimmed version of the string |
| [swapcase()](https://www.w3schools.com/python/ref_string_swapcase.asp) | Swaps cases, lower case becomes upper case and vice versa |
| [title()](https://www.w3schools.com/python/ref_string_title.asp) | Converts the first character of each word to upper case |
| [translate()](https://www.w3schools.com/python/ref_string_translate.asp) | Returns a translated string |
| [upper()](https://www.w3schools.com/python/ref_string_upper.asp) | Converts a string into upper case |
| [zfill()](https://www.w3schools.com/python/ref_string_zfill.asp) | Fills the string with a specified number of 0 values at the beginning |

# Python Booleans

Booleans represent one of two values: `True` or `False`.

## Boolean Values

In programming you often need to know if an expression is `True` or `False`.

You can evaluate any expression in Python, and get one of two answers, `True` or `False`.

When you compare two values, the expression is evaluated and Python returns the Boolean answer:

```python
print(10 > 9)
print(10 == 9)
print(10 < 9)
```

When you run a condition in an if statement, Python returns `True` or `False`:

### Example

Print a message based on whether the condition is `True` or `False`:

```python
a = 200
b = 33

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

## Evaluate Values and Variables

The `bool()` function allows you to evaluate any value, and give you `True` or `False` in return,

### Example

Evaluate a string and a number:

```python
print(bool("Hello"))
print(bool(15))
```

### Example

Evaluate two variables:

```python
x = "Hello"
y = 15

print(bool(x))
print(bool(y))
```

## Most Values are True

Almost any value is evaluated to `True` if it has some sort of content.

Any string is `True`, except empty strings.

Any number is `True`, except `0`.

Any list, tuple, set, and dictionary are `True`, except empty ones.

### Example

The following will return True:

```python
bool("abc")
bool(123)
bool(["apple", "cherry", "banana"])
```

## Some Values are False

In fact, there are not many values that evaluate to `False`, except empty values, such as `()`, `[]`, `{}`, `""`, the number `0`, and the value `None`. And of course the value `False` evaluates to `False`.

### Example

The following will return False:

```python
bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})
```

One more value, or object in this case, evaluates to `False`, and that is if you have an object that is made from a class with a `__len__` function that returns `0` or `False`:

```python
class myclass():
  def __len__(self):
    return 0

myobj = myclass()
print(bool(myobj))
```

## Functions can Return a Boolean

You can create functions that returns a Boolean Value:

### Example

Print the answer of a function:

```python
def myFunction() :
  return True

print(myFunction())
```

You can execute code based on the Boolean answer of a function:

### Example

Print "YES!" if the function returns True, otherwise print "NO!":

```python
def myFunction() :
  return True

if myFunction():
  print("YES!")
else:
  print("NO!")
```

Python also has many built-in functions that return a boolean value, like the `isinstance()` function, which can be used to determine if an object is of a certain data type:

### Example

Check if an object is an integer or not:

```python
x = 200
print(isinstance(x, int))
```

## Python Operators

Operators are used to perform operations on variables and values.

In the example below, we use the `+` operator to add together two values:

### Example

```python
print(10 + 5)
```

Python divides the operators in the following groups:

* Arithmetic operators
    
* Assignment operators
    
* Comparison operators
    
* Logical operators
    
* Identity operators
    
* Membership operators
    
* Bitwise operators
    

## Python Arithmetic Operators

Arithmetic operators are used with numeric values to perform common mathematical operations:

| Operator | Name | Example |  |
| --- | --- | --- | --- |
| + | Addition | x + y |  |
| \- | Subtraction | x - y |  |
| \* | Multiplication | x \* y |  |
| / | Division | x / y |  |
| % | Modulus | x % y |  |
| \*\* | Exponentiation | x \*\* y |  |
| // | Floor division | x // y |  |

## Python Assignment Operators

Assignment operators are used to assign values to variables:

| Operator | Example | Same As |  |
| --- | --- | --- | --- |
| \= | x = 5 | x = 5 |  |
| += | x += 3 | x = x + 3 |  |
| \-= | x -= 3 | x = x - 3 |  |
| \*= | x \*= 3 | x = x \* 3 |  |
| /= | x /= 3 | x = x / 3 |  |
| %= | x %= 3 |  |  |
| //= | x //= 3 | x = x // 3 |  |
| \*\*= | x \*\*= 3 | x = x \*\* 3 |  |
| &= | x &= 3 | x = x & 3 |  |
|  | \= | x | \= 3 |
| ^= | x ^= 3 | x = x ^ 3 |  |
| \&gt;&gt;= | x &gt;&gt;= 3 | x = x &gt;&gt; 3 |  |
| &lt;&lt;= | x &lt;&lt;= 3 | x = x &lt;&lt; 3 |  |

---

---

## Python Comparison Operators

Comparison operators are used to compare two values:

| Operator | Name | Example |  |
| --- | --- | --- | --- |
| \== | Equal | x == y |  |
| != | Not equal | x != y |  |
| \&gt; | Greater than | x &gt; y |  |
| &lt; | Less than | x &lt; y |  |
| \&gt;= | Greater than or equal to | x &gt;= y |  |
| &lt;= | Less than or equal to | x &lt;= y |  |

---

## Python Logical Operators

Logical operators are used to combine conditional statements:

| Operator | Description |  |  |
| --- | --- | --- | --- |
| and | Returns True if both statements are true | x &lt; 5 and  x &lt; 10 |  |
| or | Returns True if one of the statements is true | x &lt; 5 or x &lt; 4 |  |
| not | Reverse the result, returns False if the result is true | not(x &lt; 5 and x &lt; 10) |  |

---

## Python Identity Operators

Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location:

| Operator | Description | Example |  |
| --- | --- | --- | --- |
| is | Returns True if both variables are the same object | x is y |  |
| is not | Returns True if both variables are not the same object | x is not y |  |

---

## Python Membership Operators

Membership operators are used to test if a sequence is presented in an object:

| Operator | Description | Example |  |
| --- | --- | --- | --- |
| in | Returns True if a sequence with the specified value is present in the object | x in y |  |
| not in | Returns True if a sequence with the specified value is not present in the object | x not in y |  |

---

## Python Bitwise Operators

Bitwise operators are used to compare (binary) numbers:

| Operator | Name | Description | Example | Try it |
| --- | --- | --- | --- | --- |
| & | AND | Sets each bit to 1 if both bits are 1 | x & y | [T](https://www.w3schools.com/python/trypython.asp?filename=demo_oper_and)Operator precedence describes the order in which operations are performed.[y it »](https://www.w3schools.com/python/trypython.asp?filename=demo_oper_and) |
|  |  | OR | Sets each bit to 1 if one of two bits is 1 | x |
| ^ | XOR | Sets each bit to 1 if only one of two bits is 1 | x ^ y | [Try it »](https://www.w3schools.com/python/trypython.asp?filename=demo_oper_xor) |
| ~ | NOT | Inverts all the bits | ~x | [Try it »](https://www.w3schools.com/python/trypython.asp?filename=demo_oper_not) |
| &lt;&lt; | Zero fill left shift | Shift left by pushing zeros in from the right and let the leftmost bits fall off | x &lt;&lt; 2 | [Try it »](https://www.w3schools.com/python/trypython.asp?filename=demo_oper_left_shift) |
| \&gt;&gt; | Signed right shift | Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off | x &gt;&gt; 2 | [Try it »](https://www.w3schools.com/python/trypython.asp?filename=demo_oper_right_shift) |

---

## Operator Precedence

Operator precedence describes the order in which operations are performed.

### Example

Parentheses has the highest precedence, meaning that expressions inside parentheses must be evaluated first:

```python
print((6 + 3) - (6 + 3))
```

### Example

Multiplication `*` has higher precedence than addition `+`, and therefor multiplications are evaluated before additions:

```python
print(100 + 5 * 3)
```