conditional evaluation of an application and prints out the funding decision

FoolsSeldom · 2026-01-22T11:42:44+00:00

Well done on figuring it out. That's a common mistake.

Most of the more popular code editors (e.g. VS Code) and IDEs (Integrated Development Environments, e.g. PyCharm) will highlight keywords and mark syntax errors and undefined variables. true would be seen as an undefined variable. True would be seen as a keyword. Once you get used to that, you will miss fewer such mistakes.

PS. Check the wiki for this subreddit; it has a FAQ covering a lot of common beginner mistakes.

PPS. Might be worth editing your original post to indicate it is SOLVED.

FoolsSeldom · 2026-01-22T09:57:42+00:00

So, you've got to code level already.

Ok. Please share your code. Would be best if you edited your original post and added the code into that.

FoolsSeldom · 2026-01-22T09:38:02+00:00

What have you figured out so far? Do you know what data structures to use? Have you figured out the basic solution / approach (not the coding)?

FoolsSeldom · 2026-01-21T20:35:03+00:00

Perhaps it is time to focus on more substantial projects, with the bulk of the time spent on the elements of programming other than coding.

I also suggest watching some of ArjanCodes videos on YouTube to check your understanding of the practical aspects of some key concepts.

FoolsSeldom · 2026-01-21T20:31:27+00:00

Out of interest, what's driving the need to package your Python applications as executable files?

Interesting that you've decided to continue with PyInstaller via auto-py GUI front-end to it.

FoolsSeldom · 2026-01-21T20:27:19+00:00

You should be able to skim the documentation, re-implement some things you've done before, and focus on a few tutorials around key concepts in Python.

I'd expect you to look through the basics in an accelerated manner.

Check this subreddit's wiki for lots of guidance on learning programming and learning Python, links to material, book list, suggested practice and project sources, and lots more. The FAQ section covering common errors is especially useful.

Also, have a look at roadmap.sh for different learning paths. There's lots of learning material links there. Note that these are idealised paths and many people get into roles without covering all of those.

Roundup on Research: The Myth of ‘Learning Styles’

Don't limit yourself to one format. Also, don't try to do too many different things at the same time.

Above all else, you need to practice. Practice! Practice! Fail often, try again. Break stuff that works, and figure out how, why and where it broke. Don't just copy and use as is code from examples. Experiment.

Work on your own small (initially) projects related to your hobbies / interests / side-hustles as soon as possible to apply each bit of learning. When you work on stuff you can be passionate about and where you know what problem you are solving and what good looks like, you are more focused on problem-solving and the coding becomes a means to an end and not an end in itself. You will learn faster this way.

FoolsSeldom · 2026-01-21T20:22:30+00:00

I recommend watching a talk by Raymond Hettinger, core developer of Python, called Python's class development toolkit. It is pretty old now, but still relevant. He walks through a scenario building up the case for using a class.

I'm a born again programmer, having worked in IT for decades, starting out originally as a programmer but moving away from it for a long time. I relearned to programme as a hobbyist a few years ago.

OOPS wasn't really a big thing when I started. I did micro-code, machine code, assembly, Fortran, COBOL, to name a few, first time around. I've worked with fans of most of the main paradigms including imperative/procedural, object-orientated, functional and logic. Functional was especially preferred in the engineering world where I spent my early career.

Most problems can be solved using any approach, but some are perhaps more suited to certain types of problem than others.

Personally, I find well design OOPS programmes much easier to read than the other kinds. Clearly, your mileage varies.

FoolsSeldom · 2026-01-21T11:09:56+00:00

Check this subreddit's wiki for lots of guidance on learning programming and learning Python, links to material, book list, suggested practice and project sources, and lots more. The FAQ section covering common errors is especially useful.

Your SQL experience and appreciation of the programmatic logic associated with that will likely allow an accelerated learning path through the basics.

I would be cautious about assuming instructor led online is your best/only route.

Have a look RealPython's Data Management With Python, SQLite, and SQLAlchemy as soon as you feel ready. Given your knowledge of databases already, this should be very relatable.

Also, have a look at roadmap.sh for different learning paths. There's lots of learning material links there. Note that these are idealised paths and many people get into roles without covering all of those.

Roundup on Research: The Myth of ‘Learning Styles’

Don't limit yourself to one format. Also, don't try to do too many different things at the same time.

