350+ Exercises – Python Programming Mega Pack – OOP – 2022

350+ Exercises - Python Programming Mega Pack - OOP - 2022

350+ Exercises – Python Programming Mega Pack – OOP – 2022

Mega Pack – Improve your Python programming & Object Oriented Programming skills and solve over 350 exercises!

Language: english

Note: 5.0/5 (15 notes) 11,421 students

Instructor(s): Paweł Krakowiak

Last update: 2022-08-31

What you’ll learn

  • solve over 350 exercises in Python and Object Oriented Programming (OOP)
  • deal with real programming problems
  • work with documentation
  • guaranteed instructor support

 

Requirements

  • completion of all courses in the Python Developer learning path
  • basic knowledge of Object Oriented Programming (OOP) concepts
  • basic knowledge of Python
  • I have courses which can assist in obtaining all the necessary skills for this course

 

Description

Welcome to the 350+ Exercises – Python Programming Mega Pack – OOP course where you can test your Python & Object Oriented Programming skills.


Topics you will find in the basic exercises:

  • print() function

  • calculations in Python

  • slicing

  • strings, and str methods

  • data types

  • data structures: set. tuple, list, dict

  • program flow control

  • if statement

  • for loops

  • break statement

  • continue statement

  • while loops

  • exception handling

  • input/output

  • reading files

  • saving to files

  • built-in functions

  • defining your own functions

  • anonymous functions – lambda expression

  • generators

  • set comprehension

  • list comprehension

  • dict comprehension

  • built-in modules


Topics you will find in the Object Oriented Programming exercises:

  • namespaces and scopes

  • LEGB rule

  • *args and **kwargs

  • class attributes

  • instance attributes

  • the __init__() method

  • visibility of variables/attributes

  • encapsulation

  • computed attributes

  • class method – decorator @classmethod

  • static method – decorator @staticmethod

  • special methods, __new__(), __init__(), __repr__(), __str__(), __len__() and many more

  • inheritance, single inheritance, multiple inheritance

  • MRO – Method Resolution Order

  • super()

  • abstract classes, the ABC class and the @abstractmethod decorator


This course is designed for people who have basic knowledge in Python and OOP concepts. It consists of 350 exercises with solutions. This is a great test for people who are learning the Python language and Object Oriented Programming and are looking for new challenges. Exercises are also a good test before the interview.


If you’re wondering if it’s worth taking a step towards Python and OOP, don’t hesitate any longer and take the challenge today.


Stack Overflow Developer Survey

According to the Stack Overflow Developer Survey 2021, Python is the most wanted programming language. Python passed SQL to become our third most popular technology. Python is the language developers want to work with most if they aren’t already doing so.

 

Who this course is for

  • everyone who wants to learn by doing
  • everyone who wants to improve Python programming skills
  • everyone who wants to improve OOP skills
  • everyone who wants to prepare for an interview

 

