In today’s digital age, having a compelling online portfolio is essential for showcasing your skills and experience. This article will walk you through my journey of creating a modern, responsive portfolio website using React, Vite, and Tailwind CSS for my Web Development final project (UAS).

Project Overview

This portfolio website serves as a comprehensive showcase of my educational background, work experience, skills, and projects. The website features a clean, modern design with smooth animations and responsive layout that works seamlessly across all devices.

Key Features:

• Responsive Design : Optimized for desktop, tablet, and mobile devices
• Interactive UI : Smooth animations and particle effects
• Project Showcase : Detailed presentation of completed projects
• Contact Section : Easy way for visitors to get in touch
• Modern Stack : Built with cutting-edge web technologies

Technology Stack

React.js

React was chosen as the frontend framework for its component-based architecture, which allows for:

• Reusable UI components
• Efficient state management
• Fast rendering with virtual DOM
• Strong community support and extensive ecosystem

Vite

Vite serves as the build tool and development server, providing:

• Lightning-fast hot module replacement (HMR)
• Optimized build process
• Modern ES modules support
• Excellent developer experience

Tailwind CSS

Tailwind CSS was selected for styling because it offers:

• Utility-first approach for rapid development
• Consistent design system
• Easy responsive design implementation
• Small bundle size with purging unused styles

Project Structure

src/
├── components/
│   ├── Particle.js          # Particle animation effects
│   ├── Project.jsx          # Individual project component
│   └── sections/
│       ├── Contact.jsx      # Contact form and information
│       ├── EducationAndExperience.jsx
│       ├── Footer.jsx       # Website footer
│       ├── Hero.jsx         # Landing section
│       ├── Projects.jsx     # Projects showcase
│       └── Skills.jsx       # Skills presentation
├── data/
│   └── user_info.js         # Centralized data management
├── pages/
│   ├── 404.jsx             # Error page
│   └── Homepage.jsx        # Main page layout
└── App.jsx                 # Main application component

Key Components Breakdown

1. Hero Section
2. Education & Experience
3. Projects Showcase
4. Contact Section

Conclusion

Building this portfolio website was an excellent learning experience that reinforced the importance of modern web development practices. The combination of React, Vite, and Tailwind CSS proved to be a powerful stack for creating fast, maintainable, and visually appealing web applications.

The project successfully demonstrates proficiency in:

• Modern JavaScript frameworks
• Responsive web design
• User interface development
• Project organization and deployment
• Version control and collaboration tools

This portfolio serves not only as a showcase of my work but also as a testament to the skills acquired during my Web Development studies. The clean, professional design and smooth user experience reflect the attention to detail and technical competence that employers and clients value.

Getting Started

1. Clone the repository:
```bash
git clone https://github.com/adlanmuammarshiddiq/adlan-portofolio.git
```

2. Install dependencies:
```bash
npm install
```

3. Start the development server:
```bash
npm run dev
```

4. Open your browser and navigate to `http://localhost:5173`

1. CVS: Awal Mula Sistem Version Control

CVS (Concurrent Versions System) adalah salah satu sistem kontrol versi pertama yang digunakan secara luas, terutama pada tahun 1990-an. CVS bekerja dengan model centralized version control system (CVCS), artinya ada satu server pusat tempat seluruh versi kode disimpan, dan semua developer harus terhubung ke server tersebut untuk melakukan commit atau update.

Kelebihan CVS pada zamannya:

• Memungkinkan kolaborasi banyak developer secara bersamaan.
• Mendukung pencatatan perubahan (change history) untuk setiap file.
• Memiliki konsep tag dan branch dasar.

Namun, CVS memiliki banyak keterbatasan:

• Tidak mendukung perubahan atomic commit, sehingga satu commit bisa saja meninggalkan kode dalam kondisi setengah jalan.
• Branching dan merging sangat tidak efisien.
• Bergantung pada koneksi ke server pusat, sehingga menyulitkan developer yang bekerja secara offline.

Dengan keterbatasan ini, banyak komunitas open-source mulai beralih ke sistem yang lebih canggih.

2. Git: Sistem Kontrol Versi Modern

Git diperkenalkan oleh Linus Torvalds (pencipta Linux) pada tahun 2005. Berbeda dengan CVS, Git menggunakan model Distributed Version Control System (DVCS). Ini berarti setiap developer memiliki salinan lengkap dari repositori, termasuk seluruh histori perubahan.

Keunggulan utama Git dibanding CVS dan sistem lama lainnya:

• Distribusi penuh: Developer bisa bekerja secara offline dan melakukan commit lokal, baru melakukan push ke repositori pusat saat online.
• Kecepatan tinggi: Operasi seperti commit, diff, merge, dan branch jauh lebih cepat karena dilakukan secara lokal.
• Branching fleksibel dan ringan: Membuat dan berpindah branch sangat mudah dan cepat di Git.
• Integrity check: Git menggunakan SHA-1 checksum untuk memastikan integritas data.
• Open-source dan lintas platform: Didukung oleh hampir semua layanan pengembangan perangkat lunak saat ini (GitHub, GitLab, Bitbucket, dsb).

3. Gitflow: Alur Kerja Git yang Terstruktur

Untuk mengatasi tantangan pengelolaan kode dalam tim yang besar dan kompleks, muncullah konsep Gitflow, sebuah alur kerja (workflow) yang diusulkan oleh Vincent Driessen.

Gitflow memperkenalkan struktur cabang yang rapi dan jelas:

