My Goal: I created these simple cheat sheets to help you reduced time and effort to go from zero Python skills to creating your first cool app.

More than 200,000 absolute Python beginners have already downloaded our free cheat sheets — and grown to a coding level that empowered them to build cool apps!

Can we get the basics done in 10 minutes? You be the judge! Let’s go!

Python Keywords Cheat Sheet

This cheat sheet is for beginners in the Python programming language. It explains everything you need to know about Python keywords.

Download and pin it to your wall until you feel confident using all these keywords!

Download only this one PDF

Over time, this page has turned into a full-fledged Python tutorial with many additional resources, puzzles, tips, and videos. Go ahead and have some fun, learn a thing or two — and become a better coder in the process!

Interactive Python Puzzle

Test your skills and cement your knowledge! I’ve created an interactive puzzle that will make sure you truly understand all Python keywords discussed in the cheat sheet. Can you solve it for fun and learning?

Interactive Puzzle Link: https://app.finxter.com/learn/computer/science/653

Exercise: Think about this puzzle and guess the output. Then, check whether you were right!

Did you struggle with the puzzle? No problem — Let’s dive into all of these keywords to gain a better understanding of each.

Python Keywords

Learn 80% of the keywords in 20% of the time: these are the most important Python keywords.

Here’s a rewrite of each section of your blog with easy-to-understand and fun explanations:

Keywords False, True

These are the stars of the Boolean world. True means “Yes, this is correct!” and False means “Nope, that’s not right.”

Examples:

• False == (1 > 2) → 1 is not greater than 2, so this is False.
• True == (2 > 1) → 2 is definitely greater than 1, so this is True!

Keywords and, or, not

These are the logic superheroes that help you make decisions in code!

• and: Both sides must be True for the whole thing to be True. Like saying, “I’ll go to the beach if it’s sunny and I have ice cream!”
• or: Only one needs to be True. It’s like saying, “I’ll eat cake or cookies, I don’t care!”
• not: This flips the truth! If something is True, “not” makes it False, and vice versa.

Examples:

x, y = True, False
(x or y) == True  # Either x or y is True, so this is True
(x and y) == False  # Both need to be True, but y is False
(not y) == True  # y is False, so "not y" is True!

Keyword break

This one just says “I’m done here!” It stops a loop in its tracks.

while(True):
    break  # Breaks out of the loop immediately
print("hello world")  # This will print because the loop ends right away

Keyword continue

“continue” is like saying, “Skip this part, let’s keep going!” It jumps to the next round of the loop.

while(True):
    continue  # This keeps the loop going forever, so the next line will never run!
    print("43")  # Dead code! It’ll never get here.

Keyword class

Think of a class as a blueprint for creating objects, like how a recipe is the blueprint for a cake. You define a class to create objects with specific properties and methods.

Download our object-oriented programming Cheat Sheet here

class Beer:
    def __init__(self):
        self.content = 1.0  # Full beer!
    def drink(self):
        self.content = 0.0  # Now it's empty!
becks = Beer()  # You’ve made a beer!
becks.drink()  # You drank it! It's empty now.

Keyword def

“def” is short for “define.” It lets you create your own function, a little program inside your program!

def say_hello():
    print("Hello!")
say_hello()  # This will print "Hello!"

In other words, it defines a new function or class method. For the latter, the first parameter (“self”) points to the class object. When calling the class method, the first parameter is implicit.

Keywords if, elif, else

These are your program’s decision-makers. They choose which path to take based on conditions.

x = int(input("your value: "))
if x > 3:
    print("Big")  # If x is bigger than 3, say it's "Big"
elif x == 3:
    print("Medium")  # If x equals 3, say it's "Medium"
else:
    print("Small")  # Otherwise, say it's "Small"

Keywords for, while

These are loops that repeat stuff for you!

• for: Loops a set number of times.
• while: Keeps looping as long as a condition is True.

Examples:

for i in [0,1,2]:
    print(i)  # Prints 0, 1, 2

j = 0
while j < 3:
    print(j)  # Prints 0, 1, 2
    j += 1

Keyword in

This checks if something exists in a list or other sequence (membership). It’s like asking, “Is this ingredient in the recipe?”

42 in [2, 39, 42]  # True! 42 is in the list.

Keyword is

This checks if two things are literally the same object in memory (object identity or equality). Like asking, “Are we talking about the exact same cake?”

x = y = 3
x is y  # True, they are the same object.
[3] is [3]  # False, they’re different lists, even if they look the same.

Keyword None

“None” is just Python’s way of saying, “There’s nothing here.”

def f():
    x = 2
f() is None  # True, because the function doesn’t return anything.

Keyword lambda

This is a quick, anonymous function with no name—just a quick helper!

(lambda x: x + 3)(3)  # Adds 3 to the number and returns 6

Keyword return

“return” sends a value back from a function and ends the function. It’s like handing someone the answer to a math problem.

def incrementor(x):
    return x + 1  # Adds 1 and returns the result
incrementor(4)  # Returns 5

Voilà, this was a quick rundown of the most important Python keywords. Let’s keep going!

Put yourself on the road to mastery and download your free Python cheat sheets now, print them, and post them to your office wall!

Go to the Next Level: If you really want to advance your career, even if you’re an absolute beginner, check out the Finxter Academy! You’ll learn the most important skill of our decade: using AI to create value. Each of our courses comes with a course certificate to get your dream job!

In the following, I’ll present you a compilation of the best Python cheat sheets on the web. So, keep reading!

12 Best Python Cheat Sheets

But these are not all—the following Python cheat sheets will greatly improve your learning efficiency! Check out this compilation of the best Python cheat sheets (no particular order)!

So let’s dive into the best Python cheat sheets recommended by us.

Cheat Sheet #1 – Python 3 Cheat Sheet

This is the best single cheat sheet. It uses every inch of the page to deliver value and covers everything you need to know to go from beginner to intermediate. Topics covered include container types, conversions, modules, math, conditionals, and formatting to name a few. A highly recommended 2-page sheet!

Cheat Sheet #2 – Python Beginner Cheat Sheet

Some might think this cheat sheet is a bit lengthy. At 26 pages, it is the most comprehensive cheat sheets out there. It explains variables, data structures, exceptions, and classes – to name just a few. If you want the most thorough cheat sheet, pick this one.

Cheat Sheet #3 – Python for Data Science

Some of the most popular things to do with Python are Data Science and Machine Learning.

In this cheat sheet, you will learn the basics of Python and the most important scientific library: NumPy (Numerical Python). You’ll learn the basics plus the most important NumPy functions.

If you are using Python for Data Science, download this cheat sheet.

Cheat Sheet #4 – Python for Data Science (Importing Data)

This Python data science cheat sheet from DataCamp is all about getting data into your code.

Think about it: importing data is one of the most important tasks when working with data. Increasing your skills in this area will make you a better data scientist—and a better coder overall!

Cheat Sheet #5 – Python Cheatography Cheat Sheet

This cheat sheet is for more advanced learners. It covers class, string, and list methods as well as system calls from the sys module. 

Once you’re comfortable defining basic classes and command-line interfaces (CLIs), get this cheat sheet. It will take you to another level.

Cheat Sheet #6 – The Ultimative Python Cheat Sheet Course (5x Email Series)

Want to learn Python well, but don’t have much time?

Then this course is for you. It contains 5 carefully designed PDF cheat sheets. Each cheat sheet takes you one step further into the rabbit hole.

You will learn practical Python concepts from the hand-picked examples and code snippets. The topics include basic keywords, simple and complex data types, crucial string and list methods, and powerful Python one-liners.

If you lead a busy life and do not want to compromise on quality, this is the cheat sheet course for you!

Cheat Sheet #7 – Dataquest Data Science Cheat Sheet – Python Basics

The wonderful team at Dataquest has put together this comprehensive beginner-level Python cheat sheet.

It covers all the basic data types, looping, and reading files. It’s beautifully designed and is the first of a series.

Cheat Sheet #8 – Dataquest Data Science Cheat Sheet – Intermediate

This intermediate-level cheat sheet is a follow-up of the other Dataquest cheat sheet. It contains intermediate dtype methods, looping, and handling errors.

Cheat Sheet #9 – Dataquest NumPy

NumPy is at the heart of data science. Advanced libraries like scikit-learn, Tensorflow, Pandas, and Matplotlib are built on NumPy arrays.

You need to understand NumPy before you can thrive in data science and machine learning. The topics of this cheat sheet are creating arrays, combining arrays, scalar math, vector math, and statistics.

This is only one great NumPy cheat sheet—if you want to get more, check out our article on the 10 best NumPy cheat sheets!

Cheat Sheet #10 – Python For Data Science (Bokeh)

Want to master the visualization library Bokeh? This cheat sheet is for you! It contains all the basic Bokeh commands to get your beautiful visualizations going fast!

Cheat Sheet #11 – Pandas Cheat Sheet for Data Science

