DEV Community: Leonardo Zeaiter

# Python Crash Course for C# Developers — Part 2: Data Structures

Leonardo Zeaiter — Wed, 22 Jul 2026 16:13:38 +0000

By Leonardo Zeaiter

Part 2 of 5 in a free introductory series, laying the groundwork for my forthcoming book: *Python Beyond Syntax: Advanced Topics for the C# Developer*.

It's worth noting that everything covered in this series is intentionally a quick, practical introduction, enough to get you reading and writing basic Python comfortably, not a complete treatment of any single topic. Think of this series as learning to hold a conversation; the book is where you become fluent. Python Beyond Syntax: Advanced Topics for the C# Developer takes everything you already know from years of C# and uses it as the map for learning Python properly: not just syntax, but the reasoning behind async, memory management, object-oriented design, generators and the idioms that make Python code actually look like Python. Each topic is explored in both languages side by side, so you always know exactly where your existing instincts hold and where they'll mislead you. And because Python is the language behind nearly every AI tool and library worth knowing, this isn't just a second language, it's your fastest path to being dangerous with AI development without starting from zero.

Where We Left Off

In Article 1, you got comfortable reading Python: indentation, data types, variables, naming conventions, if/elif and loops. That's the grammar. This article is the vocabulary: the collections you'll actually use constantly, in almost every piece of Python you write.

You already think in lists and key-value lookups every day in C#. What's ahead is mostly a lighter, more flexible syntax for things you already know how to use.

1. Lists

Python's list is close to List<T> in C#; it is an ordered (thus indexed) and mutable collection that allows duplicates. The difference is that a Python list has no declared element type. It can hold anything, including a mix of types in the same list, though in practice you'll usually keep them uniform out of habit and readability.

scores = [95, 87, 72, 100]  # this is a list of int

To create a list, just use square brackets with comma-separated values; no new List<int> { ... } ceremony required.

Common operations

scores = [95, 87, 72, 100]

print(type(scores) == list)  # True

len(scores)          # 4 - returns the number of items 
                     # works on all four collection types

scores.append(60)    # adds 60 to the end of the list: 
                     # [95, 87, 72, 100, 60]

scores[0]     # 95 - indexing works just like C#'s array/list indexing
scores[-1]    # 60 - negative indexing counts from the end
              # this returns the last element

scores[-2]    # 100 - the second last item

sub_scores = scores[1:3]    # slicing: a sub-list from index 1 up to 
                            # (not including) index 3 

print(type(sub_scores) == list)  # True - the result is itself a list
print(sub_scores)                # [87, 72]

A list can be mutated using just the indexer. This is a powerful feature as it allows you to insert, update and remove easily without memorizing different functions.

scores = [95, 87, 72, 100]

# replace 87 and 72 by 77, 76 and 75
scores[1:3] = [77, 76, 75]  # translates to: start at index 1 then 
                            # replace 2(3-1) elements with 77, 76, and 75

print(scores)               # output: [95, 77, 76, 75, 100]

scores = [95, 87, 72, 100]  # reset scores

# insert 98 before 100 i.e. at index 3
scores[3:3] = [98]    # this translates to: start at index 3 then 
                      # replace 0(3-3) elements with 98

# this could have been achieved using the insert(): scores.insert(3, 98)

scores = [95, 87, 72, 100]  # reset scores

scores[2:4] = []  # this translates to: start at index 2, replace 2(4-2)
                  # elements with nothing i.e. delete them

print(scores)     # output: [95, 87]

Everything in Python is an object including primitive types like int, float, bool etc. Objects act almost the same way as their C# counterparts.

scores = [95, 87, 72, 100]

values = scores  # now both scores and values refer to the same object in memory

print(id(values) == id(scores))  # returns True indicating both objects refer to
                                 # the same address 

scores[1] = 90   # modify the second element of scores; values is also affected 
                 # as both point to the same list

print(scores)    # output: [95, 90, 72, 100]
print(values)    # output: [95, 90, 72, 100]

scores_clone = scores.copy()           # create a clone of the scores list

print(scores == scores_clone)          # True, both lists have the same content 
                                       # this is different in C#

print(id(scores) == id(scores_clone))  # False, they are different objects in memory

scores_clone[1] = 85                   # modify the second element of the clone; 
                                       # original scores is unaffected