• main: branch utama yang selalu berisi kode stabil dan siap produksi.
• develop: tempat utama pengembangan fitur; semua fitur baru bercabang dari sini.
• feature/*: setiap fitur baru dikembangkan di cabang terpisah dari develop.
• release/*: digunakan untuk mempersiapkan rilis; di-merge ke main dan develop setelah selesai.
• hotfix/*: untuk perbaikan darurat terhadap rilis yang sudah di-deploy.

Manfaat Gitflow:

• Alur kerja terstruktur dan mudah diikuti dalam tim.
• Mencegah campur aduk antara fitur yang sedang dikembangkan dan kode produksi.
• Memudahkan rollback jika terjadi kesalahan.

Memahami sistem kontrol versi dan alur kerja seperti Git dan Gitflow adalah keterampilan fundamental bagi setiap developer modern. Di era kolaborasi global, remote working, dan open-source, kemampuan mengelola versi kode dengan benar tidak hanya membuat pekerjaan lebih rapi, tapi juga meningkatkan produktivitas dan kualitas perangkat lunak.

Bagi mahasiswa, startup, atau tim pengembangan profesional, menggunakan Git dengan alur kerja yang sesuai (misalnya Gitflow) adalah pondasi penting menuju pengembangan perangkat lunak yang berkelanjutan, aman, dan terorganisir.

In the dynamic world of React development, staying updated with the latest advancements is crucial. One such groundbreaking evolution is the introduction of React Hooks. Whether you’re a seasoned developer or just starting with React, understanding Hooks can significantly enhance your ability to write cleaner, more maintainable code.

What are React Hooks?

React Hooks are functions that allow you to use state and other React features in functional components without writing a class. Introduced in React 16.8, Hooks offer a more direct API to React’s features, previously only available in class components. They aim to simplify component logic and promote reuse of stateful logic across components.

Key Hooks Explained

useState

useState is the most commonly used Hook and replaces this.state in class components. It lets you add state to functional components:

import React, { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
}

useEffect performs side effects in functional components, such as data fetching, subscriptions, or manually changing the DOM:

import React, { useState, useEffect } from 'react';

function Example() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    document.title = `You clicked ${count} times`;
  }, [count]); // Only re-run the effect if count changes

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
}

Additional Hooks

useContext

useContext allows functional components to consume context that has been established by a Provider higher up in the component tree.

import React, { useContext } from 'react';
import ThemeContext from './ThemeContext';

function ThemedButton() {
  const theme = useContext(ThemeContext);

  return <button style={{ background: theme.background, color: theme.foreground }}>I am styled by theme context!</button>;
}

useRef

useRef gives you a way to keep mutable values around similar to instance properties on class instances.

import React, { useRef } from 'react';

function TextInputWithFocusButton() {
  const inputEl = useRef(null);
  const onButtonClick = () => {
    // `current` points to the mounted text input element
    inputEl.current.focus();
  };

  return (
    <>
      <input ref={inputEl} type="text" />
      <button onClick={onButtonClick}>Focus the input</button>
    </>
  );
}

Custom Hooks

Custom Hooks are a way to reuse stateful logic across different components. They are more of a convention than a feature, so there’s no functional difference between a custom Hook and a built-in Hook.

import { useState, useEffect } from 'react';

function useDocumentTitle(title) {
  useEffect(() => {
    document.title = title;
  }, [title]);
}

function Example() {
  const [count, setCount] = useState(0);

  useDocumentTitle(`You clicked ${count} times`);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
}

Benefits of React Hooks

• Simplicity: Hooks reduce the complexity of managing state and side effects compared to class components.
• Code Reuse: Encapsulate logic in custom Hooks for easy reuse across components.
• Performance Optimizations: Hooks optimize performance by allowing React to skip unnecessary re-renders.

React Hooks have transformed React development, offering a modern and efficient way to manage state and side effects in functional components. By embracing Hooks, developers can write cleaner, more maintainable code and enhance productivity. Start integrating Hooks into your projects today and experience the benefits firsthand!

Website yang statis bisa saja fungsional, tapi sering kali terasa hambar. Di era digital saat ini, animasi adalah kunci untuk menciptakan pengalaman pengguna yang menyenangkan. JavaScript memungkinkan kita menambahkan animasi yang dinamis, interaktif, dan responsif tanpa harus bergantung penuh pada CSS atau library berat.

Kenapa Harus Menggunakan Animasi di Website?

• Menarik perhatian user
• Meningkatkan UX (user experience)
• Menjelaskan alur proses (contoh: animasi loading, progress, atau transisi halaman)
• Memperkuat identitas visual brand

Jenis-Jenis Animasi di Website

• Scroll animation
• Hover animation
• Click / tap animation
• Page transition animation
• Micro-interaction

Mengenal JavaScript untuk Animasi

JavaScript bisa digunakan untuk membuat animasi dengan beberapa cara:

• Native JavaScript: requestAnimationFrame(), setInterval()
• CSS Manipulation via JavaScript
• Library seperti:

1. GSAP (GreenSock)
2. Anime.js
3. Three.js (untuk animasi 3D)
4. ScrollReveal, Locomotive Scroll
5. Framer Motion (React)

let box = document.getElementById("box");
let position = 0;

function moveBox() {
  position += 1;
  box.style.left = position + "px";
  
  if (position < 300) {
    requestAnimationFrame(moveBox);
  }
}

moveBox();

Library Paling Populer: GSAP & Anime.js

• Powerfull
• Cross-browser
• Animasi kompleks dan chaining mudah

gsap.to(".box", { duration: 2, x: 300, rotation: 360 });

anime({
  targets: '.letter',
  translateY: [-100, 0],
  delay: anime.stagger(100),
  easing: 'easeOutExpo'
});

Scroll Animation: Buat Website Terlihat Premium

Scroll animation membuat elemen muncul saat halaman di-scroll, menciptakan pengalaman yang sinematik.

ScrollReveal().reveal('.card', { 
  distance: '50px',
  duration: 1000,
  origin: 'bottom',
  interval: 200
});

Kesimpulan

Animasi bukan cuma “hiasan”, tapi bagian penting dari storytelling di web modern. Dengan JavaScript, kamu punya fleksibilitas besar untuk menghidupkan situs kamu. Gunakan animasi dengan bijak agar pengalaman pengguna tetap optimal dan menyenangkan.

Seorang web developer atau desainer harus membuat layout yang responsif — yakni tampilan yang dapat menyesuaikan diri secara otomatis dengan ukuran layar pengguna — karena pengguna internet saat ini mengakses website dari tablet dan smartphone dengan berbagai ukuran layar.

Dalam artikel ini, kita akan membahas cara menggunakan HTML5 dan CSS3 untuk membuat layout website responsif, khususnya dengan memanfaatkan Flexbox dan Media Query. Kami akan membuat layout sederhana yang terdiri dari:

• Header
• Navigasi (Nav)
• Main Konten
• Sidebar
• Footer

Tata letak ini akan tampak sejajar secara horizontal pada layar besar dan akan terakumulasi secara vertikal pada layar kecil. Dengan memanfaatkan CSS standar, kita dapat mencapai hasil ini tanpa perlu menjadi tergantung pada framework seperti Bootstrap atau TailwindCSS.

Berikut adalah struktur HTML dasar yang kita gunakan untuk membuat tampilan website sederhana yang responsif :

<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <title>Layout Responsif</title>
  <link rel="stylesheet" href="style.css" />
</head>
<body>
  <header class="header">Header</header>
  <nav class="nav">Navigation</nav>
  <main class="main">Main Content</main>
  <aside class="sidebar">Sidebar</aside>
  <footer class="footer">Footer</footer>
</body>
</html>

/* style.css */
* {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

body {
  display: flex;
  flex-wrap: wrap;
  font-family: sans-serif;
  min-height: 100vh;
}

.header, .footer {
  width: 100%;
  background-color: #3f51b5;
  color: white;
  padding: 20px;
  text-align: center;
}

.nav {
  flex: 1 1 200px;
  background-color: #f5f5f5;
  padding: 20px;
}

.main {
  flex: 2 1 400px;
  background-color: #e3f2fd;
  padding: 20px;
}

.sidebar {
  flex: 1 1 200px;
  background-color: #bbdefb;
  padding: 20px;
}

.footer {
  margin-top: auto;
}

Penjelasan :

• display: flex membuat seluruh <body> menjadi wadah fleksibel.
• flex-wrap: wrap memungkinkan elemen turun ke baris baru jika tidak muat dalam satu baris.
• Properti flex digunakan untuk mengatur lebar relatif antar elemen.
• width: 100% untuk header dan footer agar tetap memenuhi layar.
• Warna dan padding ditambahkan agar layout lebih jelas secara visual.

Responsif dengan Media Query :

@media (max-width: 768px) {
  body {
    flex-direction: column;
  }

  .nav, .main, .sidebar {
    width: 100%;
  }
}

Kesimpulan

Dengan menggabungkan Flexbox dan Media Query, kita bisa menciptakan desain website yang adaptif dan nyaman digunakan tanpa perlu mengandalkan framework yang besar. Mengetahui konsep ini secara mendalam akan sangat membantu saat memasuki dunia pengembangan frontend yang lebih rumit.

Selama ini JavaScript di terkenal sebagai bahasa dominan dalam pemrograman web. Namun, seiring dengan kemajuan teknologi, penggunaan JavaScript mulai merambah ke wilayah baru seperti Machine Learning (ML). Dulu, bahasa pemrograman Python dan R lebih banyak digunakan dalam pengolahan dan pemodelan machine learning. Akan tetapi, sekarang ini para web developer dapat dengan mudah mendankan model AI kedalam aplikasi berbasis browser dengan dihadirkannya berbagai perpustakaan ML berbasis javaScript tanpa perlu mengubah bahasa pemrograman.

Mengapa JavaScript untuk Machine Learning?

Sebelum melakukan langkah-langkah lebih dalam pada proses implementasi, ada baiknya kita melihat untuk apa JavaScript bisa dipilih menjadi kandidat yang menggiurkan untuk machine learning:

1. Bisa Dieksekusi Melalui Browser

Dengan JavaScript, sebuah model machine learning dapat berjalan secara langsung di dalam browser tanpa memerlukan backend server khusus.

2. Menjangkau Jangkauan Web

Dengan Anda yang merupakan seorang developer web menggunakan React, Angular, atau Vue.js, model ML dapat digabungkan tanpa harus beralih ke bahasa lainnya.

3. Memiliki Support Library Terkini

Berbagai model machine learning berbasis JavaScript pada umumnya sudah dan dapat digunakan untuk berbagai tugas oleh Google, Facebook, dan komunitas open-source.

Library Machine Learning Populer di JavaScript

1. TensorFlow.js

TensorFlow.js adalah versi JavaScript dari TensorFlow, framework ML paling populer yang dikembangkan oleh Google. Library ini memungkinkan kita untuk melatih dan menjalankan model ML langsung di browser atau Node.js.

import * as tf from '@tensorflow/tfjs';

const model = tf.sequential();
model.add(tf.layers.dense({ units: 10, inputShape: [2], activation: 'relu' }));
model.add(tf.layers.dense({ units: 1, activation: 'sigmoid' }));

model.compile({ optimizer: 'sgd', loss: 'meanSquaredError' });

2. Brain.js

Jika Anda ingin implementasi machine learning yang lebih sederhana, Brain.js bisa menjadi pilihan yang lebih ringan dibanding TensorFlow.js. Library ini sangat cocok untuk model sederhana seperti prediksi angka, klasifikasi teks, dan pengenalan pola.

const brain = require('brain.js');
const net = new brain.NeuralNetwork();

net.train([
  { input: [0, 0], output: [0] },
  { input: [0, 1], output: [1] },
  { input: [1, 0], output: [1] },
  { input: [1, 1], output: [0] }
]);

console.log(net.run([1, 0])); // Output: sekitar 1

3. ml5.js

Apabila Anda ingin lebih mudah menerapkan Machine Learning di JavaScript, Anda dapat menggunakan ml5.js. Library ini dibangun di atas TensorFlow.js tetapi memiliki level abstraksi yang lebih tinggi.

Contoh implementasi (Image Classification dengan ml5.js):

const classifier = ml5.imageClassifier('MobileNet', modelReady);

function modelReady() {
  classifier.classify(document.getElementById('myImage'), (err, results) => {
    console.log(results);
  });
}

Implementasi Machine Learning di Browser dengan TensorFlow.js

import * as tf from '@tensorflow/tfjs';

async function loadModel() {
  const model = await tf.loadLayersModel('https://path-to-your-model/model.json');
  return model;
}

const model = loadModel();

async function predict(imageData) {
  const tensor = tf.browser.fromPixels(imageData).resizeNearestNeighbor([28, 28]).toFloat().expandDims();
  const prediction = model.predict(tensor);
  console.log("Prediksi: ", prediction.argMax(1).dataSync());
}

Kode ini akan mengambil gambar yang diberikan, mengubahnya menjadi tensor, dan memprediksi angka yang ada dalam gambar menggunakan model yang dilatih sebelumnya.

In the realm of business management, personnel managers and HR personnel grapple with many challenges. One of the most pressing issues among them is attrition, which is a very important issue. For organizations committed to fostering a stable and engaged workforce, it is imperative to understand attrition rates and the underlying drivers of employee turnover.

Therefore, the main objective of this study was to use HR Analytics techniques to detect and investigate individual-related trends that are closely associated with attrition. Through careful examination of the data, we sought to uncover the complex elements associated with attrition rates. These elements cover a wide range of aspects, including employee demographics, performance metrics, job satisfaction levels, and potential indicators of voluntary exit.

This comprehensive analysis is aimed at providing invaluable insights to organizations. These insights empower them to proactively address attrition challenges and implement targeted strategies to reduce employee turnover. By leveraging HR Analytics to uncover trends in the field of human resource management regarding attrition rates and related factors, organizations can strive to achieve better employee retention, increased productivity, and continued success in the business arena.

To solve a problem statement above we will do several stages are :

1. Load Dataset
2. Data Cleaning
3. EDA & Data Visualization
4. Machine Learning Model

We will start the discussion by starting from Load dataset and data understanding with the aim of understanding more about the data sets we have.

Load Dataset

data=pd.read_csv("https://raw.githubusercontent.com/triangle836/DB61_Python_final_term_project/main/HR-Employee-Attrition.csv")
print(f"Shape of the dataset: {data.shape}")

Shape of the dataset: (1470, 35)

Dataset Description

About the Data

This dataset was discovered on Kaggle and is openly accessible. There are 35 variables and 1,470 employee records. On the internet, projects involving HR analytics are fairly common with this data collection. The purpose of this data collection is to develop a model to forecast employees who are likely to quit based on the information about these 1,470 employees and the following characteristics:

• Age : Age in years of the employee
• Attrition: People who people leave
• BusinessTravel : How often an employee embark on a job related travel
• DailyRate : Daily rate at which an employee is paid
• Department : Department where the employee works
• DistanceFromHome : Distance an employee travels from home to work
• Education : Level of education of the employee
• EducationField : What field the employee studied in school
• EmployeeCount : Count of employee
• EmployeeNumber : EMployee number
• EnvironmentSatisfaction : Employee environment satisfaction
• Gender : Gender of the employee
• HourlyRate : Hourly rate of pay of the employee
• JobInvolvement : Employee job involvement ratings
• JobLevel : Employee Job level
• JobRole : Employee Job role
• JobSatisfaction : Employee Job Staisfaction
• MaritalStatus : Employee Marital Status
• MonthlyIncome : Employee monthly income
• MonthlyRate : Employee Monthly rate
• NumCompaniesWorked : Number of companies the person have worked in the past
• Over18 : Age over 18 years or not
• OverTime : Work overtime
• PercentSalaryHike : Salary increment in Percentages
• PerformanceRating : Performance rating
• RelationshipSatisfaction : Relationship satisfaction
• StandardHours : Employee standard hours worked
• StockOptionLevel Stock options level
• TotalWorkingYears Total working hours
• TrainingTimesLastYear : Total working years
• WorkLifeBalance : Work life balance rating
• YearsAtCompany : Years at the company
• YearsInCurrentRole : Years in current role
• YearsSinceLastPromotion : Years since last promotion
• YearsWithCurrManager : Years with current manager

After we do the data understanding or data load stage, we will do the data cleaning stage itself in order to provide accurate statistical analysis results as well as for machine learning modeling.

Data Cleaning

There are several stages of data cleaning that we do :

Basic Data Discovery

Check missing values and Dropping unnecessary columns

Data is cleaned and have no missing value.
Since the number of columns are overwhelming, it is plausible to retain the most crucial valuesets in relation to our analytical purposes.

• “employee_count”, “over18” and “standard_hours” columns consist of 1 value only for all entries, so they can be omitted.
• “employee_number” is employee ID, which is unique for each entry, so it can also be omitted as it provides no characteristic of the employee
• “performance_rating” consists of merely 2 values (3 and 4), suggesting its appreciable value in this analytical process.

# Drop some column
data.drop(['employee_count','employee_number','standard_hours','over18','performance_rating'],
            axis=1,inplace=True
            )

Removing Outliers

There are outliers in some columns, but either the number of outliers is small (\<5\%) or the outliers values are in realistic, reasonable range. Except for monthly_income column.

# Removing Outliers
drop_outlier_col = ['monthly_income']

for col in drop_outlier_col:
    Q1 = data[col].quantile(0.25)
    Q3 = data[col].quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR

    new_df = data[(data[col]>=lower_bound)&(data[col]<=upper_bound)]

new_df = new_df.reset_index(drop=True)
print(f"Shape of the dataset after cleanning: {new_df.shape}")

Shape of the dataset after cleanning: (1356, 30)

EDA & Data Visualization

After we do the data cleaning stage, we will do Explorarity Data Analysis and Data Visualization to better understand and analyze the problems of the datasets we have.

Heatmap Correlations

cols = ['total_working_years','years_at_company','years_in_current_role','years_since_last_promotion','attrition','job_level']
sns.pairplot(new_df[cols], hue='attrition')

Feature Analysis

• Gender Distribution

• Age Ditribution

• attrition vs density

• It can be seen that 60% of the research population is male, against 40% females.
• Both groups have the same distribution in age, ranging from 18–60.The rate of attrition between male and female employees stays roughly the same at 15%.This prove the data is not bias.

Correlation Carrier Background

As the graph and correlation heatmap suggest, the employee’s total working years closely correlated to the number of years working at the current company and position. There is little to no difference between male and female counterparts.

Monthly Income Correlation

• It can be inferred that there is a linear correlation between monthly income to total working years and years worked at the company, but only from 0–20 years.
• Income jumps up at the mark of 20 working years or more and fluctuate volatilely from then on.
• However, the data prove that the more one works in 1 role, the more they would earn monthly.

Attrition Univariate Analysis — Correlation

It is noticeable that the age range of 25 to 35 stands out with the most remarkable attrition rate, indicating a higher tendency of voluntary exits among all brackets. Conversely, from around 40 onwards, a downtrend was recorded, suggesting a reduced likelihood for departures. Similarly, a declining trend manifests itself starkly from the age of 25 downwards, which can most likely attributed to the probation period or introductory time span for the company.

ATTRITION — MARITAL STATUS

The employee marital status is split between Married, Single and Divorced. There is no clear trend that marital status affect attrition.

ATTATTRITION — WORKPLACE ELEMENTS

The attrition rate is consistant between departments, staying around the 80–85\% level.

The attrition rate is specifically lower for the following positions: Research and Manufacturing Directors, Managers, HR and Healthcare representatives.

From the chart, there is no evidence of job satisfaction affect attrition, which is surprising.

It can be seen that the attrition rate is higher for employees who are paid lower, from $2000 to $4000.

The majority of employees stay within 10km of their workplace. However, there is no evidence supporting that attrition rate is higher for people living far from work. This can be seen from the following graph.

From the chart, there is no difference in attrition rate between most of the levels of Enviroment satisfaction, apart from that of the lowest level, whose proportion almost doubles that of others

Machine Learning Model

After we do EDA and Data Visualization, we will continue to the last stage, namely the Machine Learning Modeling stage.

Feature Engineering

• Encode Non-Numeric Variables

# Encoding
le = LabelEncoder()

for i in df1.columns:
    if df1[i].dtype == 'object':
        df1[i] = le.fit_transform(df1[i])

• Standardize Numeric Variables

# Scaling
scaler = StandardScaler()
scaler.fit(df1.drop('attrition',axis=1))

• Create train and test splits

X = df1_feat
y = df1['attrition']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

Model 1 : Random Forest

• Model Building & Feature Importance Analysis

model = RandomForestClassifier(max_features='sqrt', n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test)[:,1]
print(f"Accuracy Score: {accuracy_score(y_test, y_pred)}")
print(f"ROC AUC Score: {roc_auc_score(y_test, y_pred_proba)}")

feature_importance = pd.DataFrame({'Feature': X.columns, 'Importance': model.feature_importances_})
feature_importance.sort_values(by='Importance', ascending=False, inplace=True)
feature_importance.reset_index(drop=True, inplace=True)
feature_importance

plt.figure(figsize=(10, 5))
fig = px.line(x=feature_importance['Feature'], y=feature_importance['Importance'], markers="o",title="Feature Importance",template="plotly_dark",color_discrete_sequence=['pink'])
fig.update_layout(
    xaxis_title="Feature",
    yaxis_title="Importance",
    font={"family":"Arial", "size":12})

fig.update_xaxes(tickangle=60)

fig.show()

Accuracy Score: 0.8427518427518428
ROC AUC Score: 0.7882712944332663

Overall, a great number of features have direct yet insignificant influence on the risk of voluntary departure. Most noticeable correlation coefficients range any where below 0.1, with monthly_income taking the lead.

• Model Evaluation

Having a closer look at the ROC AUC index, we can notice the pronounced pattern of trade-off between TPR and FPR at different thresholds of testing, all of which accrue up to a whopping 0.8 in aggregate area.

Model 2 : Logistic Regression

• Encoding Non-Numeric Features

# Encoding
def dummies(df):
 list=[]
 for col in df.select_dtypes(exclude=np.number).columns:
  dummy = pd.get_dummies(df[col],prefix=col,drop_first=True)
  list.append(dummy)

 df=df.drop([i for i in df.select_dtypes(exclude=np.number).columns],axis=1)

 for dummy_df in list:
  df=pd.concat([df,dummy_df],axis=1)
 return df

• Standardizing Numeric Variables

# Scaler 
scaler = StandardScaler()

# Fitting
scaler.fit(df2.drop('attrition_Yes',axis=1))

scaled_features_df2 = scaler.transform(df2.drop('attrition_Yes',axis=1))

• Train Test Split

X_train, X_test, y_train, y_test = train_test_split(df2_feat,df2['attrition_Yes'], test_size=0.3,random_state=101)

• Training And Predicting

logmodel = LogisticRegression()
logmodel.fit(X_train,y_train)

• Analysing Feature Importance

feature_importance = logmodel.coef_[0]

feature_names = X_train.columns

importance_df = pd.DataFrame({'Feature': feature_names, 'Coefficient': feature_importance})

importance_df = importance_df.reindex(importance_df['Coefficient'].abs().sort_values(ascending=False).index).reset_index(drop=True)

import plotly.express as px

fig = px.bar(
    importance_df,
    x='Coefficient',
    y='Feature',
    orientation='h',
    title='Feature Coefficients in Logistic Regression',
    #template='plotly_dark'
)

fig.show()

• Model Evaluation

Conclusion and Recommendations

Conclusion

Recommendations

Living in the dynamic era of digital advancements, the integration of machine learning technology presents an exciting avenue for uncovering concealed insights within datasets. Among the intriguing applications is the capacity to forecast an individual’s gender by analyzing distinctive facial features. This discourse aims to delve into the profound realms of gender classification using machine learning, specifically focusing on the utilization of Decision Trees.

Through the application of machine learning techniques, we can construct classification models proficient in predicting gender (Male/Female) based on the intricate features discernible on an individual’s face.

What is a decision tree and how does it work??

A decision tree is a predictive model in machine learning that is used to perform classification and regression. The model is similar to a tree structure, where each node in the tree represents a decision or test on a particular feature, and each branch of the node represents the outcome of the decision or test. Basically, Decision Tree helps in decision making in a hierarchical manner.

Structure of a Decision Tree:

• Root: A representation of the entire dataset or a particular subset to be broken down.
• Decision Node: Represents testing on a particular attribute/feature. Based on the results of this test, the data is split to the appropriate child nodes.
• Leaf Node: Represents the predicted result or the given class after performing a series of decisions.

Basic Formula for Choosing the Best Feature on a Testing Node:

The Decision Tree algorithm uses methods to select the best features to split at each test node. One commonly used method is “Gini Impurity” for classification. The Gini Impurity formula for a node is as follows:

• c is the number of classes/targets
• pi is the proportion of samples from class
• i at that node.

Some steps that can be taken to use this dataset for machine learning with a decision tree approach are:

1. Data Understanding
2. Explorarity Data Analysis (EDA)
3. Data Analysis
4. Modeling

To better understand gender classification with machine learning, we will do the modeling stage starting with the data understanding.

Data Understanding

Before we go any further we need to understand the data we have to get an initial understanding of the data needed to solve the given problem.

This dataset contains 7 features and a label column.

• long_hair : This column contains 0’s and 1’s where 1 is “long hair” and 0 is “not long hair”.
• forehead_width_cm : This column is in CM’s. This is the width of the forehead.
• forehead_height_cm : This is the height of the forehead and it’s in Cm’s.
• nose_wide : This column contains 0’s and 1’s where 1 is “wide nose” and 0 is “not wide nose”.
• nose_long : This column contains 0’s and 1’s where 1 is “Long nose” and 0 is “not long nose”.
• lips_thin : This column contains 0’s and 1’s where 1 represents the “thin lips” while 0 is “Not thin lips”.
• distance_nose_to_lip_long : This column contains 0’s and 1’s where 1 represents the “long distance between nose and lips” while 0 is “short distance between nose and lips”.
• gender : This is either “Male” or “Female”.

We will display the first 5 rows the data set

#Load Dataset
df = pd.read_csv('gender_classification_v7.csv')
df.head()

# Checking Unique Value
listItem = []
for col in df.columns :
    listItem.append( [col, df[col].nunique(), df[col].unique()])

unique_values = pd.DataFrame(columns=['Column Name', 'Number of Unique', 'Unique Sample'], data=listItem)
unique_values

# concise summary of dataframe
df.info()

• Our data set has 6 categorical columns: long_hair,nose_wide,nose_long,lips_thin,distance_nose_to_lip_long,
  gender.
• And it has 2 numerical columns: forehead_width_cm, forehead_height_cm.
• For categorical columns other than gender, they only have unique values, namely 1 and 0.

Explorarity Data Analysis (EDA)

# proportion of male and female in our target column
df['gender'].plot(kind='hist', title='proportion of Male and Female')
df['gender'].value_counts()

Our data set has a balanced proportion therefore we do not need to use a resampler.

Correlation

# heatmap correlation
plt.figure(figsize=(15,10))
sns.heatmap(df.corr('spearman',numeric_only=True), annot=True,linewidths=0.5, cmap="Reds")

# Getting Mean Columns with gender

m_col=['long_hair','forehead_width_cm','forehead_height_cm','nose_wide',
       'nose_long','lips_thin','distance_nose_to_lip_long','gender']

# Pairplot for mean columns
sns.pairplot(df[m_col],hue='gender',palette='Blues')

Data Cleaning

# Checking Duplicate and Missing Value
display(df.duplicated().sum())
display(df.isna().sum())

1768

long_hair                    0
forehead_width_cm            0
forehead_height_cm           0
nose_wide                    0
nose_long                    0
lips_thin                    0
distance_nose_to_lip_long    0
gender                       0
dtype: int64

# Drop Duplicate Value
df = df.drop_duplicated()

Data Analysis

Numerical vs Target

plt.figure(figsize=(8, 6))
plotnumber = 1
for feature in numerical_features:
    ax = plt.subplot(2, 2, plotnumber)
    sns.barplot(x = 'gender', y = feature, data = df, estimator=np.median, errorbar=('ci', 0),palette='rocket')
    plt.ylabel(feature)
    ax.bar_label(ax.containers[0], padding= -20, size=8)  
    plotnumber += 1
    plt.tight_layout()


plt.show()

From the barplot diagram above we get the information that :

• On average, the forehead width of a woman is larger than that of a man.
• The average forehead height of a man tends to be smaller than that of a woman.

Categorical vs Target

categorical_features = df[['long_hair','nose_wide','nose_long','lips_thin','distance_nose_to_lip_long']]

plotnumber = 1
fig, axes = plt.subplots(2, 3, figsize=(16, 9))

sns.set_palette("rocket")

for feature, ax in zip(categorical_features[:-1], axes.flatten()):
    pd.crosstab(df[feature], df['gender'], normalize='index').plot(kind='bar', stacked=True, ax=ax)
    ax.set_title(f'{feature}', size=12)
    ax.set_xticklabels(ax.get_xticklabels(), rotation=0)
    ax.legend(loc='upper right', prop={'size': 12}, title='gender')

plt.tight_layout()
plt.show()

From the results of the above analysis :

• The average hair length of women and men has the same value.
• Men tend to have a larger nose width.
• The average male has a longer nose length
• Women tend to have thicker lips than men.
• Men have a longer distance between lips and nose than women.

Modeling

# Define Features and Target
# Features
X = df.drop(columns='gender')

# Target
y = df['gender']

# Data Splitting
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2, random_state = 0,stratify=y)

