Courses

In this course, I learned how to create and manage containers with Docker, manage, create, and optimize images, work with networks, and use Docker Compose to orchestrate containers.

In this course, I learned:

• Learning as a Lifestyle: The importance of lifelong learning, the role of a professional in continuous development, personal motivations for learning, and different learning styles.
• Talent or Discipline?: How to move from the comfort zone to the learning zone, the role of discipline in learning, habit formation, eliminating barriers, the practice of feedback, and strategies for building good habits.
• Unraveling the Brain: The difference between fixed and growth mindsets, strategies to reinforce a growth mindset, focused vs. diffuse learning modes, learning formats, distributed practice vs. cramming, and techniques to strengthen long-term memory.
• The Power of Goals: How to define effective learning goals, use the SMART method for goal setting, measure progress through different levels, and apply the Learning Matrix for tracking evolution.
• Learning Routine: How to create and plan an effective learning routine, manage time and space, balance physical and mental activities, use simple yet powerful techniques, and leverage different tools for optimizing learning.

• Reading Students with JSON: Setting up the environment, reading student names from JSON, adding unique IDs, merging DataFrames, and working with JSON both locally and on the web.
• Creating Courses from HTML: Extracting course data from HTML, modifying indexes, and analyzing data correctness.
• Writing CSV, JSON, and HTML: Enrolling students, selecting courses, and exporting data in multiple formats, including CSV, JSON, and HTML tables.
• Reading and Writing SQL: Creating and querying an SQL database using Pandas, handling table creation, and executing SQL queries.
• Reading and Writing Excel: Managing student data in Excel, writing and reading spreadsheets, and maintaining attendance sheets.

In this course, I learned:

• Getting to Know Jupyter: How to install Anaconda, set up a virtual environment, and use Jupyter Notebook for data analysis.
• Importing Data: How to download files, import datasets into Pandas, and explore the structure and information of a DataFrame.
• Series and Index: How to remove duplicates, apply Pandas methods, redefine indexes, and create or concatenate DataFrames.
• Filtering Data: How to filter residential properties, make selections in a dataset, export databases, and organize DataFrames using sort_index.
• Property Frequencies: How to analyze selection frequencies, work with different levels of selection, and apply various filtering techniques.
• Handling Missing Data: How to identify and remove null values, apply conditional treatments, and use interpolation methods to fill missing data.
• New Variables: How to create new variables, troubleshoot errors in variable creation, and remove unnecessary variables using different exclusion methods.
• Descriptive Statistics: How to group data, summarize key insights, and apply descriptive statistics, including creating value ranges with the cut() function.
• Removing Outliers: How to detect and remove outliers using box plot statistics, group-based filtering, and data visualization techniques with Matplotlib.

In this course, I learned:

• Course Introduction: The basics of Python, setting up the development environment, working with data, and an initial introduction to the Pandas library.
• Static Lists - Tuples: How to create and use tuples, select and iterate over items, and apply loops and the zip() function with tuples.
• Mapping Data - Dictionaries: Creating and manipulating dictionaries, performing operations, using dictionary methods, and iterating over dictionary structures.
• Code Organization - Functions and Packages: Defining functions with and without parameters, returning values, improving function design, and using built-in functions.
• The Scientists' Library - Pandas: Understanding Pandas data structures, creating and selecting data in DataFrames, performing queries, iterating over data, and handling missing values.

In this course, I learned:

• Data Scientist Environment: How to setting up the development environment, checking Python version, working with NumPy arrays, and using them with external data.
• Python Features: How to performing mathematical operations, working with variables and data types, string formatting and concatenation, and understanding indentation and comments.
• Working with Lists: How to creating and manipulating lists, selecting and slicing list elements, and using list methods and copy operations.
• Conditionals and Loops: How to using for loops, list comprehensions, nested loops, and conditional statements (if, elif, else) with logical operators.
• Exploring NumPy: How to understanding NumPy arrays, performing operations, selecting and slicing array elements, and applying basic statistical functions like calculating the mean.

