# 60 Days of Learning Python

• Numbers
• Strings
• Booleans
• Lists
• Tuples
• Sets
• Dictionaries

## Numbers

Numbers are used to represent integers, floating point numbers, and complex numbers.

• Integers
``````>>> 1
1
>>> 2
2
``````
• Floats: Floating point numbers are represented in Python using decimal points. Also known as real numbers.
``````  >>> 1.1
1.1
``````
• Complex Numbers: Complex numbers are written in the form, x + yj, where x is the real part and y is the imaginary part.
``````  >>> 1 + 2j
(1+2j)
``````

## Strings

Strings are used to represent text data, the text is given under quote marks. Python treats single quotes the same as double quotes.

• Single Quotes
• Double Quotes
• Triple Quotes: Triple quotes are used to span the string across multiple lines.
``````>>> 'Hello World'
'Hello World'
>>> "Hello World"
'Hello World'
>>> """Hello World"""
'Hello World'
``````
• String Concatenation: Strings can be concatenated (glued together) with the + operator, and repeated with *:
``````>>> 'Hello' + 'World'
'HelloWorld'
>>> 'Hello' * 3
'HelloHelloHello'
``````
• String Slicing: Strings can be sliced (subscripted), with the syntax [start:stop:step]. If start is omitted, it is default to 0. If stop is omitted, it is default to the end of the string. If step is omitted, it is default to 1.
``````>>> word = 'Python'
>>> word  # character in position 0
'P'
>>> word  # character in position 5
'n'
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'
>>> word[:2] + word[2:]
'Python'
``````
• String Methods: Strings have a bunch of useful methods. Some of them are listed below.
``````>>> word = 'Python'
>>> word.upper()
'PYTHON'
>>> word.lower()
'python'
>>> word.startswith('P')
True
>>> word.endswith('n')
True
``````

You can find more string methods here.

## Booleans

Booleans represent one of two values: True or False.

``````>>> True
True
>>> False
False
``````

## Lists

A list is a collection of items in a particular order.
You can make a list that includes the letters of the alphabet, the digits from 0-9.
You can put anything you want into a list, and the items in your list don't have to be related in any particular way.
The syntax for defining a list is to enclose the items in square brackets, with commas between them.

``````>>> [1, 2, 3]
[1, 2, 3]
>>> ['Hello', 'World']
['Hello', 'World']
>>> [1, 'Hello', 2.5]
[1, 'Hello', 2.5]
``````

Characteristics of Lists:

• Ordered
• Mutable
• Allows Duplicate Elements

### Example of List and Manipulating it

``````bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)
print(bicycles)
``````
• Slicing a list => When slicing a list, just as strings, it has 3 parts i.e [start:stop:stepover]
``````    print(bicycles[1:3])
``````
• Duplicating a list - [:] is used to create an entirely new copy of the existing list
``````    new_bicycles = bicycles[1::2]
new_bicycles = 'seat'
print(new_bicycles)
print(bicycles)

```
{% endraw %}

- Matrix: A matrix is a two-dimensional data structure that can store numbers or other types of data ie it's a liat that stores another list inside of them.

### Example of Matrix
{% raw %}

```python
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

print(matrix)
```

### List Methods

- append() => This method adds an item to the end of the list

```python
bicycles.append('word')
``````
• insert() => This method adds an item at a specific index
``````bicycles.insert(0, 'shoo')
``````
• extend() => This method adds multiple items to the end of the list
``````bicycles.extend(['word2', 'word3'])
``````
• remove() => This method removes an item from the list by its value and not by its index
``````bicycles.remove('word2')
``````
• pop() => This method removes the last item from the list and returns the popped item
``````new_bask = bicycles.pop(0)
``````
• clear() => This method removes all the items from the list and returns an empty list
``````bicycles.clear()
``````
• index() => This method returns the index of the first item with the specified value and returns an error if the value is not found

``````print(bicycles.index('word3'))
``````
• count() => This method returns the number of times the specified value appears in the list
``````print(bicycles.count('word3'))
``````

### Common List Patterns

``````bicycles.sort()
bicycles.reverse()