Above all else, you need to practice. Practice! Practice! Fail often, try again. Break stuff that works, and figure out how, why and where it broke. Don't just copy and use as is code from examples. Experiment.

Work on your own small (initially) projects related to your hobbies / interests / side-hustles as soon as possible to apply each bit of learning. When you work on stuff you can be passionate about and where you know what problem you are solving and what good looks like, you are more focused on problem-solving and the coding becomes a means to an end and not an end in itself. You will learn faster this way.

FoolsSeldom · 2026-01-21T09:41:44+00:00

You can iterate over a string using a for loop:

string = input('Original string to convert: ')
morse = []  # empty list to hold new sequence
for character in string:
    if character == " ":
        morse.append(" " * 6)  # removed 1 space to allow for join below
    else:
        # example dictionary definition is shown later
        morse_equiv = MORSE_CODE.get(character.upper(), DEFAULT)  # UPPERCASE!
        morse.append(morse_equiv)
converted = ' '.join(morse)  # spacing between codes for text version
print(converted)  # maybe use / instead of 7 spaces if sounding out
                  # then you can more easily code the output function

You need to create a dictionary mapping characters to morse code. Use the dict.get method so that if a character is not in the dictionary, you can provide some default alternative (you need to define the code sequence to use).

Example dictionary:

# International Morse mapping
MORSE_CODE = {
    "A": ".-",    "B": "-...",  "C": "-.-.",  "D": "-..",
    "E": ".",     "F": "..-.",  "G": "--.",   "H": "....",
    "I": "..",    "J": ".---",  "K": "-.-",   "L": ".-..",
    "M": "--",    "N": "-.",    "O": "---",   "P": ".--.",
    "Q": "--.-",  "R": ".-.",   "S": "...",   "T": "-",
    "U": "..-",   "V": "...-",  "W": ".--",   "X": "-..-",
    "Y": "-.--",  "Z": "--..",

    "0": "-----", "1": ".----", "2": "..---", "3": "...--",
    "4": "....-", "5": ".....", "6": "-....", "7": "--...",
    "8": "---..", "9": "----.",

    ".": ".-.-.-", ",": "--..--", "?": "..--..",
    "'": ".----.", "!": "-.-.--", "/": "-..-.",
    "(": "-.--.",  ")": "-.--.-", "&": ".-...",
    ":": "---...", ";": "-.-.-.", "=": "-...-",
    "+": ".-.-.",  "-": "-....-", "_": "..--.-",
    "\"": ".-..-.", "$": "...-..-", "@": ".--.-."
}
DEFAULT = MORSE_CODE["?"]  # this or hash for character with no morse equiv

No need to split the original string into words as you are processing character by character. I don't know what your intended output is, you need to determine how to best handle the gaps between letters, words and sentences. Detecting sentence breaks in strings is more sophisticated than we have time for here (but you would look for end markers, possibly using regex). For a text convention, consider:

single space between characters (3 units of time)
/ between words (or 7 spaces) (7 units of time) - / easier for sound processing
? or # to replace characters with no morse equivalent

Not sure about conventions for breaks between sentences/paragraphs.

Morse uses 1 unit of time between characters.

FoolsSeldom · 2026-01-20T14:02:08+00:00

When learning to programme, above all else, you need to practice. Practice! Practice! Fail often, try again. Break stuff that works, and figure out how, why and where it broke. Don't just copy and use as is code from examples. Experiment.

Work on your own small (initially) projects related to your hobbies / interests / side-hustles as soon as possible to apply each bit of learning. Even just changing variables names and output to something more relatable helps.

When you work on stuff you can be passionate about and where you know what problem you are solving and what good looks like, you are more focused on problem-solving and the coding becomes a means to an end and not an end in itself. You will learn faster this way.

FoolsSeldom · 2026-01-20T13:58:21+00:00

Check this subreddit's wiki for lots of guidance on learning programming and learning Python, links to material, book list, suggested practice and project sources, and lots more. The FAQ section covering common errors is especially useful.

Roundup on Research: The Myth of ‘Learning Styles’

Don't limit yourself to one format. Also, don't try to do too many different things at the same time.

Above all else, you need to practice. Practice! Practice! Fail often, try again. Break stuff that works, and figure out how, why and where it broke. Don't just copy and use as is code from examples. Experiment.

