DEV Community: ssenyonga yasin

Pandas cheat sheet 1

ssenyonga yasin — Mon, 31 Jan 2022 10:47:19 +0000

Pandas Cheat Sheet for Data Science in Python

A quick guide to the basics of the Python data analysis library Pandas, including code samples.
The Pandas library is one of the most preferred tools for data scientists to do data manipulation and analysis, next to matplotlib for data visualization and NumPy, the fundamental library for scientific computing in Python on which Pandas was built.

The fast, flexible, and expressive Pandas data structures are designed to make real-world data analysis significantly easier, but this might not be immediately the case for those who are just getting started with it. Exactly because there is so much functionality built into this package that the options are overwhelming.

That's where this Pandas cheat sheet might come in handy.

It's a quick guide through the basics of Pandas that you will need to get started on wrangling your data with Python.

As such, you can use it as a handy reference if you are just beginning their data science journey with Pandas or, for those of you who already haven't started yet, you can just use it as a s a guide to make it easier to learn about and use it.

The Pandas cheat sheet will guide you through the basics of the Pandas library, going from the data structures to I/O, selection, dropping indices or columns, sorting and ranking, retrieving basic information of the data structures you're working with to applying functions and data alignment.

Python For Data Science Cheat Sheet:

Pandas Basics
Use the following import convention:

import pandas as pd

Pandas Data Structures

Series

A one-dimensional labeled array capable of holding any data type

s = pd.Series([3, -5, 7, 4], index=['a', 'b', 'c', 'd'])

DataFrame

A two-dimensional labeled data structure with columns of potentially different types

data = {'Country': ['Belgium', 'India', 'Brazil'], 'Capital': ['Brussels', 'New Delhi', 'Brasilia'],'Population': [11190846, 1303171035, 207847528]}

df = pd.DataFrame(data,columns=['Country', 'Capital', 'Population'])

Country Capital Population
1   Belgium Brussels    11190846
2   India   New Delhi   1303171035
3   Brazil  Brasilia    207847528

Please note that the first column 1,2,3 is the index and Country,Capital,Population are the Columns.

Asking For Help

 help(pd.Series.loc)
I/O

Read and Write to CSV

 pd.read_csv('file.csv', header=None, nrows=5)
 df.to_csv('myDataFrame.csv')

Read multiple sheets from the same file

 xlsx = pd.ExcelFile('file.xls')
df = pd.read_excel(xlsx,  'Sheet1')

Read and Write to Excel

 pd.read_excel('file.xlsx')
 df.to_excel('dir/myDataFrame.xlsx',  sheet_name='Sheet1')

Read and Write to SQL Query or Database Table.

(read_sql()is a convenience wrapper around read_sql_table() and read_sql_query())

from sqlalchemy import create_engine
engine = create_engine('sqlite:///:memory:')
pd.read_sql(SELECT * FROM my_table;, engine)
pd.read_sql_table('my_table', engine)
pd.read_sql_query(SELECT * FROM my_table;', engine)
df.to_sql('myDf', engine)

FACE DETECTION IN PYTHON 2

ssenyonga yasin — Fri, 05 Nov 2021 11:34:33 +0000

introduction

Face Detection is the first and essential step for face recognition, and it is used to detect faces in the images. It is a part of object detection and can use in many areas such as security, bio-metrics, law enforcement, entertainment, personal safety.

It is used to detect faces in real time for surveillance and tracking of person or objects. It is widely used in cameras to identify multiple appearances in the frame Ex- Mobile cameras and DSLR’s. Facebook is also using face detection algorithm to detect faces in the images and recognise them.

How the Face Detection Works......

There are many techniques to detect faces, with the help of these techniques, we can identify faces with higher accuracy. These techniques have an almost same procedure for Face Detection such as OpenCV, Neural Networks, Matlab, etc. The face detection work as to detect multiple faces in an image. Here we work on OpenCV for Face Detection, and there are some steps that how face detection operates, which are as follows-

Firstly the image is imported by providing the location of the image. Then the picture is transformed from RGB to Grayscale because it is easy to detect faces in the grayscale.

After that, the image manipulation used, in which the resizing, cropping, blurring and sharpening of the images done if needed. The next step is image segmentation, which is used for contour detection or segments the multiple objects in a single image so that the classifier can quickly detect the objects and faces in the picture.

The next step is to use Haar-Like features algorithm, which is proposed by Voila and Jones for face detection. This algorithm used for finding the location of the human faces in a frame or image. All human faces shares some universal properties of the human face like the eyes region is darker than its Neighbour pixels and nose region is brighter than eye region.

Face Detector in Real-Time (Webcam).

import libraries
import cv2 import numpy as np

import classifier for face and eye detection
face_classifier = cv2.CascadeClassifier(‘Haarcascades/haarcascade_frontalface_default.xml’)
Import Classifier for Face and Eye Detection
face_classifier = cv2.CascadeClassifier(‘Haarcascades/haarcascade_frontalface_default.xml’) eye_classifier = cv2.CascadeClassifier (‘Haarcascades/haarcascade_eye.xml’) def face_detector (img, size=0.5):
Convert Image to Grayscale
gray = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) faces = face_classifier.detectMultiScale (gray, 1.3, 5) If faces is (): return img
Given coordinates to detect face and eyes location from ROI
for (x, y, w, h) in faces x = x — 100 w = w + 100 y = y — 100 h = h + 100 cv2.rectangle (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = gray[y: y+h, x: x+w] roi_color = img[y: y+h, x: x+w] eyes = eye_classifier.detectMultiScale (roi_gray) for (ex, ey, ew, eh) in eyes: cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,0,255),2) roi_color = cv2.flip (roi_color, 1) return roi_color
Webcam setup for Face Detection
cap = cv2.VideoCapture (0) while True: ret, frame = cap.read () cv2.imshow (‘Our Face Extractor’, face_detector (frame)) if cv2.waitKey (1) == 13: #13 is the Enter Key break
When everything done, release the capture
cap.release () cv2.destroyAllWindows ()

