In this course we'll learn about the syntax of the Python programming language! We will go over fundamental commands that store variables, print messages, and perform mathematical operations.

Hello World

Python strings are very flexible, but if we try to create a string that occupies multiple lines we find ourselves face-to-face with a `SyntaxError`. Python offers a solution: [_multi-line_ strings](https://www.codecademy.com/resources/docs/python/strings?page_ref=catalog). By using three quote-marks (`"""` or `'''`) instead of one, we tell the program that the string doesn't end until the next triple-quote. This method is useful if the string being defined contains a lot of quotation marks and we want to be sure we don't close it prematurely.

```py
leaves_of_grass = """
Poets to come! orators, singers, musicians to come!
Not to-day is to justify me and answer what I am for,
But you, a new brood, native, athletic, continental, greater than
  before known,
Arouse! for you must justify me.
"""
```

In the above example, we assign a famous poet's words to a variable. Even though the quote contains multiple linebreaks, the code works!

If a multi-line string isn't assigned a variable or used in an expression it is treated as a comment.


Multi-line Strings

Python can also perform exponentiation. In written math, you might see an [exponent](https://www.codecademy.com/resources/docs/python/operators?page_ref=catalog) as a superscript number, but typing superscript numbers isn't always easy on modern keyboards. Since this operation is so related to multiplication, we use the notation `**`.

```py
# 2 to the 10th power, or 1024
print(2 ** 10)

# 8 squared, or 64
print(8 ** 2)

# 9 * 9 * 9, 9 cubed, or 729
print(9 ** 3)

# We can even perform fractional exponents
# 4 to the half power, or 2
print(4 ** 0.5)
```

Here, we compute some simple exponents. We calculate 2 to the 10th power, 8 to the 2nd power, 9 to the 3rd power, and 4 to the 0.5th power.


Exponents

Ironically, the first thing we're going to do is show how to tell a computer to ignore a part of a program. Text written in a program but not run by the computer is called a [comment](https://www.codecademy.com/resources/docs/python/comments?page_ref=catalog). Python interprets anything after a `#` as a comment.

Comments can: 

 * Provide context for why something is written the way it is:
```py
# This variable will be used to count the number of times anyone tweets the word persnickety
persnickety_count = 0
```

 * Help other people reading the code understand it faster: 
```py
# This code will calculate the likelihood that it will rain tomorrow
complicated_rain_calculation_for_tomorrow()
```

 * Ignore a line of code and see how a program will run without it:
```py
# useful_value = old_sloppy_code()
useful_value = new_clean_code()
```


Comments

The `+` operator doesn't just add two numbers, it can also "add" two strings! The process of combining two strings is called [_string concatenation_](https://www.codecademy.com/resources/docs/python/strings?page_ref=catalog). Performing string concatenation creates a brand new string comprised of the first string's contents followed by the second string's contents (without any added space in-between).

```py
greeting_text = "Hey there!"
question_text = "How are you doing?"
full_text = greeting_text + question_text

# Prints "Hey there!How are you doing?"
print(full_text)
```

In this sample of code, we create two variables that hold strings and then concatenate them. But we notice that the result was missing a space between the two, let's add the space in-between using the same concatenation operator!

```py
full_text = greeting_text + " " + question_text

# Prints "Hey there! How are you doing?"
print(full_text)
```

Now the code prints the message we expected.

If you want to concatenate a string with a number you will need to make the number a string first, using the [`str()` function](https://www.codecademy.com/resources/docs/python/built-in-functions/str?page_ref=catalog). If you're trying to `print()` a numeric variable you can use commas to pass it as a different argument rather than converting it to a string.

```py
birthday_string = "I am "
age = 10
birthday_string_2 = " years old today!"

# Concatenating an integer with strings is possible if we turn the integer into a string first
full_birthday_string = birthday_string + str(age) + birthday_string_2

# Prints "I am 10 years old today!"
print(full_birthday_string)

# If we just want to print an integer 
# we can pass a variable as an argument to 
# print() regardless of whether 
# it is a string.

# This also prints "I am 10 years old today!"
print(birthday_string, age, birthday_string_2)
```

Using `str()`  we can convert variables that are not strings to strings and then concatenate them. But we don't need to convert a number to a string for it to be an argument to a print statement.

Concatenation

Python offers a companion to the division operator called the modulo operator. The [modulo operator](https://www.codecademy.com/resources/docs/python/modulo?page_ref=catalog) is indicated by `%` and gives the remainder of a division calculation. If the number is divisible, then the result of the modulo operator will be 0.

```py
# Prints 4 because 29 / 5 is 5 with a remainder of 4
print(29 % 5)

# Prints 2 because 32 / 3 is 10 with a remainder of 2
print(32 % 3)

# Modulo by 2 returns 0 for even numbers and 1 for odd numbers
# Prints 0
print(44 % 2)
```

Here, we use the modulo operator to find the remainder of division operations. We see that `29 % 5` equals 4, `32 % 3` equals 2, and `44 % 2` equals 0.

The modulo operator is useful in programming when we want to perform an action every nth-time the code is run. Can the result of a modulo operation be larger than the divisor? Why or why not?


Modulo

Python offers a shorthand for updating variables. When you have a number saved in a variable and want to add to the current value of the variable, you can use the `+=` [(plus-equals) operator](https://www.codecademy.com/resources/docs/python/operators?page_req=catalog).

```py
# First we have a variable with a number saved
number_of_miles_hiked = 12

# Then we need to update that variable
# Let's say we hike another two miles today
number_of_miles_hiked += 2

# The new value is the old value
# Plus the number after the plus-equals
print(number_of_miles_hiked)
# Prints 14
```

Above, we keep a running count of the number of miles a person has gone hiking over time. Instead of recalculating from the start, we keep a grand total and update it when we've gone hiking further.

The plus-equals operator also can be used for string concatenation, like so:

```py
hike_caption = "What an amazing time to walk through nature!"

# Almost forgot the hashtags!
hike_caption += " #nofilter"
hike_caption += " #blessed"
```

We create the social media caption for the photograph of nature we took on our hike, but then update the caption to include important social media tags we almost forgot.

Plus Equals

Programming languages offer a method of storing data for reuse. If there is a greeting we want to present, a date we need to reuse, or a user ID we need to remember we can create a  [variable](https://www.codecademy.com/resources/docs/python/variables?page_ref=catalog) which can store a value. In Python, we [_assign_](https://www.codecademy.com/resources/docs/python/operators?page_ref=catalog) variables by using the equals sign (`=`).

```py
message_string = "Hello there"
# Prints "Hello there"
print(message_string)
```

In the above example, we store the message "Hello there" in a variable called `message_string`. Variables can't have spaces or symbols in their names other than an underscore (`_`). They can't begin with numbers but they can have numbers after the first letter (e.g., `cool_variable_5` is OK). 

It's no coincidence we call these creatures "variables". If the context of a program changes, we can update a variable but perform the same logical process on it.

```py
# Greeting
message_string = "Hello there"
print(message_string)

# Farewell
message_string = "Hasta la vista"
print(message_string)
```

Above, we create the variable `message_string`, assign a welcome message, and print the greeting. After we greet the user, we want to wish them goodbye. We then update `message_string` to a departure message and print that out.


Variables

Computer programmers refer to blocks of text as [strings](https://www.codecademy.com/resources/docs/python/strings?page_ref=catalog). In our last exercise, we created the string "Hello world!". In Python a string is either surrounded by double quotes (`"Hello world"`) or single quotes (`'Hello world'`).  It doesn't matter which kind you use, just be consistent.

Strings

Variables that are assigned numeric values can be treated the same as the numbers themselves. Two variables can be added together, divided by `2`, and multiplied by a third variable without Python distinguishing between the variables and _literals_ (like the number `2` in this example). Performing arithmetic on variables does not change the variable &mdash; you can only update a variable using the `=` sign.

```py
coffee_price = 1.50
number_of_coffees = 4

# Prints "6.0"
print(coffee_price * number_of_coffees)
# Prints "1.5"
print(coffee_price)
# Prints "4"
print(number_of_coffees)

# Updating the price 
coffee_price = 2.00

# Prints "8.0"
print(coffee_price * number_of_coffees)
# Prints "2.0"
print(coffee_price)
# Prints "4"
print(number_of_coffees)
```

We create two variables and assign numeric values to them. Then we perform a calculation on them. This doesn't update the variables! When we update the `coffee_price` variable and perform the calculations again, they use the updated values for the variable!


Changing Numbers

Computers absolutely excel at performing calculations. The "compute" in their name comes from their historical association with providing answers to mathematical questions. Python performs the [arithmetic operations](https://www.codecademy.com/resources/docs/python/operators?page_ref=catalog) of addition, subtraction, multiplication, and division with `+`, `-`, `*`, and `/`.

```py
# Prints "500"
print(573 - 74 + 1)

# Prints "50"
print(25 * 2)

# Prints "2.0"
print(10 / 5)
```

Notice that when we perform division, the result has a decimal place. This is because Python converts all `int`s to `float`s before performing division. In older versions of Python (2.7 and earlier) this conversion did not happen, and integer division would always round down to the nearest integer.

Division can throw its own special error: `ZeroDivisionError`. Python will raise this error when attempting to divide by 0.

Mathematical operations in Python follow the standard mathematical [order of operations](https://www.codecademy.com/resources/docs/python/operators?page_ref=catalog).

Calculations

Python is a programming language. Like other languages, it gives us a way to communicate ideas. In the case of a programming language, these ideas are "commands" that people use to communicate with a computer!

We convey our commands to the computer by writing them in a text file using a programming language. These files are called _programs_. Running a program means telling a computer to read the text file, translate it to the set of operations that it understands, and perform those actions.

Welcome

Now what we're going to do is teach our computer to communicate. The gift of speech is valuable: a computer can answer many questions we have about "how" or "why" or "what" it is doing. In Python, the [`print()`](https://www.codecademy.com/resources/docs/python/built-in-functions/print?page_ref=catalog) function is used to tell a computer to talk. The message to be printed should be surrounded by quotes:

```py
# from Mary Shelley's Frankenstein
print("There is something at work in my soul, which I do not understand.")
```

In the above example, we direct our program to `print()` an excerpt from a notable book. The printed words that appear as a result of the `print()` function are referred to as _output_. The output of this example program would be:

```
There is something at work in my soul, which I do not understand.
```


Print

Humans are prone to making mistakes. Humans are also typically in charge of creating computer programs. To compensate, programming languages attempt to understand and explain mistakes made in their programs. 

Python refers to these mistakes as [errors](https://www.codecademy.com/resources/docs/python/errors?page_ref=catalog) and will point to the location where an error occurred with a `^` character. When programs throw errors that we didn't expect to encounter we call those errors _bugs_. Programmers call the process of updating the program so that it no longer produces unexpected errors _debugging_.

Two common errors that we encounter while writing Python are `SyntaxError` and `NameError`. 
* `SyntaxError` means there is something wrong with the way your program is written &mdash; punctuation that does not belong, a command where it is not expected, or a missing parenthesis can all trigger a `SyntaxError`.

* A `NameError` occurs when the Python interpreter sees a word it does not recognize. Code that contains something that looks like a variable but was never defined will throw a `NameError`.


Errors

In this lesson, we accomplished a lot of things! We instructed our computers to print messages, we stored these messages as variables, and we learned to update those messages depending on the part of the program we were in. We performed mathematical calculations and explored some of the mathematical expressions that Python offers us. We learned about errors and other valuable skills that will continue to serve us as we develop our programming skills.

Good job!

Here are a few more resources to add to your toolkit:

- [Codecademy Docs: Python](https://www.codecademy.com/resources/docs/python?page_ref=catalog)
- [Codecademy Workspaces: Python](https://www.codecademy.com/workspaces/new)

Make sure to bookmark these links so you have them at your disposal.



Review

Computers can understand much more than just strings of text. Python has a few [numeric _data types_.](https://www.codecademy.com/resources/docs/python/data-types?page_ref=catalog)  It has multiple ways of storing numbers. Which one you use depends on your intended purpose for the number you are saving.

An _integer_, or `int`, is a whole number. It has no decimal point and contains all counting numbers (1, 2, 3, ...) as well as their negative counterparts and the number 0. If you were counting the number of people in a room, the number of jellybeans in a jar, or the number of keys on a keyboard you would likely use an integer.

A _floating-point number_, or a `float`, is a decimal number. It can be used to represent fractional quantities as well as precise measurements. If you were measuring the length of your bedroom wall, calculating the average test score of a seventh-grade class, or storing a baseball player's batting average for the 1998 season you would likely use a `float`.

Numbers can be assigned to variables or used literally in a program:

```py
an_int = 2
a_float = 2.1

print(an_int + 3)
# Output: 5
```

Above we defined an integer and a float as the variables `an_int` and `a_float`. We printed out the sum of the variable `an_int` with the number `3`. We call the number 3 here a _literal_, meaning it's actually the number `3` and not a variable with the number 3 assigned to it.

Floating-point numbers can behave in some unexpected ways due to how computers store them. For more information on floating-point numbers and Python, review [Python's documentation on floating-point limitations](https://docs.python.org/3/tutorial/floatingpoint.html).