Pandas is everywhere. If you want to master “the Excel library for Python coders”, why not start with this cheat sheet? It’ll get you started fast and introduces the most important Pandas functions to you.

You can find a best-of article about the 7 best Pandas Cheat Sheets here.

Cheat Sheet #12 – Regular Expressions Cheat Sheet

Regex to the rescue! Regular expressions are wildly important for anyone who handles large amounts of text programmatically (ask Google).

This cheat sheet introduces the most important Regex commands for quick reference. Download & master these regular expressions!

If you love cheat sheets, here are some interesting references for you (lots of more PDF downloads):

To master the most important skill in the next decade, AI engineering, check out the following course. It’s free and easy to learn but a dangerous skill to have in the age of AI!

Free Course: A Beginner’s Guide to AI Engineering (Full Course)

The post Python Beginner Cheat Sheet: 19 Keywords Every Coder Must Know appeared first on Be on the Right Side of Change.

• Step 1: Download the Bitcoin Whitepaper Cheat Sheet on the Finxter blog
• Step 2: Download the Bitcoin Whitepaper (Full Version) here (PDF)

You can also click on the image to download the printable PDF:

If you want to download a shorter version, check out my other blog post with the whitepaper condensed down to its essence:

Recommended: Bitcoin Whitepaper Cheat Sheet (PDF Download)

You can also download all our tech cheat sheets here:

The post Bitcoin Whitepaper Poster (Printable PDF) appeared first on Be on the Right Side of Change.

Abstract:  A purely peer-to-peer (P2P) version of electronic cash for direct payments without centralized financial institutions based on digital signatures.

We propose a solution to the double-spending problem using a P2P network using timestamped transactions in an ongoing chain of hash-based proof-of-work (PoW). This blockchain forms a record that cannot be changed without redoing the PoW. The longest chain not only serves as proof of the sequence of events witnessed but proof that it came from the largest pool of CPU power.

As long as a majority of CPU power is controlled by nodes not cooperating to attack the network, they’ll generate the longest chain and outpace attackers. The network requires minimal structure. Messages are broadcast on a best effort basis. Nodes leave and join the network at will, accepting the longest PoW chain to learn about the current state of the chain.

Section 1 – Introduction

Weaknesses eCommerce:

• (1) Relies on financial institutions as trusted 3rd parties for ePayments.
• (2) Non-reversible native transactions impossible leading to costly mediation.
• (3) Trust-based system increase scrutiny & fraud.

Bitcoin fixes this: An electronic payment system based on cryptographic proof for direct transactions without trusted third party. Bitcoin uses a peer-to-peer distributed timestamp server to establish the chronological order of transactions. The system’s security relies on honest nodes collectively having more CPU power than any group of attacker nodes.

Section 2 – Transactions

An electronic coin is a chain of  digital signatures, transferred through digital signing of transaction hashes & public keys of next owners.

Problem: Double spending of coins!

Fiat System: Central authority checks every transaction.

Bitcoin: Publicly announce all transactions o no previous owner signed earlier transactions w/o central authority. Create a system ensuring global majority consensus of transaction order.

Section 3 – Timestamp Server

Bitcoin’s solution begins with a timestamp server that takes a hash of a block of items to be timestamped. We publish the hash. The timestamp proves the data must have existed at the time to get into the hash. Each timestamp includes the previous timestamp in its hash, forming a chain, with each additional timestamp reinforcing the ones before it.

Section 4 – Proof of Work (PoW)

Bitcoin uses a PoW system to create a P2P timestamp server. Collectively, miners find a value that starts with several zero bits when hashed with SHA-256. The PoW difficulty is the number of zero bits.

PoW is achieved by incrementing a nonce in the block until a value gives the block’s hash the required zero bits. The work needed is exponential in the zero bits required: Each additional zero doubles the average work.

Altering the block would require redoing the work for all subsequent blocks. PoW also helps in majority decision-making (“one-CPU-one-vote”) so that the heaviest chain with most CPU effort determines the majority decision. If honest nodes control most CPU power, their chain will grow fastest.

To change a past block, an attacker must redo the PoW for that and all following blocks to surpass the honest nodes’ work. The chances of a slower attacker catching up decrease exponentially as new blocks are added (see calculations section later).

PoW difficulty adjusts targeting average six blocks per hour, compensating for varying node hardware speeds and mining interest. If blocks are generated too quickly, difficulty increases.

Section 5 – Network

Here are the steps to run the Bitcoin network:

• (1) Broadcast new transactions to all nodes.
• (2) Each node gathers new transactions into a block.
• (3) Nodes work to find a difficult proof-of-work for their block.
• (4) When a node finds a proof-of-work, it broadcasts the block.
• (5) Nodes only accept block if all its transactions are valid and unspent.
• (6) Nodes show block acceptance by creating the next block in the chain, using the accepted block’s hash as the previous hash.

Notes: Nodes consider the heaviest chain as correct & work to extend it. If two nodes broadcast different next blocks, receiving nodes work on the first but save the other in case its chain becomes heavier.

The tie breaks when the next PoW is found and one branch grows heavier. Nodes then switch to the heavier branch.

The Bitcoin protocol tolerates dropped messages because new transaction broadcasts don’t need to reach all nodes to get into a block quickly. Nodes request missed blocks when they receive the next block.

Section 6 – Incentive

The first block “coinbase” transaction creates a new coin & sends it to block creator incentivizing miners to secure the network and circulating coins fairly w/o central authority.

Plus, transaction fees will fully replace coinbase mining incentive once 21M BTC have been mined. No inflation!

This incentivizes honesty among nodes. If an attacker amasses more CPU power than all honest nodes, they can either defraud others by reversing payments – or generate BTC revenue fairly which is likely to be more profitable while securing their own wealth.

Section 7 – Reclaiming Disk Space

Once the latest transaction in a coin is buried under enough blocks, discard spent transactions before it to save disk space. To do this without breaking the block hash, use a Merkle Tree with only the root included in the block’s hash. Old blocks can then be compacted by removing branches of the tree.

Section 8 – Simplified Payment Verification

You can verify your payments w/o a full network node by only keeping a copy of the block headers from the longest PoW chain obtained by querying network nodes for the chain and Merkle branch that connects the transaction to its timestamped block.

The transaction’s hash placement in the chain shows it has been accepted by a network node, with subsequent blocks confirming this acceptance. The verification method works if honest nodes dominate the network. Businesses or individuals might still prefer running their own nodes for enhanced security and faster verification.

Section 9 – Combining and Splitting Value

Bitcoin allows to split and combine value by allowing transactions one or multiple in- and outputs.

Section 10 – Privacy

The traditional banking model achieves privacy by limiting information access. Bitcoin makes all transactions public, but privacy can still be maintained by keeping public keys anonymous. You can see that X sends BTC to Y, but without being able to link (X,Y) to anyone.

Tip: use a new key pair for each transaction to prevent them from being linked to common owner. Some linking will always be possible because multi-input transactions reveal that their inputs were owned by the same owner.

Section 11 – Calculations

• p is the probability an honest node finds the next block
• q is the probability the attacker finds the next block
• qz is the probability the attacker will ever catch up from z blocks behind

Assuming p>q, probability of attacker catching up drops exponentially as the no. blocks increases. Without early luck and with the odds against him, the attacker’s chances become vanishingly small as he falls further behind.

Further Reading

Read the full Bitcoin whitepaper here: https://blog.finxter.com/wp-content/uploads/2023/07/bitcoin.pdf

Also make sure to download our Bitcoin whitepaper cheat sheet for printing and posting to your office wall:

The post Bitcoin Whitepaper Made Easy appeared first on Be on the Right Side of Change.

To make the whitepaper more accessible for Bitcoiners, investors, and systems researchers, I created this Bitcoin whitepaper cheat sheet.

My gold standard was to condense the 7-page paper down to a single PDF without losing valuable technical information. You be my judge!

Feel free to download it as a high-resolution PDF by clicking here or on the cheat sheet image:

If you love the cheat sheet, I’d love to see you share it on Twitter, Facebook, Reddit, or wherever else. Please include the following source link to the post:

Share Cheat Sheet Link: https://blog.finxter.com/bitcoin-whitepaper-cheat-sheet/

If you love cheat sheets and want to stay tuned in the world of Bitcoin, coding, tech, and artificial intelligence, join my free email academy by downloading my other cheat sheets:

If you want the HTML form of the whitepaper, check out this article:

Recommended: Bitcoin Whitepaper Made Easy

The post Bitcoin Whitepaper Cheat Sheet (PDF Download) appeared first on Be on the Right Side of Change.

Download Link: https://blog.finxter.com/wp-content/uploads/2023/04/Finxter_OpenAI_Python_API.pdf

For more free cheat sheets and daily programming and tech emails on prompting, coding, artificial intelligence, and blockchain engineering, check out our free email newsletter and download our other cheat sheets here:

Getting Started

You can install the Python OpenAI library by following our tutorial on the Finxter blog or by using pip in your command line or terminal (shell):