In this course, I learned:

• Introduction to PEP-8 and Type Hints: Understanding Type Hints, building a class following PEP-8 guidelines, and improving code readability.
• Code Linting Tools: Using Mypy and Flake8 for static analysis, integrating Flake8 into commits, and ensuring code quality.
• Template Method and PEP-8: Managing line length, solving style issues, implementing the Template Method pattern, and refining code structure.
• Advanced Typing Techniques: Exploring PEP-8 constants, factory functions, and advanced type annotations to enhance code maintainability.
• Dependency Injection and Responsibility: Reducing conditional logic, implementing dependency injection, discussing responsibility in code design, and using type aliases.

In this course, I learned:

• Object Creation and the Factory Pattern: Introduction to the problem of object creation, naming conventions, Factory and Builder patterns, and implementing a factory without a class.
• Saving States with Memento: Using the Memento pattern to store previous states, creating the Contract class, and challenges in implementation.
• DSLs and the Interpreter Pattern: Applying the Interpreter pattern for building domain-specific languages and defining abstract classes.
• Data Structures and the Visitor Pattern: Implementing the Visitor pattern to manipulate complex data structures.
• Different Actions with the Command Pattern: Applying the Command pattern to encapsulate requests, implementing the Order class, and exploring variations of the pattern.

In this course, I learned:

• Design Patterns and the Strategy Pattern: Introduction to design patterns, motivation for their use, when to apply the Strategy pattern, and practical implementation.
• Multiple Discounts and the Chain of Responsibility: Using the Chain of Responsibility pattern to handle multiple discount calculations, its advantages, and integration with the Strategy pattern.
• Similar Code and the Template Method: Applying the Template Method pattern to structure similar taxation logic using abstract classes.
• Composed Behaviors and the Decorator Pattern: Implementing the Decorator pattern to dynamically extend behavior, comparing it to Chain of Responsibility, and exploring Python's built-in decorator capabilities.
• Changing States and the State Pattern: Managing state-dependent behavior using the State pattern, applying extra discounts conditionally.
• Object Creation and the Builder Pattern: Using the Builder pattern to create objects with complex initialization, comparing it to Python's built-in constructor mechanisms.
• Executing Different Actions with the Observer Pattern: Applying the Observer pattern to trigger multiple actions in response to an event.
• Beyond Design Patterns: Exploring additional design patterns for filtering, external system notifications, algorithm structuring, and contract handling.

In this course, I learned:

• Reading Files: Introduction to file reading, understanding encoding, different reading methods, and hands-on practice.
• Writing Files: Writing data to files, managing file operations with close and flush methods, and iterating over files.
• Best Practices and Exceptions: Handling concurrency, properly closing resources, managing common exceptions, and using context managers (with).
• Understanding Buffers: Optimizing memory with buffering, writing efficiently, and handling text differences between Python 2 and Python 3.
• Converting Contacts: Converting CSV data to Python objects, using Pickle and JSON, discussing system communication, and implementing DAOs for data access.
• Conclusion: Final considerations on file handling in Python.

In this course, I learned:

• Introduction to Exceptions: Understanding AttributeError, identifying exceptions, forcing errors, using try and except, and handling errors.
• Propagation and Raising Exceptions: Handling multiple except blocks, using raise, and understanding exception flow.
• Arguments and Aliases: Simulating private attributes, encapsulating assignments, and working with exception arguments.
• Debugging via Command Line: Using the debugger to analyze and fix exceptions efficiently.
• Enhancing Exceptions: Creating custom exceptions, reflecting on errors, and enriching exception handling.
• Chained Exceptions: Understanding traceback, handling chained exceptions, and managing error information.
• Releasing Resources with with: Using the finally block, resource management, and syntactic sugar for cleanup operations.
• Final Project and Conclusion: Applying learned concepts in a final project.

In this course, I learned:

