Learning Python from Scratch

Python as a programming Language, and not Python as a snake

My First Week as a Data Science Intern: Getting Started with Python

Week 1 of my Data Science Internship at DataraFlow

Starting a new role always comes with a mixture of excitement, curiosity, and a little uncertainty.

For me, becoming a Data Science Intern at DataraFlow was no different.

I knew I would be working with data, Python, machine learning, and other tools as the internship progressed. But before getting anywhere near machine learning models or complex datasets, I had to start with something much more fundamental:

Python.

My first week was focused on understanding the basics of Python and becoming more comfortable with writing code.

At first, some of the concepts looked very simple. Variables. Strings. Numbers. Lists. Conditions. Loops. Functions.

But one thing I quickly realized is that “simple” does not necessarily mean “unimportant.”

These basic concepts are the building blocks for almost everything that comes later in data science.

So, rather than rushing through them, I decided to pay attention to how each concept works and, more importantly, how I could use it to solve small problems.

This is a reflection on what I learned during my first week.

Why Python?

Before this internship, I had already come across Python several times in my learning journey.

I knew it was widely used in data science and machine learning, but learning Python specifically for data science made me look at the language differently.

Python is a general-purpose programming language, which means it can be used for many different kinds of tasks. It is also known for its relatively readable syntax, which makes it a popular starting point for people learning programming.

For someone interested in data science, Python becomes even more important because it provides the foundation for working with data and eventually using tools and libraries for analysis, visualization, and machine learning.

But there was no shortcut.

Before learning how to manipulate a dataset or build a model, I needed to understand how Python itself works.

And that was where my first week began.

What I Learned During Week One

My first week was mainly about understanding the fundamentals.

Some of the major topics I worked through included:

• Variables
• Data types
• Strings
• Numbers
• Lists
• Dictionaries
• Operators
• Conditional statements
• Loops
• Functions
• Basic error handling
• Python methods

Each topic introduced a different way of thinking about problems.

Let’s go through some of them.

1. Variables: Giving Information a Name

One of the first things I learned was how variables work.

A variable is simply a name that we give to a value so that we can use that value later.

For example:

name = "Divine"
age = 20
role = "Data Science Intern"

Now Python knows that:

• name contains "Divine"
• age contains 20
• role contains "Data Science Intern"

I can then use those variables in my program.

print(name)
print(age)
print(role)

The output would be:

Divine
20
Data Science Intern

This might look extremely basic, but it introduced an important idea:

Programs work with information, and variables help us organize that information.

As someone moving toward data science, this becomes particularly important because data is everywhere.

Names, ages, prices, scores, dates, locations, measurements, and thousands of other things can all become values that a program needs to work with.

2. Understanding Data Types

After variables, I learned that not every piece of information is the same.

Python has different data types for different kinds of values.

For example:

name = "Divine"       # String
age = 20              # Integer
height = 1.75         # Float
is_intern = True       # Boolean

Here we have:

String

Used for text.

name = "Divine"

Integer

Used for whole numbers.

age = 20

Float

Used for numbers containing decimal values.

height = 1.75

Boolean

Represents either True or False.

is_intern = True

I also learned that Python allows us to check the type of a value using type().

score = 85

print(type(score))

Output:

<class 'int'>

This became useful because understanding what type of data I am working with can prevent unexpected errors later.

3. Strings and Working With Text

Strings are basically text stored inside Python.

For example:

first_name = "Divine"
last_name = "Odey"

full_name = first_name + " " + last_name
print(full_name)

Output:

Divine Odey

I also learned that Python provides methods that make it easier to work with strings.

For example:

name = "python"

print(name.upper())

Output:

PYTHON

Or:

name = "PYTHON"

print(name.lower())

Output:

python

There are many other string methods, but the bigger lesson for me was understanding that Python gives us tools for manipulating information rather than forcing us to do everything manually.

That idea becomes increasingly useful when working with real-world data.

4. Lists: Working With Multiple Values

Another important concept I learned was the list.

Instead of creating separate variables for several related values, I can store them together.

For example:

scores = [75, 82, 90, 68, 88]

Now scores contains five values.

I can access individual values using their position:

print(scores[0])

Output:

75

Something that initially confused me was that Python starts counting from 0.

So:

scores[0] → 75
scores[1] → 82
scores[2] → 90

I also learned that lists can be modified.

scores.append(95)

print(scores)

Now the list contains:

[75, 82, 90, 68, 88, 95]

This was one of the moments where programming started to feel more practical.

I wasn’t just learning syntax anymore.

I was learning how to store and manipulate collections of information.

5. Conditional Statements: Teaching Programs to Make Decisions

One of my favorite concepts from the week was the if statement.

It allows a program to make decisions based on a condition.

For example:

score = 75

if score >= 50:
    print("You passed")
else:
    print("You failed")

Since the score is 75, Python prints:

You passed

We can also have multiple conditions using elif.

score = 75

if score >= 80:
    print("Excellent")
elif score >= 60:
    print("Good")
elif score >= 50:
    print("Pass")
else:
    print("Try again")

This helped me understand something important about programming.

Get Odey Divine’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

A program doesn’t just execute instructions blindly.

We can give it rules and allow it to respond differently depending on the information it receives.

Python’s control-flow tools include if, elif, and else for conditional decisions.

6. Loops: Avoiding Repetition

Imagine having to print 100 names individually.

That would be frustrating.

This is where loops become useful.

For example:

names = ["David", "John", "Mary", "Sarah"]

for name in names:
    print(name)

Python goes through each name in the list and prints it.

Output:

David
John
Mary
Sarah

Instead of writing:

print(names[0])
print(names[1])
print(names[2])
print(names[3])

I can use a loop.

That might seem like a small difference, but it represents a major programming idea:

Let the computer handle repetitive work.

This idea is especially relevant to data science because datasets can contain thousands or millions of records.

I also encountered while loops, which continue running as long as a particular condition remains true.

number = 1

while number <= 5:
    print(number)
    number += 1

Output:

1
2
3
4
5

7. Functions: Making Code Reusable

Another important lesson was functions.

Before learning functions, I could easily find myself writing the same kind of code multiple times.

Functions provide a way to package instructions into something reusable.

For example:

def greet(name):
    print("Hello", name)

I can then use the function whenever I need it.

greet("David")
greet("Sarah")
greet("John")

Output:

Hello David
Hello Sarah
Hello John

Functions became particularly interesting to me because they showed me how larger programs can be broken into smaller, manageable pieces.

Instead of having one huge block of code, I can create different functions for different tasks.

For example:

def add_numbers(a, b):
    return a + b

Then:

result = add_numbers(10, 5)

print(result)

Output:

15

Python uses the def keyword to define functions, and functions can accept parameters and return results.

8. Operators and Comparisons

I also spent time understanding operators.

For example, arithmetic operators allow us to perform calculations:

a = 10
b = 3

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

We also have comparison operators:

x = 10
y = 5

print(x > y)
print(x < y)
print(x == y)
print(x >= y)
print(x <= y)

The output is:

True
False
False
True
False

Understanding these operators became important because they are used everywhere.

They appear in calculations, conditions, loops, data processing, and eventually more advanced programming tasks.

9. Learning Through Small Problems

One thing I particularly enjoyed about the week was solving small problems instead of only reading about concepts.

For example, I could combine variables, conditions, and functions to create something as simple as a grade checker.

def check_grade(score):

    if score >= 70:
        return "A"
    elif score >= 60:
        return "B"
    elif score >= 50:
        return "C"
    elif score >= 45:
        return "D"
    else:
        return "F"

score = 72
print(check_grade(score))

Output:

A

This tiny program combines several concepts I learned during the week.

And that was the biggest difference between simply studying Python and actually practicing it.

Once I started putting concepts together, I began to understand why each concept mattered.

The Part That Wasn’t Always Easy

Of course, the week wasn’t completely smooth.

There were moments when I understood something while following an example, only to get confused when I tried writing it myself.

Sometimes the problem was something as small as a missing bracket.

Other times, I misunderstood what Python expected from my code.

And then there were errors.

Lots of errors.

At first, seeing an error message can feel like Python is simply telling you that you got everything wrong.

But I gradually started seeing errors differently.

An error is information.

For example:

age = "20"

print(age + 5)

This produces an error because "20" is text, while 5 is a number.

The solution is to understand what Python is trying to tell me and then investigate the problem.

That changed my approach to debugging.

Instead of immediately thinking:

“My code doesn’t work.”

I started thinking:

“What exactly is Python telling me?”

That small change in mindset is something I want to carry throughout my internship.

One Important Lesson: Don’t Rush the Basics

One thing my first week reminded me of is that it is very easy to underestimate fundamentals.

When you’re interested in data science, it can be tempting to jump straight into machine learning.

You see people building impressive models and working with advanced libraries, and you naturally want to get there quickly.

But there is a foundation underneath all of that.

Before manipulating a dataset, you need to understand data.

Before writing more complex programs, you need to understand basic programming concepts.

Before debugging complicated projects, you need to become comfortable reading simple errors.

Python’s own tutorial introduces learners to basic expressions, data types, lists, control flow, functions, and data structures before moving into more advanced areas.

My first week made that approach make much more sense.

What I Took Away From Week One

If I had to summarize my first week in a few lessons, they would be these:

1. Understanding is more important than speed

I don’t want to simply memorize Python syntax.

I want to understand why I’m writing something and what is happening when the code runs.

2. Practice makes concepts clearer

A concept can make sense when someone explains it, but writing the code yourself is a different experience.

You notice gaps in your understanding much faster.

3. Errors are part of learning

Getting an error doesn’t mean I should give up.

It means there is something to investigate.

4. Small programs are valuable

A simple calculator or grade checker might not look impressive, but small projects force you to combine different concepts.

That is where learning becomes practical.

5. The basics are not “just basics”

Variables, data types, conditions, loops, and functions may be beginner topics, but they are extremely important building blocks.

Looking Ahead

My first week at DataraFlow was just the beginning.

I know there is still a lot ahead of me.

Python is much bigger than the few concepts I covered this week, and data science goes far beyond simply knowing how to write Python code.

There will be data cleaning, analysis, visualization, statistics, machine learning, and many other things to learn.

But I’m learning to appreciate the process rather than rushing toward the final destination.

For now, I’m happy that I have spent my first week strengthening the foundation.

The goal isn’t to know everything after one week.

The goal is to understand a little more than I did yesterday and keep building from there.

And if this first week has taught me anything, it’s this:

You don’t become good at programming by avoiding mistakes. You become better by writing code, making mistakes, understanding them, and trying again.

This is the first article in my journey as a Data Science Intern at DataraFlow. I plan to document what I learn along the way, including the concepts that challenge me, the projects I work on, and the lessons that come with growing as a data professional.