![\"Introduction](\"img/lecture-1/ad.jpeg\")
\n",
"\n",
"
\n",
"![](\"img/lecture-1/Python-data-structure.jpg\")
\n",
"\n", "Question: What is the difference between 2 and 2.0?" ] }, { "cell_type": "code", "execution_count": null, "id": "6af65fd4", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "49739ba8", "metadata": {}, "source": [ "
Basic Arithmetic
\n", "Numbers, in Python, can be subjected to various computational forms, such as basic arithmetic (+, -, /, *, powers, mod, etc...)\n", "\n", "By default, using both float and integer in a singular arithmetic action returns a float result. (eg. 2 + 0.5). There are a few exceptions to this statement (just so you know).\n", "\n", "![](\"img/lecture-1/arithmetic.png\")
"
]
},
{
"cell_type": "code",
"execution_count": 53,
"id": "b75a5720",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5.2"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 + 3.2 #Addition"
]
},
{
"cell_type": "code",
"execution_count": 54,
"id": "10006fef",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"9.3"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 * 3.1 #Multiplication"
]
},
{
"cell_type": "code",
"execution_count": 55,
"id": "724aa83d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"4.9 - 0.9 #Subtraction"
]
},
{
"cell_type": "code",
"execution_count": 56,
"id": "3cc56a14",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.3333333333333333"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"4/3 #Division"
]
},
{
"cell_type": "code",
"execution_count": 57,
"id": "d7189b88",
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"4.1//2.1 #Floor Division"
]
},
{
"cell_type": "code",
"execution_count": 58,
"id": "807d1b71",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"5%3 #Modulus (%)"
]
},
{
"cell_type": "code",
"execution_count": 59,
"id": "adcda1df",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"9"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3**2 #Exponentiation"
]
},
{
"cell_type": "code",
"execution_count": 60,
"id": "e7e389f3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"9.0"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3**2. #Exponentiation"
]
},
{
"cell_type": "code",
"execution_count": 61,
"id": "d69aad9f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3^0"
]
},
{
"cell_type": "markdown",
"id": "c0fb887e",
"metadata": {
"tags": [
"Boolean"
]
},
"source": [
"Boolean Data Type
\n", "\n", " This comprises of only two variables (True or False). They mostly occur when an action is expected to return any of the two stated outputs. However, they can also be assigned to a variable by the user. Let's try to check their type below and find what the output is.\n", "
" ] }, { "cell_type": "code", "execution_count": 62, "id": "10ffbfe5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(True)" ] }, { "cell_type": "code", "execution_count": 63, "id": "5a6eb2c3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(False)" ] }, { "cell_type": "code", "execution_count": 64, "id": "4e406377", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(2>3)" ] }, { "cell_type": "markdown", "id": "81a4a494", "metadata": { "tags": [ "Lists" ] }, "source": [ "Lists
\n", "\n", "\n", "Lists are created by placing all the items (elements) inside square brackets [], separated by commas. It can have any number of items and they may be of different types (integer, float, string etc.). Lists need not be homogeneous always which makes it the most powerful tool in Python. A single list may contain DataTypes like Integers, Strings, as well as Objects. Lists are mutable, and hence, they can be altered even after their creation.\n", " \n", "`A list can also have another list as an item. This is called a nested list.`" ] }, { "cell_type": "code", "execution_count": 65, "id": "b1043bf2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = [1,2,3,4]\n", "type(a)" ] }, { "cell_type": "markdown", "id": "ca09ed43", "metadata": {}, "source": [ "List Subsetting\n", "--\n", "List subsetting is similar to the string subsetting. Lists can be subset using the square brackets containing the starting index, ending index and step.\n", "\n", "N/B: Python indexing starts from zero (0).\n", "\n", "When left empty, the default starting index is 0, the ending index is equivalent to the length of the string and the step is 1, by default." ] }, { "cell_type": "code", "execution_count": 20, "id": "2ece1a9f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names = ['Abel','Emma','Quantum','Legendre','Ghana']\n", "type(names)" ] }, { "cell_type": "code", "execution_count": 67, "id": "878e395e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Abel'" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[0] #List elements at the first index" ] }, { "cell_type": "code", "execution_count": 68, "id": "1d12fdf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Emma', 'Quantum']" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[1:3] #List elements from the 2nd to 3rd index" ] }, { "cell_type": "code", "execution_count": 69, "id": "9250c7cb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Abel', 'Quantum', 'Ghana']" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[::2] #List elements at the odd index" ] }, { "cell_type": "code", "execution_count": 70, "id": "dc6d3ab8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Emma', 'Legendre']" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[1::2] #List elements at the even index" ] }, { "cell_type": "markdown", "id": "074ec756", "metadata": {}, "source": [ "List data types are mutable: They can be altered. " ] }, { "cell_type": "code", "execution_count": 71, "id": "1a331bad", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['New Name', 'Emma', 'Quantum', 'Legendre', 'Ghana']" ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[0] = 'New Name'\n", "names" ] }, { "cell_type": "code", "execution_count": 72, "id": "43392d73", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ghana', 'Legendre', 'Quantum', 'Emma', 'New Name']" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[::-1] #This reverses the list elements" ] }, { "cell_type": "code", "execution_count": 73, "id": "29b4f80b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ghana', 'Quantum', 'New Name']" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names[::-2] #This reverses the list elements, producing elements at locations from the end to the front with a step of 2." ] }, { "cell_type": "markdown", "id": "d43dd3cf", "metadata": {}, "source": [ "
Appending to a List
\n", "\n", "New items can be added to a list using the append() method." ] }, { "cell_type": "code", "execution_count": 75, "id": "e8aeeb78", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['New Name', 'Emma', 'Quantum', 'Legendre', 'Ghana', 'Michael']" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names.append('Michael')\n", "names" ] }, { "cell_type": "markdown", "id": "eb65998d", "metadata": {}, "source": [ "
Removing an item from a List
\n", "\n", "Items can be removed/dropped from a list using the remove() method." ] }, { "cell_type": "code", "execution_count": 76, "id": "47bc825d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['New Name', 'Emma', 'Quantum', 'Legendre', 'Ghana']" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names.remove('Michael')\n", "names" ] }, { "cell_type": "markdown", "id": "9e75aae6", "metadata": {}, "source": [ "Other Built-In List Methods\n", "--" ] }, { "cell_type": "code", "execution_count": 77, "id": "fed25bda", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names.count('Emma') #Gives the count of the set variable in the list" ] }, { "cell_type": "code", "execution_count": 78, "id": "3a8e79fa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names.append('Emma')\n", "names.count('Emma')" ] }, { "cell_type": "code", "execution_count": 79, "id": "84e0a19a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names.index('Quantum') #Gives the first index of the given variable from the list" ] }, { "cell_type": "code", "execution_count": 80, "id": "0888ca81", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['New Name', 'Emma', 'InsertedName', 'Quantum', 'Legendre', 'Ghana', 'Emma']" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "names.insert(2, 'InsertedName') #Insert a new variable at the given index of the defined list.\n", "names" ] }, { "cell_type": "code", "execution_count": 81, "id": "95fb45c3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Emma', 'Emma', 'Ghana', 'InsertedName', 'Legendre', 'New Name', 'Quantum']" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sorted(names) #Sorting the list items using the sorted() method" ] }, { "cell_type": "markdown", "id": "71492cf9", "metadata": { "tags": [ "Tuples" ] }, "source": [ "
Tuples
\n", "\n",
"\n",
"Tuples are used to store multiple items in a single variable. Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage. A tuple is a collection which is ordered and unchangeable. Tuples are written with round brackets \"( )\"."
]
},
{
"cell_type": "code",
"execution_count": 82,
"id": "62d363ae",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tuple"
]
},
"execution_count": 82,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = (1,2,3,4,5)\n",
"type(a)"
]
},
{
"cell_type": "code",
"execution_count": 83,
"id": "6fa31cab",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 83,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Tuple Subsetting\n",
"a[0]"
]
},
{
"cell_type": "code",
"execution_count": 84,
"id": "b5dccd39",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 3, 5)"
]
},
"execution_count": 84,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[::2]"
]
},
{
"cell_type": "markdown",
"id": "b7b8fc5a",
"metadata": {},
"source": [
"Tuples are immutable: They cannot be altered."
]
},
{
"cell_type": "markdown",
"id": "2cf7cc61",
"metadata": {},
"source": [
" \n",
"\n",
" \n",
"Sets are used to store multiple items in a single variable.\n",
"\n",
"Set is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Tuple, and Dictionary, all with different qualities and usage.\n",
"\n",
"A set is unordered, unchangeable*, and unindexed."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3acf1c08",
"metadata": {},
"outputs": [],
"source": [
"a = {1,2,3}\n",
"type(a)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "01e50109",
"metadata": {},
"outputs": [],
"source": [
"#There are no duplicates in a set.\n",
"a1 = {1,2,3,1,'Hi'}\n",
"a1"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "def9dc1a",
"metadata": {},
"outputs": [],
"source": [
"#Sets are unindexed.\n",
"a1[0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "08e401d1",
"metadata": {},
"outputs": [],
"source": [
"#Sets are immutable: They cannot be changed.\n",
"a1[0] = 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "96e84fc8",
"metadata": {},
"outputs": [],
"source": [
"#Adding a new item to the end of a set.\n",
"a1.add('New')\n",
"a1"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4a2832a6",
"metadata": {},
"outputs": [],
"source": [
"a1.add('Item')\n",
"a1"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5f09088d",
"metadata": {},
"outputs": [],
"source": [
"#Updating a Set. This adds the item in no particular order\n",
"a1.update(['This','There'])\n",
"a1"
]
},
{
"cell_type": "markdown",
"id": "f936b625",
"metadata": {},
"source": [
"Frozen Sets\n",
"--\n",
"Python provides another built-in type called a frozenset, which is in all respects exactly like a set, except that a frozenset is immutable. You can perform non-modifying operations on a frozenset:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "354607f1",
"metadata": {},
"outputs": [],
"source": [
"x = frozenset(['1', '2', '3'])\n",
"type(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ea1c1811",
"metadata": {},
"outputs": [],
"source": [
"x.union({1,2,5}) #Produces a Union Set of x with the new set."
]
},
{
"cell_type": "markdown",
"id": "261eb8cf",
"metadata": {
"tags": [
"Dictionary"
]
},
"source": [
" \n",
"\n",
"Dictionaries are used to store data values in key:value pairs.\n",
"A dictionary is mutable but does not allow duplicates.\n",
"Dictionaries are written with curly brackets, and have keys and values:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "75740039",
"metadata": {},
"outputs": [],
"source": [
"a = {\n",
" \"Name\": \"OneQuantum Ghana\",\n",
" \"Country\": \"Ghana\",\n",
" \"Course\": \"Introduction to Programming with Python\",\n",
" \"Year\": 2022\n",
"}\n",
"\n",
"type(a)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a7867fef",
"metadata": {},
"outputs": [],
"source": [
"#You can access the items of a dictionary by referring to its key name, inside square brackets:\n",
"a['Year']"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "02968ad7",
"metadata": {},
"outputs": [],
"source": [
"#Alternatively, you can use the get() method.\n",
"a.get(\"Name\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2745a656",
"metadata": {},
"outputs": [],
"source": [
"a.items() #Produces the items (keys and values) stored in the dictionary"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4eb73357",
"metadata": {},
"outputs": [],
"source": [
"a.keys() #Produces the keys in the dictionary"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf1f6909",
"metadata": {},
"outputs": [],
"source": [
"a.values() #Produces the values stored in the dictionary"
]
},
{
"cell_type": "markdown",
"id": "db2edb75",
"metadata": {
"tags": [
"conditions"
]
},
"source": [
" \n",
"\n",
" Conditional statement consist of a test and one or more actions to be executed. The action in these action statement execute when the test evalutes to be True. However, in Python every value can be interpreted as a boolean value, regardless of its data type. i.e., when you test a condition, and your test is of a value that is not True or False, it will still be interpreted as either True or False. Comparison is one of the common boolean expressions and it consist of two values with a comparison operator between them. This expression evalutes to True or False Boolean expressions can be combined with logical operators and used in an if construct. There are three logical operators; \n",
" Decision making is anticipation of conditions occurring while execution of the program and specifying actions taken according to the conditions. Decision structures evaluate multiple expressions which produce TRUE or FALSE as outcome. You need to determine which action to take or which statements to execute if outcome is TRUE or FALSE otherwise.\n",
" The advantages of Python programming spans, but is not limited to the following:![](\"img/lecture-1/mutables.png\")
"
]
},
{
"cell_type": "code",
"execution_count": 85,
"id": "ff4f6173",
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'tuple' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_40152/2869727665.py\u001b[0m in \u001b[0;36m Sets
\n",
" Dictionary Data Type
\n",
" Conditions In Python (IF Statements)
\n",
"Comparisons
\n",
"![](\"img/lecture-1/comparisons.jpg\")
\n",
"\n",
"\n",
"Logical Operators
\n",
"![](\"img/lecture-1/logical.jpg\")
\n",
"\n",
"\n",
"
\n",
"\n",
"# One way Decision"
]
},
{
"cell_type": "code",
"execution_count": 86,
"id": "6eba8c18",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x equals 5\n"
]
}
],
"source": [
"# Examples\n",
"x = 5\n",
"if x == 5: \n",
" print( \"x equals 5\" )"
]
},
{
"cell_type": "code",
"execution_count": 87,
"id": "db9eb27e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x is greater than 4\n"
]
}
],
"source": [
"if x > 4:\n",
" print( \"x is greater than 4\" )"
]
},
{
"cell_type": "code",
"execution_count": 88,
"id": "97ef4c0e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x is less than or equal to 5\n"
]
}
],
"source": [
"if x <= 5:\n",
" print( \"x is less than or equal to 5\" )"
]
},
{
"cell_type": "code",
"execution_count": 89,
"id": "b87dd6eb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x does not equal 6\n"
]
}
],
"source": [
"if x != 6 :\n",
" print( \"x does not equal 6\" )"
]
},
{
"cell_type": "markdown",
"id": "c74660f1",
"metadata": {},
"source": [
"# Two way Decision & Multiple Decision\n",
"Often a decision branches, e.g., if a certain condition arises, you want to take a particular action, but if it does not arise, you want to take another action. This is supported by Python in the form of an expansion to the if statement that adds an else branch. In other cases too there are lots of decision which need to be taken."
]
},
{
"cell_type": "code",
"execution_count": 91,
"id": "19e49dca",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"enter a your name: John\n",
"You are welcome John\n",
"Two decision execution complete\n",
"####################################\n",
"Next is Multiple Decision\n"
]
}
],
"source": [
"# syntax involves if,elif and else\n",
"# with multiple decision the number of elif depends on the number of decision to be taken\n",
"\n",
"###############################################\n",
"####### Two way Decision ####################\n",
"###############################################\n",
"\n",
"Name = input(\"enter a your name: \")\n",
"if Name == 'John':\n",
" print(\"You are welcome\",Name) \n",
"else:\n",
" print (\" I don't know you please\")\n",
" \n",
"\n",
"print(\"Two decision execution complete\")\n",
"print(\"####################################\")\n",
"print(\"Next is Multiple Decision\")"
]
},
{
"cell_type": "code",
"execution_count": 92,
"id": "0da4452d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"enter a number pls: 7\n",
"num is between 0 and 20\n"
]
}
],
"source": [
"###############################################\n",
"##### Multiple Decision with if ########\n",
"###############################################\n",
"num = int(input(\"enter a number pls: \"))\n",
"if num == 0:\n",
" print(\"num is zero\") \n",
"elif num > 0 and num < 20:\n",
" print (\"num is between 0 and 20\") \n",
"elif num > 20 and num < 45:\n",
" print (\"num is between 20 and 45\") \n",
"else:\n",
" print (\" I don't know the number\")"
]
},
{
"cell_type": "markdown",
"id": "59e5c3ca",
"metadata": {},
"source": [
"# Nested If Statements"
]
},
{
"cell_type": "code",
"execution_count": 90,
"id": "76430f9d",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\tStudent scored a passing grade\n",
"\tpassed with A\n",
"\tpassed with A+\n"
]
}
],
"source": [
"grade = 100\n",
"if grade > 60:\n",
" print(\"\\tStudent scored a passing grade\")\n",
" if grade >= 90:\n",
" print(\"\\tpassed with A\")\n",
" if grade >= 96:\n",
" print(\"\\tpassed with A+\")"
]
},
{
"cell_type": "markdown",
"id": "5161d44f",
"metadata": {
"tags": [
"one-liner-conditions"
]
},
"source": [
"One-Liner Conditions\n",
"--\n",
"\n",
"`Syntax:`
\n",
"action_for_true if condition_True else action_for_false"
]
},
{
"cell_type": "code",
"execution_count": 93,
"id": "8f169fbc",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Yes'"
]
},
"execution_count": 93,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'Yes' if 5>2 else 'No'"
]
},
{
"cell_type": "code",
"execution_count": 94,
"id": "664c1878",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Yes'"
]
},
"execution_count": 94,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'Even' if 5%2==0 else ('Yes' if 5>2 else 'No') "
]
},
{
"cell_type": "markdown",
"id": "ac62fec0",
"metadata": {},
"source": [
"One-Liners are very useful ways of refactoring codes. They tend to optimize your code and make them easy to read and interpret. Once done right, they save you a tonne of work. On subsequent days, we will look at some more one-liner options of various constructs.
\n",
"\n",
"Let's try our hands on a few more examples from what we have learnt today."
]
},
{
"cell_type": "markdown",
"id": "aa3f38c2",
"metadata": {},
"source": [
"`Trial Example: `
\n"
]
},
{
"cell_type": "markdown",
"id": "9f6bfc16",
"metadata": {},
"source": [
"
\n",
" RECAP OF ITEMS STUDIED
\n",
"
\n",
"\n",
"
\n",
"
\n",
" END OF DAY ONE
\n"
]
}
],
"metadata": {
"celltoolbar": "Tags",
"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.8.12"
}
},
"nbformat": 4,
"nbformat_minor": 5
}