Python for C# Developers: Learn Python Using What You Already Know

C# vs Python, side by side

Each pair below does the same job. Start with the code you know, then see how Python expresses it.

Static vs dynamic typing

int count = 3;
count = "three";   // compile error

string Greet(string name) => $"Hi {name}";

count = 3
count = "three"    # allowed

def greet(name: str) -> str:
    return f"Hi {name}"

In C#, the compiler rejects count = "three". In Python a name can be rebound to any value, and types are checked only when the line runs. Type hints such as name: str are read by tools like mypy, never enforced at runtime.

Classes and properties

public class Account
{
    public decimal Balance { get; private set; }

    public void Deposit(decimal amount) => Balance += amount;
}

class Account:
    def __init__(self):
        self.balance = 0

    def deposit(self, amount):
        self.balance += amount

Python uses a plain attribute where C# uses an auto-property, and you can switch to @property later without changing callers. There is no private set; a leading underscore, as in _balance, marks something as internal by convention.

LINQ vs comprehensions and generators

var names = people
    .Where(p => p.Active)
    .Select(p => p.Name)
    .ToList();

names = [p.name for p in people if p.active]

# lazy: nothing runs until you iterate it
active = (p for p in people if p.active)

A list comprehension builds the whole list at once, like ToList(). A generator expression in parentheses is lazy, but it can be consumed only once, unlike a LINQ query you can enumerate again. They are not one-to-one: for GroupBy or OrderBy you will use dictionaries and sorted.

async/await

async Task<string[]> FetchAllAsync(IEnumerable<string> urls)
{
    return await Task.WhenAll(urls.Select(FetchAsync));
}

import asyncio

async def fetch_all(urls):
    return await asyncio.gather(*(fetch(url) for url in urls))

Both use async and await, but a Python coroutine does nothing until it is awaited or scheduled, for example with asyncio.run(...), while a C# Task starts running as soon as it is created. asyncio is single-threaded, so it suits waiting on I/O rather than CPU-heavy work.