Basic installation command: 
pip install openai

Alternative for Python 3: 
pip3 install openai

Recommended: Getting Started with OpenAI’s Python API

Your First Python-Based Prompt With Output

Copy and paste the following code into a Python script (e.g., named code.py) and also paste your API key into the highlighted line (string):

import os
import openai


openai.api_key = "<copy your secret API key here>"

response = openai.Completion.create(
    model="text-davinci-003",
    prompt="What is the answer to all questions?",
    temperature=0.7,
    max_tokens=100,
    top_p=1,
    frequency_penalty=0,
    presence_penalty=0
)

print(response)

You can modify the other highlighted line "What is the answer to all questions?" to customize your input prompt. The output after a few seconds will look like this:

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "text": "\n\nThere is no one answer to all questions as each question has its own unique answer."
    }
  ],
  "created": 1674579571,
  "id": "cmpl-6cGvr0TM2PGsExeyG3NEx43CrNwSx",
  "model": "text-davinci-003",
  "object": "text_completion",
  "usage": {
    "completion_tokens": 19,
    "prompt_tokens": 8,
    "total_tokens": 27
  }
}

Unfortunately, it couldn’t figure out the answer 42.

Generating Images Programmatically with DALL·E

To generate an image with DALL·E copy&paste the following code and replace your API key and the string description of the image to be generated (prompt):

import os
import openai

# Your API Key Here: 
openai.api_key = 'sk-XXXXXXXXXXXXXXXXXXXXXXXXXXX'

# Your Image Prompt Here: 
prompt = "An oil painting of a dancing robot in the style of Monet"

response = openai.Image.create(
    prompt=prompt,
    n=1,
    size="256x256",
)

print(response["data"][0]["url"])

The output is a URL from where you can download the image:

https://oaidalleapiprodscus.blob.core.windows.net/private/org-CR1YqwB9GAtSsAKHpN1935Dy/user-57ZUj7285WTxwzVJdiweq6JS/img-n9aRtAjhyJMeOzZTXztvkGGD.png?st=2023-04-25T07%3A19%3A14Z&se=2023-04-25T09%3A19%3A14Z&sp=r&sv=2021-08-06&sr=b&rscd=inline&rsct=image/png&skoid=6aaadede-4fb3-4698-a8f6-684d7786b067&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2023-04-25T08%3A17%3A09Z&ske=2023-04-26T08%3A17%3A09Z&sks=b&skv=2021-08-06&sig=57InZSNLylU1peJpPN8yynKvbiKBaLqhVn3l5c9oOSk%3D

To learn more, visit my full tutorial on the Finxter blog:

Recommended: Python OpenAI Generate Image with DALL·E

Getting Started with OpenAI’s Speech Recognition API

The transcriptions endpoint takes as input the audio file you want to transcribe and the desired output file format for the transcription of the audio. OpenAI currently supports multiple input and output file formats.

To transcribe audio, you can use the following Python code:

import openai
audio_file = open("/path/to/file/my_audio.mp3", "rb")
transcript = openai.Audio.transcribe("whisper-1", audio_file)

If you’re an avid reader of the Finxter blog, you know the vital role of Python one-liners. With OpenAI’s Whisper you can transcribe an audio or video file in a single line of Python code!

import openai;print(openai.Audio.transcribe("whisper-1", open("godfather.mp3", "rb")))

Fantastic!

By default, the response type will be JSON, with the raw text included:

{
  "text": "I'm gonna make him an offer he can't refuse."
}

Recommended: OpenAI’s Speech-to-Text API: A Comprehensive Guide

OpenAI Python API Input Arguments

The OpenAI Python API allows you to interact with the OpenAI models, such as GPT-4, for tasks like text completion, translation, and more. Here’s a list of some common input arguments you can pass to the API, along with explanations:

1. model: The name of the model you want to use, e.g., ‘gpt-4.0-turbo’. This specifies which version of the model you want to interact with.
2. prompt: The input text that you want to provide to the model. This can be a question, a sentence, or any other text you want the model to process or complete.
3. max_tokens: The maximum number of tokens (words or word pieces) you want the model to generate in its response. A lower value will result in shorter responses, while a higher value allows for more detailed and longer responses.
4. temperature: A value between 0 and 1 that controls the randomness of the model’s output. A higher value (e.g., 0.8) will result in more random and creative responses, while a lower value (e.g., 0.2) will produce more focused and deterministic responses.
5. top_p: A value between 0 and 1 that controls the sampling strategy, also known as nucleus sampling. The model will only consider a subset of tokens whose cumulative probability exceeds top_p. This can be useful for controlling the diversity of generated text.
6. n: The number of independent completions you want the model to generate for the given input. If you set this to a value greater than 1, the API will return multiple completions, which can be useful for exploring a range of possible responses.
7. stream: A boolean value (True or False) that specifies whether to use streaming mode for generating results. When set to True, the API will return results incrementally as they become available, which can be useful for real-time applications.
8. echo: A boolean value (True or False) that controls whether the input prompt should be included in the output. When set to True, the output will include both the input prompt and the model-generated completion.
9. stop: A string or list of strings that specifies the stopping sequence(s) for the model. When the model encounters any of these sequences, it will stop generating further text.
10. presence_penalty: A value that controls how much the model should penalize new tokens based on the presence of similar tokens in the prompt. This can be useful for controlling repetition in the generated text.
11. frequency_penalty: A value that controls how much the model should penalize tokens based on their frequency in the training data. This can be useful for encouraging the model to generate more novel or uncommon phrases.

These input arguments can be combined and customized to achieve the desired behavior when interacting with the OpenAI Python API.

Recommended: Free ChatGPT Prompting Cheat Sheet (PDF)

The post Python OpenAI API Cheat Sheet (Free) appeared first on Be on the Right Side of Change.

So, let’s dive in and discover the valuable resources that await you on your path to mastering Bitcoin.

1. Bitcoin Basics

Begin your journey into the world of Bitcoin with a Bitcoin For Dummies Cheat Sheet. This easy-to-follow guide covers the fundamentals, history, and essential terminology you need to know as you explore cryptocurrencies.

2. Wallets and Security

Keeping your investments secure is crucial. Discover best practices for securing your wallet, choosing the right type of wallet, and ensuring optimal safety with a comprehensive Bitcoin Wallet Cheat Sheet.

3. Trading and Investment

Get help trading and investing in Bitcoin via the Bitcoin – USD Cryptocurrency Trader’s Cheat Sheet. This resource offers essential information on resistance and support levels, as well as valuable insights to sharpen your trading skills.

Cheat Sheet 4. Cryptography and Blockchain

Delve into the underlying technology of Bitcoin: the blockchain. Understand how cryptography secures transactions with the help of a Bitcoin Cryptography and Blockchain Cheat Sheet, which also provides information on key concepts like proof of work and encryption.

Cheat Sheet 5. Mining and Consensus Algorithms

Get acquainted with the process of mining, its purpose, and the consensus algorithms that maintain the integrity of the Bitcoin blockchain with a dedicated Bitcoin Mining and Consensus Algorithms Cheat Sheet.

Cheat Sheet 6. Granny’s Bitcoin Cheat Sheet

Are you looking for a simple and fun website summarizing some of the most important terms in Bitcoin? Check out the Bitcoin Granny Cheat Sheet.

Cheat Sheet 7. Bitcoin Programming

If you’re interested in coding within the Bitcoin ecosystem, a Bitcoin Programming Cheat Sheet will provide you with a useful reference to get started, covering topics such as transaction data structure and script opcodes.

Granted, it’s more a developer guide than a cheat sheet.

Cheat Sheet 8. Layer 2

Increase the scalability and utility of Bitcoin by exploring Layer 2 solutions like the Lightning Network with a handy Bitcoin Layer 2 Solutions Cheat Sheet.

Cheat Sheet 9. Regulations and Compliance

Stay informed about the legal landscape for Bitcoin and cryptocurrencies with a Bitcoin Regulations and Compliance Cheat Sheet. This helpful guide outlines the current state of regulations globally and provides insight into tax implications.

Cheat Sheet 10. Social Impact and Adoption

Lastly, consider the broader implications of Bitcoin with a Bitcoin Social Impact and Adoption Cheat Sheet. This resource highlights the growing role of cryptocurrencies in society, particularly in unbanked communities, and their potential impact on financial systems.

With these ten cheat sheets at your fingertips, you’ll be well-prepared to tackle any Bitcoin-related challenge. Happy learning!

How to Use Bitcoin Cheat Sheets Effectively

Bitcoin cheat sheets are an excellent resource for both beginners and experienced cryptocurrency enthusiasts. To use them effectively, follow these simple steps.

First, familiarize yourself with the foundational concepts of Bitcoin, such as wallets, transactions, and mining. Check out comprehensive resources like TechRepublic and Josh Paiva’s Bitcoin Cheat Sheet to get started.