Why pitch-based funding competitions are harmful and we need to stop having them

ssenyonga yasin — Mon, 18 Oct 2021 11:30:28 +0000

What's pitching

The most extreme manifestation of this idea of “pitching” are the “Shark Tank”-style funding opportunities where leaders go on stage to give short presentations about their organizations’ work to a live audience, after which, depending on how they do and how the “judges” and people watching their presentations react, they could walk away with one of several small grant prizes.

What you gain from pitching.

Like many philosophies and practices in our sector that we’ve accepted as normal, pitch-based funding opportunities can seem fine, fun, and helpful.
Often, participants get mentorship and training on public speaking and obtain some experience. A colleague who participated in one of these competitions told me she got to know other participants and it was not at all competitive; people supported one another and everyone had a great time.

These competitions can be done with a spirit of camaraderie and public awareness and not the cutthroat events they could potentially become. Plus, they are certainly more interesting for everyone than the traditional, tedious grantmaking process.

Is pitching Really useful

Here are several reasons why i think it may not be

If you must use more than ten slides to explain your business, you probably don’t have a business.

The whole idea being presented in only 10 slides sometimes given five minutes to present.

The ten topics that a venture capitalist cares about are:

1.Problem
2.Your solution
3.Business model
4.Underlying magic/technology
5.Marketing and sales
6.Competition
7.Team
8.Projections and milestones
9.Status and timeline.
10.Summary and call to action.

1.They entrench existing power dynamics between funders/donors and nonprofits.

Why is it always nonprofits that are pitching to funders and donors? Why is it never the other way around? Simple: Because one party has money, and in our society that means they by default get to call the shots. But is this what we want to reinforce? Why should people who have money have so much power, and the people who are actually doing the work of running programs and services have to jump through hoops? How can we become equal partners in this work if we keep reinforcing the asymmetric power differentials that are already pervasive everywhere else?

2.They’re inequitable, rewarding the organizations that can play the game best.
Grant applications are usually inequitable because the organizations that can write the “best” proposals usually win, and they tend to be mainstream, white-led orgs. Pitch-based competitions have the same challenges: Those who win tend to be the best presenters, the most charismatic, and the ones with the missions that most tug at heart-strings. Participants from marginalized backgrounds, who may not be as fluent in English as others, or who may not have as much presentation skills, or whose missions are harder to explain or get people to care about, are often left behind. Also, who can participate as judges and audience members? Mostly well-off white people and others of privilege.

3.They perpetuate competitiveness among different interrelated missions.
Sure, when done thoughtfully, they can be friendly competitions. But they are competitions nonetheless. There is already so much jostling in our sector for resources: grants, donations, media coverage, even talent. We need to do a much better job understanding that all our missions are interrelated and we should be supporting one another. Funders complain about nonprofits not collaborating enough, especially to work on systemic issues, and yet every day they force nonprofits to compete with one another through their funding processes, including these pitch competitions, which my colleague Mari Kim likens to Squid Game, but less interesting.

4.They turn the work of equity and justice into spectacles.
A major reason so many of us were upset at the proposed show on CBS called “The Activist” is that it reduces critical causes into entertainment. These pitch-based competitions are basically just smaller, local versions of that show. There are already enough ingrained expectations in our sector that we manipulate our messaging to make our work emotionally resonant and easily digestible to people with money. We shouldn’t have to also simultaneously develop skills to entertain them too, as that only conditions people to pay attention to stuff that rouses their interests, not what would most be needed to build a just and equitable world (that stuff tends to be less entertaining).

5.They reinforce ignorance among the public.
Oftentimes, the people “judging” the competitions as well as those in attendance may have never worked at nonprofits addressing these causes or had any first-hand experience in these issues at all. And yet they get the microphone and ask ridiculous questions or make comments that further the public’s misperceptions of nonprofits. One colleague told me she failed to get funding because one “judge,” a dude from the tech sector, asked how her mission was going to be self-sustaining (Most nonprofits will never be self-sustaining and it is a delusion to think they will ever be). Questions on sustainability, overhead, scaling, etc. betray a complete lack of understanding of how nonprofits actually run and reinforce harmful misinformation, making nonprofits’ work even more difficult.

6.They are time-consuming and distracting.
These competitions require significant investment in time and energy. Meeting with mentors, practicing, rehearsals, etc. These competitions hosted by Health Organisations for funding to address children’s mental health, for example, requires participants to attend six weeks of trainings on pitching and other stuff. The people working hard to ensure children have mental health support do not need training on public speaking or making pitches or whatever. They need money! That’s something we need funders and donors to understand: Stop wasting our time on nonsensical stuff and making us jump through flaming hoops for your entertainment or edification and just provide money.

