Week 1-5 Flashcards

Question

What would a literal statement look like?

Answer 1

myNumber = 15 | myNumber is a variable and 15 is a literal.

Answer 2

variableName = expression.

Answer 3

this means "save to" or "assign to", which is used to attach an expression to a variable. **it does not mean equals to****

Answer 4

- load the value of x from memory. - subtract 2 from that value. - save the number 3 into the number 3 into the number you just calculated.

Answer 5

It is important to note that the program runs one line at a time from start to finish. There are no automatic actions, everything is specified.

Answer 6

- must begin with a letter or underscore. - may contain numbers. - are case sensitive. - is not one of Python's reserved keywords.

Answer 7

The print statement; | print( "hello world" )

Answer 8

A string is a data type, defined as a sequence of characters contained between a pair of quotation marks. Note that characters can have letters, number or symbols, but they are always read as text.

Answer 9

my_name | myName

Answer 10

Boolean Values Integer Numbers Real Numbers Strings

Answer 11

boolean - true or false

Answer 12

int - numbers without decimals

Answer 13

float - numbers with decimals

Answer 14

str - characters enclosed in quotes

Answer 15

Absolutely not

Answer 16

Order of operations

Answer 17

1: () brackets trump all 2: ** exponents 3: - negation 4: * multiplication 4: / division 4: // integer division 4: %modulo (remainder) 5: + addition 5: - subtraction ** NOTE that there are many on the 4th and 2 on the 5th line of importance.. They have equal importance and are read from left to right **

Answer 18

``` > Greater than >= Greater than or equals < Less than <= Less than or equals == Equal to != Not equal to **ALWAYS TRUE OR FALSE** ```

Answer 19

ASCII Chart

Answer 20

This is true

Answer 21

Answer 22

Answer 23

a | not false | true true | false

Answer 24

not (a and b) = not(a) or not (b) | not (a or b) = not(a) and not (b)

Answer 25

``` + Concatenation * Repitition [n] Substring (slice) [m:n] Substring (slice) in Membership ```

Answer 26

+ | "hi" + "there" == "hithere"

Answer 27

* | "hi" * 2 == "hihi"

Answer 28

[n] | "hello" [1] Gives "e"

Answer 29

[m:n] | "hello" [1:4] Gives "ello"

Answer 30

``` 1 - String (slice, concatenation) 2 - Arithmetic and String repetition 3 - Relational & String membership 4 - Logical 5 - Assignment ```

Answer 31

ALWAYS USE BRACKETS

Answer 32

operators are symbols that represent functions, the data they work with are called operands.

Answer 33

3 and 5 are operands, + is the operator.

Answer 34

you use the plus sign (+) to join strings together.

Answer 35

Caution: integer division can act unexpectedly if one of the operands is negative - it will always round AWAY from 0. eg. -12//5 is -3

Answer 36

not, and, or... respectively

Answer 37

ABSOLUTELY NOT

Answer 38

if boolean-expressions: code block (if the boolean expression evaluates to true then the statements in the indented code block should be run.)

Answer 39

``` if boolean-expression: code block else: code block (this gives us a basic "this or that" decision making pattern) ```

Answer 40

``` if boolean-expression: code block elif boolean-expression: code block else: code block (you may have several elif statements with their own condition. the else statement can be left out if your logic doesn't require it.) ```

Answer 41

``` IF number is greater than 0 Then SHOW greater than 0 message ELIF number is equal to 0 THEN SHOW equal to 0 message ELSE SHOW less than 0 message ENDIF ```

Answer 42