# Decission tree Params
clf_ent = DecisionTreeClassifier(criterion = "gini",random_state = 100,max_depth=3, min_samples_leaf=5,min_samples_split=5)

# Fitting to train set
clf_ent.fit(X_train,y_train)

# Predict to Test Set
y_pred = clf_ent.predict(X_test)

accuracy_score(y_test, y_pred)*100

95.05409582689336

Plot Tree

From the plot tree above, it can be concluded that :

• If a person has lips_thin ≤ 0.5 then it will enter the Male class group for the first level.
• If a person has nose_long ≤ 0.5, it will be classified as female for the first level.
• A person who has forehead_height_cm ≤ 6.55 will be classified as male.

Model Limitation

1. This model is only valid when the features/columns of long_hair,nose_wide,nose_long,lips_thin,distance_nose_to_lip_long are only 1 and 0.
2. The valid range for the forehead_width_cm column is in the range of 11.4–15.5.
3. And this model is said to be valid when the forehead_height_cm feature is in the range of 5.1–7.1

Conclusion and Recommendations

Conclusion

From the resulting decision tree plot, we can extract important insights into how the model decides on gender classes. The decision starts by considering key features such as lips_thin, nose_long, and forehead_height_cm. Hierarchically, the model effectively sorts the dataset and produces accurate classification decisions.From our data set we were able to get a very good accuracy score of 95% with the decision tree approach.

