CLICK HERE TO REGISTER

• Boolean operators: not and or
• relational operators ( == != > >= < <= ), building complex Boolean expressions
• assignments and shortcut operators
• accuracy of floating-point numbers
• basic input and output: input(), print(), int(), float(), str() functions formatting print() output with end= and sep= arguments
• conditional statements: if, if-else, if-elif, if-elif-else
• the pass instruction
• simple lists: constructing vectors, indexing and slicing, the len() function
• simple strings: constructing, assigning, indexing, slicing comparing, immutability
• building loops: while, for, range(), in, iterating through sequences expanding loops: while-else, for-else, nesting loops and conditional statements
• controlling loop execution: break, continue
• strings in detail: ASCII, UNICODE, UTF-8, immutability, escaping using the \ character, quotes and apostrophes inside strings, multiline strings, copying vs. cloning, advanced slicing, string vs. string, string vs. non-string, basic string methods (upper(), lower(), isxxx(), capitalize(), split(), join(), etc.) and functions (len(), chr(), ord()), escape characters
• lists in detail: indexing, slicing, basic methods (append(), insert(), index()) and functions (len(), sorted(), etc.), del instruction, iterating lists with the for loop, initializing, in and not in operators, list comprehension, copying and cloning
• lists in lists: matrices and cubes
• tuples: indexing, slicing, building, immutability
• tuples vs. lists: similarities and differences, lists inside tuples and tuples inside lists
• dictionaries: building, indexing, adding and removing keys, iterating through dictionaries as well as their keys and values, checking key existence, keys(), items() and values() methods
• defining and invoking your own functions and generators
• return and yield keywords, returning results, the None keyword, recursion
• parameters vs. arguments, positional keyword and mixed argument passing, default parameter values
• converting generator objects into lists using the list() function
• name scopes, name hiding (shadowing), the global keyword
• lambda functions, defining and using
• map(), filter(), reduce(), reversed(), sorted() functions and the sort() method
• the if operator
• import directives, qualifying entities with module names, initializing modules
• writing and using modules, the __name__ variable
• pyc file creation and usage
• constructing and distributing packages, packages vs. directories, the role of the __init__.py file
• hiding module entities
• Python hashbangs, using multiline strings as module documentation
• defining your own classes, superclasses, subclasses, inheritance, searching for missing class components, creating objects
• class attributes: class variables and instance variables, defining, adding and removing attributes, explicit constructor invocation
• class methods: defining and using, the self parameter meaning and usage
• inheritance and overriding, finding class/object components
• single inheritance vs. multiple inheritance
• name mangling
• invoking methods, passing and using the self argument/parameter
• the __init__ method
• the role of the __str__ method
• introspection: __dict__, __name__, __module__, __bases__ properties, examining class/object structure
• writing and using constructors
• hasattr(), type(), issubclass(), isinstance(), super() functions
• using predefined exceptions and defining your own ones
• the try-except-else-finally block, the raise statement, the excepts variant
• exceptions hierarchy, assigning more than one exception to one except branch
• adding your own exceptions to an existing hierarchy assertions
• the anatomy of an exception object
• input/output basics: opening files with the open() function, stream objects, binary vs. text files, newline character translation, reading and
• writing files, bytearray objects read(), readinto(), readline(), write(), close() methods
• import variants; advanced qualifiying for nested module
• dir(); sys.path variable
• math: ceil(), floor(), trunc(), factorial(), hypot(), sqrt(); random: random(), seed(), choice(), sample()
• platform: platform(), machine(), processor(), system(), version(), python_implementation(), python_version_tuple()
• idea, __pycache__, __name__, public variables, __init__.py
• searching for modules/packages; nested packages vs directory tree
• except, except:-except; except:-else:, except (e1,e2)
• the hierarchy of exceptions
• raise, raise ex, assert
• event classes, except E as e, arg property
• self-defined exceptions, defining and using
• ASCII, UNICODE, UTF-8, codepoints, escape sequences
• ord(), chr(), literals
• indexing, slicing, immutability
• iterating through,
• concatenating, multiplying, comparing (against strings and numbers) in, not in
• .isxxx(), .join(), .split()
• .sort(), sorted(), .index(), .find(), .rfind()
• ideas: class, object, property, method, encapsulation, inheritance, grammar vs class, superclass, subclass
• instance vs class variables: declaring, initializing
• __dict__ property (objects vs classes)
• private components (instance vs classes), name mangling
• methods: declaring, using, self parameter
• instrospection: hasattr() (objects vs classes), __name__, __module__, __bases__ properties
• inheritance: single, multiple, isinstance(), overriding, not is and is operators
• inheritance: single, multiple, isinstance(), overriding, not is and is operators
• constructors: declaring and invoking
• polymorphism
• __name__, __module__, __bases__ properties, __str__() method
• multiple inheritance, diamonds
• list comprehension: if operator, using list comprehensions
• lambdas: defining and using lambdas, self-defined functions taking lambda as as arguments; map(), filter();
• closures: meaning, defining, and using closures
• I/O Operations: I/O modes, predefined streams, handles; text/binary modes open(), errno and its values; close() .read(), .write(), .readline(); readlines() (along with bytearray())

