RafayAhmad/dotfiles
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
dotfiles/.config/Code/User/History/-51561e2a/cSz2.ipynb

2121 lines
41 KiB
Text
Raw Normal View History

update
2024-09-09 16:59:28 +05:00
{
"cells": [
{
"cell_type": "markdown",
"id": "d9be6007",
"metadata": {},
"source": [
"# Variables\n",
"In Python, variables are used to store and manage data. Each variable has a name and a value, and the type of the variable indicates what kind of data it can hold.\n",
"### Variable Naming Rules:\n",
" * Variable names in Python can contain alphanumerical characters `a-z`, `A-Z`, `0-9` and some special characters such as `_`.\n",
" * Normal variable names must start with a letter.\n",
" * By convention, variable names start with a lower-case letter, and Class names start with a capital letter.\n",
" * In addition, there are a number of Python keywords that cannot be used as variable names. These keywords are:\n",
"\n",
" and, as, assert, break, class, continue, def, del, elif, else, except, \n",
" exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n",
" pass, print, raise, return, try, while, with, yield\n"
]
},
{
"cell_type": "markdown",
"id": "736c7bab",
"metadata": {},
"source": [
"## Assignment in Python\n",
"The assignment operator in Python is `=`.\n",
"\n",
"Assigning a value to a new variable creates the variable:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f17cbaf7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10 John True\n"
]
}
],
"source": [
"#Assigning values to variable\n",
"x = 10\n",
"name = \"Joh\"\n",
"is_student = True\n",
"\n",
"#print the variable\n",
"print(x, name, is_student)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "3fe322b1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"What is your name?ali\n",
"Name: ali\n"
]
}
],
"source": [
"#using input and output in python\n",
"\n",
"name= input(\"What is your name?\")\n",
"print(\"Name:\", name)"
]
},
{
"cell_type": "markdown",
"id": "f0ecf03c",
"metadata": {},
"source": [
"# Operators\n",
"Most operators and comparisons in Python work as one would expect:\n",
"\n",
"### Arithmetic operators `+`, `-`, `*`, `/`, `//` (integer division), '**' power\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "4dc5a097",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3 -1 2 3\n"
]
}
],
"source": [
"print (1 + 2, 1 - 2, 1 * 2, 7 // 2)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "8ccede4f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.0 -1.0 2.0 0.5\n"
]
}
],
"source": [
"print (1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "96b9d6a0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0\n"
]
}
],
"source": [
"# Integer division of float numbers\n",
"print (3.0 // 2.0)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "499597eb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.5\n"
]
}
],
"source": [
"# Flaot division of integers\n",
"print (3/2)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "9082a90f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4\n"
]
}
],
"source": [
"# The power operators in python isn't ^, but **\n",
"print (2 ** 2)\n"
]
},
{
"cell_type": "markdown",
"id": "43c97990",
"metadata": {},
"source": [
"Note: The `/` operator always performs a floating point division in Python 3.x.\n",
"This is not true in Python 2.x, where the result of `/` is always an integer if the operands are integers.\n",
"to be more specific, `1/2 = 0.5` (`float`) in Python 3.x, and `1/2 = 0` (`int`) in Python 2.x (but `1.0/2 = 0.5` in Python 2.x)."
]
},
{
"cell_type": "markdown",
"id": "d0c64a24",
"metadata": {},
"source": [
"* The boolean operators are spelled out as the words `and`, `not`, `or`."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c875a486",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print (True and False)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "74efcd1e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print (not False)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "db035d4c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print (True or False)"
]
},
{
"cell_type": "markdown",
"id": "4f2f3959",
"metadata": {},
"source": [
"* Comparison operators `>`, `<`, `>=` (greater or equal), `<=` (less or equal), `==` equality, `is` identical."
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "4a655ee1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True False\n"
]
}
],
"source": [
"print (2 > 1, 2 < 1)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "960280fa",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True True\n"
]
}
],
"source": [
"print (2 >= 2, 2 <= 2)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "009ceee9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"# equality\n",
"print ([1,2] == [1,2])"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "414deba4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"# objects identical?\n",
"l1=l2=[1,2]\n",
"\n",
"print (l1 is l2)"
]
},
{
"cell_type": "markdown",
"id": "280e319e",
"metadata": {},
"source": [
"# Data Types\n",
"Python is a dynamically typed language, so we do not need to specify the type of a variable when we create one.\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "1f3cb259",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'float'>\n",
"<class 'int'>\n"
]
}
],
"source": [
"x=1.2\n",
"print(type(x))\n",
"\n",
"#If we assign a new value to a variable, its type can change.\n",
"x=3\n",
"print(type(x))"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "0a507159",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'int'>\n"
]
}
],
"source": [
"#integers\n",
"x = 1\n",
"print (type(x))"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "bf1a321c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'float'>\n"
]
}
],
"source": [
"# float\n",
"x = 1.0\n",
"print (type(x))"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "32492b1d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'bool'>\n"
]
}
],
"source": [
"# boolean\n",
"b1 = True\n",
"b2 = False\n",
"\n",
"print (type(b1))"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "9cf80875",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'complex'>\n"
]
}
],
"source": [
"# complex numbers: note the use of `j` to specify the imaginary part\n",
"x = 1.0 - 1.0j\n",
"print (type(x))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "1d1bc47e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(1-1j)\n",
"1.0 -1.0\n"
]
}
],
"source": [
"print(x)\n",
"print(x.real, x.imag)"
]
},
{
"cell_type": "markdown",
"id": "6f8f7f88",
"metadata": {},
"source": [
"Check if a certain variable is integer or float...."
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "5c422cc5",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"x= 5\n",
"print (type(x) is int)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "e915abab",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"x= 5.0\n",
"print (type(x) is int)"
]
},
{
"cell_type": "markdown",
"id": "b5efd598",
"metadata": {},
"source": [
"We can also use the `isinstance` method for testing types of variables:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "2b2880c6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print (isinstance(x, float))"
]
},
{
"cell_type": "markdown",
"id": "8ea12c90",
"metadata": {},
"source": [
"# Type casting\n",
"Typecasting in Python refers to the process of converting a variable from one data type to another. Python provides several built-in functions for typecasting. Here are some common typecasting functions:"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "ee5598a3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"# int(x)\n",
"\n",
"float_num = 3.14\n",
"int_num = int(float_num)\n",
"print(int_num)\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "a02a2e54",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5.0\n"
]
}
],
"source": [
"# float(x)\n",
"\n",
"int_num = 5\n",
"float_num = float(int_num)\n",
"print(float_num)\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "514957ba",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"# bool(x)\n",
"\n",
"number = 0\n",
"bool_value = bool(number)\n",
"print(bool_value)\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "322e28b2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['h', 'e', 'l', 'l', 'o']\n"
]
}
],
"source": [
"#list(x)\n",
"\n",
"string = \"hello\"\n",
"list_chars = list(string)\n",
"print(list_chars)"
]
},
{
"cell_type": "markdown",
"id": "61b6449d",
"metadata": {},
"source": [
"Complex variables cannot be cast to floats or integers. We need to use `z.real` or `z.imag` to extract the part of the complex number we want:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "f261b3fb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.0 4\n"
]
}
],
"source": [
"z = 3 + 4.2j\n",
"float_z= float(z.real)\n",
"int_z = int(z.imag)\n",
"print(float_z, int_z)"
]
},
{
"cell_type": "markdown",
"id": "71304a89",
"metadata": {},
"source": [
"# Compound data types: Strings, List and dictionaries\n",
"## Strings\n",
"Strings are the variable type that is used for storing text messages. "
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "c29c3b59",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'str'>\n"
]
}
],
"source": [
"s = \"Hello world\"\n",
"print (type(s))"
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "77ec8e67",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11\n"
]
}
],
"source": [
"# length of the string: the number of characters\n",
"print (len(s))"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "f7e42b91",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello test\n"
]
}
],
"source": [
"# replace a substring in a string with somethign else\n",
"s2 = s.replace(\"world\", \"test\")\n",
"print (s2)"
]
},
{
"cell_type": "markdown",
"id": "dcc1affc",
"metadata": {},
"source": [
"We can index a character in a string using `[]`:\n",
"\n",
"Indexing starts with 0\n",
"\n",
"We can extract a part of a string using the syntax `[start:stop]`, which extracts characters between index `start` and `stop` -1 (the character at index `stop` is not included):"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "6faf3700",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"H\n"
]
}
],
"source": [
"print (s[0])"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "a42f0cb6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hell\n"
]
}
],
"source": [
"print (s[0:4])"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "8935ac5c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"o\n"
]
}
],
"source": [
"print (s[4:5])"
]
},
{
"cell_type": "markdown",
"id": "45f6987c",
"metadata": {},
"source": [
"If we omit either (or both) of `start` or `stop` from `[start:stop]`, the default is the beginning and the end of the string, respectively:"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "e148143f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello\n"
]
}
],
"source": [
"print (s[:5])"
]
},
{
"cell_type": "code",
"execution_count": 36,
"id": "f0262e12",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"world\n"
]
}
],
"source": [
"print (s[6:])"
]
},
{
"cell_type": "code",
"execution_count": 37,
"id": "94c70a81",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello world\n"
]
}
],
"source": [
"print (s[:])"
]
},
{
"cell_type": "markdown",
"id": "8cae043b",
"metadata": {},
"source": [
" We can also define the step size using the syntax `[start:end:step]` (the default value for `step` is 1, as we saw above)\n",
" \n",
" \n",
"This technique is called *slicing*. Read more about the syntax here: http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "6dd4bde8",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hlowrd\n",
"He\n"
]
}
],
"source": [
"print (s[::2])\n",
"print (s[:2:1])"
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "e914acdf",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"str1 str2 str3\n"
]
}
],
"source": [
"print (\"str1\", \"str2\", \"str3\") # The print statement concatenates strings with a space"
]
},
{
"cell_type": "code",
"execution_count": 40,
"id": "cf65e8d7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"str1 1.0 False (-0-1j)\n"
]
}
],
"source": [
"print (\"str1\", 1.0, False, -1j) # The print statements converts all arguments to strings"
]
},
{
"cell_type": "code",
"execution_count": 41,
"id": "1ced3e89",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"str1str2str3\n"
]
}
],
"source": [
"print (\"str1\" + \"str2\" + \"str3\") # strings added with + are concatenated without space"
]
},
{
"cell_type": "markdown",
"id": "ed451e26",
"metadata": {},
"source": [
"## Lists\n",
"In Python, lists are mutable, commonly used to store collection of items.\n",
"\n",
"Lists contain comma separated values within square brackets `[]`:\n",
"\n",
"Elements in a list do not all have to be of the same type\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "8cc70b96",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['apple']"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_list = [1, 2, 3, 'apple', 'orange']\n",
"my_list =['apple']\n",
"my_list"
]
},
{
"cell_type": "markdown",
"id": "83421420",
"metadata": {},
"source": [
"Python lists can be inhomogeneous and arbitrarily nested:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"id": "0685822d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1,\n",
" [2,\n",
" 3,\n",
" [4,\n",
" 5,\n",
" [6, 7, 8, [9, [10, 11, [12, 13, [14, [15, [16]], [23]]], [22]]], [21]]],\n",
" [20]],\n",
" [19]]"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"k=[1,2.2,3,'a']\n",
"k=[1,[2,3,[4,5,[6,7,8,[9,[10,11,[12,13,[14,[15,[16]],[23]]],[22]]],[21]]],[20]],[19]]\n",
"k"
]
},
{
"cell_type": "markdown",
"id": "3dc3f384",
"metadata": {},
"source": [
"There are a number of convenient functions for generating lists of various types, for example the `range` function:\n",
"\n",
" in python 3 \"range\" generates an interator, which can be converted to a list using 'list(...)'.\n",
" It has no effect in python 2\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"id": "9b3ee3d4",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1,\n",
" 3,\n",
" 5,\n",
" 7,\n",
" 9,\n",
" 11,\n",
" 13,\n",
" 15,\n",
" 17,\n",
" 19,\n",
" 21,\n",
" 23,\n",
" 25,\n",
" 27,\n",
" 29,\n",
" 31,\n",
" 33,\n",
" 35,\n",
" 37,\n",
" 39,\n",
" 41,\n",
" 43,\n",
" 45,\n",
" 47,\n",
" 49,\n",
" 51,\n",
" 53,\n",
" 55,\n",
" 57,\n",
" 59,\n",
" 61,\n",
" 63,\n",
" 65,\n",
" 67,\n",
" 69,\n",
" 71,\n",
" 73,\n",
" 75,\n",
" 77,\n",
" 79,\n",
" 81,\n",
" 83,\n",
" 85,\n",
" 87,\n",
" 89,\n",
" 91,\n",
" 93,\n",
" 95,\n",
" 97,\n",
" 99]"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#print list(range(start, stop, step))\n",
"list(range(1,100,2))"
]
},
{
"cell_type": "code",
"execution_count": 47,
"id": "9a1a1d14",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
]
}
],
"source": [
"print (list(range(-10, 10)))"
]
},
{
"cell_type": "code",
"execution_count": 49,
"id": "0590772d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Peshawar'"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#different list operations\n",
"list1= [\"Lahore\", \"Karachi\", \"Peshawar\", \"Islamabad\"]\n",
"\n",
"#indexing\n",
"list1[2]"
]
},
{
"cell_type": "code",
"execution_count": 50,
"id": "33febd53",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Karachi']"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#slicing\n",
"list1[1:2]\n"
]
},
{
"cell_type": "code",
"execution_count": 51,
"id": "632913fb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Lahore', 'Karachi', 'Peshawar', 'Islamabad', 4, 5, 6]"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Concatenation\n",
"list2 = list1 + [4, 5, 6]\n",
"list2"
]
},
{
"cell_type": "code",
"execution_count": 52,
"id": "e04c4d3e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Lahore',\n",
" 'Karachi',\n",
" 'Peshawar',\n",
" 'Islamabad',\n",
" 'Lahore',\n",
" 'Karachi',\n",
" 'Peshawar',\n",
" 'Islamabad']"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Repitition\n",
"repeat_list = list1 * 2\n",
"repeat_list"
]
},
{
"cell_type": "markdown",
"id": "96bd06df",
"metadata": {},
"source": [
"### List Methods\n",
"#### Adding, inserting, modifying, and removing elements from lists"
]
},
{
"cell_type": "code",
"execution_count": 63,
"id": "7beb2e8b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3, 6, 8, 9, 0, 1, 'banana']"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#add an element to the end of the list\n",
"my_list = [3, 6, 8, 9, 0, 1]\n",
"my_list.append('banana')\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 64,
"id": "ed2af4bb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3, 6, 8, 9, 0, 1, 'banana', 7, 8, 9]"
]
},
"execution_count": 64,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Extend the list by appending elements from an iterable.\n",
"my_list.extend([7, 8, 9])\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 65,
"id": "3a8236ff",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3, 6, 'grape', 8, 9, 0, 1, 'banana', 7, 8, 9]"
]
},
"execution_count": 65,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Insert an element at a specified index.\n",
"my_list.insert(2, 'grape') # Insert 'grape' at index 2\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 66,
"id": "5fa0b722",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3, 6, 'grape', 8, 9, 0, 1, 7, 8, 9]"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Remove the first occurrence of a specified value\n",
"my_list.remove('banana')\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 67,
"id": "2f9c99ce",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3, 6, 8, 9, 0, 1, 7, 8, 9]"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Removes and returns the element at a specified index.\n",
"my_list.pop(2)\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 68,
"id": "c1b50c99",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 68,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Return the index of the first occurrence of a value.\n",
"index = my_list.index(6)\n",
"index"
]
},
{
"cell_type": "code",
"execution_count": 69,
"id": "4e6f634b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 69,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Return the number of occurrences of a value.\n",
"count_of_2 = my_list.count(2)\n",
"count_of_2"
]
},
{
"cell_type": "code",
"execution_count": 70,
"id": "80d2b6ed",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1, 3, 6, 7, 8, 8, 9, 9]"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Sorts the list in ascending order.\n",
"my_list.sort()\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 71,
"id": "d003dade",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[9, 9, 8, 8, 7, 6, 3, 1, 0]"
]
},
"execution_count": 71,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Reverse the order of elements in the list.\n",
"my_list.reverse()\n",
"my_list"
]
},
{
"cell_type": "code",
"execution_count": 72,
"id": "3a0f7451",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[9, 'a', 'd', 'd', 7, 6, 3, 1, 0]"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#list can also be modified by assigning the values at specific index\n",
"my_list[1:4]= ['a', 'd', 'd']\n",
"my_list"
]
},
{
"cell_type": "markdown",
"id": "42fb862a",
"metadata": {},
"source": [
"## Tuple\n",
"Tuples are like lists, except that they cannot be modified once created, that is they are *immutable*. \n",
"\n",
"In Python, tuples are created using the syntax `(..., ..., ...)`, or even `..., ...`:"
]
},
{
"cell_type": "code",
"execution_count": 74,
"id": "5273ebdf",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 2, 3, 'apple', 'orange')"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#creating a tuple\n",
"my_tuple = (1, 2, 3, 'apple', 'orange')\n",
"my_tuple"
]
},
{
"cell_type": "code",
"execution_count": 75,
"id": "f5cc6bda",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 75,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"first_element = my_tuple[0] # Access the first element\n",
"first_element"
]
},
{
"cell_type": "code",
"execution_count": 76,
"id": "a7eee4af",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 2, 3, 'apple', 'orange', 4, 5, 6)"
]
},
"execution_count": 76,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
" # concatenate a tuple\n",
"new_tuple = my_tuple + (4, 5, 6)\n",
"new_tuple"
]
},
{
"cell_type": "code",
"execution_count": 77,
"id": "d4c6836d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 2, 3, 'apple', 'orange', 1, 2, 3, 'apple', 'orange')"
]
},
"execution_count": 77,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# repeat a tuple using * operator\n",
"repeated_tuple = my_tuple * 2\n",
"repeated_tuple"
]
},
{
"cell_type": "code",
"execution_count": 78,
"id": "fc1e669f",
"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)",
"Input \u001b[1;32mIn [78]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# tuples are immutable so u cant modify it\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m my_tuple[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m11\u001b[39m\n",
"\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
]
}
],
"source": [
"# tuples are immutable so u cant modify it\n",
"#modifying a tuple would result in error\n",
"my_tuple[1] = 11"
]
},
{
"cell_type": "code",
"execution_count": 80,
"id": "997cb5f0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(10, 20) <class 'tuple'>\n"
]
}
],
"source": [
"point = 10, 20\n",
"\n",
"print (point, type(point))"
]
},
{
"cell_type": "markdown",
"id": "e2ae0783",
"metadata": {},
"source": [
"# Dictionaries\n",
"In Python, a dictionary is a collection type that allows you to store key-value pairs. Dictionaries are also known as associative arrays, hash maps, or hash tables in other programming languages. They are defined by enclosing comma-separated key-value pairs within curly braces {}"
]
},
{
"cell_type": "code",
"execution_count": 81,
"id": "0cca9c25",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}"
]
},
"execution_count": 81,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}\n",
"my_dict"
]
},
{
"cell_type": "code",
"execution_count": 87,
"id": "664db423",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'Ali': [2.7, 'B+'], 'Ahmad': [3.1, 'A'], 'Zain': [3.4, 'A']}"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_dict = {\n",
" 'Ali': [2.7, \"B+\"],\n",
" 'Ahmad': [3.1, \"A\"],\n",
" \"Zain\": [3.4, \"A\"]\n",
"}\n",
"my_dict"
]
},
{
"cell_type": "code",
"execution_count": 88,
"id": "661e601b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2.7, 'B+']"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#accessing an element using key value\n",
"my_dict['Ali']"
]
},
{
"cell_type": "code",
"execution_count": 90,
"id": "a6b07ecf",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'Ali': [2.7, 'B+'],\n",
" 'Ahmad': [3.1, 'A'],\n",
" 'Zain': [3.4, 'A'],\n",
" 'Ayesha': [4.0, 'A+']}"
]
},
"execution_count": 90,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_dict['Ayesha'] = [4.0, \"A+\"] # Add a new entry\n",
"my_dict"
]
},
{
"cell_type": "code",
"execution_count": 91,
"id": "87d36f4e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'Ali': [2.3, 'C+'],\n",
" 'Ahmad': [3.1, 'A'],\n",
" 'Zain': [3.4, 'A'],\n",
" 'Ayesha': [4.0, 'A+']}"
]
},
"execution_count": 91,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_dict['Ali'] = [2.3, \"C+\"] # Modify an existing entry\n",
"my_dict"
]
},
{
"cell_type": "code",
"execution_count": 92,
"id": "324d4f24",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'Ali': [2.3, 'C+'], 'Zain': [3.4, 'A'], 'Ayesha': [4.0, 'A+']}"
]
},
"execution_count": 92,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"del my_dict['Ahmad'] # Remove the entry with key \n",
"my_dict"
]
},
{
"cell_type": "code",
"execution_count": 93,
"id": "360a3779",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['Ali', 'Zain', 'Ayesha'])"
]
},
"execution_count": 93,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Return a view of all keys in the dictionary.\n",
"my_dict.keys()\n"
]
},
{
"cell_type": "code",
"execution_count": 94,
"id": "8d4022d3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict_values([[2.3, 'C+'], [3.4, 'A'], [4.0, 'A+']])"
]
},
"execution_count": 94,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Returns a view of all values in the dictionary.\n",
"my_dict.values()\n"
]
},
{
"cell_type": "code",
"execution_count": 96,
"id": "7397cd93",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict_items([('Ali', [2.3, 'C+']), ('Zain', [3.4, 'A']), ('Ayesha', [4.0, 'A+'])])"
]
},
"execution_count": 96,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Returns a view of all key-value pairs as tuples.\n",
"my_dict.items()"
]
},
{
"cell_type": "markdown",
"id": "30e7fa96",
"metadata": {},
"source": [
"# Sets\n",
"In Python, a set is an unordered and mutable collection of unique elements. Sets are defined by enclosing comma-separated values within curly braces {}. Here are some key characteristics and examples of sets in Python:\n",
"### Key Characteristics:\n",
"#### Uniqueness:\n",
"\n",
"Sets only allow unique elements. If you try to add a duplicate element, it will not be added.\n",
"#### Unordered:\n",
"\n",
"Sets are unordered, meaning the elements do not have a specific order.\n",
"#### Mutability:\n",
"\n",
"Sets are mutable, so you can add or remove elements after the set is created.\n",
"### Creating Sets:\n",
"You can create a set using the following syntax:"
]
},
{
"cell_type": "code",
"execution_count": 97,
"id": "f955e645",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 3, 4, 5}"
]
},
"execution_count": 97,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_set = {1, 2, 3, 4, 5}\n",
"my_set"
]
},
{
"cell_type": "code",
"execution_count": 99,
"id": "4c8de147",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 3, 4, 5, 6}"
]
},
"execution_count": 99,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#You can add elements to a set using the add() method.\n",
"my_set.add(6)\n",
"my_set"
]
},
{
"cell_type": "code",
"execution_count": 100,
"id": "05bb1e10",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 4, 5, 6}"
]
},
"execution_count": 100,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#You can remove elements using the remove() or discard() methods.\n",
"my_set.remove(3)\n",
"my_set"
]
},
{
"cell_type": "code",
"execution_count": 114,
"id": "bec000ac",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"set()"
]
},
"execution_count": 114,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Removes all elements from the set\n",
"my_set.clear()\n",
"my_set"
]
},
{
"cell_type": "code",
"execution_count": 115,
"id": "ea745432",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 3, 4, 5}"
]
},
"execution_count": 115,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#You can perform a union of two sets using the union() method or the | operator.\n",
"set1 = {1, 2, 3}\n",
"set2 = {3, 4, 5}\n",
"union_set = set1.union(set2)\n",
"union_set"
]
},
{
"cell_type": "code",
"execution_count": 116,
"id": "23b956c5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{3}"
]
},
"execution_count": 116,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#You can perform an intersection of two sets using the intersection() method or the & operator.\n",
"intersection_set = set1.intersection(set2)\n",
"intersection_set"
]
},
{
"cell_type": "code",
"execution_count": 117,
"id": "90449f5b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2}"
]
},
"execution_count": 117,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#You can find the difference between two sets using the difference() method or the - operator.\n",
"difference_set = set1.difference(set2)\n",
"difference_set"
]
},
{
"cell_type": "code",
"execution_count": 118,
"id": "3edda799",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 4, 5}"
]
},
"execution_count": 118,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# You can find the symmetric difference between two sets using the symmetric_difference() method or the ^ operator.\n",
"symmetric_difference_set = set1.symmetric_difference(set2)\n",
"symmetric_difference_set"
]
},
{
"cell_type": "code",
"execution_count": 120,
"id": "39ab8750",
"metadata": {},
"outputs": [],
"source": [
"set1.add(4)\n",
"set1.add(5)"
]
},
{
"cell_type": "code",
"execution_count": 121,
"id": "240f7a53",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 121,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"subset = set1.issubset(set2)\n",
"subset"
]
},
{
"cell_type": "code",
"execution_count": 122,
"id": "831460d0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 122,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"superset = set1.issuperset(set2)\n",
"superset"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5538bceb",
"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.9.12"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Reference in a new issue Copy permalink