• Introduction to Test Doubles: Understanding TDD, designing book consultation tests, and why test doubles are useful.
• Using Test Doubles: Applying test doubles for HTTP requests, understanding Stub, and handling exceptions with unittest.mock.
• Capturing Indirect Outputs: Testing function calls, verifying directory and file creation, using Spy, and ensuring correct write operations.
• Programming Expected Behavior and Verifying Inputs: Exploring the Mock double, testing repeated requests and responses, handling errors in API calls, and logging failures.
• Handling Errors and Dependencies: Testing failures on the first page of results, dealing with unavailable components, and verifying database insertions.
• Using Fake Doubles: Implementing Fake test doubles with and without unittest.mock and testing data persistence.
• Final Project and Conclusion: Applying test doubles in real-world scenarios.

In this course, I learned:

• Preparing the Environment: Setting up the project, understanding the domain, and implementing the auction evaluator.
• Unit Testing Basics: Starting with unit tests, running tests in the terminal, and exploring the connection between testing and productivity.
• Best Practices and Test Scenarios: Creating new tests, renaming them, working with equivalence classes, and isolating the test setup.
• Refactoring Domain Classes: Implementing encapsulation, understanding state and behavior, and applying the Law of Demeter (Principle of Least Knowledge).
• New Business Rules and Exception Testing: Adding new business rules, testing exceptions, and following TDD with baby steps.
• Testing with Pytest: Introduction to Pytest, writing tests, using fixtures, and testing exceptions.
• Refactoring the Project: Isolating conditions, adding business exceptions, improving code readability, and refactoring the domain.

In this course, I learned:

• Validating CPF: Understanding and validating CPF numbers, using Python packages, and how to utilize them effectively.
• Validating CNPJ and Building a Factory: Validating CNPJ, creating CNPJ masks, and refactoring code to build a Factory pattern.
• Validating Phone Numbers with Regular Expressions: Using regular expressions (regex) to define and validate phone numbers and creating phone number masks.
• Manipulating and Formatting Dates: Working with dates in Python, formatting them, and understanding timedelta differences, as well as using strftime.
• Working with ZIP Codes (CEP) and Accessing an API: Understanding APIs, validating CEPs, making requests with Python, and working with API responses related to ZIP codes.

In this course, I learned:

• Introduction to Sets: Understanding sets in Python, performing basic operations, and verifying data in sets.
• Set Operations: Exploring more set operations, working with different types of sets, and handling set variations.
• Dictionaries: Introduction to dictionaries, performing operations on dictionaries, and filtering values from them.
• Variations of Dictionaries: Exploring defaultdict and Counter, counting values, and applying these variations in practical scenarios.
• Practical Practice: Applying all the concepts learned in practice and finalizing the project.

In this course, I learned:

• Introduction and Slicing Strings: Introduction to string slicing and its use in extracting parts of strings like names and URLs. Discusses string immutability in Python.
• Using String Methods: Exploring methods like find() and len() for string manipulation. Validating and extracting parameters from URLs.
• Applying Object-Oriented Programming: Creating a class for URL validation and handling special cases like None vs. empty, and conditional checks in Python.
• Regular Expressions: Introduction to regular expressions (RegEx), quantifiers, intervals, and using them for tasks like CPF validation and URL validation in the application.
• Special Methods: Discussing special methods like __len__() and __str__(), and understanding the difference between is and == for identity and equality checks in Python.
• Project: Implementing a currency conversion project using the knowledge gained from the course.

In this course, I learned:

• The Problem with the Procedural Paradigm: The differences between procedural and object-oriented programming, the concept of data and behavior, and the initial steps of an object-oriented project.
• Classes and Objects: How to define classes and objects, create constructors, assign default values to attributes, and access class attributes.
• Implementing Methods: How to define and use methods, improve class behavior, understand None and garbage collection, and specify a class's responsibilities.
• Encapsulation: The importance of private attributes, the use of double underscores (__), the benefits of encapsulation, and the principles of cohesion in object-oriented programming.
• Using Properties: How to create and use getters and setters, improve access to private attributes, and implement properties for better data control.
• Private and Static Methods: The role of private and static methods, their syntax, when to use them, and the differences between object-oriented programming in Python and Java.

