-
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())
Anyone who does not have any idea on programming language. And you
should have good internet and zeal to learn C programming language.
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 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 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.
After the completion of this course, candidates would be able to