DEV Community: Qu35t

Flask Simple WebApp

Qu35t — Fri, 27 Aug 2021 20:39:28 +0000

This project is a simple web app were user can register and login and the web app authenticates the user. Create a folder where the whole project will be located, inside the folder create a other folders named website and a file named main.py. Inside the website folder create two folders named static and templets, also inside the same folder creat four files : init.py, auth.py, models.py and views.py.

Requirements

requirements.txt

flask
Flask-SQLAlchemy
flask-login

__init__.py


from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from os import path
from flask_login import LoginManager

db = SQLAlchemy()
DB_NAME = "database.db"

def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hjshjhdjah kjshkjdhjs'
app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{DB_NAME}'
db.init_app(app)

from .views import views
from .auth import auth

app.register_blueprint(views, url_prefix='/')
app.register_blueprint(auth, url_prefix='/')

from .models import User, Note

create_database(app)

login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)

@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))

return app

def create_database(app):
if not path.exists('website/' + DB_NAME):
db.create_all(app=app)
print('Created Database!')


main.py


from website import create_app

app = create_app()

if __name__ == '__main__':
app.run(debug=True)


models.py

from . import db
from flask_login import UserMixin
from sqlalchemy.sql import func

class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.String(10000))
date = db.Column(db.DateTime(timezone=True), default=func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(150), unique=True)
password = db.Column(db.String(150))
first_name = db.Column(db.String(150))
notes = db.relationship('Note')


views.py

from flask import Blueprint, render_template, request, flash, jsonify
from flask_login import login_required, current_user
from .models import Note
from . import db
import json

views = Blueprint('views', __name__)

@views.route('/', methods=['GET', 'POST'])
@login_required
def home():
if request.method == 'POST':
note = request.form.get('note')

if len(note) < 1:
flash('Note is too short!', category='error')
else:
new_note = Note(data=note, user_id=current_user.id)
db.session.add(new_note)
db.session.commit()
flash('Note added!', category='success')

return render_template("home.html", user=current_user)

@views.route('/delete-note', methods=['POST'])
def delete_note():
note = json.loads(request.data)
noteId = note['noteId']
note = Note.query.get(noteId)
if note:
if note.user_id == current_user.id:
db.session.delete(note)
db.session.commit()

return jsonify({})


auth.py

from flask import Blueprint, render_template, request, flash, redirect, url_for
from .models import User
from werkzeug.security import generate_password_hash, check_password_hash
from . import db
from flask_login import login_user, login_required, logout_user, current_user

auth = Blueprint('auth', __name__)

@auth.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
email = request.form.get('email')
password = request.form.get('password')

user = User.query.filter_by(email=email).first()
if user:
if check_password_hash(user.password, password):
flash('Logged in successfully!', category='success')
login_user(user, remember=True)
return redirect(url_for('views.home'))
else:
flash('Incorrect password, try again.', category='error')
else:
flash('Email does not exist.', category='error')

return render_template("login.html", user=current_user)

@auth.route('/logout')
@login_required
def logout():
logout_user()
return redirect(url_for('auth.login'))

@auth.route('/sign-up', methods=['GET', 'POST'])
def sign_up():
if request.method == 'POST':
email = request.form.get('email')
first_name = request.form.get('firstName')
password1 = request.form.get('password1')
password2 = request.form.get('password2')

user = User.query.filter_by(email=email).first()
if user:
flash('Email already exists.', category='error')
elif len(email) < 4:
flash('Email must be greater than 3 characters.', category='error')
elif len(first_name) < 2:
flash('First name must be greater than 1 character.', category='error')
elif password1 != password2:
flash('Passwords don\'t match.', category='error')
elif len(password1) < 7:
flash('Password must be at least 7 characters.', category='error')
else:
new_user = User(email=email, first_name=first_name, password=generate_password_hash(
password1, method='sha256'))
db.session.add(new_user)
db.session.commit()
login_user(new_user, remember=True)
flash('Account created!', category='success')
return redirect(url_for('views.home'))

return render_template("sign_up.html", user=current_user)

templets folder


base.html

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link
rel="stylesheet"
href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"
integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh"
crossorigin="anonymous"
/>
<link
rel="stylesheet"
href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"
crossorigin="anonymous"
/>