Recommendations

• Can add other features such as height or weight
• For features that have column values of 1 and 0, it can be converted into cm units so that the results are not biased because long or short, or thick or thin are relative because basically humans have various races of tribes that have different physical characteristics.
• We can also try to do hyperparameter tuning to make better accuracy results.

In the digital age, data has become one of the most valuable assets for individuals and companies. Data can be used for a variety of purposes, whether for making business decisions or solving a problem. However, in order to make the most of data, data visualization is needed.

Data visualization is the process of transforming data into a visual format that is easy to understand. This can be done using a variety of charts, graphs, maps, and dashboards. Effective data visualization can help us to see trends, patterns, and relationships in data.

Power BI is one of the most popular data visualization platforms available today. Power BI offers a variety of features that make it easy for us to create interactive, engaging, and informative data visualizations.

In this article, we will talk about the following topics:

• Advantages and disadvantages of Microsoft Power BI
• Exploring POWER BI Architecture
• Features in POWER BI

Why Microsoft PowerBI ?? 😕

Advantages of Microsoft Power BI

Let’s discuss some of the most important advantages of Power BI that play a significant role in making Power BI a successful tool 👌:

1. Access to Volumes of Data from Multiple Sources

Power BI can access vast volumes of data from multiple sources. It allows you to view, analyze, and visualize vast quantities of data that cannot be opened in Excel. Some of the important data sources available for Power BI are Excel, CSV, XML, JSON, pdf, etc.

