Python

Python

A high-level, interpreted programming language known for its easy readability.

Variable

A container for storing data values. Example: x = 5.

Data Types

Types of data representing the kind of value that can be stored. Examples: int, float, str.

List

A collection of items in a single variable. Example: my_list = [1, 2, 3].

Tuple

An immutable collection of items. Example: my_tuple = (1, 2, 3).

Dictionary

A collection of key-value pairs. Example: my_dict = {'name': 'Alice', 'age': 25}.

Function

A block of reusable code that performs a specific task. Example: def my_function(): return 'Hello'.

Conditionals

Used to perform different actions based on different conditions. Example: if x > 10: print('x is greater than 10').

Loop

A programming structure that repeats a block of code. Example: for i in range(5): print(i).

Import

To bring in external libraries or modules. Example: import math.

List Comprehension

A concise way to create lists. Example: squares = [x**2 for x in range(10)].

Lambda Function

An anonymous function defined with the lambda keyword. Example: f = lambda x: x + 1.

Error Handling

Using try and except blocks to manage exceptions. Example: try: print(1/0) except ZeroDivisionError: print('Divided by zero').

Object-Oriented Programming

A programming paradigm based on the concept of objects. Example: class Car, my_car = Car().

Class

A user-defined blueprint for creating objects. Example: class Dog: pass.

Inheritance

The mechanism of acquiring properties from another class. Example: class Puppy(Dog): pass.

Polymorphism

The ability to present the same interface for different data types.

File Handling

Reading from and writing to files. Example: with open('file.txt', 'r') as f: content = f.read().

Modules

Files containing Python code that can be imported and used in other files.

Virtual Environment

An isolated Python environment for package management.

pip

Package installer for Python, used to install and manage software packages.

Framework

A collection of libraries that provide a standard way to build and deploy applications. Example: Flask, Django.

Decorator

A function that modifies another function's behavior. Example: @app.route('/').

Generator

A special type of iterator that yields values one at a time. Example: def my_gen(): yield 1.

Iterator

An object that can be iterated upon, returning one element at a time.

List Methods

Functions available to lists. Example: my_list.append(4).

String Methods

Functions available to strings. Example: my_str.upper().

Lambda Expressions

Anonymous functions defined using the lambda keyword.

Scope

The context in which a variable is defined and can be accessed.

Global Variable

A variable defined outside any function, accessible globally.

Local Variable

A variable defined within a function, accessible only within that function.

Python Built-in Functions

Functions available by default in Python. Example: len(), type().

Comprehensions

Concise methods for creating lists, sets, and dictionaries.

Try/Except

Error handling using try and except blocks.

AS keyword

Used in import statements to create an alias. Example: import numpy as np.

Enumerate Function

Adds a counter to an iterable. Example: for index, value in enumerate(my_list): print(index, value).

Join Method

Combines a list of strings into a single string. Example: ', '.join(my_list).

Split Method

Divides a string into a list based on a delimiter. Example: my_str.split(',').

Map Function

Applies a function to all items in an input list. Example: list(map(str, my_list)).

Filter Function

Filters items out of a list based on a condition. Example: list(filter(lambda x: x > 5, my_list)).

Reduce Function

Reduces a list to a single value using a binary function. Example: from functools import reduce; reduce(lambda x, y: x + y, my_list).

Set

An unordered collection of unique items. Example: my_set = {1, 2, 3}.

Set Operations

Operations such as union, intersection, and difference. Example: set1.union(set2).

Regular Expressions

A sequence of characters that forms a search pattern.

Web Scraping

Extracting data from websites using libraries like BeautifulSoup.

API

Application Programming Interface, a set of tools for building software applications.

Requests Module

A popular HTTP library for sending network requests.

JSON Module

A library for parsing JSON data in Python.

Unit Testing

Testing individual components of code using frameworks like unittest.

Scripting

Writing short programs to automate tasks.

List Slice

Accessing a portion of a list. Example: my_list[1:3].

Tuple Unpacking

Assigning values from a tuple to variables. Example: x, y = my_tuple.

Timestamp

A representation of a point in time, important for logging.

Date/Time Module

A module for manipulating dates and times. Example: from datetime import datetime.

Context Managers

A way to allocate and free resources precisely when you want to.

F-Strings

Formatted string literals for easier string formatting. Example: f'Hello, {name}'.

Shell Scripting

Writing scripts for command-line interface operations.

Concurrency

Running tasks simultaneously. Example: using the asyncio library.

Web Development

Creating web applications using frameworks like Flask and Django.

Data Analysis

Using libraries like Pandas and NumPy to analyze data.

Object Serialization

Converting an object to a format that can be easily saved to a file or database. Example: using pickle.

Memory Management

How Python manages memory and garbage collection.

Multithreading

A technique to run multiple threads in a single process.

Multiprocessing

A technique to run multiple processes, allowing CPU-bound tasks to perform better.

Database Connectivity

Interacting with databases using libraries like SQLite, SQLAlchemy.

Deployment

The process of making a web application or service available for use.

Type Hints

A feature that allows specifying the data types of function parameters and return values.

Decorator Arguments

Passing arguments into decorators.

Static Typing

Specifying the type of a variable when declaring it, introduced with type hints.

Dynamic Typing

The type of variable is interpreted at runtime.

Immutable Data Types

Types that cannot be modified after their creation. Examples: strings, tuples.

Mutable Data Types

Types that can be changed after their creation. Examples: lists, dictionaries.

Command-Line Arguments

Inputs to a program provided when the program is run from the terminal.

Virtual Dictionary

Using only Python dictionaries to store complex data structures.

Meta Programming

Programming techniques for writing programs that manipulate other programs.

Mixed Data Type Handling

Handling multiple data types in operations, for instance when working with lists.

Unit Tests

Automated tests for checking that certain parts of software work as required.