Python Programming Fundamentals

• Python supports Integer, Real, Character, String, Boolean, and Nothing data types
• Boolean data type is logical where false represents 0 and true represent 1

Programming Languages

• Programming languages create software and interact with hardware through a set of instructions
• Assembly and C are low-level programming languages
  • They are closer to machine code
  • They are very fast as a result
  • They are very complex
• Python is a high-level programming language that is simple and close to human language
  • These characteristics make it easy to learn and use
• Compilers translate complete source code into machine language before execution
  • Conversion of the entire program into machine code is required
• Uninitialized variables lack a default value and generally don't exist in Python
  • A default value of an uninitialized variable in Python is "None", which represents the absence of any value
• Exceptions in Python are handled using the try-except syntax

Features of Programming Langauges

• Programming languages require logical data types, conditions, and loops such as if statements and for loops

Important concepts

• Software are algorithms represented as programs that can be translated and executed by a CPU
• Loaders put data and instructions into the CPU's memory for execution
• Inputs come from devices like keyboard and mouse
• Outputs are displayed on screen, sent to speaker, or saved to file

Syntax and Semantics

• Syntax are the rules for writing code,
• Semantics is the meaning of the code itself For example, how Python interprets concatenating a string with an integer

Variables and Constants

• Variables are named locations in memory that hold data
  • Variables can be reassigned
  • Ex: year = 2023 can become year = 2025
• Constants are variables with values that cannot be changed
  • Ex: PI = 3.14

Data Types in Python

• Integer: Whole numbers, like age = 21
• Float: Decimal numbers, like pi = 3.14
• String: Text data, like name = "Alice"
• Boolean: True or False, like is_valid = True

Order of Operations and Arithmetic

• Order of Operations follows PEMDAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction)
  • Ex: 5 + 3 * 2 = 11 because multiplication comes before addition
