This lesson will introduce you to Python, a general-purpose, object-oriented interpreted language you can use for countless standalone projects or scripting applications.

Python Syntax

Variables can also hold numeric values. The simplest kind of number in Python is the integer, which is a whole number with no decimal point:

```py
int1 = 1
int2 = 10
int3 = -5
```

A number with a decimal point is called a _float_. You can define floats with numbers after the decimal point or by just including a decimal point at the end:

```py
float1 = 1.0
float2 = 10.
float3 = -5.5
```

You can also define a float using scientific notation, with `e` indicating the power of 10:
```py
# this evaluates to 150:
float4 = 1.5e2 
```
 

Numbers

Great! So far we’ve looked at:

- Print statements
- How to create, modify, and use variables
- Arithmetic operations like addition, subtraction, division, and multiplication
- How to use comments to make your code easy to understand
- Different data types, including strings, ints, floats, and booleans
- Converting between data types

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

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

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

Review

If programming is the act of teaching a computer to have a conversation with a user, it would be most useful to first teach the computer how to speak. In Python, this is accomplished with the `print` statement.

```py
print "Hello, world!"
print "Water; there is not a drop of water there! Were Niagara but a cataract of sand, would you travel your thousand miles to see it?"
```

A `print` statement is the easiest way to get your Python program to communicate with you. Being able to command this communication will be one of the most valuable tools in your programming toolbox.


Hello World!

Changing the contents of a variable is one of the essential operations. As the flow of a program progresses, data should be updated to reflect changes that have happened.

```py
fish_in_clarks_pond = 50

print "Catching fish"

number_of_fish_caught = 10
fish_in_clarks_pond = fish_in_clarks_pond - number_of_fish_caught
```

In the above example, we start with 50 fish in a local pond. After catching 10 fish, we update the number of fish in the pond to be the original number of fish in the pond minus the number of fish caught. At the end of this code block, the variable `fish_in_clarks_pond` is equal to 40.

Updating a variable by adding or subtracting a number to its original value is such a common task that it has its own shorthand to make it faster and easier to read.

```py
money_in_wallet = 40
sandwich_price = 7.50
sales_tax = .08 * sandwich_price

sandwich_price += sales_tax
money_in_wallet -= sandwich_price
```

In the above example, we use the price of a sandwich to calculate sales tax. After calculating the tax we add it to the total price of the sandwich. Finally, we complete the transaction by reducing our `money_in_wallet` by the cost of the sandwich (with tax).

Updating Variables

Most of the time, code should be written in such a way that it is easy to understand on its own. However, if you want to include a piece of information to explain a part of your code, you can use the `#` sign. A line of text preceded by a `#` is called a _comment_. The machine does not run this code &mdash; it is only for humans to read. When you look back at your code later, comments may help you figure out what it was intended to do.

```py
# this variable counts how many rows of the spreadsheet we have:
row_count = 13
```


Comments

We have seen how to define a string with single quotes and with double quotes. If we want a string to span multiple lines, we can also use triple quotes:

```py
address_string = """136 Whowho Rd
Apt 7
Whosville, WZ 44494"""
```
This address spans multiple lines, and is still contained in one variable, `address_string`.

When a string like this is not assigned to a variable, it works as a multi-line comment. This can be helpful as your code gets more complex:

```py

"""The following piece of code does the following steps:
takes in some input
does An Important Calculation
returns the modified input and a string that says "Success!" or "Failure..."
"""
... a complicated piece of code here...

```


Multi-line Strings

There are two different Python versions. Both Python 2 and Python 3 are used throughout the globe. The most significant difference between the two is how you write a `print` statement. In Python 3, `print` has parentheses.

```py
print("Hello World!")
print("Deep into distant woodlands winds a mazy way, reaching to overlapping spurs of mountains bathed in their hill-side blue.")
```

In this course we will be using Python 2. If you go on to write Python 3 it will be useful to note this key difference.


Print Statements

Sometimes we have a need for variables that are either true or false. This datatype, which can only ever take one of two values, is called a boolean. In Python, we define booleans using the keywords `True` and `False`:

```py
a = True
b = False
```

A boolean is actually a special case of an integer. A value of `True` corresponds to an integer value of `1`, and will behave the same. A value of `False` corresponds to an integer value of `0`.


Booleans

In Python 2, when we divide two integers, we get an integer as a result. When the quotient is a whole number, this works fine:
```py
quotient = 6/2
# the value of quotient is now 3, which makes sense
```
However, if the numbers do not divide evenly, the result of the division is truncated into an integer. In other words, the quotient is rounded down to a whole number. This can be surprising when you expect to receive a decimal and you receive a rounded-down integer:

```py
quotient = 7/2
# the value of quotient is 3, even though the result of the division here is 3.5
```

To yield a float as the result instead, programmers often change either the numerator or the denominator (or both) to be a float:

```py
quotient1 = 7./2
# the value of quotient1 is 3.5
quotient2 = 7/2.
# the value of quotient2 is 3.5
quotient3 = 7./2.
# the value of quotient3 is 3.5
```
An alternative way is to use the `float()` method:
```py
quotient1 = float(7)/2 
# the value of quotient1 is 3.5
```

Two Types of Division