7.They are insulting and patronizing.
As one colleague put it regarding a competition in her community: “nonprofit staff are forced to perform for self-described ‘sharks,’ who regularly insult and belittle staff for failing to be sufficiently entrepreneurial. Be prepared to dance, monkey, dance.” If it’s not overtly insulting, it’s often patronizing. “If nonprofits develop their speaking and pitching skills, they can approach other funders; you know, teach someone to fish, etc.” This is a condescending attitude that is too prevalent among funders and donors. Do not create ridiculous and inequitable processes and think you’re doing nonprofits a favor by helping them develop skills in navigating the ridiculousness and inequity.

For these and other reasons, I’d like for us to move away from pitch-based competitions altogether. Let’s phase them out completely. I know there are counter-arguments we can make, but almost any and every benefit of pitch-based competitions (getting to know other nonprofits, exposing the public to important causes, developing presentation skills) can be done in other, better ways.

Let’s be more thoughtful and fund in more equitable ways. The whole concept of “pitching” is problematic and it goes way beyond these competitions. As colleague Yvonne Moore of Moore Philanthropy said during that Clubhouse discussion, and I paraphrase: “We [communities of color and other marginalized communities] are really good at pitches. People just don’t hear us.”

You free to give your suggestions and arguments in the comments section.

THINK LIKE PROGRAMMERS

ssenyonga yasin — Tue, 07 Sep 2021 07:15:45 +0000

If you’re interested in programming, you may well have seen this quote before:

“Everyone in this country should learn to program a computer, because it teaches you to think.” — Steve Jobs
You probably also wondered what does it mean, exactly, to think like a programmer? And how do you do it??

Essentially, it’s all about a more effective way for problem solving.

In this post, my goal is to teach you that way.

By the end of it, you’ll know exactly what steps to take to be a better problem-solver.

Why is this important?
Problem solving is the meta-skill.

We all have problems. Big and small. How we deal with them is sometimes, well…pretty random.

Unless you have a system, this is probably how you “solve” problems (which is what I did when I started coding):

Try a solution.
If that doesn’t work, try another one.
If that doesn’t work, repeat step 2 until you luck out.
Look, sometimes you luck out. But that is the worst way to solve problems! And it’s a huge, huge waste of time.

The best way involves a) having a framework and b) practicing it.

“Almost all employers prioritize problem-solving skills first.
Problem-solving skills are almost unanimously the most important qualification that employers look for….more than programming languages proficiency, debugging, and system design.
Demonstrating computational thinking or the ability to break down large, complex problems is just as valuable (if not more so) than the baseline technical skills required for a job.” — Hacker Rank (2018 Developer Skills Report)
Have a framework
To find the right framework, I followed the advice in Tim Ferriss’ book on learning, “The 4-Hour Chef”.

It led me to interview two really impressive people: C. Jordan Ball (ranked 1st or 2nd out of 65,000+ users on Coderbyte), and V. Anton Spraul (author of the book “Think Like a Programmer: An Introduction to Creative Problem Solving”).

I asked them the same questions, and guess what? Their answers were pretty similar!

Soon, you too will know them.

Sidenote: this doesn’t mean they did everything the same way. Everyone is different. You’ll be different. But if you start with principles we all agree are good, you’ll get a lot further a lot quicker.

“The biggest mistake I see new programmers make is focusing on learning syntax instead of learning how to solve problems.” — V. Anton Spraul
So, what should you do when you encounter a new problem?

Here are the steps:

Understand Know exactly what is being asked. Most hard problems are hard because you don’t understand them (hence why this is the first step).

How to know when you understand a problem? When you can explain it in plain English.

Do you remember being stuck on a problem, you start explaining it, and you instantly see holes in the logic you didn’t see before?

Most programmers know this feeling.

This is why you should write down your problem, doodle a diagram, or tell someone else about it (or thing… some people use a rubber duck).

“If you can’t explain something in simple terms, you don’t understand it.” — Richard Feynman

Plan Don’t dive right into solving without a plan (and somehow hope you can muddle your way through). Plan your solution!

Nothing can help you if you can’t write down the exact steps.

In programming, this means don’t start hacking straight away. Give your brain time to analyze the problem and process the information.

To get a good plan, answer this question:

“Given input X, what are the steps necessary to return output Y?”

Sidenote: Programmers have a great tool to help them with this… Comments!

Divide Pay attention. This is the most important step of all.

Do not try to solve one big problem. You will cry.

Instead, break it into sub-problems. These sub-problems are much easier to solve.

Then, solve each sub-problem one by one. Begin with the simplest. Simplest means you know the answer (or are closer to that answer).

After that, simplest means this sub-problem being solved doesn’t depend on others being solved.

Once you solved every sub-problem, connect the dots.

Connecting all your “sub-solutions” will give you the solution to the original problem. Congratulations!

This technique is a cornerstone of problem-solving. Remember it (read this step again, if you must).

“If I could teach every beginning programmer one problem-solving skill, it would be the ‘reduce the problem technique.’
For example, suppose you’re a new programmer and you’re asked to write a program that reads ten numbers and figures out which number is the third highest. For a brand-new programmer, that can be a tough assignment, even though it only requires basic programming syntax.
If you’re stuck, you should reduce the problem to something simpler. Instead of the third-highest number, what about finding the highest overall? Still too tough? What about finding the largest of just three numbers? Or the larger of two?
Reduce the problem to the point where you know how to solve it and write the solution. Then expand the problem slightly and rewrite the solution to match, and keep going until you are back where you started.” — V. Anton Spraul

Stuck? By now, you’re probably sitting there thinking “Hey Richard... That’s cool and all, but what if I’m stuck and can’t even solve a sub-problem??”

First off, take a deep breath. Second, that’s fair.

Don’t worry though, friend. This happens to everyone!

