Visual Basic.CodeCompared.To/Python

There is no module, no entry point, no imports and no type declarations. A Python file is a program: the interpreter runs its statements from top to bottom. print() is a built-in function, always available, and the parentheses are required — this is the one place Python is stricter than Console.WriteLine, which you can also call with them.

$"..." becomes f"...", and the expression inside {} works the same way. The format specifiers do not carry across: .NET's D5 is Python's 05d, F2 is .2f, N0 is ,d, and P1 is .1%. String.Format("{0} ...") has a direct counterpart in "...".format(), though f-strings are what modern Python actually uses.

Console.Write versus Console.WriteLine becomes print(..., end="") versus plain print(...): the end argument is what gets appended, and it defaults to a newline. print also takes any number of values and joins them with sep, which defaults to a single space — so print("x", "y", "z") does the work of String.Join. Both end and sep are keyword arguments, an idea covered under Functions.

A block opens with a colon and is delimited by indentation alone; where the indentation goes back out, the block ends. This is not a style rule, it is the grammar, and mixing tabs with spaces is an error rather than a warning. The practical consequence is that you can no longer reformat by hand without changing meaning — but the code you already write, once the End lines are deleted, is almost exactly the shape Python wants.

A comment is # rather than '. There is no block comment. What replaces '''<summary> is the docstring — a plain string as the first statement of a function, class or module — and it is not a comment at all: it is stored on the object as __doc__, which is how help() and every editor tooltip works. Note also that the function name changed case: Python's convention is snake_case for functions and variables, not PascalCase.

Python identifiers are case-sensitive, so customerName and CustomerName are separate names. Worse than in a compiled language, assigning to an undeclared name simply creates it — there is no Option Explicit and no declaration step, so a typo on the left of an = is a brand-new variable rather than an error. The conventions that keep you safe are snake_case for variables and functions, PascalCase for classes, UPPER_SNAKE_CASE for constants.