2. User-friendly interface.

Power BI offers various specialized visualizations, which are visualizations created by developers for specific use. Specialized visuals are available on the Microsoft marketplace. Apart from the collection of common visualizations available, you can use Power BI custom visualizations in your reports and dashboards. The range of specialized visualizations includes KPIs, maps, charts, graphs,etc.

3. Excel Integration

In Power BI, you also have the option to upload and display your data in Excel. You can select/filter/slice data in a Power BI report or dashboard and place it in Excel. You can then open Excel and view the same data in table form on an Excel worksheet. In other words, the Excel integration capability in Power BI helps users view and work with the raw data behind Power BI visualizations.

4. Shared Datasets

Power BI partners and other trusted organizations can publish their cleaned, transformed, and verified datasets after ingesting and shaping them with Power BI. This acts as a trusted source of data with which other designers can get started away easily for their content. If the source data is updated, it updates the dashboards and apps of the designers connected to and using those datasets

Disadvantages of Microsoft Power BI

Next, Let’s discuss some of the disadvantages of Power BI :

1. Handling Large Data Volumes

Power BI indeed has a data ingestion limitation of approximately 2 GB of data at a time. If you aim to import and work with larger volumes of data, upgrading from the free version to a paid Power BI version is necessary. Additionally, users have reported that Power BI might take longer than usual or even pause when processing millions of rows and columns of data.