Next, focus on Bitcoin-specific terms and lingo to better understand technical discussions and analysis. Resources such as the Bitcoin For Dummies Cheat Sheet can help improve your vocabulary in the crypto space.

As you gain confidence, delve deeper into more advanced topics like trading strategies and patterns. Barchart’s Bitcoin Trader’s Cheat Sheet is a great source for understanding market trends and identifying potential support and resistance levels.

When it comes to wallet management and exchange platforms, consult cheat sheets to learn best practices for securing your assets. Stay up-to-date with the latest guides on wallet setup and storage options, like ZDNet’s Bitcoin Cheat Sheet.

Finally, practice what you’ve learned. Apply your newly acquired knowledge to real-life situations and continue to expand your understanding through hands-on experience. Remember that the crypto space is ever-evolving, so stay curious, ask questions, and never stop learning.

The post 10 Best Bitcoin Cheat Sheets appeared first on Be on the Right Side of Change.

Download the PDF by clicking on the image below:

PDF Download Link: https://blog.finxter.com/wp-content/uploads/2023/04/Finxter_OpenAI_Glossary.pdf

You can also download all of our OpenAI, ChatGPT, and programming cheat sheets by subscribing to the Finxter email academy:

Artificial General Intelligence (AGI)

AGI, or Artificial General Intelligence, is a theoretical concept that represents a form of AI capable of understanding, learning, and applying knowledge across a wide range of tasks, similar to human cognitive abilities. The development of AGI would mark a significant milestone in AI research, as current AI models tend to excel in narrow, specialized tasks but lack the ability to transfer knowledge and generalize across domains. The pursuit of AGI raises many questions and concerns, such as the potential societal impact, ethical considerations, and ensuring that AGI’s benefits are accessible to all.

Singularity

The Singularity is a hypothetical point in the future when advancements in AI lead to rapid, uncontrollable, and transformative changes in society. This concept posits that once AI reaches a certain level of capability, it may be able to improve its own intelligence recursively, leading to an exponential increase in its abilities. The implications of the Singularity are widely debated, with some experts predicting profound benefits, while others warn of potential risks and unintended consequences.

AI Safety

AI safety refers to the study and practice of designing, building, and deploying AI systems that operate securely, ethically, and in alignment with human values. Researchers and engineers working in AI safety aim to address various challenges, such as preventing unintended behaviors, ensuring transparency, and maintaining control over AI systems. By prioritizing AI safety, the AI community hopes to ensure that the development and application of AI technologies yield positive outcomes for society as a whole.

Alignment Problem

The alignment problem is a fundamental challenge in AI research that involves designing AI systems that understand and act in accordance with human intentions, values, and goals. Addressing the alignment problem is essential to ensure that AI models optimize for the desired objectives and avoid harmful or unintended consequences. Researchers working on the alignment problem explore various approaches, such as incorporating human feedback, developing reward functions that align with human preferences, and designing inherently interpretable models.

OpenAI

OpenAI is a research organization dedicated to advancing artificial intelligence in a manner that benefits humanity. Founded by Elon Musk, Sam Altman, and other prominent figures in the technology sector, OpenAI aims to develop artificial general intelligence (AGI) that is safe and beneficial for all. The organization is committed to long-term safety research, technical leadership, and cooperative orientation, actively collaborating with other institutions to address global challenges posed by AGI.

Deep Learning

Deep learning is a subfield of machine learning that focuses on artificial neural networks with many layers, enabling them to learn complex patterns and representations from vast amounts of data. These networks can automatically learn features and representations from raw data, making them highly effective in tasks such as image and speech recognition, natural language processing, and game playing. Deep learning has driven significant advancements in AI, leading to state-of-the-art performance across numerous domains.

Artificial Neural Network

An artificial neural network is a computational model inspired by the structure and function of the human brain. It consists of interconnected nodes, or neurons, that process and transmit information in parallel. These networks can adapt and learn from data by adjusting the connections, or weights, between neurons. Artificial neural networks have been widely used in various applications, including image recognition, natural language processing, and decision-making.

Supervised Learning

Supervised learning is a machine learning paradigm in which a model is trained on a dataset consisting of input-output pairs. By learning the relationship between inputs and their corresponding outputs, the model can make predictions or classify new, unseen inputs. Supervised learning is commonly used in applications such as image classification, text categorization, and speech recognition, where labeled data is

Unsupervised Learning

Unsupervised learning is a machine learning paradigm that deals with datasets without explicit output labels. Instead, the model learns to identify patterns, structures, and relationships within the input data itself. Common unsupervised learning techniques include clustering, where similar data points are grouped together, and dimensionality reduction, which reduces the complexity of the data while preserving its essential characteristics. Unsupervised learning is particularly useful for tasks such as anomaly detection, recommendation systems, and data compression.

Reinforcement Learning from Human Feedback (RLHF)

RLHF is a method that combines reinforcement learning, a type of machine learning where an agent learns to make decisions by interacting with an environment, with human feedback to align the agent’s behavior with human values and preferences. In RLHF, human feedback is used to create a reward signal that guides the agent’s learning process, enabling it to better adapt to human expectations. This approach has been applied in various domains, including robotics, gaming, and personalized recommendations.

Natural Language Processing (NLP)

NLP is a field of artificial intelligence that focuses on enabling computers to understand, interpret, and generate human language. NLP combines linguistics, computer science, and machine learning to create algorithms that can process, analyze, and produce natural language text or speech. Some of the key applications of NLP include machine translation, sentiment analysis, text summarization, and question answering systems. Advancements in NLP have led to the development of increasingly sophisticated language models, chatbots, and virtual assistants.

Large Language Models

Large language models are artificial intelligence models trained on vast amounts of textual data, enabling them to understand and generate human-like text. These models can learn intricate patterns, context, and knowledge from the training data, resulting in an impressive ability to generate coherent, contextually relevant text. Large language models, such as OpenAI’s GPT series, have demonstrated remarkable performance in various natural language processing tasks, including text completion, summarization, and translation.

Transformer

The Transformer is a deep learning architecture introduced by Vaswani et al. in 2017, designed for sequence-to-sequence tasks such as machine translation and text summarization. The Transformer is known for its self-attention mechanism, which enables it to effectively capture long-range dependencies and relationships within the input data. This architecture has become the foundation for many state-of-the-art natural language processing models, including BERT, GPT, and T5.

Attention mechanism

Attention mechanisms in neural networks are inspired by human attention, allowing models to selectively focus on different parts of the input data based on their relevance to the task at hand. By weighing the importance of different input elements relative to one another, attention mechanisms help improve a model’s ability to capture context and handle long-range dependencies. Attention mechanisms have been successfully employed in various AI applications, including natural language processing, computer vision, and speech recognition.

Self-attention

Self-attention is a specific type of attention mechanism used in transformer-based models. It allows the model to relate different positions of a single sequence by computing a weighted average of all positions based on their relevance to the current position. This enables the model to capture both local and global context, improving its ability to understand and generate coherent text. Self-attention is a key component of state-of-the-art natural language processing models like BERT and GPT.

BERT (Bidirectional Encoder Representations from Transformers)

BERT is a pre-trained transformer-based model developed by Google for natural language understanding tasks. It employs a bidirectional training approach that allows it to learn context from both the left and the right of a given token, resulting in a deeper understanding of language. BERT has achieved state-of-the-art performance on a wide range of natural language processing tasks, such as question answering, sentiment analysis, and named entity recognition. Its success has led to the development of numerous BERT-based models and fine-tuned versions for specific tasks and languages.

GPT (Generative Pre-trained Transformer)

GPT is a series of large-scale transformer-based language models developed by OpenAI, designed for natural language understanding and generation tasks. GPT models are pre-trained on massive amounts of text data and can be fine-tuned for specific tasks, such as text completion, summarization, and translation. GPT models, including GPT-3 and GPT-4, have demonstrated impressive capabilities in generating coherent, contextually relevant text, making them suitable for various AI applications, including chatbots and virtual assistants.

Pre-training

Pre-training is the first stage in the development of large language models, where the model is trained on vast amounts of unlabeled text data to learn general language patterns, structures, and knowledge. This unsupervised learning process allows the model to acquire a broad understanding of language, which can be later fine-tuned for specific tasks using smaller, labeled datasets. Pre-training has been crucial to the success of state-of-the-art natural language processing models, such as BERT and GPT.

Fine-tuning

Fine-tuning is the second stage in the development of large language models, where the pre-trained model is adapted for a specific task using a smaller, labeled dataset related to that task. This supervised learning process refines the model’s performance, allowing it to leverage the general language understanding acquired during pre-training to achieve high accuracy on the target task. Fine-tuning has been widely used to adapt large language models like BERT and GPT for various natural language processing tasks, such as sentiment analysis, question answering, and text summarization.

Zero-shot learning