print(bicycles[::-1]) # This is used to reverse a list and it creates a new copy of the list
print(bicycles)

``````

### List Unpacking: This is used to assign multiple variables at once

``````a, b, c, *rest, d = bicycles

print(rest)

print(d)
``````

### Looping through a list

• For Loop
``````for bicycle in bicycles:
print(bicycle)
``````
• Remove duplicates from a list
``````names = ['John', 'Bob', 'Mosh', 'Sarah', 'Mosh', 'John', 'Anne', 'Jane', 'Bob', 'Anne']

duplicate_names = []
unique_names = []

for name in names:
if name not in unique_names:
unique_names.append(name)
else:
duplicate_names.append(name)
print(unique_names)
print(duplicate_names)

pictures = [
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 1, 1, 0],
[1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0]
]

for row in pictures:
for pixels in row:
if pixels == 1:
print('\*', end='')
else:
print(' ', end='')
print('') # This is used to print a new line after each row
``````
• While Loop
`````` i = 0
while i < len(bicycles):
print(bicycles[i])
i += 1
``````
• Looping through a list of dictionaries
``````users = [{'username': 'Jobizil', 'email': 'jobizil@email.com','age': 26},
{'username': 'Quill', 'email': 'quill@email.com', 'age': 22}]

for user in users:
``````

### List Comprehension: This is used to create a new list from an existing list

``````new_list = [expression for item in list if conditional]
new_list = [item['email'] for item in users]
print(new_list)
``````

### List Comprehension with if statement

``````new_list = [item['email'] for item in users if item['age'] > 25]
print(new_list)
``````

## Tuples: Just like Lists, Tuples are used to store multiple items in a single variable but they are stored within brackets (elements).

``````    >>> (1, 2, 3)
(1, 2, 3)
>>> ('Hello', 'World')
('Hello', 'World')
>>> (1, 'Hello', 2.5)
(1, 'Hello', 2.5)
``````

Characteristics of Tuple:

• Ordered
• Immutable
• Allows Duplicate Elements

## Sets

A set is a collection which is unordered and unindexed. In Python, sets are written with curly brackets.

``````>>> {1, 2, 3}
{1, 2, 3}
>>> {'Hello', 'World'}
{'Hello', 'World'}
>>> {1, 'Hello', 2.5}
{1, 'Hello', 2.5}
``````

Characteristics of Sets:

• Unordered
• Mutable
• Does Not Allow Duplicate Elements

### Example of a set

``````fruits = {'apple', 'orange', 'apple', 'grape', 'pear', 'banana'}
fruits_2 = {'babana', 'pawpaw', 'apple', 'orange', 'pear', 'banana', 'mango'}
print(fruits)
``````

### Common Set Patterns

• Convert a list to a set
`````` fruits_list = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana']
fruits_set = set(fruits_list)
print(list(fruits_set))
``````
• Remove duplicates from a list
`````` fruits_list = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana']
fruits_set = set(fruits_list)
print(list(fruits_set))
``````
• Find the intersection of two lists
``````fruits_list = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana']

fruits_list_2 = ['apple', 'orange', 'apple', 'grape', 'pear', 'banana', 'mango']

fruits_set = set(fruits_list)
fruits_set_2 = set(fruits_list_2)

print(fruits_set.intersection(fruits_set_2))

``````
• Find the difference between two lists
``````print(fruits_set.difference(fruits_set_2))
print(fruits_set_2.difference(fruits_set))
``````
• Find the union of two lists
``````print(fruits_set.union(fruits_set_2))
``````

### Set Methods