<title>{% block title %}Home{% endblock %}</title>
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
<button
class="navbar-toggler"
type="button"
data-toggle="collapse"
data-target="#navbar"
>
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbar">
<div class="navbar-nav">
{% if user.is_authenticated %}
<a class="nav-item nav-link" id="home" href="/">Home</a>
<a class="nav-item nav-link" id="logout" href="/logout">Logout</a>
{% else %}
<a class="nav-item nav-link" id="login" href="/login">Login</a>
<a class="nav-item nav-link" id="signUp" href="/sign-up">Sign Up</a>
{% endif %}
</div>
</div>
</nav>

{% with messages = get_flashed_messages(with_categories=true) %} {% if
messages %} {% for category, message in messages %} {% if category ==
'error' %}
<div class="alert alert-danger alter-dismissable fade show" role="alert">
{{ message }}
<button type="button" class="close" data-dismiss="alert">
<span aria-hidden="true">&times;</span>
</button>
</div>
{% else %}
<div class="alert alert-success alter-dismissable fade show" role="alert">
{{ message }}
<button type="button" class="close" data-dismiss="alert">
<span aria-hidden="true">&times;</span>
</button>
</div>
{% endif %} {% endfor %} {% endif %} {% endwith %}

<div class="container">{% block content %} {% endblock %}</div>
<script
src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"
></script>
<script
src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"
></script>
<script
src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"
></script>

<script
type="text/javascript"
src="{{ url_for('static', filename='index.js') }}"
></script>
</body>
</html>


home.html

{% extends "base.html" %} {% block title %}Home{% endblock %} {% block content
%}
<h1 align="center">Notes</h1>
<ul class="list-group list-group-flush" id="notes">
{% for note in user.notes %}
<li class="list-group-item">
{{ note.data }}
<button type="button" class="close" onClick="deleteNote({{ note.id }})">
<span aria-hidden="true">&times;</span>
</button>
</li>
{% endfor %}
</ul>
<form method="POST">
<textarea name="note" id="note" class="form-control"></textarea>
<br />
<div align="center">
<button type="submit" class="btn btn-primary">Add Note</button>
</div>
</form>
{% endblock %}


login.html

{% extends "base.html" %} {% block title %}Login{% endblock %} {% block content
%}
<form method="POST">
<h3 align="center">Login</h3>
<div class="form-group">
<label for="email">Email Address</label>
<input
type="email"
class="form-control"
id="email"
name="email"
placeholder="Enter email"
/>
</div>
<div class="form-group">
<label for="password">Password</label>
<input
type="password"
class="form-control"
id="password"
name="password"
placeholder="Enter password"
/>
</div>
<br />
<button type="submit" class="btn btn-primary">Login</button>
</form>
{% endblock %}

sing_up.html

{% extends "base.html" %} {% block title %}Sign Up{% endblock %} {% block
content %}
<form method="POST">
<h3 align="center">Sign Up</h3>
<div class="form-group">
<label for="email">Email Address</label>
<input
type="email"
class="form-control"
id="email"
name="email"
placeholder="Enter email"
/>
</div>
<div class="form-group">
<label for="firstName">First Name</label>
<input
type="text"
class="form-control"
id="firstName"
name="firstName"
placeholder="Enter first name"
/>
</div>
<div class="form-group">
<label for="password1">Password</label>
<input
type="password"
class="form-control"
id="password1"
name="password1"
placeholder="Enter password"
/>
</div>
<div class="form-group">
<label for="password2">Password (Confirm)</label>
<input
type="password"
class="form-control"
id="password2"
name="password2"
placeholder="Confirm password"
/>
</div>
<br />
<button type="submit" class="btn btn-primary">Submit</button>
</form>
{% endblock %}

static folder


function deleteNote(noteId) {
fetch("/delete-note", {
method: "POST",
body: JSON.stringify({ noteId: noteId }),
}).then((_res) => {
window.location.href = "/";
});
}

Python enumerate(): Simplify Looping With Counters

Qu35t — Wed, 11 Aug 2021 21:27:39 +0000

Table of Contents
• Iterating With for Loops in Python
• Using Python’s enumerate()
• Practicing With Python enumerate()
◦ Natural Count of Iterable Items
◦ Conditional Statements to Skip Items
• Understanding Python enumerate()
• Unpacking Arguments With enumerate()
• Conclusion