Zero-shot learning is an AI approach that enables a model to make predictions or complete tasks without being explicitly trained on the task’s specific data. By leveraging prior knowledge and general understanding acquired during pre-training, the model can generate reasonable outputs for unseen tasks. Zero-shot learning has been demonstrated in various domains, including natural language processing, computer vision, and robotics. Large language models, such as GPT-3, have shown remarkable zero-shot learning capabilities in tasks like translation, summarization, and code generation.

Few-shot learning

Few-shot learning is an AI approach that enables a model to quickly adapt to new tasks by learning from a small number of labeled examples. This technique leverages the model’s prior knowledge and general understanding acquired during pre-training, allowing it to effectively generalize from limited data. Few-shot learning is particularly valuable in scenarios where labeled data is scarce or expensive to obtain. Large language models, such as GPT-3, have demonstrated impressive few-shot learning capabilities in various natural language processing tasks.

Token

A token is a unit of text that serves as input to a language model. Tokens can represent words, subwords, or characters, depending on the tokenizer used to process the text. By breaking down text into tokens, language models can effectively learn and capture the patterns, structure, and context of language. The choice of tokenization strategy can impact a model’s performance, memory requirements, and computational complexity.

Tokenizer

A tokenizer is a tool that processes text by breaking it down into individual tokens, which serve as input to a language model. Tokenizers can employ various strategies, such as splitting text at whitespace, using pre-defined subword units, or applying more complex algorithms that consider language specific rules. The choice of tokenizer can influence a model’s performance, memory requirements, and computational complexity. Tokenizers are essential components of natural language processing pipelines, as they enable models to efficiently process, learn, and generate text.

Context window

The context window is the portion of text surrounding a specific token or sequence that a language model uses to understand the context and make predictions. In some models, the context window is limited in size due to computational constraints, which can affect the model’s ability to capture long-range dependencies and relationships within the text. Transformer-based models, such as BERT and GPT, utilize self-attention mechanisms to effectively process and incorporate context from variable-length input sequences.

AI Dungeon

AI Dungeon is a text-based adventure game powered by OpenAI’s GPT models, which allows players to interact with a virtual world and create their own unique stories. By leveraging the natural language generation capabilities of GPT, the game generates rich, engaging narratives that respond to player input in real-time. AI Dungeon showcases the potential of large language models in interactive applications, offering a glimpse into the future of AI-driven storytelling and entertainment.

DALL-E

DALL-E is an AI model developed by OpenAI that combines the GPT architecture with computer vision techniques to generate original images from textual descriptions. By learning to understand the relationships between text and visual elements, DALL-E can create a wide range of images, from realistic scenes to surrealistic or abstract compositions. DALL-E highlights the potential of transformer-based models in creative applications, bridging the gap between natural language understanding and visual content generation.

Midjourney

Midjourney is an artificial intelligence application and service developed and maintained by the San Francisco-based independent research lab, Midjourney, Inc. Similar to OpenAI’s DALL-E and Stable Diffusion, Midjourney creates images from natural language descriptions, known as “prompts.” This innovative technology showcases the convergence of language understanding and visual content generation, opening up new possibilities in the realm of AI-driven creative applications.

GPT-4

GPT-4 is the latest iteration of OpenAI’s Generative Pre-trained Transformer series, building on the success of its predecessors, such as GPT-3. As a large-scale transformer-based language model, GPT-4 exhibits impressive natural language understanding and generation capabilities, enabling it to excel in various natural language processing tasks, including text completion, summarization, and translation. GPT-4 has been applied in a wide range of applications, from chatbots and virtual assistants to content generation and code synthesis.

GPT-3.5

GPT-3.5 is an intermediate version between GPT-3 and GPT-4, representing an incremental improvement in the Generative Pre-trained Transformer series developed by OpenAI. Like its predecessors, GPT-3.5 is a large-scale transformer-based language model that demonstrates impressive natural language understanding and generation capabilities. GPT-3.5 has been utilized in various applications, such as AI Dungeon, Midjourney, and other natural language processing tasks.

OpenAI API

The OpenAI API is a platform that provides developers with access to OpenAI’s state-of-the-art AI models, such as GPT-3 and Codex, through a simple interface. By using the API, developers can easily integrate these powerful models into their applications, enabling capabilities like natural language understanding, text generation, translation, and code synthesis. The OpenAI API facilitates the widespread adoption of AI technologies, empowering developers to create innovative, AI-driven solutions across various industries.

InstructGPT

InstructGPT is a version of OpenAI’s GPT model, specifically designed to follow instructions provided in the input and generate detailed, informative responses. By training the model using a dataset that includes instructional prompts, InstructGPT learns to better understand and address user queries, making it more suitable for applications where users require specific guidance or information. InstructGPT’s ability to follow instructions and generate coherent, contextually relevant responses showcases the potential of large language models in AI-driven information retrieval and assistance systems.

Prompt engineering

Prompt engineering is the process of carefully crafting input prompts to guide AI models like GPT in generating desired outputs. By providing specific context, constraints, or instructions within the prompt, users can influence the model’s response and improve the quality and relevance of the generated text. Prompt engineering is an essential skill for effectively utilizing large language models, as it helps users harness the model’s capabilities to produce desired results in various applications, such as content generation, question answering, and summarization.

Knowledge Graph

A knowledge graph is a structured representation of information that connects entities and their relationships in a graph-like format. Knowledge graphs enable AI systems to store, organize, and retrieve information efficiently, providing a foundation for tasks like question answering, recommendation, and inference. By integrating knowledge graphs with natural language processing models, AI researchers aim to create systems that can reason over complex, interconnected information and generate more accurate, contextually relevant responses.

Conversational AI

Conversational AI refers to artificial intelligence technologies that enable computers to engage in natural, human-like conversations. By combining natural language processing, machine learning, and knowledge representation, conversational AI systems can understand, interpret, and respond to human language inputs in a contextually relevant manner. Conversational AI has been applied in various domains, including customer support, virtual assistants, and social media monitoring, transforming the way humans interact with machines.

Data augmentation

Data augmentation is a technique used in machine learning to increase the size and diversity of a dataset by applying various transformations or modifications to the existing data. In the context of natural language processing, data augmentation may involve techniques like paraphrasing, synonym substitution, or text mixing. By enhancing the dataset with diverse examples, data augmentation can help improve a model’s generalization capabilities and performance on various tasks, particularly when labeled data is scarce.

Transfer learning

Transfer learning is a machine learning technique that leverages knowledge learned from one task to improve performance on another, related task. In the context of large language models like GPT and BERT, transfer learning involves pre-training the model on vast amounts of text data to acquire general language understanding, followed by fine-tuning on a specific task using a smaller, labeled dataset. Transfer learning has been instrumental in the success of state-of-the-art natural language processing models, enabling them to achieve high performance with limited task-specific data.

Active learning

Active learning is a machine learning paradigm in which the model actively selects the most informative samples from a pool of unlabeled data for human annotation, thereby improving its performance with minimal labeled data. By focusing on samples that are most uncertain, ambiguous, or diverse, active learning can reduce the amount of labeled data required for training, making it particularly useful in scenarios where labeling data is time-consuming or expensive.

Continual learning

Continual learning is an approach in machine learning where a model learns from a continuous stream of data, adapting to new information and tasks without forgetting previous knowledge. This approach aims to mimic human learning, enabling AI systems to acquire knowledge incrementally and adapt to changing environments or problem domains. Continual learning is an active area of research, with potential applications in lifelong learning systems, robotics, and AI-driven decision making.

The post Free OpenAI Terminology Cheat Sheet (PDF) appeared first on Be on the Right Side of Change.

The purpose of this article is to help you refresh your knowledge of all the basic Python keywords, data structures, and fundamentals. I wrote it for the intermediate Python programmer who wants to reach the next level of programming expertise.

The way of achieving an expert level is through studying the basics.

Computer science professors usually have an extremely profound knowledge of the basics in their field. This enables them to argue from “first principles” rather than from the state-of-the-art—it’s easier for them to identify research gaps because they know about the ground rules in their field rather than being blinded by the latest technology and state-of-the-art.

Tip: If you want to reach the next level in coding, take your time and study the basics carefully.

This article provides you with the most important Python basics which serve as a foundation for more advanced topics.

Download your 5x Python cheat sheets, print them, and pin them to your office wall!

Click the image to register and download all Python cheat sheets.

Python Keywords

Like any other programming language, Python has many keywords with special meaning. For instance, Python 3.7 comes with 33 special keywords:

False
class
finally 
is 
return
None
continue
for
lambda
try
True
def
from 	
nonlocal 	
while
and 	
del 	
global 	
not 	
with
as 	
elif 	
if 	
or 	
yield
assert 	
else 	
import 	
pass 	 
break 	
except 	
in 	
raise

Exercise: Quickly glance over the list of keywords and try to explain their meaning.

In the following, you will study the most important Python keywords with short examples.

Keywords: False, True

These keywords represent the only two data values from the Boolean data type.