In this course, I learned:

• Revisiting Classes and Objects: Understanding object-oriented concepts, initializing objects, adding attributes and methods, encapsulating behavior, and using properties.
• Removing Duplication with Inheritance: Exploring inheritance, reducing code duplication, reusing and extending classes, and understanding the advantages of inheritance.
• Reducing Ifs with Polymorphism: Applying polymorphism to simplify conditional logic, enhancing object representation, and using __str__ for textual output.
• When Not to Use Inheritance: Identifying cases where inheritance increases complexity, understanding its drawbacks, and considering alternative approaches.
• Duck Typing and Data Models: Implementing Duck Typing, protected attributes, iterable advantages, Python’s data model, abstract base classes (ABCs), and composition vs. extension.
• Multiple Inheritance: Managing multiple parent classes, resolving method conflicts, understanding mixins, and exploring the pros and cons of multiple inheritance.

In this course, I learned:

• Game Loop: Setting up the game structure, understanding boolean types, handling errors, and configuring the IDE for UTF-8 support.
• Manipulating Strings: Finding and iterating over characters in a string, using built-in string functions, and modifying strings effectively.
• Working with Lists: Understanding list structures, storing guessed letters, counting occurrences, and exploring list operations.
• Working with Tuples: Learning about immutable sequences, differences between lists and tuples, and using tuples alongside lists.
• Implementing Game Termination: Setting error limits, controlling loops, using list comprehensions, and handling alternative exit strategies.
• Reading and Writing Files: Using the open function, managing file access, reading and writing words, and implementing best practices.
• Improving Code and Presentation: Organizing code into functions, enhancing game visuals, applying best coding practices, and exporting refactored code.

In this course, I learned:

• Introduction to Collections and Lists: Introduction to lists and list operations, exploring list comprehension, and handling the mutability of lists.
• Tuples: Exploring tuples, comparing them to lists, and using them with objects and classes. Understanding the difference between tuples and lists.
• Polymorphism and Arrays: Exploring lists with polymorphism, arrays using NumPy, and creating arrays with abstract methods.
• Equality: Understanding equality in Python and implementing the __eq__ method for object comparison.
• Other Built-in Functions: Exploring built-in functions like enumerate, range, and automatic tuple unpacking.
• Natural Order: Basic sorting of lists and organizing data.
• Custom Sorting: Implementing custom sorting for objects and using the __lt__ method to define the sorting behavior.
• Total Sorting: Using functools for complete sorting and applying best practices in sorting.

In this course, I learned:

• Python Installation: Installing Python on Windows and other platforms, using Python without installation, and understanding basic functions like print and variables.
• Understanding Variables and Typing: Learning about variable types and Python's type system, including snake_case naming convention and user input handling.
• Working with PyCharm: Setting up PyCharm, creating your first project, comparing variables, and understanding the differences between Python 2 and Python 3.
• Conditionals and Loops: Using if, elif, else, and while loops, including string formatting, conditional statements, and loop control using break and continue.
• Random Numbers: Generating random numbers, defining intervals, and creating random games or simulations using Python's random module.
• Game Development: Adding levels, scores, and built-in functions to a game, as well as rounding numbers and dividing points.
• Organizing Code: Importing files, creating functions, and understanding module imports and execution flow.
• Comparing Python with C: Understanding the differences between interpreted (Python) and compiled (C) languages.

In this course, I learned:

• Function and High-level Language: Learning the basics of high-level programming languages, creating variables, defining functions, and understanding the difference between high and low-level languages.
• Parameters, Conditionals, and Type Conversion: Creating functions with parameters, using conditional statements, and performing type conversions in Python.
• Lists, Loops, and Boolean Type: Working with lists, using loops to iterate through them, and understanding the boolean data type in Python.
• The Import System: Learning about importing libraries and modules, using Python's import system, and understanding the organization of Python code with lists and imports.
• Plotting with Matplotlib: Creating basic plots and graphs using the Matplotlib library, and understanding logic and final values in visualizations.