2. Visual Configuration

In most cases, you might not feel the need to configure and optimize visualizations in Power BI. However, even if you do, Power BI doesn’t provide many options for configuring visualizations according to your needs. Therefore, users have limited choices about what they can modify in visuals.

3. Data Quality

Microsoft Power BI does not provide any data cleansing solutions. This means it assumes that the data you retrieve has been cleaned beforehand and is of high quality. So, if you require data cleansing capabilities, you might need to look for an alternative solution to clean your data.

After learning about the strengths and weaknesses of Microsoft Power BI, before delving deeper into Microsoft Power BI, we need to understand the workflow of how the tool operates. Therefore, we will continue the discussion in the next point, Power BI Architecture :

POWER BI Architecture

1. Data ingestion

Data ingestion is the process of collecting data from various sources and loading it into Power BI. Data can come from various types of sources, such as Excel files, JSON, XML, and databases (SQL, Azure, Google BigQuery, etc). Power BI provides a wide range of connectors to facilitate the data ingestion process.

2. Data Preparation

Data preparation is the process of cleaning, transforming, and modeling data so that it is ready for analysis. This process is crucial to ensure that the data maintains a high level of accuracy, making the final analysis results reliable and suitable for making informed business decisions.

Power BI offers a variety of tools to aid in the data preparation process, such as Power Query and DAX. Power Query is a tool used to extract, transform, and load data from various sources. DAX is a programming language used to create formulas and functions for manipulating data.