The difference is the best programmers/problem-solvers are more curious about bugs/errors than irritated.

In fact, here are three things to try when facing a whammy:

Debug: Go step by step through your solution trying to find where you went wrong. Programmers call this debugging (in fact, this is all a debugger does).
“The art of debugging is figuring out what you really told your program to do rather than what you thought you told it to do.”” — Andrew Singer
Reassess: Take a step back. Look at the problem from another perspective. Is there anything that can be abstracted to a more general approach?
“Sometimes we get so lost in the details of a problem that we overlook general principles that would solve the problem at a more general level. […]
The classic example of this, of course, is the summation of a long list of consecutive integers,

1 + 2 + 3 + … + n,

which a very young Gauss quickly recognized was simply n(n+1)/2, thus avoiding the effort of having to do the addition.” — C. Jordan Ball
Sidenote: Another way of reassessing is starting anew. Delete everything and begin again with fresh eyes. I’m serious. You’ll be dumbfounded at how effective this is.

Research: Ahh, good ol’ Google. You read that right. No matter what problem you have, someone has probably solved it. Find that person/ solution. In fact, do this even if you solved the problem! (You can learn a lot from other people’s solutions).
Caveat: Don’t look for a solution to the big problem. Only look for solutions to sub-problems. Why? Because unless you struggle (even a little bit), you won’t learn anything. If you don’t learn anything, you wasted your time.

Practice
Don’t expect to be great after just one week. If you want to be a good problem-solver, solve a lot of problems!

Practice. Practice. Practice. It’ll only be a matter of time before you recognize that “this problem could easily be solved with .”

How to practice? There are options out the wazoo!

Chess puzzles, math problems, Sudoku, Go, Monopoly, video-games, cryptokitties, bla… bla… bla….

In fact, a common pattern amongst successful people is their habit of practicing “micro problem-solving.” For example, Peter Thiel plays chess, and Elon Musk plays video-games.

“Byron Reeves said ‘If you want to see what business leadership may look like in three to five years, look at what’s happening in online games.’
Fast-forward to today. Elon [Musk], Reid [Hoffman], Mark Zuckerberg and many others say that games have been foundational to their success in building their companies.” — Mary Meeker (2017 internet trends report)
Does this mean you should just play video-games? Not at all.

But what are video-games all about? That’s right, problem-solving!

So, what you should do is find an outlet to practice. Something that allows you to solve many micro-problems (ideally, something you enjoy).

For example, I enjoy coding challenges. Every day, I try to solve at least one challenge (usually on Coderbyte).

Like I said, all problems share similar patterns.

Conclusion
That’s all folks!

Now, you know better what it means to “think like a programmer.”

You also know that problem-solving is an incredible skill to cultivate (the meta-skill).

As if that wasn’t enough, notice how you also know what to do to practice your problem-solving skills!

Phew… Pretty cool right?

Finally, I wish you encounter many problems and solve them

Special thanks to Richard Reis

TWITTER IMAGES INTO YOUR WEBSITE

ssenyonga yasin — Fri, 03 Sep 2021 07:51:02 +0000

1.Click the icon located within the Tweet.
2.From the menu, select Embed Tweet.
3.This will open publish.twitter.com where you can customize the look of the embedded Tweet by clicking set customization options.
4.If the Tweet is a reply to another Tweet, you can check Hide Conversation to hide the original Tweet.
5.Once you like the look of the embedded Tweet, copy the code provided by clicking the Copy Code button.
6.Paste the code into your blog or website.

example

#MoneyHeistSeason5 must watch today pic.twitter.com/IyFpGbFLfD
— computer_wizard (@MillersYasin) September 3, 2021

<blockquote class="twitter-tweet" data-theme="dark"><p lang="en" dir="ltr"><a href="https://twitter.com/hashtag/MoneyHeistSeason5?src=hash&amp;ref_src=twsrc%5Etfw">#MoneyHeistSeason5</a> must watch today <a href="https://t.co/IyFpGbFLfD">pic.twitter.com/IyFpGbFLfD</a></p>&mdash; computer_wizard (@MillersYasin) <a href="https://twitter.com/MillersYasin/status/1433677771751010308?ref_src=twsrc%5Etfw">September 3, 2021</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

You can also edit the image as you are coding in your editor that's the height, width etc.

Make your site very light by using twitter to host the images.

FLASK WEB DEVELOPMENT

ssenyonga yasin — Fri, 13 Aug 2021 09:44:01 +0000

Web development In Python

So one of the application domains of Python is Web development. You can use it to make powerful and fast web applications. In so making, a number of tools and frameworks have been developed to aid web development in Python.

Some of these are but not limited to;

Django
Flask
Pyramid

web-frameworks-python

Our focus will be on the Flask framework.
And for a quick overview on how to get started with Python Web development, consider looking into, Getting Started with Python Web Development using ###FLASK

Once you have mastered the basic overview of flask, we will dive into the topic of the day.
What an introduction !!! Hope you are enjoying the article. Let us refocus now.

refocus-image

Given a minimal Flask application, such as;

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello World, dear Friend!'


@app.route('/page/<int:page_num>')
def content(page_num):
    return f'<h1>Yoo.. It is your page {page_num}</h1>'

