Python
Copy Slice
>>> name one = 'Monty' >>> name two = name one[:] >>> name two 'Monty' >>> Remember, a new string is yielded as the result of a slice; the original string is not modified. Thus a copy slice is indeed a new copy of the original string.
'while' loop
A 'while' loop works as follows: 1. The program enters the 'while' construct and evaluates the Boolean expression (condition). 2. If the Boolean expression is (True), then the associated 'while suite' is executed. 3. At the end of the 'suite', control flows back to the top of the 'while', where the Boolean expression is re-evaluated. 4. If the Boolean expression yields (True), the loop executes again. If the Boolean yields (False), then the 'while' suite is skipped and the code following the 'while' loop is executed. Some things to note about how a 'while' statement works: 1. The condition is evaluated before the suite is executed. This means that if the condition starts out (False), the loop will never run. 2. If the condition always remained True, the loop will never end, i.e. an 'infinite loop'.
Boolean type
A Boolean value has a Python type 'bool'. The Boolean type refers to the values True or False (note the capitalization). If an object is of type Boolean, it can be only one of those two values. In fact, the two Boolean objects are represented as integers: 0 is False and 1 is True. More generally, an object with value 0 is considered to be the equivalent of a False Boolean value and any nonzero value is considered to be the equivalent of a True Boolean value. In addition, any empty object, such as an empty string (' '), is considered to be False.
Collection
A collection in Python is a single object that contains multiple elements that are associated with the collection object. Examples: 1. strings 2. lists 3. dictionaries 4. sets
Expression
A combination of values and operations that creates a new value that we call a return value—i.e., the value returned by the operation(s). If you enter an expression into the Python shell, a value will be returned and displayed. >>> my int + 5 # expression , value associated with my int added to 5 10 >>> my int # no s ide e f f e c t of expres sion , my int i s unchanged 5 >>>
Strings Are Iterable
A data type that is iterable means that the individual elements can be "iterated through" using a 'for' loop (or other methods). Example: >>> for char in 'Hi mom': print(char, type(char)) H <class 'str'> i <class 'str'> <class 'str'> m <class 'str'> o <class 'str'> m <class 'str'> >>> As with range, the for assigns each individual element of the string, one at a time, to the variable 'char' and prints them out. Also printed is the type of the object associated with 'char', which is of course type 'str'.
Dictionary type
A dictionary in Python is of type 'dict'. A dictionary is a map type, a collection though not a sequence. A map type consists of a set of element pairs. The first element in the pair is the key and the second is the value. The key can be used to search for a value, much like a dictionary or phone book. If you want to look up the phone number (the value) or a person (the key), you can efficiently search for the name and find the number. Curly braces, ({ and }) indicate dictionaries; a colon separates the key and value pair. Example: {'Jones':3471124, 'Larson':3472289, 'Smith':3471288}
'half-open' range
A half-open range designates the beginning of the sequence that is included in the result along with an end of the sequence that is not included. hello str = 'Hello World' For hello str[6:10] the range indicates a subsequence consisting of the strings at indices 6, 7, 8, and 9. The string at index 10 is not included. Every range can be specified with two values: the beginning index of the range and end index of the range, separated by a colon (:). If a value on either side of the colon is missing, a 'default' is used in place of the missing value. If the first index is missing, default is 0: hello str[:5] is 'Hello' is the same as hello str[0:5] is 'Hello' If the last index is missing, default is the end of the sequence, INCLUDING the last character. hello str[6:] is 'World' is the same as hello str[6:11] is 'World'
List type
A list in Python is of type 'list'. A list is also a sequence type, like a string, though it can have elements other than characters in the sequence. Because sequences are collections, a list is also a collection. Lists are indicated with square brackets ([ and ]), and their contents are separated by commas. Example: [4, 3.57, 'abc']
Literals
A literal is a notation for representing a fixed value—a value that cannot be changed in the program.
Sequence
A sequence is a collection where there is an order associated with the elements. For example, a string is a sequence because the order of the characters is important.
Set type
A set in Python is of type 'set'. A set is a collection of unique elements—similar to a set in mathematics. Sets, like dictionaries, use curly braces, but unlike dictionaries there are no colons. A set supports mathematical set operations such as union and intersection. Example: {1,3,5}
Side effect
A side effect is some change that results from executing the statement.
Statement
A statement does not return a value, but does perform some task. Some statements may control the flow of the program, and others might ask for resources; statements perform a wide variety of tasks. >>> my int = 5 # statement , no return value but my int now has value 5 >>> my int 5
String type
A string in Python has the type 'str'. A string is our first collection type. A collection type contains multiple objects organized as a single object type. The string type is a 'sequence'. It consists of a collection of characters in a sequence (order matters), delimited by single quotes (' ') or double quotes (" "). For example, "This is a string!" or 'here is another string' or even a very short string as "x".
Variables
A variable is a name you create in your program to represent "something" in your program. That "something" can be one of many types of entities: - a value (an integer, a string, a floating-point number, and so on) - another program to run - a set of data - a file Variables should have meaningful names, because the purpose of a good variable name is to make your code more readable. Once a variable is created, you can store, retrieve, or modify the data associated with that variable. Every time you use your variable in a program, its value is retrieved by Python and used in that variable's place. Thus, a variable is really a way to make it easier to read the program you are writing.
'if-else' Statement
A variation on the basic 'if' statement adds the ability to execute one suite of statements if the decision Boolean is (True) or to execute a different suite of statements if the Boolean expression is (False). Note that there are two statements and two suites here: the suite associated with the 'if' and the suite associated with the 'else'. Also note that the 'if' and 'else' are at the same indentation; the 'else' is not part of the 'if' suite, but together they create an 'if-else' compound statement. The if-else statement operation is as follows: 1. Evaluate boolean expression to yield True or False. 2. If boolean expression yields (True), (a) Execute the 'if suite', indented under the 'if'. (b) Continue with the rest of the Python program. 3. If boolean expression yields (False), (a) Execute the 'else suite', indented under the 'else'. (b) Continue with the rest of the Python program.
While loops
Also know as a 'pre-test' loop -Tests the loop condition BEFORE it runs •May never run if the condition is false to start with •Like decisions, an iteration 'block' has 2 parts -Header While <condition>: -Body •Code within the loop, must be indented
Assignment
Assignment is one way to create a name for a variable. The purpose of assignment is to associate a name with a value. The symbol of assignment for Python is the equal sign (=). N.B. This is not the same as in maths, where the equal sign (=) denotes equality. In Python, the equal sign (=) represents assignment. Assignment is the operation to associate a value with a variable. The left-hand side represents the variable name and the right-hand side represents the value. Example: my_var = my_var + 1 We interpret the previous statement as follows: - get the value referred to by my_var, add 1 to it, and then associate the resulting sum with the variable my_var. That is, if my_var's value was 4, then after assignment, its value will be updated to be 5.
Naming types
Because the type information is not part of the variable, it is often helpful to help keep track of types by affixing the type name to their variables, such as my_int,b_float, phone_book_dict.
For loops
Before we start the loop, we set the value of the variable that is used as the counter -On each iteration the value of variable increases by one, until it is equal to end -On the last iteration the value of variable will be end •E.g. For count in range (10): Print(str(count)) Will display the numbers 1,2,3,4,5,6,7,8,9 and 10 One after the other
Assignment statement
Evaluation of an assignment statement is a two-step process: 1. Evaluate the expression on the right-hand side. 2. Take the resulting value from the right-hand expression and associate it with the variable on the left-hand side (create the variable if it doesn't exist; otherwise update it). For example: my_var = 2 + 3 * 5 First evaluate the expression on the right-hand side, resulting in the value 17 (remember, multiplication before addition), then associate 17 with my_var, that is, update the namespace so that my_var is an alias for 17 in the namespace.
Getting values in Python
Existing Python function: -variableName = input(prompt) •Displays prompt (whatever it's value) and then gets a value from the keyboard. This value will be stored in variableName
Floating-Point Numbers
Floating-point or real numbers are designated in Python as type 'float'. The floating-point type refers to non-integer numbers—numbers with decimal points. Floats are created either by typing the value, such as 25.678, or by using exponential notation, with the exponent represented by an "e." Thus, 2.99 × 108 is written as 2.99e8 and 9.109 × 10−31 can be written as 9.109e-31. N.B. Floats represent Real numbers, but only approximately! Examples: >>> 2.0 / 3.0 0.6666666666666666 >>> 1.1 + 2.2 3.3000000000000003 >>> 0.1 + 0.1 + 0.1 - 0.3 5.551115123125783e-17 >>> If you were to do the calculations yourself on paper, you would find that 1.1+2.2 is equal to 3.3. However, the session shows it is 3.3000000000000003. Same for the last addition. The result should be zero but Python returns a very small value instead. Approximations like this, if carried through multiple evaluations, can lead to significant differences than what is expected. Python does provide a module called the 'decimal' module that provides more predictable, and controllable, results for floating-point numbers. It is important to remember that floating-point values are approximate values, not exact, and that operations using floating-point values yield approximate values.
Syntax errors
How do we identify them? -Run code •How do we find them? -READ error messages •No, really, READ them! •How do we fix them? -Practice and familiarity •Build up a dictionary of commons errors and their fixes
Logic errors
How do we identify them? -Test, test and test again -Incorrect results indicate logic errors -What makes good test data? •KNOWN results •(otherwise what are you comparing it to?) •How do we find them? -Debugging •How do we fix them? -Modify code
Object type
In Python, and in many other languages, each object is considered an example of a type. For example, 1, 27, and 365 are objects, each of the same type, called int (integer). Knowing the type of an object informs Python of two things: 1. Attributes of the object tell us something about its ''content.'' For example, there are no decimal points in an integer object, and there are no letters in either an integer object or a float object. 2. Operations we can perform on the object and the results they return. For example, we can divide two integer objects or two float objects, but the division operation makes no sense on a string object.
Variable creation
In Python, when a name is first used (assigned a value, defined as a function name, etc.) is when the name is created. Python updates the namespace with the new name and its associated value.
Variables
In contrast to literals, variables are symbols that can be assigned a value, and that value can be modified during the execution of the code.
Indentation
Indentation is used by all programmers to make code more readable. - Programmers often indent code to indicate that the indented code is grouped together, meaning those statements have some common purpose. - However, indentation is treated uniquely in Python. - Python requires it for grouping.
Slicing strings
Indexing also allows selection of subsequences of the string with the proper indices. Python calls such a subsequence a slice. Remember, just like for a single index, a slice returns a new string and does not change the original string in any way. To index a subsequence, you indicate a range of indices within the square bracket by providing a pair of indices separated by a colon (:). Example: >>> hello str = 'Hello World' >>> hello_str[6:10] 'Worl' >>>
Compound statement
Is considered to be one logical statement. Indentation is used to indicate that the indented statements following the 'if' are associated with that 'if'. Consists of the 'if' keyword which is part of the header and the set of indented statements is called the 'suite'. All headers end with a colon (:) A suite of statements is a set of statements that has the same indentation and these statements are executed as a group.
Keywords
Keywords are special words in Python that cannot be used by you to name things. They indicate commands to the Python interpreter. Examples: - print, if, import, while, and, not, True, False, def, return etc.
Runtime errors
Often linked to 'types' of data -Eg we read a value from the keyboard into an Integer and then double it •What if the user types in a word? •How do we fix them? -For now - ignore them -Eventually •Limit user inputs with drop-down box
Order of operations and parentheses
Operator Description ( ) Parentheis * * Exponentiation +x, -x Positive, Negative *, /, %, // Multiplication, Division, Remainder, Quotient =, - Addition, Subtraction ● Remember, parentheses always takes precedence
Operators
Operators are special tokens (sequences of characters) that have meaning to the Python interpreter. Using them implies some operation, such as addition, subtraction, or something similar. Examples: +, -, /, //, <, >, %, & etc.
Precedence of relational operators
Precedence & associativity (order) of relational operators: highest to lowest. Operator Description () parentheses (grouping) ** exponentiation +x, -x positive, negative *,/,%,// multiplication, division, remainder, quotient +,- addition, subtraction <, <=, >, >=, !=, == Comparisons not x Boolean NOT and Boolean AND or Boolean OR
Print statement
Print is a function that performs a much-used operation—printing values to the Python shell. - Printable elements are placed in the parentheses after the print statement. - If the element being printed is quoted, it is printed exactly as it appears in the quotes; if the element is a variable, then the value associated with the variable is printed. - Each object (string, variable, value, etc.) that is to be printed is separated from other objects by commas.
Best practice for naming variables
Pro-tip: Good identifier naming is very important for producing quality code •100% of the identifiers in a program must be meaningful -Variable names, function names, function arguments, ... Best-practice suggestions: -Don't be cute, don't use abbreviations -Use intention-revealing names -Avoid names that imply something that isn't true -Use pronounceable names -Avoid mental mapping
Refactoring
Pro-tip: Refactor, refactor, refactor, ... •It's common to create code and "just get it working" -But imagine looking at your code in six-months' time! -You will have no idea what it means •A best-practice strategy is called refactoring -Each time you work on your code look for ways to improve its readability -And change it!
Punctuators
Punctuators, a.k.a. delimiters, separate different elements in Python statements and expressions. Examples: ( ) [ ] @ : ; , = \ # etc.
Fractions
Python also provides the type 'fraction' for rational numbers. A fraction consists of the obvious two parts: the numerator and the denominator. Fractions do not suffer from the conversion of a rational to a real number, as discussed previously, and can be operated on without loss of precision using addition, subtraction, multiplication, and division.
Whitespace
Python counts as whitespace the following characters: space, tab, return, linefeed, formfeed, and vertical tab. Python has the following rules about how whitespace is used in a program: - Whitespace is ignored within both expressions and statements. For example, Y=X+5 has exactly the same meaning as Y = X + 5. - Leading whitespace, whitespace at the beginning of a line, defines indentation. Indentation plays a special role in Python (see the following section). - Blank lines are also considered to be whitespace, and the rule for blank lines is trivial: blank lines are allowed anywhere and are ignored.
Function
Python function: - Represents a single operation to be performed - Takes zero or more arguments as input - Returns one value (potentially a compound object) as output
Types of Python variables
Python has many types... Type. The values it has int. All whole numbers (..., -3, -2, -1, 0, 1, 2, 3, ...) float. Some real numbers (...,-2.73,-1.0,-0.5,0.0,0.5,3.1415, ...) str Any sequence of characters ('hello world', 'answer', ...) list A collection of objects ... ...
'indexing' operator
Python lets us look at the individual characters in the string sequence using the indexing operator, represented by the square brackets operator [ ]. Python also allows indexing from the back end of the sequence. Thus, if you want to index from the string end, Python starts indexing the last character of the string with -1 and subtracts one from the index for each character to the left. >>> hello str = 'Hello World' >>> hello str 'Hello World' >>> hello str[0] # counting s t a r t s at zero 'H' >>> hello str[5] ' ' >>> hello str[-1] # negative index works back from the end 'd' >>> hello str[10] 'd'
Namespace
Python makes a list of names (variables, but other names as well) that are being used right now in the Python interpreter. The interpreter maintains a special structure called a namespace to keep this list of names and their associated values.
Continuation
Python provides ways to make long lines more readable by splitting them. Such splitting is called a continuation. If a single statement runs long, that statement can be continued onto another line (or lines) to help with readability. That is, a continued line is still a single line, it just shows up over multiple lines in the editor. You indicate a continuation by placing a backslash character (\) at the end of a line. Multiple-line expressions can be continued similarly. In this way, a long line that may be difficult to read can be split in some meaningful and readable way across multiple lines.
Whitespace indentation
Python requires consistency in whitespace indentation. If previous statements use an indentation of four spaces to group elements, then that must be done consistently throughout the program.
Augmented Assignment Operators
Python, like other languages, has shortcuts for operations—especially groups of operations—that are used repeatedly. The shortcut make typing easier and, at some point, make the code shorter and easier to read. Our first shortcut is the combination of an integer operation and the assignment sign (=). Shortcut Equivalence my_int += 2 my_int= my_int + 2 my_int -= 2 my_int = my_int - 2 my_int /= 2 my_int = my_int / 2 my_int *= 2 my_int = my_int * 2
Naming objects
Rules for naming: 1. Every name must begin with a letter or the underscore character ( _ ): - A numeral is not allowed as the first character.3 - Multiple-word names can be linked together using the underscore character ( _ ) e.g. monty_python_holy grail. A name starting with an underscore is often used by Python to denote a variable with special characteristics. You will see these as we go along, but for now it is best to not start variable names with an underscore until you understand what that implies. 2. After the first letter, the name may contain any combination of letters, numbers, and underscores: - The name cannot be a keyword - Delimiters, punctuation, or operators cannot be used in a name. 2 ibid1. 3. A name can be of any length. 4. UPPERCASE is different from lowercase: my_name is different than my_Name or My_Name or My_name.
Augmented assignment
Shortcuts can be distracting, but one that is often used is augmented assignment: ● combines an operation and reassignment to the same variable ● useful for increment/decrement Shortcut Equivalence num += 2 num = num + 2 num -= 2 num = num - 2 num /= 2 num = num / 2 num *= 2 num = num * 2
String Representation
Single-character strings, like all other data, are represented in a computer as numbers. The individual characters are stored in a special computer representation know as Unicode (UTF-8 is the Unicode default for Python 3). UTF-8, and any Unicode set in general, maps each character to an integer. By "map," we mean that in the UTF-8 set, each character is associated with a particular integer value. That integer is what gets stored in a computer, and Python labels its type as str. Example: Character Dec 'a' 97 'A' 65 @ 32 \ 92 'u' 117 'U' 85
Extended Slicing
Slicing allows a third parameter that specifies the step in the slice. This means that you can have as many as three numbers in the index operator brackets separated by two colon characters: the first number is the beginning of the sequence, the second number specifies the end of the sequence, and the third is the step to take along the sequence. If not indicated, the step number has a default of 1. Examples: >>> hello str = "Hello World" >>> hello str[::2] # every other l e t t e r in the slice 'HloWrd' >>> hello str[::3] # every third l e t t e r 'HlWl' >>> hello str[::-1] # step backwards from the end to the beginning 'dlroW olleH' >>> hello str[::-2] # backwards , every other letter 'drWolH' >>> >>> digits = "0123456789" >>> digits[::2] # even digits (default start at 0; skip every other ) '02468' >>> digits[1::2] # odd digits (start at 1; skip every other ) '13579' >>> digits[::-1] # reverse digits '9876543210' >>> digits[::-2] # reverse odds '97531' >>> digits[-2::-2] # reverse evens (start with 2nd last letter ) '86420'
The Triple-Quote String
Special kind of string denoted by triple quotes, as in '''Hello World'''. This, too, is a string, but it has one special property. This string preserves all the format information of the string. If the string spans multiple lines, those carriage returns between lines are preserved. If there are quotes, tabs, any information at all, it is preserved. In this way, you can capture a whole paragraph as a single string. Here is an example from The Zen of Python: zen_str = '''Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated.'''The
Strings as a Sequence
String objects are defined as a sequence of characters. Therefore, 'Hello World' is a sequence of 11 characters—remember that a space is a character. Because a sequence has an order, we can number the characters by their position in the sequence: characters H e l l o W o r l d index 0 1 2 3 4 5 6 7 8 9 10 ..... -2 -1 This position is called the index of the character within the string. In Python, and other languages as well, the first index (the first position) in a sequence is index 0.
Structure of for loops
Structure for i in range(5) print("I am wonderful") •Index variable is automatically set to zero •The first time through the loop our index has the value of 0. Next iteration it will be 1 then 2 then 3, etc. •After all the statements in the loop are executed, the control flows back to the start of the loop and checks that the index variable is still within the given range •If the condition is true, the statements in the body of the loop are executed again •If the condition is false, the control exits the loop and goes to the next section of code. Pseudocode total = 0 For i = 1 to 10: total = total + i Next i display total Python total = 0 For i in range(10): total = total + i print(str(total))
Structure of While loops
Structure while <condition>: <code goes here> •Program enters the while statement and evaluates the condition •If the condition for the loop is true then the program executes the statements in the body of the loop •After all the statements in the loop are executed, the control flows back to the start of the loop and checks the loop condition again •If the condition is true, the statements in the body of the loop are executed again •If the condition is false, the control exits the loop and goes to the next section of code
Syntax vs Logic Errors
Syntax errors are usually easy to find -Python IDE will tell you which line (or close) is wrong! •Logic errors can be sneaky -Which is why modern programming environments provide debuggers •Both are corrected by modifying code -Either to fix the syntax, or to use the correct logic
'import' function
The 'import' command allows Python to load modules into a program.
'while' statement
The 'while' statement allows us to repeat a suite of Python code as long as some condition (Boolean expression) is True. When the condition becomes False, repetition ends and control moves on to the code following the repetition. A 'while' statement is structurally similar to an 'if'. It consists of a header (which has the loop condition) and a 'suite' of statements. We can repeatedly execute the while suite as long as the associated condition is (True). The condition is, as was true with selection, a Boolean expression. We evaluate the condition and, if the condition is (True), we evaluate all of the 'while suite' code. At the end of that suite, we again evaluate the condition. If it is again True, we execute the entire suite again. The process repeats until the condition evaluates to False. The 'while loop' contains a Boolean decision that can be expressed in English as:
Readability
The benefit of indentation is readability. Python's whitespace indentation forces readability.
'id' function
The function 'id' returns the ID number of any object. The ID number is a system-dependent ID number. That number will be different from session to session or machine to machine. Example: >>> a_int = 7 >>> id(a_int) 16790848 >>> b_float = 2.5 >>> id(b float) 17397652 # note the two di f f e r e n t ID' s >>> a_int = b_float # associate a_int with value of b_float >>> id(a_int) 17397652 # a_int has the same ID as b_float
'type' function
The function 'type' returns the type of any object. >>> a_int = 7 >>> type(a_int) # a_int contains a type 'int' <class 'int'> >>> b float = 2.5 >>> type(b_float) # b_float contains a type 'float' <class 'float'> Most important, the type of an object has nothing to do with the variable name; instead it specifies only the object with which it is associated. >>> a_int = b_float # assign a_int with value of b_float >>> type(a int) <class 'float'> # a_int contains a type 'float'
Integers
The integer type is designated in Python as type 'int'. The integer type corresponds to our mathematical notion of integer. In Python, integers can grow to be as large as needed to store a value, and that value will be exact, but really big integers can be slower to operate on.
Modulus Operator
The modulus operator (%) give the integer remainder of division: ● 5 % 3 yields 2 ● 7.0 % 3 yields 1.0 Again, the type of the result depends on the types of the operands.
Assignment
The operation to associate a value with a variable. Python uses the equal sign '=' to represent assignment. LHS = RHS Step 1: Evaluate the RHS (Right Hand Side) to get a value. Step 2: Associate that value with the variable named on the LHS (Left Hand Side). The LHS represents the variable name and the RHS represents the value.
Two types of division
The standard division operator (/) yields a floating point result no matter the type of its operands: ● 2 / 3 yields 0.6666666666666666 ● 4.0 / 2 yields 2.0 ● Integer division (//) yields only the integer part of the divide (its type depends on its operands): ● 2 // 3 yields 0 ● 4.0 // 2 yields 2.0 ● 7 / 2 yields 3.5 (float) ● 7 // 2 yields 3 (int)
'for' Statement
The variable an element is a variable associated with the for loop that is assigned the value of an element in the collection. The variable an element is assigned a different element during each pass of the for loop. Eventually, an element will have been assigned to each element in the collection. The variable collection is a collection that has an associated iterator that acts as the source of elements. The keyword in precedes the collection. Like the 'if' and 'while' statement, the 'for' statement has a header and an associated suite. for element in collection: # for suite As with a 'while' loop, the entire for suite is evaluated during each pass of the loop. One can therefore perform operations on each element of a collection in a very straightforward way.The for loop completes when the last of the elements has been evaluated by the suite.
Object
● In Python, every 'thing' in the system is an OBJECT ● An OBJECT has: ● An identity ● some attributes ● Zero or more names ● Whenever an object is created (instantiated) by Python, it receives an identification number, ID. ● The ID number is used by python to distinguish one object from another ● The ID number is system-dependent; it will differ from session to session or machine to machine. ● The id( ) function used to find an objects ID number: >>> num1 = 7 >>> id(num1) 16790848 >>> num2 = 2.5 >>> id(num1) 7397652 ● An object can also have a name or multiple names. The name is not part of the object's ID. It is used by programmers to make code more readable. ● Python uses the namespace to associate a name (e.g. a variable name) with an object. ● Attributes are information about the object: ● type ● methods ● names of any values stored in the object In Python, every 'thing' in a program is considered to be an object. Some attributes - information about the object; e.g. type, such as int, float, str or Boolean; type tells Python which operations can be used with an object and the results they return. The type function returns the type of any object. >>>print(type("David")) yields <class 'str'>
Naming Python variables
Variable names in Python follow the alphanumeric style •The rules of the style are: -A variable name may contain any letters (uppercase or lowercase), digits (0 to 9), and the underscore character -A variable name cannot start with a digit •Examples: _name = "bob" theAnswer = 42 my_pets_name = "bonbon"
Displaying variables
We can easily display a single thing using the 'print()' statement. •What if we want something more complex? -For example: •"The sum of 3 and 12 is 15" We can join things together in a string using 'concatenation', another word to add to our vocabulary -In planning we use '+' to indicate this: •display "The sum of " + num1 + " and " + num2 " is " + num3 -The Python symbol is + as well •print("The sum of " + str(num1)+ " and " + str(num2) " is " + str(num3)) -OR •print("The sum of", num1, "and", num2, "is", num3)
Mixed Types
What is the difference between 42 and 42.0 ? ● their types: the first is an integer, the second is a float What happens when you mix types: ● done so no information is lost 42 * 3 -> 126 42.0 * 3 -> 126.0
Testing code
Why? •We (should) have already checked our design, so we know it works -So why do we need to make sure the code works? •We need to check that we implemented our solution correctly How? •Try running it, see what happens •If and when error messages appear READ THEM! -Right now they may seem unhelpful, but we will become familiar with them over time What are we testing? That it runs -Syntax errors •That it gives the correct results -Logic errors •Are there any user inputs which break the program -Runtime errors
package
a collection of modules Example: from kivy.app import App - this gets 'app' from 'kivy' 'kivy' is the package and 'app' is one module within that package App is a 'class'
If statement
an 'if' statement has a Boolean expression (or condition) that is evaluated, and the result of that Boolean expression dictates what happens next. 'if' boolean expression: # if suite(code executed if True) The basic 'if statement' allows you to do the following: 1. Evaluate boolean expression, yielding either (True) or (False). 2. If boolean expression yields (True), (a) Execute the Python suite of code indented under the if, the 'if suite'. (b) Once the indented code is executed, continue with any Python code after the indented code (that is, any code following the 'if' at the same indentation as the 'if' itself ). 3. If boolean expression yields (False), (a) Ignore any code indented under the if, (that is, do not execute it). (b) Continue with any Python code after the indented code (that is, any code following the if at the same indentation as the if itself ).
Non-Printing Characters
carriage return \n tab \t Example: >>> print(" first line \n second line") first line second line
math module
import math >>> print(math.pi) # constant in math module >>> print(math.sin(1.0)) # a function in math >>> help(math.pow) # help info on pow
Assignment example
my_var = my_var + 1 The process is to evaluate everything in the expression on the right-hand side, get the value of that expression and assign it to the name on the left-hand side.
String methods
name = "David" name.upper() name.lower() name.capitalize() name.count() name.isalpha() Note: --> the parenthesis ( ) at the end of the method
Explicit type conversion
● A character '1' is not an integer 1. ● You need to convert the value returned by the input command (characters) into an integer ● int("123") yields the integer 123 >>> age = int(input("Age:")) input function creates a string, then the int converts the string to integer type
Methods
● A method is a variation on a function: --> it has a name --> it has a list of arguments in parentheses ● However, methods differ in the way they are invoked ● every method is called in conjunction with a particular object ● The methods that can be used in conjunction with an object depends on the object's type ● The invocation is done using the dot ( . ) notation
Module
● A module is a file containing programs to solve particular problems; e.g., the math module Modules are files that can be imported into your Python program. ● use other, well proven code with yours Example is the math module ● we import a module to use its contents ● we use the name of the module as part of the content we imported
The memory model for Python is:
● A program contains variables and objects: --> A variable is a label that is assigned to one object --> An object holds a value, and every value has a type ● We can visualise the memory model as a diagram
Python name conventions
● All names must begin with a letter or underscore _: --> Ab_123 is OK, but 123_ABC is not. ● may contain letters, digits, and underscores: --> this_is_an_identifier_123 ● may be of any length ● upper and lower case letters are different: Length_Of_Rope is not length_of_rope ● names starting with _ (underline) have special meaning. Be careful!
Naming indices
● Exception to best practice: --> letters 'i', 'j' & 'k' which are industry standard defaults for 1st, 2nd & 3rd indices: >>> for i in range(5): print(i)
Types
● In Python, each OBJECT is an example of a TYPE. ● The TYPE of an object determines two things: 1. ATTRIBUTES - its content 2. Operations that can be performed on the object ● The type( ) function returns the type of any object: >>> num1 = 7 >>> type(num1) <class 'int'> >>> num2 = 2.5 >>> type(num2) <class 'float'> ● Some Python types: ● int --> integer ● float --> floating-point numbers ● bool --> Boolean ● A collection type contains multiple objects organised as a single object type. ● collection types: ● str --> string ● list --> list ● dict --> dictionary ● set --> set Note: ● Strings & lists are collections that are ordered and are known as sequences
Python name conventions more
● Names for variables and functions start with a lowercase letter and use lower_with_under: --> my_list --> square_root_function ● Classes start with upper case letter and use Pascal case: class FoodItem(Product): ● Constants use all UPPERCASE: MINIMUM_ALCOHOL_THRESHOLD = 0.00 # class attribute
Dynamically typed language
● Python is a dynamically typed language ● Python does not require you to pre-define what type can be associated with a variable: age = 13 is an integer name = "David" is a string numbers = [1, 2, 3] is a list ● What type a variable holds can change ● Nonetheless, knowing the type can be important for using the correct operation on a variable. Thus proper naming is important! print(type(age)) returns <class 'int'>
Strongly typed language
● Python is a strongly typed language: >>> age = 13 >>> name = "David" >>> age + name returns TypeError: unsupported operand type(s) for +: 'int' and 'str'
What is a type?
● a type in Python essentially defines two things: --> the internal structure of the type (what it contains) --> the kinds of operations you can perform ● 'abc'.capitalize() is a method you can call on strings, but not integers ● some types have multiple elements (collections),
Example naming
● distance_in_metres reveals its intent better than distance ● using d to map to the concept of distance is even worse ● monthly_rainfall is more pronounable than mthly_rfall ● game_over is a poor name to represent that a game is running, since it implies another more obvious meaning ● However, is_game_over is a good name for a Boolean i.e. Y or N ● It's standard industry practice to use variable names such as i j inside loop constructs: for i in range(start, end): print(i)
Type conversion
● int(some_var) returns an integer ● float(some_var) returns a float ● str(some_var) returns a string ● should check out what works: - int(2.1) -> 2, int('2') ->2, but int('2.1') fails - float(2) -> 2.0, float('2.0') -> 2.0, -> float('2') -> 2.0, float(2.0) -> 2.0 - str(2) -> '2', str(2.0) -> '2.0', str('a') -> 'a'
Python "types"
● integers: 5 ● floats: 1.2 ● booleans: True ● strings: "anything" or 'something' ● lists: [] ['a',1,1.3] ● dictionaries: {} ['Jane': 23, 'Alan': 39] ● classes: class Shape: ● exceptions: NameError ● others we will see
dot ( . ) operator
● the dot operator indicates that object on the right of dot is a member of object on the left Example: from kivy.app import App 'app' is a module within 'kivy' which is a package
Constructing New Values
There are also some operations associated with the type itself. One of the most useful of those operations is the constructor. A constructor is a special operation that is used to make a particular object of that type. Each type has an associated constructor: the constructor's name is the name of the type (int, float, str, . . .). If no value is provided within the parentheses, then a default value of that type is provided (for int it is 0; for float it is 0.0, for str it is ''). If a value is provided in the parentheses, then the constructor will convert that value to a new object of the specified type if it can. Thus, constructors can be used to convert one object to a new object of a different type. You have already seen conversion in examples: int(my_var) returns an integer representation of the object associated with my_var. - Note my_var itself is unaffected. The object associated with my_var is provided to the function int, a new object is created, the my_var object is converted to an int, and that new, converted object is returned. - If the object associated with my_var cannot be converted to an integer (say, the value ""), then an error will occur. float(my_var) returns a floating-point representation of the object associated with my_var. As with int, if the object cannot be converted to a floating-point number, then an error will occur. str(my_var) returns a string representation of the object associated with my_var. It is again important to note that 1 and "1" are very different. 1 is the integer 1. "1" is the character digit that gets typed on a keyboard.
Tokens
These are special keywords, symbols, and characters that can be used in a Python program. These special language elements are known generically as tokens. Examples: - keywords, operators, punctuators & delimiters and literals
Three options for importing modules
This affects how you call functions from the module: >>> import math #everything in math is accessible, must use fully-qualified name: math.pi >>> from math import pi #only pi is accessible, don't need module name, just: pi >>> from math import * #everything is accessible, don't need module name, just: pi
While loops for error checking
This is a very standard error checking loop. You will need to use code like this very often in your programs. Pseudocode get value from user while value is less than zero: print an error display prompt get value display value Python code num = input ("Enter a number") while num < 0: print("Number is too small") num = input("Enter a number") print(str(num))
Python Variables
To get a variable in Python we just need to type the variable name and assign it a value with the '=' symbol (assignment operator) -We do not need to tell the computer the variable's data type -The variable's type will be determined by what type of value we store in it -We assign a value to a variable by saying: height = 1.65 message = "Hello World!" -Note that the equal sign here is not the same as in math. This is not an equation where both sides are equal -We are assigning a space in memory called height with the value 1.65 and a space called message with a greeting
