{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<small><small><i>\n",
"All the IPython Notebooks in **Python Introduction** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
"</i></small></small>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python Variables and Constants\n",
"\n",
"In this class, you will learn about Python variables, constants, literals and their use cases."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 1. Python Variables\n",
"\n",
"A variable is a named location used to **store data in the memory**. Variable also known as **identifier** and used to hold value. It is helpful to think of variables as a container that holds data that can be changed later in the program. **Mnemonic** variables are recommended to use in many programming languages. A mnemonic variable is a variable name that can be easily remembered and associated. A variable refers to a memory address in which data is stored. For example,\n",
"\n",
"```python\n",
">>>number = 90\n",
"```\n",
"\n",
"Here, we have created a variable named **`number`**. We have assigned the value **`10`** to the variable.\n",
"\n",
"You can think of variables as a bag to store books in it and that book can be replaced at any time.\n",
"\n",
"```python\n",
">>>number = 90\n",
">>>number = 9.1\n",
"```\n",
"\n",
"Initially, the value of number was **`90`**. Later, it was changed to **`9.1`**.\n",
"\n",
"> **Note**: In Python, we don't actually assign values to the variables. Instead, Python gives the reference of the object(value) to the variable.\n",
"\n",
"In Python, we don't need to specify the type of variable because Python is a **type infer language** and smart enough to get variable type. \n",
"\n",
"Python Variable Name Rules\n",
"\n",
"- A variable name must start with a **letter** **`A`**-**`z`** or the **underscore** **`_`** character\n",
"- A variable name cannot start with a **number** **`0`**-**`9`**\n",
"- A variable name can only contain alpha-numeric characters and underscores (**`A`**-**`z`**, **`0`**-**`9`**, and **`_`** )\n",
"- Variable names are case-sensitive (**`firstname`**, **`Firstname`**, **`FirstName`** and **`FIRSTNAME`**) are different variables). It is recomended to use lowercase letters for variable name."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Let us see valid variable names\n",
"\n",
"```python\n",
"firstname\n",
"lastname\n",
"age\n",
"country\n",
"city\n",
"first_name\n",
"last_name\n",
"capital_city\n",
"_if # if we want to use reserved word as a variable\n",
"year_2021\n",
"year2021\n",
"current_year_2021\n",
"birth_year\n",
"num1\n",
"num2\n",
"```\n",
"\n",
"Invalid variables names:\n",
"\n",
"```python\n",
"first-name\n",
"first@name\n",
"first$name\n",
"num-1\n",
"1num\n",
"```\n",
"\n",
"We will use standard Python variable naming style which has been adopted by many Python developers. Python developers use snake case(snake_case) variable naming convention. We use underscore character after each word for a variable containing more than one word (eg. **`first_name`**, **`last_name`**, **`engine_rotation_speed`**). The example below is an example of standard naming of variables, underscore is required when the variable name is more than one word.\n",
"\n",
"When we assign a certain data type to a variable, it is called variable declaration. For instance in the example below my first name is assigned to a variable **`first_name`**. The equal sign is an assignment operator. Assigning means storing data in the variable. The equal sign in Python is not equality as in Mathematics."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Assigning values to Variables in Python\n",
"\n",
"Think of a variable as a name attached to a particular object. In Python, variables need not be declared or defined in advance, as is the case in many other programming languages. \n",
"\n",
"As you can see from the above example, you can use the assignment operator **`=`** to assign a value to a variable."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Example 1: Declaring and assigning value to a variable"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:19.999226Z",
"start_time": "2021-10-02T06:36:19.972865Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"9.1"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"number = 90\n",
"number = 9.1\n",
"number"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.099323Z",
"start_time": "2021-10-02T06:36:20.003137Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"github.com\n"
]
}
],
"source": [
"website = \"github.com\" # `website` is my variable and `github.com` is an argument\n",
"print(website)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the above program, we assigned a value **`github.com`** to the variable **`website`**. Then, we printed out the value assigned to **`website`** i.e. **`github.com`**.\n",
"\n",
"> **Note**: Python is a **[type-inferred](https://en.wikipedia.org/wiki/Type_inference)** language, so you don't have to explicitly define the variable type. It automatically knows that **`github.com`** is a string and declares the **`website`** variable as a string."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.214178Z",
"start_time": "2021-10-02T06:36:20.099323Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello , World !\n"
]
}
],
"source": [
"print('Hello',',', 'World','!') # it can take multiple arguments, 4 arguments have been passed"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.358600Z",
"start_time": "2021-10-02T06:36:20.217491Z"
}
},
"outputs": [],
"source": [
"first_name = 'Milaan'\n",
"last_name = 'Parmar'\n",
"country = 'Finland'\n",
"city = 'Tampere'\n",
"age = 96\n",
"is_married = True\n",
"skills = ['Python', 'Matlab', 'JS', 'C', 'C++']\n",
"person_info = {\n",
" 'firstname':'Milaan',\n",
" 'lastname':'Parmar',\n",
" 'country':'Finland',\n",
" 'city':'Tampere'\n",
" }"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let us print and also find the length of the variables declared at the top:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.481648Z",
"start_time": "2021-10-02T06:36:20.364463Z"
},
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First name: Milaan\n",
"First name length: 6\n",
"Last name: Parmar\n",
"Last name length: 6\n",
"Country: Finland\n",
"City: Tampere\n",
"Age: 96\n",
"Married: True\n",
"Skills: ['Python', 'Matlab', 'JS', 'C', 'C++']\n",
"Person information: {'firstname': 'Milaan', 'lastname': 'Parmar', 'country': 'Finland', 'city': 'Tampere'}\n"
]
}
],
"source": [
"# Printing the values stored in the variables\n",
"\n",
"print('First name:', first_name)\n",
"print('First name length:', len(first_name))\n",
"print('Last name: ', last_name)\n",
"print('Last name length: ', len(last_name))\n",
"print('Country: ', country)\n",
"print('City: ', city)\n",
"print('Age: ', age)\n",
"print('Married: ', is_married)\n",
"print('Skills: ', skills)\n",
"print('Person information: ', person_info)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Example 2: Declaring multiple variables in one line** using comma **`,`** and semicolon **`;`**"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.608794Z",
"start_time": "2021-10-02T06:36:20.484580Z"
},
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6\n",
"9.3\n",
"Hello\n"
]
}
],
"source": [
"a, b, c = 6, 9.3, \"Hello\"\n",
"\n",
"print (a)\n",
"print (b)\n",
"print (c)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.701379Z",
"start_time": "2021-10-02T06:36:20.608794Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 2 3\n"
]
},
{
"data": {
"text/plain": [
"(1, 2, 3)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = 1; b = 2; c = 3\n",
"print(a,b,c) # outout: 1 2 3\n",
"a,b,c # outout: 1 2 3"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.823509Z",
"start_time": "2021-10-02T06:36:20.702346Z"
},
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Milaan Parmar Finland 96 True\n",
"First name: Milaan\n",
"Last name: Parmar\n",
"Country: Finland\n",
"Age: 96\n",
"Married: True\n"
]
}
],
"source": [
"first_name, last_name, country, age, is_married = 'Milaan', 'Parmar', 'Finland', 96, True\n",
"\n",
"print(first_name, last_name, country, age, is_married)\n",
"print('First name:', first_name)\n",
"print('Last name: ', last_name)\n",
"print('Country: ', country)\n",
"print('Age: ', age) # Don't worry it is not my real age ^_^\n",
"print('Married: ', is_married)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we want to assign the same value to **multiple**/**chained** variables at once, we can do this as:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:20.946004Z",
"start_time": "2021-10-02T06:36:20.825916Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"same\n",
"same\n",
"same\n"
]
}
],
"source": [
"x = y = z = \"same\"\n",
"\n",
"print (x)\n",
"print (y)\n",
"print (z)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The second program assigns the **`same`** string to all the three variables **`x`**, **`y`** and **`z`**."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.046591Z",
"start_time": "2021-10-02T06:36:20.946494Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"300 300 300\n"
]
}
],
"source": [
"p = q = r = 300 # Assigning value together\n",
"print(p, q, r) # Printing value together"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Example 3: Changing the value of a variable"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.168662Z",
"start_time": "2021-10-02T06:36:21.047080Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"github.com\n",
"baidu.com\n"
]
}
],
"source": [
"website = \"github.com\"\n",
"print(website)\n",
"\n",
"# assigning a new variable to website\n",
"website = \"baidu.com\"\n",
"\n",
"print(website)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the above program, we have assigned **`github.com`** to the **`website`** variable initially. Then, the value is changed to **`baidu.com`**."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.289757Z",
"start_time": "2021-10-02T06:36:21.175502Z"
},
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"300\n"
]
}
],
"source": [
"n=300\n",
"print(n)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.464561Z",
"start_time": "2021-10-02T06:36:21.297568Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"300\n",
"1000\n"
]
}
],
"source": [
"m=n\n",
"print(n)\n",
"\n",
"m = 1000 # assigning a new value to n\n",
"print(m)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.542044Z",
"start_time": "2021-10-02T06:36:21.464561Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10\n"
]
}
],
"source": [
"# Declare & Redeclare variables\n",
"m = \"Python is Fun\"\n",
"m = 10\n",
"print (m)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2. Constants\n",
"\n",
"A constant is a type of variable whose value cannot be changed. It is helpful to think of constants as containers that hold information which cannot be changed later.\n",
"\n",
"You can think of constants as a bag to store some books which cannot be replaced once placed inside the bag."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Assigning value to constant in Python\n",
"\n",
"In Python, constants are usually declared and assigned in a module. Here, the module is a new file containing variables, functions, etc which is imported to the main file. Inside the module, constants are written in all capital letters and underscores separating the words."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Example 1: Declaring and assigning value to a constant\n",
"\n",
"Create a **constant.py**:\n",
"\n",
"```python\n",
">>>PI = 3.14\n",
">>>GRAVITY = 9.8\n",
"```\n",
"\n",
"Create a **main.py**:\n",
"\n",
"```python\n",
">>>import constant\n",
">>>print(constant.PI)\n",
">>>print(constant.GRAVITY)\n",
"\n",
"3.14\n",
"9.8\n",
"```\n",
"\n",
"In the above program, we create a **constant.py** module file. Then, we assign the constant value to **`PI`** and **`GRAVITY`**. After that, we create a **main.py** file and import the **`constant`** module. Finally, we print the constant value.\n",
"\n",
"> **Note**: In reality, we don't use constants in Python. Naming them in all capital letters is a convention to separate them from variables, however, it does not actually prevent reassignment."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Rules and Naming Convention for Variables and constants\n",
"\n",
"The examples you have seen so far have used **short**, terse variable names like m and n. But variable names can be more **verbose**. In fact, it is usually beneficial if they are because it makes the purpose of the variable more evident at first glance. \n",
"\n",
"1. Constant and variable names should have a combination of letters in lowercase (a to z) or uppercase (**A to Z**) or digits (**0 to 9**) or an underscore **`_`**. For example:\n",
"\n",
"```python\n",
"snake_case\n",
"MACRO_CASE\n",
"camelCase\n",
"CapWords\n",
"```\n",
"\n",
"2. Create a name that makes sense. For example, **`vowel`** makes more sense than **`v`**.\n",
"\n",
"3. If you want to create a variable name having two words, use underscore to separate them. For example:\n",
"\n",
"```python\n",
"my_name\n",
"current_salary\n",
"```\n",
"\n",
"4. Use capital letters possible to declare a constant. For example:\n",
"\n",
"```python\n",
"PI\n",
"G\n",
"MASS\n",
"SPEED_OF_LIGHT\n",
"TEMP\n",
"```\n",
"\n",
"5. Never use special symbols like **!**, **@**, **#**, **$** <b> % </b>, etc.\n",
"\n",
"6. Don't start a variable name with a digit.\n",
"\n",
">**Note**: One of the additions to Python 3 was full Unicode support, which allows for **Unicode** characters in a variable name as well. You will learn about Unicode in greater depth in a future tutorial."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For example, all of the following are valid variable names:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.667195Z",
"start_time": "2021-10-02T06:36:21.542044Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bob 54 True\n"
]
}
],
"source": [
"name = \"Bob\"\n",
"Age = 54\n",
"has_W2 = True\n",
"print(name, Age, has_W2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But this one is not, **because a variable name can’t begin with a digit**:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:36:21.779446Z",
"start_time": "2021-10-02T06:36:21.667684Z"
},
"scrolled": true
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid decimal literal (<ipython-input-16-8cc0f1bdc5ed>, line 1)",
"output_type": "error",
"traceback": [
"\u001b[1;36m File \u001b[1;32m\"<ipython-input-16-8cc0f1bdc5ed>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m 1099_filed = False # cannot start name of a variable with a number.\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid decimal literal\n"
]
}
],
"source": [
"1099_filed = False # cannot start name of a variable with a number."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that case is **significant**. Lowercase and uppercase letters are not the same. Use of the underscore character is significant as well. Each of the following defines a different variable:\n",
"\n",
"```python\n",
">>>age = 1\n",
">>>Age = 2\n",
">>>aGe = 3\n",
">>>AGE = 4\n",
">>>a_g_e = 5\n",
">>>_age = 6\n",
">>>age_ = 7\n",
">>>AGe = 8\n",
">>>print(age, Age, aGe, AGE, a_g_e, age, age, AGe)\n",
"\n",
"1 2 3 4 5 6 7 8 \n",
"```\n",
"There is nothing stopping you from creating two different variables in the same program called age and Age, or for that matter agE. But it is probably **ill-advised**. It would certainly be likely to confuse anyone trying to read your code, and even you yourself, after you’d been away from it awhile."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"ExecuteTime": {
"end_time": "2021-10-02T06:37:08.476696Z",
"start_time": "2021-10-02T06:37:08.454238Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 2 3 4 5 1 1 8\n"
]
}
],
"source": [
"age = 1\n",
"Age = 2\n",
"aGe = 3\n",
"AGE = 4\n",
"a_g_e = 5\n",
"_age = 6\n",
"age_ = 7\n",
"AGe = 8\n",
"print(age, Age, aGe, AGE, a_g_e, age, age, AGe)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 💻 Exercises ➞ <span class='label label-default'>Variables</span>\n",
"\n",
"### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
"\n",
"1. Write a python comment saying **`Python variables and Constants`**\n",
"2. Declare a **`first_name`** variable and assign a value to it\n",
"3. Declare a **`last_name`** variable and assign a value to it\n",
"4. Declare a **`full_name`** variable and assign a value to it\n",
"5. Declare a variable **`is_light_on`** and assign a value to it\n",
"6. Declare multiple variable on one line\n",
"\n",
"### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
"\n",
"1. Check the data type of all your variables using **`type()`** built-in function\n",
"2. Using the **`len()`** built-in function, find the length of your first name\n",
"3. Compare the length of your **`first_name`** and your **`last_name`**\n",
"4. Declare **6** as **`num_1`** and **4** as **`num_2`**\n",
" 1. Add **`num_1`** and **`num_2`** and assign the value to a variable **`total`**\n",
" 2. Subtract **`num_2`** from **`num_1`** and assign the value to a variable **`difference`**\n",
" 3. Multiply **`num_2`** and **`num_1`** and assign the value to a variable **`product`**\n",
" 4. Divide **`num_1`** by **`num_2`** and assign the value to a variable **`division`**\n",
" 5. Use modulus division to find **`num_2`** divided by **`num_1`** and assign the value to a variable **`remainder`**\n",
" 6. Calculate **`num_1`** to the power of **`num_2`** and assign the value to a variable **`exp`**\n",
" 7. Find floor division of **`num_1`** by **`num_2`** and assign the value to a variable **`floor_division`**\n",
" \n",
"5. The radius of a circle is **30 meters**.\n",
" 1. Calculate the area of a circle and assign the value to a variable name of **`area_of_circle`** by taking user **`input()`**\n",
" 2. Calculate the circumference of a circle and assign the value to a variable name of **`circum_of_circle`** by taking user **`input()`**\n",
" 3. Take radius as user **`input()`** and calculate the area.\n",
" \n",
"6. Use the built-in **`input()`** function to get first name, last name, country and age from a user and store the value to their corresponding variable names\n",
"7. Run help (**`keywords`**) in Python shell or in your file to check for the Python reserved words or keywords"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"hide_input": false,
"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.10.9"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
},
"varInspector": {
"cols": {
"lenName": 16,
"lenType": 16,
"lenVar": 40
},
"kernels_config": {
"python": {
"delete_cmd_postfix": "",
"delete_cmd_prefix": "del ",
"library": "var_list.py",
"varRefreshCmd": "print(var_dic_list())"
},
"r": {
"delete_cmd_postfix": ") ",
"delete_cmd_prefix": "rm(",
"library": "var_list.r",
"varRefreshCmd": "cat(var_dic_list()) "
}
},
"types_to_exclude": [
"module",
"function",
"builtin_function_or_method",
"instance",
"_Feature"
],
"window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}