As we get more familiar with the Python programming language, we run into errors and exceptions. These are complaints that Python makes when it doesn't understand what you want it to do. Everyone runs into these issues, so it is a good habit to read and understand them. Here are some common errors that we might run into when printing strings:

```py
print "Mismatched quotes will cause a SyntaxError'
print Without quotes will cause a NameError
```

If the quotes are mismatched Python will notice this and inform you that your code has an error in its syntax because the line ended (called an `EOL`) before the double-quote that was supposed to close the string appeared. The program will abruptly stop running with the following message: 

```
SyntaxError: EOL while scanning a string literal
```

This means that a string wasn't closed, or wasn't closed with the same quote-character that started it.

Another issue you might run into is attempting to create a string without quotes at all. Python treats words not in quotes as commands, like the `print` statement. If it fails to recognize these words as defined (in Python or by your program elsewhere) Python will complain the code has a `NameError`. This means that Python found what it thinks is a command, but doesn't know what it means because it's not defined anywhere.


Handling Errors

Python automatically assigns a variable the appropriate datatype based on the value it is given. A variable with the value `7` is an integer, `7.` is a float, and `"7"` is a string. Sometimes, we will want to convert variables to different **datatypes**. For example, if we wanted to print out an integer as part of a string, we would need to _convert that integer to a string first_. We can do that using `str()`:

```py
age = 13
print "I am " + str(age) + " years old!"
```

This would print:
```py
>>> "I am 13 years old!"
```

Similarly, if we have the string `"7"` and we want to perform arithmetic operations on it, we must convert it to a numeric datatype. We can do this using `int()`:

```py
number1 = "100"
number2 = "10"

string_addition = number1 + number2 
# string_addition now has a value of "10010"

int_addition = int(number1) + int(number2)
# int_addition has a value of 110
```

If we have a string that is a floating point value, such as `"7.5"`, we can convert it to a numeric datatype using `float()` instead:

```py
string_num = "7.5"
print float(string_num)
```
```py
>>> 7.5
```

Using `float()` on an integer value, whether string or numeric, will convert the value to a float:

```py
string_int = "10"
numeric_int = 12

print float(string_int)
print float(numeric_int)
```
```py
>>> 10.0
>>> 12.0
```

The result of using `int()` on a floating point value will depend on whether the value is a string or numeric datatype. If you use `int()` on a floating point _string_ value, it will raise a `ValueError`:

```py
string_float = "7.5"
print int(string_float)
```
```
Traceback (most recent call last):
  File "script.py", line 2, in <module>
    print int(string_num)
ValueError: invalid literal for int() with base 10: '7.5'
```

Using `int()` on a floating point _numeric_ value converts the number to an integer by removing the decimal portion and rounding the number closer towards `0`:

```py
numeric_float_positive = 7.5
numeric_float_negative = -9.5

print int(numeric_float_positive)
print int(numeric_float_negative)
```
```py
>>> 7
>>> -9
```

**Note**: Use caution when converting a floating point number into an integer, as this may result in the loss of the decimal data.

ValueError

When printing things in Python, we are supplying a text block that we want to be printed. Text in Python is considered a specific type of data called a _string_. A string, so named because they're a series of letters, numbers, or symbols connected in order &mdash; as if threaded together by string. Strings can be defined in different ways:

```py
print "This is a good string"
print 'You can use single quotes or double quotes for a string'
```

Above we printed two things that are strings and then attempted to print two things that are not strings. While double-quotes (") and single-quotes (') are both acceptable ways to define a string, a string needs to be opened and closed by the same type of quote mark.

We can combine multiple strings using `+`, like so:

```py
print "This is " + "a good string"
```

This code will print out "This is a good string".


Strings

In Python, and when programming in general, we need to build systems for dealing with data that changes over time. That data could be the location of a plane, or the time of day, or the television show you're currently watching. The only important thing is that it may be different at different times. Python uses _variables_ to define things that are subject to change.

```py
greeting_message = "Welcome to Codecademy!"
current_excercise = 5
```

In the above example, we defined a variable called `greeting_message` and set it equal to the string "Welcome to Codecademy!". It also defined a variable called `current_exercise` and set it equal to the number 5.


Variables

One thing computers are capable of doing exceptionally well is performing arithmetic. Addition, subtraction, multiplication, division, and other numeric calculations are easy to do in most programming languages, and Python is no exception. Some examples:

```py
mirthful_addition = 12381 + 91817
amazing_subtraction = 981 - 312
trippy_multiplication = 38 * 902
happy_division = 540 / 45
sassy_combinations = 129 * 1345 + 120 / 6 - 12
```

Above are a number of arithmetic operations, each assigned to a variable. The variable will hold the final result of each operation. Combinations of arithmetical operators follow the usual <a href="https://en.wikipedia.org/wiki/Order_of_operations" rel="noopener noreferrer" target="_blank">order of operations</a>.

Python also offers a companion to division called the modulo operator. The modulo operator is indicated by `%` and returns the remainder after division is performed.

```py
is_this_number_odd = 15 % 2
is_this_number_divisible_by_seven = 133 % 7
```
In the above code block, we use the modulo operator to find the remainder of `15` divided by `2`. Since `15` is an odd number the remainder is `1`. 

We also check the remainder of `133 / 7`. Since `133` divided by `7` has no remainder, `133 % 7` evaluates to `0`.