Curriculum

Python Curriculum by Scriptixari

Explore the full Scriptixari course map: from a first look at Python to multi-part study scenarios with files, functions, data, objects, and code review.

1. Free Kit

Focus: A first introduction to Python, basic code reading, variables, conditions, and short exercises.

Modules:

  • Python First Look — an initial understanding of what Python code looks like.
  • Code Logic Basics — the basic logic behind actions in code.
  • Variables and Values — variables, values, and simple data types.
  • Simple Conditions — conditions and basic code behavior paths.
  • Basic Practice Tasks — short exercises for first practice.
  • Common Beginner Mistakes — common starting mistakes and careful code reading.
  • Learning Structure Map — a general map of the learning route.
  • Next Study Direction — guidance for choosing the next learning step.

2. Luma Guide

Focus: Core Python topics presented in a sequential order.

Modules:

  • Python Syntax Guide — syntax, indentation, and the general format of Python code.
  • Data Building Blocks — strings, numbers, boolean values, and data types.
  • Conditions in Practice — conditions used in practical examples.
  • Loop Logic — repeated actions and working with multiple values.
  • Function Basics — creating simple functions.
  • Lists and Simple Collections — lists and basic collections.
  • Practice Tasks Map — an approach to study tasks.
  • Code Reading Routine — careful reading of short code fragments.

3. Vertex Module

Focus: Combining core topics into practical study tasks.

Modules:

  • Task Planning Basics — reviewing a task description before writing code.
  • Function Structure — functions with separate roles.
  • Lists in Real Tasks — lists used in practical examples.
  • Dictionary Logic — keys, values, and simple data structures.
  • Conditions with Data — using conditions together with collections.
  • Loop Patterns — searching, counting, and grouping with loops.
  • Code Cleanup Practice — reducing repetition and improving code order.
  • Mini Task Assembly — combining several topics into one task.

4. Nexus Series

Focus: Files, errors, modules, and connections between code parts.

Modules:

  • Code Structure Map — understanding the role of different parts of a solution.
  • Working with Files — reading, creating, and changing text files.
  • Error Reading Basics — carefully reading error messages.
  • Exception Handling — handling unexpected situations in code.
  • Module Thinking — dividing code into several logical parts.
  • Data Flow Between Blocks — movement of data between functions and files.
  • Simple Project Layout — basic organization of a study project.
  • Review and Refine — reviewing completed code and improving its organization.

5. Cipher Framework

Focus: Code roles, objects, data validation, and reusable components.

Modules:

  • Framework Thinking — understanding code as a set of parts with different roles.
  • Logic Separation — separating logic, validation, and helper blocks.
  • Class Basics — classes, objects, attributes, and methods.
  • Object Practice — simple objects for study tasks.
  • Data Validation Flow — the sequence for checking input data.
  • Reusable Code Blocks — code components that can be used again.
  • Small System Layout — a small Python system made of several parts.
  • Framework Review Practice — reviewing structure and dependencies.

6. Loom Collection

Focus: Combining Python topics into a broader study scenario.

Modules:

  • Learning Route Assembly — combining previous knowledge into one route.
  • Scenario Planning — dividing a larger task into stages.
  • Data Handling Practice — receiving, cleaning, and preparing data.
  • Function and Class Balance — choosing between functions and simple classes.
  • File-Based Workflow — working with several files.
  • Code Connection Patterns — connecting modules, functions, and classes.
  • Practical Study Scenario — moving from a task description to completed code.
  • Review, Notes, and Refinement — notes, review, and structure improvement.

7. Arc Collection

Focus: The full task path: idea, data, logic, checks, and final review.

Modules:

  • Arc Planning Method — building a task from an idea into a working outline.
  • Input and Output Logic — input data, final output, and processing rules.
  • Structured Functions — functions with separate roles.
  • Class-Based Study Blocks — simple classes for related data and actions.
  • Data Movement Map — tracking data movement through the code.
  • Error and Edge Case Practice — unusual situations and additional checks.
  • Multi-Part Study Build — a study solution made of several blocks.
  • Final Review Routine — final review and readability improvement.

8. Slate Collection

Focus: Planning, naming, data preparation, and organized code structure.

Modules:

  • Clean Task Outline — a short task plan before writing code.
  • Code Block Roles — the roles of blocks: data, logic, checks, and output.
  • Naming and Readability — understandable names for variables, functions, and files.
  • Data Preparation Flow — preparing and checking data.
  • Function Layout Practice — arranging functions inside a study solution.
  • Multi-File Organization — dividing code across several files.
  • Refinement Pass — reviewing repetition and unnecessary complexity.
  • Slate Study Build — a complete example with planning, structure, and review.

9. Grid Collection

Focus: A Python solution viewed as a grid of connected blocks.

Modules:

  • Grid Thinking for Code — understanding a solution as a system of connected parts.
  • Task Structure Matrix — stages, roles, data, and expected output.
  • Data Layer Organization — organizing the data layer.
  • Function Grid Practice — a set of functions with different roles.
  • Class and Object Placement — the place of classes and objects within the structure.
  • File and Module Layout — files, modules, and helper components.
  • Multi-Block Study Build — a solution made of several connected blocks.
  • Grid Review Method — reviewing the full structure as one connected grid.

10. Motion Collection

Focus: Step-based building, checking, and improving longer study scenarios.

Modules:

  • Motion Planning Flow — a stage map for a larger task.
  • Step-Based Code Building — building code in separate parts.
  • Data Movement Practice — tracking changes and data movement.
  • Function Sequence Design — the sequence of functions inside a scenario.
  • Object Use in Motion — simple objects used in multi-step tasks.
  • Midpoint Review Routine — reviewing code during the work process.
  • Multi-Stage Study Scenario — a multi-step study solution.
  • Final Motion Pass — final review, refined naming, and reduced repetition.

A digital infographic outlining the 'Scriptixari Python Curriculum' on a dark, code-patterned background. The curriculum is displayed as a vertical list of blue rectangular modules connected by lines, including Free Kit, Luma Guide, Vertex Module, Nexus Series, Cipher Framework, Arc Collection, State Collection, Grid Collection, and Motion Collection.