PYTHON ESSENCIALS

INTRODUCTION TO COMPUTER PROGRAMMING

PROGRAMMING: ORGANIZING CODE TO ACHIEVE A DESIRED EFFECT.
KEY ASPECTS:
ALPHABETICAL: USE RECOGNIZABLE SCRIPT.
LEXICAL: KNOW THE LANGUAGE’S VOCABULARY.
SYNTAX: FOLLOW THE RULES.
SEMANTICS: ENSURE LOGICAL MEANING.

2 WAYS TO RUN CODE:

1. COMPILATION: TRANSLATES ENTIRE PROGRAM ONCE INTO MACHINE CODE (E.G., .EXE). REQUIRES A COMPILER.
2. INTERPRETATION: TRANSLATES CODE EVERY TIME IT RUNS. REQUIRES AN INTERPRETER.

PYTHON
PYTHON CHARACTERISTICS
WHAT IS PYTHON?
EASY TO: LEARN, TEACH, USE, UNDERSTAND.
INTERPRETED, OBJECT-ORIENTED, HIGH-LEVEL PROGRAMMING LANGUAGE WITH
FREE AND OPEN SOURCE
DYNAMIC SEMANTICS.
NOT THE FASTEST PERFORMANCE
PYTHON WAS DEVELOPED BY GUIDO VAN ROSSUM IN 1991.
TESTING CHALLENGES
NAMED AFTER THE COMEDY SHOW MONTY PYTHON'S FLYING CIRCUS, NOT THE SNAKE.
CREATED BY GUIDO VAN ROSSUM IN THE NETHERLANDS.

INSTALLING PYTHON:
DOWNLOAD PYTHON 3 FROM PYTHON.ORG.
INSTALL IT (CHECK ADD PYTHON TO PATH ON WINDOWS).
VERIFY WITH PYTHON --VERSION, THEN OPEN IDLE FROM YOUR OS MENU TO START
CODING.

LITERALS:
FIXED VALUES IN CODE (E.G., 123 FOR NUMBERS, "TEXT" FOR STRINGS).
NUMBER SYSTEMS:
BINARY: BASE 2 (E.G., 1010 IS 10 IN DECIMAL).
OCTAL: BASE 8.
HEXADECIMAL: BASE 16 (USES 0-9 AND A-F).
NUMBER TYPES:
INTEGERS: WHOLE NUMBERS (E.G., 256, -1).
FLOATS: NUMBERS WITH FRACTIONS (E.G., 1.27).
STRING QUOTES:
USE ESCAPE CHARACTERS (E.G., 'I\'M HAPPY') OR OPPOSITE QUOTES
(E.G., "I'M HAPPY").
BOOLEAN VALUES:
TRUE AND FALSE (1 IS TRUE, 0 IS FALSE).
SPECIAL LITERAL:
NONE: REPRESENTS THE ABSENCE OF A VALUE.

THE HELLO WORLD PROGRAM

PRINT() FUNCTION:
OUTPUTS TEXT TO THE CONSOLE.
FUNCTION BASICS:
CALL WITH NAME AND PARENTHESES.
EXAMPLE: PRINT("HELLO").
STRINGS:
ENCLOSED IN QUOTES.
SPECIAL CHARACTERS:
\N FOR NEW LINES.
ARGUMENTS:
POSITIONAL: ORDER MATTERS.
KEYWORD: IDENTIFIED BY KEYWORDS.
PRINT() PARAMETERS:
SEP: SEPARATOR BETWEEN ARGUMENTS.
END: END CHARACTER.

OPERATORS:
EXPRESSION: COMBINES VALUES/OPERATORS TO PRODUCE A RESULT (E.G., 1 + 2).
OPERATORS: SYMBOLS FOR OPERATIONS (E.G., * FOR MULTIPLICATION).
ARITHMETIC OPERATORS: +, -, *, / (FLOAT), %, **, //.
UNARY OPERATOR: ONE OPERAND (E.G., -1).
BINARY OPERATOR: TWO OPERANDS (E.G., 4 + 5).
OPERATOR PRIORITY: (HIGHEST), +/- (LOWEST).
PARENTHESES: CALCULATED FIRST (E.G., 15 - 1 * (5 * (1 + 2))).
RIGHT-SIDED BINDING: EXPONENTIATION (E.G., 2 ** 2 ** 3).
VARIABLES:
VARIABLE: NAMED MEMORY LOCATION FOR VALUES.
IDENTIFIER: UNIQUE NAME; STARTS WITH A LETTER/UNDERSCORE, CASE-SENSITIVE.
DYNAMIC TYPING: NO NEED TO DECLARE VARIABLES.
ASSIGNMENT: VAR = 1; COMPOUND OPERATORS LIKE +=.
UPDATING: ASSIGN NEW VALUES WITH = OR COMPOUND OPERATORS.
COMBINING TEXT: USE + WITH STRINGS AND VARIABLES.

