Learn Python 3

Computer Science

A list in Python is a data type used to store a collection of objects. Lists are always ordered and can contain different types of objects, such as strings, integers, booleans, etc. Lists are a mutable data type and therefore a good choice for dynamic data (adding and subtracting to lists). There are multiple ways to define a list in Python. We can either assign a variable to a pair of square brackets ([]) with or without values, or we can assign a variable to the list() keyword and afterwords pass in its list items. Defining empty lists: py list1 = [] list2 = list()

.append()

The Python list method `.append()` adds an item to the end of a list.

## Syntax

```py
list.append(item)
```

The `.append()` will place the object passed in as a new element at the very end of the list. Printing the list afterwards will visually show the appended value.

This method is not to be confused with returning an entirely new list with the passed object.

## Example

To add `'🥚'` to the end of the `grocery` list:

```py
grocery = ['🍉', '🍪', '🥬', '🥕']

grocery.append('🥚')

print(grocery)
# Output: ['🍉', '🍪', '🥬', '🥕', '🥚']
```

## Codebyte Example

To add `'tulips'` to the end of the `orders` list:

```codebyte/python
orders = ['daisies', 'periwinkle']

orders.append('tulips')

print(orders)
```


Python

.clear()

The Python `.clear()` method removes all items from a list.

## Syntax

```py
list.clear()
```

The `.clear()` method has no parameters.

## Example

To remove all items from the `grocery` list:

```python
grocery = ['🍉', '🍪', '🥬', '🥕']

grocery.clear()

print(grocery)
# Output: []
```

## Codebyte Example

To remove all items from the `orders` list:

```codebyte/python
orders = ['daisies', 'periwinkle']

orders.clear()

print(orders)
```


.copy()

Returns a shallow copy of a list.

## Syntax

```py
list2 = list1.copy()
```

The `.copy()` method has no parameters.

## Example

A Python list can be copied using the `=` assignment operator:

```py
list1 = [1, 2, 3, 4]
list2 = list1

print(list1) # Ouptut: [1, 2, 3, 4]
print(list2) # Ouptut: [1, 2, 3, 4]
```

However, if you modify `list2`, `list1` is also modified. This is because `list2` is actually pointing to the `list1` object.

If you want the original list unchanged when the new list is modified, you can use the `.copy()` method.

Copying the `orders` list using `.copy()` method:

```codebyte/python
orders = ['daisies', 'periwinkle']

new_orders = orders.copy()

print(new_orders)
# Output: ['daisies', 'periwinkle']
```

Now if you change `new_orders`, `orders` stays the same.

## Shallow Copy

If you are copying nested lists, shallow copy means if you modify any of the new nested list elements, changes are reflected in both the new and old lists as they point to the same reference. Whereas in deep copy, if you modify any of the new nested list elements, only the new list changes.


Searches a list for a particular item and returns the number of matching entries found.

.count()

Searches a list for a particular item and returns the number of matching entries found.

## Syntax

```py
list.count(value, start, end)
```

The `.count()` method has three parameters:

- `value`: The string to search for. (Required)
- `start`: The index to start the search. Default is index 0.
- `end`: The position to end the search. Default is end of the string.

## Example 1

To count the number of `'pen'` within the `backpack` list:

```codebyte/python
backpack = ['pencil', 'pen', 'notebook', 'textbook', 'pen', 'highlighter', 'pen']

numPen = backpack.count('pen')

print(numPen)
# Output: 3
```

## Example 2

To count the number of `'pen'` within the `backpack` list from index 0 to index 5:

```codebyte/python
backpack = ['pencil', 'pen', 'notebook', 'textbook', 'pen', 'highlighter', 'pen']

numPen = backpack.count('pen', 0, 5)

print(numPen)
# Output: 2
```


.extend()

Adds list elements to end of the list.

## Syntax

```py
list.append(iterable)
```

This will place passed in iterable (list, tuple, or string) as new elements at the very end of the list.

`.append()` does not return any value.

## Examples

To add `grocery_new` to the end of the `grocery` list:

```codebyte/python
grocery = ['blueberries', 'eggs', 'artichoke']
grocery_new = ['milk', 'cookies']

grocery.extend(grocery_new)

print(grocery)
# Output: ['blueberries', 'eggs', 'artichoke', 'milk', 'cookies']
```

It works for any other type of iterables:

```codebyte/python
to_do_list = ['respond to email', 'check github']
targets = (4, 1, 6, 20)

to_do_list.extend(targets)

print(to_do_list)
# Output: ['respond to email', 'check github', 4, 1, 6, 20]
```


Finds the first occurence of a particular value within the list.

.index()

Finds the first occurence of a particular value within the list.

## Syntax

```py
list.index(value, start, end)
```

The `.index()` list method has three parameters:

- `value`: The string to search for. (Required)
- `start`: The index to start the search. Default is index 0.
- `end`: The position to end the search. Default is end of the string.

## Example 1

To find the index the first `'pen'` within the `backpack` list:

```codebyte/python
backpack = ['pencil', 'pen', 'notebook', 'textbook', 'pen', 'highlighter', 'pen']

firstPen = backpack.index('pen')

print(firstPen)
# Output: 1
```

## Example 2

To find the index the first `'pen'` within the `backpack` list within index 3 to index 6:

```codebyte/python
backpack = ['pencil', 'pen', 'notebook', 'textbook', 'pen', 'highlighter', 'pen']

firstPen = backpack.count('pen', 3, 6)

print(firstPen)
# Output: 4
```


Adds an item at a specified index in the list.

.insert()

Adds an item at a specified index in the list.

## Syntax

```py
list.insert(index, item)
```

The `.insert()` method takes in two parameters:

- The index that you want to insert into.
- The item that you want to insert at the specified index.

## Example

To add an item at index 2 of `store_line` list:

```codebyte/python
store_line = ['Karla', 'Maxium', 'Martim', 'Isabella']

store_line.insert(2, 'Vikor')

print(store_line)
# Output: ['Karla', 'Maxium', 'Vikor', 'Martim', 'Isabella']
```


Removes an item from a list while also returning it.

.pop()

Removes an item from a list while also returning it.

## Syntax

```py
list.pop(index)
```

It accepts one optional input which is the index of the element to remove. If no index is provided, then the last element in the list will be removed and returned.

## Example

To pop the element `'Discrete Math'` from the `courses` list:

```codebyte/python
courses = ['Into to Programming', 'Data Structures & Algorithms', 'Databases', 'Discrete Math', 'Computer Architecture']

courses.pop(3)

print(courses)
# Output: ['Into to Programming', 'Data Structures & Algorithms', 'Databases', 'Computer Architecture']
```

## Example 2

If no index is provided:

```codebyte/python
courses = ['Into to Programming', 'Data Structures & Algorithms', 'Databases', 'Discrete Math', 'Computer Architecture']

courses.pop()

print(courses)
# Output: ['Into to Programming', 'Data Structures & Algorithms', 'Databases', 'Discrete Math']
```


Remove an item from a list by passing in the value of the item to be removed as an argument.

.remove()

Remove an item from a list by passing in the value of the item to be removed as an argument.

## Syntax

```py
list.remove(item)
```

In the case where two or more elements in the list have the same value, the first occurrence of the element is removed.

## Example

To remove the first occurance of `'eggs'`:

```codebyte/python
grocery_list = ['blueberries', 'mochi', 'eggs', 'chocolate']

grocery_list.remove('eggs')

print(grocery_list)
# Output: ['blueberries', 'mochi', 'chocolate']
```


.reverse()

Reverse the elements in the list.

## Syntax

```py
list.reverse()
```

The `.reverse()` method does not take in any arguments.

## Example 1

```python
counting = [1, 2, 3, 4, 5]

counting.reverse()

print(counting)
# Output: [5, 4, 3, 2, 1]
```

## Example 2

To reverse a list called `hand`:

```codebyte/python
hand = ['Rock ✊', 'Paper 🖐', 'Scissors ✌️']

print('Original order: ', hand)

hand.reverse()

print('Updated order: ', hand)
```


Sort the contents of the list it is called on.

.sort()

Sort the contents of the list it is called on.

## Syntax

```py
list.sort()
```

Numerical lists will be sorted in ascending order, and lists of strings will be sorted into alphabetical order. It modifies the original list, and has no return value.

## Example

To sort a list called `exampleList`:

```codebyte/python
exampleList = [4, 2, 1, 3]

exampleList.sort()

print(exampleList)
# Output: [1, 2, 3, 4]
```


Lists

A list in Python is a data type used to store a collection of objects.