3. Data Warehouse

Data Warehouse is a centralized storage space for integrated data from various sources. The data warehouse streamlines the data analysis process as data from diverse sources has been structured and standardized. Power BI can connect to various data warehouses such as Azure SQL Database, Amazon Redshift, and Google BigQuery.

4. Data Visualization and Analysist

Data visualization is the process of presenting data in the form of charts, graphs, and maps to make it more comprehensible. Power BI provides a variety of tools to create compelling and interactive data visualizations. Data analysis is the process of extracting information from data to uncover patterns and trends. Power BI offers various tools for data analysis, such as filters, slicers, and drill-down functionalities.

Additionally, here are examples of some visualizations available in Power BI :

• Charts are the most commonly used visualizations. They can display numerical or categorical data
• Graphs are visualizations used to represent numerical data in graphical form.
• Maps are visualizations used to display geographic data.
• Tables are visualizations used to display data in tabular form.
• PivotTables are visualizations used for data analysis in pivot table format.

Power BI also provides various specialized visualizations for specific data types, such as:

• Area chart to display data that changes over time.
• Bar and column charts to compare data from two or more groups.
• Combo chart to combine two or more visualization types.
• Donut chart to display proportions of a whole.
• Funnel chart to track data flow through a process.
• Gauge chart to display a single numerical data.
• KPI (Key Performance Indicator) to display key performance indicators.

5. Data Publish

Once the data has been visualized and analyzed, it can be published to Power BI Service, allowing access and sharing with others. Power BI Service also offers various features to manage and secure data, such as role-based access control and auditing

Data from various sources is ingested into Power BI Desktop, where the data can be prepared and modeled. Once the data is ready, it can be published to Power BI Service for access and sharing with others. Users can utilize Power BI Desktop or Power BI Service to create data visualizations and perform data analysis.

Features in Microsoft Power BI

After understanding the Microsoft Power BI workflow, we will continue to discuss the next topic, namely various features that are often used in Microsoft Power BI.

Extract Insights from large datasets [varies by version]

Excel worksheets come with a standard limit of 1,048,576 rows. Although performance in Excel will slow down well before that row limit, it is a common requirement for users to analyze datasets larger than one million rows. Power BI compresses your data so you can extract insights from large data sets. With a well-built data model, Power BI can help you analyze data sets containing more than 100 million rows.

Power BI also offers useful features for working with very large data sets of more than several hundred million rows. For example, users can set up aggregation tables in Power BI. Aggregation leverages pre-computed data to speed up queries, reducing the time it takes to render your reports.

Create custom visualizations with R and Python (available in all versions)

While Power BI supports many standard data visualizations out of the box, it’s also possible to build your own with custom data visualizations. By adding open-source data-viz libraries from R and Python, analysts can create highly customizable visualizations to add to their next Power BI report.

Analyze your datasets in Excel (Pro or Premium only)

The challenge for BI analysts has been how to offer this flexibility in a way that maintains the integrity of the connected reporting environment.

With that in mind, Microsoft released Analyze in Excel. Excel can connect directly to your underlying Power BI data, so users can do their own tabular and ad-hoc reporting. If you’re comfortable creating PivotTables in Excel, you can use this familiar experience to slice and dice your data, referencing the same datasets used in other Power BI reports.

Finally, users can get the latest data from Power BI datasets by refreshing their Excel connections. This ease of access is a game-changer for organizations stuck between the two platforms.

Automatic data refreshes (Pro or Premium only)

Power BI’s scheduled refresh feature automates the process of refreshing your datasets, freeing you from tedious, manual report updates. By quickly and accurately refreshing your data, insights can be easily surfaced and shared amongst your team.

Power BI Mobile App (available in all versions)

Power BI offers a feature-rich set of apps for iOS, Android, and Windows 10 mobile devices. Users can view mobile-optimized reports, share insights with colleagues, and set alerts within the mobile apps.

Conclusion

From our previous discussions, it can be concluded that Microsoft Power BI is a Business Intelligence tool that excels in analyzing and visualizing data. In this regard, Microsoft Power BI stands as a highly valuable tool for a Data Analyst in effectively visualizing and analyzing data.

There are several strengths in Microsoft Power BI, such as its capability to access volumes of data from multiple sources, a user-friendly interface, and more. However, users should also consider its drawbacks, including limitations in handling large volumes of data, some features accessible only through paid versions, and others.

CRUD stands for Create, Read, Update, and Delete processes, which are utilized to manage data within a data processing system or application. To ensure effective data management within the application we create, it is crucial to select the appropriate collection data type. Choosing the right collection data type can significantly enhance application performance, efficiency, and security.

The collection data type itself is a data type used to store a group of data. In Python, there are four primary types of collection data types:

1. List []
2. Tuple ()
3. Set {}
4. Dictionary {key: value}

Each collection data type possesses distinct characteristics and applications. In this article, I will explore the four types of collection data types present in Python programming, providing a comparative analysis and describing the advantages and disadvantages of each type for CRUD applications.

The Python programming language offers a variety of collection data types designed for storing and managing collections of data. Collection Data Types are typically utilized for storing both small and large amounts of data, allowing us to perform operations on this data.