``````fruits.add('mango')
print(fruits)
``````
• clear() => This method removes all the elements from the set
``````fruits.clear()
print(fruits)
``````
• copy() => This method returns a copy of the set
``````fruits_copy = fruits.copy()
print(fruits_copy)
``````
• difference() => This method returns a set containing the difference between two or more sets
``````print(fruits.difference(fruits_2))
print(fruits_2.difference(fruits))
``````
• difference_update() => This method removes the items in this set that are also included in another, specified set and returns a set
``````print(fruits.difference_update(fruits_2))
print(fruits)
``````
• discard() => This method removes the specified element from the set
``````fruits.discard('apple')
print(fruits)
``````
• intersection() => This method returns a set that contains the similarity between two or more sets
``````print(fruits.intersection(fruits_2))
``````
• intersection_update() => This method removes the items in this set that are not present in other, specified set(s) and returns a set
``````print(fruits.intersection_update(fruits_2))
``````
• isdisjoint() => This method returns True if two sets have a null intersection
``````print(fruits.isdisjoint(fruits_2))
``````
• issubset() => This method returns True if another set contains this set
``````print(fruits.issubset(fruits_2))
print(fruits_2.issubset(fruits))
``````
• issuperset() => This method returns True if this set contains another set
``````print(fruits.issuperset(fruits_2))
print(fruits_2.issuperset(fruits))
``````
• union() => This method returns a set that contains all items from the original set, and all items from the specified sets
``````print(fruits.union(fruits_2))
``````

## Dictionaries

A dictionary in Python is a collection of key-value pairs usually unordered. Each key is connected to a value, and you can use a key to access the value associated with that key. A key's value can be a number, a string, a list, or even another dictionary. In fact, you can use any object that you can create in Python as a value in a dictionary.
They store data values in key:value pairs within curly braces {elements}.

``````>>> {'name': 'John', 'age': 30}
{'name': 'John', 'age': 30}
>>> {'name': 'John', 'age': 30, 'name': 'Jane'}
{'name': 'Jane', 'age': 30}
``````

Characteristics of Dictionaries:

• Unordered
• Mutable
• Does Not Allow Duplicate Keys

### Example of a dictionary

``````user = {'username': 'Jobizil',
'email': 'jobizil@email.com',
'age': 25,
'color': 'blue',
'is_active': True,
'is_staff': False,
}
``````

### Dictionary Methods

• get() => This method returns the value of the specified key
``````  print(user.get('username'))
``````
• keys() => This method returns a list of all the keys in the dictionary
``````  print(user.keys())
print(user.values())
``````
• items() => This method returns a list of tuples containing the key-value pairs
``````  print(user.items())
``````
• clear() => This method removes all the items from the dictionary and returns an empty dictionary
``````  print(user.clear())
``````
• pop() => This method removes the item with the specified key name and returns the value of the removed item
``````  print(user.pop('username'))
``````
• popitem() => This method removes the last inserted item and returns a tuple containing the key-value pair of the removed item
``````  print(user.popitem())
``````
• copy() => This method returns a copy of the dictionary
``````  user_2 = user.copy()
print(user_2)
``````
• update() => This method updates the dictionary with the specified key-value pairs
``````  user.update({'username': 'Quill', 'email': 'quill@email.com'})
user_3 = user.copy()
print(user_3)
``````

### Common Dictionary Patterns

• Looping through a dictionary

`````````python
``````

for key, value in user.items():
print(f'Key: {key}')
print(f'Value: {value}')

``````
``````
• Looping through a dictionary keys

``````for key in user.keys():
print(key)
```
{% endraw %}
``````
• Looping through a dictionary values
{% raw %}

``````for value in user.values():
print(value)
``````
• Dictionary Comprehension:

Dictionary comprehension is a way to create a dictionary in a single line of code. It is a combination of a for loop and a dictionary.

### Example of Dictionary Comprehension

`````````python
squared = {num: num**2 for num in [1, 2, 3, 4, 5]}
print(squared)
```
``````
• Dictionary Comprehension with conditional logic

Dictionary comprehension with conditional logic is a way to create a dictionary in a single line of code. It is a combination of a for loop, a conditional statement and a dictionary.

### Example of Dictionary Comprehension with conditional logic

`````````python
squared = {num: num**2 for num in [1, 2, 3, 4, 5] if num % 2 == 0}
print(squared)
```
``````

## Conclusion

I might not have covered everything in this article but I hope it helps you understand the basics of Python data structures. You can learn more about Python data structures here.

Also, I might not be able to update this article series as soon as I learn new things within my learning journey. But I will ensure I update it on my GitHub repo. You can check it out here.