`if __name__ == '__main__':
    app.run(host='',port='',debug=True)

The minimal application can be run following the steps below, (as you might be familiar),

On Bash

export FLASK_APP=app.py
flask run

Other scenarios you might want to specify the host and port number, environment, debug mode etc. for which you want your flask application to run, you would have to include all that into the export command above.
That can become tedious over time as you develop your cool project, pressing up arrow key many times to retrace the export command (bash users, you know what I mean).

On Bash
flask run

The variables that we add to the export command are known as environment variables. These variables are used by your flask application to serve your project.

Examples of environment variables include;

FLASK_ENV
FLASK_DEBUG.
FLASK_RUN_EXTRA_FILES
FLASK_RUN_HOST
FLASK_RUN_PORT
FLASK_RUN_CERT
FLASK_RUN_KEY

Those are default flask environment variables defined by the framework. If not specified, they use their default values.

User defined variables
Also, if you wanted to connect your application to a database, you would have to hard code your credentials into your python code, which is not recommended.
An example

from flask import Flask
app = Flask(__name__)

app.config[MYSQL_USER]="your_username"
app.config[MYSQL_HOST]="localhost"
app.config[MYSQL_DB]="my_appdb"
app.config[MYSQL_PASSWORD]="your_password"

@app.route('/')
def index():
    return {'Message': 'Hello World'}

That kind of hard coding credentials is not ideal if you are working on a large project with other people

Incase you do not follow Strict password policies and use one password everywhere....You are hacked!!!. You just shared your password with the world.

So how do we deal with the flask environment variables?
We are going to see how to load flask environment variables automatically. You are here because you're tired of setting environment variables every time you are running your flask app? Variables like FLASK_APP or FLASK_ENV using export command. Am going to help you do just that.

Step 1: Install python-dotenv
In your virtual environment, run;
pip install python-dotenv

I emphasize, always use virtual environments on your system to prevent corrupting your main Python installation. In case you want a recap on how to create virtual environments, refer to this guide. Creation of Virtual Environments

Step 2: Create .env and .flaskenv files in your project root folder

On Bash

touch .env
touch .flaskenv

Step 3: Place your flask environment variables in .flaskenv
Depending on your use case, this will guide you on what to include.

In .flaskenv

//this is the .flaskenv file
FLASK_ENV - Controls the environment.
FLASK_DEBUG - Enables debug mode.
FLASK_RUN_EXTRA_FILES - A list of files that will be watched by the re-loader in addition to the Python modules.
FLASK_RUN_HOST - The host you want to bind your app to.
FLASK_RUN_PORT - The port you want to use.
FLASK_RUN_CERT - A certificate file for so your app can be run with HTTPS.
FLASK_RUN_KEY - The key file for your cert.
for example; FLASK_APP=app.py

Boom, great work done. To run your app now, Simply do run;

flask-run

That was fast,.... right?? Yes so you can now focus on programming instead of looking for which flask environment variable is missing.

So how about my-secretly-defined environment variables?
Yes getting to that now. Follow this guide.

Step 1. Place your-secretly-defined environment variables in .env
These can include;

In .env
//This is the .env file
MYSQL_USER=root
MYSQL_PASSWORD=my_mysql_password
MYSQL_DB=userdb
MYSQL_HOST=localhost
SECRET_KEY=topsecretkey
API_KEY=donotsharethisapikeywithanyone

Step 2: Create a settings.py file
(Since these variables are not served automatically, we have to load them through this settings.py file)

In settings.py
//This is the settings.py file

from os import environ
SECRET_KEY=environ.get('SECRET_KEY)
API_KEY=environ.get('API_KEY')
MYSQL_USER=environ.get('MYSQL_USER')
//add any more variables you have

Note: For consistency, it is good to keep the same variable name as the environment variable.

Step 3: Add the configurations to our app
In your app.py , the file that has your flask object.
app.config.from_pyfile('settings.py')

loading all environment variables from settings.py

So what happens is that the settings.py will read the values you placed in your .env file and store them in variables as you defined them in settings.py.

When you use the flask object's config method, together with the from_pyfile sub-method, the app will have access to the secretly defined variables in a secure way.

Good lck in coding

INTRODUCTIN TO PYTHON FUCTIONS

ssenyonga yasin — Mon, 02 Aug 2021 11:57:32 +0000

What are functions?

Functions are a set of actions that we group together, and give a name to. You have already used a number of functions from the core Python language, such as string.title() and list.sort(). We can define our own functions, which allows us to "teach" Python new behavior.

General Syntax

A general function looks something like this:

# Let's define a function.
def function_name(argument_1, argument_2):
    # Do whatever we want this function to do,
    #  using argument_1 and argument_2

# Use function_name to call the function.
function_name(value_1, value_2)

This code will not run, but it shows how functions are used in general.

Defining a function

Give the keyword def, which tells Python that you are about to define a function.
Give your function a name. A variable name tells you what kind of value the variable contains; a function name should tell you what the function does.
Give names for each value the function needs in order to do its work.
These are basically variable names, but they are only used in the function.
They can be different names than what you use in the rest of your program.
These are called the function's arguments.
Make sure the function definition line ends with a colon.
Inside the function, write whatever code you need to make the function do its work.

Using your function

To call your function, write its name followed by parentheses.
Inside the parentheses, give the values you want the function to work with.
These can be variables such as current_name and current_age, or they can be actual values such as 'eric' and 5.
top

Basic Examples

For a simple first example, we will look at a program that compliments people. Let's look at the example, and then try to understand the code. First we will look at a version of this program as we would have written it earlier, with no functions.

print("You are doing good work, Adriana!")
print("Thank you very much for your efforts on this project.")

print("\nYou are doing good work, Billy!")
print("Thank you very much for your efforts on this project.")

print("\nYou are doing good work, Caroline!")
print("Thank you very much for your efforts on this project.")

Functions take repeated code, put it in one place, and then you call that code when you want to use it. Here's what the same program looks like with a function.

def thank_you(name):
    # This function prints a two-line personalized thank you message.
    print("\nYou are doing good work, %s!" % name)
    print("Thank you very much for your efforts on this project.")

thank_you('Adriana')
thank_you('Billy')
thank_you('Caroline')

In our original code, each pair of print statements was run three times, and the only difference was the name of the person being thanked. When you see repetition like this, you can usually make your program more efficient by defining a function.

The keyword def tells Python that we are about to define a function. We give our function a name, thank_you() in this case. A variable's name should tell us what kind of information it holds; a function's name should tell us what the variable does. We then put parentheses. Inside these parenthese we create variable names for any variable the function will need to be given in order to do its job. In this case the function will need a name to include in the thank you message. The variable name will hold the value that is passed into the function thank_you().

To use a function we give the function's name, and then put any values the function needs in order to do its work. In this case we call the function three times, each time passing it a different name.

A common error

A function must be defined before you use it in your program. For example, putting the function at the end of the program would not work.

thank_you('Adriana')
thank_you('Billy')
thank_you('Caroline')

def thank_you(name):
    # This function prints a two-line personalized thank you message.
    print("\nYou are doing good work, %s!" % name)
    print("Thank you very much for your efforts on this project.")

On the first line we ask Python to run the function thank_you(), but Python does not yet know how to do this function. We define our functions at the beginning of our programs, and then we can use them when we need to.

A second example

When we introduced the different methods for sorting a list, our code got very repetitive. It takes two lines of code to print a list using a for loop, so these two lines are repeated whenever you want to print out the contents of a list. This is the perfect opportunity to use a function, so let's see how the code looks with a function.

First, let's see the code we had without a function:

students = ['bernice', 'aaron', 'cody']

# Put students in alphabetical order.
students.sort()

# Display the list in its current order.
print("Our students are currently in alphabetical order.")
for student in students:
    print(student.title())

# Put students in reverse alphabetical order.
students.sort(reverse=True)

# Display the list in its current order.
print("\nOur students are now in reverse alphabetical order.")
for student in students:
    print(student.title())
Here's what the same code looks like, using a function to print out the list:

def show_students(students, message):
    # Print out a message, and then the list of students
    print(message)
    for student in students:
        print(student.title())

students = ['bernice', 'aaron', 'cody']

# Put students in alphabetical order.
students.sort()
show_students(students, "Our students are currently in alphabetical order.")

#Put students in reverse alphabetical order.
students.sort(reverse=True)
show_students(students, "\nOur students are now in reverse alphabetical order.")

This is much cleaner code. We have an action we want to take, which is to show the students in our list along with a message. We give this action a name, show_students().

This function needs two pieces of information to do its work, the list of students and a message to display. Inside the function, the code for printing the message and looping through the list is exactly as it was in the non-function code.

Now the rest of our program is cleaner, because it gets to focus on the things we are changing in the list, rather than having code for printing the list. We define the list, then we sort it and call our function to print the list. We sort it again, and then call the printing function a second time, with a different message. This is much more readable code.

Advantages of using functions

You might be able to see some advantages of using functions, through this example:

We write a set of instructions once.

We save some work in this simple example, and we save even more work in larger programs.
When our function works, we don't have to worry about that code anymore. Every time you repeat code in your program, you introduce an opportunity to make a mistake. Writing a function means there is one place to fix mistakes, and when those bugs are fixed, we can be confident that this function will continue to work correctly.
We can modify our function's behavior, and that change takes effect every time the function is called. This is much better than deciding we need some new behavior, and then having to change code in many different places in our program.
For a quick example, let's say we decide our printed output would look better with some form of a bulleted list. Without functions, we'd have to change each print statement. With a function, we change just the print statement in the function:

def show_students(students, message):
    # Print out a message, and then the list of students
    print(message)
    for student in students:
        print("- " + student.title())

students = ['bernice', 'aaron', 'cody']

# Put students in alphabetical order.
students.sort()
show_students(students, "Our students are currently in alphabetical order.")

#Put students in reverse alphabetical order.
students.sort(reverse=True)
show_students(students, "\nOur students are now in reverse alphabetical order.")

You can think of functions as a way to "teach" Python some new behavior. In this case, we taught Python how to create a list of students using hyphens; now we can tell Python to do this with our students whenever we want to.

Returning a Value

Each function you create can return a value. This can be in addition to the primary work the function does, or it can be the function's main job. The following function takes in a number, and returns the corresponding word for that number:

def get_number_word(number):
    # Takes in a numerical value, and returns
    #  the word corresponding to that number.
    if number == 1:
        return 'one'
    elif number == 2:
        return 'two'
    elif number == 3:
        return 'three'
    # ...

# Let's try out our function.
for current_number in range(0,4):
    number_word = get_number_word(current_number)
    print(current_number, number_word)

It's helpful sometimes to see programs that don't quite work as they are supposed to, and then see how those programs can be improved. In this case, there are no Python errors; all of the code has proper Python syntax. But there is a logical error, in the first line of the output.

We want to either not include 0 in the range we send to the function, or have the function return something other than None when it receives a value that it doesn't know. Let's teach our function the word 'zero', but let's also add an else clause that returns a more informative message for numbers that are not in the if-chain.

def get_number_word(number):
    # Takes in a numerical value, and returns
    #  the word corresponding to that number.
    if number == 0:
        return 'zero'
    elif number == 1:
        return 'one'
    elif number == 2:
        return 'two'
    elif number == 3:
        return 'three'
    else:
        return "I'm sorry, I don't know that number."

# Let's try out our function.
for current_number in range(0,6):
    number_word = get_number_word(current_number)
    print(current_number, number_word)

If you use a return statement in one of your functions, keep in mind that the function stops executing as soon as it hits a return statement. For example, we can add a line to the get_number_word() function that will never execute, because it comes after the function has returned a value:

def get_number_word(number):
    # Takes in a numerical value, and returns
    #  the word corresponding to that number.
    if number == 0:
        return 'zero'
    elif number == 1:
        return 'one'
    elif number == 2:
        return 'two'
    elif number == 3:
        return 'three'
    else:
        return "I'm sorry, I don't know that number."

    # This line will never execute, because the function has already
    #  returned a value and stopped executing.
    print("This message will never be printed.")

# Let's try out our function.
for current_number in range(0,6):
    number_word = get_number_word(current_number)
    print(current_number, number_word)

PYTHON BASICS

ssenyonga yasin — Thu, 22 Jul 2021 11:31:24 +0000

Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation.

python

Common Feature Provided By python

Simplicity-> Think less of the syntax of the language and more of the code.

Open Source-> A powerful language and it is free for everyone to use and alter as needed.

Portability->Python code can be shared and it would work the same way it was intended to. Seamless and hassle-free.

Applications of Python.

Artificial Intelligence
Desktop Application
Automation
Web Development

Python Hello World.
Launch the VS code ,create a new python file, let say hello.py file and enter the following code and save the file:

print('Hello, World!')

The print() is a built-in function that displays a message on the screen. In our case, it’ll show the message 'Hello, Word!'.

Executing the Python program.

To execute the file we created above, you launch the Command Prompt or Terminal on vascode.

After that, type the following command,
Python3 hello.py

output


Hello, World!

Comments

A comment is text in a program's code, script, or another file that is not meant to be seen by the user .

Comments help make code easier to understand by explaining what is happening in the code

single line comment

'''
multiline comment

Using docstring
'''

Arithmetic Operators.
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)

Variables

What is a Variable in Python?

A Python variable is a reserved memory location to store values. In other words, a variable in a python program gives data to the computer for processing.

Python Variable Types

Every value in Python has a datatype. Different data types in Python are Numbers, List, Tuple, Strings, Dictionary, etc. Variables in Python can be declared by any name or even alphabets like a, aa, abc, etc.

How to Declare and use a Variable

Let see an example. We will define variable in Python and declare it as "a" and print it.


a=100 
print (a)

Re-declare a Variable

You can re-declare Python variables even after you have declared once.

Here we have Python declare variable initialized to f=0.

Later, we re-assign the variable f to any value

Python 2 Example

# Declare a variable and initialize it

f = 0
print f
# re-declaring the variable works
f = 'new'
print f

Python 3 Example

# Declare a variable and initialize it
f = 0
print(f)
# re-declaring the variable works
f = 'new'
print(f)

Python String Concatenation and Variable

Let's see whether you can concatenate different data types like string and number together. For example, we will concatenate "new" with the number "version".

For the following code, you will get undefined output -

a="new"
b = "version"
print a+b

Once the integer is declared as string, it can concatenate both

a="new"
b = "version"
print(a+str(b))

Python Variable Types: Local & Global

There are two types of variables in Python, Global variable and Local variable. When you want to use the same variable for rest of your program or module you declare it as a global variable, while if you want to use the variable in a specific function or method, you use a local variable while Python variable declaration.

Let's understand this Python variable types with the difference between local and global variables in the below program.

Let us define variable in Python where the variable "f" is global in scope and is assigned value 101 which is printed in output
Variable f is again declared in function and assumes local scope. It is assigned value "I am learning Python." which is printed out as an output. This Python declare variable is different from the global variable "f" defined earlier
Once the function call is over, the local variable f is destroyed.

What are Logical Operators in Python?

Logical Operators in Python are used to perform logical operations on the values of variables. The value is either true or false. We can figure out the conditions by the result of the truth values. There are mainly three types of logical operators in python : logical AND, logical OR and logical NOT. Operators are represented by keywords or special characters.

Arithmetic Operators
Comparison Operators
Python Assignment Operators
Logical Operators or Bitwise Operators
Membership Operators
Identity Operators
Operator precedence

Arithmetic Operators

Arithmetic Operators perform various arithmetic calculations like addition, subtraction, multiplication, division, %modulus, exponent, etc. There are various methods for arithmetic calculation in Python like you can use the eval function, declare variable & calculate, or call functions.

Example: For arithmetic operators we will take simple example of addition where we will add two-digit 4+5=9

x= 4    
y= 5
print(x + y)

Similarly, you can use other arithmetic operators like for multiplication(*), division (/), substraction (-), etc.

Comparison Operators

Comparison Operators In Python compares the values on either side of the operand and determines the relation between them. It is also referred to as relational operators. Various comparison operators in python are ( ==, != , <>, >,<=, etc.)

Example: For comparison operators we will compare the value of x to the value of y and print the result in true or false. Here in example, our value of x = 4 which is smaller than y = 5, so when we print the value as x>y, it actually compares the value of x to y and since it is not correct, it returns false.

x = 4
y = 5
print(('x > y  is',x>y))

Likewise, you can try other comparison operators (x < y, x==y, x!=y, etc.)

Python Assignment Operators

Assignment Operators in Python are used for assigning the value of the right operand to the left operand. Various assignment operators used in Python are (+=, - = , *=, /= , etc.).

Example: Python assignment operators is simply to assign the value, for example

num1 = 4
num2 = 5
print(("Line 1 - Value of num1 : ", num1))
print(("Line 2 - Value of num2 : ", num2))

Example of compound assignment operator

We can also use a compound assignment operator, where you can add, subtract, multiply right operand to left and assign addition (or any other arithmetic function) to the left operand.

Step 1: Assign value to num1 and num2
Step 2: Add value of num1 and num2 (4+5=9)
Step 3: To this result add num1 to the output of Step 2 ( 9+4)
Step 4: It will print the final result as 13

num1 = 4
num2 = 5
res = num1 + num2
res += num1
print(("Line 1 - Result of + is ", res))

Logical Operators

Logical operators in Python are used for conditional statements are true or false. Logical operators in Python are AND, OR and NOT. For logical operators following condition are applied.

For AND operator – It returns TRUE if both the operands (right side and left side) are true
For OR operator- It returns TRUE if either of the operand (right side or left side) is true
For NOT operator- returns TRUE if operand is false
Example: Here in example we get true or false based on the value of a and b

a = True
b = False
print(('a and b is',a and b))
print(('a or b is',a or b))
print(('not a is',not a))

Membership Operators

These operators test for membership in a sequence such as lists, strings or tuples. There are two membership operators that are used in Python. (in, not in). It gives the result based on the variable present in specified sequence or string

Example: For example here we check whether the value of x=4 and value of y=8 is available in list or not, by using in and not in operators.

x = 4
y = 8
list = [1, 2, 3, 4, 5 ];
if ( x in list ):
   print("Line 1 - x is available in the given list")
else:
   print("Line 1 - x is not available in the given list")
if ( y not in list ):
   print("Line 2 - y is not available in the given list")
else:
   print("Line 2 - y is available in the given list")

Declare the value for x and y
Declare the value of list
Use the "in" operator in code with if statement to check the value of x existing in the list and print the result accordingly
Use the "not in" operator in code with if statement to check the value of y exist in the list and print the result accordingly
Run the code- When the code run it gives the desired output

Identity Operators

Identity Operators in Python are used to compare the memory location of two objects. The two identity operators used in Python are (is, is not).

Operator is: It returns true if two variables point the same object and false otherwise
Operator is not: It returns false if two variables point the same object and true otherwise
Following operands are in decreasing order of precedence.

Operators in the same box evaluate left to right

Operators (Decreasing order of precedence) Meaning
** Exponent
, /, //, % Multiplication, Division, Floor division, Modulus
+, - Addition, Subtraction
<= < > >= Comparison operators
= %= /= //= -= += *= *= Assignment Operators
is is not Identity operators
in not in Membership operators
not or and Logical operators
Example:

x = 20
y = 20
if ( x is y ): 
    print("x & y  SAME identity")
y=30
if ( x is not y ):
    print("x & y have DIFFERENT identity")

Declare the value for variable x and y
Use the operator "is" in code to check if value of x is same as y
Next we use the operator "is not" in code if value of x is not same as y
Run the code- The output of the result is as expected
Operator precedence
The operator precedence determines which operators need to be evaluated first. To avoid ambiguity in values, precedence operators are necessary. Just like in normal multiplication method, multiplication has a higher precedence than addition. For example in 3+ 4*5, the answer is 23, to change the order of precedence we use a parentheses (3+4)5, now the answer is 35. Precedence operator used in Python are (unary + - ~, *, * / %, + - , &) etc.

v = 4
w = 5
x = 8
y = 2
z = 0
z = (v+w) * x / y;   
print("Value of (v+w) * x/ y is ",  z)

Declare the value of variable v,w…z
Now apply the formula and run the code
The code will execute and calculate the variable with higher precedence and will give the output
Python 2 Example
Above examples are Python 3 codes, if you want to use Python 2, please consider following codes

#Arithmetic Operators
x= 4    
y= 5
print x + y

#Comparison Operators
x = 4
y = 5
print('x > y  is',x>y)

#Assignment Operators
num1 = 4
num2 = 5
print ("Line 1 - Value of num1 : ", num1)
print ("Line 2 - Value of num2 : ", num2)

#compound assignment operator
num1 = 4
num2 = 5
res = num1 + num2
res += num1
print ("Line 1 - Result of + is ", res)

#Logical Operators
a = True
b = False
print('a and b is',a and b)
print('a or b is',a or b)
print('not a is',not a)

#Membership Operators
x = 4
y = 8
list = [1, 2, 3, 4, 5 ];
if ( x in list ):
   print "Line 1 - x is available in the given list"
else:
   print "Line 1 - x is not available in the given list"
if ( y not in list ):
   print "Line 2 - y is not available in the given list"
else:
   print "Line 2 - y is available in the given list"

#Identity Operators
x = 20
y = 20
if ( x is y ):
    print "x & y  SAME identity"
y=30
if ( x is not y ):
    print "x & y have DIFFERENT identity"

#Operator precedence
v = 4
w = 5
x = 8
y = 2
z = 0
z = (v+w) * x / y;   
print "Value of (v+w) * x/ y is
pi = 3.14 # float
total = age + pi # float
print(type(age), type(pi), type(total)) # <class 'int'> <class 'float'> <class 'float'>

Windows 10 out windows 11 in

ssenyonga yasin — Mon, 19 Jul 2021 19:15:48 +0000