A for loop in Python is often written as a loop over an iterable object. To access objects in the iterable, you don't require a counting variable. However, there are situations when you'll want a variable that changes with each loop iteration. You can use Python's enumerate() to get a counter and the value from an iterable at the same time, rather than generating and incrementing a variable yourself!

You'll learn how to:
• Use enumerate() to get a counter in a loop
• Apply enumerate() to display item counts
• Use enumerate() with conditional statements
• Implement your own equivalent function to enumerate()
• Unpack values returned by enumerate()

Python Iteration Using for Loops
In Python, a for loop uses collection-based iteration. This means that on each iteration, Python assigns the next item from an iterable to the loop variable, as in this example:


values = ["a", "b", "c"]

for value in values:
  print(value)

OutPut

a
b
c

Introduction To Python Functions

Qu35t — Tue, 03 Aug 2021 15:14:21 +0000

After reading this article, you will be able to:
• What are functions, and how are they defined?
• What are the parameters and arguments
• How to return values from functions
• How to define a function documentation
• What represents the scope in Python
• What are keyword arguments
• Flexible and Default arguments
• What are the Python exceptions and how to handle and how to raise them
• Assert Statements

Introduction

A function is a reusable, well-organized piece of code that performs a certain task. Functions enable us to keep our code clean while also allowing us to reuse it.

Built-in Functions

Python comes with a number of built-in functions that are always available. Print and max are two of these functions. Let's look at some examples of how we can apply them.
Objects are accepted and printed by the print function.

print("Python")
print("chess", "backgammon")

Output:

Python
chess backgammon

The max function accepts an iterable and returns the largest item

numbers = [10, 5, 49, 24, -10]
largest_number = max(numbers)
largest_number

Output:

We simply call the function by writing its name and pass the required inputs

User-Defined Functions

As a programmer or data scientist, we occasionally require functionality that is customized to our requirements. We can define our own functions in these situations.

To define a function, we must adhere to the following guidelines:
1. Use the keyword def to introduce a function definition
2. Write the function name followed by parentheses () and a colon:
3. Define a list of parameters inside these parentheses (optional)
4. Write the function body. The statements that form the function body, start at the next line and must be intended. When the function is called the code in the function body is run.
5. The first statement of the function body can be a string literal which represents the function documentation (optional)
6. Use the return keyword to pass back a result to the caller (optional)
If you believe there are a lot of steps, don't worry. Many instances will be shown, and the concepts will become clear.

Defining a Function Without Parameters

Let's look at a simple function definition that doesn't include any optional elements. We can use parenthesis () to call the function by typing its name . The current date will be printed when we call this function.


#Defining a Function Without Parameters

import datetime # importing the "datetime" module

def print_current_date():
    current_date = datetime.datetime.now().date()
    print(current_date)

print_current_date()

Output


2021-08-03

Please keep in mind that your results may vary. The date you executed the function will be the output.

Defining a Function With Parameters

We need function parameters almost always. They’re used when we want to pass data into our function. When we call a function we pass arguments (values for the parameters) to the function.
One Parameter Example

def print_message(text):
    print(text)

print_message("Forgive yourself for your faults and your mistakes and move on. - Les Brown")

output:

Almost all of the time, we require function parameters. When we need to provide data into a function, we use them. Arguments (parameter values) are passed to a function when it is called.

It's essential when defining parameters like that. We'll get an error if we don't pass an argument value for this parameter.

def print_message(text):
    print(text)

print_message()

Output:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-f2f093834d71> in <module>()
      2     print(text)
      3 
----> 4 print_message()

TypeError: print_message() missing 1 required positional argument: 'text'

We'll look at how to define optional arguments later in this article (arguments with a default value).

Multiple Parameters Example

We can add as many parameters as we want and, as long as we use commas to separate them. In many circumstances, more than one parameter is required.
The order in which the arguments are given matches to the order in which our function's parameters are defined. In the example below, the number1 parameter is set to 10 and the number2 parameter is set to 5.

def sum_numbers(number1, number2):
    print(number1 + number2)

sum_numbers(10, 5)

Output:

However, because our function just prints the result and does not utilize a return statement, we cannot save the value in a variable using the above function definition. Let's have a look at what happens if we attempt to save the result.