print(scores)                          # output: [95, 90, 72, 100]
print(values)                          # output: [95, 90, 72, 100]
print(scores_clone)                    # output: [95, 85, 72, 100]

A striking difference with C# is when comparing two lists having the same content but referring to two different objects in memory; in C#, the == operator returns false while in Python, and as we noticed in the example above, the result was True. The fact of having both objects referring to different areas in memory was detected through comparing the ids of both lists on the line beneath. When we deep dive into the dunder methods of Python, we'll learn how we can override this behavior.

2. Dictionaries

Python's dict is your Dictionary<TKey, TValue>. Same core idea: unique keys mapped to values, fast lookup by key. Dictionaries are not ordered, do not allow duplicate keys and, like lists, are mutable.

user = {"name": "John", "age": 48, "active": True}

No new Dictionary<string, object> declaration needed; just curly braces and keys/values that can be of different types within the same dictionary without any special handling.

Common operations

user = {"name": "John", "age": 48, "active": True}

len(user)                   # 3 - number of items
user["name"]                # "John" - direct key access, like C#'s indexer 
                            # if no entry with key, raise error
user.get("email", "N/A")    # "N/A" - safer access: if the key is missing
                            # return the second argument
"age" in user               # True - checks whether a key exists, no TryGetValue needed
user.keys()                 # dict_keys(['name', 'age', 'active']) - all the keys, for iterating
user.values()               # all the values
user.items()                # more on that later

user.get("email", "N/A") is worth pausing on; it's a one-line equivalent of C#'s TryGetValue pattern, returning a fallback value instead of throwing or requiring an out parameter. It's one of the small conveniences that makes Python dictionaries feel a bit less ceremonious to work with day to day.

user = {
   "id": 1,
   "name": "John Doe",
   "salary": 15_000
}

print(type(user) == dict)  # True

print(user["id"])   # output: 1

print(user["age"])  # raise an error (KeyError) - can you use the safer get() instead

# loop through the dictionary
for key in user:
    print(f"{key}: {user[key]}")  

# output: 
#        id: 1
#        name: John Doe 
#        salary: 15000 

# a more common way to loop through a dictionary
for key, value in user.items():  # unpack the key and value from each item
    print(f"{key}: {value}")   


if("name" in user):
    print("Name exists in the dictionary")  
    # output: Name exists in the dictionary 

print(user.get("salary", None))            
# output: 15000 - no KeyError even if the key is not present

john = user.copy()                          
# create a clone of the user dictionary; changing john will not affect user

3. Tuples

A tuple is an ordered, fixed-size, immutable sequence. The closest C# cousin is ValueTuple (the (int, string) syntax), but tuples are far more common in everyday Python, especially for returning multiple values from a function without declaring a class or a named tuple type first.

point = (3, 7)  # parentheses with comma-separated values 
                # can have any number of values, not just two

Once created, you can't reassign any individual element; typing something like point[0] = 5 raises an error. Remember that among the four common collections of Python, tuples are the only immutable entities; create one and you'll never be able to modify its content before first destroying it.

Common operations

point = (3, 7)

len(point)    # 2 - same len() function as lists and dicts

point[0]      # 3 - indexing works the same way as lists
point[1]      # 7

x, y = point  # unpacking: x = 3, y = 7, in one line

It's a common pattern in Python, to have a function return multiple values packed into a tuple; the caller can then unpack the result into individual variables as in the below code:

def get_coordinates():
    return (3, 7)  # parentheses can be removed here

x, y = get_coordinates()
print(x,y)  # print 3 7

No out parameters, no wrapper class needed just to hand back two values at once.

4. Sets

A set is an unordered collection of unique values, Python's equivalent of C#'s HashSet<T>. No duplicates, no guaranteed order, and it's built for fast membership testing.

tags = {"python", "csharp", "ai", "python"}  
# no errors even though python is included twice; duplicates are just ignored

print(tags)  # {'python', 'ai', 'csharp'}

Curly braces with comma-separated values, no colons; that's what distinguishes a set literal from a dict literal at a glance.

Common operations

tags = {"python", "csharp", "ai"}

len(tags)               # 3 - number of items
"python" in tags        # True - fast membership check, the main reason to use a set
tags.add("dotnet")      # adds a new item: {"python", "csharp", "ai", "dotnet"} 
                        # no error if the item is already in the set