COMMENTS:
COMMENTS: START WITH #, IGNORED AT RUNTIME.
MULTI-LINE: USE # ON EACH LINE.
SELF-COMMENTING NAMES: USE CLEAR VARIABLE NAMES.
PURPOSE: MAKE CODE UNDERSTANDABLE FOR YOU AND OTHERS.

COMPARISON OPERATORS:
==, !=, >, <, >=, <=.
CONDITIONAL STATEMENTS:
IF: EXECUTES CODE IF THE CONDITION IS TRUE.
IF-ELSE: EXECUTES ONE BLOCK IF THE CONDITION IS TRUE, ANOTHER IF FALSE.
IF-ELIF-ELSE: CHECKS MULTIPLE CONDITIONS; EXECUTES THE FIRST TRUE BLOCK.
NESTED: IF INSIDE ANOTHER IF

LOOPS:
WHILE: EXECUTES AS LONG AS THE CONDITION IS TRUE.
FOR: ITERATES OVER A SEQUENCE (E.G., LIST, STRING).
LOGICAL OPERATORS: FLOW CONTROL:
AND: TRUE IF BOTH ARE TRUE. BREAK: EXITS THE LOOP.
OR: TRUE IF ANY IS TRUE. CONTINUE: SKIPS TO THE NEXT ITERATION.
NOT: REVERSES THE RESULT. ELSE WITH LOOPS: RUNS AFTER THE LOOP UNLESS INTERRUPTED BY BREAK.
BITWISE OPERATORS: RANGE(): GENERATES A SEQUENCE OF NUMBERS; RANGE(START, STOP, STEP).
&: BITWISE AND.
|: BITWISE OR.
~: BITWISE NOT.
^: BITWISE XOR.
>>: RIGHT SHIFT. LISTS: ORDERED, MUTABLE COLLECTIONS IN SQUARE BRACKETS (E.G., [1, NONE, TRUE]).
<<: LEFT SHIFT. INDEXING/UPDATING: ACCESS AND MODIFY WITH INDICES (E.G., MY_LIST[1], MY_LIST[0]
= "NEW").
NESTING: LISTS CAN CONTAIN OTHER LISTS (E.G., [1, ['NESTED']]).
DELETING: USE DEL TO REMOVE ELEMENTS OR THE WHOLE LIST (E.G., DEL MY_LIST[1]).
ITERATION: USE FOR LOOP TO ITERATE THROUGH ELEMENTS (E.G., FOR ITEM IN MY_LIST).
LENGTH: USE LEN() TO GET THE NUMBER OF ELEMENTS (E.G., LEN(MY_LIST)).
FUNCTION VS METHOD: FUNCTIONS ARE CALLED AS FUNCTION(ARG), METHODS AS
DATA.METHOD(ARG).

SORTING SIMPLE LISTS:

SORT(): SORTS THE LIST IN ASCENDING ORDER (E.G., [5, 3, 1, 2, 4]
BECOMES [1, 2, 3, 4, 5]).
REVERSE(): REVERSES THE ORDER OF THE LIST (E.G., [5, 3, 1, 2, 4]
BECOMES [4, 2, 1, 3, 5]).

ASSIGNMENT: L2 = L1 MAKES L2 REFERENCE THE SAME LIST AS L1, NOT A COPY.

COPYING LISTS: USE SLICING TO COPY LISTS:
L1[:] FOR A FULL COPY
L1[START:END] FOR PART OF THE LIST
NEGATIVE INDICES: USE NEGATIVE INDICES FOR SLICING:
L1[2:-1] SLICES FROM THE 3RD ITEM TO THE SECOND-TO-LAST ITEM.
OPTIONAL PARAMETERS: START AND END PARAMETERS ARE OPTIONAL IN SLICING:
L1[2:], L1[:2], AND L1[-2:].
DELETING SLICES: USE DEL TO REMOVE SLICES:
DEL L1[0:2] AND DEL L1[:] TO CLEAR LIST CONTENT.
MEMBERSHIP TESTING: CHECK IF ITEMS ARE IN A LIST USING IN AND NOT IN:
"A" IN L1, "C" NOT IN L1.
LIST COMPREHENSION: CREATE NEW LISTS CONCISELY:
SYNTAX: [EXPRESSION FOR ELEMENT IN LIST IF CONDITIONAL]
EXAMPLE: [NUM ** 3 FOR NUM IN RANGE(5)] RESULTS IN [0, 1, 8, 27, 64].
NESTED LISTS: USE NESTED LISTS TO CREATE MATRICES:
EXAMPLE: TABLE = [[":(", ":)", ":(", ":)"], ...]
ACCESS ELEMENTS WITH TABLE[ROW][COLUMN].
N-DIMENSIONAL LISTS: CREATE HIGHER-DIMENSIONAL LISTS:
EXAMPLE: CUBE = [[[':(', 'X', 'X'], ...], ...]
ACCESS ELEMENTS WITH MULTIPLE INDICES: CUBE[0][0][0].