def sum_numbers(number1, number2):
    print(number1 + number2)

result = sum_numbers(10, 5)
print(result)

Output:

15
None

Because our function was called, the sum is printed, but the result variable has a value of None instead of 15. Let's look at how we can return values in the next part.

Defining a Function That Returns a Result

The return keyword can be used to exit the current function call and return a desired result. Let's look at how we may re-define sum numbers to return the sum rather than printing it.

def sum_numbers(number1, number2):
    return number1 + number2

result = sum_numbers(10, 5)
print(result)

Output:

The result variable has a value of 15 this time, as we can easily see.

Defining a Function That Returns Multiple Values

We can also define a function that returns multiple values. We can do that by constructing objects called tuples in your function. The tuples data type in Python is an immutable sequence. This means that they can contain multiple values like lists.

import datetime

def get_current_datetime():
    current_datetime = datetime.datetime.now()
    current_date = current_datetime.date()
    current_time = current_datetime.time()
    return (current_date, current_time)

date, time = get_current_datetime()
print(date)
print(time)

Output:

2021-08-03
18:08:43.049105

Sequence unpacking is used in the example above. The values from the tuple are simply "unpacked" into date and time variables.

Random Password Generator

Qu35t — Sun, 25 Jul 2021 01:57:02 +0000

We all use passwords on a regular basis; however, in order to keep your account safe and prevent it from being stolen, you must create a password that is difficult to guess.
Password generator is a program that produces a password with a mix of upper and lowercase letters, numbers, and symbols that is strong enough to provide outstanding protection.

What is a Password:

A password, also known as a passcode, is a secret that is memorized and normally consists of a string of characters that is used to verify a user's identity during the authentication process. If you're interested in learning more, refer toPassword

Applicable Modules:-

String Module:

The string module contains a number of useful constants, classes and a number of functions to process the standard python string.
1. string.ascii_letters: Concatenation of the ascii (upper and lowercase) letters
2. string.ascii_lowercase: All lower case letters
3. string.ascii_uppercase: All Upper case letters
4. string.digits: The string ‘0123456789’.
5. string.punctuation: String of ASCII characters which are considered punctuation characters in the C locale.

Random Module.

Random module is used to perform the random generations. We are making use of random.sample module here. If you will observe in the output all characters will be unique. random.sample() never repeats characters. If you don’t want to repeat characters or digits in the random string, then use random.sample() but it is less secure because it will reduce the probability of combinations because we are not allowing repetitive letters and digits.

Now that you are familiar with password use cases and have acquired basic knowledge of random and string module, we can move forward to the coding section.

Code
In order to access the Python library, we need to import the package in our Python script.

import random
import string

Let's greet the user !

print('Hi, Welcome to Password generator')

you can ask the user for the password length

#length of Password

length = int(input('\nEnter the length of password: '))

Choose the length of the password you want to generate.

#length of Password

length = 8

The data must now be defined. For this, we'll employ the string module.


#define data
lower = string.ascii_lowercase
upper = string.ascii_uppercase
num = string.digits
symbols = string.punctuation

Store the data by combining the stored lowercase and uppercase letters, as well as numbers and symbols.

#combine the data

all = lower + upper + num + symbols

From the data we have, use the random module to generate a password. Passing in the combined data, as well as the password length, and finally joining them.

#use random

temp = random.sample(all,length)

#create the Password
password = "".join(temp)

We can further minimize the amount of lines of code by removing the data storage now that you have a clear knowledge of the script. Let's take a closer look.

all = string.ascii_letters + string.digits + string.punctuation
pass = "".join(random.sample(all,length))

Finally, print the password!

print(password)

a few examples of output:

#SAMPLE O/P: (length = 8)
[Y+4TEsA
c.@2XV:;
*\vbEQ[W
I.;F)L!~
X]60Js_3
G{CK%fm#

Source 1

#import the necessary modules

import random
import string

print('Hi, Welcome to Password generator')

#length of Password
length = 8

#define data
lower = string.ascii_lowercase
upper = string.ascii_uppercase
num = string.digits
symbols = string.punctuation 

#combine the data

all = lower + upper + num + symbols

#use random

temp = random.sample(all,length)

#create the Password
password = "".join(temp)

#print password

print(password)

Source 2

#import the necessary modules

import random
import string

print('Hi, Welcome to Password generator')

#length of Password
length = 8

all = string.ascii_letters + string.digits + string.punctuation
password = "".join(random.sample(all,length))

print(password)

Python Basics, Python 101

Qu35t — Sat, 24 Jul 2021 21:04:23 +0000

Python is an interpreted high-level general-purpose programming language created by Guido van Rossum in the late 1980s and published to the general public in 1991.

Its syntax and semantics, which emphasize code simplicity and readability, set it apart from other programming languages. This is achievable thanks to its well-defined English keywords and low punctuation reliance. For example, unlike c and c++, python employs white space indentation instead of curly brackets to delimit code blocks, and semicolons aren't necessary for statement termination.
Python is kept simple in general, and you may find it easier to go through the lines and see what you're doing. Python programs are stored in files with the .py extension, which can be run from the command line by typing python file_name.py.

Python's desirable features include:

Python is really interactive. This makes it easier to test a program's functionality. This can be accomplished by modularization, which involves taking tiny chunks of code and evaluating them to see if they work. It can also be combined with IDLE, a development environment.

Python has numerous libraries. This broadens a programmer's horizons by allowing him or her to work with other programming tools needed in many industries such as web development, data science, machine learning, and so on, to enable various features such as connecting to web servers.

Python is platform independent. Python programs can be run on Unix, Linux, Windows, and Mac OS X systems. Python is a flexible programming language. It's simple to expand into other modules, such as C or C++, and construct snippets to do a variety of tasks.

Python is open Source. Download, use, modify, and redistribute the product are all free. It's available under an open source license, so anyone can use it.

Debugging is simple. Because data types are dynamically typed, errors can be spotted fast. When you mix types that don't match, an exception will be raised for you to see. If necessary, you can organize the codes into packages and modules.

Object oriented programming. Objects aid in the decomposition of complex real-world problems into a form that can be coded and solved to achieve solutions.

Python's applications are numerous.
These are a few examples of applications:
• Web Development
• Artificial Intelligence
• Data Science
• Machine Learning
• Automation
• Internet of Thing
• Scientific and Numeric Applications
• Wrangling, Exploration, and Visualization of Data
• Game Development
• Desktop Applications

Python Installation

Install the most recent Python version for your operating system Here

Install Text Editor:

A code editor is a tool that is used to write and edit code. They are usually lightweight and can be great for learning especially for a beginner.

1.) Visual Studio Code

Visual Studio Code (VS Code) is a free and open-source IDE created by Microsoft that can be used for Python development.Download VScode

2.) Sublime Text

Sublime Text is a popular code editor that supports many languages including Python.Sublime

3.) Atom

Atom is a highly customizable open-source code editor developed by Github that can be used for Python development.Atom

4.) Thonny

Thonny is a simple UI Python dedicated IDE that comes with Python 3 built-in. Once you install it, you can start writing Python code.Thonny

5.) Pycharm

PyCharm is a Jetbrain-powered IDE for professional developers.Pycharm

Hello world

The first example of any programming language is usually "Hello world."
Start IDLE and open a new window (select New Window from the File Menu), create a new file and save it as hello.py in your desired program folders, and then input the following code.

print(“Hello World”)

Executing the Python program.

To run the hello.py file we produced earlier, use the Command Prompt on Windows or the Terminal on Mac or Linux. Then navigate to the location where our file is stored.
Then, to run the hello.py file, type the following command:

python3 hello.py

If everything is in order, the program should run without issues and display the following message on the screen.

Hello World

Creating Comments in Python

A comment is text in a program's code, script, or another file that the user is not supposed to read. When looking at the source code, though, it can be seen.
Comments make code more understandable by explaining what's going on and by preventing pieces of a program from running.

The # character is used to create a single-line comment.

A multi-line comment is one that spans multiple lines and is typed in triple quotes.

#single line comment
’’’
Multi-line comment
using docstring
’’’

Variables

Variables are identified memory locations where data is kept for programs to refer to and manipulate. Variables, to put it simply, are data storage containers.

When assigning values to variables, the equal sign (=) is used.
The name of the variable is the operand to the left of the = operator, and the value stored in the variable is the operand to the right of the = operator.

fav_activity =  “swimming”
print(fav_activity)