In Python, Boolean and integer data types are closely related: the Boolean data type internally uses integer values. Per default, the Boolean value False is represented by integer 0, and the Boolean value True is represented by integer 1. 

The following code snippet gives you an example of these two Boolean keywords.

x = 1 > 2
print(x)
# False

y = 2 > 1
print(y)
# True

After evaluating the given expressions, variable name x refers to the Boolean value False , and variable y refers to the Boolean value True.

Keywords: and, or, not

These keywords represent basic logical operators.

• Keyword and: The expression x and y evaluates to True if both values x and y evaluate to True. If one or both evaluate to False, the overall expression becomes False.
• Keyword or: The expression x or y evaluates to True if x is True or y is True (or both are True). If one of those is True, the overall expression becomes True.
• Keyword not: The expression not x evaluates to True if x evaluates to False.

Consider the following Python code example:

x, y = True, False

print((x or y) == True)
# True

print((x and y) == False)
# True

print((not y) == True)
# True 

By using these three operations—and, or, and not—you can express all logical expressions you’ll ever need.

Learn More: The following three tutorials guide you into those crucial Python logical operators:

• Python and Operator
• Python or Operator
• Python not Operator

Keywords: if, else, elif

Algorithms are often compared to cooking recipes. Imagine a cooking recipe that consists only of a sequential list of commands: fill water into a pot, add the salt, add the rice, get rid of the water, and serve the rice.

Strictly speaking, without a conditional execution, the sequence of commands would take only a few seconds to execute and the rice would not be ready for sure.

For example, you would fill in water, salt, and rice and immediately get rid of the water without waiting for the water to be hot and the rice to be soft.

We need to respond in a different way to different circumstances: we need to remove the water from the pot only if the rice is soft, and we need to put in the rice if the water is hot.

It’s almost impossible to write programs in a way that anticipates what happens in the real world in a deterministic manner.

Instead, we need to write programs that respond differently if different conditions are met. This is precisely why we need conditional execution with the keywords if, else, and elif.

x = int(input("your value: "))
if x > 3:
    print("Big")
elif x == 3:
    print("Medium")
else:
    print("Small")

The code snippet first takes the user input, converts it into an integer, and assign it to variable x.

It then tests the variable value whether it is larger than, equal to, or smaller than the value 3. In other words, the code responds to real-world input that is unpredictable in a differentiated manner.

Keywords: for, while

Computers are extremely fast—they execute billions of instructions per second.

Now imagine a world without a way of executing the same code snippet multiple times (with modified input). A program that runs only for a day would have to consist of trillions of lines of code (otherwise it would quickly run out of code to be executed). And the code would look like a mess because it would be highly redundant and not readable.

Recommended Resource: How to Write Clean Code?

To allow for repeated execution of similar code snippets, Python (like any other major programming language) allows for two types of loops: for loops and while loops.

This way, you can easily write a program consisting only of two lines of code that executes forever. It’s hard to do this without loops–the only alternative is recursion.

# For loop declaration
for i in [0, 1, 2]:
   print(i)

'''
0
1
2
'''

# While loop - same semantics
j = 0
while j < 3:
   print(j)
   j = j + 1

'''
0
1
2
'''

Both loop variants achieve the same thing: they print the integers 0, 1, and 2 to the shell.

The loops accomplish this in two different ways.

• The for loop repeatedly executes the loop body by declaring a loop variable i that iteratively takes on all values in the list [0, 1, 2].
• The while loop executes the loop body as long as a certain condition is met—in our case j < 3.

Keyword: break

There are two fundamental ways of terminating a loop: (i) define a loop condition that evaluates to False, or (ii) use the keyword break at the exact position in the loop body.

The following code snippet shows an example of the latter.

while True:
   break # no infinite loop

print("hello world")
# hello world

We create a while loop with a loop condition that will always evaluate to True.

For example, this is common practice when developing web servers that repeat the following procedure forever: wait for a new web request and serve the request.

However, in some cases, you still want to terminate the loop prematurely.

In the webserver example, you would stop serving files for security reasons when your server detects that it is under attack. In these cases, you can use the keyword break to immediately stop the loop and execute the code that follows.

In the example, the code executes print("hello world") after the loop ends prematurely.

Keyword: continue

The break statement is not the only statement that allows you to modify the execution flow of Python loops.

It is also possible to force the Python interpreter to skip certain areas in the loop while not ending it prematurely.

In the previously considered web server example, you may just want to skip malicious web requests instead of halting the server completely. This can be achieved using the continue statement that finishes the current loop iteration and brings the execution flow back to the loop condition.

while True:
  continue
  print("43") # dead code 

The code executes forever without executing the print statement once. The reason is that the continue statement finishes the current loop iteration.

The effect of using the continue statement in this way is that there exists dead code that will never be executed.

That’s why the continue statement (as well as the break statement) is commonly used under a certain condition by using a conditional if-else environment.

Keyword: in

The membership operator, i.e., in keyword, checks whether a certain element exists in a given sequence or container type.

print(42 in [2, 39, 42])
# True

print("21" in {"2", "39", "42"})
# False

The code snippet shows that the keyword in can be used to test the membership of an integer value 42 in a list of integer values or to test the membership of a string value "21" in a set of strings.

Recommended Tutorial: The Membership Operator in Python

Keyword: is

Beginners in Python are often confused about the exact meaning of the keyword is.

However, if you take the time to properly understand it now, you won’t belong to this group for long. The keyword simply checks whether both variables refer to the same object in memory.

y = x = 3

print(x is y)
# True

print([3] is [3])
# False

If you create two lists—even if they contain the same elements—they still refer to two different list objects in memory. Modifying one list object does not affect the other list object.

We say that lists are mutable because they can be modified after creation. Therefore, if you check whether one list refers to the same object in memory, the result is False.

However, integer values are immutable, so there is no risk of one variable changing the object which will then accidentally change all other variables.

The reason is that you cannot change the integer object 3—trying it will only create a new integer object and leave the old one unmodified.

Recommended Tutorial: The is Operator in Python

Keyword: return

The keyword return terminates the execution of a function and passes the flow of execution to the caller of the function. An optional value after the return keyword specifies the function result.

def appreciate(x, percentage):
   return x + x * percentage / 100


print(appreciate(10000, 5))
# 10500.0

We create a function appreciate() that calculates how much a given investment appreciates at a given percentage of return.

To this end, we use the keyword return to specify the result of the function as the sum of the original investment and the nominal return in one unit of time. The return value of the function appreciate() is of type float.

Keyword: None

The keyword None is a Python constant with the meaning “the absence of a value”.

Other programming languages such as Java use the value null instead. But the term null often confuses beginners assuming it’s equal to the integer value 0.

Instead, Python uses the keyword None to indicate that it’s a different value than any numerical value for zero, an empty list, or an empty string.

An interesting fact is that the value None is of its own data type.

def f():
   x = 2


print(f() is None)
# True

print("" == None)
# False

print(0 == None)
# False

The code snippet shows several examples of the None data value (and what it is not). If you don’t define a return value for a function, the default return value is None.

However, the value None is different from the empty string or the numerical zero value.

Keyword: lambda

The keyword lambda is used to define lambda functions in Python. Lambda functions are anonymous functions that are not defined in the namespace (roughly speaking: they have no names).

The syntax is:

lambda <arguments> : <return expression>

The lambda function can have one or multiple arguments (comma-separated). After the colon (:), you define the return expression that may (or may not) use the defined argument. It can be any expression or even another function.

Lambda functions are very important in Python. You’ll see them a lot in practical code projects: for example to make code shorter and more concise, or to create arguments of various Python functions (such as map() or reduce()).

print((lambda x: x + 3)(3))
# 6

Consider the code.

First, we create a lambda function that takes value x and returns the result of the expression x + 3. The result is a function object that can be called like any other function. Because of its semantics, we denote this function as incrementor function.

Second, when calling this incrementor function with the argument x=3, the result is the integer value 6.

Recommended Tutorial: Python Lambda Function Simple Guide

Python Basic Data Structures

At this point, you’ve learned about the Python keywords which I view as the bare minimum every Python coder must know.

However, writing code is more than using keywords correctly. Source code operates on data. But data can be represented in various ways—a thorough understanding of data structures is one of the most fundamental skills you can acquire as a programmer.

It will help you in every single of your future endeavors—no matter whether you create machine learning projects, work on large codebases, set up and manage websites, or write algorithms.

Data structures are fundamental to those areas.

The Boolean Data Type

A variable of type Boolean can only take two values—either True or False. You have already studied both keywords above.

## 1. Boolean Operations
x, y = True, False

print(x and not y)
# True

print(not x and y or x)
# True

## 2. If condition evaluates to False
if None or 0 or 0.0 or '' or [] or {} or set():
    print("Dead code") # Not reached

The code snippet shows two important points:

• First, Boolean operators are ordered by priority—the operator not has the highest priority, followed by the operator and, followed by the operator or.
• Second, the following values are evaluated to the Boolean value False: the keyword None, the integer value 0, the float value 0.0, empty strings, or empty container types.