• Arithmetic Operations:
  • Addition (+), subtraction (-), multiplication (*), division (/), exponentiation (**), modulus (%), and floor division (//)
• Modulus (%) returns the division remainder
• Floor division (//) rounds the result of division to the nearest integer

Variable Naming

• Variable names must follow certain rules:
  • They must start with a letter or underscore
  • They can consist of alphanumeric characters and underscores
  • They cannot start with a number or special characters
  • They are case-sensitive; age and Age are different variables

Data Type Conversions

• Data types can be converted implicitly or explicitly:
  • Implicit conversion is automatic
    • Ex: adding an integer and a float results in a float
  • Explicit conversion is manually implemented using functions like int(), float(), or str()
  • Data loss can occur, such as converting 24.45 to an integer, resulting in 24

Python vs C

• Python is interpreted and executes line by line
  • That means it is slower
  • But is also easier to debug
• C is a compiled language and the entire program converted to machine code before execution
  • Faster
  • More complex

Coding Best Practices

• Always initialize any variables
  • For example, set year = 0 before assigning year = 2023
• Adhere to naming conventions
  • Use camelCase or snake_case

Julia

• Julia combines the simplicity of Python with the speed of C
• Julia is still in early stages

Strings

• The '+' operator concatenates (e.g., “Hello” + “World” gives "Hello World")
• The '*' operator repeats strings (e.g., "Hi" * 3 gives "HiHiHi")
• The '&' operator is invalid for strings
• The '/' operator is invalid for strings
• The ',' operator gives spaces in the output (e.g., ‘Hello', ‘World' gives 'Hello World')

String Methods

• .format() method injects variables into strings (e.g., ‘Hello, {}'.format(name))
• range() generates numbers
• list() converts the numbers range() generated into a list (e.g., list(range(5)) gives [0, 1, 2, 3, 4])

Python Variables

• Variable names must follow industry standards
  • First letter capitalized
  • camelCase
• They must start with a letter or underscore and not a number

Python Datatypes

• Python assigns a variable type based on the value assigned
  • A variable speed = 50 is created as an Integer type
• String multiplied by a number
  • Repeats the string
  • '50' * 14 repeats "50" 14 times

Type Conversion

• int(), float(), and round() converts to that type
• abs() returns the absolute value of a number

Strings in Python

• String literals can use single or double quotes
• String index starts from 0

String slicing

• Strings can be sliced using [start:end] indices
• Negative indices access characters from the end
  • [:-1] accesses the last character
• -1 means the statement is wrong
• Negative slices start from the right side of the string
• Positive slices start from the left side of the string

Helpful String Methods

• len() returns the length of a string
• find() and rfind() get the index of substring occurrences from the left and right, respectively
  • method returns -1 when the substring isn't found
• upper(), lower(), capitalize(), and title() modify the string case
• strip(), rstrip(), and lstrip() remove whitespace
• count() returns the number of substring occurrences

String Concatenation and Lists

• Strings can be joined using the + operator or f-strings
  • Ex: f"Hello {name}"
• Lists are ordered mutable collections of items enclosed in square brackets
• They contain mixed data types

List operations

• append() adds items to the end
• .join() joins elements with spaces
• insert() adds item at a specific index
• remove() deletes an item by value
• len(), max(), min(), and sum() gets list information
• Lists can be sliced like strings
  • list[1:3] returns elements from index 1 to 2

More on Lists

• List can be altered after creation
• list2 = list(list1) creates a new list by copying list1
• list2 = list1 creates a reference to the same list

Python Tuples

• Tuples are similar to lists and are also immutable
• They are useful for storing fixed data
• Tuples are created using parentheses

User Input

• input() takes a user's input
• Prompting the user is common
  • input("Enter your name")

Coding Readability

• Write code comments improve readability
• Documenting code helps others understand the code

Errors and Best Practices

• Index Errors occur outside of index range for List and string
• Chains methods effectively
  • string.upper().strip()

Security

• Programs crashing vulnerabilities can happen due to buffer overflow and out-of-bound errors
• Python attempts to handle these errors, but it is best to be aware of them

Practical Examples

• Combining the first and last letter and a number creates a password
• split() to creates a list from string and join() to combine the list into a string

Conditions and Loops

• Conditions and loops are fundamental in differentiating programming languages from non-programming languages, like HTML
• if statements control the flow of the program and evaluate inner statements
• Python does not require variable declarations like C
• In a for loop for, the range function starts at 0 by default

Control Structures

• Control structures include sequences, selections, iteration, and branching:
  • Sequences: Code execution line by line
  • Selections: Decisions based on conditions (e.g., if-else)
  • Iteration: For and while loops that repeat execution until a condition is met
  • Branching: Enables jumping to different code parts based on conditions
• Function calls are not considered control structures

If-Else Statements

• The syntax is an if condition: with indented code blocks
• else: and elif (else if) handle additional conditions
• Code blocks are distinguished with indentation
• The else statement defines action if the if condition is false

Relational and Logical Operators

• Operators , =, ==, and != compare values
• Conditions result in a boolean value (True or False) Logical Operators (combined conditions):
  • and: Both conditions must be true
  • or: At least one must be true
  • not: Inverts the boolean value

Loops

• while loops execute while a condition is true, and without a termination condition, it will run indefinitely
• for loops iterate over a sequence, like numbers or a list
• Infinite loops occur if the condition tested is always true
  • Ex: while True
  • Range function is range(start, stop, step), generates a sequence of numbers
  • start is inclusive, stop is exclusive

Nested Loops

• Nested Loops are loops inside other loops
• inner if statements are refered to same as outer if statements if indented correctly

Loop Control

• break exits the nearest enclosing loop.
• continue skips the current iteration and moves to the next.
• return exits a function and returns a value.

Flowcharts and Pseudocode

• Flowcharts are visual representations of program logic
• Pseudocode writes code logic simply without specific syntax

Lists and Iteration

• Lists are ordered, mutable collections
• Iteration can run through each item of the list to derive values

String Manupulation

• Strings can be manipulated with indexing and slicing

User Input

• input() takes user input

Error Handling

• When attempting to access an out-of-range index, an Index Error occurs

Practical Examples

• Passwords can be created by combining the first letter of a name, the last letter of a name, and a random number
• Strings can be split by split() and joined by join()

Python Functions

• Functions help code modularity
  • Help in reducing code complexity
  • Make programs more readable
  • Increase reusability
• Passing no parameters requires empty parentheses
• Function parameters can have default values
• The phrase "pass by reference" refers to parameter changes affecting the original variable
• Functions can be nested or defined inside one another and is called nesting
• Code block are defined by indendation using 4 spaces or a tab
• Parameterless function require no parameters

Benefits of Using Functions

• Functions increases readability, reusability, and are easier to maintain

Functions vs. Methods

• Functions are operations either user-defined or built-in
• Methods are functions associated with objects or data types
  • For example, list.append()

Function Syntax

• Declared using the def keyword
• Input Parameters: take input parameters to perform operations

Use of Main Function

• Acts as entrypoint to other functions
• Calls to other functions
• Execution order starts from Main and executes the program
• Built in functions like print(), input(), len(), int(), float(), etc, are packaged in Python for use in code
• Functions can be defined by the user that allow better organization
• The return statement is used when a function needs to return a value with a keyword
• function parameters and arguments are listed as variables in the function definition
• the arguments are then called when the function is used

Default Parameters

• Functions can have defaults for various passed variables
• This means that functions can be declared with a guest default parameter value if one is not provided
• Scope of variables determines what data the function can access

Global vs Local Scope

• Local variables exist inside the function
• Global variables exist outside of functions and can be accessed anywhere

Call by Reference and Value

• When called by value, the values of the variables are copied
• When called by reference, the references of the variables are copied and any mutations affect the original due to pointing to the same value

Calculating Factorials

• Example: Recursive approach in use of nested function parameters

Error Handling

• Functions can use conditional statements to handle errors

Function Examples

• Functions can validate passwords by validating certain conditions

File Set Notes

• In file setting: opening a nonexistent file in write mode creates the file
• Sets are unique and unordered by nature.
• truncate() can resize the file to a specific size
• infile.readlines() gets lines in a file and puts those to a list.
• with statements allows files to be closed after it suits, and is closed at the very end
• the item in set code determines what items exist in a set
• opening the w mode will create the file if it doesn't exist or the file will be overridden if does exist

File Appending

• open() helps append content to a file
• open(file.txt, 'w') creates a file if it doesnt exist. can work in conjunction with set(list).

Concepts of File Handling

• File are very useful for tasks that need writing to files like logging, data processing, etc.
• Files like CSV and TXT are common
• Python file commands are straightforward

Input (I/O) Connections

• Standard Input (STDIN) is usually the keyboard
• Standard Output (STDOUT) is usually the monitor
• Standard Error (STDERR) is for errors in the monitor
• Redirect is for inputs and outputs

Reading and Writing Datatypes

• Text files are in the text form
• Newlines are added automatically,
• But can be removed by end=""'

Files

• open() takes two arguments for read, write , append, along with absolute/relative values
• Make the habit of checking existence and closing the file by file.close()

File Mehtods

• read() reads entire file content
• readline() reads one line
• readlines() returns a list of lines
• use a for loop to iterate to loop with for line in file

Loops

• the while line doesn't equal nothing is a great way to loop through things
• write() doesn't add newlines automatically, one must be added
• copying files is done by looping and dumping content

Verifying Files

• os.path-exists() command checks for the existence of a file
• os.path.isfile() checks that the path provided is a file

Set Properties

• collections with no duplicates
• x {1,2,2,3} would equal {1,2,3}
• methods are add, discard , clear

Union and Intersection

• union() combines sets
• intersection takes common elements

Best practices

• Check permissions
• Resource management and statements for closing files

Important data types to know

• list (ordered/mutable/duplicates), tuples(ordered/immutable), sets (unordered/no duplicates, useful for tests)

Key Points on File Handling

• File handling is critical to data/processing storage
• Use simple methods
• Powerful setting
• always valiate file/paths before running.