Programs consist of statements. A statement is a unit of executable code. Think of a statement like a sentence. In a nutshell, statements are how you do things in a program. Writing a program consists of breaking down a problem you want to solve into smaller pieces that you can represent as mathematical propositions and then solve. The statement is where this process gets played out. Statements themselves consist of some number of expressions involving data. Let’s see how this works.

An expression would be something like 2+2=4. This expression, however is not a complete statements. Ask Python to evaluate it and you will get the error “SyntaxError: can’t assign to operator”. What’s going on here? Basically we didn’t provide a complete statement. If we want to see the sum of 2+2 we have to write a complete statement that tells the interpreter what to do and what to do it with. The verb here is ‘print’ and the object is ‘2+2’. Ask Python to evaluate ‘print 2+2’ and it will show ‘4’. We could also throw in subject and do something a bit more detailed: ‘Sum=2+2’. In this case we are assigning the value of 2+2 to the variable, Sum. We can then do all sorts of things with Sum. We can print it. We can add other numbers to it, hand it off to a function and so on. For instance, might want to know the root of Sum. In which case we might write something like ‘print sqrt(sum)’ which will display ‘2’.

A shell is essentially a user interface that provides you access to a system’s features. Normally, this means access to an Operating System. In cases like this, the shell provides you access to the Python programming environment.

Anything preceed by a “#” is not interpreted or executed by the programming shell. Comments are used widely to document programs. One school of programming holds that code should be so clear that comments are uncessary.

Now that we’ve seen some variable assignments, let’s talk about best practices. First off, aside from reserved words, variable names can be almost any combination of letters, numbers and punctuation marks. You, however, should never ever, use the following punctuation marks in variable names:

• +
• –
• !
• @
• ^
• %
• (
• )
• .
• “
• ?
• /
• :
• ;

*

These punctuation marks tends to be operators and characters that have special meanings in most computer languages. The other issue is reserved words. What are “reserved words”? They are words that Python interprets as commands. Pythons reservers the following words.:

• True: A special value set aside for boolean values
• False: The other special value set aside for boolean vaules
• None: The logical equivalent of 0
• and: a way of combining logical conditions
• as: describes how modules are imported
• assert: a way of forcing something to take on a certain value. Used in debugging of large programs
• break: breaks out of a loop and goes on with the rest of the program
• class: declares a class for object oriented design. For now, just remember not to use this variable name
• continue: returns to the top of the loop and keeps on going again
• def: declares functions which allow you to modularize your code.
• elif: else if, a cotnrol structure we’ll see next lesson
• else: as above
• except: another control structure
• finally: a loop control structure
• for: a loop control structure
• from: used to import modules
• global: a scoping statement
• if: a control structure/li>
• in: used in for each loops
• is: a logical operator
• lamda: like def, but weird. It defines a function in a single line. I will not teach this becuase it is icky. If you ever learn Perl you will see this sort of thing a lot and you will hate it, but that’s just my personal opinion.
• nonlocal: a scoping command
• not: a logical operator
• or: another logical operator
• pass: does nothing. Used as placeholder
• raise: raises an error. This is used to write custom error messages. Your programs may have conditions which would be considered invalid based on our business situation. The interpreter may not consider them errors, but you might not want your user to do something so you ‘raise’ an exception and stop the program.
• return: tells a function to return a value
• try: this is part of an error testing statement
• while: starts a while loop
• with: a context manager. This will be covered in the course after the next one in this series
• yield: works like return

Putting together valid statements can be a little hard at first. There’s a grammar to them. Thus far, we’ve mainly been workign with expressions such as “x = x+1”. You can think of expression as nouns. We’ve clearly defined x, but how do we look inside? For that we need to give it a verb, the print command. We would then write “print x”. However we can skip the middle statement and print an expression such as “print x + 1”. The interpreter evaluates this per the order of operations I laid out earlier. However, once that expression is evaluated, it then applies the verb, “print”, to that expression.

Print is a function that comes with the Python distribution. There are many more and you can create your own. We’ll cover that a bit in next lesson. Let’s look at little more at the grammar of a statement. Consider:

x = sin(b)

Assume that b has been defined elsewhere. x is the subject, b is the object and sin is the verb. Python will go to the right side of the equal sign first. It will then go to the inside of the function and evaluate what’s there first. It then evaluates the value of the function and finishes by setting x to that value. What about something like this?

x=sin(x+3/y)

Python evaluates from the inside out according to the rules of operation. Very complex statements can be built up this way.