Types of Collection Data Types in Python

Here are some types of collection data types available in Python:

1. List is a collection data type that can store heterogeneous data, meaning data with different data types. Lists are denoted by square brackets [].

# List Syntax in Phyton
my_list = [1, "Alice", 25]

2. Tuple is a collection data type similar to a list, but its data cannot be changed. Tuples are denoted by parentheses ().

# Tuple Syntax in Phyton
my_tuple = (1, "Alice", 25)

3. Set is a collection data type that only stores unique data. Sets are denoted by curly braces {}.

# Set Syntax in Phyton
my_set = {1, "Alice", 25}

4. Dict (Dictionary) is a collection data type that stores data in the form of key-value pairs. Dictionaries are also denoted by curly braces {}.

# Dictionary Syntax in Phyton
my_dict = {
    "id": 1,
    "name": "Alice",
    "age": 25,
}

Characteristics and Usage of Collection Data Types

List[]

Characteristics :
- Heterogeneous data,
- Data can be changed
Usage:
- Storing a list of data,
- Perform operations on data, such as searching, sorting, and merging

Tuple()

Characteristics:
- Heterogeneous data
- Immutable data
Use Cases:
- Storing a collection of data that will not change
-Use Performing operations on data, such as searching and sorting

Set{}

Characteristics:
- Unique data
- Immutable data
Use Cases:
- Storing a unique collection of data
- Performing operations on data, such as searching and sorting

Dictionary{key : values}

Characteristics:
- Data in the form of key-value pairs
- Mutable data
Use Cases:
- Storing a collection of data with key-value pairs
- Performing operations on data, such as searching, sorting, and merging

Comparison of Invocation Speed Among the 4 Collection Data Types

Here is a comparison of invocation speed among the 4 collection data types using the ‘import time’ module:

import time

def create_list(data):
    start = time.time()
    my_list = [i for i in data]
    end = time.time()
    return end - start

def create_tuple(data):
    start = time.time()
    my_tuple = tuple(data)
    end = time.time()
    return end - start

def create_set(data):
    start = time.time()
    my_set = set(data)
    end = time.time()
    return end - start

def create_dict(data):
    start = time.time()
    my_dict = {i: i for i in data}
    end = time.time()
    return end - start

data = list(range(100000))

print("Membuat list:", create_list(data))
print("Membuat tuple:", create_tuple(data))
print("Membuat set:", create_set(data))
print("Membuat dict:", create_dict(data))

Output :

Membuat list: 0.009367942810058594
Membuat tuple: 0.0005419254302978516
Membuat set: 0.0
Membuat dict: 0.01611042022705078

From the above output, it can be seen that a set is the fastest collection data type to create, followed by a tuple, list, and dictionary.

The Differences in Applying Collection Data Types for CRUD Applications in Python

1. List is a good choice for storing mutable data, such as a list of products in a store or a list of customer orders. Lists can be accessed randomly, making it easy to add, remove, or update data.
2. Tuple is a good choice for storing immutable data, such as configuration data or historical data. Tuples cannot be changed, ensuring data consistency.
3. Set is a good choice for storing unique data, like a list of usernames or product categories. Sets cannot have duplicates, making them suitable for quickly filtering data.
4. Dictionary is a good choice for storing related data, such as customer data or product data. Dictionaries use keys to access data, making them suitable for fast data retrieval.

Here is a simple CRUD program using the 4 collection data types:

List for CRUD

# Create Using List
products = []
products.append({"id": 1, "name": "Product 1", "price": 100})
products.append({"id": 2, "name": "Product 2", "price": 200})
products.append({"id": 3, "name": "Product 3", "price": 300})

# Read Using List
for product in products:
    print(product)

# Delete Using List
products.remove({"id": 2})

# Update Using
products[0]["price"] = 150

# Print Updated Products
for product in products:
    print(product)

Output :

{'id': 1, 'name': 'Product 1', 'price': 100}
{'id': 3, 'name': 'Product 3', 'price': 300}
{'id': 1, 'name': 'Product 1', 'price': 150}

Tuple for CRUD

# Create Using Tuple
configuration = ("production", "database", "localhost")

# Read Using Tuple
print(configuration)

# Update Using Tuple
configuration = ("development", "database", "127.0.0.1")

# Print updated configuration
print(configuration)

Output :

('production', 'database', 'localhost')
('development', 'database', '127.0.0.1')

Set for CRUD

# Create Using Set
users = {"johndoe", "janedoe", "marysmith"}

# Read Using Set
print(users)

# Add
users.add("peterjones")

# Remove
users.remove("johndoe")

# Print updated users
print(users)

Output :

{'johndoe', 'janedoe', 'marysmith'}
{'janedoe', 'marysmith', 'peterjones'}

Dictionary for CRUD

# Create Using Dictionary
customers = {
    "johndoe": {"id": 1, "name": "John Doe", "email": "johndoe@example.com"},
    "janedoe": {"id": 2, "name": "Jane Doe", "email": "janedoe@example.com"},
    "marysmith": {"id": 3, "name": "Mary Smith", "email": "marysmith@example.com"},
}

# Read Using Dictionary
customer = customers["johndoe"]
print(customer)

# Add
customers["peterjones"] = {"id": 4, "name": "Peter Jones", "email": "peterjones@example.com"}

# Update Using Dictionary
customers["johndoe"]["email"] = "johndoe@newdomain.com"

# Print updated customers
print(customers)

Output :

{'id': 1, 'name': 'John Doe', 'email': 'johndoe@example.com'}
{'id': 1, 'name': 'John Doe', 'email': 'johndoe@newdomain.com',
 'id': 2, 'name': 'Jane Doe', 'email': 'janedoe@example.com',
 'id': 3, 'name': 'Mary Smith', 'email': 'marysmith@example.com',
 'id': 4, 'name': 'Peter Jones', 'email': 'peterjones@example.com'}

Conclusion

Collection data types in Python are vital for managing data efficiently. For CRUD tasks, sets are the quickest to create, while list and tuple are easy to use. Reading data is versatile across list, tuple, set, and dictionary. List and dictionary are ideal for updates, and data deletion can be done using list, tuple, or set. In terms of creation speed, sets rank highest, followed by dictionary, list, and tuple. Understanding these data types and CRUD operations facilitates efficient Python programming, with import time helping choose the right data type.

Explanation:

• Effectiveness refers to the ability of collection data types to meet the needs of an application.
• Speed refers to the time it takes to perform CRUD operations on collection data types.
• Application in CRUD refers to the collection data types’ capability to be used for various CRUD features.