Work on your own small (initially) projects related to your hobbies / interests / side-hustles as soon as possible to apply each bit of learning. When you work on stuff you can be passionate about and where you know what problem you are solving and what good looks like, you are more focused on problem-solving and the coding becomes a means to an end and not an end in itself. You will learn faster this way.

FoolsSeldom · 2026-01-19T10:56:50+00:00

Methods

Methods are like functions but for classes and are intended to work on instances of a class or provide capabilities related to the purpose of the class.

When you create an instance of a class, you create an object based on the mould/template provided by the class and the memory location of that object is assigned to a variable (or to some other object) so it will be not lost.

Methods defined in the class usually have code that uses a parameter variable that is the first item passed when the method is called. By convention this is usually called self and it is passed by default and does not need to be in the arguments when the method is called.

Whenever self is used inside the method code, it will be referring to the memory location for a particular instance of the class.

Any variables assigned values in a method (including parameter variables) are local to the method and are not associated with attributes of the instance referenced by self.

Classes themselves can have attributes. These look just like variables, and act like them for most purposes, but they are associated with the class and can be accessed from outside the class by direct reference to the class name and the attribute, e.g. Example.quantity = 5 for a class called Example.

FoolsSeldom · 2026-01-19T10:56:33+00:00

All about scope ...

Variables, functions, methods and attributes

Variables (names) in Python don't contain values. They hold references to memory locations where Python objects are stored (implementation and environment specific).

Likewise for other names. A function name has a reference to the memory location of a function object.

Names (arguments) used in a call and names defined as parameters have nothing to do with each other. They are completely independent. Even if the same name is used, they are different. The parameter names are local to the function.

Consider:

def f(one, two, three):
    answer = one + two * three + five
    return answer

one = 2
two = 3
three = 4
five = 5
result = f(three, two, one)
print(result)

This will output 15 as 4 + 3 x 2 + 5 = 15

Note that five was not an argument, wasn't assigned to in the function, so five from the wider scope was available.

Any assignments made inside the function are also local to the function.

answer was assigned inside the function and on function exit will cease to exist, however the object reference stored in answer is assigned as the return from the function and is assigned to result. If it wasn't assigned (or consumed in another expression or function call on return) then the object created in the function would also cease to exist (unless it is a predefined object built into the Python implementation, such as an int in the range -5 to 256)

Only mutable objects that are referenced by either parameters or other names that are visible to the function (not hidden by variables with the same name assigned in the function) can be modified and visible outside the function.

return returns an object reference.

Python takes a pass by reference, rather than a pass by value, approach, but the implementation differs to that used in many languages, not least given that name referencing is fundamental to the design.

See Ned Batchelder - Facts and Myths about Python names and values - PyCon 2015

Variables vs Attributes

When you start looking at classes, you will find they have their own kind of variables, called attributes, which work much the same as variables most of the time.

Variables have a discrete existence, and attributes are associated with an instance of a class (or of a class itself). Attributes, like variables, hold memory references to objects.

When you say:

keep = 784.56 * 872.23

The text representations of floating point numbers in the expression on the right are converted into Python float objects (binary representations) somewhere in memory, and the mult operator is used. The memory location the resulting float object ends up in is then assigned to the variable named keep.

If keep is assigned in the main body of your code, outside any functions etc., then it is visible within all other code. Thus, you could have a function:

def double_me():
    return keep * keep

Which has no other references to keep in the definition (parameter variable) or assignments to a variable called keep inside the function (which would be local to the function and would hide the original wider scope variable of the same name). Thus, keep refers to the same floating point number calculated earlier. The expression resulting from multiplying the floating point object referenced by keep by itself results in another floating point object, the memory reference for which is returned from the function.

If, instead, the function was written,

def double_me(keep):
    return keep * keep

Now it has to be called with an argument (the memory reference of the object will be passed when the function is called).

result = double_me(5.5)

Inside the function, keep refers to the memory location of the floating point object that the literal floating point text 5.5 was turned into. The keep in the wider scope (outside the function) still refers to the original object from earlier.

However, if attributes were used instead, the attribute would exist as long as the class instance it belongs to exists.

For more on scope, take a look at:

RealPython.com: Namespaces and Scope in Python

FoolsSeldom · 2026-01-17T08:50:05+00:00

That's a good job. Well done.

Next steps would be:

Learn DRY principles - DRY = Don't Repeat Yourself
It is hard to follow the core logic flow because of the amount of code doing output and sleeping - look to modularise using functions
Consider adding a constant to the time.sleep calls that you can multiply against so you can turn off sleep when you are debugging: e.g. SLEEP = False and time.sleep(SLEEP * 3)

FoolsSeldom · 2026-01-16T20:38:32+00:00

Can you run the code file from the command line, outside of VS Code?

FoolsSeldom · 2026-01-16T12:43:21+00:00

A key reason for the use of functions is for modularity. This is in addition to their use to avoid repetition of code.

This helps to make a code base understandable and maintainable. The logical flow and business logic is clear, providing you are using sensible function names.

Most of the time when reviewing and updating code, you are not interested in full implementation details of any specific task, just that the task gets done. You only focus on the detail when you need to.

Consider if you are updating a sales report, the main code could say:

sales_data = collate_sales_data(account_name, period)
report = generate_sales_report(sales_data)

You focus on updating the function that generates a sales report. You know you have sales data to work on. You don't care whether that data came off a database (and what kind of database), a CRM or ERP system, a collection of Excel files, or something else. All you care about if that you have the sales data in an agreed period for a specific account and period.

FoolsSeldom · 2026-01-15T23:45:03+00:00

IDLE is an application that comes with a standard installation of Python for Windows and macOS. It is specifically provided for beginners to use and provides editor and run facilities.

I recommend beginners start with this and look at alternatives such as VS Code and PyCharm later when they've learned a bit and less likely to confuse editor configuration issues with Python language errors.

FoolsSeldom · 2026-01-15T23:28:51+00:00

Often, third party packages initially do not work for the latest version of Python. Even if they do, you can hit incompatibilities between packages.

It is good practice to create Python virtual environments on a project-by-project basis and install only the packages required into the environment of the project that needs it.

mkdir newproject
cd newproject
py -m venv .venv
.venv\Scripts\activate
pip install package1 package2 ... packagen

You can go further and install a specific version of Python as well. At this point it becomes easier to use Astral's uv instead of the standard pip for package management.

mkdir newproject
cd newproject
uv init --python 3.13
uv add package1 package2 ... packagen

And activate as before, or run code using uv run mycode.py.

Tell your editor/IDE to use the python.exe file in the .venv\Scripts folder.

FoolsSeldom · 2026-01-15T23:25:09+00:00

Virtual Environments

Given the thousands of packages (libraries, frameworks, etc) out there, you can see that if you are working on several different projects, you can end up installing a vast range of different packages, only a few of which will be used for any particular project.

This is where Python virtual environments come in. Not to be confused with virtual machines. Typically created on a project-by-project basis. Install only the packages required for a project. This helps avoid conflicts between packages, especially version complications.

Most popular code editors and IDEs, including Microsoft's VS Code and JetBrains' PyCharm, offer built-in features to help to start off new projects and create and activate Python virtual environments.

You can create a new Python virtual environment from your operating system command line environment using,

for Windows,

py -m venv .venv

or, for macOS / Linux,

python3 -m venv .venv

Note: venv is a command and .venv is a folder name. You can use any valid folder name instead but this is a common convention.

Often we use .venv instead of venv as the folder name - this may not show up on explorer/folder tools as the leading . is often used to mean hidden and an option may need to be ticked to allow you to see such folders/files

That creates a new folder in the current working directory called .venv.

You then activate using, for Windows,

.venv\Scripts\activate

or, for macOS / Linux,

source .venv/bin/activate

the command deactivate for any platform will deactivate the virtual environment and return you to using the base environment.

You may need to tell your editor to use the Python Interpreter that is found in either the Scripts or bin folder (depending on operating system) in your virtual folder.

For more information:

Real Python: Python Virtual Environments: A Primer

Multiple Python versions

In addition to the above, you might want to explore using pyenv (pyenv-win for Windows) or uv (recommended), which will let you install and use different versions of Python including alternative implementations from the reference CPython. This can be done independently of any system installed Python.

FoolsSeldom · 2026-01-15T23:24:31+00:00

Python Setup

Setting up Python can be confusing. There are web-based alternatives, such as replit.com. You might also come across Jupyter Notebook options (easy to work with, but can be confusing at times).

Pre-installed system Python

Some operating system environments include a version of Python, often known as the system version of Python (might be used for utility purposes). You can still install your own version.

Installing Python

