Saves Valuable Time
Trusted Accuracy Since 2004
15-Day Money-Back Guarantee

Contact Testimonials Purchase Download Converters

VB and Python Equivalents

Abstract Methods

The closest thing in Python to an abstract method is an empty method:

VB	Python
Public MustInherit Class AbstractClass Public MustOverride Sub abstractMethod() End Class	class AbstractClass: def abstractMethod(self): pass

Arrays

You can convert VB arrays to Python's 'list'.

Unsized Array

VB	Python
Dim myArray() As Integer	myArray = []

Sized Array

VB	Python
Dim myArray(1) As Integer	myArray = [0 for _ in range(2)]

Access Array Element

VB	Python
x = myArray(0)	x = myArray[0]

Jagged Array

VB	Python
Dim myArray()() As Single = { New Single() {x, y} }	myArray = [[x, y]]

Rectangular Array

VB	Python
Dim myArray()() As Integer = { New Integer() {10, 20, 30, 40}, New Integer() {50, 60, 70, 80, 90, 100}, New Integer() {110, 120} }	myArray = [[10, 20, 30, 40], [50, 60, 70, 80, 90, 100], [110, 120]]

'ByRef' Parameters

Python does not support VB-style 'ByRef' parameters. All Python parameters are passed by value (if it's a reference, then the reference is passed by value). However, you can wrap the parameter type in another type (we call it 'RefObject').

Here's a simple example:

VB:

Public Sub refParamMethod(ByRef i As Integer)
    i = 1
End Sub

Public Sub callRefParamMethod()
    Dim i As Integer = 0
    refParamMethod(i)
End Sub

Python:

def refParamMethod(self, i):
    i.arg_value = 1

def callRefParamMethod(self):
    i = 0
    temp_ref_i = RefObject(i)
    self.refParamMethod(temp_ref_i)
    i = temp_ref_i.arg_value

# ----------------------------------------------------------------------------------------
# Copyright © 2023 Tangible Software Solutions, Inc.
# This class can be used by anyone provided that the copyright notice remains intact.
#
# This class is used to replicate the ability to have 'ByRef' parameters in Python.
# ----------------------------------------------------------------------------------------
class RefObject:
    def __init__(self, ref_arg):
        self.arg_value = ref_arg

Casting

VB	Python
Sub casts() x = CInt(y) x = CSng(y) x = CStr(y) End Sub	def casts(self): x = int(y) x = float(y) x = str(y)

Collections

Lists

VB's System.Collections.Generic.List collection and Python's 'list' are very close equivalents.

VB	Python
Sub Lists() Dim myList As New List(Of Integer)() myList.Add(1) myList.Insert(1, 2) Dim i As Integer = 1 myList(0) = i i = myList(0) End Sub	def arrayLists(self): myList = [] myList.append(1) myList.insert(1, 2) i = 1 myList[0] = i i = myList[0]

Dictionaries

VB's System.Collections.Generic.Dictionary collection and Python's 'dict' are very close equivalents.

VB	Python
Sub Dictionaries() Dim map As New Dictionary(Of String, Integer)() Dim s As String = "test" map(s) = 1 Dim i As Integer = map(s) i = map.Count Dim b As Boolean = map.Count = 0 map.Remove(s) End Sub	def hashMaps(self): map = {} s = "test" map[s] = 1 i = map[s] i = len(map) b = not map map.pop(s)

Comments

Python has a single comment format, starting with the '#' symbol. Multiline comments can also be created using triple quoted multiline strings.

VB	Python
' single-line comment foo() ' end-of-line comment ' comment ' over multiple lines	# single-line comment foo() # end-of-line comment # comment # over multiple lines # using multiline strings to simulate multiline comments: """ comment over multiple lines"""

Constants, Fields, and Local Variables

Local Variable

VB	Python
Dim myVar As Integer = 2	myVar = 2 # Python infers the type

Inferred Types

Inferred typing is available in VB, but Python always infers the type:

VB	Python
Option Infer On Dim myVar = 2	myVar = 2

Static Field

In Python, static fields are initialized at the class level:

VB	Python
Class FooClass Public Shared staticField As Integer = 7 End Class	class FooClass: staticField = 7

Instance Field

In Python, instance fields are not listed at the class level and are qualified with the instance object, given by the first instance method parameter (usually named 'self' by convention):

VB	Python
Class FooClass Public instanceField As Integer = 2 End Class	class FooClass: def __init__(self): self.instanceField = 2

Local Constant

VB	Python
Const myConst As Integer = 2	MY_CONST = 2 # at method level - up to programmers to respect the naming convention and avoid changing it

Class Constant

VB	Python
Public Const myConst As Integer = 2	MY_CONST = 2 # at class level - up to programmers to respect the naming convention and avoid changing it

Constructors

Python constructors are named __init__, but a serious shortcoming of Python is the restriction of allowing only one constructor per class.

VB	Python
Class Foo Public Sub New() End Sub End Class	class Foo: def __init__(self): pass

Default Parameters

Python and VB both allow default or optional parameters.

VB	Python
Public Sub defaultParam(Optional ByVal param As Integer = 0) ... End Sub	def defaultParam(self, param=0): ...

Delegates

Since methods are first class objects in Python delegates are converted easily:

VB	Python
Public Class Test Public Delegate Sub FooDelegate(ByVal arg As Integer) Public Shared Sub static_method(ByVal p As Integer) Console.WriteLine("static_method called with arg " & p) End Sub Public Sub instance_method(ByVal p As Integer) Console.WriteLine("instance_method called with arg " & p) End Sub Public Sub method() Dim f1 As New FooDelegate(AddressOf static_method) f1(1) Dim f2 As FooDelegate = AddressOf instance_method f2(2) Dim f3 As FooDelegate = Sub(i As Integer) instance_method(i) f3(3) End Sub End Class	class Test: class FooDelegate: def __init__(self, method, instance): self._method = method self._instance = instance def invoke(self, arg): if self._instance is None: self._method(arg) else: self._method(self._instance, arg) @staticmethod def static_method(p): print("static_method called with arg " + str(p)) def instance_method(self, p): print("instance_method called with arg " + str(p)) def method(self): f1 = Test.FooDelegate(Test.static_method, None) f1.invoke(1) f2 = Test.FooDelegate(Test.instance_method, self) f2.invoke(2) f3 = Test.FooDelegate(lambda i : self.instance_method(i), None) f3.invoke(3)

Python

Public Class Test
    Public Delegate Sub FooDelegate(ByVal arg As Integer)

    Public Shared Sub static_method(ByVal p As Integer)
        Console.WriteLine("static_method called with arg " & p)
    End Sub

    Public Sub instance_method(ByVal p As Integer)
        Console.WriteLine("instance_method called with arg " & p)
    End Sub

    Public Sub method()
        Dim f1 As New FooDelegate(AddressOf static_method)
        f1(1)

        Dim f2 As FooDelegate = AddressOf instance_method
        f2(2)

        Dim f3 As FooDelegate = Sub(i As Integer) instance_method(i)
        f3(3)
    End Sub
End Class

class Test:
    class FooDelegate:
        def __init__(self, method, instance):
            self._method = method
            self._instance = instance

        def invoke(self, arg):
            if self._instance is None:
                self._method(arg)
            else:
                self._method(self._instance, arg)

    @staticmethod
    def static_method(p):
        print("static_method called with arg " + str(p))

    def instance_method(self, p):
        print("instance_method called with arg " + str(p))

    def method(self):
        f1 = Test.FooDelegate(Test.static_method, None)
        f1.invoke(1)

        f2 = Test.FooDelegate(Test.instance_method, self)
        f2.invoke(2)

        f3 = Test.FooDelegate(lambda i : self.instance_method(i), None)
        f3.invoke(3)

Enums

Enums in VB have equivalents in Python using the 'enum' module:

VB	Python
Public Enum Simple Foo Bar End Enum	from enum import Enum class Simple(Enum): FOO = 0 BAR = 1

Equality

......

VB	Python
' value equality with primitives: Dim i As Integer = 1 Dim j As Integer = 1 Dim valuesIdentical As Boolean = i = j ' identity equality with class types: Dim f As New Foo() Dim g As Foo = f Dim objectsIdentical As Boolean = f = g ' strings: Dim s1 As String = "abc" Dim s2 As String = s1 valuesIdentical = s1 = s2 ' caution: VB string internment often ' makes this true whenever '==' is true: objectsIdentical = string.ReferenceEquals(s1, s2)	# value equality: i = 1 j = 1 valuesIdentical = i == j # identity equality f = Foo() g = f objectsIdentical = f is g # strings: s1 = "abc" s2 = s1 valuesIdentical = s1 == s2 # caution: Python string internment often # makes this true whenever '==' is true: objectsIdentical = s1 is s2

Python

' value equality with primitives:
Dim i As Integer = 1
Dim j As Integer = 1
Dim valuesIdentical As Boolean = i = j

' identity equality with class types:
Dim f As New Foo()
Dim g As Foo = f
Dim objectsIdentical As Boolean = f = g

' strings:
Dim s1 As String = "abc"
Dim s2 As String = s1
valuesIdentical = s1 = s2
' caution: VB string internment often
' makes this true whenever '==' is true:
objectsIdentical = string.ReferenceEquals(s1, s2)

# value equality:
i = 1
j = 1
valuesIdentical = i == j

# identity equality
f = Foo()
g = f
objectsIdentical = f is g

# strings:
s1 = "abc"
s2 = s1
valuesIdentical = s1 == s2
# caution: Python string internment often
# makes this true whenever '==' is true:
objectsIdentical = s1 is s2

Exception Handling

The Python try/except/finally scheme is equivalent to VB's Try/Catch/Finally:

VB	Python
Sub exceptionHandling() Try Catch f As Foo Throw f Catch e As Bar Throw New Bar() Finally End Try End Sub	def exceptionHandling(self): try: pass except Foo as f: raise f except Bar as e: raise Bar() finally: pass

Extension Methods

Python doesn't have extension methods, so a VB extension method is just converted to an ordinary Python static method (calls to the method have to be adjusted to static calls using the class name).

VB	Python
Public Module ContainsExtension <System.Runtime.CompilerServices.Extension> _ Public Sub ExtensionMethod(ByVal myParam As String) ' ... End Sub End Module Class TestClass Sub TestMethod() Dim s As String = "abc" s.ExtensionMethod() End Sub End Class	class ContainsExtension: @staticmethod def ExtensionMethod(myParam): # ... pass class TestClass: def _TestMethod(self): s = "abc" ContainsExtension.ExtensionMethod(s)

If-Else

VB	Python
If conditionA Then ElseIf conditionB Then Else End If	if conditionA: pass elif conditionB: pass else: pass

If Conditional Operator

VB	Python
result = If(condition, truePart, falsePart)	result = truePart if condition else falsePart

Indexers

Python does not have indexers, so you must use get/set methods instead:

VB	Python
Default Public Property Item(ByVal index As Integer) As Integer Get Return field(index) End Get Set(ByVal value As Integer) field(index) = value End Set End Property	def get(self, index): return field[index] def set(self, index, value): field[index] = value

Inheritance

VB	Python
Public Class one Protected baseField As Integer = 1 Public Sub New(ByVal i As Integer) End Sub Public Overridable Sub baseMethod() End Sub End Class Public Class two Inherits one Public Sub New() MyBase.New(0) End Sub Public Sub method() MyBase.baseField = 2 MyBase.baseMethod() End Sub End Class	class one: def __init__(self, i): self.baseField = 1 def baseMethod(self): pass class two(one): def __init__(self): super().__init__(0) def method(self): self.baseField = 2 super().baseMethod()

Interfaces

Defining Interfaces

Interfaces in Python are just classes with empty methods:

VB	Python
Public Interface IFooInterface Sub method() End Interface	class IFooInterface: def method(self): pass

Implementing Interfaces

VB	Python
Public Class Foo Implements IFooInterface Public Sub method() ... some code End Sub End Class	class Foo(IFooInterface): def method(self): ... some code

Lambdas

Expression Lambda

VB	Python
myVar = Function(text As String) text.Length	myVar = lambda text : len(text)

Multi-statement Lambda

VB	Python
myVar = Sub(param1 As Foo, param2 As Bar) ' ...multiple statements End Sub	No direct Python equivalent

Logical and Bitwise Operators

VB	Python
Dim x As Boolean = y AndAlso z x = y OrElse z x = Not y Dim i As Integer = j Or k i = j And k i = j Xor k	x = y and z x = y or z x = not y i = j \| k i = j & k i = j ^ k

Loops

For Loop

VB.NET	Python
For i As Integer = 1 To 9 Next i	for i in range(1, 10): pass

For Each Loop

VB.NET	Python
For Each s As String In StringList Next S	for s in StringList: pass

While Loop

VB.NET	Python
Do While condition Loop or: While condition End While	while condition: pass

Do While Loop

VB.NET	Python
Do Loop While condition	loop_condition = True while loop_condition: loop_condition = condition

Loop Until

VB.NET	Python (no specific 'loop until' construct)
Do Loop Until condition	loop_condition = True while loop_condition: loop_condition = not(condition)

Do Until

VB.NET	Python (no specific 'do until' construct)
Do Until condition Loop	while not(condition): pass

Math

VB	Python
Sub exponentiation() x = y ^ z ' or: x = Math.Pow(y, z) End Sub Sub integerDivision() ' VB integer division always rounds towards 0: Dim i As Integer = -5 Dim j As Integer = 2 Dim result As Integer = i \ j ' result is -2 End Sub Sub modulusOperator() ' VB 'Mod' operator and Python '%' operator are only equivalent for positive numbers: Dim i As Integer = 2 Dim j As Integer = -3 Dim result As Integer = i Mod j ' result is 2 End Sub Sub otherMathOperations() x = Math.Abs(y) ' see the System.Math class for many more functions: x = Math.Cos(y) x = Math.E x = Math.PI End Sub	import math def exponentiation(self): x = y ** z def integerDivision(self): i = -5 j = 2 result = math.trunc(i / float(j)) # result is -2 # Python integer division rounds away from 0 when negative: result = i / j # result is -3 def modulusOperator(self): i = 2 j = -3 result = math.fmod(i, j) # result is 2 # Python modulus operator produces a different result: result = i % j # result is -1 def otherMathOperations(self): x = abs(y) # 'abs' is a built-in Python function # see the Python 'math' module for many more functions: x = math.cos(y) x = math.e x = math.pi

Python

Sub exponentiation()
    x = y ^ z
    ' or:
    x = Math.Pow(y, z)
End Sub

Sub integerDivision()
    ' VB integer division always rounds towards 0:
    Dim i As Integer = -5
    Dim j As Integer = 2
    Dim result As Integer = i \ j   ' result is -2
End Sub

Sub modulusOperator()
    ' VB 'Mod' operator and Python '%' operator are only equivalent for positive numbers:
    Dim i As Integer = 2
    Dim j As Integer = -3
    Dim result As Integer = i Mod j   ' result is 2
End Sub

Sub otherMathOperations()
    x = Math.Abs(y)

    ' see the System.Math class for many more functions:
    x = Math.Cos(y)
    x = Math.E
    x = Math.PI
End Sub

import math

def exponentiation(self):
    x = y ** z

def integerDivision(self):
    i = -5
    j = 2
    result = math.trunc(i / float(j))   # result is -2

    # Python integer division rounds away from 0 when negative:
    result = i / j   # result is -3

def modulusOperator(self):
    i = 2
    j = -3
    result = math.fmod(i, j)   # result is 2

    # Python modulus operator produces a different result:
    result = i % j   # result is -1

def otherMathOperations(self):
    x = abs(y)   # 'abs' is a built-in Python function

    # see the Python 'math' module for many more functions:
    x = math.cos(y)
    x = math.e
    x = math.pi

Methods - Instance vs Static

Python instance methods have a first parameter indicating the instance ('self' is the convention for this parameter and not a keyword), and static methods have the '@staticmethod' decorator.

VB	Python
Public Sub instanceMethod() End Sub Public Shared Sub staticMethod() End Sub	def instanceMethod(self): pass @staticmethod def staticMethod(): pass

Multiline Strings

VB	Python
Dim s As String = "multiline string"	s = """multiline string"""

Operator Overloading

VB	Python
Public Class SomeType Private IntValue As Integer = 1 Public Shared Operator +(ByVal X As SomeType, ByVal Y As SomeType) As Integer Return X.IntValue + Y.IntValue End Operator Public Sub OperatorTest() Dim o As New SomeType() Dim p As New SomeType() i = o + p End Sub End Class	class SomeType: def __init__(self): self._IntValue = 1 @staticmethod def op_add(X, Y): return X._IntValue + Y._IntValue def OperatorTest(self): o = SomeType() p = SomeType() i = SomeType.op_add(o, p)

Parameter Arrays

VB	Python
Private Sub method(ParamArray ByVal args() As String) For Each x As String In args ... logic for each item in args Next x End Sub	def method(self, *args): for x in args: ... logic for each item in args

Properties

Python does not have properties, so you must use get/set methods instead:

VB	Python
Public Property IntProperty() As Integer Get Return intField End Get Set(ByVal value As Integer) intField = value End Set End Property	def get_int_property(self): return intField def set_int_property(self, value): intField = value

Select Case

Python 3.10 has 'match' syntax, but if/elif/else is used prior to Python 3.10.

VB	Python
Select Case pivot Case 1 foo() Case 2, 3 bar() Case 4 Case Else ack() End Select	Python 3.10: match pivot: case 1: foo() case 2 \| 3: bar() case 4: pass case other: ack() Prior to Python 3.10: if pivot == 1: foo() elif pivot == 2 or pivot == 3: bar() elif pivot == 4: pass else: ack()

Static Constructors

VB static constructors and Python code at the class level serve the same purpose.

VB	Python
Class Foo Public Shared field As Integer Shared Sub New() ... logic to set 'field' value End Sub End Class	class Foo: field = 0 ... logic to set 'field' value

Strings

VB	Python
Dim s As String = initValue Dim i As Integer = s.IndexOf(y) i = s.LastIndexOf(y) i = s.Length Dim b As Boolean = s.Contains(y) s = s.Substring(i) s = s.Substring(i, j) b = s.EndsWith(y) b = s.StartsWith(y) s = s.ToLower() s = s.ToUpper() s = s.TrimStart() s = s.TrimEnd()	s = initValue i = s.find(y) i = s.rfind(y) i = len(s) b = y in s s = s[i:] s = s[i:i + j] b = s.endswith(y) b = s.startswith(y) s = s.casefold() s = s.upper() s = s.lstrip() s = s.rstrip()

Type Discovery

VB	Python
' checking if 'f' is an instance of type 'Foo': Dim b As Boolean = TypeOf f Is Foo	# checking if 'f' is an instance of type 'Foo': b = isinstance(f, Foo)

VB 'Imports' Directive vs Python 'import'

VB	Python
Imports FooNamespace ' type import with alias matching type name: Imports FooClass = FooNamespace.FooClass ' namespace alias: Imports fooalias = FooNamespace ' type import: Imports FooNamespace.BarClass	from FooNamespace import * from FooNamespace import FooClass * no equivalent to type or namespace aliases * * no equivalent to VB type imports without alias matching type name *

VB Legacy String Functions

VB.NET	Python (omitting null handling)
x = LCase(x) x = UCase(x) x = Left(x, 2) x = Right(x, 2) x = Mid(x, 3) i = InStr(x, y) i = InStrRev(x, y)	x = x.casefold() x = x.upper() x = x[0:2] x = x[len(x) - 2:] x = x[2:] i = x.find(y) + 1 i = x.rfind(y) + 1

VB Legacy Type Suffixes

VB.NET	Python
Dim myIntegerVar% Dim myStringVar$ Dim myFloatVar! Dim myDoubleVar#	myIntegerVar = 0 myStringVar = None myFloatVar = 0 myDoubleVar = 0

VB 'Using' Statement vs Python 'with'

VB	Python
Using foo As New FooType() ... End Using	with FooType() as foo: ...

Testimonials | Support | Uninstall Instructions | FAQ

Questions? Email Us | Facebook