tags.remove("ai")       # removes "ai" from the set 
tags.remove({"react"})  # KeyError is raised because react is not in the set

if "react" in tags:
    tags.remove("react")   # safe way to remove an item that may not be present

As in C#, set operations include intersection, union, difference and symmetric difference.

john_cars = {"Mercedes", "BMW", "Audi", "Toyota"}
edmond_cars = {"Honda", "Ford", "Toyota", "Chevrolet"}

# Common cars between John and Edmond: {'Toyota'}
common_cars = john_cars.intersection(edmond_cars)
print("Common cars between John and Edmond:", common_cars) 

# All cars owned by John and Edmond: 
# {'Toyota', 'Ford', 'Mercedes', 'Audi', 'Chevrolet', 'Honda', 'BMW'}
all_cars = john_cars.union(edmond_cars)
print("All cars owned by John and Edmond:", all_cars)  

# Cars owned by John but not by Edmond: 
# {'Audi', 'Mercedes', 'BMW'}
# order matters; (A - B) != (B - A)
john_unique_cars = john_cars.difference(edmond_cars)  
print("Cars owned by John but not by Edmond:", john_unique_cars)

# Cars owned by Edmond but not by John: 
# {'Honda', 'Ford', 'Chevrolet'}
edmond_unique_cars = edmond_cars.difference(john_cars)  
print("Cars owned by Edmond but not by John:", edmond_unique_cars)

# Cars owned by either John or Edmond but not both: 
# {'Honda', 'Ford', 'Chevrolet', 'Audi', 'Mercedes', 'BMW'}
unique_cars = john_cars.symmetric_difference(edmond_cars)
print("Cars owned by either John or Edmond but not both:", unique_cars)

You'll probably use sets less often than lists or dicts, but when you need to ignore duplicates or quickly check if a value exists, sets will be the right tool; this is exactly the same reasoning that would point you toward HashSet<T> in C#.

What You Can Already Do

Between Article 1 and this one, you can now read and write Python code that stores data, loops through it and makes decisions. That's the working core of the language.

In the next article, you'll explore functions, lambdas, variable scoping and error handling. You'll also learn about list comprehension.

If you’d like early access to my forthcoming book: Python Beyond Syntax: Advanced Topics for the C# Developer, kindly sign up at https://tally.so/r/9q5l2Q.

Python Crash Course for C# Developers — Part 1: Reading the Room (Syntax & Control Flow)

Leonardo Zeaiter — Mon, 06 Jul 2026 16:20:17 +0000

By Leonardo Zeaiter

Part 1 of 5 in a free introductory series, laying the groundwork for my forthcoming book: *Python Beyond Syntax: Advanced Topics for the C# Developer*.

Why you're here

You didn't wake up one day and decide you needed a new hobby. You're exploring this series because Python has quietly become the language every interesting conversation in tech seems to run through: AI, data, automation, the tools you keep seeing in demos that make you think "wait, how did they do that so fast?" And somewhere in the back of your mind is a small, slightly annoying voice saying: I should probably know this, not just nod along.

The good news is this: you're not starting from zero. You're starting from 5 (or 10, or 3) years of already knowing what a variable is, what a loop does, why functions exist, and how to think like a programmer. You're not learning to code. You're learning Python's accent, a new way of saying things you already know how to say.

Before We Start: Running Python in VS Code

You probably already have VS Code installed; let's get it running Python so you can then try each example as we go.

1. Install Python itself. VS Code edits code, but it doesn't run Python on its own; you need to install Python on your machine first. Download it from https://python.org by grabbing the latest stable version and run the installer. On Windows, make sure you tick "Add python.exe to PATH" during setup. Skipping it is the most common reason Python "doesn't work" afterward.

2. Install the Python extension. Open VS Code, click the Extensions icon in the left sidebar (or press Ctrl+Shift+X / Cmd+Shift+X), search for "Python" (the official one, published by Microsoft), and click Install. This gives you syntax highlighting, autocomplete, and the ability to run Python files directly from the editor, the same kind of experience you're used to with C# in Visual Studio.

3. Create and run a file. Create a new file, name it hello.py and type:

print("Hello from Python")

Then run it by clicking the Run button that appears in the top-right corner of the editor.