Variables do not require declaration. Python is a dynamically typed language since their data types are deduced from their assignment statement. This means that throughout the code, different data types might be given to the same variable.

Data Types

Python contains a number of standard data types that describe the operations that may be performed on them as well as the storage technique for each of them.
The most common data types-

1. Numbers

Number data types are the ones that will store the numeric values and are classified as:
-Complex (such as complex numbers)
-Float (floating point real values
-Long (long integers that can also be shown as hexadecimal and octal.)
-Int (signed integers)
It also involves numbers and simple mathematics in Python.

Arithmetic

print(46 + 2)  # 48 (addition)
print(10 - 9)  # 1 (subtraction)
print(3 * 3)  # 9 (multiplication)
print(84 / 2)  # 42.0 (division)
print(2 ** 8)  # 256 (exponent)
print(11 % 2)  # 1 (remainder of the division)
print(11 // 2)  # 5 (floor division)

The math module in Python contains well-known arithmetic functions such as sin, cos, tan, exp, log, log10, factorial, sqrt, floor, and ceil.

2. Strings

In Python, strings are a data type for dealing with text. They're a collection of characters encased in quotation marks.
Using the numerous string methods provided, you may conduct a variety of actions on strings.
Creating a string - A string is created by enclosing text in quotes. You can use either single quotes,', or double quotes, ". A triple-quote can be used for multi-line strings.

language = “python”
multi_lin = ’’’come one
came all
’’’
greetings = ‘hello’

3. Lists

Lists are one of the most versatile data types that you can work on in Python. It contains different items enclosed within square brackets and separated out with commas. In Python, a list is referred to as an array in other programming languages.
Lists are mutable and can contain elements of different data types and even other lists.

# can store any data type
multiple_types = [True, 3.7, "Python"]

# access and modify
favourite_foods = ["pasta", "pizza", "french fries"]
print(favourite_foods[1]) # pizza
favourite_foods[0] = "rösti"
print(favourite_foods[0]) # rösti

# subsets
print(favourite_foods[1:3]) # ['pizza', 'french fries']
print(favourite_foods[2:]) # ['french fries']
print(favourite_foods[0:2]) # ['rösti', 'pizza']

# append
favourite_foods.append("paella")

# insert at index
favourite_foods.insert(1, "soup")

# remove
favourite_foods.remove("soup")

# get length
print(len(favourite_foods)) # 4

# get subset (the original list is not modified)
print(favourite_foods[1:3]) # ['pizza', 'french fries']

# lists inside lists
favourite_drinks = ["water", "wine", "juice"]
favourites = [favourite_foods, favourite_drinks]
print(favourites[1][2]) # juice

4. Tuples

Immutable lists contained in parenthesis are referred to as tuples.

#tuples

new_tuple = ("a", "b", "c", "d")
print(len(new_tuple)) # 4
print(new_tuple[1]) # b
print(new_tuple[1:4]) # ('b', 'c', 'd')

To convert an object into a tuple, use tuple() constructor.

t1 = tuple([12,25,93])
t2 = tuple('abcde')

To write a tuple with one element include a comma(,) after the element.


t1 = (5,)

Tuples are immutable, which means they can't be changed. However, portions/slices of existing tuples can be combined to form a new tuple.

5. Dictionary

Dictionaries are key-value pairs and are surrounded by {}, and are similar to objects in JavaScript.
Creating dictionaries - To declare a dictionary we enclose it in curly braces, {}. Each entry consists of a pair separated
by a colon. The first part of the pair is called the key and can be of any data type and the second is the value. The key acts like an index.


language_creators = {
  "Python" : "Guido van Rossum",
  "C" : "Dennis Ritchie",
  "Java" : "James Gosling",
  "Go": "Robert Griesemer",
  "Perl" : "Larry Wall"
}

# access, modify, delete
print(language_creators["Python"]) # Guido van Rossum
language_creators["Go"] = ["Robert Griesemer", "Rob Pike", "Ken Thompson"]
print(language_creators["Go"]) # ['Robert Griesemer', 'Rob Pike', 'Ken Thompson']
print(len(language_creators)) # 5
del language_creators["Perl"]
print(len(language_creators)) # 4

# print keys and values
print(language_creators.keys())
print(language_creators.values())

6. Boolean

# booleans

a = True
b = False
if a is True and b is False:
  print("YUP!")

Comparison, Logical, and Conditional Operators.

Comparison: ==, !=, <, >, <=, >=
Logical: and, or, not
Conditionals: if, else, elif

# logical operators:

laundry_day = "Monday"
today = "Tuesday"
on_vacation = False
if today is laundry_day and today is not "Sunday" and on_vacation is False:
  print("It's laundry day!")
else:
  print("The laundry can wait!")


# comparison operators:
age = 21
if age >= 21:
  print("You can drive a trailer")
elif age >= 16:
  print("You can drive a car")
else:
  print("You can ride a bike")

Loops

for loops


# foor loop
for x in range(0, 3):
  print(x)

# loop through list
for x in ["Python", "Go", "Java"]:
  print(x)

# loop through dictionary
language_creators = {
  "Python" : "Guido van Rossum",
  "C" : "Dennis Ritchie",
  "Java" : "James Gosling",
}
for key, value in language_creators.items():
  print("Language: {}; Creator: {}".format(key, value))

while loops

# while loop

level = 0
while(level < 30):
  level += 1
  print(level)

Functions

Functions are defined using the def keyword.

# functions
def allowed_to_drive(age):
  if age >= 21:
    return True
  else:
    return False

print(allowed_to_drive(42)) # True
print(allowed_to_drive(12)) # False

Argument default values can also be specified.

def is_laundry_day(today, laundry_day = "Monday", on_vacation = False):
  if today is laundry_day and today is not "Sunday" and on_vacation is False:
    return True
  else:
    return False

print(is_laundry_day("Tuesday")) # False
print(is_laundry_day("Tuesday", "Tuesday")) # True
print(is_laundry_day("Friday", "Friday", True)) # False

Classes

Classes are groups of variables and the functions that interact with them.
The class keyword in Python is used to define classes. They are comparable to classes in other languages such as Java and C#, although there are several variations, such as the use of self instead of this to refer to the class's resultant object. In addition, instead of the more common class name, the constructor method is called init. Every time a class variable is referenced, self must be the first parameter in the argument list of each function, including the constructor.

Method overloading is not possible in Python, however it can be achieved to some extent by providing default values for arguments (shown in the Functions section).


# classes

class Email:
  # __ means private
  __read = False

  def __init__(self, subject, body):
    self.subject = subject
    self.body = body

  def mark_as_read(self):
    self.__read = True

  def is_read(self):
    return self.__read

  def is_spam(self):
    return "you won 1 million" in self.subject

e = Email("Check this out", "There are a bunch of free online course here: https://course.online")
print(e.is_spam()) # False
print(e.mark_as_read())
print(e.is_read()) # True

Python also allows classes to inherit methods and variables from other classes or multiple classes (multiple inheritance).


# inheritance

class EmailWithAttachment(Email):
  def __init__(self, subject, body, attachment):
    super(EmailWithAttachment, self).__init__(subject, body)
    self.__attachment = attachment

  def get_attachment_size(self):
    return len(self.__attachment)

email_with_attachment = EmailWithAttachment("you won 1 million dollars", "open attachment to win", "one million.pdf")
print(email_with_attachment.is_spam()) # True
print(email_with_attachment.get_attachment_size()) # 15

File I/O

Python file handling operations also known as File I/O deal with two types of files. They are:

Text files
Binary files

Despite the fact that the two file formats appear to be identical on the surface, they encode data differently.

A text file is structured as a sequence of lines. And, each line of the text file consists of a sequence of characters. Termination of each line in a text file is denoted with the end of line (EOL). There are a few special characters that are used as EOL, but comma {,} and newlines are the most common ones.

Image files such as .jpg, .png, .gif, etc., and documents such as .doc, .xls, .pdf, etc., all of them constitute binary files.

Different file handling methods include:
1.Opening a File
2.Writing into a File
3.Reading from a File
4.Closing a File

# write
todos_file = open("todos.txt", "wb")
todos_file.write(bytes("buy a new domain name\n", "UTF-8"))
todos_file.write(bytes("work on the side project\n", "UTF-8"))
todos_file.write(bytes("learn a new programming language\n", "UTF-8"))
todos_file.close()

# read
todos_file = open("todos.txt", "r+")
todos_file_contents = todos_file.read()
print(todos_file_contents)