Lists are always ordered and can contain different types of objects, such as strings, integers, booleans, etc. Lists are a mutable data type and therefore a good choice for dynamic data (adding and subtracting to lists).

## Creating a List

There are multiple ways to define a list in Python. We can either assign a variable to a pair of square brackets (`[]`) with or without values, or we can assign a variable to the `list()` keyword and afterwords pass in its list items.

Defining empty lists:

```py
list1 = []
list2 = list()
```

Creating lists with values in them:

```py
list1 = ['one', 2, 'three']
list2 = [True, False, False, True, False]
list3 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list4 = ['one', 2, True]
list5 = ['one', 'two', 'three']
```

## Using a Built-in List Method

```py
friends = ['Sue', 'Bob']

print(type(friends))

# Use a built-in method to add Anna to the list of friends.
friends.append('Anna')

print(friends)
```

The output would be:

```shell
<class 'list'>
['Sue', 'Bob', 'Anna']
```


The Python interpreter has a set of functions and types built into it (pre-defined). They are always ready at your disposal; you can use them without needing to import a library. There are 68 built-in functions and they are listed here in alphabetical order.

Built-in Functions

The Python interpreter has a set of functions and types built into it (pre-defined). They are always ready at your disposal; you can use them without needing to import a library.

There are 68 built-in functions and they are listed here in alphabetical order.


Classes are templates used to define the properties and methods of objects in code. They can describe the kinds of information that the class holds, and also how a programmer interacts with that data. It serves as a blueprint or template for the objects, or "instances" of the class. In Python, classes are defined using the class keyword. py class Animal: def init(self, name, leg_count): self.name = name

Classes

Classes are templates used to define the properties and methods of objects in code. They can describe the kinds of information that the class holds, and also how a programmer interacts with that data.

It serves as a blueprint or template for the objects, or "instances" of the class.

## Creating a Class

In Python, classes are defined using the `class` keyword.

```py
class Animal:
  def __init__(self, name, leg_count):
    self.name = name
    self.leg_count = leg_count
```

Class definitions cannot be empty, so the `pass` statement can be used as a placeholder to avoid errors.

```py
class Home:
  pass
```

## Creating Instances of a Class

Objects can be created from classes. These objects are called instances of a class, and when we create an instance, that is known as instantiating a class.

To create an instance of a class, we can set a variable equal to the class name followed by parentheses `()`.

```py
my_home = Home()
```

Here, the instance name is `my_home`, and the class is `Home`.

## Class Methods

Methods are functions defined as part of a class. The first parameter for any class method is the actual object calling the method, usually called `self`.

For example, the following class `Home` has a method called `.paint_wall()`:

- The first parameter is `self`.
- The second parameter is `color`.

When calling a class method, no argument is provided for the parameter `self`, but arguments must be provided for each following parameter.

```py
class Home:
  def paint_wall(self, color):
    # ...

# Creating an instance of the class
blue_home = Home()

# Calling the method on the instance
blue_home.paint_wall("blue")
```

## Class Attributes

Class attributes are variables that are defined outside of all methods and have the same value for every instance of the class.

```py
class Bird:
  # Class attribute
  leg_count = 2

parakeet = Bird()
parrot = Bird()

print(parakeet.leg_count) # Output: 2
print(parrot.leg_count)   # Output: 2
```

## Instance Variables

Instance variables are variables that are unique to each instance of a class. They can be set initially within the `__init__()` method when the instance is created, or instance variables can be added by setting them to values.

```py
class Dog:
  def __init__(self, breed):
    # Instance variable:
    self.breed = breed

dog = Dog("Jindo")

dog.name = "Ruff"
```

We give the instance `dog` a new instance variable called `name` and set it to the value `"Ruff"`.

## **init**() Method

This method is used to initialize a newly created object. It is called each time a class is instantiated. Instance variables are set within the `__init__()` method block. Input parameters can be set for this method, which are passed during instantiation.

```py
class Home:
  def __init__(self, rooms, stories):
    # Setting instance variables
    self.rooms = rooms
    self.stories = stories

home = Home(4, 2)

print(home.rooms)   # Output: 4
print(home.stories) # Output: 2
```

## **repr**() Method

The `__repr__()` method returns the string representation of the class. One way to see the string representation is to call `print()` on the instance.

```py
class Home:
  def __init__(self, rooms, stories):
    self.rooms = rooms
    self.stories = stories

  def __repr__(self):
    return "Home with {} rooms and {} stories".format(self.rooms, self.stories)

home1 = Home(4, 2)
print(home1) # Output: Home with 4 rooms and 2 stories

home2 = Home(5, 2)
print(home2) # Output: Home with 5 rooms and 2 stories
```

## Accessing Methods and Variables in the Class

Within the code of the class, we can call its methods and access its variables. We do this by using `self` followed by a period `.` and then followed by the method or variable.

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

  def sayHi(self):
    # Calls its method .getName()
    print("Hi my name is {}".format(self.getName()))

  def getName(self):
    # Accesses the name variable
    return self.name

bob = Person("Bob")
bob.sayHi()
# Output: Hi my name is Bob
```

## type() Function

The `type()` function returns the data type of the argument passed to it. When the argument is an instance of a class, it returns the class that it is an instance of.

```py
home = Home(4, 2)

print(type(home))
# Output: <class '__main__.Home'>
```

## hasattr() Function

The `hasattr()` function can be used to check if an instance of a class has an attribute. It returns `True` if it does have the attribute, and `False` otherwise.

```py
home = Home(4, 2)

print(hasattr(home, 'rooms')) # Output: True
print(hasattr(home, 'year'))  # Output: False
```

## Deleting Objects

Objects, or instances of classes, can be deleted using the `del` keyword.

```py
del instance_name
```

## Deleting Attributes

Attributes of objects can be deleted using the `del` keyword.

```py
del instance_name.attribute_name
```

## Example

Lets demonstrate a class for an `Employee`:

```py
class Employee(object):
  name = "Sam"
  company = "ILoveCode Inc."
  age = 30
  is_on_vacation = True

  def working(self, employee_name):
    self.name = employee_name
    print(employee_name + " is working")
```

Once we create an `Employee` class like we did above we can import the module in our code and create instances of it whenever and wherever we want, thereby enabling code reusablity and making our code more efficient and easier to maintain.

```py
from employee import Employee

def create_employee():
  print("employee is starting thier job")
  employee1 = Employee(name="Blake")
  name = employee1.name

  print(employee1.work(name))
  # Output: Blake is working
```

When creating applications classes are a great way to organize and improve the quality of your code.


A comment is a piece of text within a program that is not executed. It can be used to provide additional information to aid in understanding the code. In Python, the # character is used to start a comment. The comment continues after the # until the end of the line. py name = "Pied Piper" # Comment after code  Python does not have a specific syntax for multi-line comments, unlike some other languages. Instead, multiple # characters can be used:

Comments

A comment is a piece of text within a program that is not executed. It can be used to provide additional information to aid in understanding the code.

## Single-line Comments

In Python, the `#` character is used to start a comment. The comment continues after the `#` until the end of the line.

```py
# Comment on a single line

name = "Pied Piper" # Comment after code
```

## Multi-line Comments

Python does not have a specific syntax for multi-line comments, unlike some other languages.

Instead, multiple `#` characters can be used:

```py
# This is a comment written over
# more than one line

print("Hello, World!")
```

Another, less official way of writing comments in Python is to use a multi-line string. Python will ignore string literals that are not assigned to a variable, so multi-line strings (created by surrounding text with triple quotes `"""`) can be used as de facto comments:

```py
"""
This is a string written over
more than one line
"""

print("Hello, World!")
```

## Codebyte Example

Here are some examples of comments in a Python program:

```codebyte/py
"""
Tip Calculator
Written by Sonny
"""

# Calculate tip
tip = 18.95 * 0.2

# Output tip
print(tip)
```


Conditionals take an expression, which is code that evaluates to determine a value, and checks if it is True or False. If it’s True, we can tell our program to do one thing — we can even account for False to do another. As we write more complex programs, conditionals allow us to address multiple scenarios and make our programs more robust. The Python if statement is used to determine the execution of code based on the evaluation of a Boolean expression. - If the if statement expression evaluates to True, then the indented code following the statement is executed. - If the expression evaluates to False then the indented code following the if statement is skipped and the program executes the next line of code which is indented at the same level as the if statement. py test_value = 100

Conditionals

Conditionals take an expression, which is code that evaluates to determine a value, and checks if it is `True` or `False`. If it’s `True`, we can tell our program to do one thing — we can even account for `False` to do another.

As we write more complex programs, conditionals allow us to address multiple scenarios and make our programs more robust.

