"Welcome to this warm-up tutorial! Let's take a look at some highlights of Python!\n",
"\n",
"Let's start with the usual **hello world** program:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "c8562e26",
"metadata": {
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World!\n"
]
}
],
"source": [
"print(\"Hello World!\")"
]
},
{
"cell_type": "markdown",
"id": "48a13786",
"metadata": {},
"source": [
"You can print multiple items in a row:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "bea4da9f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 + 12 = 13\n"
]
}
],
"source": [
"print(\"1 + 12 =\", 13)"
]
},
{
"cell_type": "markdown",
"id": "5a70d15c",
"metadata": {},
"source": [
"## Comments\n",
"You can also comment your code with ```#``` for a **single line** or with ```\"\"\"comment\"\"\"``` for **multiple lines**:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "6b5d414b",
"metadata": {},
"outputs": [],
"source": [
"# This is a comment and will be ignored upon execution"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "d69d90e9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"What's that thing that spells the same backwards as forwards?\n",
"A palindrome...?\n"
]
}
],
"source": [
"print(\"What's that thing that spells the same backwards as forwards?\")\n",
"\"\"\"\n",
"I am a comment too!\n",
"See, this line is ignored as well!\n",
"\"\"\"\n",
"print(\"A palindrome...?\")"
]
},
{
"cell_type": "markdown",
"id": "c4c8535a",
"metadata": {},
"source": [
"## Variables and Data-Types\n",
"Python is a **dynamically-typed** language, i.e. you don't have to define your variable types:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "f7179786",
"metadata": {},
"outputs": [],
"source": [
"a = 13 # This is an integer\n",
"b = \"This is a string\" # This is a string\n",
"c = True # A boolean \n",
"d = 14.5 # This is a double-precision floating-point variable (called a 'double' in C-speak)\n",
"e = [1, 3, 15, 34] # This is a list, an array of objects\n",
"f = (\"Emmental\", \"Brie\", \"Gouda\", \"Danish Blue\") # This is a tuple, an immutable array"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "d0586d1b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The second element in a is: None (should be 3)\n"
]
}
],
"source": [
"# You can use squared brackets to access elements in an array or tuple\n",
"# What's the second element in array e?\n",
"print(\"The second element in a is:\", None,\"(should be 3)\")"
]
},
{
"cell_type": "markdown",
"id": "0019db03",
"metadata": {},
"source": [
"## Elementary Arithmetics\n",
"You can use the usual **operators** +, -, \\, / for elementary arithmetics:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "86b8e68c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"13 x 14.5 = ?\n"
]
}
],
"source": [
"# Use the variables a and d defined above to calculate 13 x 14.5!\n",
"print(\"13 x 14.5 =\", \"?\")"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "29eac6ed",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"13 + True = ?\n"
]
}
],
"source": [
"# Booleans work as numbers as well. What happens if you add a and c?\n",
"print(\"13 + True =\", \"?\")"
]
},
{
"cell_type": "markdown",
"id": "f6d98d65",
"metadata": {},
"source": [
"## Comparison Opeartors\n",
"You can use <, >, ==, <=, >= to **compare numbers** (**and objects**), the **keywords** ```and```, ```or``` to compare statements (booleans) and the keyword ```not``` to negate them.\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "b0a7cbe1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"# What's the output of (\"a bigger than d\" AND \"c is True\")?\n",
"print((a==14) and not (c<d))"
]
},
{
"cell_type": "markdown",
"id": "cbba9080",
"metadata": {},
"source": [
"## Control Flow Tools\n",
"For **conditional branching**, the usual keywords ```if```, ```then``` and ```else``` are defined."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "784cb3e8",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.7"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
%% Cell type:markdown id:897fcfcd tags:
# Python Tutorial
-----------------------
Welcome to this warm-up tutorial! Let's take a look at some highlights of Python!
Let's start with the usual **hello world** program:
%% Cell type:code id:c8562e26 tags:
``` python
print("Hello World!")
```
%% Output
Hello World!
%% Cell type:markdown id:48a13786 tags:
You can print multiple items in a row:
%% Cell type:code id:bea4da9f tags:
``` python
print("1 + 12 =",13)
```
%% Output
1 + 12 = 13
%% Cell type:markdown id:5a70d15c tags:
## Comments
You can also comment your code with ```#``` for a **single line** or with ```"""comment"""``` for **multiple lines**:
%% Cell type:code id:6b5d414b tags:
``` python
# This is a comment and will be ignored upon execution
```
%% Cell type:code id:d69d90e9 tags:
``` python
print("What's that thing that spells the same backwards as forwards?")
"""
I am a comment too!
See, this line is ignored as well!
"""
print("A palindrome...?")
```
%% Output
What's that thing that spells the same backwards as forwards?
A palindrome...?
%% Cell type:markdown id:c4c8535a tags:
## Variables and Data-Types
Python is a **dynamically-typed** language, i.e. you don't have to define your variable types:
%% Cell type:code id:f7179786 tags:
``` python
a=13# This is an integer
b="This is a string"# This is a string
c=True# A boolean
d=14.5# This is a double-precision floating-point variable (called a 'double' in C-speak)
e=[1,3,15,34]# This is a list, an array of objects
f=("Emmental","Brie","Gouda","Danish Blue")# This is a tuple, an immutable array
```
%% Cell type:code id:d0586d1b tags:
``` python
# You can use squared brackets to access elements in an array or tuple
# What's the second element in array e?
print("The second element in a is:",None,"(should be 3)")
```
%% Output
The second element in a is: None (should be 3)
%% Cell type:markdown id:0019db03 tags:
## Elementary Arithmetics
You can use the usual **operators** +, -, \, / for elementary arithmetics:
%% Cell type:code id:86b8e68c tags:
``` python
# Use the variables a and d defined above to calculate 13 x 14.5!
print("13 x 14.5 =","?")
```
%% Output
13 x 14.5 = ?
%% Cell type:code id:29eac6ed tags:
``` python
# Booleans work as numbers as well. What happens if you add a and c?
print("13 + True =","?")
```
%% Output
13 + True = ?
%% Cell type:markdown id:f6d98d65 tags:
## Comparison Opeartors
You can use <,>, ==, <=,>= to **compare numbers** (**and objects**), the **keywords**```and```, ```or``` to compare statements (booleans) and the keyword ```not``` to negate them.
%% Cell type:code id:b0a7cbe1 tags:
``` python
# What's the output of ("a bigger than d" AND "c is True")?
print((a==14)andnot(c<d))
```
%% Output
False
%% Cell type:markdown id:cbba9080 tags:
## Control Flow Tools
For **conditional branching**, the usual keywords ```if```, ```then``` and ```else``` are defined.