Prerequisite

Anyone who does not have any idea on programming language. And you should have good internet and zeal to learn C programming language.

How We Coach

Acceleratron researched that basic and advanced courses are majorly available in urban cities. Which are unavailable for rural candidates. If any candidate wants to take these courses, then they must stay temporarily in cities. Also, they send a lot of time, energy & money during their daily convenience.

To overcome all these situations, we deliver our course through virtual classes. During our interactive sessions, we engage our students with discussions & project module development. Acceleratron learning process is divided into two parts, viz. knowledge gathering and skill development. Teachers & coaches deliver knowledge within the virtual interactive class. During these classes, students are provided with assignments which is a time-bound activity. Once the information delivery of a subject is complete, they engage with project module development. Projects are developed in small groups. Mentors govern this group activity to demonstrate the deployment life cycle along with the project development.

Our Sessions

Our sessions are 2 hours long. The entire course takes approximately 36 Hrs. Every week three classes are organized, which include both technical and practical class. These classes are scheduled on Monday, Tuesday & Friday. Mostly these sessions are arranged in the late evening to avoid any schedule conflicts with professionals and students. Candidate should also be available for the group activities like project discussion, project status meeting. On regular intervals (biweekly/monthly), we take feedback from our students to maximize the effectiveness of our learning process.

Journey with Acceleratron

Journey with Acceleratron starts from enrolment of a candidate through online enrolment form. During enrolment, each candidate pays enrolment fees*. Once enrolled, candidates will go through an intake discussion. We capture a few details about the candidate during this discussion.

We start with our course delivery. At this point, candidates don't pay us any tuition fees*. After the first week, if the candidate is unhappy, we don't charge any tuition fees*, else he pays the entire tuition fees*. After the completion of the first month (started from the first class of the curriculum), If the candidate wants to continue with our course, then he pays the final instalment.

We tailored our course in slots so that the candidates can always have an option to withdraw, without any financial loss.

* The fees structure varies with the country from which the candidate is joining. Please contact Acceleratron help desk or your referee to get more insight on our fees structure.

Learning Outcomes & Exit Profiles

After the completion of this course, candidates would be able to

• Learn the universal concepts of computer programming
• Learn the syntax and semantics of the Python language
• Practice skills in resolving typical implementation challenges
• Use the most important elements of Python Standard Library
• They will be able to make their software independently
• Write your own Python programs
• Learn general coding techniques and best practices
• Learn to use object-oriented programming in Python
• Learn how to import and use Python modules
• Learn how to handle exceptions
• Learn how to process files
• Prepare for PCAP certification
• Use the most important elements of Python Standard Library
• Certificate of completion from Acceleratron after finishing the full Python course