if myNumber > 0: print( "My Number is bigger than 0:) if myNumber % 2 == 0: print( "My number is even too!" ) else: print( "My number is less than or equal to 0" )

Answer 43

When nesting make sure you indent one extra level.

Answer 44

Flow charts are more clear than pseudo code when dealing with IF statements

Answer 45

The circle is used to represent the start & finish of the flow chart. Start: 0 arrows in, 1 arrow out Finish: 1 or more arrows in, 0 arrows out

Answer 46

The rectangle is used to represent a code block in the flow chart. code block: 1 or more arrows in, 1 arrow out

Answer 47

The diamond is used to represent a boolean expression. | boolean expression: 1 or more arrows in, 2 arrows out

Answer 48

Code blocks are programming paragraphs, multiple statements put together.

Answer 49

a bug is when the program told the computer told to do something it couldn't do

Answer 50

the worst type of bug is one that doesn't crash, just give incorrect information. At least when a bug causes a crash you notice that there is a problem.

Answer 51

First you find the bug by tracking down where you gave the wrong information, then you need to figure out what the right instructions are, and then you need to update those instructions without introducing more bugs

Answer 52

It is either getting new features added or bugs fixed

Answer 53

Parenthesis

Answer 54

The operating system

Answer 55

A python interpreter

Answer 56

2 (53 divided by 24 = 2 with a remainder of 5) the "//" operator only displays the integer.

Answer 57

5 (53 divided by 24 = 2 with a remainder of 5) the "%" operator only displays the remainder.

Answer 58

Yes but the result is rounded down to the nearest whole number. eg. >>> 3.3 // 1 3.0

Answer 59

``` A binary operator is an operator that has two operands. eg. >>> -5 -5 >>> --5 5 >>> ---5 -5 ```

Answer 60

An overloaded operator

Answer 61

No, absolutely not. It's terrible and can cause many many problems in your code. Make sure you test and test and test to make sure it works as it should.

Answer 62

This code demonstrates that assigning to a variable does not change any other variable.

Answer 63

the answer is 14. (the right hand side does its process then the answer is multiplied by d because of the "*=" augmented assignment operator.)

Answer 64

Yes they are, both would give an answer of 100, because the "*=" is used to replace the first repetition of the LHS variable that occurs on the right hand side.

Answer 65

``` += : ( " x = x + 2 " equals " x += 2 " ) -= : ( " x = x - 2 " equals " x -= 2 " ) *= : ( " x = x * 2 " equals " x *= 2 " ) /= : ( " x = x / 2 " equals " x /= 2 " ) //= : ( " x = x // 2 " equals " x //= 2 " ) %= : ( " x = x % 2 " equals " x %= 2 " ) **= : ( " x = x ** 2 " equals " x **= 2 " ) ```

Answer 66

Syntax & Semantic

Answer 67

Syntax errors happen when you type something that isn't valid Python code.

Answer 68

Semantic errors happen when you tell Python to do something that it just can't do, like try to divide a number by zero or try to use a variable that doesn't exist.

Answer 69

1: Make sure your line break occurs inside parentheses. 2: Use the line-continuation character, which is a backslash, \. * * note that the backslash "\" is the line-continuation character, not the forward slash "/" which is the division symbol. **

Answer 70

the hashtag #

Answer 71

no, it can come after your statement. eg. >>> (212 - 32) * 5 / 9 # Convert 212 degrees.... 100.00

Answer 72

the abs function produces the absolute value of a number. eg. >>> abs( -9 ) 9

Answer 73

An argument is an expression that appears between the parentheses of a function call. eg. in "abs( -9 )", the argument is "-9"

Answer 74

the round function rounds a decimal or float number to a whole number or real number. eg. >>> round(4.3) 4

Answer 75

``` the pow function takes two numbers, and turns it into "first number" to the power of "second number". eg. >>> pow(2,4) 16 *2 to the power of 4 is 16* ```

Answer 76

the int function converts whatever the argument is, into an integer, truncating any decimal. eg. >>> int(-4.3) -4

Answer 77

the float function converts the argument into a decimal number. eg. >>> float(21) 21.0

Answer 78

use the built in function help. eg. >>> help(abs) Help on built-in function abs in module builtins: abs(...) abs(number) -> number Return the absolute value of the argument.

Answer 79

``` you use the id function. eg. >>> shoeSize = 8.5 >>> id( shoeSize ) 42985674 ```

Answer 80

``` aliasing is when two variable refer to the exact same object. eg. >>> i = 3 >>> j = 3 >>> k = 4 - 1 >>> id( i ) 4299456 >>> id( j ) 4299456 >>> id( k ) 4299456 ```

Answer 81

you use def to define, & return for the formula. eg. >>> def convertToCelsius(fahrenheit): return (fahrenheit - 32) * 5 / 9 >>> convertToCelsius(80) 26.66666666666

Answer 82

No, Local variables get created each time that fuction is called, and erased when the function returns. Because they only exist when the function is being executed, they can't be used outside of the function. Trying to do so causes an error.

Answer 83

``` >>> def quadratic( a, b, c, x ): first = a * x ** 2 second = b * x third = c return first + second + third ``` >>> quadratic( 2, 3, 4, 0.5 ) 6.0

Answer 84

The are of a program that a variable can be used in is called the variable scope. The scope of a local variable is from the line in which it is defined up until the end of the function.

Answer 85

The function must have the same amount of arguments as the parameters given when it was defined. eg. >>> quadratic( 1, 2, 3 ) Traceback (most recent call last): File "", line 1, in TypeError: quadratic() takes exactly 4 arguments (3 given)

Answer 86

End of line

Answer 87

an empty string

Answer 88

it returns the number of characters between the opening and closing quotes.

Answer 89

use single quotes for the full string and double quotes inside. or use the escape sequence \"

Answer 90

not if the string is using double quotes to open and close it. or use the escape sequence \'

Answer 91

``` \' : single quote \' : double quote \\ : backslash \t : tab \n : newline \r : carriage return ```

Answer 92

``` To span multiple lines you put ''' or """ (3 single or double quotes) around the string instead. eg. >>> '''one two three''' 'one\ntwo\nthree' ```

Answer 93

A WHILE loop runs as long as the condition is true.

Answer 94

The WHILE loop is a fundamental structure; we define other types of loops by comparing them to the WHILE loop.

Answer 95

The parts of the while loop are the initial state, the loop condition, the loop body and the post state.

Answer 96

``` GET a number from the user SET loop counter to 1 SET the message to blank LOOP IF loop counter <= input number THEN CONCATENATE message and loop counter INCREMENT loop counter OTHERWISE EXIT LOOP END IF END LOOP SHOW message to user ```

Answer 97

The most common error is that it does not run the number of times you want it to. It will run too many times, not enough, never, or forever. - 1 time too many or too few is often from using <= instead of instead of >=, or vice versa. - Never running is often from an incorrect initial condition. Infinite running is often from forgetting to guarantee that the loop condition eventually becomes false. *** Always check before coding***

Answer 98

Two techniques we can use to manage this problem are SENTINEL VALUES and BOOLEAN FLAGS.

Answer 99

Sentinel Values are values which cause the loop to exit and are often hinted at to the user in an input prompt. (e.g) choice = “” while choice != “Q” : choice = input( “Enter a value (or Q to quit): “ )

Answer 100

Boolean flags are variables which hold the result of a more complicated expression and should be used to clarify code or to reduce calculations. (e.g) decision = True while decision: number = int( input( “A number? “ ) ) decision = number * 3 < 20 and number % 5 == 0 if decision: print( “Go Again!” ) **Another useful example is when you want to write “while not decision” but don’t want to change your formula.**

Answer 101

The FOR loop’s way of operating with strings is to say “for each character in the string do something with it.”

Answer 102

The parts of the while loop are the initial state, the loop condition, the loop body and the post state.

Answer 103

It involves defining the different parts of the loop; | initial state, loop condition, loop body and post state.

Answer 104

``` GET a number from the user SET loop counter to 1 SET the message to blank LOOP IF loop counter <= input number THEN CONCATENATE message and loop counter INCREMENT loop counter OTHERWISE EXIT LOOP END IF END LOOP SHOW message to user ```

Answer 105

The FOR loop is especially useful for working with strings and lists.

Answer 106

The general form is: for variable in StringOrList: code-block

Answer 107

Although it is possible to modify the original variable the for loop is generally considered "read only".

Answer 108

Count how many times the letter e appears in a string. ``` myString = "This is my very nice string." eCount = 0 for character in myString: if ( character == "e" ) : eCount = eCount + 1 print( "There are" + str( eCount ) + \ "letter e's in your string." ) ```

Answer 109

Function "print" does not allow any styling of the output: no colors, no italics, no boldface. All output is plain text.

Answer 110

>>>print( "one\ttwo\nthree\tfour" ) one two three four *the \t symbol indicates the tab character and is used to lay values out in columns. The \n symbol indicates a new line in multiline string.*

Answer 111

a comma. (e.g.) >>>print( 1, 2, 3 ) 1 2 3

Answer 112

The print ends the current line, advancing to the next one. (e.g) >>>print() >>>

Answer 113

Yes. (e.g) >>>print( 1, "two", "three", 4.0 ) 1 two three 4.0

Answer 114

The separator parameter lets you choose how you want lists to be separated, it is set to a space by default. (e.g) >>> print( "a", "b", "c" ) #separator is a space by default. a b c >>> print( "a", "b", "c", sep=", " ) a, b, c

Answer 115

You use the keyword argument end="" to tell python to end with an empty string instead of a new line. (e.g) >>> print("a", "b", "c", sep= ", ", end="" ) a, b, c>>>

Answer 116

the input function returns whatever the user enters as a string, even if it looks like a number.

Answer 117

These statements involve a python type that is used to represent truth and falsehood to control the way the computer executes programs.

Answer 118

this type has only two values and three operators.

Answer 119

2, true or false

Answer 120

AND, OR, and NOT. NOT has the highest precedence, followed by AND and then OR

Answer 121

NOT is a unary operator: it is applied to just one value, like the negation in the expression -(3 + 2).

Answer 122

>>> not True false >>> not false True

Answer 123

``` AND is a binary operator; the expression left and right produces True if both left and right are True, and it produces False otherwise. >>> True and True True >>> False and False False >>> True and False False >>> False and False False ```

Answer 124

``` OR is also a binary operator. It produces True if either operand is True, and it produces False only if both are False. >>> True or True True >>> False or False False >>> True or False True >>> False or True ```

Answer 125

IFF stands for "if and only if" or "exactly when" the conditions are met will True be returned. It is implied that when those conditions aren't met the function will return False.

Answer 126

- Arithmetic operators have higher precedence than relational operators. "+ and / are evaluated before < or >" - Relational operators have higher precedence than Boolean. "< or > are evaluated before AND ,OR and NOT" - All relational operators have the same precedence.

Answer 127

You don't have to, but it's usually a good idea to put the parentheses in since it helps the eye find the subexpressions and clearly communicates the order to anyone reading your code.

Answer 128

You combine the comparisons with AND. (e.g) >>> x = 3 >>> ( 1 < x ) and ( x <= 5 ) True *** BUT this happens so often that python lets you chain the comparison (e.g) >>> x = 3 >>> 1 < x <= 5 True ***only chain comparisons when dealing with similar operators not < and != ***

Answer 129

Python treats 0 and 0.0 as false and all other numbers as true.

Answer 130

Python treats an empty string as False and all other strings as true.

Answer 131

When Python evaluates an expression containing AND or OR, it does so from left to right. As soon as it knows enough to stop evaluating, it stops, even if some operands haven't been looked at yet. This is called short-circuit evaluation.

Answer 132

In an OR expression, if the first operand is True, we know that the expression is True. Python knows this as well, so it doesn't even evaluate the second operand.

Answer 133

In an AND expression, if the first operand is False, we know that the expression is False. Python knows this as well, so it doesn't even evaluate the second operand.

Answer 134

It's possible to compare strings just as you would compare numbers. The characters in strings are represented by integers: a capital A, for example is represented by 65, while a space is 32, and a lowercase z is 172. So "_" < "A" < "z"

Answer 135

``` The " in" operator. (e.g) >>> "Jan" in "01 Jan 1838" True >>> "Feb" in "01 Jan 1838" False *The "in" operator produces True exactly when the first string appears in the second string, this is case sensitive.* ```

Answer 136

Yes, it will not run properly, and python will let us know with an error message.

Answer 137

The difference between the two is that ELIF is checked only when the IF condition above it evaluated to False, where the every if statement back to back would get checked even though only one can be true.

Answer 138

If the body of the first IF changes the value of a variable used in the second condition. (e.g) >>> if ph < 7.0: ph = 8.0 >>> if ph > 7.0: print( ph, "is acidic." ) 8. 0 is acidic. * now if that was an if/elif expression then the second condition would have been skipped even though the variable change from the first statement would have made the second true.*

Answer 139

``` If two conditions are related, by using multiple elif clauses. (e.g) >>> compound = input( "Enter the compound: " ) Enter the compound: CH4 >>> if compound == "H20": print( "Water" ) elif compound == "NH3": print( "Ammonia" ) elif compound == "CH4": print( "Methane" ) ``` Methane >>>

Answer 140

If none of the conditions in a chain of if/elif statements are satisfied and we want our program to print something we use an ELSE clause to print "this" if no conditions are met.

Answer 141

Any type of python statement even other IF statements.

Answer 142

A Nested IF statement.

Answer 143

``` Nested: young = age < 45 slim = bmi , 22.0 if young: if slim: risk = "low: else: risk = "medium" else: if slim: risk = "medium" else: risk = "high" ``` ``` Not Nested: young = age < 45 slim = bmi < 22.0 if young and slim: risk = "low" elif young and not slim: risk = "medium" elif not young and slim: risk = "medium" elif not young and not slim: risk = "high" ```

Answer 144

FOR loops are useful only if you know how many iterations of the loop you need. If you do not know how many loop iterations to execute then you will use a while loop.

Answer 145

the while loop is "keep looping while the expression evaluates true, only stop when the expression is false" making the length vary depending of many different things, while the for loop is "Loop for X amount of times then end loop". Use the FOR loop when you know how many loop intervals you need and WHILE loops when you do not.

Answer 146

``` You use the input function in a loop to make it interactive. (e.g) text = "" while text != "quit": text = input ( "Enter a word (or 'quit' to exit): " ) if text == "quit": print( "...now exiting" ) elif text == "H20": print( "water" ) elif text == "NH3": print( "Ammonia" ) else: print( "unknown" ) ``` >>> Enter a word (or 'quit' to exit): NH3 Ammonia >>> Enter a word (or 'quit' to exit): H20 Water >>> Enter a word (or 'quit' to exit): quit ...now exiting

Answer 147

FOR and WHILE loops execute all the statements in their body on each iteration, however sometimes it is handy to be able to break that rule. Python provides two ways of controlling the iteration of a loop: Break, & Continue.

Answer 148

``` A Break terminated the execution of a loop immediately. (e.g) text = "" while text != "quit": text = input ( "Enter a word (or 'quit' to exit): " ) if text == "quit": print( "...now exiting" ) break elif text == "H20": print( "water" ) elif text == "NH3": print( "Ammonia" ) else: print( "unknown" ) ``` ** only use if letting the loop run its course would cause an issue and terminating the loop at that exact time makes the most sense. **

Answer 149

No, a break only terminates the innermost loop in which its contained, this means that in a nested loop, a break statement inside the inner loop will terminate only the inner loop not both loops.

Answer 150

A continue statement causes Python to skip immediately ahead to the next iteration of a loop. All statements in the loop body that appear after it are skipped.

Answer 151

an int truncated

Week 1-5 Flashcards

(196 cards)