## If Statement

The Python `if` statement is used to determine the execution of code based on the evaluation of a Boolean expression.

- If the `if` statement expression evaluates to `True`, then the indented code following the statement is executed.
- If the expression evaluates to `False` then the indented code following the if statement is skipped and the program executes the next line of code which is indented at the same level as the if statement.

```py
test_value = 100

if test_value > 1:
  print("This code is executed!")

if test_value > 1000:
  print("This code is NOT executed!")

print("Program continues at this point.")
```

## Else Statement

The Python `else` statement provides alternate code to execute if the expression in an if statement evaluates to `False`.

The indented code for the `if` statement is executed if the expression evaluates to `True`. The indented code immediately following the `else` is executed if and only if the expression evaluates to `False`.

To mark the end of the else block, the code must be unindented to the same level as the starting if line.

```py
test_grade = 61

if test_grade > 60:
  print("You passed.")
else:
  print("You failed.")

# Output: You passed.
```

## Elif Statement

The Python `elif` statement allows for continued checks to be performed after an initial `if` statement. An `elif` statement differs from the else statement because another expression is provided to be checked, just as with the initial `if` statement.

If the expression is `True`, the indented code following the `elif` is executed. If the expression evaluates to False, the code can continue to an optional `else` statement.

Multiple elif statements can be used following an initial `if` to perform a series of checks. Once an `elif` expression evaluates to `True`, no further `elif` statements are executed.

```py
pet_type = "fish"

if pet_type == "dog":
  print("You have a dog.")
elif pet_type == "cat":
  print("You have a cat.")
elif pet_type == "fish":
  # This is performed
  print("You have a fish")
else:
  print("Not sure!")
```

## Codebyte Example

```codebyte/py
pH = 2

if pH < 7:
  print("Acidic")
elif pH > 7:
  print("Basic")
else:
  print("Neutral")
```

What do you think will happen if `pH` is changed to 7?


Python is a strongly typed language. Strongly typed means that the data type of a value doesnt change in unexpected ways. py codecademy = 575 codecademy = "575 broadway"  After line 1, codecademy is an int. After line 2, codecademy is a str. Here are Pythons built-in data types:

Data Types

Python is a strongly typed language. Strongly typed means that the data type of a value doesn't change in unexpected ways.

```py
codecademy = 575
codecademy = "575 broadway"
```

After line 1, `codecademy` is an `int`. After line 2, `codecademy` is a `str`.

Here are Python's built-in data types:

- String type: `str`
- Boolean type: `bool`
- Binary types: `bytes`, `bytearray`, `memoryview`
- Number types: `int`, `float`, `complex`
- Sequence Types: `list`, `range`, `tuple`
- Set types: `set`, `frozenset`
- Dictionary type: `dict`

## type()

To find the data type of any object, the `type()` function can be used:

```py
message = "Hello, world!"

print(type(message))
```

This will output:

```shell
<class 'str'>
```

## isinstance()

You can also use the built-in `isinstance()` function to test if a variable is an instance of a specified type:

```py

word = "purple"
languages = ("Python", "JavaScript", "Go")

print(isinstance(word, str))
print(isinstance(languages, list))
print(isinstance(languages, tuple))
```

This will print a boolean value for each function call indicating if the object is an instance of the given type:

```shell
True
False
True
```


The built-in Python module called datetime is used to create and modify dates and times.

Dates