Inside any bracket — (, [ or { — a Python statement continues across lines freely, which is why the arithmetic above is wrapped in parentheses it does not otherwise need. Outside brackets there is a backslash continuation, \ at end of line, but it is considered poor style and almost never used. The bracket rule covers essentially every real case.

A Python variable is created by assigning to it, and it is a name bound to an object rather than a typed storage slot. The type belongs to the value, not the name, so count can hold an integer on one line and a string on the next and nothing objects. This is the single biggest loss of safety in the move, and the next two rows are about getting some of it back. Note True keeps its capital T here, unlike C#.

A type hint puts the type after a colon and the return type after ->, which is the same right-to-left order as text As String. The difference that matters: the interpreter ignores them entirely. repeat(5, 3) is annotated as taking a string, and Python runs it anyway — 5 * 3 is a perfectly good multiplication, so it returns 15 where the annotation promised text. The Visual Basic column will not compile the equivalent line at all. Hints are documentation that external tools — mypy, pyright, your editor — can check; treat them as Option Strict On that only your tooling honors.

Short, Integer and Long all become int, which grows to whatever size the value needs — there is no overflow and no OverflowException. Double becomes float and behaves identically, binary rounding and all, which is why 6.7 + 0.1 is untidy in both columns. Decimal is not a built-in: it comes from the standard library and takes a string, because Decimal(8.9) would already have lost the precision you asked for.

None is a single object meaning "nothing here", and testing for it uses is None — which reads exactly like Visual Basic's Is Nothing and means the same thing, identity comparison. The mismatch is on the other side: Dim n As Integer = Nothing stores zero, because Visual Basic's Nothing means "the default value for this type". Python has no such notion — None is None whatever the variable held before.

CInt, CStr, CDbl and CBool become int(), str(), float() and bool(). What has no counterpart is the TryParse pattern: Python has no output parameters, so a conversion that might fail is wrapped in try/except ValueError. That is idiomatic Python rather than a workaround — the community phrase is "easier to ask forgiveness than permission", and exceptions are used for ordinary control flow far more freely than in .NET.

Python spells its logical operators as words, just as Visual Basic does: and, or, not. They all short-circuit, so they correspond to AndAlso, OrElse and Not. There is no non-short-circuiting pair — & and | exist but are bitwise, so plain And and Or have no equivalent and are not missed. If you have been writing And where you meant AndAlso, the translation quietly fixes it.

Visual Basic's \ becomes // and / stays floating-point in both, so the habit transfers intact — a relief after C#, where / silently truncates. Mod becomes %. The one genuine difference is negatives: Visual Basic truncates toward zero, so -17 \ 5 is -3, while Python floors, giving -4. The same split affects %, whose Python result takes the sign of the right operand.

^ becomes **. Unlike C#, which drops the operator entirely in favor of Math.Pow, Python keeps it — and improves on the Visual Basic version by returning an int when both operands are integers, so 7 ** 2 is 49 rather than 49.0. Do not write ^ out of habit: as in C#, it is the bitwise exclusive-or, so 7 ^ 2 quietly evaluates to 5.

= for comparison becomes ==, and <> becomes !=. The addition is chained comparison: 10 < value < 20 means exactly what it does in mathematics, evaluates value only once, and short-circuits. It reads better than the AndAlso version and is what Python programmers expect to see for a range test.

+=, -=, *= and /= are identical; &= for strings becomes +=, and \= becomes //=. Python has no increment operator: there is no ++ or --, so count += 1 is the only way, which is also all Visual Basic ever offered. Anyone who has read C-family code and expected i++ to appear will not find it here.

Trim→strip, ToUpper→upper, Replace→replace, StartsWith→startswith — all snake_case or simply lower case. Two change shape: Contains becomes the in operator, which reads as English and also works on lists and dictionaries; and .Length becomes the built-in function len(), which likewise works on every sized thing. Python has no equivalent of the Microsoft.VisualBasic family — Mid, Left, Right, InStr — and does not need one, as the next row shows.

A slice is [start:stop:step], where each part may be left out. [:6] is Left(text, 6), [7:] is Mid(text, 8), and negative numbers count from the end — so [-5:] is Right(text, 5) and text[-1] is the last character. A step of -1 reverses. The rule to remember is that stop is exclusive, which makes text[:6] six characters, and that slicing never raises for an out-of-range bound — it just gives you what is there.

Single and double quotes are interchangeable, so the simplest way to include a quote is to wrap the string in the other kind. A backslash escapes, as in C#, so a Windows path needs the raw prefix r"..." — Python's answer to C#'s @"...". Triple quotes open a string that runs until the closing triple quote, newlines included, which is what replaces the & Environment.NewLine & chain. The same triple-quoted form is what docstrings use.

Split becomes split and takes a string rather than a character. String.Join(separator, parts) becomes separator.join(parts) — the separator is the object you call the method on, which looks backwards for about a day and then stops. Calling split() with no argument splits on any run of whitespace and discards empties, which is what you usually want for parsing a line of text.

Every string method returns a new string in both languages, which is why text is unchanged above. Where .NET reaches for StringBuilder, Python collects the pieces in a list and calls "".join() once at the end. It is the same idea — one allocation instead of many — using the collection type it already has. Visual Basic 4.0 and later already made strings immutable, so this is not new; VB6's mutable fixed-length strings are what does not carry over.

A list is written in square brackets, grows and shrinks freely, and can hold anything — there is no element type to declare. Add becomes append, Count becomes len(), and indexing uses square brackets, which removes the array-versus-method-call ambiguity that parentheses create in Visual Basic. There is no fixed-size array to choose instead, and no ReDim Preserve to worry about: a list simply resizes.

numbers[-1] is the last element, [-2] the one before it; there is no UBound and no Length - 1. A slice returns a new list, so [1:4] replaces Skip(1).Take(3) and [::-1] replaces Reverse(). Note that printing a list shows it in brackets with its punctuation, unlike String.Join — that is Python showing you the object rather than its contents as text.

A dictionary literal is {key: value, ...}. Iterating gives you the keys by default, so .items() is what yields pairs — and Python unpacks the pair into two loop variables in the header, where Visual Basic needs a KeyValuePair and two property reads. ContainsKey becomes the in operator. TryGetValue becomes .get(key, default), which returns the default rather than assigning to an output parameter. A VBA reader should note this is the Scripting.Dictionary they know, built in and typed by nothing.

A tuple is a comma-separated list of values, and the parentheses are usually optional: return min(values), max(values) returns one. Unpacking on the left of an = pulls the parts into separate names, and *rest collects whatever is left over. Tuples are immutable, which is what distinguishes them from lists. Python's tuples have no field names as Visual Basic's do — when you want those, the answer is a dataclass or a NamedTuple.

HashSet(Of T) becomes a set literal in braces — note that {} alone is an empty dictionary, so an empty set is set(). Duplicates collapse on construction in both. Where .NET spells the operations out as mutating methods (IntersectWith, UnionWith, ExceptWith), Python offers &, | and - as non-mutating operators, which read like the mathematics they come from.

A list is a reference in both columns, so alias_list = original gives the same list a second name and appending through one is visible through the other. Copying is original[:] — a full slice — or list(original), matching New List(Of Integer)(original). Both are shallow: the list is new, the objects inside it are not. In Visual Basic the As clause at least tells you a reference type is involved; in Python you have to know, which is why this catches people.

ElseIf becomes elif, the Then and the End If go away, and each branch header ends with a colon. The condition needs no parentheses, unlike C#. This is the shape most Visual Basic code already has, so most If ladders port almost mechanically.

An empty list, an empty string, an empty dictionary, 0, 0.0 and None are all falsy; everything else is truthy. So if not items means "if the list is empty". It is genuinely idiomatic and worth adopting — but note what it costs you: if not count cannot tell zero from None, and if not text cannot tell an empty string from a missing one. When that distinction matters, test explicitly with is None.

Case 2, 3 becomes case 2 | 3, and Case Else becomes case _. A range test has no direct form, so it becomes a capture with a guard: case value if 4 <= value <= 6. Like Select Case and unlike C#, no branch falls through to the next. match can also destructure lists, dictionaries and objects, which puts it closer to C#'s pattern matching than to Select Case — but for the plain value-dispatch shown here, a dictionary of functions is still the more common Python idiom.

If(condition, whenTrue, whenFalse) becomes whenTrue if condition else whenFalse — the value first, the test in the middle. It short-circuits, evaluating only the branch it takes. The two-argument If(value, fallback) has no dedicated operator; supplied or "(unnamed)" is the short idiom, but it falls back on any falsy value, so an empty string would also be replaced. Where that matters, spell out is not None as above.

range(start, stop, step) produces numbers from start up to but not including stop, so Visual Basic's inclusive To 5 becomes range(1, 6). This is the off-by-one to watch, and it is the same rule as slicing. range(n) with one argument counts from 0, which is what you want for indexing. A negative step counts down, and the exclusive stop applies there too — To 0 becomes -1.

For Each word As String In words becomes for word in words. When you need the position too, enumerate() yields (index, value) pairs which unpack straight into two loop variables — no counting loop, no Count - 1, no indexing. It takes a start= argument if you want to number from 1. Reaching for range(len(words)) instead is the classic sign of code written by someone who has not met enumerate yet.

While ... End While becomes while ...:. Python has no do ... while at all, so the entire Do ... Loop While / Loop Until family becomes while True: with a break at the point the condition would have been tested. It looks worse than it is: the test ends up written exactly where it happens, and the pattern is common enough in Python that nobody blinks at it.

Exit For becomes break and Continue For becomes continue, both acting on the innermost loop. The addition is the loop else: it runs only if the loop finished without hitting break, which removes the found-it flag the anchor column has to carry. Read it as "else, no break" rather than "else" — the keyword is admittedly badly chosen — and it is exactly the right tool for a search loop.

Sub and Function both become def; the difference is only whether there is a return. A def with no return gives back None, so there is no void to declare and nothing stops you assigning the result — a small trap when a function you thought returned a value does not. Note the order: Python executes top to bottom, so a function must be defined before the line that calls it, unlike a Module where order never mattered.

The Optional keyword disappears — a default value is what makes a parameter optional — and a named argument uses name= rather than name:=. As in Visual Basic, parameters with defaults must come last. Named arguments are used far more heavily in Python than in .NET, and a function with more than two or three parameters is normally called with them for readability.

ParamArray values() As Integer becomes *values, which collects the extra positional arguments into a tuple. **details is the half with no counterpart: it collects any extra named arguments into a dictionary, which is how so many Python libraries accept open-ended options. The same two stars work at the call site, spreading a list or a dictionary back out into arguments — sum_all(*[1, 2, 3]).

There is no ByRef, no ref, no out. Assigning to a parameter rebinds the local name and the caller sees nothing — which is why double_ has to return. But calling a mutating method on a passed object changes the object the caller holds, so add_item works. The rule is not "value versus reference" but "rebinding versus mutating", and the practical advice is to return new values rather than modify arguments in place.

Function(number) number * 2 becomes lambda number: number * 2. A Python lambda holds one expression and nothing more — no statements, no multi-line body, so there is no equivalent of the multi-line Sub() ... End Sub form. Where Visual Basic would reach for a lambda inside Select, Python usually reaches for a comprehension instead, as the first line shows. Lambdas survive mainly as the key= argument to sorted, min and max.

Public Sub New becomes __init__, one of the "dunder" (double-underscore) methods Python uses for everything the language calls on your behalf. Me becomes self — and unlike Me, it is written out as the first parameter of every method and used explicitly for every field access. There is no New keyword at the call site: Person("Ada", 36) calls the class. Fields are created by assigning to self.something inside __init__; there is no separate declaration.

@property turns a method into something read as an attribute, and @name.setter supplies the write half; a property with only the getter is read-only, matching ReadOnly Property. The important cultural difference is that Python does not wrap fields in properties by default: a plain self.celsius is normal, and you convert it to a property later if you need validation — the calling code does not change. The leading underscore on _celsius is a convention meaning "internal", not an access modifier; Python has no Private.

Inherits Animal becomes (Animal) after the class name. Overridable and Overrides have no equivalent — every method can be overridden and redefining one is all it takes, which means nothing warns you if you misspell the name and accidentally add a method rather than replacing one. MyBase becomes super(), and Dog here does not need a constructor at all: leaving __init__ out inherits the parent's.

Python does not check that an object implements an interface; it calls the method and sees what happens. Anything with a greet method is usable here, declared relationship or not — this is duck typing, and it is why so much Python code has no type hierarchy at all. What you give up is the compiler telling you a class forgot a member. When you want that back, the abc module's ABC and @abstractmethod raise on instantiation if a method is missing, and typing.Protocol lets a type checker verify the shape without inheritance.

Operator + becomes __add__, and there is one of these for every operator — __sub__, __mul__, __eq__, __lt__. Overrides Function ToString becomes __str__, which print() and str() call; its companion __repr__ is what the interactive prompt and a printed list show, and is meant for developers rather than users. This family of dunder methods is how Python exposes essentially all of its built-in behavior, including __len__ for len() and __iter__ for for ... in.

import math brings in the module and you reach through it, which is the default and the clearest. from math import sqrt brings one name into your file, matching Imports System.Math. import datetime as dt is the aliased form, matching Imports Builder = .... Unlike a Visual Basic project, there are no project-level imports: every file states what it needs, so nothing is quietly available because a project setting says so.

Python's standard library is the counterpart of the base class library, and it is unusually broad — collections, itertools, datetime, json, csv, re, pathlib, sqlite3, statistics all ship with the interpreter. Counter above replaces the whole tally loop. Anything beyond it comes from PyPI via pip install, which is the equivalent of NuGet — and for the reader coming from Excel, openpyxl and pandas are the two names to look up first.

Because importing a module runs it, any statement at the top level of a file executes when someone imports it. __name__ is "__main__" only when the file is run directly, so the guard means "do this when I am the program, not when I am a library". It is the closest thing Python has to Sub Main, and unlike Sub Main it is a convention rather than a rule — the short examples on this page skip it, as short scripts generally do.

Catch name As TypeName becomes except TypeName as name, and Finally becomes finally. Order still matters, most specific first. The addition is else, which runs only when the try block completed without raising — it keeps the "if this worked, now do that" code out of the try, so an exception from it is not caught by mistake. As with C#, On Error Resume Next and On Error GoTo have no counterpart and must be rewritten rather than translated.

Throw New becomes raise, and the custom type inherits with (Exception). MyBase.New(message) becomes super().__init__(message). Two naming notes: Python convention ends exception class names in Error, not Exception; and printing the exception object gives you the message, so there is no .Message property to reach for. A bare raise inside an except re-raises the current exception with its traceback intact, matching a bare Throw.

Using ... End Using becomes with ...:, and it guarantees the same thing — the resource is released when the block ends, exception or not. Where .NET requires IDisposable, Python requires the object to define __enter__ and __exit__; that pair is called a context manager. The most common use by far is with open("file.txt") as handle:, which is the standard way to read a file and the reason a Python programmer almost never has to remember to close one.

.NET culture checks first — ContainsKey, TryParse, Exists — partly because exceptions there are genuinely expensive. Python culture attempts the operation and catches the failure, a style its community abbreviates as EAFP: easier to ask forgiveness than permission. Exceptions in Python are cheap, and the check-first version has a race in it whenever the thing being checked can change. Both styles work; the point is that Python code you read will be written the second way, so it needs to look normal to you.

A list comprehension reads "the expression, for each item, where the condition" — Select at the front, Where at the back, one line, no lambdas. The same brackets change the result type: {...} gives a set, {key: value for ...} gives a dictionary, and (...) gives a lazy generator. Where LINQ is lazy by default and needs ToList(), a list comprehension is eager and builds the list immediately.

Sum, Max, Min, Any and All become sum(), max(), min(), any() and all(), called around the sequence instead of on it. Average has no built-in — it is sum(x) / len(x), or statistics.mean. OrderBy becomes sorted(), which returns a new list, while list.sort() sorts in place. The argument to any and all above is a generator expression — a comprehension in parentheses, evaluated lazily, which is why any can stop at the first match.

Iterator Function ... Yield becomes a plain def containing yield — the presence of yield is what makes it a generator, so there is no Iterator keyword to write. Both suspend at the yield and resume where they left off, so an infinite sequence is fine as long as the caller stops taking. Take(8) becomes itertools.islice(..., 8). Note the Python column also swaps two variables in one line, previous, current = current, previous + current, which is tuple packing and unpacking doing the work of a temporary.

Writing a function's name without parentheses gives you the function itself; adding parentheses calls it. There is no AddressOf and no delegate type to declare, so a dictionary of functions is just a dictionary. This is also the idiomatic replacement for a long Select Case that dispatches to different behavior — build a table once and index it, rather than testing values in order.

A default value is evaluated once, when the function is defined — not on each call. So target=[] creates one list that every call without an argument shares, and it accumulates. Visual Basic cannot hit this because an Optional parameter's default must be a compile-time constant, so it can never be a list. The fix is the idiom shown: default to None and build the real value inside. Treat any mutable default — list, dictionary, set — as a bug.

Python's is is identity comparison, the same as Visual Basic's Is, and == is value comparison, the same as Visual Basic's = on strings. The trap is that small integers and short strings are often interned — reused rather than recreated — so a is b can be True for two separately computed values and then quietly become False when the numbers get larger. Never use is to compare values. Use it only against None, True and False, which really are single objects.

Python has no constant declaration. The convention is UPPER_SNAKE_CASE, which every Python programmer reads as "do not reassign this", and which some type checkers will enforce if you annotate it as Final. But at runtime it is an ordinary variable. The same is true of privacy: a leading underscore means "internal, do not touch", and nothing prevents touching it. Python's stance throughout is that the language states intent and trusts the programmer, where .NET has the compiler enforce it.

Dim slots(5) is six slots because the number is the upper bound; [0] * 5 is five because the number is the count. UBound becomes len(x) - 1, and LBound is always 0. What is genuinely new is that you rarely need either: slots[-1] is the last element directly, and for item in slots avoids indexing altogether. If you are carrying VB6 habits, note that Option Base 1 has no equivalent in .NET or Python, and the 1-based Mid/InStr family has none here either.

Python compiles a file only far enough to check its syntax. A misspelled name, a call with the wrong number of arguments, an attribute that does not exist — all of these are found when the line executes, and a branch that never runs is never checked. There is no Option Strict, no Option Explicit and no compiler to lean on. What replaces them is discipline the language does not enforce for you: tests that exercise every branch, type hints checked by mypy or pyright, and a linter such as ruff in the editor. Set those up on day one rather than after the first production surprise.

My.Computer.Name is platform.node(), My.Computer.FileSystem is pathlib and shutil, IsNumeric is str.isdigit() or a try: float(x), Now is datetime.datetime.now(), and MsgBox/InputBox have no equivalent in a script at all — the console, or a real UI library, replaces them. For the VBA reader the biggest one is the Excel object model: openpyxl reads and writes workbooks directly, and pandas reads a sheet into a table you can work on without looping over cells.