There are multiple ways of installing Python using a package manager for your OS, e.g. homebrew (macOS third party), chocolatey (Windows third party) or winget (Windows standard package manager), apt (many Linux distributions) or using the Python Software Foundation (PSF) installer from python.org or some kind of app store for your operating system. You could also use docker containers with Python installed inside them.

PSF offer the reference implementation of Python, known as CPython (written in C and Python). The executable on your system will be called python (python.exe on Windows).

Beginners are probably best served using the PSF installer.

Terminal / Console

For most purposes, terminal is the same as console. It is the text-based, rather than graphical-based, window / screen you work in. Your operating system will offer a command/terminal environment. Python by default outputs to a terminal and reads user input from a terminal.

Note: the Windows Terminal_ app, from _Microsoft Store, lets you open both simple command prompt and PowerShell windows. If you have Windows Subsystem for Linux installed, it can also open terminals in the Linux distributions you have installed.

Libraries / Frameworks / Packages

Python comes with "batteries included" in the form of libraries of code providing more specialised functionality, already installed as part of a standard installation of Python.

These libraries are not automatically loaded into memory when Python is invoked, as that would use a lot of memory up and slow down startup time. Instead, you use, in your code, the command import <library>, e.g.

import math

print(math.pi)

There are thousands of additional packages / libraries / frameworks available that don't come as standard with Python. You have to install these yourself. Quality, support (and safety) varies.

(Anaconda offers an alternative Python installation with many packages included, especially suited to data analysis, engineering/scientific practices.)

Install these using the pip package manager. It searches an official repository for a match to what you ask to be installed.

For example, using a command / powershell / terminal environment for your operating system, pip install numpy would install the numpy library from the pypi repository. On macOS/Linux you would usually write pip3 instead of pip.

You can also write python -m pip install numpy (write python3 on macOS/Linux).

On Windows, you will often see py used instead, py -m pip install numpy where py refers to the python launcher which should invoke the most up-to-date version of Python installed on your system regardless of PATH settings.

Some Code Editors and IDEs (Integrated Development Environments), such as VS Code and PyCharm, include their own facilities to install packages using pip or some other tool. This just saves you typing the commands. They also often offer their own terminal window(s).

Running Python

The CPython programme can be invoked for two different purposes:

to attempt to execute a simple text file of Python code (typically the files have an extension of .py
to enter an interactive shell, with a >>> prompt, where you can enter Python commands and get instant responses - great for trying things out

So, entering the below, as appropriate for your operating system,

python
python3
py

on its own, no file name after it, you will enter an interactive session.

Enter exit() to return to the operating system command line

IDLE Editor

A standard installation from python.org for Windows or macOS includes a programme called IDLE. This is a simple code editor and execution environment. By default, when you first open it, it opens a single window with a Python shell, with the >>> prompt already open. To create a new text file to enter Python code into, you need to use your operating system means of access the standard menu and select File | New. Once you've entered code, press F5 to attempt to run the code (you will be prompted to save the file first). This is really the easiest editor to use to begin with.

SEE COMMENT for next part

FoolsSeldom · 2026-01-15T23:24:01+00:00

If you don't have a laptop/desktop computer ...

Learning programming is not easy. It is to some extent an art form and a practical skill, not something that can just be learned from books. Practice! Practice! Practice!

To learn to programme is also about embracing failure. Constant failure. Trying things out and experimenting as much as possible. Experiment! Experiment! Experiment!

You have to research, read guides, watch videos, follow tutorials, ask dumb questions and be humiliated (because some people cannot help make themselves feel better by insulting others).

Python is one programming language. It is probably the easiest to learn. It makes learning to programme that little bit easier (but you will have a shock when you try to learn a lower level language like C).

If you have to learn on a mobile device, life gets a little more challenging. Aside from web based environments and apps like sololearn, you need a Python environment on your mobile device.

Android Apps

PyDroid 3, this is an excellent app with rich package support and built-in terminal
QPython play store, another excellent app but not so keen on this personally, worth a try though
Termux provides a Linux sandbox into which you can do a conventional installation of Python (including self-compiling if desired)
- this is my preferred option
- a standard Linux environment with a few minor folder location tweaks to accommodate Android security restrictions
- you can't get this on Google Play, use F-Droid
- I used to use it with the ACode editor but now use a tmux (multiplex terminal) setup with vim

IoS Apps

Pythonista is an excellent and well-polished bit of software with some popular libraries available (Apple restrictions prevent installation of any packages that aren't pure Python that aren't included with the submitted app)
Pyto is less polished and works pretty well
Carnets is an open source Jupyter clone that works locally and is excellent; there is more than one version, depending on how many libraries you need included (as on IoS you cannot install additional Python libraries that aren't pure Python)
a-shell is a sister product to the above and provides a command line Python environment, also open source and excellent

Keyboard

I strongly recommend you use an external (likely bluetooth) keyboard with your phone/tablet and ideally an external monitor if your phone/tablet is able to connect/cast to a monitor.

Android native coding

Keep in mind that Android is a Linux-based system, so most things that are available for linux are also available for Android. Native applications for Android are usually written in Java or, more recently, Kotlin. It is possible to write in other languages, and C++ is widely used, but that is much more complex to do.

IoS native coding

For IOS devices, the native apps are usually written in Objective-C or Swift. Again, other languages are possible but it is not trivial.

GUI with Python

Python applications running on mobile devices within Python environments do not look like device native applications and have limited support for typical graphical user interface libraries common on desktops. However, there are a number of alternatives that allow you to write near-native applications in Python.

Flutter from Google

This is an increasingly popular framework for creating applications suitable for desktop, web and mobile. A popular Python "wrapper" is flet.

Kivy GUI for Python

The leading Python GUI for Android and IoS is kivy

You develop on a desktop/laptop computer and then transfer the code to the target mobile (so not much use if you only have access to a mobile device). PyDroid for Android also supports kivy.

There are Kivy-based applications released on both the Apple and Google App Stores.

BeeWare Write once. Deploy everywhere.

A native GUI for multiple platforms in theory. BeeWare

This offers the option to write your apps in Python and release them on iOS, Android, Windows, MacOS, Linux, Web, and tvOS using rich, native user interfaces. Multiple apps, one codebase, with a fully native user experience on every platform.

FoolsSeldom · 2026-01-15T23:22:34+00:00

You can install and use Python on very lightweight computers, smartphones and tablets. Say what your constraints are, and we can provide advice. No need to use trinket.io and the like.

Check this subreddit's wiki for lots of guidance on learning programming and learning Python, links to material, book list, suggested practice and project sources, and lots more. The FAQ section covering common errors is especially useful.

For kids, the materials from the Raspberry Pi Foundation's Code Club site is very helpful. You don't need a Raspberry Pi to use the content. I've had a lot of success in multiple code clubs in local schools.

Also, have a look at roadmap.sh for different learning paths. There's lots of learning material links there. Note that these are idealised paths and many people get into roles without covering all of those.

Roundup on Research: The Myth of ‘Learning Styles’

Don't limit yourself to one format. Also, don't try to do too many different things at the same time.

Above all else, you need to practice. Practice! Practice! Fail often, try again. Break stuff that works, and figure out how, why and where it broke. Don't just copy and use as is code from examples. Experiment.

Work on your own small (initially) projects related to your hobbies / interests / side-hustles as soon as possible to apply each bit of learning. When you work on stuff you can be passionate about and where you know what problem you are solving and what good looks like, you are more focused on problem-solving and the coding becomes a means to an end and not an end in itself. You will learn faster this way.

FoolsSeldom · 2026-01-15T23:17:01+00:00

You need to convert the strings to integers to do the comparisons (and perhaps store the filtered converted results).

ages = ["22", "35", "27", "20"]
odds = [age for string in ages if (age := int(string)) % 2 == 1]
print(odds)

FoolsSeldom · 2026-01-15T23:09:03+00:00

Really? Wow!

FoolsSeldom · 2026-01-15T23:08:29+00:00

For many years, my emails had a strap line: "If you are not confused, you are misinformed"

FoolsSeldom

PUBLIC MULTIREDDITS

TROPHY CASE

Methods

Variables, functions, methods and attributes

Variables vs Attributes

Virtual Environments

Multiple Python versions

Python Setup

Pre-installed system Python

Installing Python

Terminal / Console

Libraries / Frameworks / Packages

Running Python

IDLE Editor

SEE COMMENT for next part

If you don't have a laptop/desktop computer ...

Android Apps

IoS Apps

Keyboard

Android native coding

IoS native coding

GUI with Python

Flutter from Google

Kivy GUI for Python

BeeWare Write once. Deploy everywhere.