Course content

  • Tips
    • A few words from the author
    • Configuration
    • Requirements
  • Starter
    • Exercise 0
    • Solution 0
  • —–BASICS—–
    • Intro
  • print() function
    • Exercise 1
    • Solution 1
    • Exercise 2
    • Solution 2
    • Exercise 3
    • Solution 3
    • Exercise 4
    • Solution 4
    • Exercise 5
    • Solution 5
    • Exercise 6
    • Solution 6
    • Exercise 7
    • Solution 7
    • Exercise 8
    • Solution 8
    • Exercise 9
    • Solution 9
    • Exercise 10
    • Solution 10
  • Calculations in Python
    • Exercise 11
    • Solution 11
    • Exercise 12
    • Solution 12
    • Exercise 13
    • Solution 13
    • Exercise 14
    • Solution 14
    • Exercise 15
    • Solution 15
    • Exercise 16
    • Solution 16
    • Exercise 17
    • Solution 17
    • Exercise 18
    • Solution 18
    • Exercise 19
    • Solution 19
    • Exercise 20
    • Solution 20
    • Exercise 21
    • Solution 21
    • Exercise 22
    • Solution 22
  • Slicing
    • Exercise 23
    • Solution 23
    • Exercise 24
    • Solution 24
    • Exercise 25
    • Solution 25
    • Exercise 26
    • Solution 26
  • Data Types
    • Exercise 27
    • Solution 27
    • Exercise 28
    • Solution 28
    • Exercise 29
    • Solution 29
  • Strings
    • Exercise 30
    • Solution 30
    • Exercise 31
    • Solution 31
    • Exercise 32
    • Solution 32
    • Exercise 33
    • Solution 33
    • Exercise 34
    • Solution 34
    • Exercise 35
    • Solution 35
    • Exercise 36
    • Solution 36
    • Exercise 37
    • Solution 37
    • Exercise 38
    • Solution 38
    • Exercise 39
    • Solution 39
    • Exercise 40
    • Solution 40
    • Exercise 41
    • Solution 41
    • Exercise 42
    • Solution 42
    • Exercise 43
    • Solution 43
    • Exercise 44
    • Solution 44
  • —– DATA STRUCTURES —–
    • Intro
  • Sets
    • Exercise 45
    • Solution 45
    • Exercise 46
    • Solution 46
    • Exercise 47
    • Solution 47
    • Exercise 48
    • Solution 48
    • Exercise 49
    • Solution 49
  • Tuples
    • Exercise 50
    • Solution 50
    • Exercise 51
    • Solution 51
    • Exercise 52
    • Solution 52
    • Exercise 53
    • Solution 53
    • Exercise 54
    • Solution 54
    • Exercise 55
    • Solution 55
    • Exercise 56
    • Solution 56
  • Lists
    • Exercise 57
    • Solution 57
    • Exercise 58
    • Solution 58
    • Exercise 59
    • Solution 59
    • Exercise 60
    • Solution 60
    • Exercise 61
    • Solution 61
    • Exercise 62
    • Solution 62
    • Exercise 63
    • Solution 63
  • Dictionaries
    • Exercise 64
    • Solution 64
    • Exercise 65
    • Solution 65
    • Exercise 66
    • Solution 66
    • Exercise 67
    • Solution 67
    • Exercise 68
    • Solution 68
    • Exercise 69
    • Solution 69
    • Exercise 70
    • Solution 70
    • Exercise 71
    • Solution 71
    • Exercise 72
    • Solution 72
    • Exercise 73
    • Solution 73
    • Exercise 74
    • Solution 74
    • Exercise 75
    • Solution 75
    • Exercise 76
    • Solution 76
    • Exercise 77
    • Solution 77
  • —– PROGRAM FLOW CONTROL —–
    • Intro
  • if statement
    • Exercise 78
    • Solution 78
    • Exercise 79
    • Solution 79
    • Exercise 80
    • Solution 80
    • Exercise 81
    • Solution 81
    • Exercise 82
    • Solution 82
    • Exercise 83
    • Solution 83
    • Exercise 84
    • Solution 84
    • Exercise 85
    • Solution 85
  • for loop
    • Exercise 86
    • Solution 86
    • Exercise 87
    • Solution 87
    • Exercise 88
    • Solution 88
    • Exercise 89
    • Solution 89
    • Exercise 90
    • Solution 90
    • Exercise 91
    • Solution 91
    • Exercise 92
    • Solution 92
    • Exercise 93
    • Solution 93
    • Exercise 94
    • Solution 94
    • Exercise 95
    • Solution 95
    • Exercise 96
    • Solution 96
    • Exercise 97
    • Solution 97
  • break statement
    • Exercise 98
    • Solution 98
    • Exercise 99
    • Solution 99
    • Exercise 100
    • Solution 100
  • continue statement
    • Exercise 101
    • Solution 101
    • Exercise 102
    • Solution 102
  • while loop
    • Exercise 103
    • Solution 103
    • Exercise 104
    • Solution 104
    • Exercise 105
    • Solution 105
    • Exercise 106
    • Solution 106
  • Exception handling
    • Exercise 107
    • Solution 107
    • Exercise 108
    • Solution 108
    • Exercise 109
    • Solution 109
  • —–INPUT/OUTPUT—–
    • Intro
  • Reading files
    • Exercise 110
    • Solution 110
    • Exercise 111
    • Solution 111
    • Exercise 112
    • Solution 112
    • Exercise 113
    • Solution 113
    • Exercise 114
    • Solution 114
  • Saving to file
    • Exercise 115
    • Solution 115
    • Exercise 116
    • Solution 116
    • Exercise 117
    • Solution 117
  • —–FUNCTIONS—–
    • Intro
  • Built-in functions
    • Exercise 118
    • Solution 118
    • Exercise 119
    • Solution 119
    • Exercise 120
    • Solution 120
    • Exercise 121
    • Solution 121
    • Exercise 122
    • Solution 122
    • Exercise 123
    • Solution 123
    • Exercise 124
    • Solution 124
  • Defining your own functions
    • Exercise 125
    • Solution 125
    • Exercise 126
    • Solution 126
    • Exercise 127
    • Solution 127
    • Exercise 128
    • Solution 128
    • Exercise 129
    • Solution 129
    • Exercise 130
    • Solution 130
    • Exercise 131
    • Solution 131
    • Exercise 132
    • Solution 132
    • Exercise 133
    • Solution 133
    • Exercise 134
    • Solution 134
    • Exercise 135
    • Solution 135
    • Exercise 136
    • Solution 136
    • Exercise 137
    • Solution 137
  • Lambda expression
    • Exercise 138
    • Solution 138
    • Exercise 139
    • Solution 139
    • Exercise 140
    • Solution 140
    • Exercise 141
    • Solution 141
    • Exercise 142
    • Solution 142
    • Exercise 143
    • Solution 143
    • Exercise 144
    • Solution 144
    • Exercise 145
    • Solution 145
    • Exercise 146
    • Solution 146
  • Generators
    • Exercise 147
    • Solution 147
    • Exercise 148
    • Solution 148
    • Exercise 149
    • Solution 149
  • —– TRANSFORMATION OF DATA STRUCTURES —–
    • Intro
  • set comprehension
    • Exercise 150
    • Solution 150
    • Exercise 151
    • Solution 151
    • Exercise 152
    • Solution 152
    • Exercise 153
    • Solution 153
    • Exercise 154
    • Solution 154
    • Exercise 155
    • Solution 155
  • list comprehension
    • Exercise 156
    • Solution 156
    • Exercise 157
    • Solution 157
    • Exercise 158
    • Solution 158
    • Exercise 159
    • Solution 159
    • Exercise 160
    • Solution 160
    • Exercise 161
    • Solution 161
    • Exercise 162
    • Solution 162
  • dict comprehension
    • Exercise 163
    • Solution 163
    • Exercise 164
    • Solution 164
    • Exercise 165
    • Solution 165
    • Exercise 166
    • Solution 166
    • Exercise 167
    • Solution 167
    • Exercise 168
    • Solution 168
    • Exercise 169
    • Solution 169
  • —– BUILT-IN PACKAGES —–
    • Intro
  • Built-in packages
    • Exercise 170
    • Solution 170
    • Exercise 171
    • Solution 171
    • Exercise 172
    • Solution 172
    • Exercise 173
    • Solution 173
    • Exercise 174
    • Solution 174
    • Exercise 175
    • Solution 175
    • Exercise 176
    • Solution 176
    • Exercise 177
    • Solution 177
    • Exercise 178
    • Solution 178
    • Exercise 179
    • Solution 179
    • Exercise 180
    • Solution 180
    • Exercise 181
    • Solution 181
    • Exercise 182
    • Solution 182
    • Exercise 183
    • Solution 183
  • Summary
    • Exercise 184
    • Solution 184
    • Exercise 185
    • Solution 185
    • Exercise 186
    • Solution 186
    • Exercise 187
    • Solution 187
    • Exercise 188
    • Solution 188
    • Exercise 189
    • Solution 189
    • Exercise 190
    • Solution 190
    • Exercise 191
    • Solution 191
    • Exercise 192
    • Solution 192
    • Exercise 193
    • Solution 193
    • Exercise 194
    • Solution 194
    • Exercise 195
    • Solution 195
    • Exercise 196
    • Solution 196
    • Exercise 197
    • Solution 197
    • Exercise 198
    • Solution 198
    • Exercise 199
    • Solution 199
    • Exercise 200
    • Solution 200
    • Exercise 201
    • Solution 201
  • —– OBJECT ORIENTED PROGRAMMING (OOP) —–
    • Intro
  • Namespaces and Scopes
    • Exercise 202
    • Solution 202
    • Exercise 203
    • Solution 203
    • Exercise 204
    • Solution 204
  • The LEGB rule
    • Exercise 205
    • Solution 205
    • Exercise 206
    • Solution 206
    • Exercise 207
    • Solution 207
    • Exercise 208
    • Solution 208
    • Exercise 209
    • Solution 209
  • Reminder: *args and **kwargs
    • Exercise 210
    • Solution 210
    • Exercise 211
    • Solution 211
  • Classes – the basics
    • Exercise 212
    • Solution 212
    • Exercise 213
    • Solution 213
    • Exercise 214
    • Solution 214
    • Exercise 215
    • Solution 215
    • Exercise 216
    • Solution 216
    • Exercise 217
    • Solution 217
    • Exercise 218
    • Solution 218
    • Exercise 219
    • Solution 219
    • Exercise 220
    • Solution 220
    • Exercise 221
    • Solution 221
    • Exercise 222
    • Solution 222
    • Exercise 223
    • Solution 223
    • Exercise 224
    • Solution 224
  • Class attributes
    • Exercise 225
    • Solution 225
    • Exercise 226
    • Solution 226
    • Exercise 227
    • Solution 227
    • Exercise 228
    • Solution 228
    • Exercise 229
    • Solution 229
    • Exercise 230
    • Solution 230
    • Exercise 231
    • Solution 231
    • Exercise 232
    • Solution 232
    • Exercise 233
    • Solution 233
    • Exercise 234
    • Solution 234
    • Exercise 235
    • Solution 235
  • Instance attributes
    • Exercise 236
    • Solution 236
    • Exercise 237
    • Solution 237
    • Exercise 238
    • Solution 238
    • Exercise 239
    • Solution 239
    • Exercise 240
    • Solution 240
    • Exercise 241
    • Solution 241
    • Exercise 242
    • Solution 242
  • __init__() method
    • Exercise 243
    • Solution 243
    • Exercise 244
    • Solution 244
    • Exercise 245
    • Solution 245
    • Exercise 246
    • Solution 246
    • Exercise 247
    • Solution 247
    • Exercise 248
    • Solution 248
    • Exercise 249
    • Solution 249
    • Exercise 250
    • Solution 250
    • Exercise 251
    • Solution 251
  • Visibility of variables
    • Exercise 252
    • Solution 252
    • Exercise 253
    • Solution 253
    • Exercise 254
    • Solution 254
    • Exercise 255
    • Solution 255
  • Encapsulation
    • Exercise 256
    • Solution 256
    • Exercise 257
    • Solution 257
    • Exercise 258
    • Solution 258
    • Exercise 259
    • Solution 259
    • Exercise 260
    • Solution 260
    • Exercise 261
    • Solution 261
    • Exercise 262
    • Solution 262
    • Exercise 263
    • Solution 263
    • Exercise 264
    • Solution 264
    • Exercise 265
    • Solution 265
    • Exercise 266
    • Solution 266
    • Exercise 267
    • Solution 267
    • Exercise 268
    • Solution 268
    • Exercise 269
    • Solution 269
    • Exercise 270
    • Solution 270
    • Exercise 271
    • Solution 271
    • Exercise 272
    • Solution 272
  • Computed Attributes
    • Exercise 273
    • Solution 273
    • Exercise 274
    • Solution 274
    • Exercise 275
    • Solution 275
    • Exercise 276
    • Solution 276
    • Exercise 277
    • Solution 277
  • Class method – decorator @classmethod
    • Exercise 278
    • Solution 278
    • Exercise 279
    • Solution 279
    • Exercise 280
    • Solution 280
    • Exercise 281
    • Solution 281
    • Exercise 282
    • Solution 282
  • Static method – decorator @staticmethod
    • Exercise 283
    • Solution 283
    • Exercise 284
    • Solution 284
    • Exercise 285
    • Solution 285
    • Exercise 286
    • Solution 286
  • Special methods
    • Exercise 287
    • Solution 287
    • Exercise 288
    • Solution 288
    • Exercise 289
    • Solution 289
    • Exercise 290
    • Solution 290
    • Exercise 291
    • Solution 291
    • Exercise 292
    • Solution 292
    • Exercise 293
    • Solution 293
    • Exercise 294
    • Solution 294
    • Exercise 295
    • Solution 295
    • Exercise 296
    • Solution 296
    • Exercise 297
    • Solution 297
    • Exercise 298
    • Solution 298
    • Exercise 299
    • Solution 299
    • Exercise 300
    • Solution 300
    • Exercise 301
    • Solution 301
    • Exercise 302
    • Solution 302
    • Exercise 303
    • Solution 303
    • Exercise 304
    • Solution 304
    • Exercise 305
    • Solution 305
  • Inheritance
    • Exercise 306
    • Solution 306
    • Exercise 307
    • Solution 307
    • Exercise 308
    • Solution 308
    • Exercise 309
    • Solution 309
    • Exercise 310
    • Solution 310
    • Exercise 311
    • Solution 311
    • Exercise 312
    • Solution 312
    • Exercise 313
    • Solution 313
    • Exercise 314
    • Solution 314
    • Exercise 315
    • Solution 315
    • Exercise 316
    • Solution 316
    • Exercise 317
    • Solution 317
    • Exercise 318
    • Solution 318
    • Exercise 319
    • Solution 319
    • Exercise 320
    • Solution 320
    • Exercise 321
    • Solution 321
    • Exercise 322
    • Solution 322
  • Abstract classes
    • Exercise 323
    • Solution 323
    • Exercise 324
    • Solution 324
    • Exercise 325
    • Solution 325
    • Exercise 326
    • Solution 326
    • Exercise 327
    • Solution 327
    • Exercise 328
    • Solution 328
    • Exercise 329
    • Solution 329
  • Summary
    • Exercise 330
    • Solution 330
    • Exercise 331
    • Solution 331
    • Exercise 332
    • Solution 332
    • Exercise 333
    • Solution 333
    • Exercise 334
    • Solution 334
    • Exercise 335
    • Solution 335
    • Exercise 336
    • Solution 336
    • Exercise 337
    • Solution 337
    • Exercise 338
    • Solution 338
    • Exercise 339
    • Solution 339
    • Exercise 340
    • Solution 340
    • Exercise 341
    • Solution 341
    • Exercise 342
    • Solution 342
    • Exercise 343
    • Solution 343
    • Exercise 344
    • Solution 344
    • Exercise 345
    • Solution 345
    • Exercise 346
    • Solution 346
    • Exercise 347
    • Solution 347
    • Exercise 348
    • Solution 348
    • Exercise 349
    • Solution 349
    • Exercise 350
    • Solution 350
    • Exercise 351
    • Solution 351
    • Exercise 352
    • Solution 352
  • Configuration (optional)
    • Info
    • Google Colab + Google Drive
    • Google Colab + GitHub
    • Google Colab – Intro
    • Anaconda installation – Windows 10
    • Introduction to Spyder
    • Anaconda installation – Linux
  • Bonus
    • Bonus

 

Time remaining or 791 enrolls left

 

Don’t miss any coupons by joining our Telegram group 

Udemy Coupon Code 100% off | Udemy Free Course | Udemy offer | Course with certificate