Python has a built-in module called [datetime](https://docs.python.org/3/library/datetime.html) that can be used to create and modify `datetime` objects.

Because the module comes built-in with Python, installation is not required, but we do need to import it at top of a Python file.

As an example, the code below employs the `.datetime.now()` method to return the current date and time:

```codebyte/py
import datetime

current_datetime = datetime.datetime.now()

print(current_datetime)
```

The result will be the current date and time, something like:

```shell
2022-10-05 10:20:57.944968
```

It contains the year, month, day, hour, minute, second, and microsecond:

```pseudo
YYYY-MM-DD hh:mm:ss.ffffff
```

## Creating New datetime Objects

The `datetime` module has three main types available:

- `date`
- `time`
- `datetime`

```py
import datetime

# Create date object with year=2021, month=10, and day=5
meeting_date = datetime.date(2021, 10, 5)

# Create time object with hour=10, minute=5, and seconds=31
meeting_time = datetime.time(10, 5, 31)

# Create datetime object with year=2021, month=10, day=5, hour=10, minute=5 and seconds=31
meeting = datetime.datetime(2021, 10, 5, 10, 5, 31)
```

Furthermore, we also have a `timedelta` type which is used to represent time difference.

```py
timedelta(days, seconds, microseconds, milliseconds, minutes, hours, weeks)
```

Note that all of the arguments are optional and have default value of 0.

## Operations on datetime Objects

We can perform different operations on a `datetime` object.
For example, if we want to add 2 months to a current date, it can be done as below:

```codebyte/py
import datetime

# Assign current datetime
current_date = datetime.datetime.now()

date_after_two_months = current_date + datetime.timedelta(days = 30*2)

print(date_after_two_months)
# Displays date 2 months from current date
```

Date and time differences can be calculated using the subtraction operator `-` on `datetime` objects.

```codebyte/py
import datetime

# Assign current datetime
current_date = datetime.datetime.now()

date_after_interval = datetime.datetime(2023, 10, 5)

date_difference = date_after_interval - current_date

print(date_difference)
# Displays date interval
```


Decorators are a structural design pattern that wrap the original object, to add extra functionality dynamically, without modifying the original object. Decorators are usually used to run code before and/or after a function. Thus, they decorate the function with additional functionality, without changing the original function. They can also be used to alter the functionality of methods and classes.

Decorators

Decorators are a structural design pattern which wrap the original object, to add extra functionality dynamically, without modifying the original object. Decorators are usually used to run code before and/or after a function. Thus, they decorate the function with additional functionality, without changing the original function. They can also be used to alter the functionality of methods and classes.

## Creating Decorators

Functions in Python are first class objects: they can be assigned to variables, passed into functions as arguments, returned from functions and declared inside functions.

With that in mind, a decorator can be created using functions or classes.

### Decorator using Functions

The general syntax for creating a decorator using functions is as follows:

```py
def decorator_name(original_function):

  def wrapper():
    # Code can be executed before the original function call

    original_function()

    # Code can be executed after the original function call

  return wrapper
```

The `original_function()`, in this case, is the function that is decorated with the `decorator_name()`.

For example, a decorator that upper cases the returned values from any function can be created as follows:

```py
# Define a function called upper_case_decorator() which will act as a decorator with parameter original_function

def upper_case_decorator(original_function):

  # Creating the wrapper to wrap additional code around the original function
  def wrapper():

    # Code can be executed before the original function
    print(f"'{original_function.__name__}' function execution will start now.")

    # Original function call with the upper cased argument
    result = original_function(arg1)

    # Code can be executed after the original function
    result = result.upper()
    return result

  # Return the wrapper function
  return wrapper
```

### Decorator using Classes

The general syntax for creating a decorator using classes is as follows:

```py
class decorator:

  def __init__(self, original_function):
    self.original_function = original_function


  def __call__(self):
    # Code can be executed before the original function

    # original function call with the upper cased argument
    self.original_function()

    # Code can be executed after the original function
```

For example, a decorator created using class based syntax that upper cases the return values from any function:

```codebyte/py
# Define a class called upper_case_decorator_with_class which will act as a decorator with the __init__ method requiring a parameter original_function

class upper_case_decorator_using_class:

  def __init__(self, original_function):
    self.original_function = original_function


  def __call__(self):
    # Code can be executed before the original function
    print(f"'{self.original_function.__name__}' function execution will start now.")

    # Original function call with the upper cased argument
    result = self.original_function()

    # Code can be executed after the original function
    result = result.upper()
    return result
```

## Applying Decorator to a Function

The decorators created above accept an argument called `original_function` which can be any function. Therefore, we create a `greeting()` function and decorate it with the `@upper_case_decorator`.

```py
def greeting():
  return "hello Dharma"
```

`greeting()` function can be decorated with the common python syntax by calling the decorator function and assigning the result back to `greeting`.

```py
# Without using the @decorator syntax

greeting = upper_case_decorator(greeting)

print(greeting())
# Output: HELLO DHARMA
```

However, Python provides a simpler way to achieve the same result using the `@` symbol syntax. Add the line `@upper_case_decorator` at the start of function definition to decorate it.

```py
# Using the @decorator syntax

@upper_case_decorator
def greeting():
  return 'hello Dharma'

print(greeting())
# Output: HELLO DHARMA
```

`@upper_case_decorator` or `@upper_case_decorator_with_class` can be used to decorate other functions as well.

```py
@upper_case_decorator_with_class
def farewell():
  return 'bye'

farewell()
# Output: BYE
```

The full code with a decorator created using function will be:

```codebyte/py
def upper_case_decorator(original_function):

    def wrapper():
        result = original_function()
        result = result.upper()
        return result
    return wrapper

@upper_case_decorator
def greeting():
    return 'hello Dharma'

class upper_case_decorator_using_class:

  def __init__(self, original_function):
    self.original_function = original_function


  def __call__(self):
    # Code can be executed before the original function
    print(f"'{self.original_function.__name__}' function execution will start now.")

    # original function call with the upper cased argument
    result = self.original_function()

    # Code can be executed after the original function
    result = result.upper()
    return result

@upper_case_decorator_using_class
def farewell():
    return 'bye'

print(greeting())
print(farewell())
```

## Passing arguments to the Decorated functions

Arguments can be passed to the original function by creating parameters in the `wrapper()` function.

Eg: `arg1` is the parameter that the original function `greeting()` requires. Thus, the `wrapper()` function receives it and passes it along to the original function call.

```codebyte/py
def upper_case_decorator(original_function):

    # arg1 is received by the wrapper
    def wrapper(arg1):

        # arg1 is passed to the original function from the wrapper.
        result = original_function(arg1)

        result = result.upper()
        return result

    return wrapper

@upper_case_decorator
def greeting(arg1):
    return arg1 + '!'


print(greeting('hi'))

# output:
# HI!

```

General purpose decorators can be also be created that can accept any number of arguments by packing positional arguments using `*args` and by packing keyword arguments using `**kwargs`.

```py
def general_decorator(original_function):

    # accepting variable number of arguments
    def wrapper(*args, **kwargs):
        func(args, kwargs)

    return wrapper

@general_decorator
def original_function(args, kwargs):
    # code for the function
```

An example of variable arguments accepting decorator is as follows:

```codebyte/py
def upper_case_decorator(original_function):

    def wrapper(*arg1, **kwargs):

        result = original_function(*arg1)

        result = result.upper()
        return result
    return wrapper


@upper_case_decorator
def greeting(arg1):
    return arg1 + "!"


@upper_case_decorator
def double_greeting(arg1, arg2):
    return arg1 + ". " + arg2 + "!"


print(greeting('hi'))
# output:
# HI!

print(double_greeting('hi', 'hello'))
# Output:
# HI. HELLO!

```

## Passing Arguments to Decorators

Arguments can also be passed to the decorator itself. To pass arguments to the decorator, there should be a `decorator_wrapper_to_accept_decorator_arguments()` function wrapping the original decorator.

```py
def decorator_wrapper_to_accept_decorator_arguments(decorator_arg1, decorator_arg2):

    def decorator(original_function):

        def wrapper(*args, **kwargs):
            original_function(args, kwargs)

        return wrapper

    # (IMPORTANT)
    return decorator

@decorator_wrapper_to_accept_decorator_arguments('value 1', 'value 2')
def function_name(arg):
  # statements

```

Eg: With the greeting function, the decorator could be setup to use a `number_of_times_to_greet` parameter to greet once or more than once.

```py
def upper_case_decorator_wrapper(number_of_times_to_greet):
    def upper_case_decorator(original_function):

        def wrapper(*arg1, **kwargs):

            result = ""
            for i in range(number_of_times_to_greet):
                result += original_function(*arg1, **kwargs)
            result = result.upper()
            return result
        return wrapper

    return upper_case_decorator


@upper_case_decorator_wrapper(1)
def greeting(arg1):
    return arg1 + "!"


@upper_case_decorator_wrapper(2)
def greeting_twice(arg1):
    return arg1 + "!"


print(greeting('hi'))
# output:
# HI!

print(greeting_twice('hi'))
# output:
# HI!HI!

```

Even though, `greeting()` and `greeting_twice()` have the exact same function definition, their outputs are different because the decorator is executing these functions as per the `number_of_times_to_greet` argument passed to the decorator.

## `help()` with Decorators

The original function name and docstring are lost when it's wrapped by a decorator.

```codebyte/py
def upper_case_decorator(original_function):

    def wrapper():
        """decorates a function by uppercasing the return value"""

        result = original_function()
        result = result.upper()
        return result

    return wrapper

@upper_case_decorator
def greeting():
    """ returns a str greeting """
    return 'hello Dharma'

print(greeting.__name__)
print(greeting.__doc__)


# output:
# wrapper
# decorates a function by uppercasing the return value
```

The name of the function is `greeting()` and not `wrapper()`. The decorator completely hides the function and it's docstring. This also means that the `help(greeting)` call will be completely useless since it'll have no information about the `greeting()` function.

To solve this problem, python provides a decorator. `@functools.wraps()` decorator can be used to decorate the `wrapper()` function.

```codebyte/py
import functools

def upper_case_decorator(original_function):

    @functools.wraps(original_function)
    def wrapper():
        """ decorates a function by uppercasing the return value"""
        result = original_function()
        result = result.upper()
        return result
    return wrapper


@upper_case_decorator
def greeting():
    """returns a str greeting"""
    return 'hello Dharma'

print(greeting.__name__)
print(greeting.__doc__)


# output:
# greeting
# returns a str greeting
```

## Example Decorators

### Decorators can be used to measure the performance of a function

```codebyte/py
import functools
import time


def performance_measure(original_function):

    @functools.wraps(original_function)
    def wrapper(loop_val):
        """ decorates a function by measuring time for it's execution"""
        start_time = time.perf_counter()
        result = original_function(loop_val)
        stop_time = time.perf_counter()
        print(stop_time - start_time)
        return result
    return wrapper


@performance_measure
def long_loop(loop_value):
    for i in range(loop_value):
        pass


long_loop(10000)
long_loop(100000000)

```

### Decorators are used to create specialized functions

Special functions like 'once' that would only execute one time even if they're called more than once, can be created using decorators.

```codebyte/py
import functools


def run_once(original_function):
    has_run = False

    @functools.wraps(original_function)
    def wrapper():
        nonlocal has_run
        if not(has_run):
            original_function()
            has_run = True
        else:
            print("This function can no longer be executed")
    return wrapper


@run_once
def print_name():
    print("Dharma")


print_name()
print_name()

# output:
# Dharma
# This function can no longer be executed.
```


A dictionary is an ordered set of key-value pairs. It provides a way to map pieces of data to each other and allows for quick access to values associated to keys.

Dictionaries

A dictionary is an ordered set of key-value pairs. It provides a way to map pieces of data to each other and allows for quick access to values associated with keys. Keys must be unique in dictionaries, but the values don't have to be.

Python dictionaries are dynamic and mutable, which means they can change.

If you assign a value to an already existing dictionary key, it does not add the key a second time. Instead, it replaces the existing value. Dictionaries also have several built-in methods which make it easier to manipulate the data structure and objects contained within.

**Note:** As of Python version 3.7, dictionaries are ordered based on insertion, but this is not the case in Python 3.6 and earlier.

## Syntax

The syntax of a dictionary is as follows:

```pseudo
dictionary_name = { key1: value1,  key2: value2,  key3: value3 }
```

Each entry in a dictionary is a key-value pair. Each pair is separated by a comma.

Dictionary keys must be immutable types such as numbers and strings because keys should not change. Keys cannot be lists because lists are mutable, and it will raise a `TypeError`.

Values can be any type, such as strings, numbers, lists, and even other dictionaries.

## Creating a Dictionary

An empty dictionary is created with curly braces:

```py
diner = {}
```

An empty dictionary can also be created using the built-in function, `dict()`, with no arguments:

```py
diner = dict()
```

A dictionary with entries:

```py
coffee_shop = { "cold brew": 3.50, "latte": 4.25, "cappucino": 3.99 }
```

The three key-value pairs in the `coffee_shop` dictionary:

- `"cold brew": 3.50`
- `"latte": 4.25`
- `"cappucino": 3.99`

## Accessing a Dictionary

The values in a dictionary can be accessed by passing the associated key name:

```py
coffee_shop = { "cold brew": 3.50, "latte": 4.25, "cappucino": 3.99 }

print(coffee_shop["cold brew"])
# Output: 3.5
```

When you try to access a key that does not exist, it will raise a `KeyError`.

## Iterating Through a Dictionary

There are several ways to iterate through a dictionary depending on which data you want to access: keys, values, or both.

The following codebyte consists of four `for` loops that iterate through the `coffee_shop` dictionary:

```codebyte/py
coffee_shop = { "cold brew": 3.50, "latte": 4.25, "cappucino": 3.99 }

for key in coffee_shop.keys():
    print(key)

for value in coffee_shop.values():
    print(value)

for item in coffee_shop.items():
    print(item)

for key, value in coffee_shop.items():
    print(key, value)
```

The `for` loops access and print each key, value, key-value tuple, and individual key-values in `coffee_shop`, respectively.

## Adding an Entry

To add an entry, use square brackets to create an index into a `new_key` and assign it a `new_value`:

```py
my_dict[new_key] = new_value
```

## Creating a Dictionary using Dictionary Comprehension

Like a list comprehension, a dictionary comprehension is a Pythonic way to create a dictionary. They can be used to filter and manipulate data in tons of useful ways. The syntax is as follows:

```py
new_dict = { expression for key, value in old_dict.items() if condition }
```

The `if` condition at the end is optional, but is a great tool for filtering data. For example, given a dictionary with a person's name and age, make a new dictionary that only contains people with an age under 25:

```py
person_age = { "Mark": 55, "Shiela": 28, "Bryce": 24, "Jim": 41, "Eric": 33, "Ally": 23 }
person_age_filtered = { name: age for name, age in person_age.items() if age < 25 }
```

The expression is `name: age`, as that's how the new dictionary will be formatted. Then, the typical for loop iteration, `for name, age in person_age.items()`. Lastly, the `if` condition filters out the results.

The expression can also perform operations on the data being extracting. For example, to create a dictionary with key value pairs of a number and its square given a list of numbers:

```py
nums_list = [ 1, 2, 3, 4, 5 ]
nums_squared = { num: num**2 for num in nums_list }
```

`nums_squared` will produce a result of: `{ 1: 1, 2: 4, 3: 9, 4: 16, 5: 25 }`


There are (at least) two distinguishable kinds of errors in Python: syntax errors and exceptions. Syntax errors, also known as parsing errors, are perhaps the most common kind of complaint you get while you are still learning Python: error File "script.py", line 1 while True print("Hello world!") ^ SyntaxError: invalid syntax

Errors

There are (at least) two distinguishable kinds of errors in Python: syntax errors and exceptions.

## Syntax Errors

Syntax errors, also known as parsing errors, are perhaps the most common kind of complaint you get while you are still learning Python:

```error
File "script.py", line 1
  while True print("Hello world!")
                   ^
SyntaxError: invalid syntax
```

The parser repeats the offending line and displays a little arrow `^` pointing at the earliest point in the line where the error was detected.

The error is caused by (or at least detected at) the token preceding the arrow in the example, the error is detected at the function `print()`, since a colon `:` is missing before it.

File name and line number are printed so you know where to look in case the input came from a script.

## Exceptions

Even if a statement or expression is syntactically correct, it may cause an error when an attempt is made to execute it. Errors detected during execution are called exceptions and are not unconditionally fatal. Most exceptions are not handled by programs, however, and result in error messages as shown here:

### Value Error

`ValueError` is thrown when a function's argument is of an inappropriate type.

```error
Traceback (most recent call last):
File "script.py", line 1, in <module>
int('xyz')
ValueError: invalid literal for int() with base 10: 'xyz'
```

### Name Error

`NameError` is thrown when an object could not be found.

```error
Traceback (most recent call last):
File "script.py", line 1, in <module>
age
NameError: name 'age' is not defined
```

### Index Error

`IndexError` is thrown when trying to access an item at an invalid index.

```error
Traceback (most recent call last):
File "script.py", line 1, in <module>
employees[3]
IndexError: list index out of range
```

### Module Not Found Error

`ModuleNotFoundError` is thrown when a module could not be found.

```error
Traceback (most recent call last):
File "script.py", line 1, in <module>
import notamodule
ModuleNotFoundError: No module named 'notamodule'
```

### Zero Division Error

`ZeroDivisionError` is thrown when the second operator in the division is zero.

```error
Traceback (most recent call last):
File "script.py", line 1, in <module>
ratio = 100 / 0
ZeroDivisionError: division by zero
```


Files are named locations on disk to store related information. They are used to permanently store data in a non-volatile memory (e.g. hard disk). Since Random Access Memory (RAM) is volatile (which loses its data when the computer is turned off), we use files for future use of the data by permanently storing them. When we want to read from or write to a file, we need to open it first. When we are done, it needs to be closed so that the resources that are tied with the file are freed. Hence, in Python, a file operation takes place in the following order: 1. Open a file 2. Read or write (perform operation) 3. Close the file

File Methods

Files are named locations on disk to store related information. They are used to permanently store data in a non-volatile memory (e.g. hard disk).

Since Random Access Memory (RAM) is volatile (which loses its data when the computer is turned off), we use files for future use of the data by permanently storing them.

When we want to read from or write to a file, we need to open it first. When we are done, it needs to be closed so that the resources that are tied with the file are freed.

Hence, in Python, a file operation takes place in the following order:

1. Open a file
2. Read or write (perform operation)
3. Close the file

File handling is an important part of any web application.

Python has a set of methods available for creating, reading, updating, and deleting files:


Some tasks need to be performed multiple times within a program. Rather than rewrite the same code in multiple places, a function may be defined using the def keyword. Function definitions may include parameters, providing data input to the function. Functions may return a value using the return keyword followed by the value to return. py def myfunction(x): return x + 1 print(myfunction(2)) # Output: 3 print(my_function(3 + 5)) # Output: 9

Functions

Some tasks need to be performed multiple times within a program. Rather than rewrite the same code in multiple places, a function may be defined using the `def` keyword. Function definitions may include parameters, providing data input to the function.

Functions may return a value using the `return` keyword followed by the value to return.

```py
# Define a function my_function() with parameter x

def my_function(x):
  return x + 1

# Invoke the function

print(my_function(2))      # Output: 3
print(my_function(3 + 5))  # Output: 9
```

## Calling Functions

Python uses simple syntax to use, invoke, or call a preexisting function. A function can be called by writing the name of it, followed by parentheses.

For example, the code provided would call the `doHomework()` function.

```py
doHomework()
```

## Function Parameters

Sometimes functions require input to provide data for their code. This input is defined using parameters.

Parameters are variables that are defined in the function definition. They are assigned the values which were passed as arguments when the function was called, elsewhere in the code.

For example, the function definition defines parameters for a character, a setting, and a skill, which are used as inputs to write the first sentence of a book.

```py
def write_a_book(character, setting, special_skill):
  print(character + " is in " +
        setting + " practicing her " +
        special_skill)
```

## Returning Value from Function

The `return` keyword is used to return a value from a Python function. The value returned from a function can be assigned to a variable which can then be used in the program.

In the example, the function `check_leap_year()` returns a string which indicates if the passed parameter is a leap year or not.

```codebyte/py
def check_leap_year(year):
  if year % 4 == 0:
    return str(year) + " is a leap year."
  else:
    return str(year) + " is not a leap year."

year_to_check = 2018

returned_value = check_leap_year(year_to_check)

print(returned_value)
```

## Recursion

Functions in Python can call themselves — a concept known as "recursion". Recursion provides an elegant way to solve problems by breaking them down into smaller, more easily-solvable parts, and using those parts to build up a solution.

Consider the Fibonacci sequence, whose first two terms are explicitly defined to be 0 and 1. Each subsequent term is constructed by taking the sum of the previous two terms. Thus, the first six terms of the sequence are 0, 1, 1, 2, 3, and 5.

Defining a function that prints the `n`-th Fibonacci number is most easily achieved using recursion.

```codebyte/py
def fibonacci(n):
  if n <= 1:
    # Base cases
    return n
  else:
    # Sum of the previous two terms
    return fibonacci(n - 2) + fibonacci(n - 1)

for i in range(6):
  print(fibonacci(i))
```

Notice how inside the `fibonacci()` function, it calls itself.

## Higher-Order Functions

In Python, functions are treated as "first-class objects". This means that they can be assigned to variables, stored in data structures, and passed to or returned from other functions.

A function is considered to be of "higher-order" if it takes a function as a parameter or returns a function. One example is the built-in `filter()` function:

```py
# Returns true if n is a perfect square, and false otherwise

def is_perfect_square(n):
  return (n ** 0.5).is_integer()

numbers = [3, 4, 37, 9, 7, 32, 25, 81, 79, 100]

perfect_squares = filter(is_perfect_square, numbers)

print(list(perfect_squares))
# Output: [4, 9, 25, 81, 100]
```

`filter()` takes a predicate (a function that returns a boolean value) and an iterable, and returns a new iterable containing all elements of the first one that make the predicate true.

## Anonymous Functions

The act of defining a function using the `def` keyword binds that function to a name. However, functions can also be defined without giving them a name. Such functions are called "anonymous" and are defined using the `lambda` keyword.

```pseudo
lambda <parameters> : <function body>
```

The following two definitions are equivalent.

```py
def add(a, b):
  return a + b
```

```py
add = lambda a, b: a + b
```

The expression to the right of the assignment operator is called a "lambda expression". The Python interpreter takes this expression and defines a function object which can be bound to an identifier (in this case, `add`). There is no difference between binding a function to a name using the assignment operator or by using the `def` keyword.

Lambda expressions are most commonly used to define simple, single-use functions which are passed to higher-order functions.

```py
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

odd_numbers = filter(lambda n : n % 2 == 1, numbers)

print(list(perfect_squares))
# Output: [1, 3, 5, 7, 9]
```

For more complex functions with larger bodies, it is recommended to use the `def` keyword to keep code readable.


In Python, a while loop will repeatedly execute a code block as long as a condition evaluates to True. The condition of a while loop is always checked first before the block of code runs. If the condition is not met initially, then the code block will never run. pseudo while condition: # Code inside  This loop will only run 1 time:

Loops

## While Loops

In Python, a `while` loop will repeatedly execute a code block as long as a condition evaluates to `True`.

The condition of a `while` loop is always checked first before the block of code runs. If the condition is not met initially, then the code block will never run.

```pseudo
while condition:
  # Code inside
```

This loop will only run 1 time:

```py
hungry = True

while hungry:
  print("Time to eat!")
  hungry = False
```

This loop will run 5 times:

```py
i = 1

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

## For Loop

Python `for` loops can be used to iterate over and perform an action one time for each element in a list.

Proper for loop syntax assigns a temporary value, the current item of the list, to a variable on each successive iteration:

```py
for <temporary value> in <a list>:
```

`for` loop bodies must be indented to avoid an `IndentationError`.

```python
dog_breeds = ["boxer", "bulldog", "shiba inu"]

# Print each breed:
for breed in dog_breeds:
  print(breed)
```

## Nested Loops

In Python, loops can be nested inside other loops. Nested loops can be used to access items of lists which are inside other lists. The item selected from the outer loop can be used as the list for the inner loop to iterate over.

```py
groups = [["Jobs", "Gates"], ["Newton", "Euclid"], ["Einstein", "Feynman"]]

# This outer loop will iterate over each list in the groups list
for group in groups:
  # This inner loop will go through each name in each list
  for name in group:
    print(name)
```

## Break Keyword

In a loop, the `break` keyword escapes the loop, regardless of the iteration number. Once break executes, the program will continue to execute after the loop.

```py
numbers = [0, 254, 2, -1, 3]

for num in numbers:
  if (num < 0):
    print("Negative number detected!")
    break
  print(num)
```

In this example, the output would be:

```shell
0
254
2
Negative number detected!
```

## Continue Keyword

In Python, the `continue` keyword is used inside a loop to skip the remaining code inside the loop code block and begin the next loop iteration.

```py
big_number_list = [1, 2, -1, 4, -5, 5, 2, -9]

# Print only positive numbers:
for i in big_number_list:
  if i < 0:
    continue
  print(i)
```


Python has a built-in math module that we can use for mathematical tasks. This module provides access to the mathematical functions defined by the C standard. The following functions are provided by this module. Except when explicitly noted otherwise, all return values are floats.

Math Module

Python has a built-in `math` module that we can use for mathematical tasks. This module provides access to the mathematical functions defined by the C standard.

The following functions are provided by this module. Except when explicitly noted otherwise, all return values are `float`s.


A module is a Python file that contains functions, definitions, and statements that can be included in an application.

Modules

A module is a Python file that contains functions, definitions, and statements that can be included in an application.

Think of a module as a code library that can be reused across applications. Modules improve code reusablity and allow us to access shared libraries and packages.

Instead of entering commands directly into a Python interpreter, Python code can be saved as a module so that we can use it again later in other applications. Modules can also be used to access libraries such as `numpy`, `sklearn`, and the `date-time` built-in module.

## Creating and Importing Modules

A module can be created by saving a Python file with the **.py** file extension. It can then be imported into another Python file with the `import` command followed by the module name.

For example, to import a **video_player.py** file:

```py
import video_player

# Rest of the program starts here...
```

The program now has access to all functions, objects, and statements contained within the `video_player` module.

## Importing Specific Resources

Instead of importing the whole module, individual named resources can be specified. For example:

```py
from collections import Counter
```

This will import only the `Counter` class from Python's `collections` built-in module, rather than all types of collections contained within it.

It's often useful to import only the resources that you need to avoid slowing down your program and polluting your local namespace where your code runs.

## Namespaces and Scope

A module within our local namespace can be renamed by creating an alias using the `as` keyword. For example:

```py
from bs4 import BeautifulSoup as bs
```

Aliasing is especially convenient for shortening module names and managing the local namespace where our code executes.

Once a module is imported, it is within the scope of the program and it can be accessed in the local namespace.


A modulo calculation returns the remainder of the division between two numbers.

Modulo

In Python, the percent sign (`%`) is known as the modulo operator.

A modulo calculation returns the remainder of the division between two numbers.

## Example 1

```py
x = 12 % 5

print(x) # Output: 2
```

Because 12 is not evenly divisible by 5, the value of `x` is 2.

## Example 2

```py
y = 10 % 5

print(y) # Output: 0
```

Because 10 is evenly divisible by 5, the value of `y` is 0.

## Codebyte Example

```codebyte/py
# Check if even or odd

num = 499

if (num % 2) == 0:
  print(num, "is even.")
else:
  print(num, "is odd.")
```


Operators are used to perform operations on variables and values. In the example below, we use the + operator to add together two values: py print(10 + 5)  Python divides the operators in the following groups: - Arithmetic operators

Operators

Operators are used to perform operations on variables and values.

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

```py
print(10 + 5)
```

Python divides the operators in the following groups:

- Arithmetic operators
- Assignment operators
- Comparison operators
- Logical operators

## Arithmetic Operators

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

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

## Assignment Operators

Assignment operators are used to assign values to variables:

- `+=`
- `-=`
- `*=`
- `/=`
- `%=`

## Comparison Operators

Comparison operators are used to compare two values:

| Operator | Name                     | Example  |
| -------- | ------------------------ | -------- |
| `==`     | Equal                    | `a == b` |
| `!=`     | Not equal                | `a != b` |
| `<`      | Less than                | `a < b`  |
| `>`      | Greater than             | `a > b`  |
| `<=`     | Less than or equal to    | `a <= b` |
| `>=`     | Greater than or equal to | `a >= b` |

## Logical Operators

Logical operators are used to combine conditional statements:

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


pip offers practical ways to install and use pre-made code for Python.

[pip](https://pypi.org/project/pip) is the package installer used in Python to install code packages. A similar tool is Node Package Manager ([npm](https://www.codecademy.com/resources/docs/javascript/npm)) in JavaScript. Much like npm, `pip` is the same community-driven package space, but for Python.

## Packages

The concept of packages is not unique to `pip`. A package is a collection of code that is designed for a specific purpose. These packages are also meant to be re-used and distributed by other developers.

One example is [Flask](https://pypi.org/project/Flask/). Much like how [Express](https://expressjs.com/) can facilitate the creation of server routes for backend development in JavaScript, Flask can offer the same reproducible and concise solution for developers who use Python.

## Python Package Index Repository (PyPI)

The [Python Package Index Repository](https://pypi.org/) (PyPI), hosts a large collection of packages. The official package installer of PyPI is `pip`, which is used in the command line. A good practice to understand how to use a package is reading its documentation on PyPI.

Documentation on PyPI typically comes with the following:

- A list of requirements to run the package.
- Instructions for installing the package.
- One or more examples of how the package is implemented.

## `pip` Installation

`pip` commonly comes with the installation of Python. Therefore, the first step in installing `pip` is verifying that it is already installed. This step can vary between versions of Python as well as what machine it is running on. The examples below are for version 3.6.3 and above. A good resource for more specific instructions would be the [official Python tutorial on installing packages](https://packaging.python.org/tutorials/installing-packages/).

```shell
# Windows
py --version

# Linux/macOS
python3 --version
```

It should be noted that as per the [pip documentation](https://pip.pypa.io/en/stable/development/release-process/?highlight=python%202#:~:text=pip%E2%80%99s%20public%20API.-,Python%202%20Support,-%C2%B6), `pip` maintainers are no longer supporting Python 2 and below.

To upgrade Python, [python.org](python.org) will have the latest version for install. In addition, Python 3.4 and above will have `pip` [installed by default](https://docs.python.org/3/installing/index.html#key-terms).

The following command is run to check the latest version `pip`:

```shell
# Windows
py -m pip --version

# Linux/macOS
python -m pip --version
```

If `pip` is already installed, its version will appear in the terminal.

If `pip` is out of date, the following command will upgrade it:

```shell
# Windows
py -m pip install --upgrade

# Linux/macOS
python -m pip install --upgrade
```

Finally, it is now possible to start installing packages from PyPI. In the following example, a fake package called `ACoolPackage` will be used. This isn't a real package on PyPI, rather it is just a placeholder for a real package. It is recommended to visit the PyPI page of the package being installed for more specific instructions.

```shell
py -m pip install ACoolPackage
```


Python has a special module called random that can be used to randomly generate or modify integers, floats, lists, and strings. In order to use the random module, import it at the top of a Python file: py import random  For example, the .random() method will generate a float greater than or equal to 0.0 and less then 1.0. codebyte/py

Random Module

Python has a special module called [random](https://docs.python.org/3/library/random.html) that can be used to randomly generate or modify integers, floats, lists, and strings.

In order to use the `random` module, import it at the top of a Python file:

```py
import random
```

For example, the `.random()` method will generate a float greater than or equal to 0.0 and less then 1.0.

```codebyte/py
import random

my_number = random.random()

print(my_number)
```

The result should be different every time `.random()` is called. It should be a random number between 0.0 and 1.0, including 0.0 and excluding 1.0.

## Generating Random Numbers

The random module can generate random integers rather than floats by using `.randint(a, b)`, where `a` and `b` are integers. This generates a number between `a` and `b` inclusive.

```codebyte/py
import random

dice_roll = random.randint(1, 6)

print(dice_roll)
# Output: Either 1, 2, 3, 4, 5, or 6
```

Alternatively, to generate a random float between `a` and `b`, use the `.uniform(a, b)` method. However, unlike `.randint(a, b)`, `.uniform(a, b)` is inclusive of `a` but exclusive of `b`:

```codebyte/py
import random

my_number = random.uniform(1, 2)

print(my_number)
# Output: A number between 1.0 and 2.0, including 1.0 and excluding 2.0

my_number = random.uniform(1.5, 10.3)

print(my_number)
# Output: A number between 1.5 and 10.3, including 1.5 and excluding 10.3
```

## Using Random with Lists and Strings

The random module can also be used to modify and interact with lists. For example, to pick a random element from a list, use the `.choice()` method. Because strings are also a form of list, the `.choice()` method can also be used on strings:

```codebyte/py
import random

my_list = ["apples", "bananas", "cherries"]
my_fruit = random.choice(my_list)

print(my_fruit)
# Output: A random fruit from the above list

my_letter = random.choice(my_fruit)

print(my_letter)
# Output: A random letter from the fruit chosen above
```

The random module also has the `.shuffle()` and `.sample(a, b)` methods, both of which randomize all of the elements in a list. `.shuffle()` randomizes the list itself and takes no parameters; `.sample(a, b)` returns a new list, where `a` is the list to randomize and `b` is the number of list elements to return:

```codebyte/py
import random

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
random.shuffle(my_list)

print(my_list)
# Output: my_list in a randomized order

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
random.sample(my_list, len(my_list))

print(my_list)
# Output: my_list is unchanged

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_list = random.sample(my_list, len(my_list))

print(my_list)
# Output: my_list in a randomized order

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_list = random.sample(my_list, 4)

print(my_list)
# Output: Four numbers from my_list in a randomized order
```

The difference between `.shuffle()` and `.sample(a, b)` matters when randomizing strings. Because lists are mutable, they can be changed directly with `.shuffle()`; however, strings are immutable, so using `.shuffle()` on a string will cause an error.

```codebyte/py
import random

my_string = "Codecademy"
random.shuffle(my_string)

print(my_string)
# Output: TypeError: 'str' object does not support item assignment
```

On the other hand `.sample(a, b)` returns a new object rather than modifying the original string, so it can be used:

```codebyte/py
import random

my_string = "Codecademy"
my_list = random.sample(my_string, len(my_string))

print(my_list)
# Output: A randomized list of the letters in "Codecademy"
```

To make the list returned by `.sample(a, b)` a string again, use Python's built in `.join()` method:

```codebyte/py
import random

my_string = "Codecademy"
my_list = random.sample(my_string, len(my_string))
my_string = "".join(my_list)

print(my_string)
# Output: A randomized string of the letters in "Codecademy"
```


Regex, short for Regular Expressions, is a powerful system for searching text. Regular expressions are implemented in a variety of languages including java and python. In Python, regular expressions are available through the re module: python import re  The following are some of the regular expression operations:

Regular Expressions

Regex, short for Regular Expressions, is a powerful system for searching text. Regular expressions are implemented in a variety of languages including java and python.

In Python, regular expressions are available through the `re` module:

```python
import re
```

The following are some of the regular expression operations:


The requests module is the de facto standard for sending HTTP requests in Python. It abstracts the complexities of making requests behind a beautiful, simple API so that you can focus on interacting with services and consuming data in your application. The HTTP request returns a Response Object with all the response data (content, encoding, status, etc). Let’s begin by installing the requests module. To do so, run the following command in the terminal: bash pip install requests 

Requests

The `requests` module is the de facto standard for sending HTTP requests in Python.

It abstracts the complexities of making requests behind a beautiful, simple API so that you can focus on interacting with services and consuming data in your application.

The HTTP request returns a Response Object with all the response data (content, encoding, status, etc).

## Installation

Let’s begin by installing the `requests` module. To do so, run the following command in the terminal:

```bash
pip install requests
```

Once `requests` is installed, you can use it in your program. Importing `requests` looks like this:

```py
import requests
```


A set is an unordered collection of elements without any duplicates. Sets are especially useful for performing logical operations like finding the union, intersection, or difference between collections of elements. For example, sets could be used to determine mutual friends on a social networking site. There are several ways to create a set. We can create a set from a list with the set() keyword: py animals = set() animals = set([aardvark, snail, squid])

Sets

A set is an unordered collection of elements without any duplicates.

Sets are especially useful for performing logical operations like finding the union, intersection, or difference between collections of elements. For example, sets could be used to determine mutual friends on a social networking site.

## Creating a Set

There are several ways to create a set.

We can create a set from a list with the `set()` keyword:

```py
animals = set()
animals = set(['aardvark', 'snail', 'squid'])
```

A set can also be created with curly braces:

```py
oceans = {'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic'}
```

It's important to note that creating a set will remove any duplicate elements. For example:

```py
dog_breeds = {'pug', 'golden retriever', 'corgi', 'pug', 'corgi'}

print(dog_breeds)
# Output: {'pug', 'golden retriever', 'corgi'}
```

This will create a new set with only unique values.

## Set Operations

Sets are especially useful for logical operations such as finding the intersection, union, or difference between collections.

## Union

The `.union()` method or `|` operator can be used to merge two or more sets:

```py
liked_artists1 = {'Grimes', 'Billie Eilish'}
liked_artists2 = set({'Daft Punk', 'Iggy Azalea'})

all_likes = liked_artists1.union(liked_artists2)

print(all_likes)
```

The output would be:

```shell
{'Iggy Azalea', 'Daft Punk', 'Grimes', 'Billie Eilish'}
```

## Intersection

We can use the `.intersection()` method or `&` operator to find the shared elements within two or more sets. For example:

```py
friend_group1= {'Juan', 'Mary', 'David', 'Yukiko', 'Alice'}
friend_group2 = {'Yukiko', 'Peter', 'Juan', 'Alice'}

mutual_friends = friend_group1.intersection(friend_group2)

print(mutual_friends)
```

The output would be:

```shell
{'Yukiko', 'Alice', 'Juan'}
```

## Difference

We can use the `.difference()` method or `-` operator to identify objects unique to a set. For example:

```py
sue_likes = {'Pizza', 'Tofu', 'Poke'}
erika_likes = {'Poke', 'Pizza', 'Popcorn'}

print(sue_likes - erika_likes)
```

This would only print the items unique to the first set:

```shell
{'Tofu'}
```

## Frozensets

Frozensets are a special type of set that are immutable. Like tuples, their contents are frozen and cannot changed after creation.

We can create frozensets with the `frozenset()` function:

```py
frozen_objects = frozenset(['ice cube', 'glacier', 'frozen_set'])
```

Set methods that modify the set such as `.update()`, `.remove()`, and `.add()` cannot be used with frozensets since they are frozen in place!


A string is a sequence of characters contained within a pair of single quotes () or double quotes("). They provide a way to store something like a word, sentence, or whole paragraph. They can be any length and can contain letters, numbers, symbols, and spaces. py message1 = "I am a string" message2 = I am also a string  Other data types such as integers, doubles and booleans, can also be strings as long as they are wrapped in quotes: All of the below are strings:

Strings

A string is a sequence of characters contained within a pair of single quotes (`'`) or double quotes(`"`). They provide a way to store something like a word, sentence, or whole paragraph. They can be any length and can contain letters, numbers, symbols, and spaces.

```py
message1 = "I am a string"
message2 = 'I am also a string'
```

Other data types such as `integers`, `doubles` and `booleans`, can also be `strings` as long as they are wrapped in quotes:

All of the below are strings:

```py
"2"
'3.6'
"True"
```

All of the below are not strings:

```shell
7
Hello
True
```

Strings are immutable, or cannot change. Each time we perform an operation on a string, it will create an entirely new string.

## Accessing Characters of a String

A string can be thought of as a list of characters. Each character has an index, starting from 0.

```py
name = "phillis"
name[0] # "p"
```

If you try to access an index out of bounds, it will return an `IndexError`.

```py
name = "phillis"
name[8] # Throws an IndexError
```

## Multi-line String

Strings can be long or short. If your text is long, you may want to use a multi-line string. Multi-line strings begin and end with three double or single quotes:

```py
my_string = """If it were done when 'tis done, then 'twere well
It were done quickly: if the assassination
Could trammel up the consequence, and catch
With his surcease success; that but this blow
Might be the be-all and the end-all here,
But here, upon this bank and shoal of time,
We'ld jump the life to come."""
```

## Escape Character

Sometimes a string may have a character that Python tries to interpret such as `'`.

```py
my_string = 'It's a lovely day!'

print(my_string)
```

This will give an error because the interpreter thinks that the second `'` marks the end of the string.

```error
  File "main.py", line 1
    my_string = 'It's a lovely day!'
                    ^
SyntaxError: invalid syntax
```

These characters can be "escaped" by adding a backslash beforehand. The `\` is called an escape character.

The backslash will not be visible if the string is printed:

```py
my_string = 'It\'s a lovely day!'

print(my_string)
# Output: It's a lovely day!
```

Python also has a series of non-printable characters that can modify strings. For example, `\n` will add a new line, and `\t` will add a tab:

```codebyte/py
note = "I am on top!\nI am on bottom. \tI am indented!"

print(note)
```

## Modifying Strings

Python has special operators to modify strings. For example, we can use `+` to concatenate two strings or `*` to duplicate a string. We can also use the keyword `in` to see if a given character exists in a `string`.

```py
string_one = "Hello, "
string_two = "World! "
combo = string_one + string_two

print(combo)
# Output: Hello, World!

new_combo = combo * 2

print(new_combo)
# Output: Hello, World! Hello, World!

if "World" in new_combo:
  print("It's here!")
  # Output: It's here!
```

Strings in Python are technically a type of a list, where each character is a separate element in that list. That means we can access different letters in our string the same way we can access items in a list:

```codebyte/py
myString = "Hello, World!"

var_1 = myString[0]
var_2 = myString[7:]
var_3 = myString[1:4]

print("var_1: " + var_1)
print("var_2: " + var_2)
print("var_3: " + var_3)
```

## Built-in String Methods

Python has many built in string methods to manipulate strings. However, when these methods are called, the original string will not be changed, so any modifications will need to be saved to a new variable. A few useful built-in string methods are:


A tuple is a Python data structure used to store an ordered and immutable collection of objects. Tuples are similar to lists, except that tuples cannot be changed after creation. There are multiple ways to create a tuple in Python. Tuples can be created with the built-in tuple() constructor: py streaming_platforms = tuple(["Netflix", "Hulu", "Amazon", "Apple TV"])  We can also create tuples with parentheses:

Tuples

A tuple is a Python data structure used to store an ordered and immutable collection of objects. Tuples are similar to lists, except that tuples cannot be changed after creation.

## Creating a Tuple

There are multiple ways to create a tuple in Python.

Tuples can be created with the built-in `tuple()` constructor:

```py
streaming_platforms = tuple(["Netflix", "Hulu", "Amazon", "Apple TV"])
```

We can also create tuples with parentheses:

```py
mountains = ("Everest", "Kilimanjaro", "Fuji")
```

One-element tuples are a special case. We can create a one-element tuple with a trailing comma:

```py
controller = ("joystick", )
```

Without the trailing comma, Python will interpet the surrounding parentheses as an expression instead of a tuple:

```py
streaming_days = (3)

print(type(streaming_days))
# Output: <class 'int'>
```

## Using a Tuple

Much like lists, since tuples are ordered, we can access tuple elements by index:

```py
streaming_platforms = tuple(["Netflix", "Hulu", "Amazon", "Apple TV"])

print(streaming_platforms[1])
# Output: Hulu
```

However, since tuples are immutable, we cannot modify, delete, or add new elements. For example, attempting to re-assign an element will throw an error:

```py
streaming_platforms = tuple(["Netflix", "Hulu", "Amazon", "Apple TV"])

streaming_platforms[2] = "YouTube"
```

This will result in:

```error
TypeError: 'tuple' object does not support item assignment
```

Tuples also support sequence operations such as `len()`, `min()`, `max()`.


input() is a built-in function in Python that allows a user to assign custom input to a variable. python mycatsname = input("What is your cats name? \n") print("The best cat in the world is " + mycatsname)  When this code is run, it will print out "What is your cats name?". Then, the user can type in something and press enter. Whatever the user types will be saved to the variable mycatsname and printed out in the final print() function. Once a user inputs a value it can be used like a normal variable. For example, it can be compared against other variables:

User Input

`input()` is a built-in function in Python that allows a user to assign custom input to a variable.

```python
my_cats_name = input("What is your cat's name? \n")

print("The best cat in the world is " + my_cats_name)
```

When this code is run, it will print out "What is your cat's name?". Then, the user can type in something and press <kbd>enter</kbd>. Whatever the user types will be saved to the variable `my_cats_name` and printed out in the final `print()` function.

Once a user inputs a value it can be used like a normal variable. For example, it can be compared against other variables:

```python
answer = input("What is the meaning of life? \n")

if answer == "42":
  print("Good job!")
else:
  print("Sorry! That's not it.")
```

In this case, when the code is run, it will print out "What is the meaning of life?". If the user types `"42"` and presses `enter`, it will print "Good job!". If the user types anything other than `"42"`, it will print out "Sorry! That's not it".

Whatever the user types will be saved as a string. However, the string can be converted to other types.

```python
my_num = input("What number comes after 1? \n")

if my_num == 2:
  print("Correct!")
else:
  print("No...")

# Output: No...
```

This always prints "No..." because the string `'2'` does not equal the number `2`.

```python
my_num = input("What number comes after 1? \n")

if int(my_num) == 2:
  print("Correct!")
else:
  print("No...")
```

With the addition of the `int()` type conversion function, this now prints "Correct!" if and only if the user inputs `2`.


A variable is used to store data that will be used by the program. This data can be a number, a string, a Boolean, a list or some other data type. Every variable has a name which can consist of letters, numbers, and the underscore character . The equal sign = is used to assign a value to a variable. After the initial assignment is made, the value of a variable can be updated to new values as needed. A variable can have a short name (like x and y) or a more descriptive name (age, grade, grocerylist). Rules for Python variables: - A variable name must start with a letter or the underscore character. It 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 (num, Num, and NUM are three different variables).

Variables

A variable is used to store data that will be used by the program. This data can be a number, a string, a Boolean, a list or some other data type. Every variable has a name which can consist of letters, numbers, and the underscore character `_`.

The equal sign `=` is used to assign a value to a variable. After the initial assignment is made, the value of a variable can be updated to new values as needed.

## Variable Names

A variable can have a short name (like `x` and `y`) or a more descriptive name (`age`, `grade`, `grocery_list`).

Rules for Python variables:

- A variable name must start with a letter or the underscore character. It 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 (`num`, `Num`, and `NUM` are three different variables).

## Examples

These are all valid variable names and assignment:

```py
user_name = "@sonny420"
user_id = 100
verified = False
```

A variable's value can be changed after assignment

```codebyte/py
points = 100
points = 120

print(points)
```


Lists

Creating a List

Using a Built-in List Method

Lists

Contributors

Learn Python on Codecademy

Learn Python 3

Computer Science

Contributors

Languages

Subjects

Languages