├── Conditions.ipynb ├── Data Type Conversion and Type casting.ipynb ├── Data Types-Python.ipynb ├── Dictionary1.ipynb ├── Functions.ipynb ├── Hello World.ipynb ├── Indexing and slicing.ipynb ├── Lists.ipynb ├── Operators.ipynb ├── Python-loops.ipynb ├── Rules for naming the variable.ipynb ├── String Handling.ipynb └── Tuple.ipynb /Conditions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### Conditions\n", 8 | "### If statement" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 1, 14 | "metadata": {}, 15 | "outputs": [], 16 | "source": [ 17 | "a=50\n", 18 | "b=100\n", 19 | "if a>b:\n", 20 | " print(\"a is greater than b\") ### No output-Nothing is defined for False Statement" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "a is greater than b\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "a=150\n", 38 | "b=100\n", 39 | "if a>b:\n", 40 | " print(\"a is greater than b\") ### True-So there is output" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 3, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "name": "stdout", 50 | "output_type": "stream", 51 | "text": [ 52 | "b is greater\n" 53 | ] 54 | } 55 | ], 56 | "source": [ 57 | "a=34\n", 58 | "b=56\n", 59 | "if a>b:\n", 60 | " print(\"a is greater\")\n", 61 | "else:\n", 62 | " print(\"b is greater\")\n" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 12, 68 | "metadata": {}, 69 | "outputs": [ 70 | { 71 | "name": "stdout", 72 | "output_type": "stream", 73 | "text": [ 74 | "Enter the password:Hello\n", 75 | "Welcome to Home!\n" 76 | ] 77 | } 78 | ], 79 | "source": [ 80 | "x=str(input('Enter the password:'))\n", 81 | "if x=='Hello':\n", 82 | " print('Welcome to Home!')\n", 83 | "else:\n", 84 | " print('incorrect password')\n" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 6, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "8 is greater than zero\n" 97 | ] 98 | } 99 | ], 100 | "source": [ 101 | "num=8\n", 102 | "if(num>0):\n", 103 | " print(num,\"is greater than zero\")\n", 104 | "else:\n", 105 | " print(num,\"is less than zero\")" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 7, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "name": "stdout", 115 | "output_type": "stream", 116 | "text": [ 117 | "Less than average marks\n" 118 | ] 119 | } 120 | ], 121 | "source": [ 122 | "math = 10\n", 123 | "sci = 20\n", 124 | "eng =15\n", 125 | "\n", 126 | "if((math + sci + eng)/3 <= 35):\n", 127 | " print(\"Less than average marks\")\n", 128 | "else:\n", 129 | " print(\"Average score is: \", (math+sci+eng)/3)\n" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 19, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "name": "stdout", 139 | "output_type": "stream", 140 | "text": [ 141 | "-5 is less than zero\n" 142 | ] 143 | } 144 | ], 145 | "source": [ 146 | "### check if a number is greater than zero\n", 147 | "num=-5\n", 148 | "if(num>0):\n", 149 | " print(num,\"is greater than zero\")\n", 150 | "else:\n", 151 | " print(num,\"is less than zero\")" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "### if-elif-else" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 24, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "Enter age:14\n", 171 | "Bus fare is 30\n" 172 | ] 173 | } 174 | ], 175 | "source": [ 176 | "### Display Bus Fare\n", 177 | "age=int(input(\"Enter age:\"))\n", 178 | "if(0num2:\n", 213 | " print(num1,\"is greater\")\n", 214 | "else:\n", 215 | " if num3>num2:\n", 216 | " print(num3,\"is greater\")\n", 217 | " else:\n", 218 | " print(num2,\"is greater\")" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 46, 224 | "metadata": {}, 225 | "outputs": [ 226 | { 227 | "name": "stdout", 228 | "output_type": "stream", 229 | "text": [ 230 | "Enter user id:la_pl\n", 231 | "password:123\n", 232 | "password accepted.logged in\n" 233 | ] 234 | } 235 | ], 236 | "source": [ 237 | "### Progrm to check password for a user id\n", 238 | "user_id=input(\"Enter user id:\")\n", 239 | "password=input(\"password:\")\n", 240 | "if user_id==\"la_pl\":\n", 241 | " if password==\"123\":\n", 242 | " print(\"password accepted.logged in\")\n", 243 | " else:\n", 244 | " print(\"wrong password\")" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [] 253 | } 254 | ], 255 | "metadata": { 256 | "kernelspec": { 257 | "display_name": "Python 3", 258 | "language": "python", 259 | "name": "python3" 260 | }, 261 | "language_info": { 262 | "codemirror_mode": { 263 | "name": "ipython", 264 | "version": 3 265 | }, 266 | "file_extension": ".py", 267 | "mimetype": "text/x-python", 268 | "name": "python", 269 | "nbconvert_exporter": "python", 270 | "pygments_lexer": "ipython3", 271 | "version": "3.8.3" 272 | } 273 | }, 274 | "nbformat": 4, 275 | "nbformat_minor": 4 276 | } 277 | -------------------------------------------------------------------------------- /Data Type Conversion and Type casting.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Type Conversion\n", 8 | "### Implicit Conversion-Conversion done without Programmer's intervention\n", 9 | "### Explicit Conversion -user fefined that forces conversion" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 4, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stdout", 19 | "output_type": "stream", 20 | "text": [ 21 | "112.5\n" 22 | ] 23 | }, 24 | { 25 | "data": { 26 | "text/plain": [ 27 | "float" 28 | ] 29 | }, 30 | "execution_count": 4, 31 | "metadata": {}, 32 | "output_type": "execute_result" 33 | } 34 | ], 35 | "source": [ 36 | "### implicit\n", 37 | "price=22.5\n", 38 | "units=5\n", 39 | "total=price*units\n", 40 | "print(total)\n", 41 | "type(total)" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 7, 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "ename": "TypeError", 51 | "evalue": "unsupported operand type(s) for +: 'int' and 'str'", 52 | "output_type": "error", 53 | "traceback": [ 54 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 55 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 56 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mincome\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m10000\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mtax\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"123.5\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mtotal\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mincome\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mtax\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtotal\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 57 | "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" 58 | ] 59 | } 60 | ], 61 | "source": [ 62 | "### explicit\n", 63 | "income=10000\n", 64 | "tax=\"123.5\"\n", 65 | "total=income+tax\n", 66 | "print(total)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 9, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "10123.5\n" 79 | ] 80 | } 81 | ], 82 | "source": [ 83 | "income=10000\n", 84 | "tax=\"123.5\"\n", 85 | "total=income+float(tax)\n", 86 | "print(total)" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 12, 92 | "metadata": {}, 93 | "outputs": [ 94 | { 95 | "ename": "ValueError", 96 | "evalue": "invalid literal for int() with base 10: '123.5'", 97 | "output_type": "error", 98 | "traceback": [ 99 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 100 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 101 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mincome\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m10000\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mtax\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"123.5\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mtotal\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mincome\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtax\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtotal\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 102 | "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: '123.5'" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "income=10000\n", 108 | "tax=\"123.5\"\n", 109 | "total=income+int(tax)\n", 110 | "print(total)" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 13, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "name": "stdout", 120 | "output_type": "stream", 121 | "text": [ 122 | "10123\n" 123 | ] 124 | } 125 | ], 126 | "source": [ 127 | "income=10000\n", 128 | "tax=\"123\"\n", 129 | "total=income+int(tax)\n", 130 | "print(total)" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "## Type casting\n", 138 | "### int()\n", 139 | "### float()\n", 140 | "### bool()\n", 141 | "### str" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "# int to other type conversion" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 14, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "data": { 158 | "text/plain": [ 159 | "12.0" 160 | ] 161 | }, 162 | "execution_count": 14, 163 | "metadata": {}, 164 | "output_type": "execute_result" 165 | } 166 | ], 167 | "source": [ 168 | "x=12\n", 169 | "float(x)" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 15, 175 | "metadata": {}, 176 | "outputs": [ 177 | { 178 | "data": { 179 | "text/plain": [ 180 | "True" 181 | ] 182 | }, 183 | "execution_count": 15, 184 | "metadata": {}, 185 | "output_type": "execute_result" 186 | } 187 | ], 188 | "source": [ 189 | "bool(x)" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 16, 195 | "metadata": {}, 196 | "outputs": [ 197 | { 198 | "data": { 199 | "text/plain": [ 200 | "'12'" 201 | ] 202 | }, 203 | "execution_count": 16, 204 | "metadata": {}, 205 | "output_type": "execute_result" 206 | } 207 | ], 208 | "source": [ 209 | "str(x)" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "# float to other type conversion" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": 21, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [ 225 | "y=12.9" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 22, 231 | "metadata": {}, 232 | "outputs": [ 233 | { 234 | "data": { 235 | "text/plain": [ 236 | "12" 237 | ] 238 | }, 239 | "execution_count": 22, 240 | "metadata": {}, 241 | "output_type": "execute_result" 242 | } 243 | ], 244 | "source": [ 245 | "int(y)" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 23, 251 | "metadata": {}, 252 | "outputs": [ 253 | { 254 | "data": { 255 | "text/plain": [ 256 | "True" 257 | ] 258 | }, 259 | "execution_count": 23, 260 | "metadata": {}, 261 | "output_type": "execute_result" 262 | } 263 | ], 264 | "source": [ 265 | "bool(y)" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": 24, 271 | "metadata": {}, 272 | "outputs": [ 273 | { 274 | "data": { 275 | "text/plain": [ 276 | "'12.9'" 277 | ] 278 | }, 279 | "execution_count": 24, 280 | "metadata": {}, 281 | "output_type": "execute_result" 282 | } 283 | ], 284 | "source": [ 285 | "str(y)" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": {}, 291 | "source": [ 292 | "# string to other type conversion" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 25, 298 | "metadata": {}, 299 | "outputs": [], 300 | "source": [ 301 | "z=\"latha\"" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": 26, 307 | "metadata": {}, 308 | "outputs": [ 309 | { 310 | "ename": "ValueError", 311 | "evalue": "invalid literal for int() with base 10: 'latha'", 312 | "output_type": "error", 313 | "traceback": [ 314 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 315 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 316 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 317 | "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'latha'" 318 | ] 319 | } 320 | ], 321 | "source": [ 322 | "int(z)" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 27, 328 | "metadata": {}, 329 | "outputs": [ 330 | { 331 | "ename": "ValueError", 332 | "evalue": "could not convert string to float: 'latha'", 333 | "output_type": "error", 334 | "traceback": [ 335 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 336 | "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", 337 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 338 | "\u001b[1;31mValueError\u001b[0m: could not convert string to float: 'latha'" 339 | ] 340 | } 341 | ], 342 | "source": [ 343 | "float(z)" 344 | ] 345 | }, 346 | { 347 | "cell_type": "markdown", 348 | "metadata": {}, 349 | "source": [ 350 | "# bool to other data types" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 28, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "data": { 360 | "text/plain": [ 361 | "True" 362 | ] 363 | }, 364 | "execution_count": 28, 365 | "metadata": {}, 366 | "output_type": "execute_result" 367 | } 368 | ], 369 | "source": [ 370 | "bool(z)" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": 29, 376 | "metadata": {}, 377 | "outputs": [], 378 | "source": [ 379 | "a=True" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 31, 385 | "metadata": {}, 386 | "outputs": [ 387 | { 388 | "data": { 389 | "text/plain": [ 390 | "1.0" 391 | ] 392 | }, 393 | "execution_count": 31, 394 | "metadata": {}, 395 | "output_type": "execute_result" 396 | } 397 | ], 398 | "source": [ 399 | "float(a)" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 32, 405 | "metadata": {}, 406 | "outputs": [ 407 | { 408 | "data": { 409 | "text/plain": [ 410 | "1" 411 | ] 412 | }, 413 | "execution_count": 32, 414 | "metadata": {}, 415 | "output_type": "execute_result" 416 | } 417 | ], 418 | "source": [ 419 | "int(a)" 420 | ] 421 | }, 422 | { 423 | "cell_type": "code", 424 | "execution_count": 33, 425 | "metadata": {}, 426 | "outputs": [ 427 | { 428 | "data": { 429 | "text/plain": [ 430 | "'True'" 431 | ] 432 | }, 433 | "execution_count": 33, 434 | "metadata": {}, 435 | "output_type": "execute_result" 436 | } 437 | ], 438 | "source": [ 439 | "str(a)" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": 34, 445 | "metadata": {}, 446 | "outputs": [], 447 | "source": [ 448 | "b=False" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": 35, 454 | "metadata": {}, 455 | "outputs": [ 456 | { 457 | "data": { 458 | "text/plain": [ 459 | "0.0" 460 | ] 461 | }, 462 | "execution_count": 35, 463 | "metadata": {}, 464 | "output_type": "execute_result" 465 | } 466 | ], 467 | "source": [ 468 | "float(b)" 469 | ] 470 | }, 471 | { 472 | "cell_type": "code", 473 | "execution_count": 36, 474 | "metadata": {}, 475 | "outputs": [ 476 | { 477 | "data": { 478 | "text/plain": [ 479 | "0" 480 | ] 481 | }, 482 | "execution_count": 36, 483 | "metadata": {}, 484 | "output_type": "execute_result" 485 | } 486 | ], 487 | "source": [ 488 | "int(b)" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": 37, 494 | "metadata": {}, 495 | "outputs": [ 496 | { 497 | "data": { 498 | "text/plain": [ 499 | "'False'" 500 | ] 501 | }, 502 | "execution_count": 37, 503 | "metadata": {}, 504 | "output_type": "execute_result" 505 | } 506 | ], 507 | "source": [ 508 | "str(b)" 509 | ] 510 | } 511 | ], 512 | "metadata": { 513 | "kernelspec": { 514 | "display_name": "Python 3", 515 | "language": "python", 516 | "name": "python3" 517 | }, 518 | "language_info": { 519 | "codemirror_mode": { 520 | "name": "ipython", 521 | "version": 3 522 | }, 523 | "file_extension": ".py", 524 | "mimetype": "text/x-python", 525 | "name": "python", 526 | "nbconvert_exporter": "python", 527 | "pygments_lexer": "ipython3", 528 | "version": "3.8.3" 529 | } 530 | }, 531 | "nbformat": 4, 532 | "nbformat_minor": 4 533 | } 534 | -------------------------------------------------------------------------------- /Data Types-Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### Data Types" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "latha\n" 20 | ] 21 | }, 22 | { 23 | "data": { 24 | "text/plain": [ 25 | "str" 26 | ] 27 | }, 28 | "execution_count": 1, 29 | "metadata": {}, 30 | "output_type": "execute_result" 31 | } 32 | ], 33 | "source": [ 34 | "name=\"latha\" ## String \n", 35 | "print(name)\n", 36 | "type(name)" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "### Numeric-Integer and Float" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "name": "stdout", 53 | "output_type": "stream", 54 | "text": [ 55 | "5\n", 56 | "3.5\n" 57 | ] 58 | } 59 | ], 60 | "source": [ 61 | "num_of_unit=5\n", 62 | "price_per_unit=3.5\n", 63 | "print(num_of_unit)\n", 64 | "print(price_per_unit)\n" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 5, 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "text/plain": [ 75 | "int" 76 | ] 77 | }, 78 | "execution_count": 5, 79 | "metadata": {}, 80 | "output_type": "execute_result" 81 | } 82 | ], 83 | "source": [ 84 | "type(num_of_unit) ### no decimal point" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 6, 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "text/plain": [ 95 | "float" 96 | ] 97 | }, 98 | "execution_count": 6, 99 | "metadata": {}, 100 | "output_type": "execute_result" 101 | } 102 | ], 103 | "source": [ 104 | "type(price_per_unit) ### decimal point" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 8, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "text/plain": [ 115 | "bool" 116 | ] 117 | }, 118 | "execution_count": 8, 119 | "metadata": {}, 120 | "output_type": "execute_result" 121 | } 122 | ], 123 | "source": [ 124 | "x=True\n", 125 | "type(x)" 126 | ] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "## Assessment\n", 133 | "### y=False\n", 134 | "### x=\"True\"\n", 135 | "### your height in cm\n", 136 | "### your weight in digital scale" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | } 146 | ], 147 | "metadata": { 148 | "kernelspec": { 149 | "display_name": "Python 3", 150 | "language": "python", 151 | "name": "python3" 152 | }, 153 | "language_info": { 154 | "codemirror_mode": { 155 | "name": "ipython", 156 | "version": 3 157 | }, 158 | "file_extension": ".py", 159 | "mimetype": "text/x-python", 160 | "name": "python", 161 | "nbconvert_exporter": "python", 162 | "pygments_lexer": "ipython3", 163 | "version": "3.8.3" 164 | } 165 | }, 166 | "nbformat": 4, 167 | "nbformat_minor": 4 168 | } 169 | -------------------------------------------------------------------------------- /Dictionary1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Dictionary" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "{1: 'Fourth', 2: 'First', 3: 'Third'}\n" 20 | ] 21 | } 22 | ], 23 | "source": [ 24 | "dict_1={1:\"First\",2:\"First\",3:\"Third\",1:\"Fourth\"}\n", 25 | "print(dict_1)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "data": { 35 | "text/plain": [ 36 | "'First'" 37 | ] 38 | }, 39 | "execution_count": 2, 40 | "metadata": {}, 41 | "output_type": "execute_result" 42 | } 43 | ], 44 | "source": [ 45 | "dict_1[2]" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 4, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "dict_1[2]=\"Seventh\"" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 5, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "name": "stdout", 64 | "output_type": "stream", 65 | "text": [ 66 | "{1: 'Fourth', 2: 'Seventh', 3: 'Third'}\n" 67 | ] 68 | } 69 | ], 70 | "source": [ 71 | "print(dict_1)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 7, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "del dict_1[2]" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 8, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "name": "stdout", 90 | "output_type": "stream", 91 | "text": [ 92 | "{1: 'Fourth', 3: 'Third'}\n" 93 | ] 94 | } 95 | ], 96 | "source": [ 97 | "print(dict_1)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## Word count" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 10, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "name": "stdout", 114 | "output_type": "stream", 115 | "text": [ 116 | "{'can': 6, 'you': 1, 'a': 3, 'as': 1, 'canner': 1}\n" 117 | ] 118 | } 119 | ], 120 | "source": [ 121 | "twister=\"can you can a can as a canner can can a can\"\n", 122 | "word_count={}\n", 123 | "for word in twister.split():\n", 124 | " if word not in word_count:\n", 125 | " word_count[word]=1\n", 126 | " else:\n", 127 | " word_count[word]+=1\n", 128 | "print(word_count)\n", 129 | " " 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "## default dictionary" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 11, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [ 145 | "from collections import defaultdict" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 14, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "word_count=defaultdict(int)\n", 155 | "for word in twister.split():\n", 156 | " word_count[word]+=1" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 15, 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "data": { 166 | "text/plain": [ 167 | "defaultdict(int, {'can': 6, 'you': 1, 'a': 3, 'as': 1, 'canner': 1})" 168 | ] 169 | }, 170 | "execution_count": 15, 171 | "metadata": {}, 172 | "output_type": "execute_result" 173 | } 174 | ], 175 | "source": [ 176 | "word_count" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 16, 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "data": { 186 | "text/plain": [ 187 | "2" 188 | ] 189 | }, 190 | "execution_count": 16, 191 | "metadata": {}, 192 | "output_type": "execute_result" 193 | } 194 | ], 195 | "source": [ 196 | "len(dict_1)" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 18, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "data": { 206 | "text/plain": [ 207 | "dict_keys([1, 3])" 208 | ] 209 | }, 210 | "execution_count": 18, 211 | "metadata": {}, 212 | "output_type": "execute_result" 213 | } 214 | ], 215 | "source": [ 216 | "dict_1.keys()" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": 19, 222 | "metadata": {}, 223 | "outputs": [ 224 | { 225 | "data": { 226 | "text/plain": [ 227 | "dict_values(['Fourth', 'Third'])" 228 | ] 229 | }, 230 | "execution_count": 19, 231 | "metadata": {}, 232 | "output_type": "execute_result" 233 | } 234 | ], 235 | "source": [ 236 | "dict_1.values()" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": 20, 242 | "metadata": {}, 243 | "outputs": [ 244 | { 245 | "data": { 246 | "text/plain": [ 247 | "dict_items([(1, 'Fourth'), (3, 'Third')])" 248 | ] 249 | }, 250 | "execution_count": 20, 251 | "metadata": {}, 252 | "output_type": "execute_result" 253 | } 254 | ], 255 | "source": [ 256 | "dict_1.items()" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": 23, 262 | "metadata": {}, 263 | "outputs": [ 264 | { 265 | "data": { 266 | "text/plain": [ 267 | "'Third'" 268 | ] 269 | }, 270 | "execution_count": 23, 271 | "metadata": {}, 272 | "output_type": "execute_result" 273 | } 274 | ], 275 | "source": [ 276 | "dict_1.get(3)" 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": 22, 282 | "metadata": {}, 283 | "outputs": [ 284 | { 285 | "data": { 286 | "text/plain": [ 287 | "{1: 'Fourth', 3: 'Third'}" 288 | ] 289 | }, 290 | "execution_count": 22, 291 | "metadata": {}, 292 | "output_type": "execute_result" 293 | } 294 | ], 295 | "source": [ 296 | "dict_1" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 26, 302 | "metadata": {}, 303 | "outputs": [ 304 | { 305 | "data": { 306 | "text/plain": [ 307 | "{1: 'Fourth', 3: 'Third', 10: 'Tenth'}" 308 | ] 309 | }, 310 | "execution_count": 26, 311 | "metadata": {}, 312 | "output_type": "execute_result" 313 | } 314 | ], 315 | "source": [ 316 | "dict_1.setdefault(10,\"Tenth\")\n", 317 | "dict_1" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": null, 323 | "metadata": {}, 324 | "outputs": [], 325 | "source": [] 326 | } 327 | ], 328 | "metadata": { 329 | "kernelspec": { 330 | "display_name": "Python 3", 331 | "language": "python", 332 | "name": "python3" 333 | }, 334 | "language_info": { 335 | "codemirror_mode": { 336 | "name": "ipython", 337 | "version": 3 338 | }, 339 | "file_extension": ".py", 340 | "mimetype": "text/x-python", 341 | "name": "python", 342 | "nbconvert_exporter": "python", 343 | "pygments_lexer": "ipython3", 344 | "version": "3.8.3" 345 | } 346 | }, 347 | "nbformat": 4, 348 | "nbformat_minor": 4 349 | } 350 | -------------------------------------------------------------------------------- /Functions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### Functions - A block of reusable code that runs when called\n", 8 | "#### Built-in\n", 9 | "#### User defined\n", 10 | "#### lambda " 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "### built-in" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 8, 23 | "metadata": {}, 24 | "outputs": [ 25 | { 26 | "name": "stdout", 27 | "output_type": "stream", 28 | "text": [ 29 | "Hello:Welcome to the session\n" 30 | ] 31 | } 32 | ], 33 | "source": [ 34 | "print(\"Hello\",\"Welcome to the session\",sep=':')" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 9, 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "name": "stdout", 44 | "output_type": "stream", 45 | "text": [ 46 | "Pythonis fun\n" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "print(\"Python\" + \"is fun\")" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 10, 57 | "metadata": {}, 58 | "outputs": [ 59 | { 60 | "ename": "TypeError", 61 | "evalue": "can only concatenate str (not \"int\") to str", 62 | "output_type": "error", 63 | "traceback": [ 64 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 65 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 66 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"My phone number is\"\u001b[0m\u001b[1;33m+\u001b[0m \u001b[1;36m90000000\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 67 | "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str" 68 | ] 69 | } 70 | ], 71 | "source": [ 72 | "print(\"My phone number is\"+ 90000000)" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 11, 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "name": "stdout", 82 | "output_type": "stream", 83 | "text": [ 84 | "My phone number is90000000\n" 85 | ] 86 | } 87 | ], 88 | "source": [ 89 | "print(\"My phone number is\"+ str(90000000))" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 12, 95 | "metadata": {}, 96 | "outputs": [ 97 | { 98 | "name": "stdout", 99 | "output_type": "stream", 100 | "text": [ 101 | "Hello and Welcome to the session\n" 102 | ] 103 | } 104 | ], 105 | "source": [ 106 | "### User Defined\n", 107 | "def greet():\n", 108 | " print(\"Hello and Welcome to the session\")\n", 109 | "greet()" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 13, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "name": "stdout", 119 | "output_type": "stream", 120 | "text": [ 121 | "Enter your name:latha\n", 122 | "Hello latha Welcome to the session\n" 123 | ] 124 | } 125 | ], 126 | "source": [ 127 | "def greet(name):\n", 128 | " print(\"Hello\",name,\"Welcome to the session\")\n", 129 | "person_name=input(\"Enter your name:\")\n", 130 | "greet(person_name)" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 7, 136 | "metadata": {}, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "10\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "def addition(num1,num2):\n", 148 | " add=num1+num2\n", 149 | " return(add)\n", 150 | "summation=addition(2,8)\n", 151 | "print(summation)" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 14, 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "data": { 161 | "text/plain": [ 162 | "25.0" 163 | ] 164 | }, 165 | "execution_count": 14, 166 | "metadata": {}, 167 | "output_type": "execute_result" 168 | } 169 | ], 170 | "source": [ 171 | "def area_of_triangle(base,height):\n", 172 | " return(0.5*base*height)\n", 173 | "\n", 174 | "area_of_triangle(5,10)" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 17, 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "name": "stdout", 184 | "output_type": "stream", 185 | "text": [ 186 | "Hello and welcome\n" 187 | ] 188 | } 189 | ], 190 | "source": [ 191 | "def greet():\n", 192 | " print(\"Hello and welcome\")\n", 193 | "greet()" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 18, 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "Hello\n", 206 | "Welcome\n" 207 | ] 208 | } 209 | ], 210 | "source": [ 211 | "def hello_and_welcome():\n", 212 | " print(\"Hello\")\n", 213 | " print(\"Welcome\")\n", 214 | "hello_and_welcome()" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 19, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "name": "stdout", 224 | "output_type": "stream", 225 | "text": [ 226 | "Enter your name:latha\n", 227 | "Hello latha Welcome to the Session\n", 228 | "Enter your name:premalatha\n" 229 | ] 230 | }, 231 | { 232 | "ename": "TypeError", 233 | "evalue": "greet() missing 1 required positional argument: 'name'", 234 | "output_type": "error", 235 | "traceback": [ 236 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 237 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 238 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mperson_name\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Enter your name:\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mgreet\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", 239 | "\u001b[1;31mTypeError\u001b[0m: greet() missing 1 required positional argument: 'name'" 240 | ] 241 | } 242 | ], 243 | "source": [ 244 | "def greet(name):\n", 245 | " print(\"Hello\",name,\"Welcome to the Session\")\n", 246 | "person_name=input(\"Enter your name:\")\n", 247 | "greet(person_name)\n", 248 | "\n", 249 | "person_name=input(\"Enter your name:\")\n", 250 | "greet()\n", 251 | "\n" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": 20, 257 | "metadata": {}, 258 | "outputs": [ 259 | { 260 | "name": "stdout", 261 | "output_type": "stream", 262 | "text": [ 263 | "25\n" 264 | ] 265 | } 266 | ], 267 | "source": [ 268 | "def addition(num1,num2):\n", 269 | " add=num1+num2\n", 270 | " return(add)\n", 271 | "\n", 272 | "sum=addition(12,13)\n", 273 | "print(sum)" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": 21, 279 | "metadata": {}, 280 | "outputs": [ 281 | { 282 | "name": "stdout", 283 | "output_type": "stream", 284 | "text": [ 285 | "()\n", 286 | "11\n" 287 | ] 288 | } 289 | ], 290 | "source": [ 291 | "def addition(num1,num2):\n", 292 | " add=num1+num2\n", 293 | " return()\n", 294 | "sum=addition(12,13)\n", 295 | "print(sum)\n", 296 | "\n", 297 | "x=lambda a,b,c:a+b+c\n", 298 | "print(x(5,4,2))" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 23, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "ename": "NameError", 308 | "evalue": "name 'num1' is not defined", 309 | "output_type": "error", 310 | "traceback": [ 311 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 312 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 313 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;32mreturn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0maddition\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mnum2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 314 | "\u001b[1;31mNameError\u001b[0m: name 'num1' is not defined" 315 | ] 316 | } 317 | ], 318 | "source": [ 319 | "def addition(num1,num2):\n", 320 | " num1 = float(input(\"Enter the Number 1 \"))\n", 321 | " num2 = float(input(\"Enter the Number 2 \"))\n", 322 | " add = num1 + num2\n", 323 | " return(add)\n", 324 | "\n", 325 | "addition(num1,num2)" 326 | ] 327 | }, 328 | { 329 | "cell_type": "code", 330 | "execution_count": 24, 331 | "metadata": {}, 332 | "outputs": [ 333 | { 334 | "name": "stdout", 335 | "output_type": "stream", 336 | "text": [ 337 | "First argument is: 10\n", 338 | "Second argument is: 2\n" 339 | ] 340 | } 341 | ], 342 | "source": [ 343 | "### Passing Arguments\n", 344 | "\n", 345 | "def addition(num1,num2):\n", 346 | " print(\"First argument is:\",num1)\n", 347 | " print(\"Second argument is:\",num2)\n", 348 | "num1=2\n", 349 | "num2=10\n", 350 | "addition(num2,num1)" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "### Lambda Function\n" 358 | ] 359 | }, 360 | { 361 | "cell_type": "code", 362 | "execution_count": 29, 363 | "metadata": {}, 364 | "outputs": [ 365 | { 366 | "data": { 367 | "text/plain": [ 368 | "8" 369 | ] 370 | }, 371 | "execution_count": 29, 372 | "metadata": {}, 373 | "output_type": "execute_result" 374 | } 375 | ], 376 | "source": [ 377 | "\n", 378 | "### greatest number\n", 379 | "def greater(num1,num2):\n", 380 | " if(num1>num2):\n", 381 | " return num1\n", 382 | " else:\n", 383 | " return num2\n", 384 | "\n", 385 | "great=greater(7,8)\n", 386 | "great\n", 387 | "\n", 388 | "greater=lambda num1,num2:num1 if num1>num2 else num2\n", 389 | "greater(7,8)" 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": 30, 395 | "metadata": {}, 396 | "outputs": [ 397 | { 398 | "name": "stdout", 399 | "output_type": "stream", 400 | "text": [ 401 | "[5, 7, 22, 97, 62, 77, 23, 73, 61]\n" 402 | ] 403 | } 404 | ], 405 | "source": [ 406 | "\n", 407 | "li = [5, 7, 22, 97, 54, 62, 77, 23, 73, 61,33,99]\n", 408 | "final_list = list(filter(lambda x: (x%3 != 0) , li))\n", 409 | "print(final_list)" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": 31, 415 | "metadata": {}, 416 | "outputs": [ 417 | { 418 | "name": "stdout", 419 | "output_type": "stream", 420 | "text": [ 421 | "[25, 49, 484, 9409, 2916, 3844, 5929, 529, 5329, 3721]\n" 422 | ] 423 | } 424 | ], 425 | "source": [ 426 | "li = [5, 7, 22, 97, 54, 62, 77, 23, 73, 61]\n", 427 | "final_list = list(map(lambda x: x**2, li))\n", 428 | "print(final_list)" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": 32, 434 | "metadata": {}, 435 | "outputs": [ 436 | { 437 | "data": { 438 | "text/plain": [ 439 | "120" 440 | ] 441 | }, 442 | "execution_count": 32, 443 | "metadata": {}, 444 | "output_type": "execute_result" 445 | } 446 | ], 447 | "source": [ 448 | "from functools import reduce\n", 449 | "num_list=[1,2,3,4,5]\n", 450 | "reduce(lambda a,b:a*b,num_list)" 451 | ] 452 | }, 453 | { 454 | "cell_type": "code", 455 | "execution_count": null, 456 | "metadata": {}, 457 | "outputs": [], 458 | "source": [] 459 | } 460 | ], 461 | "metadata": { 462 | "kernelspec": { 463 | "display_name": "Python 3", 464 | "language": "python", 465 | "name": "python3" 466 | }, 467 | "language_info": { 468 | "codemirror_mode": { 469 | "name": "ipython", 470 | "version": 3 471 | }, 472 | "file_extension": ".py", 473 | "mimetype": "text/x-python", 474 | "name": "python", 475 | "nbconvert_exporter": "python", 476 | "pygments_lexer": "ipython3", 477 | "version": "3.8.3" 478 | } 479 | }, 480 | "nbformat": 4, 481 | "nbformat_minor": 4 482 | } 483 | -------------------------------------------------------------------------------- /Hello World.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Hello World\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "print(\"Hello World\")" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 3, 23 | "metadata": {}, 24 | "outputs": [ 25 | { 26 | "ename": "NameError", 27 | "evalue": "name 'Print' is not defined", 28 | "output_type": "error", 29 | "traceback": [ 30 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 31 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 32 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mPrint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Hello World\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;31m### It should be print not Print\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 33 | "\u001b[1;31mNameError\u001b[0m: name 'Print' is not defined" 34 | ] 35 | } 36 | ], 37 | "source": [ 38 | "Print(\"Hello World\")### It should be print not Print" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 4, 44 | "metadata": {}, 45 | "outputs": [ 46 | { 47 | "ename": "SyntaxError", 48 | "evalue": "invalid syntax (, line 1)", 49 | "output_type": "error", 50 | "traceback": [ 51 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m print(Hello World)\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" 52 | ] 53 | } 54 | ], 55 | "source": [ 56 | "print(Hello World)### Inverted comma is missing" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 5, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "name": "stdout", 66 | "output_type": "stream", 67 | "text": [ 68 | "Hello World\n" 69 | ] 70 | } 71 | ], 72 | "source": [ 73 | "print('Hello World')### single or double inverted comma is necessary for string" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 8, 79 | "metadata": {}, 80 | "outputs": [ 81 | { 82 | "name": "stdout", 83 | "output_type": "stream", 84 | "text": [ 85 | "10.5\n" 86 | ] 87 | } 88 | ], 89 | "source": [ 90 | "print(10.5)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [] 99 | } 100 | ], 101 | "metadata": { 102 | "kernelspec": { 103 | "display_name": "Python 3", 104 | "language": "python", 105 | "name": "python3" 106 | }, 107 | "language_info": { 108 | "codemirror_mode": { 109 | "name": "ipython", 110 | "version": 3 111 | }, 112 | "file_extension": ".py", 113 | "mimetype": "text/x-python", 114 | "name": "python", 115 | "nbconvert_exporter": "python", 116 | "pygments_lexer": "ipython3", 117 | "version": "3.8.3" 118 | } 119 | }, 120 | "nbformat": 4, 121 | "nbformat_minor": 4 122 | } 123 | -------------------------------------------------------------------------------- /Indexing and slicing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### Indexing and Slicing" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "text=\"Data Science is fun\" ### declare a string" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 2, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "data": { 26 | "text/plain": [ 27 | "'D'" 28 | ] 29 | }, 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "output_type": "execute_result" 33 | } 34 | ], 35 | "source": [ 36 | "text[0] ### index start from 0" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 9, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "'c'" 48 | ] 49 | }, 50 | "execution_count": 9, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "text[10]" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 8, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "ename": "IndexError", 66 | "evalue": "string index out of range", 67 | "output_type": "error", 68 | "traceback": [ 69 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 70 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 71 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtext\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 72 | "\u001b[1;31mIndexError\u001b[0m: string index out of range" 73 | ] 74 | } 75 | ], 76 | "source": [ 77 | "text[20] ### there is no index of 20" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 3, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "text/plain": [ 88 | "'Data Science is fun'" 89 | ] 90 | }, 91 | "execution_count": 3, 92 | "metadata": {}, 93 | "output_type": "execute_result" 94 | } 95 | ], 96 | "source": [ 97 | " ### display all the elementstext[:]" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": 5, 103 | "metadata": {}, 104 | "outputs": [ 105 | { 106 | "data": { 107 | "text/plain": [ 108 | "19" 109 | ] 110 | }, 111 | "execution_count": 5, 112 | "metadata": {}, 113 | "output_type": "execute_result" 114 | } 115 | ], 116 | "source": [ 117 | "len(text) ### count" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 7, 123 | "metadata": {}, 124 | "outputs": [ 125 | { 126 | "data": { 127 | "text/plain": [ 128 | "'Data Science is fun'" 129 | ] 130 | }, 131 | "execution_count": 7, 132 | "metadata": {}, 133 | "output_type": "execute_result" 134 | } 135 | ], 136 | "source": [ 137 | "text[:len(text)] ### display all the elemrents using index" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 10, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "data": { 147 | "text/plain": [ 148 | "'Data '" 149 | ] 150 | }, 151 | "execution_count": 10, 152 | "metadata": {}, 153 | "output_type": "execute_result" 154 | } 155 | ], 156 | "source": [ 157 | "text[0:5]" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 11, 163 | "metadata": {}, 164 | "outputs": [ 165 | { 166 | "data": { 167 | "text/plain": [ 168 | "'ta Science is fun'" 169 | ] 170 | }, 171 | "execution_count": 11, 172 | "metadata": {}, 173 | "output_type": "execute_result" 174 | } 175 | ], 176 | "source": [ 177 | "text[2:]" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 12, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "data": { 187 | "text/plain": [ 188 | "'ience'" 189 | ] 190 | }, 191 | "execution_count": 12, 192 | "metadata": {}, 193 | "output_type": "execute_result" 194 | } 195 | ], 196 | "source": [ 197 | "text[7:12]" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 13, 203 | "metadata": {}, 204 | "outputs": [ 205 | { 206 | "data": { 207 | "text/plain": [ 208 | "'n'" 209 | ] 210 | }, 211 | "execution_count": 13, 212 | "metadata": {}, 213 | "output_type": "execute_result" 214 | } 215 | ], 216 | "source": [ 217 | "text[-1] ### negative index q strts from right" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 18, 223 | "metadata": {}, 224 | "outputs": [ 225 | { 226 | "data": { 227 | "text/plain": [ 228 | "'Science is fu'" 229 | ] 230 | }, 231 | "execution_count": 18, 232 | "metadata": {}, 233 | "output_type": "execute_result" 234 | } 235 | ], 236 | "source": [ 237 | "text[5:-1]" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 19, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "data": { 247 | "text/plain": [ 248 | "'Science is f'" 249 | ] 250 | }, 251 | "execution_count": 19, 252 | "metadata": {}, 253 | "output_type": "execute_result" 254 | } 255 | ], 256 | "source": [ 257 | "text[5:-2]" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": 20, 263 | "metadata": {}, 264 | "outputs": [ 265 | { 266 | "data": { 267 | "text/plain": [ 268 | "'nuf si ecneicS ataD'" 269 | ] 270 | }, 271 | "execution_count": 20, 272 | "metadata": {}, 273 | "output_type": "execute_result" 274 | } 275 | ], 276 | "source": [ 277 | "text[::-1] ## reverse the string using indexing" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 24, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "data": { 287 | "text/plain": [ 288 | "'a'" 289 | ] 290 | }, 291 | "execution_count": 24, 292 | "metadata": {}, 293 | "output_type": "execute_result" 294 | } 295 | ], 296 | "source": [ 297 | "text[::-1][-4] ### reverse the string and displace the forth last letter" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": null, 303 | "metadata": {}, 304 | "outputs": [], 305 | "source": [] 306 | } 307 | ], 308 | "metadata": { 309 | "kernelspec": { 310 | "display_name": "Python 3", 311 | "language": "python", 312 | "name": "python3" 313 | }, 314 | "language_info": { 315 | "codemirror_mode": { 316 | "name": "ipython", 317 | "version": 3 318 | }, 319 | "file_extension": ".py", 320 | "mimetype": "text/x-python", 321 | "name": "python", 322 | "nbconvert_exporter": "python", 323 | "pygments_lexer": "ipython3", 324 | "version": "3.8.3" 325 | } 326 | }, 327 | "nbformat": 4, 328 | "nbformat_minor": 4 329 | } 330 | -------------------------------------------------------------------------------- /Lists.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# List" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 4, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "['Arun', 'Archana', 'Sanchayita', 'Latha']\n" 20 | ] 21 | } 22 | ], 23 | "source": [ 24 | "name_list1=[\"Arun\",\"Archana\",\"Sanchayita\",\"Latha\"]\n", 25 | "print(name_list1)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 5, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "data": { 35 | "text/plain": [ 36 | "list" 37 | ] 38 | }, 39 | "execution_count": 5, 40 | "metadata": {}, 41 | "output_type": "execute_result" 42 | } 43 | ], 44 | "source": [ 45 | "type(name_list1)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 6, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "name_list2=[\"Vinay\",\"Suja\",\"Thiru\",\"Prema\"]" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 7, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "data": { 64 | "text/plain": [ 65 | "['Arun', 'Archana', 'Sanchayita', 'Latha', 'Vinay', 'Suja', 'Thiru', 'Prema']" 66 | ] 67 | }, 68 | "execution_count": 7, 69 | "metadata": {}, 70 | "output_type": "execute_result" 71 | } 72 | ], 73 | "source": [ 74 | "names=name_list1+name_list2\n", 75 | "names" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 8, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "data": { 85 | "text/plain": [ 86 | "list" 87 | ] 88 | }, 89 | "execution_count": 8, 90 | "metadata": {}, 91 | "output_type": "execute_result" 92 | } 93 | ], 94 | "source": [ 95 | "type(names)" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 9, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [ 104 | "### How to insert an element in the list\n", 105 | "names.append(\"Lalith\")" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 10, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "name": "stdout", 115 | "output_type": "stream", 116 | "text": [ 117 | "['Arun', 'Archana', 'Sanchayita', 'Latha', 'Vinay', 'Suja', 'Thiru', 'Prema', 'Lalith']\n" 118 | ] 119 | } 120 | ], 121 | "source": [ 122 | "print(names)" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "### Gets appended at the last" 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "# Sorting elements in alist" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 11, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [ 145 | "num_list=[10,23,12,6,45]\n", 146 | "num_list.sort()" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 12, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "data": { 156 | "text/plain": [ 157 | "[6, 10, 12, 23, 45]" 158 | ] 159 | }, 160 | "execution_count": 12, 161 | "metadata": {}, 162 | "output_type": "execute_result" 163 | } 164 | ], 165 | "source": [ 166 | "num_list" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 13, 172 | "metadata": {}, 173 | "outputs": [ 174 | { 175 | "data": { 176 | "text/plain": [ 177 | "['Prema', 'Suja', 'Thiru', 'Vinay']" 178 | ] 179 | }, 180 | "execution_count": 13, 181 | "metadata": {}, 182 | "output_type": "execute_result" 183 | } 184 | ], 185 | "source": [ 186 | "name_list2.sort()\n", 187 | "name_list2" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": 15, 193 | "metadata": {}, 194 | "outputs": [ 195 | { 196 | "data": { 197 | "text/plain": [ 198 | "[45, 23, 12, 10, 6]" 199 | ] 200 | }, 201 | "execution_count": 15, 202 | "metadata": {}, 203 | "output_type": "execute_result" 204 | } 205 | ], 206 | "source": [ 207 | "num_list.sort(reverse=True) ## Sorting in reverse\n", 208 | "num_list" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 17, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "text/plain": [ 219 | "['Vinay', 'Thiru', 'Suja', 'Prema']" 220 | ] 221 | }, 222 | "execution_count": 17, 223 | "metadata": {}, 224 | "output_type": "execute_result" 225 | } 226 | ], 227 | "source": [ 228 | "name_list2.sort(reverse=True)\n", 229 | "name_list2" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 19, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "ename": "TypeError", 239 | "evalue": "'<' not supported between instances of 'str' and 'float'", 240 | "output_type": "error", 241 | "traceback": [ 242 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 243 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 244 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mlist_mixed_data_types\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m12\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4.5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"hi\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"True\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mlist_mixed_data_types\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 245 | "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'float'" 246 | ] 247 | } 248 | ], 249 | "source": [ 250 | "list_mixed_data_types=[12,4.5,\"hi\",\"True\",False] ## cannot sort with mixed data types\n", 251 | "list_mixed_data_types.sort()" 252 | ] 253 | }, 254 | { 255 | "cell_type": "markdown", 256 | "metadata": {}, 257 | "source": [ 258 | "# Sorting a list by sorted function" 259 | ] 260 | }, 261 | { 262 | "cell_type": "code", 263 | "execution_count": 24, 264 | "metadata": {}, 265 | "outputs": [], 266 | "source": [ 267 | "num_list=[23,32,12,25]" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 25, 273 | "metadata": {}, 274 | "outputs": [ 275 | { 276 | "data": { 277 | "text/plain": [ 278 | "[12, 23, 25, 32]" 279 | ] 280 | }, 281 | "execution_count": 25, 282 | "metadata": {}, 283 | "output_type": "execute_result" 284 | } 285 | ], 286 | "source": [ 287 | "num_list_sorted=sorted(num_list)\n", 288 | "num_list_sorted" 289 | ] 290 | }, 291 | { 292 | "cell_type": "markdown", 293 | "metadata": {}, 294 | "source": [ 295 | "Sort() modifies an existing list but sorted creates a new list" 296 | ] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": {}, 301 | "source": [ 302 | "# Checking Presence of element in the list" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 26, 308 | "metadata": {}, 309 | "outputs": [ 310 | { 311 | "name": "stdout", 312 | "output_type": "stream", 313 | "text": [ 314 | "False\n" 315 | ] 316 | } 317 | ], 318 | "source": [ 319 | "print(\"latha\" in name_list1)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 27, 325 | "metadata": {}, 326 | "outputs": [ 327 | { 328 | "name": "stdout", 329 | "output_type": "stream", 330 | "text": [ 331 | "True\n" 332 | ] 333 | } 334 | ], 335 | "source": [ 336 | "print(\"Latha\" in name_list1)" 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "# Iterating through all the elements in a list" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": 30, 349 | "metadata": {}, 350 | "outputs": [ 351 | { 352 | "name": "stdout", 353 | "output_type": "stream", 354 | "text": [ 355 | "Vinay\n", 356 | "Thiru\n", 357 | "Suja\n", 358 | "Prema\n" 359 | ] 360 | } 361 | ], 362 | "source": [ 363 | "for names in name_list2:\n", 364 | " print (names)" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": 31, 370 | "metadata": {}, 371 | "outputs": [ 372 | { 373 | "data": { 374 | "text/plain": [ 375 | "4" 376 | ] 377 | }, 378 | "execution_count": 31, 379 | "metadata": {}, 380 | "output_type": "execute_result" 381 | } 382 | ], 383 | "source": [ 384 | "len(name_list2) ### Number of elements" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": 32, 390 | "metadata": {}, 391 | "outputs": [ 392 | { 393 | "data": { 394 | "text/plain": [ 395 | "32" 396 | ] 397 | }, 398 | "execution_count": 32, 399 | "metadata": {}, 400 | "output_type": "execute_result" 401 | } 402 | ], 403 | "source": [ 404 | "max(num_list)" 405 | ] 406 | }, 407 | { 408 | "cell_type": "code", 409 | "execution_count": 33, 410 | "metadata": {}, 411 | "outputs": [ 412 | { 413 | "data": { 414 | "text/plain": [ 415 | "'Vinay'" 416 | ] 417 | }, 418 | "execution_count": 33, 419 | "metadata": {}, 420 | "output_type": "execute_result" 421 | } 422 | ], 423 | "source": [ 424 | "max(name_list2)" 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": 34, 430 | "metadata": {}, 431 | "outputs": [ 432 | { 433 | "data": { 434 | "text/plain": [ 435 | "12" 436 | ] 437 | }, 438 | "execution_count": 34, 439 | "metadata": {}, 440 | "output_type": "execute_result" 441 | } 442 | ], 443 | "source": [ 444 | "min(num_list)" 445 | ] 446 | }, 447 | { 448 | "cell_type": "code", 449 | "execution_count": 35, 450 | "metadata": {}, 451 | "outputs": [ 452 | { 453 | "data": { 454 | "text/plain": [ 455 | "'Archana'" 456 | ] 457 | }, 458 | "execution_count": 35, 459 | "metadata": {}, 460 | "output_type": "execute_result" 461 | } 462 | ], 463 | "source": [ 464 | "min(name_list1)" 465 | ] 466 | }, 467 | { 468 | "cell_type": "code", 469 | "execution_count": 43, 470 | "metadata": {}, 471 | "outputs": [ 472 | { 473 | "name": "stdout", 474 | "output_type": "stream", 475 | "text": [ 476 | "4\n" 477 | ] 478 | }, 479 | { 480 | "ename": "TypeError", 481 | "evalue": "'>' not supported between instances of 'str' and 'float'", 482 | "output_type": "error", 483 | "traceback": [ 484 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 485 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 486 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m30.0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"hi\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 487 | "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'str' and 'float'" 488 | ] 489 | } 490 | ], 491 | "source": [ 492 | "list=[10,20,30.0,\"hi\"]\n", 493 | "print(len(list))\n", 494 | "print(max(list))" 495 | ] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "metadata": {}, 500 | "source": [ 501 | "# Removing an elements of a list" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": 44, 507 | "metadata": {}, 508 | "outputs": [ 509 | { 510 | "name": "stdout", 511 | "output_type": "stream", 512 | "text": [ 513 | "[10, 20, 30.0, 'hi']\n" 514 | ] 515 | } 516 | ], 517 | "source": [ 518 | "print(list)\n" 519 | ] 520 | }, 521 | { 522 | "cell_type": "code", 523 | "execution_count": 45, 524 | "metadata": {}, 525 | "outputs": [ 526 | { 527 | "name": "stdout", 528 | "output_type": "stream", 529 | "text": [ 530 | "[]\n" 531 | ] 532 | } 533 | ], 534 | "source": [ 535 | "list.clear()\n", 536 | "print(list)" 537 | ] 538 | }, 539 | { 540 | "cell_type": "code", 541 | "execution_count": 53, 542 | "metadata": {}, 543 | "outputs": [], 544 | "source": [ 545 | "new_list=name_list1.copy()" 546 | ] 547 | }, 548 | { 549 | "cell_type": "code", 550 | "execution_count": 54, 551 | "metadata": {}, 552 | "outputs": [ 553 | { 554 | "name": "stdout", 555 | "output_type": "stream", 556 | "text": [ 557 | "['Arun', 'Archana', 'Sanchayita', 'Latha']\n" 558 | ] 559 | } 560 | ], 561 | "source": [ 562 | "print(new_list)" 563 | ] 564 | }, 565 | { 566 | "cell_type": "code", 567 | "execution_count": 55, 568 | "metadata": {}, 569 | "outputs": [ 570 | { 571 | "data": { 572 | "text/plain": [ 573 | "['Arun', 'Archana', 'Sanchayita', 'Latha', 'Lachu']" 574 | ] 575 | }, 576 | "execution_count": 55, 577 | "metadata": {}, 578 | "output_type": "execute_result" 579 | } 580 | ], 581 | "source": [ 582 | "new_list.append(\"Lachu\")\n", 583 | "new_list" 584 | ] 585 | }, 586 | { 587 | "cell_type": "code", 588 | "execution_count": 57, 589 | "metadata": {}, 590 | "outputs": [], 591 | "source": [ 592 | "new_list.append(\"Lachu\")" 593 | ] 594 | }, 595 | { 596 | "cell_type": "code", 597 | "execution_count": 58, 598 | "metadata": {}, 599 | "outputs": [ 600 | { 601 | "data": { 602 | "text/plain": [ 603 | "['Arun', 'Archana', 'Sanchayita', 'Latha', 'Lachu', 'Lachu']" 604 | ] 605 | }, 606 | "execution_count": 58, 607 | "metadata": {}, 608 | "output_type": "execute_result" 609 | } 610 | ], 611 | "source": [ 612 | "new_list" 613 | ] 614 | }, 615 | { 616 | "cell_type": "code", 617 | "execution_count": 59, 618 | "metadata": {}, 619 | "outputs": [ 620 | { 621 | "data": { 622 | "text/plain": [ 623 | "2" 624 | ] 625 | }, 626 | "execution_count": 59, 627 | "metadata": {}, 628 | "output_type": "execute_result" 629 | } 630 | ], 631 | "source": [ 632 | "new_list.count(\"Lachu\")" 633 | ] 634 | }, 635 | { 636 | "cell_type": "code", 637 | "execution_count": 63, 638 | "metadata": {}, 639 | "outputs": [ 640 | { 641 | "data": { 642 | "text/plain": [ 643 | "['Data', 'Analytics', 'Python', 'AI', 'BA', 'HR']" 644 | ] 645 | }, 646 | "execution_count": 63, 647 | "metadata": {}, 648 | "output_type": "execute_result" 649 | } 650 | ], 651 | "source": [ 652 | "list_1=[\"Data\",\"Analytics\",\"Python\"]\n", 653 | "list_2=[\"AI\",\"BA\",\"HR\"]\n", 654 | "list_1.extend(list_2) ## entends the current list by adding another list to an end\n", 655 | "list_1" 656 | ] 657 | }, 658 | { 659 | "cell_type": "code", 660 | "execution_count": 65, 661 | "metadata": {}, 662 | "outputs": [ 663 | { 664 | "data": { 665 | "text/plain": [ 666 | "3" 667 | ] 668 | }, 669 | "execution_count": 65, 670 | "metadata": {}, 671 | "output_type": "execute_result" 672 | } 673 | ], 674 | "source": [ 675 | "list_1.index('AI')" 676 | ] 677 | }, 678 | { 679 | "cell_type": "code", 680 | "execution_count": 67, 681 | "metadata": {}, 682 | "outputs": [ 683 | { 684 | "data": { 685 | "text/plain": [ 686 | "['Data', 'Analytics', 'HR', 'HR', 'Python', 'AI', 'BA', 'HR']" 687 | ] 688 | }, 689 | "execution_count": 67, 690 | "metadata": {}, 691 | "output_type": "execute_result" 692 | } 693 | ], 694 | "source": [ 695 | "list_1.insert(2,\"HR\") ## Inserting an element at spec index\n", 696 | "list_1" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": 70, 702 | "metadata": {}, 703 | "outputs": [ 704 | { 705 | "data": { 706 | "text/plain": [ 707 | "['Data', 'Analytics', 'Python', 'AI', 'BA', 'HR']" 708 | ] 709 | }, 710 | "execution_count": 70, 711 | "metadata": {}, 712 | "output_type": "execute_result" 713 | } 714 | ], 715 | "source": [ 716 | "list_1.pop(2) ## remove an ement using index position\n", 717 | "list_1" 718 | ] 719 | }, 720 | { 721 | "cell_type": "code", 722 | "execution_count": 71, 723 | "metadata": {}, 724 | "outputs": [ 725 | { 726 | "data": { 727 | "text/plain": [ 728 | "['Data', 'Analytics', 'Python', 'BA', 'HR']" 729 | ] 730 | }, 731 | "execution_count": 71, 732 | "metadata": {}, 733 | "output_type": "execute_result" 734 | } 735 | ], 736 | "source": [ 737 | "list_1.remove(\"AI\")\n", 738 | "list_1" 739 | ] 740 | }, 741 | { 742 | "cell_type": "code", 743 | "execution_count": 74, 744 | "metadata": {}, 745 | "outputs": [ 746 | { 747 | "data": { 748 | "text/plain": [ 749 | "['HR', 'BA', 'Python', 'Analytics', 'Data']" 750 | ] 751 | }, 752 | "execution_count": 74, 753 | "metadata": {}, 754 | "output_type": "execute_result" 755 | } 756 | ], 757 | "source": [ 758 | "list_1.reverse()\n", 759 | "list_1" 760 | ] 761 | }, 762 | { 763 | "cell_type": "code", 764 | "execution_count": 75, 765 | "metadata": {}, 766 | "outputs": [ 767 | { 768 | "data": { 769 | "text/plain": [ 770 | "['Python', 'HR', 'Data', 'BA', 'Analytics']" 771 | ] 772 | }, 773 | "execution_count": 75, 774 | "metadata": {}, 775 | "output_type": "execute_result" 776 | } 777 | ], 778 | "source": [ 779 | "list_1.sort(reverse=True)\n", 780 | "list_1" 781 | ] 782 | }, 783 | { 784 | "cell_type": "code", 785 | "execution_count": 76, 786 | "metadata": {}, 787 | "outputs": [ 788 | { 789 | "data": { 790 | "text/plain": [ 791 | "['Python', 'HR']" 792 | ] 793 | }, 794 | "execution_count": 76, 795 | "metadata": {}, 796 | "output_type": "execute_result" 797 | } 798 | ], 799 | "source": [ 800 | "list_1[0:2]" 801 | ] 802 | }, 803 | { 804 | "cell_type": "code", 805 | "execution_count": 77, 806 | "metadata": {}, 807 | "outputs": [ 808 | { 809 | "data": { 810 | "text/plain": [ 811 | "'Analytics'" 812 | ] 813 | }, 814 | "execution_count": 77, 815 | "metadata": {}, 816 | "output_type": "execute_result" 817 | } 818 | ], 819 | "source": [ 820 | "list_1[-1]" 821 | ] 822 | }, 823 | { 824 | "cell_type": "code", 825 | "execution_count": 79, 826 | "metadata": {}, 827 | "outputs": [ 828 | { 829 | "data": { 830 | "text/plain": [ 831 | "['Python', 'HR', 'Data', 'BA']" 832 | ] 833 | }, 834 | "execution_count": 79, 835 | "metadata": {}, 836 | "output_type": "execute_result" 837 | } 838 | ], 839 | "source": [ 840 | "list_1[0:-1] ## start at 0 and end at -2" 841 | ] 842 | }, 843 | { 844 | "cell_type": "code", 845 | "execution_count": 80, 846 | "metadata": {}, 847 | "outputs": [ 848 | { 849 | "data": { 850 | "text/plain": [ 851 | "['Data', 'BA']" 852 | ] 853 | }, 854 | "execution_count": 80, 855 | "metadata": {}, 856 | "output_type": "execute_result" 857 | } 858 | ], 859 | "source": [ 860 | "list_1[-3:-1]" 861 | ] 862 | }, 863 | { 864 | "cell_type": "code", 865 | "execution_count": 81, 866 | "metadata": {}, 867 | "outputs": [ 868 | { 869 | "data": { 870 | "text/plain": [ 871 | "['Analytics', 'BA', 'Data', 'HR', 'Python']" 872 | ] 873 | }, 874 | "execution_count": 81, 875 | "metadata": {}, 876 | "output_type": "execute_result" 877 | } 878 | ], 879 | "source": [ 880 | "list_1[::-1] ### reverse the list" 881 | ] 882 | }, 883 | { 884 | "cell_type": "code", 885 | "execution_count": null, 886 | "metadata": {}, 887 | "outputs": [], 888 | "source": [] 889 | } 890 | ], 891 | "metadata": { 892 | "kernelspec": { 893 | "display_name": "Python 3", 894 | "language": "python", 895 | "name": "python3" 896 | }, 897 | "language_info": { 898 | "codemirror_mode": { 899 | "name": "ipython", 900 | "version": 3 901 | }, 902 | "file_extension": ".py", 903 | "mimetype": "text/x-python", 904 | "name": "python", 905 | "nbconvert_exporter": "python", 906 | "pygments_lexer": "ipython3", 907 | "version": "3.8.3" 908 | } 909 | }, 910 | "nbformat": 4, 911 | "nbformat_minor": 4 912 | } 913 | -------------------------------------------------------------------------------- /Operators.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### Operators\n", 8 | "#### Arithmetic\n", 9 | "#### Relational \n", 10 | "#### Logical\n", 11 | "#### Membership\n", 12 | "#### Bitwise\n", 13 | "#### Assignment " 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "### Arithmetic Operators(Add,Sub,Mul,Div,Exp,Modulus,Floor Division)\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 24, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "11000" 32 | ] 33 | }, 34 | "execution_count": 24, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "income=10000\n", 41 | "incentive=1000\n", 42 | "Total=income+incentive\n", 43 | "Total" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 5, 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "data": { 53 | "text/plain": [ 54 | "22" 55 | ] 56 | }, 57 | "execution_count": 5, 58 | "metadata": {}, 59 | "output_type": "execute_result" 60 | } 61 | ], 62 | "source": [ 63 | "x=67\n", 64 | "y=45\n", 65 | "z=x-y\n", 66 | "z" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 7, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "text/plain": [ 77 | "80" 78 | ] 79 | }, 80 | "execution_count": 7, 81 | "metadata": {}, 82 | "output_type": "execute_result" 83 | } 84 | ], 85 | "source": [ 86 | "x=20\n", 87 | "y=4\n", 88 | "z=x*y\n", 89 | "z" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 8, 95 | "metadata": {}, 96 | "outputs": [ 97 | { 98 | "data": { 99 | "text/plain": [ 100 | "5.0" 101 | ] 102 | }, 103 | "execution_count": 8, 104 | "metadata": {}, 105 | "output_type": "execute_result" 106 | } 107 | ], 108 | "source": [ 109 | "x=20\n", 110 | "y=4\n", 111 | "z=x/y\n", 112 | "z" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 9, 118 | "metadata": {}, 119 | "outputs": [ 120 | { 121 | "data": { 122 | "text/plain": [ 123 | "343" 124 | ] 125 | }, 126 | "execution_count": 9, 127 | "metadata": {}, 128 | "output_type": "execute_result" 129 | } 130 | ], 131 | "source": [ 132 | "### exponential (**)\n", 133 | "a=7\n", 134 | "b=3\n", 135 | "z=a**b\n", 136 | "z" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 13, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "data": { 146 | "text/plain": [ 147 | "1" 148 | ] 149 | }, 150 | "execution_count": 13, 151 | "metadata": {}, 152 | "output_type": "execute_result" 153 | } 154 | ], 155 | "source": [ 156 | "### Modulus(%)-Remainder\n", 157 | "### x%y\n", 158 | "### if x>y,it returns remainder\n", 159 | "### ifxy,it returns quotient\n", 186 | "### if x)\n", 251 | "### Less than(<)\n", 252 | "### Greater than or equal to(>=)\n", 253 | "### Lesser than or equal to(<=)" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 42, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [ 262 | "### Relational Operators\n", 263 | "x=67a\n", 264 | "y=34" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": 43, 270 | "metadata": {}, 271 | "outputs": [ 272 | { 273 | "data": { 274 | "text/plain": [ 275 | "False" 276 | ] 277 | }, 278 | "execution_count": 43, 279 | "metadata": {}, 280 | "output_type": "execute_result" 281 | } 282 | ], 283 | "source": [ 284 | "x==y" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 44, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "data": { 294 | "text/plain": [ 295 | "True" 296 | ] 297 | }, 298 | "execution_count": 44, 299 | "metadata": {}, 300 | "output_type": "execute_result" 301 | } 302 | ], 303 | "source": [ 304 | "x!=y" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": 45, 310 | "metadata": {}, 311 | "outputs": [ 312 | { 313 | "data": { 314 | "text/plain": [ 315 | "False" 316 | ] 317 | }, 318 | "execution_count": 45, 319 | "metadata": {}, 320 | "output_type": "execute_result" 321 | } 322 | ], 323 | "source": [ 324 | "xy" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": 47, 350 | "metadata": {}, 351 | "outputs": [ 352 | { 353 | "data": { 354 | "text/plain": [ 355 | "True" 356 | ] 357 | }, 358 | "execution_count": 47, 359 | "metadata": {}, 360 | "output_type": "execute_result" 361 | } 362 | ], 363 | "source": [ 364 | "x>=y" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": 48, 370 | "metadata": {}, 371 | "outputs": [ 372 | { 373 | "data": { 374 | "text/plain": [ 375 | "False" 376 | ] 377 | }, 378 | "execution_count": 48, 379 | "metadata": {}, 380 | "output_type": "execute_result" 381 | } 382 | ], 383 | "source": [ 384 | "x<=y" 385 | ] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "### Logical Operators\n", 392 | "### AND\n", 393 | "### OR\n", 394 | "### NOT" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": {}, 400 | "source": [ 401 | "### AND" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": 52, 407 | "metadata": {}, 408 | "outputs": [], 409 | "source": [ 410 | "is_student=True\n", 411 | "in_college=True\n", 412 | "in_school=False" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": 53, 418 | "metadata": {}, 419 | "outputs": [ 420 | { 421 | "data": { 422 | "text/plain": [ 423 | "True" 424 | ] 425 | }, 426 | "execution_count": 53, 427 | "metadata": {}, 428 | "output_type": "execute_result" 429 | } 430 | ], 431 | "source": [ 432 | "is_student and in_college" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": 54, 438 | "metadata": {}, 439 | "outputs": [ 440 | { 441 | "data": { 442 | "text/plain": [ 443 | "False" 444 | ] 445 | }, 446 | "execution_count": 54, 447 | "metadata": {}, 448 | "output_type": "execute_result" 449 | } 450 | ], 451 | "source": [ 452 | "is_student and in_school" 453 | ] 454 | }, 455 | { 456 | "cell_type": "markdown", 457 | "metadata": {}, 458 | "source": [ 459 | "### OR" 460 | ] 461 | }, 462 | { 463 | "cell_type": "code", 464 | "execution_count": 56, 465 | "metadata": {}, 466 | "outputs": [ 467 | { 468 | "data": { 469 | "text/plain": [ 470 | "True" 471 | ] 472 | }, 473 | "execution_count": 56, 474 | "metadata": {}, 475 | "output_type": "execute_result" 476 | } 477 | ], 478 | "source": [ 479 | "is_student or in_school" 480 | ] 481 | }, 482 | { 483 | "cell_type": "markdown", 484 | "metadata": {}, 485 | "source": [ 486 | "### Not" 487 | ] 488 | }, 489 | { 490 | "cell_type": "code", 491 | "execution_count": 57, 492 | "metadata": {}, 493 | "outputs": [ 494 | { 495 | "data": { 496 | "text/plain": [ 497 | "False" 498 | ] 499 | }, 500 | "execution_count": 57, 501 | "metadata": {}, 502 | "output_type": "execute_result" 503 | } 504 | ], 505 | "source": [ 506 | "not(is_student)" 507 | ] 508 | }, 509 | { 510 | "cell_type": "code", 511 | "execution_count": 58, 512 | "metadata": {}, 513 | "outputs": [ 514 | { 515 | "name": "stdout", 516 | "output_type": "stream", 517 | "text": [ 518 | "True\n" 519 | ] 520 | } 521 | ], 522 | "source": [ 523 | "### Membership Operators\n", 524 | "vowels=\"aeiou\"\n", 525 | "print(\"i\" in vowels)" 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": 60, 531 | "metadata": {}, 532 | "outputs": [ 533 | { 534 | "name": "stdout", 535 | "output_type": "stream", 536 | "text": [ 537 | "False\n" 538 | ] 539 | } 540 | ], 541 | "source": [ 542 | "print(\"j\" in vowels)" 543 | ] 544 | }, 545 | { 546 | "cell_type": "code", 547 | "execution_count": 61, 548 | "metadata": {}, 549 | "outputs": [ 550 | { 551 | "name": "stdout", 552 | "output_type": "stream", 553 | "text": [ 554 | "False\n" 555 | ] 556 | } 557 | ], 558 | "source": [ 559 | "### not in\n", 560 | "print(\"a\" not in vowels)" 561 | ] 562 | }, 563 | { 564 | "cell_type": "code", 565 | "execution_count": 63, 566 | "metadata": {}, 567 | "outputs": [ 568 | { 569 | "name": "stdout", 570 | "output_type": "stream", 571 | "text": [ 572 | "True\n" 573 | ] 574 | } 575 | ], 576 | "source": [ 577 | "print(\"p\" not in vowels)" 578 | ] 579 | }, 580 | { 581 | "cell_type": "markdown", 582 | "metadata": {}, 583 | "source": [ 584 | "### Bitwise operators" 585 | ] 586 | }, 587 | { 588 | "cell_type": "code", 589 | "execution_count": 64, 590 | "metadata": {}, 591 | "outputs": [ 592 | { 593 | "data": { 594 | "text/plain": [ 595 | "False" 596 | ] 597 | }, 598 | "execution_count": 64, 599 | "metadata": {}, 600 | "output_type": "execute_result" 601 | } 602 | ], 603 | "source": [ 604 | "\n", 605 | "number=10\n", 606 | "(number%2==0)&(number%3==0)" 607 | ] 608 | }, 609 | { 610 | "cell_type": "code", 611 | "execution_count": 65, 612 | "metadata": {}, 613 | "outputs": [ 614 | { 615 | "data": { 616 | "text/plain": [ 617 | "True" 618 | ] 619 | }, 620 | "execution_count": 65, 621 | "metadata": {}, 622 | "output_type": "execute_result" 623 | } 624 | ], 625 | "source": [ 626 | "number=10\n", 627 | "(number%2==0)|(number%3==0)" 628 | ] 629 | }, 630 | { 631 | "cell_type": "markdown", 632 | "metadata": {}, 633 | "source": [ 634 | "### Assignment Operators\n", 635 | "#### a+=b => a=a+b\n", 636 | "#### a-=b => a=a-b" 637 | ] 638 | }, 639 | { 640 | "cell_type": "code", 641 | "execution_count": 7, 642 | "metadata": {}, 643 | "outputs": [ 644 | { 645 | "data": { 646 | "text/plain": [ 647 | "8" 648 | ] 649 | }, 650 | "execution_count": 7, 651 | "metadata": {}, 652 | "output_type": "execute_result" 653 | } 654 | ], 655 | "source": [ 656 | "x=3\n", 657 | "x+=5\n", 658 | "x" 659 | ] 660 | }, 661 | { 662 | "cell_type": "code", 663 | "execution_count": 10, 664 | "metadata": {}, 665 | "outputs": [ 666 | { 667 | "data": { 668 | "text/plain": [ 669 | "-2" 670 | ] 671 | }, 672 | "execution_count": 10, 673 | "metadata": {}, 674 | "output_type": "execute_result" 675 | } 676 | ], 677 | "source": [ 678 | "x=3\n", 679 | "x-=5\n", 680 | "x" 681 | ] 682 | }, 683 | { 684 | "cell_type": "code", 685 | "execution_count": 11, 686 | "metadata": {}, 687 | "outputs": [ 688 | { 689 | "data": { 690 | "text/plain": [ 691 | "15" 692 | ] 693 | }, 694 | "execution_count": 11, 695 | "metadata": {}, 696 | "output_type": "execute_result" 697 | } 698 | ], 699 | "source": [ 700 | "x=5\n", 701 | "x*=3\n", 702 | "x" 703 | ] 704 | }, 705 | { 706 | "cell_type": "code", 707 | "execution_count": 12, 708 | "metadata": {}, 709 | "outputs": [ 710 | { 711 | "data": { 712 | "text/plain": [ 713 | "5.0" 714 | ] 715 | }, 716 | "execution_count": 12, 717 | "metadata": {}, 718 | "output_type": "execute_result" 719 | } 720 | ], 721 | "source": [ 722 | "x=10\n", 723 | "x/=2\n", 724 | "x" 725 | ] 726 | }, 727 | { 728 | "cell_type": "code", 729 | "execution_count": 14, 730 | "metadata": {}, 731 | "outputs": [ 732 | { 733 | "data": { 734 | "text/plain": [ 735 | "25" 736 | ] 737 | }, 738 | "execution_count": 14, 739 | "metadata": {}, 740 | "output_type": "execute_result" 741 | } 742 | ], 743 | "source": [ 744 | "x=5\n", 745 | "x**=2\n", 746 | "x" 747 | ] 748 | }, 749 | { 750 | "cell_type": "code", 751 | "execution_count": 22, 752 | "metadata": {}, 753 | "outputs": [ 754 | { 755 | "data": { 756 | "text/plain": [ 757 | "2" 758 | ] 759 | }, 760 | "execution_count": 22, 761 | "metadata": {}, 762 | "output_type": "execute_result" 763 | } 764 | ], 765 | "source": [ 766 | "x=11\n", 767 | "x%=3\n", 768 | "x" 769 | ] 770 | }, 771 | { 772 | "cell_type": "code", 773 | "execution_count": 23, 774 | "metadata": {}, 775 | "outputs": [ 776 | { 777 | "data": { 778 | "text/plain": [ 779 | "6.0" 780 | ] 781 | }, 782 | "execution_count": 23, 783 | "metadata": {}, 784 | "output_type": "execute_result" 785 | } 786 | ], 787 | "source": [ 788 | "x=10\n", 789 | "x//=1.5\n", 790 | "x" 791 | ] 792 | } 793 | ], 794 | "metadata": { 795 | "kernelspec": { 796 | "display_name": "Python 3", 797 | "language": "python", 798 | "name": "python3" 799 | }, 800 | "language_info": { 801 | "codemirror_mode": { 802 | "name": "ipython", 803 | "version": 3 804 | }, 805 | "file_extension": ".py", 806 | "mimetype": "text/x-python", 807 | "name": "python", 808 | "nbconvert_exporter": "python", 809 | "pygments_lexer": "ipython3", 810 | "version": "3.8.3" 811 | } 812 | }, 813 | "nbformat": 4, 814 | "nbformat_minor": 4 815 | } 816 | -------------------------------------------------------------------------------- /Python-loops.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "a=20\n", 10 | "b=33\n", 11 | "if b>a:\n", 12 | " print(\"b is greater than a\")" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "a=40\n", 22 | "b=33\n", 23 | "if b>a:\n", 24 | " print(\"b is greater than a\") ### Condition is False" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": null, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "a=20\n", 34 | "b=20\n", 35 | "if b>a:\n", 36 | " print(\"b is greater than a\") ### Condition is False" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "a=20\n", 46 | "b=20\n", 47 | "if b>a:\n", 48 | "print(\"b is greater than a\") ### IndentationError: space for print is required\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "a=20\n", 58 | "b=20\n", 59 | "if b==a:\n", 60 | " print(\"a is equal to b\") " 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [ 69 | "a=20\n", 70 | "b=30\n", 71 | "if b!=a:\n", 72 | " print(\"b is not equal to a\") " 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "a=20\n", 82 | "b=30\n", 83 | "if a=b:\n", 108 | " print(\"a is greater than or equal to b\")" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [ 117 | "a=42\n", 118 | "b=56\n", 119 | "if a>b:\n", 120 | " print(\"a is greater\")\n", 121 | "else:\n", 122 | " print(\"b is greater\")\n" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [ 131 | "a=42\n", 132 | "b=42\n", 133 | "if a>b:\n", 134 | " print(\"a is greater\")\n", 135 | "else:\n", 136 | " print(\"b is greater\")\n" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [ 145 | "a=42\n", 146 | "b=42\n", 147 | "if a==b:\n", 148 | " print(\"a is equal to b\")\n", 149 | "else:\n", 150 | " print(\"a is not equal to b\")\n" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": null, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [ 159 | "a=int(input(\"enter first number :\"))\n", 160 | "b=int(input(\"enter second number :\"))\n", 161 | "if a==b:\n", 162 | " print(\" a and b are equal\")\n", 163 | "elif a>b:\n", 164 | " print(\"a is greater\")\n", 165 | "else:\n", 166 | " print('b is greater')" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [ 175 | "a=float(input(\"enter first number :\"))\n", 176 | "b=float(input(\"enter second number :\"))\n", 177 | "if a==b:\n", 178 | " print(\" a and b are equal\")\n", 179 | "elif a>b:\n", 180 | " print(\"a is greater\")\n", 181 | "else:\n", 182 | " print('b is greater')" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "a=35\n", 192 | "b=25\n", 193 | "if a==b:\n", 194 | " print(\" a and b are equal\")\n", 195 | "elif a>b:\n", 196 | " print(\"a is greater\")\n", 197 | "else:\n", 198 | " print('b is greater')" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [ 207 | "num=float(input('Enter first number '))\n", 208 | "if num>=0:\n", 209 | " if num==0:\n", 210 | " print('zero')\n", 211 | " else:\n", 212 | " print('positive')\n", 213 | "else:\n", 214 | " print ('negative')\n" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [ 223 | "num=float(input('Enter first number '))\n", 224 | "if (num % 2)==0:\n", 225 | " if num==0:\n", 226 | " print('zero')\n", 227 | " else:\n", 228 | " print('even')\n", 229 | "else:\n", 230 | " print ('odd')\n" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": null, 236 | "metadata": {}, 237 | "outputs": [], 238 | "source": [ 239 | "var = 100\n", 240 | "if var < 200:\n", 241 | " print (\"Expression value is less than 200\")\n", 242 | " if var == 150:\n", 243 | " print (\"Which is 150\")\n", 244 | " elif var == 100:\n", 245 | " print (\"Which is 100\")\n", 246 | " elif var == 50:\n", 247 | " print (\"Which is 50\")\n", 248 | " elif var < 50:\n", 249 | " print (\"Expression value is less than 50\")\n", 250 | "else:\n", 251 | " print (\"Could not find \")\n" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [ 260 | "num=int(input('enter your age'))\n", 261 | "if num>=15:\n", 262 | " if num==15:\n", 263 | " print('You can drive')\n", 264 | " else:\n", 265 | " print('test drive required') \n", 266 | "else:\n", 267 | " print('Better luck next time')\n" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": null, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [ 276 | "a=eval(input(\"Enter first number: \"))\n", 277 | "\n", 278 | "if(a<58):\n", 279 | " if(a<=21):\n", 280 | " print(\"You are not eligible for working\")\n", 281 | " else:\n", 282 | " print(\"You are eligible for working\")\n", 283 | "else:\n", 284 | " print(\"You are retired\")" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": {}, 291 | "outputs": [], 292 | "source": [ 293 | "var1 = 8\n", 294 | "var2 = 5\n", 295 | "if (var1 and var2) > 0 :\n", 296 | " print (\"Expression value is positive\")\n", 297 | " if (var1/var2>=0) :\n", 298 | " print (\"divisable\")\n", 299 | " elif(var1/var2 <0):\n", 300 | " print (\"decimal quotient\")\n", 301 | " elif (var1 and var2)==0 :\n", 302 | " print (\"indivisble\")\n", 303 | "else:\n", 304 | " print (\"ended my if for now\")\n" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": {}, 311 | "outputs": [], 312 | "source": [ 313 | "Mark=int(input ('enter your mark'))\n", 314 | "if Mark>=30:\n", 315 | " if Mark==30:\n", 316 | " print('just pass')\n", 317 | " else:\n", 318 | " print(' pass with good marks')\n", 319 | "else:\n", 320 | " print('fail')\n" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": null, 326 | "metadata": {}, 327 | "outputs": [], 328 | "source": [ 329 | "day=int(input('enter a day'))\n", 330 | "if day>=0:\n", 331 | " if day==1:\n", 332 | " print('day is monday')\n", 333 | " else:\n", 334 | " print('holiday')\n", 335 | "else:\n", 336 | " print('tuesday')\n" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": null, 342 | "metadata": {}, 343 | "outputs": [], 344 | "source": [ 345 | "x = int(input(\"enter number\"))\n", 346 | "if x > 10:\n", 347 | " print(\"Above ten,\")\n", 348 | " if x > 20:\n", 349 | " print(\"and also above 20!\")\n", 350 | " else:\n", 351 | " print(\"but not above 20.\")\n", 352 | "else:\n", 353 | " print(\"below 10\")\n" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": null, 359 | "metadata": {}, 360 | "outputs": [], 361 | "source": [ 362 | "a=float(input(\"enter marks:\"))\n", 363 | "if a>=50:\n", 364 | " \n", 365 | " if a==50:\n", 366 | " print(\"average performance\") \n", 367 | " else:\n", 368 | " print(\"good performance\")\n", 369 | "else:\n", 370 | " print(\"poor performance\")" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": null, 376 | "metadata": {}, 377 | "outputs": [], 378 | "source": [ 379 | "a=int(input('enter first number'))\n", 380 | "b=int(input('enter second number'))\n", 381 | "if a==b:\n", 382 | " print('a is equal to b')\n", 383 | "elif a>b:\n", 384 | " print('a is greater than b')\n", 385 | "else:\n", 386 | " print('b is greater')" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": null, 392 | "metadata": {}, 393 | "outputs": [], 394 | "source": [ 395 | "a=189\n", 396 | "b=123\n", 397 | "c=1000\n", 398 | "if a>b and c>a:\n", 399 | " print(\"Both are true\")" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": null, 405 | "metadata": {}, 406 | "outputs": [], 407 | "source": [ 408 | "a=189\n", 409 | "b=123\n", 410 | "c=10\n", 411 | "if a>b or c>a:\n", 412 | " print(\"Either a or b or c is true\")" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": null, 418 | "metadata": {}, 419 | "outputs": [], 420 | "source": [ 421 | "a=int(input('enter a number'))\n", 422 | "b=int(input('enter a number'))\n", 423 | "c=int(input('enter a number'))\n", 424 | "if (a and b)/c:\n", 425 | " print('a and b divisble by c')\n", 426 | "else:\n", 427 | " print('not divisible')\n" 428 | ] 429 | }, 430 | { 431 | "cell_type": "code", 432 | "execution_count": null, 433 | "metadata": {}, 434 | "outputs": [], 435 | "source": [ 436 | "a= int(input('Enter your mark')) \n", 437 | "b=int(input('Enter your mark')) \n", 438 | "c=int(input('Enter your mark')) \n", 439 | "if a<=b and a>=c:\n", 440 | " print('pass')\n" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": null, 446 | "metadata": {}, 447 | "outputs": [], 448 | "source": [ 449 | "a=float(input(\"enter no. :\"))\n", 450 | "b=float(input(\"enter no. :\"))\n", 451 | "c=float(input(\"enter no. :\"))\n", 452 | "if a>b and a>c:\n", 453 | " print(\"a is greter\")\n", 454 | "elif b>c and b>a:\n", 455 | " print(\"b is greater\") \n", 456 | "else:\n", 457 | " print(\"c is greater\")\n" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": null, 463 | "metadata": {}, 464 | "outputs": [], 465 | "source": [ 466 | "x = 50\n", 467 | "y = 30\n", 468 | "if(x==10)or(y<20):\n", 469 | " print(\"One or Both expressions are True\")\n", 470 | "else:\n", 471 | " print(\"Both are False!\")" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": null, 477 | "metadata": {}, 478 | "outputs": [], 479 | "source": [ 480 | "a=int(input(\"enter a\"))\n", 481 | "b=int(input(\"enter b\"))\n", 482 | "if (a and b ) > 0 :\n", 483 | " print(\"values are positive\")\n", 484 | " print(\"divide:\", a/b )\n", 485 | "elif b<= 0 :\n", 486 | " print(\"divide by 0 error\")\n" 487 | ] 488 | }, 489 | { 490 | "cell_type": "code", 491 | "execution_count": null, 492 | "metadata": {}, 493 | "outputs": [], 494 | "source": [ 495 | "a=int(input('enter a number'))\n", 496 | "b=int(input('enter a number'))\n", 497 | "c=int(input('enter a number'))\n", 498 | "if (a or b)/c:\n", 499 | " if (a and b)/c:\n", 500 | " print('both are divsible by c')\n", 501 | " else:\n", 502 | " print('only one is divisible')\n", 503 | "else:\n", 504 | " print('both are not divisible')\n" 505 | ] 506 | }, 507 | { 508 | "cell_type": "code", 509 | "execution_count": null, 510 | "metadata": {}, 511 | "outputs": [], 512 | "source": [ 513 | "\n" 514 | ] 515 | }, 516 | { 517 | "cell_type": "code", 518 | "execution_count": null, 519 | "metadata": {}, 520 | "outputs": [], 521 | "source": [ 522 | "a=int(input('enter first number'))\n", 523 | "b=int(input('enter second number'))\n", 524 | "c=int(input('enter third number'))\n", 525 | "if a!=b and a>b:\n", 526 | " print('you won a bike')\n", 527 | "elif a=20 or (temp==30)>20:\n", 543 | " print(\"cool weather\")\n", 544 | "else:\n", 545 | " print(\"warm weather\")\n" 546 | ] 547 | }, 548 | { 549 | "cell_type": "code", 550 | "execution_count": null, 551 | "metadata": {}, 552 | "outputs": [], 553 | "source": [ 554 | "name1=str(input(\"enter a string:\")) \n", 555 | "name2=str(input(\"enter a string:\")) \n", 556 | "if name1==name2:\n", 557 | " print('both the strings are equal') \n", 558 | "else:\n", 559 | " print('strings are not equal')\n" 560 | ] 561 | }, 562 | { 563 | "cell_type": "code", 564 | "execution_count": null, 565 | "metadata": {}, 566 | "outputs": [], 567 | "source": [ 568 | "if day1==\"saturday\" or day2==\"sunday\":\n", 569 | " print(\"You have decodr session\")\n", 570 | "elif (day1==\"sunday\") or (day2==\"saturday\"):\n", 571 | " print (\"You have decodr session\")\n", 572 | "else:\n", 573 | " print(\"Go with recorded session\")" 574 | ] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": null, 579 | "metadata": {}, 580 | "outputs": [], 581 | "source": [ 582 | "a = 10\n", 583 | " \n", 584 | "if not a:\n", 585 | " print(\"Boolean value of a is True\")\n", 586 | " \n", 587 | "if not (a%3 == 0 or a%5 == 0):\n", 588 | " print(\"10 is not divisible by either 3 or 5\")\n", 589 | "else:\n", 590 | " print(\"10 is divisible by either 3 or 5\")\n" 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": null, 596 | "metadata": {}, 597 | "outputs": [], 598 | "source": [ 599 | "a=float(input(\"enter 1st no. :\"))\n", 600 | "b=float(input(\"enter 2nd no. :\"))\n", 601 | "if a==b and a>=b:\n", 602 | " print(\"a is greater and \n", 603 | " equal\")\n", 604 | "elif not(a==b and a>=b):\n", 605 | " print(\"false\")\n", 606 | " \n" 607 | ] 608 | }, 609 | { 610 | "cell_type": "code", 611 | "execution_count": null, 612 | "metadata": {}, 613 | "outputs": [], 614 | "source": [ 615 | "str1=str(input(\"enter str1 :\"))\n", 616 | "str2=str1.reversed(str1)\n", 617 | "if str1 == str2 :\n", 618 | " print(\"str1 is palindrome\")\n", 619 | "else :\n", 620 | " print(\"str1 not palindrome\")" 621 | ] 622 | }, 623 | { 624 | "cell_type": "markdown", 625 | "metadata": {}, 626 | "source": [ 627 | "### python loops" 628 | ] 629 | }, 630 | { 631 | "cell_type": "code", 632 | "execution_count": null, 633 | "metadata": {}, 634 | "outputs": [], 635 | "source": [ 636 | "fruits=[\"Apple\",\"Mango\",\"Cherries\",\"Banana\"]\n", 637 | "for x in fruits:\n", 638 | " print(x)" 639 | ] 640 | }, 641 | { 642 | "cell_type": "code", 643 | "execution_count": null, 644 | "metadata": {}, 645 | "outputs": [], 646 | "source": [ 647 | "for x in \"Premalatha\":\n", 648 | " print(x)" 649 | ] 650 | }, 651 | { 652 | "cell_type": "code", 653 | "execution_count": null, 654 | "metadata": {}, 655 | "outputs": [], 656 | "source": [ 657 | "### break statement\n", 658 | "fruits=[\"Apple\",\"Mango\",\"Cherries\",\"Banana\"]\n", 659 | "for x in fruits:\n", 660 | " print(x)\n", 661 | " if x==\"Cherries\":\n", 662 | " break" 663 | ] 664 | }, 665 | { 666 | "cell_type": "code", 667 | "execution_count": null, 668 | "metadata": {}, 669 | "outputs": [], 670 | "source": [ 671 | "fruits=[\"Apple\",\"Mango\",\"Cherries\",\"Banana\"]\n", 672 | "for x in fruits:\n", 673 | " print(x)\n", 674 | " if x==\"Cherries\":\n", 675 | " break\n", 676 | " print(x)" 677 | ] 678 | }, 679 | { 680 | "cell_type": "code", 681 | "execution_count": null, 682 | "metadata": {}, 683 | "outputs": [], 684 | "source": [ 685 | "for x in range(10):\n", 686 | " print(x)" 687 | ] 688 | }, 689 | { 690 | "cell_type": "code", 691 | "execution_count": null, 692 | "metadata": {}, 693 | "outputs": [], 694 | "source": [ 695 | "for x in range(5,10):\n", 696 | " print(x)" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": null, 702 | "metadata": {}, 703 | "outputs": [], 704 | "source": [ 705 | "for name in\"latha\":\n", 706 | " if name==\"h\":\n", 707 | " break\n", 708 | " print(name)\n" 709 | ] 710 | }, 711 | { 712 | "cell_type": "code", 713 | "execution_count": null, 714 | "metadata": {}, 715 | "outputs": [], 716 | "source": [ 717 | "for name in\"latha\":\n", 718 | " if name==\"l\":\n", 719 | " continue\n", 720 | " print(name)" 721 | ] 722 | }, 723 | { 724 | "cell_type": "code", 725 | "execution_count": null, 726 | "metadata": {}, 727 | "outputs": [], 728 | "source": [ 729 | "for name in \"saurabh\":\n", 730 | " if name=='r':\n", 731 | " break\n", 732 | " print(name)\n" 733 | ] 734 | }, 735 | { 736 | "cell_type": "code", 737 | "execution_count": null, 738 | "metadata": {}, 739 | "outputs": [], 740 | "source": [ 741 | "students = [\"Paul\", \"Erin\", \"Connie\", \"Moira\"]\n", 742 | "\n", 743 | "for student in range(0, len(students)):\n", 744 | " if student == 2:\n", 745 | " break\n", 746 | " else:\n", 747 | " print(students[student])\n", 748 | "\n", 749 | " print(\"Counter is \" + str(student))\n" 750 | ] 751 | }, 752 | { 753 | "cell_type": "code", 754 | "execution_count": null, 755 | "metadata": {}, 756 | "outputs": [], 757 | "source": [ 758 | "days=['mon','tue','wed','thur','fri','sat','sun']\n", 759 | "for x in days:\n", 760 | " if x =='fri':\n", 761 | " break\n", 762 | " print(x)\n" 763 | ] 764 | }, 765 | { 766 | "cell_type": "markdown", 767 | "metadata": {}, 768 | "source": [ 769 | "## while loops" 770 | ] 771 | }, 772 | { 773 | "cell_type": "code", 774 | "execution_count": 3, 775 | "metadata": {}, 776 | "outputs": [ 777 | { 778 | "name": "stdout", 779 | "output_type": "stream", 780 | "text": [ 781 | "Addition is: 120\n" 782 | ] 783 | } 784 | ], 785 | "source": [ 786 | "num=15\n", 787 | "addition=0\n", 788 | "i=1\n", 789 | "while i<=num:\n", 790 | " addition=addition+i\n", 791 | " i=i+1\n", 792 | "print(\"Addition is:\",addition)" 793 | ] 794 | }, 795 | { 796 | "cell_type": "markdown", 797 | "metadata": {}, 798 | "source": [ 799 | "### For loop" 800 | ] 801 | }, 802 | { 803 | "cell_type": "code", 804 | "execution_count": 4, 805 | "metadata": {}, 806 | "outputs": [ 807 | { 808 | "name": "stdout", 809 | "output_type": "stream", 810 | "text": [ 811 | "Addition is: 55\n" 812 | ] 813 | } 814 | ], 815 | "source": [ 816 | "number=range(1,11)\n", 817 | "addition=0\n", 818 | "for i in number:\n", 819 | " addition=addition+i\n", 820 | "print(\"Addition is:\",addition)" 821 | ] 822 | }, 823 | { 824 | "cell_type": "markdown", 825 | "metadata": {}, 826 | "source": [ 827 | "### break" 828 | ] 829 | }, 830 | { 831 | "cell_type": "code", 832 | "execution_count": 6, 833 | "metadata": {}, 834 | "outputs": [ 835 | { 836 | "name": "stdout", 837 | "output_type": "stream", 838 | "text": [ 839 | "d\n", 840 | "a\n", 841 | "t\n", 842 | "a\n", 843 | "S\n", 844 | "c\n", 845 | "i\n", 846 | "The for loop stopped executing\n" 847 | ] 848 | } 849 | ], 850 | "source": [ 851 | "text=\"dataScience\"\n", 852 | "for letter in text:\n", 853 | " if letter==\"e\":\n", 854 | " break\n", 855 | " print(letter)\n", 856 | "print(\"The for loop stopped executing\")" 857 | ] 858 | }, 859 | { 860 | "cell_type": "code", 861 | "execution_count": 9, 862 | "metadata": {}, 863 | "outputs": [ 864 | { 865 | "name": "stdout", 866 | "output_type": "stream", 867 | "text": [ 868 | "d\n", 869 | "a\n", 870 | "t\n", 871 | "a\n", 872 | "S\n", 873 | "c\n", 874 | "i\n", 875 | "The loop leave a space here\n", 876 | "n\n", 877 | "c\n", 878 | "The loop leave a space here\n" 879 | ] 880 | } 881 | ], 882 | "source": [ 883 | "text=\"dataScience\"\n", 884 | "for letter in text:\n", 885 | " if letter==\"e\":\n", 886 | " print(\"The loop leave a space here\")\n", 887 | " continue\n", 888 | " print(letter)" 889 | ] 890 | }, 891 | { 892 | "cell_type": "code", 893 | "execution_count": 16, 894 | "metadata": {}, 895 | "outputs": [ 896 | { 897 | "name": "stdout", 898 | "output_type": "stream", 899 | "text": [ 900 | "Enter number of levels:10\n", 901 | "1 \n", 902 | "\n", 903 | "2 2 \n", 904 | "\n", 905 | "3 3 3 \n", 906 | "\n", 907 | "4 4 4 4 \n", 908 | "\n", 909 | "5 5 5 5 5 \n", 910 | "\n", 911 | "6 6 6 6 6 6 \n", 912 | "\n", 913 | "7 7 7 7 7 7 7 \n", 914 | "\n", 915 | "8 8 8 8 8 8 8 8 \n", 916 | "\n", 917 | "9 9 9 9 9 9 9 9 9 \n", 918 | "\n", 919 | "10 10 10 10 10 10 10 10 10 10 \n", 920 | "\n" 921 | ] 922 | } 923 | ], 924 | "source": [ 925 | "levels=int(input(\"Enter number of levels:\"))\n", 926 | "for level in range(1,levels+1):\n", 927 | " for num in range(level):\n", 928 | " print(level,end=\" \")\n", 929 | " \n", 930 | " print(\"\\n\")" 931 | ] 932 | }, 933 | { 934 | "cell_type": "code", 935 | "execution_count": null, 936 | "metadata": {}, 937 | "outputs": [], 938 | "source": [] 939 | } 940 | ], 941 | "metadata": { 942 | "kernelspec": { 943 | "display_name": "Python 3", 944 | "language": "python", 945 | "name": "python3" 946 | }, 947 | "language_info": { 948 | "codemirror_mode": { 949 | "name": "ipython", 950 | "version": 3 951 | }, 952 | "file_extension": ".py", 953 | "mimetype": "text/x-python", 954 | "name": "python", 955 | "nbconvert_exporter": "python", 956 | "pygments_lexer": "ipython3", 957 | "version": "3.8.3" 958 | } 959 | }, 960 | "nbformat": 4, 961 | "nbformat_minor": 4 962 | } 963 | -------------------------------------------------------------------------------- /Rules for naming the variable.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## what are Variables?\n", 8 | "### Variables are containers for storing values.\n", 9 | "### Python has no command for declaring the variables.\n", 10 | "### When you assign a value, a variable is created." 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "## Rules for declaring variable:\n", 18 | "### A variable name must start with a letter or underscore character\n", 19 | "### A variable name cannot start with a number\n", 20 | "### A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )\n", 21 | "### Variable names are case-sensitive (age, Age and AGE are three different variables)¶" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "data": { 31 | "text/plain": [ 32 | "5" 33 | ] 34 | }, 35 | "execution_count": 1, 36 | "metadata": {}, 37 | "output_type": "execute_result" 38 | } 39 | ], 40 | "source": [ 41 | "### Declaring a Variable\n", 42 | "x=5\n", 43 | "\n", 44 | "x" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 17, 50 | "metadata": {}, 51 | "outputs": [ 52 | { 53 | "data": { 54 | "text/plain": [ 55 | "'Latha'" 56 | ] 57 | }, 58 | "execution_count": 17, 59 | "metadata": {}, 60 | "output_type": "execute_result" 61 | } 62 | ], 63 | "source": [ 64 | "Name=\"Latha\" ## satisfy the rules\n", 65 | "Name" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 19, 71 | "metadata": {}, 72 | "outputs": [ 73 | { 74 | "data": { 75 | "text/plain": [ 76 | "'latha'" 77 | ] 78 | }, 79 | "execution_count": 19, 80 | "metadata": {}, 81 | "output_type": "execute_result" 82 | } 83 | ], 84 | "source": [ 85 | "name_123=\"latha\"\n", 86 | "name_123" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 18, 92 | "metadata": {}, 93 | "outputs": [ 94 | { 95 | "ename": "NameError", 96 | "evalue": "name 'name' is not defined", 97 | "output_type": "error", 98 | "traceback": [ 99 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 100 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 101 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mname\u001b[0m \u001b[1;31m### case sensitive\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 102 | "\u001b[1;31mNameError\u001b[0m: name 'name' is not defined" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "name ### case sensitive" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 20, 113 | "metadata": {}, 114 | "outputs": [ 115 | { 116 | "data": { 117 | "text/plain": [ 118 | "'Latha'" 119 | ] 120 | }, 121 | "execution_count": 20, 122 | "metadata": {}, 123 | "output_type": "execute_result" 124 | } 125 | ], 126 | "source": [ 127 | "Name_2nick=\"Latha\"\n", 128 | "Name_2nick" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 6, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "data": { 138 | "text/plain": [ 139 | "'Latha'" 140 | ] 141 | }, 142 | "execution_count": 6, 143 | "metadata": {}, 144 | "output_type": "execute_result" 145 | } 146 | ], 147 | "source": [ 148 | "_Nickname=\"Latha\"\n", 149 | "_Nickname\n" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 7, 155 | "metadata": {}, 156 | "outputs": [ 157 | { 158 | "ename": "SyntaxError", 159 | "evalue": "invalid syntax (, line 1)", 160 | "output_type": "error", 161 | "traceback": [ 162 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m 1Nickname=\"Latha\" ## var should not start with a number\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" 163 | ] 164 | } 165 | ], 166 | "source": [ 167 | "1Nickname=\"Latha\" ## var should not start with a number\n" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 9, 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "data": { 177 | "text/plain": [ 178 | "'Latha'" 179 | ] 180 | }, 181 | "execution_count": 9, 182 | "metadata": {}, 183 | "output_type": "execute_result" 184 | } 185 | ], 186 | "source": [ 187 | "N1ickname=\"Latha\" ### Number can be used in the variable other than the first character\n", 188 | "N1ickname" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 10, 194 | "metadata": {}, 195 | "outputs": [ 196 | { 197 | "ename": "SyntaxError", 198 | "evalue": "cannot assign to operator (, line 1)", 199 | "output_type": "error", 200 | "traceback": [ 201 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m Nick*name=\"Latha\"\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to operator\n" 202 | ] 203 | } 204 | ], 205 | "source": [ 206 | "Nick*name=\"Latha\" ### No spl character is allowed other than underscore" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": 11, 212 | "metadata": {}, 213 | "outputs": [ 214 | { 215 | "ename": "SyntaxError", 216 | "evalue": "cannot assign to operator (, line 1)", 217 | "output_type": "error", 218 | "traceback": [ 219 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m Nick@name=\"Latha\"\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to operator\n" 220 | ] 221 | } 222 | ], 223 | "source": [ 224 | "Nick@name=\"Latha\" ### No spl character is allowed other than underscore" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 12, 230 | "metadata": {}, 231 | "outputs": [ 232 | { 233 | "data": { 234 | "text/plain": [ 235 | "23" 236 | ] 237 | }, 238 | "execution_count": 12, 239 | "metadata": {}, 240 | "output_type": "execute_result" 241 | } 242 | ], 243 | "source": [ 244 | "age=23\n", 245 | "age" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 14, 251 | "metadata": {}, 252 | "outputs": [ 253 | { 254 | "ename": "NameError", 255 | "evalue": "name 'Age' is not defined", 256 | "output_type": "error", 257 | "traceback": [ 258 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 259 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 260 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mAge\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 261 | "\u001b[1;31mNameError\u001b[0m: name 'Age' is not defined" 262 | ] 263 | } 264 | ], 265 | "source": [ 266 | "Age ### case sensitive" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": 15, 272 | "metadata": {}, 273 | "outputs": [ 274 | { 275 | "ename": "NameError", 276 | "evalue": "name 'AGE' is not defined", 277 | "output_type": "error", 278 | "traceback": [ 279 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 280 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 281 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mAGE\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 282 | "\u001b[1;31mNameError\u001b[0m: name 'AGE' is not defined" 283 | ] 284 | } 285 | ], 286 | "source": [ 287 | "AGE ### case sensitive" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "## Question\n", 295 | "### 1)-var=\"hi\" \n", 296 | "### 2)1abc=23\n", 297 | "### 3)a1bc=23\n", 298 | "### 4)ab*c=23\n", 299 | "### Which of these variable name/names is/are correct?" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": {}, 306 | "outputs": [], 307 | "source": [] 308 | } 309 | ], 310 | "metadata": { 311 | "kernelspec": { 312 | "display_name": "Python 3", 313 | "language": "python", 314 | "name": "python3" 315 | }, 316 | "language_info": { 317 | "codemirror_mode": { 318 | "name": "ipython", 319 | "version": 3 320 | }, 321 | "file_extension": ".py", 322 | "mimetype": "text/x-python", 323 | "name": "python", 324 | "nbconvert_exporter": "python", 325 | "pygments_lexer": "ipython3", 326 | "version": "3.8.3" 327 | } 328 | }, 329 | "nbformat": 4, 330 | "nbformat_minor": 4 331 | } 332 | -------------------------------------------------------------------------------- /String Handling.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### String Handling" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 9, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "text=\"Data Science is interesting\"" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 11, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "data": { 26 | "text/plain": [ 27 | "'Artificial Intelligence is interesting'" 28 | ] 29 | }, 30 | "execution_count": 11, 31 | "metadata": {}, 32 | "output_type": "execute_result" 33 | } 34 | ], 35 | "source": [ 36 | "text.replace(\"Data Science\",\"Artificial Intelligence\")" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 12, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "'DATA SCIENCE IS INTERESTING'" 48 | ] 49 | }, 50 | "execution_count": 12, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "text.upper()" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 13, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "data": { 66 | "text/plain": [ 67 | "'data science is interesting'" 68 | ] 69 | }, 70 | "execution_count": 13, 71 | "metadata": {}, 72 | "output_type": "execute_result" 73 | } 74 | ], 75 | "source": [ 76 | "text.lower()" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 14, 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "text/plain": [ 87 | "'Data Science Is Interesting'" 88 | ] 89 | }, 90 | "execution_count": 14, 91 | "metadata": {}, 92 | "output_type": "execute_result" 93 | } 94 | ], 95 | "source": [ 96 | "text.title()" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "### Concatenate each element of date with sep" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": 15, 109 | "metadata": {}, 110 | "outputs": [ 111 | { 112 | "data": { 113 | "text/plain": [ 114 | "'04/05/1993'" 115 | ] 116 | }, 117 | "execution_count": 15, 118 | "metadata": {}, 119 | "output_type": "execute_result" 120 | } 121 | ], 122 | "source": [ 123 | "date=\"04\",\"05\",\"1993\"\n", 124 | "sep='/'\n", 125 | "sep.join(date)" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 22, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "data": { 135 | "text/plain": [ 136 | "'Python*for*Data*Science'" 137 | ] 138 | }, 139 | "execution_count": 22, 140 | "metadata": {}, 141 | "output_type": "execute_result" 142 | } 143 | ], 144 | "source": [ 145 | "## print the string by removing leading and trailing \"*\" character\n", 146 | "text=\"***Python*for*Data*Science***\" \n", 147 | "text.strip(\"*\")" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 23, 153 | "metadata": {}, 154 | "outputs": [ 155 | { 156 | "data": { 157 | "text/plain": [ 158 | "'Python for Data Science'" 159 | ] 160 | }, 161 | "execution_count": 23, 162 | "metadata": {}, 163 | "output_type": "execute_result" 164 | } 165 | ], 166 | "source": [ 167 | "### print the string by removing leading *\n", 168 | "text=\"***Python for Data Science\"\n", 169 | "text.strip(\"*\")" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 24, 175 | "metadata": {}, 176 | "outputs": [ 177 | { 178 | "data": { 179 | "text/plain": [ 180 | "'Python for Data Science'" 181 | ] 182 | }, 183 | "execution_count": 24, 184 | "metadata": {}, 185 | "output_type": "execute_result" 186 | } 187 | ], 188 | "source": [ 189 | "### print the string by removing trailing*\n", 190 | "text=\"Python for Data Science***\"\n", 191 | "text.strip(\"*\")" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": null, 197 | "metadata": {}, 198 | "outputs": [], 199 | "source": [] 200 | } 201 | ], 202 | "metadata": { 203 | "kernelspec": { 204 | "display_name": "Python 3", 205 | "language": "python", 206 | "name": "python3" 207 | }, 208 | "language_info": { 209 | "codemirror_mode": { 210 | "name": "ipython", 211 | "version": 3 212 | }, 213 | "file_extension": ".py", 214 | "mimetype": "text/x-python", 215 | "name": "python", 216 | "nbconvert_exporter": "python", 217 | "pygments_lexer": "ipython3", 218 | "version": "3.8.3" 219 | } 220 | }, 221 | "nbformat": 4, 222 | "nbformat_minor": 4 223 | } 224 | -------------------------------------------------------------------------------- /Tuple.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Tuple" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "('Python for DS', 'AIML', 'Business Analytics with Python')\n" 20 | ] 21 | } 22 | ], 23 | "source": [ 24 | "books_list=\"Python for DS\",\"AIML\",\"Business Analytics with Python\"\n", 25 | "print(books_list)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "data": { 35 | "text/plain": [ 36 | "tuple" 37 | ] 38 | }, 39 | "execution_count": 2, 40 | "metadata": {}, 41 | "output_type": "execute_result" 42 | } 43 | ], 44 | "source": [ 45 | "type(books_list)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 4, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "data": { 55 | "text/plain": [ 56 | "tuple" 57 | ] 58 | }, 59 | "execution_count": 4, 60 | "metadata": {}, 61 | "output_type": "execute_result" 62 | } 63 | ], 64 | "source": [ 65 | "books_list=(\"Python for DS\",\"AIML\",\"Business Analytics with Python\")\n", 66 | "type(books_list)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "### Tuple can be written with parantheses or without even brackets." 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 5, 79 | "metadata": {}, 80 | "outputs": [ 81 | { 82 | "ename": "AttributeError", 83 | "evalue": "'tuple' object has no attribute 'sort'", 84 | "output_type": "error", 85 | "traceback": [ 86 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 87 | "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", 88 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0msample_tuple\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m12\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m21\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m34\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m43\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0msample_tuple\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 89 | "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'sort'" 90 | ] 91 | } 92 | ], 93 | "source": [ 94 | "sample_tuple=12,21,34,43,1,2\n", 95 | "sample_tuple.sort()" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 7, 101 | "metadata": {}, 102 | "outputs": [ 103 | { 104 | "data": { 105 | "text/plain": [ 106 | "[1, 2, 12, 21, 34, 43]" 107 | ] 108 | }, 109 | "execution_count": 7, 110 | "metadata": {}, 111 | "output_type": "execute_result" 112 | } 113 | ], 114 | "source": [ 115 | "sample_tuple_sorted=sorted(sample_tuple)\n", 116 | "sample_tuple_sorted" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 9, 122 | "metadata": {}, 123 | "outputs": [ 124 | { 125 | "data": { 126 | "text/plain": [ 127 | "[43, 34, 21, 12, 2, 1]" 128 | ] 129 | }, 130 | "execution_count": 9, 131 | "metadata": {}, 132 | "output_type": "execute_result" 133 | } 134 | ], 135 | "source": [ 136 | "sample_tuple_rev=sorted(sample_tuple,reverse=True)\n", 137 | "sample_tuple_rev" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 10, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "data": { 147 | "text/plain": [ 148 | "(12, 21, 34, 43, 1, 2, 12, 21, 34, 43, 1, 2, 12, 21, 34, 43, 1, 2)" 149 | ] 150 | }, 151 | "execution_count": 10, 152 | "metadata": {}, 153 | "output_type": "execute_result" 154 | } 155 | ], 156 | "source": [ 157 | "repeated=sample_tuple*3 ### repeat the elements\n", 158 | "repeated" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "# Concatenating two tuples" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 11, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "data": { 175 | "text/plain": [ 176 | "(12,\n", 177 | " 21,\n", 178 | " 34,\n", 179 | " 43,\n", 180 | " 1,\n", 181 | " 2,\n", 182 | " 'Python for DS',\n", 183 | " 'AIML',\n", 184 | " 'Business Analytics with Python')" 185 | ] 186 | }, 187 | "execution_count": 11, 188 | "metadata": {}, 189 | "output_type": "execute_result" 190 | } 191 | ], 192 | "source": [ 193 | "sample_tuple+books_list" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 12, 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "True\n" 206 | ] 207 | } 208 | ], 209 | "source": [ 210 | "print(\"AIML\" in books_list) ### checking existence" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 14, 216 | "metadata": {}, 217 | "outputs": [ 218 | { 219 | "name": "stdout", 220 | "output_type": "stream", 221 | "text": [ 222 | "True\n" 223 | ] 224 | } 225 | ], 226 | "source": [ 227 | "print(\"Intro to Machine Learning\" not in books_list)" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 18, 233 | "metadata": {}, 234 | "outputs": [ 235 | { 236 | "name": "stdout", 237 | "output_type": "stream", 238 | "text": [ 239 | "Python for DS\n", 240 | "AIML\n", 241 | "Business Analytics with Python\n" 242 | ] 243 | } 244 | ], 245 | "source": [ 246 | "for every_book in books_list:\n", 247 | " print (every_book)" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 19, 253 | "metadata": {}, 254 | "outputs": [ 255 | { 256 | "data": { 257 | "text/plain": [ 258 | "3" 259 | ] 260 | }, 261 | "execution_count": 19, 262 | "metadata": {}, 263 | "output_type": "execute_result" 264 | } 265 | ], 266 | "source": [ 267 | "len(books_list)" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 20, 273 | "metadata": {}, 274 | "outputs": [ 275 | { 276 | "data": { 277 | "text/plain": [ 278 | "'Python for DS'" 279 | ] 280 | }, 281 | "execution_count": 20, 282 | "metadata": {}, 283 | "output_type": "execute_result" 284 | } 285 | ], 286 | "source": [ 287 | "max(books_list)" 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": 21, 293 | "metadata": {}, 294 | "outputs": [ 295 | { 296 | "data": { 297 | "text/plain": [ 298 | "43" 299 | ] 300 | }, 301 | "execution_count": 21, 302 | "metadata": {}, 303 | "output_type": "execute_result" 304 | } 305 | ], 306 | "source": [ 307 | "max(sample_tuple)" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 22, 313 | "metadata": {}, 314 | "outputs": [ 315 | { 316 | "data": { 317 | "text/plain": [ 318 | "1" 319 | ] 320 | }, 321 | "execution_count": 22, 322 | "metadata": {}, 323 | "output_type": "execute_result" 324 | } 325 | ], 326 | "source": [ 327 | "min(sample_tuple)" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": 25, 333 | "metadata": {}, 334 | "outputs": [ 335 | { 336 | "ename": "TypeError", 337 | "evalue": "'>' not supported between instances of 'str' and 'int'", 338 | "output_type": "error", 339 | "traceback": [ 340 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 341 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 342 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0msample_tuple_2\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m13.5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m23\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"latha\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msample_tuple_2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 343 | "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'str' and 'int'" 344 | ] 345 | } 346 | ], 347 | "source": [ 348 | "sample_tuple_2=(13.5,23,\"latha\") ## tuple is immutable\n", 349 | "max(sample_tuple_2)" 350 | ] 351 | }, 352 | { 353 | "cell_type": "code", 354 | "execution_count": 26, 355 | "metadata": {}, 356 | "outputs": [ 357 | { 358 | "ename": "AttributeError", 359 | "evalue": "'tuple' object has no attribute 'append'", 360 | "output_type": "error", 361 | "traceback": [ 362 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 363 | "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", 364 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msample_tuple\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 365 | "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'" 366 | ] 367 | } 368 | ], 369 | "source": [ 370 | "sample_tuple.append(2)" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": 28, 376 | "metadata": {}, 377 | "outputs": [ 378 | { 379 | "data": { 380 | "text/plain": [ 381 | "(12, 21)" 382 | ] 383 | }, 384 | "execution_count": 28, 385 | "metadata": {}, 386 | "output_type": "execute_result" 387 | } 388 | ], 389 | "source": [ 390 | "sample_tuple[0:2]" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": null, 396 | "metadata": {}, 397 | "outputs": [], 398 | "source": [] 399 | } 400 | ], 401 | "metadata": { 402 | "kernelspec": { 403 | "display_name": "Python 3", 404 | "language": "python", 405 | "name": "python3" 406 | }, 407 | "language_info": { 408 | "codemirror_mode": { 409 | "name": "ipython", 410 | "version": 3 411 | }, 412 | "file_extension": ".py", 413 | "mimetype": "text/x-python", 414 | "name": "python", 415 | "nbconvert_exporter": "python", 416 | "pygments_lexer": "ipython3", 417 | "version": "3.8.3" 418 | } 419 | }, 420 | "nbformat": 4, 421 | "nbformat_minor": 4 422 | } 423 | --------------------------------------------------------------------------------