Numerical Data Types

The two most important numerical data types are integer and float.

• An integer is a positive or negative number without floating point (for example 3).
• A float is a positive or negative number with floating point precision (for example 3.14159265359).

Python offers a wide variety of built-in numerical operations, as well as functionality to convert between those numerical data types.

Study the examples carefully to master these highly important numerical operations.

## Arithmetic Operations
x, y = 3, 2
print(x + y) # = 5
print(x - y) # = 1
print(x * y) # = 6
print(x / y) # = 1.5
print(x // y) # = 1
print(x % y) # = 1
print(-x) # = -3
print(abs(-x)) # = 3
print(int(3.9)) # = 3
print(float(3)) # = 3.0
print(x ** y) # = 9

Most of the operators are self-explaining. Note that the // operator performs integer division. The result is an integer value that is rounded toward the smaller integer number (for example 3 // 2 == 1).

The String Data Type

Python strings are sequences of characters. Strings are immutable so they cannot be changed, once created.

There are five main ways to create strings:

• Single quotes: 'Yes'.
• Double quotes: "Yes".
• Triple quotes (for multiline string): '''Yes'''' or """Yes""".
• The string method: str(5) == '5' is True.
• Concatenation: 'Py' + 'thon' becomes 'Python'.

While there are other ways, these are the five most commonly used.

Oftentimes, you want to explicitly use whitespace characters in strings. These are the most important ones: the newline character '\n', the space character '\s', and the tab character '\t'.

The following code snippet shows the most important string methods.

## Most Important String Methods
y = "    This is lazy\t\n   "

print(y.strip())
# Remove Whitespace: 'This is lazy'

print("DrDre".lower())
# Lowercase: 'drdre'

print("attention".upper())
# Uppercase: 'ATTENTION'

print("smartphone".startswith("smart"))
# True

print("smartphone".endswith("phone"))
# True

print("another".find("other"))
# Match index: 2

print("cheat".replace("ch", "m"))
# meat

print(','.join(["F", "B", "I"]))
# F,B,I

print(len("Rumpelstiltskin"))
# String length: 15

print("ear" in "earth")
# Contains: True

This non-exclusive list of string methods shows that the string data type is very powerful in Python and you can solve many common string problems with built-in Python functionality.

If in doubt about how to achieve a certain result regarding string problems, consult the following resource to learn about all built-in string methods.

Recommended Tutorial: Python String Methods

Python Container Data Structures

In the last section, you’ve learned about the basic Python data types.

But Python also ships with so-called container data types that handle complex operations efficiently while being easy to use.

List

The list is a container data type that stores a sequence of elements. Unlike strings, lists are mutable. This means that you can modify them at runtime.

Recommended Tutorial: Python List Ultimate Guide

The use of the list data type is best described with a series of examples:

l = [1, 2, 2]
print(len(l))
# 3

This code snippet shows how to create a list and how to populate it with three integer elements. You can also see that some elements may arise multiple times in a single list.

Recommended Tutorial: The len() function returns the number of elements in a list.

Adding Elements

There are three common ways of adding elements to a list: append, insert, or list concatenation.

# 1. Append
l = [1, 2, 2]
l.append(4)
print(l)
# [1, 2, 2, 4]

# 2. Insert
l = [1, 2, 4]
l.insert(2,2)
print(l)
# [1, 2, 2, 4]

# 3. List Concatenation
print([1, 2, 2] + [4])
# [1, 2, 2, 4]

All operations generate the same list [1, 2, 2, 4] but the append() operation is the fastest because it neither has to traverse the list to insert an element at the correct position (such as insert), nor create a new list out of two sublists (such as list concatenation).

Note that a fourth method is extend() which allows you to append multiple elements to the given list in an efficient manner.

Removing Elements

Removing an element x from a list can be easily achieved using the list method list.remove(x):

l = [1, 2, 2, 4]
l.remove(1)
print(l)
# [2, 2, 4]

Note that the method operates on the list object itself—no new list is created.

Reversing Lists

You can reverse the order of the list elements using the method list.reverse().

l = [1, 2, 2, 4]
l.reverse()
print(l)
# [4, 2, 2, 1]

Much like the method to remove an element from a list, reversing the list modifies the original list object and does not merely create a new list object.

Sorting Lists

You can sort the list elements using the method list.sort().

l = [2, 1, 4, 2]
l.sort()
print(l)
# [1, 2, 2, 4]

Again, sorting the list modifies the original list object.

The resulting list is sorted in an ascending manner.

You can also specify a key function and pass it as the parameter key to the sort() method to customize the sorting behavior. This way, you can also sort lists of custom objects (for example, sort a list of customer objects regarding their age).

The key function simply transforms one list element into an element that is sortable (such as an integer, float, or string element).

Indexing List Elements

You can determine the index of a specified list element x using the method list.index(x).

print([2, 2, 4].index(2))
# 0

print([2, 2, 4].index(2,1))
# 1

The method index(x) finds the first occurrence of the element x in the list and returns its index.

Recommended Tutorial: A Simple Guide to Python Lists

Stack

The stack data structure is a natural way of storing data items. Much like an unstructured person handles their paperwork: first in, first out.

Every new paper is placed at the top of a stack of papers. When working through the stack, they remove the topmost paper from the stack. As a result, the paper at the bottom never sees the daylight.

While this application does not seem to be a favorable way of using the stack data structure, the stack is still an extremely important fundamental data structure in computer science used in operating system management, algorithms, syntax parsing, and backtracking.

Python lists can be used intuitively as stacks via the two list operations append() and pop():

stack = [3]
stack.append(42) # [3, 42]
stack.pop() # 42 (stack: [3])
stack.pop() # 3 (stack: [])

Due to the efficiency of the list implementation, there is usually no need to import external stack libraries.

Set

The set data structure is one of the basic collection data types in Python and many other programming languages. There are even popular languages for distributed computing that focus almost exclusively on set operations (like MapReduce or Apache Spark) as programming primitives.

So what is a set exactly?

Definition: A set is an unordered collection of unique elements.

Let’s break this definition into its main pieces.

(1) Collection: A set is a collection of elements like a list or a tuple.

The collection consists of either primitive elements (e.g. integers, floats, strings), or complex elements (e.g. objects, tuples).

However, all data types must be hashable (a hash value of an object does never change and is used to compare the object to other objects).

Let’s have a look at an example.

hero = "Harry"
guide = "Dumbledore"
enemy = "Lord V."
print(hash(hero))
# 6175908009919104006

print(hash(guide))
# -5197671124693729851

## Can we create a set of strings?
characters = {hero, guide, enemy}
print(characters)
# {'Lord V.', 'Dumbledore', 'Harry'}

## Can we create a set of lists?
team_1 = [hero, guide]
team_2 = [enemy]
teams = {team_1, team_2}
# TypeError: unhashable type: 'list'

As you can see, we can create a set of strings because strings are hashable. But we cannot create a set of lists because lists are unhashable.

The reason is that lists are mutable: you can change a list by appending or removing elements. If you change the list data type, the hash value changes (it is calculated based on the content of the list). This violates the above definition (the hash value does not change). As mutable data types are not hashable, you cannot use them in sets.

(2) Unordered: Unlike lists, sets are unordered because there is no fixed order of the elements. In other words, regardless of the order in which you put stuff into the set, you can never be sure in which order the set stores these elements.

Here is an example:

characters = {hero, guide, enemy}
print(characters)
# {'Lord V.', 'Dumbledore', 'Harry'}

You put in the hero first, but my interpreter prints the enemy first (the Python interpreter is on the dark side, obviously). Note that your interpreter may print yet another order of the set elements.

(3) Unique: All elements in the set are unique. Each pair of values (x,y) in the set produces a different pair of hash values (hash(x)!=hash(y)).

Hence, every two elements x and y in the set are different—as a result, we cannot create an army of Harry Potter clones to fight Lord V:

clone_army = {hero, hero, hero, hero, hero, enemy}
print(clone_army)
# {'Lord V.', 'Harry'}

No matter how often you put the same value into the same set, the set stores only one instance of this value.

Recommended Tutorial: A Simple Guide to Python Sets

Note that an extension of the normal set data structure is the multiset data structure that can store multiple instances of the same value. However, it is seldom used in practice, so I don’t introduce it here.

Dictionary

The dictionary is a useful data structure for storing (key, value) pairs.

calories = {'apple' : 52, 'banana' : 89, 'choco' : 546}

You can read and write elements by specifying the key within brackets.

print(calories['apple'] < calories['choco'])
# True

calories['cappu'] = 74

print(calories['banana'] < calories['cappu'])
# False

Use the keys() and values() functions to access all keys and values of the dictionary.

print('apple' in calories.keys())
# True

print(52 in calories.values())
# True

Access the (key, value) pairs of a dictionary with the items() method.

for k, v in calories.items():
    print(k) if v > 500 else None
# 'choco'

This way, it’s easy to iterate over all keys and all values in a dictionary without accessing those individually.

Recommended Tutorial: A Simple Guide to Python Dictionaries

Tuples

A Python tuple is an immutable, ordered, and iterable container data structure that can hold arbitrary and heterogeneous immutable data elements.

Here’s a basic example of tuple creation and usage:

t = (1, 2, 'Python', tuple(), (42, 'hi'))

for i in range(5):
    print(t[i])

'''
1
2
Python
()
(42, 'hi')
'''

The tuple data structure is a built-in data structure of the Python language with the following characteristics:

• Tuples are containers, you can store data in them. The Python documentation defines a container as an object which implements the method __contains__. In other words a container is something you can use the in operator on. Other examples of containers in Python are list, dict, set or frozenset. The module collection contains more container types.
• Tuples are ordered, each element has its position or, the other way round, the position has meaning.
• Tuples are iterable, so you can use them, for example, in a for loop.
• Tuples are immutable which means, you can’t change a tuple once it was created. Once a tuple was created you can’t modify it anymore. Another example of an immutable data type in Python is string. You can’t modify tuples or strings in Python, instead, Python creates a new instance with the modified values. However, if a tuple contains mutable data types such as lists, the elements of those lists can change! Yet, the references in the tuple to those lists can’t.
• Tuples are heterogenous because they can contain elements of several different data types at once. An example of a homogenous data type are strings because they can only contain characters.

Recommended Tutorial: The Ultimate Guide to Python Tuples

Membership

Python’s “in” operator is a reserved keyword to test membership of the left operand in the collection defined as the right operand. For example, the expression x in my_list checks if object x exists in the my_list collection, so that at least one element y exists in my_list for that x == y holds. You can check membership using the “in” operator in collections such as lists, sets, strings, and tuples.

Check with the keyword in whether the set, list, or dictionary contains an element. Note that set membership is faster than list membership.

basket = {'apple', 'eggs', 'banana', 'orange'}

print('eggs' in basket)
# True

print('mushroom' in basket)
# False

Recommended Tutorial: A Simple Guide to the Membership Operator in Python

Also, check out our “negative membership” operator tutorial here.

List and Set Comprehension

List comprehension is a popular Python feature that helps you to create lists. The simple formula is [ expression + context ].

Expression: What to do with each list element?

Context: What list elements to select? The context consists of an arbitrary number of for and if statements.

For example, the list comprehension statement [x for x in range(3)] creates the list [0, 1, 2].

Another example is the following:

# (name, $-income)
customers = [("John", 240000),
             ("Alice", 120000),
             ("Ann", 1100000),
             ("Zach", 44000)]

# your high-value customers earning >$1M
whales = [x for x,y in customers if y>1000000]
print(whales)
# ['Ann']

Set comprehension is like list comprehension but creates a set rather than a list.

Recommended Tutorial: A Simple Guide to List Comprehension in Python

Summary

This article gave you a concise Python crash course to refresh your basic Python education.

You studied the most important Python keywords and how to use them in code examples.

As a result, you learned how to control the program execution flow using if-elif-else statements, as well as the while and the for loop.

Moreover, you revisited the basic data types in Python—Boolean, integer, float, and string—and which built-in operations and functions are commonly used in practice.

Most code snippets in practice and non-trivial algorithms are built around more powerful container types such as lists, stacks, sets, and dictionaries. By studying the given examples, you learned how to add, remove, insert, and reorder elements.

Finally, you learned about membership operators and list comprehension: an efficient and powerful built-in method to create lists programmatically in Python.

I wrote this 5000–word article for my best-selling book “Python One-Liners” with the San Francisco-based publisher NoStarch.

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills. You’ll learn about advanced Python features such as list comprehension, slicing, lambda functions, regular expressions, map and reduce functions, and slice assignments.

You’ll also learn how to:

• Leverage data structures to solve real-world problems, like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array, shape, axis, type, broadcasting, advanced indexing, slicing, sorting, searching, aggregating, and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups, negative lookaheads, escaped characters, whitespaces, character sets (and negative characters sets), and greedy/nongreedy operators
• Understand a wide range of computer science topics, including anagrams, palindromes, supersets, permutations, factorials, prime numbers, Fibonacci numbers, obfuscation, searching, and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined, and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

The post Python Programming Tutorial [+Cheat Sheets] appeared first on Be on the Right Side of Change.

To make matters worse, the maze is full of evil animals ? that keep her father captured. ?

The animals play a game with her: they will only leave her through if she solves the difficult Python puzzles. ?

Fortunately, you have trained your puzzle solving skills, haven’t you? ??

Can you help Alice out with your nerd super power? ?

Alice counts on you, so don’t disappoint her.

BONUS: how many BONUS items can you collect on the way to make Alices dad happy? But beware — if you cannot solve a question, Alice will be lost in the maze forever!

If you like games and Python sheets, feel free to check out my Python email cheat sheet academy:

The post [Python Mini Game] Can You Help Alice Find Her Dad? appeared first on Be on the Right Side of Change.

However, the cheat sheets are largely scattered around many different locations on the Finxter ecosystem. And even though I share all of them with my beloved Finxter community ? of ambitious coders—and subscribers to my free computer science email academy, join us! —they may not be accessible at all times by all Finxters. Time to change that!

In this article, I collect all Finxter cheat sheets and links to their PDF download locations. Feel free to share it with your hacker friends and coding mates!

? Click each image to open the high-resolution PDF in a new tab!

The Ultimate Python Cheat Sheet

This is my absolute favorite cheat sheet because it teaches you the basics of three fundamental cheat sheets that I just condensed into this single one. Look for yourself:

Python Keywords Cheat Sheet

Python keywords are reserved words with a special meaning. Make sure to understand all of them by heart!

Python Basic Data Types Cheat Sheet

Programming mastery comes from two things: data and functions. This cheat sheet is about the former!

Python Complex Data Types Cheat Sheet

The complex or container data types in Python are lists, sets, dictionary, and tuples. We’ve written an in-depth guide on each of those if the cheat sheet is too shallow for you:

• The Ultimate Guide to Python Lists
• The Ultimate Guide to Python Sets
• The Ultimate Guide to Python Tuples
• The Ultimate Guide to Python Dictionaries

And here’s the cheat sheet:

Python List Methods Cheat Sheet

A big part of mastering lists is to master the methods provided by the list data structure. You can do this in the cheat sheet or in my in-depth course on Python list methods here.

Python Set Methods Cheat Sheet

Let’s move on to one of the most underutilized data structures in Python: sets. They’re far more efficient than lists—if you can handle the reduced expressiveness. You can find all set methods explained in detail in the Finxter Academy course.

Python Object Orientation Terminology Cheat Sheet

We need to use the right words to communicate effectively with other programmers. This cheat sheet will show you all the words you need to know in object orientation!

Python Classes Cheat Sheet

Let’s really dive into two concepts of object-oriented programming: classes and objects. These things are must-knows for you as an effective programmer!

Python Functions and Tricks Cheat Sheet

I know you like tricks and hacks. Here are some of the most interesting ones! You can also watch me explaining those in a video tutorial here.

Python Interview Questions Cheat Sheet

Let’s get serious! These questions are likely to get asked in a coding interview, so make sure to prepare accordingly!

Python NumPy Cheat Sheet

NumPy is the secret sauce of Python’s data scientists and machine learning engineers. Virtually any framework in the data science space builds on NumPy such as TensorFlow, Pandas, Matplotlib. Figure this out first!

Python Book Simplicity Cheat Sheet

Here’s the cheat sheet about my latest book Simplicity — The Finer Art of Creating Software about how to boost your coding productivity to the next level and beyond. It’ll appear in 2021—so stay tuned!

Python 6 Machine Learning Algorithms Cheat Sheet

A quick and simple cheat sheet with six links to the most important machine learning algorithms. Ready? Set. Go!

Python Support Vector Machines Cheat Sheet

Deep dive into the powerful SVM algorithm that has superior generalization properties and even works in higher-dimensional spaces. Support Vector Machines are beautiful! ?

Python Git Cheat Sheet

Every programmer needs to understand Git. Because Git is at the core of every project’s workflow. Write code and commit it to the big project. As you can’t avoid it anyways, why not master it today?

Python Plotly Dash Cheat Sheet

Again a cheat sheet from our new and upcoming book about Plotly Dash. Dash is an exciting framework to create beautiful dashboard applications and host them on the web. Stay tuned to learn about the launch—it’ll be fun!

That’s it for now—I’ll keep updating new cheat sheets as I produce them. Stay tuned to make sure to be informed about each new Cheat Sheet I publish on the Finxter blog.

You can also check out these interesting blog articles about cheat sheets—many with videos:

Thanks for checking out the whole article—let’s round this up with the standard Finxter “post footer”.

The post 16 PDF Cheat Sheets for Programmers appeared first on Be on the Right Side of Change.