Online Coding Classes With 1-on-1 Live Mentorship

# Python OOP Example
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.courses = []
        
    def enroll_course(self, course):
        self.courses.append(course)
        print(f"{self.name} enrolled in {course}")
        
    def display_info(self):
        print(f"Student: {self.name}")
        print(f"Age: {self.age}")
        print(f"Courses: {self.courses}")

# Create a student and enroll in a course
student = Student("Alice", 22)
student.enroll_course("Python Development")
student.display_info()

# Data analysis example
import pandas as pd
import matplotlib.pyplot as plt

# Load and analyze data
data = pd.read_csv("student_data.csv")
results = data.groupby("course").mean()
results.plot(kind="bar")
plt.title("Average Scores by Course")
plt.show()
                                    

#include 
#include 
#include 

class Student {
private:
    std::string name;
    int age;
    std::vector courses;

public:
    Student(const std::string& name, int age) 
        : name(name), age(age) {}
    
    void enrollCourse(const std::string& course) {
        courses.push_back(course);
        std::cout << name << " enrolled in " << course << std::endl;
    }
    
    void displayInfo() const {
        std::cout << "Student: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "Courses: ";
        for (const auto& course : courses) {
            std::cout << course << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    Student student("Bob", 21);
    student.enrollCourse("C++ Programming");
    student.displayInfo();
    
    return 0;
}
                                    

// React Component Example
import React, { useState } from 'react';

const StudentProfile = () => {
  const [student, setStudent] = useState({
    name: 'Emma',
    age: 23,
    courses: ['HTML', 'CSS', 'JavaScript']
  });
  
  const enrollCourse = (course) => {
    setStudent(prev => ({
      ...prev,
      courses: [...prev.courses, course]
    }));
  };
  
  return (
    

      
{student.name}'s Profile
      
Age: {student.age}
      
      
Enrolled Courses:
      

        {student.courses.map((course, index) => (
          
{course}
        ))}
      
      
       enrollCourse('React')}
        className="enroll-btn"
      >
        Enroll in React
      
    
  );
};

export default StudentProfile;
                                    

// Backend: Express.js API
const express = require('express');
const mongoose = require('mongoose');
const app = express();

// Connect to MongoDB
mongoose.connect('mongodb://localhost/nplearn');

// Student model
const Student = mongoose.model('Student', {
  name: String,
  age: Number,
  courses: [String]
});

// API routes
app.get('/api/students', async (req, res) => {
  const students = await Student.find();
  res.json(students);
});

app.post('/api/students/:id/enroll', async (req, res) => {
  const { course } = req.body;
  const student = await Student.findById(req.params.id);
  student.courses.push(course);
  await student.save();
  res.json(student);
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

// Frontend: React component to consume API
function StudentList() {
  const [students, setStudents] = useState([]);
  
  useEffect(() => {
    fetch('/api/students')
      .then(res => res.json())
      .then(data => setStudents(data));
  }, []);
  
  return (
    

      
Students
      

        {students.map(student => (
          

            {student.name} - {student.courses.length} courses
          
        ))}
      
    
  );
}
                                    

# Machine Learning Example with scikit-learn
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Load student performance data
data = pd.read_csv('student_performance.csv')

# Prepare features and target
X = data.drop('passed_course', axis=1)
y = data['passed_course']

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train model
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Make predictions
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Model accuracy: {accuracy:.2f}")

# Feature importance
importances = model.feature_importances_
features = X.columns
for feature, importance in zip(features, importances):
    print(f"{feature}: {importance:.4f}")

# Predict for new student
new_student = [[25, 40, 10, 35]]  # hours studied per subject
result = model.predict(new_student)
print(f"Prediction: {'Pass' if result[0] else 'Fail'}")
                                    

// Kotlin Android Example
class StudentActivity : AppCompatActivity() {
    
    private lateinit var binding: ActivityStudentBinding
    private val viewModel: StudentViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        binding = ActivityStudentBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        setupUI()
        observeViewModel()
    }
    
    private fun setupUI() {
        binding.enrollButton.setOnClickListener {
            val course = binding.courseInput.text.toString()
            if (course.isNotEmpty()) {
                viewModel.enrollInCourse(course)
                binding.courseInput.text.clear()
            }
        }
    }
    
    private fun observeViewModel() {
        viewModel.student.observe(this) { student ->
            binding.nameText.text = student.name
            binding.ageText.text = "${student.age} years old"
            
            // Update course list
            binding.coursesList.adapter = ArrayAdapter(
                this,
                android.R.layout.simple_list_item_1,
                student.courses
            )
        }
    }
}

// ViewModel
class StudentViewModel : ViewModel() {
    private val _student = MutableLiveData(
        Student("David", 19, mutableListOf("Android Basics"))
    )
    val student: LiveData = _student
    
    fun enrollInCourse(course: String) {
        val currentStudent = _student.value ?: return
        val updatedCourses = currentStudent.courses.toMutableList()
        updatedCourses.add(course)
        
        _student.value = currentStudent.copy(
            courses = updatedCourses
        )
    }
}

data class Student(
    val name: String,
    val age: Int,
    val courses: List
)