A terminal panel opens at the bottom of VS Code and you'll see Hello from Python printed out. That terminal is running your actual code.

1. Indentation Replaces `{ }`

In C#, curly braces mark where a block starts and ends. Indentation is optional and its presence improves readability; for the compiler, it is meaningless.

if (isReady)
{
    Console.WriteLine("Let's go");
}

Python skips the braces entirely and uses indentation itself to mark the block:

if is_ready:
    print("Let's go")

The colon (:) says: a block is coming, and the indented lines underneath are that block. Stop indenting, and you're back outside it. That's really all there is to it: you already indent your C# code this way out of habit, and Python just makes it official.

The convention is 4 spaces per indentation level (a tab works too, just don't mix tabs and spaces in the same file). Most editors can be set to insert spaces automatically when you press Tab, which makes this a non-issue.

In C#, an empty block is represented by curly braces with no code inside. Since braces are omitted altogether in Python, you must use the keyword pass to declare an empty block as follows:

if is_ready:
    pass

2. Data Types: Less Ceremony, Same Idea

In C#, you're used to declaring a variable's type up front:

int score = 95;
double average = 87.5;
string name = "John";
bool isActive = true;

Python skips the type declaration entirely:

score = 95
average = 87.5
name = "John"
is_active = True

The variable still has a type. Python figures it out at runtime from the assigned value; score is an int, average is a float, name is a str, is_active is a bool, exactly as you'd expect. This is called dynamic typing, in contrast to C#'s static typing.

Python's core built-in types map onto what you already know from C#:

Python type	Roughly equivalent to	Example
`int`	`int` / `long`	`42`
`float`	`double` / `float`	`3.14`
`str`	`string`	`"hello"`
`bool`	`bool`	`True` / `False`
`NoneType`	`null`	`None`

Since Python doesn't ask you to declare a type, you'll often want to check what type a value actually is, especially while you're still getting a feel for the language. The built-in type() function tells you:

score = 95
print(type(score))          # <class 'int'>
print(type(score) == int)   # True

average = 87.5
print(type(average) == float)   # True

name = "John"
print(type(name) == str)    # True

type(x) == int is a handy way to check what a variable actually holds while you're experimenting; a genuinely useful habit while you're exploring how Python treats values.

Hint: think of a C# variable as a labeled box that can only ever hold one specific type of thing; you painted "int" on the box, and only ints go in it. A Python variable is more like a sticky note. It just points at whatever value you last assigned, and you can point it at something else entirely, including a different type, without Python complaining:

value = 42
print(type(value) == int)    # True
value = "now I'm a string"   # perfectly legal, no error
print(type(value) == str)    # True

This flexibility is genuinely useful for fast exploratory scripting and this is the kind of thing Python was built for; however, this also means you'll lose an important feature you already have in C#: the compiler's ability to catch type mistakes at build time.

3. Naming Conventions

Python has its own naming conventions, and they differ from what you're used to in C#. Adopting them early will save you from writing code that technically works but visibly looks like it was written by someone new to the language.

Variables and functions use snake_case: is_active, user_name, calculate_total().
Classes use PascalCase, same as C#: class OrderProcessor:, class UserAccount:.
Constants are typically written in ALL_CAPS_WITH_UNDERSCORES: MAX_RETRIES = 5, similar in spirit to C#'s convention for const fields.

Nobody will stop you from writing camelCase variables in Python; it'll just immediately mark your code as written by someone new to the language.

4. `if`, `elif`, and the Vanishing Parentheses

You already know exactly what this does:

if (temperature > 30)
{
    Console.WriteLine("Hot");
}
else if (temperature > 15)
{
    Console.WriteLine("Mild");
}
else
{
    Console.WriteLine("Cold");
}

Here's the same logic in Python:

if temperature > 30:
    print("Hot")
elif temperature > 15:
    print("Mild")
else:
    print("Cold")

Three small differences: no parentheses required around the condition, elif instead of else if (one word, not two), and, same as before, the colon and indentation replace the curly braces entirely.

5. Loops: `for` Works Like Your `foreach`

Python's for loop is close to C#'s foreach: it walks through a sequence directly, rather than managing a counter by hand the way C#'s classic for does.

for i in range(5):
    print(i)

range(5) produces the sequence 0, 1, 2, 3, 4, and the loop walks through it, printing each value in turn. If you're looping over a collection you already have, it reads just as naturally:

names = ["Alice", "Bob", "Charlie"]
for name in names:
    print(name)

This is exactly your foreach (var name in names) instinct from C#, just with slightly leaner syntax.

Python's while loop will feel completely familiar with zero adjustment:

count = 0
while count < 5:
    print(count)
    count += 1

Note: Python has no ++ or -- operators. count += 1 is legal and commonly used.

Two more keywords worth knowing right away, since you'll use them constantly. break and continue work exactly as they do in C#, break exits the loop entirely, continue skips to the next iteration:

for i in range(10):
    if i == 3:
        continue   # skip 3, move to the next number
    if i == 6:
        break      # stop the loop entirely once we hit 6
    print(i)
# prints: 0, 1, 2, 4, 5

6. Comments: The One Genuine Simplification

C# gives you two styles:

// single line
/* multi
   line */

Python gives you one primary style for single-line comments:

# single line

For multi-line comments, Python doesn't have a true dedicated block-comment syntax. The common convention is a triple-quoted string left standalone in the code, which Python happily ignores if it's not assigned to anything:

"""
This isn't officially a "comment."
It's a string literal Python evaluates and discards,
but it's used as a stand-in for block comments.
"""

Nothing to overthink here: the # symbol will cover 95% of your commenting needs.

7. Truthy and Falsy: Where Python Gets a Little Philosophical

This is the one concept in this article that's genuinely new, not just a syntax reshuffle. It's worth understanding properly, because it quietly affects how you'll write conditions in Python from here on.

In C#, an if condition must evaluate to an actual bool. You can't casually stick an int or a string into an if and have it just work the way you might in some looser languages.

Python is far more permissive: any value can be evaluated in a boolean context, and each type has rules for what counts as "truthy" (treated as true) or "falsy" (treated as false):

name = ""
if name:
    print("Has a name")
else:
    print("Empty!")   # this runs; an empty string is falsy

The general rule: False, 0, 0.0, "" (empty string), [] (empty list), {} (empty dict), () (empty tuple) and None are all falsy. Pretty much everything else, True, non-zero numbers, non-empty strings, non-empty collections is truthy.

This lets you write idiomatic Python like:

items = []
if items:
    print("We have items")
else:
    print("The list is empty")  # this runs

instead of the more verbose, C#-flavored:

if len(items) > 0:
    ...

Both work. The first is how experienced Python developers actually write it, and recognizing it when you read someone else's code is at least as important as being able to write it yourself.

8. Basic Input and Output

Last thing for this article, and the simplest: printing output and reading input.

print("Hello, John")

name = input("What's your name? ")
print("Nice to meet you, " + name)

print() is your Console.WriteLine(). input() is your Console.ReadLine(), with one convenience built in: it takes an optional prompt string to display before waiting for input, saving you a separate print() call.

What You Can Already Do

Stop and notice something: with just what's in this article, you can already write a Python script with variables, conditionals, and loops, which, syntax aside, is genuinely most of what a program is.

Next up, Article 2 covers the most common data structures in Python: lists, dictionaries, tuples, and sets. You'll notice that they are genuinely more flexible than what you're used to in C#, not just different.

If you'd like early access to my forthcoming book: Python Beyond Syntax: Advanced Topics for the C# Developer, kindly sign up at https://tally.so/r/9q5l2Q.

DEV Community: Leonardo Zeaiter

# Python Crash Course for C# Developers — Part 2: Data Structures

Where We Left Off

1. Lists

2. Dictionaries

3. Tuples

4. Sets

What You Can Already Do

Python Crash Course for C# Developers — Part 1: Reading the Room (Syntax & Control Flow)

Why you're here

Before We Start: Running Python in VS Code

1. Indentation Replaces { }

2. Data Types: Less Ceremony, Same Idea

3. Naming Conventions

4. if, elif, and the Vanishing Parentheses

5. Loops: for Works Like Your foreach

6. Comments: The One Genuine Simplification

7. Truthy and Falsy: Where Python Gets a Little Philosophical

8. Basic Input and Output

What You Can Already Do

1. Indentation Replaces `{ }`

4. `if`, `elif`, and the Vanishing Parentheses

5. Loops: `for` Works Like Your `foreach`