ahmedelgabri/VimScriptForPythonDevelopers.MD

## VimScriptForPythonDevelopers.MD

      
      Raw
    
  
              VimScriptForPythonDevelopers.MD
            
          
    Vim Script for Python Developers
A guide to Vim Script development for Python developers. Sample code for the various expressions, statements, functions and programming constructs is shown in both Python and Vim Script. This is not intended to be a tutorial for developing Vim scripts. It is assumed that the reader is familiar with programming in Python.
For an introduction to Vim Script development, refer to usr_41.txt, eval.txt and Learn Vimscript the Hard Way
For a similar guide for JavaScript developers, refer to Vim Script for the JavaScripter
This guide only describes the programming constructs that are present in both Python and Vim. The constructs that are unique to Vim (e.g. autocommands, key-mapping, abbreviations, user-commands, plugins, etc.) are not described in this guide.
Some of the features described in this guide are available are only in recent versions of Vim (8.1).

Variables
Creating a Variable
Python:
i = 10
pi = 3.1415
str = "Hello"
a, b, s = 10, 20, "sky"
VimScript:
let i = 10
let pi = 3.1415
let str = "Hello"
let [a, b, s] = [10, 20, "sky"]
Help: variables
Deleting a Variable
Python:
del str
VimScript:
unlet str
Help: :unlet
Here Document
Assigning multi-line values to a variable.
Python:
i = """
    one
    two
    three
"""
i = i.strip().split()
VimScript:
let i =<< trim END
    one
    two
    three
END
Help: :let-heredoc
Print an expression
Python:
print("Hello World\n")
s = "vim"
print("Editor = %s" % (s))
VimScript:
echo "Hello World"
let s = "vim"
echo "Editor = " .. s
Help: :echo

Arithmetic Operators
Python:
a = 10 + 20
a = 30 - 10
a = 3 * 5
a = 22 / 7
a += 1
a -= 2
a *= 4
a /= 2
a = 10 % 3
a = 2 ** 3
a = 10 // 3
VimScript:
let a = 10 + 20
let a = 30 - 10
let a = 3 * 5
let a = 22 / 7
let a += 1
let a -= 2
let a *= 4
let a /= 2
let a = 10 % 3
let a = float2nr(pow(2, 3))
let a = floor(10 / 3.0)
Help: expr5

Comparison Operators
Python:
a > b
a < b
a == b
a != b
a >= b
a <= b
VimScript:
a > b
a < b
a == b
a != b
a >= b
a <= b
Help: expr4

Logical Operators
Python:
x and y
x or y
not x
VimScript:
x && y
x || y
!x
Help: expr2

Bitwise Operators
Python:
c = a & b
c = a | b
c = ~a
c = x ^ y
VimScript:
let c = and(a, b)
let c = or(a, b)
let c = invert(a)
let c = xor(a, b)
Help: and(), or(), invert(), xor()

String
Vim has functions for dealing with both multibyte and non-multibyte strings. Some functions deal with bytes and some functions deal with characters. Refer to the reference guide for the various functions to get the detailed information.
Raw string
Python:
s1 = r"one\ntwo\n"
s2 = "one\ntwo\n"
VimScript:
let s1 = 'one\ntwo\n'
let s2 = "one\ntwo\n"
Help: literal-string, string
Finding string length
Python:
n = len("Hello World")
VimScript:
let n = len("Hello World")
let n = strlen("Hello World")
Help: len(), strlen(), strwidth(), strdisplaywidth()
String Concatenation
Python:
str1 = "blue"
str2 = "sky"
s = str1 + str2
VimScript:
let str1 = "blue"
let str2 = "sky"
let s = str1 .. str2
Help: expr-..
Getting a substring
In Python, when using an index range to specify a sequence of characters in a string, the character at the end index is not included. In Vim, the character at the end index is included.
Python:
str = "HelloWorld"
sub = str[2:5]
VimScript:
let str = "HelloWorld"
let sub = str[2:4]
let sub = strpart(str, 2, 3)
Help: expr-[:], strpart()
Counting the occurrences of a substring
Python:
str = "Hello World"
c = str.count("l")
VimScript:
let str = "Hello World"
let c = str->count("l")
Help: count()
Checking whether a substring is present
Python:
str = "running"
idx = str.find("nn")
idx = str.rfind("ing")
VimScript:
let str = "running"
let idx = str->stridx("nn")
let idx = str->strridx("ing")
endif
Help: stridx(), strridx()
Checking whether a string starts with or ends with a substring
Python:
str = "running"
if str.startswith("run"):
    print("starts with run")
if str.endswith("ing"):
    print("ends with ing")
VimScript:
let str = "running"
if str =~# "^ing"
    echo "starts with ing"
if str =~# "ing$"
    echo "ends with ing"
endif
Help: expr-=~#
Merging strings in a List with a separator
Python:
s = ":".join(['a', 'b', 'c'])
VimScript:
let s = join(['a', 'b', 'c'], ':')
Help: join()
Changing the case of letters in a string
Python:
s = "Hello World"
l = s.lower()
l = s.upper()
VimScript:
let s = "Hello World"
let l = s->tolower()
let l = s->toupper()
Help: tolower(), toupper()
Replace a substring
Python:
s = "Hello World"
s2 = s.replace("Hello", "New")
VimScript:
let s = "Hello World"
let s2 = s->substitute("Hello", "New", 'g')
Help: substitute()
Split a string
Python:
s = "a:b:c"
s2 = s.split(":")
VimScript:
let s = "a:b:c"
let s2 = s->split(":")
Help: split(), join(),
Stripping leading and trailing whitespace from a string
Python:
s = "  vim  "
s2 = s.strip()
VimScript:
let s = "  vim  "
let s2 = s->trim()
Help: trim()
Checking whether a string contains specific type of characters
Python:
s = "text"
if s.isalnum():
    print("Contains only alphanumeric characters")
if s.isalpha():
    print("Contains only alphabetic characters")
if s.isdigit():
    print("Contains only digits")
if s.isspace():
    print("Contains only whitespace characters")
if s.isupper():
    print("Contains only uppercase characters")
if s.islower():
    print("Contains only lowercase characters")
VimScript:
let s = "text"
if s =~ '^[:alnum:]\+'
    echo "Contains only alphanumeric characters"
endif
if s =~ '^\a\+$'
    echo "Contains only alphabetic characters"
endif
if s =~ '^\d\+$'
    echo "Contains only digits"
endif
if s =~ '^\s\+$'
    echo "Contains only whitespace characters"
endif
if s =~ '^\u\+$'
    echo "Contains only uppercase characters"
endif
if s =~ '^\l\+$'
    echo "Contains only lowercase characters"
endif
Help: /collection
Data type conversion to string
Python:
s = str(268)
s = str(22.7)
s = str([1, 2, 3])
s = str({'a' : 1, 'b' : 2})
VimScript:
let s = string(268)
let s = string(22.7)
let s = string([1, 2, 3])
let s = string({'a' : 1, 'b' : 2})
Help: string()

List
Creating a List
Python:
l = [1, 2, 3, 4]
VimScript:
let l = [1, 2, 3, 4]
Help: List
Accessing a List element
Python:
l = [1, 2, 3, 4]
v1 = l[2]
v2 = l[-2]
VimScript:
let l = [1, 2, 3, 4]
let v1 = l[2]
let v2 = l[-2]
Help: list-index
Changing the value of a List element
Python:
l = [1, 2, 3, 4]
l[3] = 5
VimScript:
let l = [1, 2, 3, 4]
let l[3] = 5
Help: list-modification
Adding an item to a List
Python:
l = []
l.append(5)
l += [6, 7]
VimScript:
let l = []
call add(l, 5)
let l += [5, 6]
Help: add()
Extending a List using a List
Python:
l = []
l.extend([2, 3])
l += [6, 7]
VimScript:
let l = []
call extend(l, [2, 3])
let l += [6, 7]
Help: extend()
Inserting an item in a List
Python:
l = [1, 3]
l.insert(1, 2)
VimScript:
let l = [1, 3]
call insert(l, 2, 1)
Help: insert()
Removing an item from a List
Python:
l = [4, 5, 6]
l.remove(5)
del l[0]
VimScript:
let l = [4, 5, 6]
call remove(l, index(l, 5))
unlet l[0]
Help: remove(), :unlet
Removing the last element from a List
Python:
l = [1, 2, 3]
v = l.pop()
VimScript:
let l = [1, 2, 3]
let v = l->remove(-1)
Help: remove()
Find the index of an item in a List
Python:
l = [1, 2, 3]
x = l.index(2)
VimScript:
let l = [1, 2, 3]
let x = l->index(2)
Help: index()
List slices
In Python, when using an index range to specify a series of items in a List, the item at the end index is not included. In Vim, the item at the end index is included.
Python:
l = [1, 2, 3, 4]
m = l[1:3]
m = l[2:]
VimScript:
let l = [1, 2, 3, 4]
let m = l[1:3]
let m = l[2:]
Help: sublist
List Concatenation
Python:
l = [1, 2] + [3 ,4]
VimScript:
let l = [1, 2] + [3 ,4]
Help: list-index
Adding multiple items to a List using repetition
Python:
l = ['vim'] * 4
VimScript:
let l = ['vim']->repeat(4)
Help: repeat()
Count the number of occurrences of an item in a List
Python:
l = [2, 4, 4, 5]
x = l.count(4)
VimScript:
let l = [2, 4, 4, 5]
let x = l->count(2)
Help: count()
Finding the List length
Python:
l = ['a', 'b', 'c']
n = len(l)
VimScript:
let l = ['a', 'b', 'c']
let n = l->len()
Help: len()
Sort a List
Python:
l = [3, 2, 1]
l.sort()
VimScript:
let l = [3, 2, 1]
call sort(l)
Help: sort()
Reverse a List
Python:
l = [1, 2, 3]
l.reverse()
VimScript:
let l = [1, 2, 3]
call reverse(l)
Help: reverse()
Copy a List
Python:
l = [3, 2, 1]
l2 = l.copy()
VimScript:
let l = [3, 2, 1]
let l2 = l->copy()
Help: copy()
Empty a List
Python:
l = [3, 2, 1]
l.clear()
VimScript:
let l = [3, 2, 1]
unlet l[:]
Help: :unlet
Comparing two Lists
Python:
l1 = [1, 2]
l2 = [1, 2]
if l1 == l2:
    print("Lists are equal")
VimScript:
let l1 = [1, 2]
let l2 = [1, 2]
if l1 == l2
    echo "Lists are equal"
endif
Help: list-identity
Filter selected elements from a List
Python:
odd = filter(lambda x: x %2, range(10))
VimScript:
let odd = filter(range(10), {idx, v -> v % 2})
Help: filter()
Map List elements
Python:
num_str = map(lambda x: str(x), range(10))
VimScript:
let num_str = map(range(10), {idx, v -> string(v)})
Help: map()
Finding the max/min value in a List
Python:
n = max([3, 10, 8])
n = min([3, 10, 8])
VimScript:
let n = max([3, 10, 8])
let n = min([3, 10, 8])
Help: max(), min()
Converting a List to a string
Python:
s = str([3, 5, 7])
VimScript:
let s = string([3, 5, 7])
Help: string()

Dictionary
Creating a Dict
Python:
d = {'red' : 10, 'blue' : 20}
x = {}
VimScript:
let d = {'red' : 10, 'blue' : 20}
let x = {}
Help: Dict
Retrieving the value of a Dict item
Python:
d = {'red' : 10, 'blue' : 20}
x = d['red']
VimScript:
let d = {'red' : 10, 'blue' : 20}
let x = d['red']
let x = d.red
Help: dict
Changing the value of a Dict item
Python:
d = {'red' : 10, 'blue' : 20}
d['red'] = 15
VimScript:
let d = {'red' : 10, 'blue' : 20}
let d.red = 15
Help: dict-modification
Accessing a Dict item
Python:
d = {'red' : 10, 'blue' : 20}
v = d.get('red')
VimScript:
let d = {'red' : 10, 'blue' : 20}
let v = get(d, 'red')
Help: get()
Adding a new Dict item
Python:
d = {'red' : 10, 'blue' : 20}
d['green'] = 30
VimScript:
let d = {'red' : 10, 'blue' : 20}
let d.green = 30
Help: dict-modification
Removing a Dict item
Python:
d = {'red' : 10, 'blue' : 20}
d.pop('red')
VimScript:
let d = {'red' : 10, 'blue' : 20}
call remove(d, 'red')
Help: remove(),
Clearing all the  items from a Dict
Python:
d = {'red' : 10, 'blue' : 20}
d.clear()
VimScript:
let d = {'red' : 10, 'blue' : 20}
call filter(d, "0")
Help: dict-modification
Getting the size of a Dict
Python:
d = {'red' : 10, 'blue' : 20}
n = len(d)
VimScript:
let d = {'red' : 10, 'blue' : 20}
let n = d->len()
Help: len()
Checking Dict membership
Python:
d = {'red' : 10, 'blue' : 20}
if 'red' in d:
    print("found red key")
VimScript:
let d = {'red' : 10, 'blue' : 20}
if d->has_key('red')
    echo "found red key"
endif
Help: has_key()
Iterating through all the keys in a Dict
Python:
d = {'red' : 10, 'blue' : 20}
for k in d:
    print(k)
for k in d:
    print(d[k])
VimScript:
let d = {'red' : 10, 'blue' : 20}
for k in keys(d)
    echo k
endfor
for k in d->keys()
    echo d[k]
endfor
Help: keys()
Iterating through all the values in a Dict
Python:
d = {'red' : 10, 'blue' : 20}
for v in d.values():
    print(v)
VimScript:
let d = {'red' : 10, 'blue' : 20}
for v in d->values()
    echo v
endfor
Help: values()
Iterating through all the key, value pairs in a Dict
Python:
d = {'red' : 10, 'blue' : 20}
for k, v in d.items():
    print(k, v)
VimScript:
let d = {'red' : 10, 'blue' : 20}
for [k, v] in d->items()
    echo k v
endfor
Help: items()
Copying a Dict
Python:
d = {'red' : 10, 'blue' : 20}
new_d = d.copy()
VimScript:
let d = {'red' : 10, 'blue' : 20}
let new_d = d->copy()
Help: copy()
Converting a Dict to a string
Python:
d = str({'a' : 1, 'b' : 2})
VimScript:
let d = string({'a' : 1, 'b' : 2})
Help: string()
Comparing two Dicts
Python:
d1 = {'a' : 10, 'b' : 20}
d2 = {'a' : 10, 'b' : 20}
if d1 == d2:
    print("Dicts are equal")
VimScript:
let d1 = {'a' : 10, 'b' : 20}
let d2 = {'a' : 10, 'b' : 20}
if d1 == d2
    echo "Dicts are equal"
endif
Help: dict-identity

If statement
Basic If statement
Python:
if a > b:
    print("a is greater than b")
VimScript:
if a > b
    echo "a is greater than b"
endif
Help: :if
If-else statement
Python:
if a > b:
    print("a is greater than b")
else:
    print("a is less than or equal to b")
VimScript:
if a > b
    echo "a is greater than b"
else
    echo "a is less than or equal to b"
endif
Help: :else
If-elseif statement
Python:
if a > b:
    print("a is greater than b")
elif a < b:
    print("a is less than b")
else:
    print("a is equal to b")
VimScript:
if a > b
    echo "a is greater than b"
elseif a < b
    echo "a is less than b"
else
    echo "a is equal to b"
endif
Help: :elseif
Checking multiple conditions
Python:
if a > b and (a > c or a > d):
    print "a is greater than b and greater than c or d"
VimScript:
if a > b && (a > c || a > d)
    echo "a is greater than b and greater than c or d"
endif
Help: expr2
Nested If statements
Python:
if status == True:
    if a >= 1:
	print("Nested if")
VimScript:
if status == v:true
    if a >= 1
	echo "Nested if"
    endif
endif
Help: :if

For Loop
Python:
for i in range(5) :
    print(i)
VimScript:
for i in range(5)
    echo i
endfor
Help: :for
Breaking out of a For loop
Python:
for i in ['a', 'b', 'c']:
    if i == 'b':
        break
    print(i)
VimScript:
for i in ['a', 'b', 'c']
    if i == 'b'
        break
    endif
    echo i
endfor
Help: :break
Continuing a For loop
Python:
for i in ['a', 'b', 'c']:
    if i == 'b':
        continue
    print(i)
VimScript:
for i in ['a', 'b', 'c']
    if i == 'b'
        continue
    endif
    echo i
endfor
Help: :continue
Nested For Loops
Python:
for i in range(10):
    for j in range(10):
	print(str(i) + 'x' + str(j) + '=' + str(i * j))
VimScript:
for i in range(4)
    for j in range(4)
	echo i .. 'x' .. j .. '=' .. i * j
    endfor
endfor
Help: :for

While Loop
Python:
i = 1
while i <= 5 :
   print(i)
   i += 1
VimScript:
let i = 1
while i <= 5
    echo i
    let i += 1
endwhile
Help: :while

Comments
Python:
# This is a python comment
i = 0    # First iteration
VimScript:
" This is a Vimscript comment
let i = 0    " First iteration
Help: :comment

Functions
The names of global functions in Vim must start with an uppercase letter.
The examples in this document use the "function" and "endfunction" keywords for
defining a function. But these can be abbreviated as "func" and "endfunc".
When a function encounters an error, it will continue to execute the rest of the function unless the "abort" argument is specified when defining the function. So it is recommended to specify the "abort" keyword at the end of the "function" line. To simplify the example code, this keyword is not used in this guide.
Defining a Function
Python:
def Min(x, y):
    return x if < y else y

print(Min(6, 3)
VimScript:
function Min(x, y) abort
    return a:x < a:y ? a:x : a:y
endfunction

echo Min(6, 3)
Help: user-functions
Calling a Function
Python:
def EchoValue(v):
    print(v)

EchoValue(100)
VimScript:
function EchoValue(v)
    echo a:v
endfunction

call EchoValue(100)
Help: :call
Function return value
Python:
def Sum(a, b):
    return a + b

s = Sum(10, 20)
VimScript:
function Sum(a, b)
    return a:a + a:b
endfunction

let s = Sum(10, 20)
Help: :return
Pass by reference
Python:
def AddValues(l):
    l.extend([1, 2, 3, 4])
VimScript:
function AddValues(l)
    call extend(a:l, [1, 2, 3, 4])
endfunction
Help: function-argument
Variable number of arguments
Python:
def Sum(v1, *args):
    sum = v1
    for i in *args:
	sum += i
    return sum
VimScript:
function Sum(v1, ...)
    let sum = a:v1
    for i in a:000
	let sum +=i
    endfor
    return sum
endfunction
let s1 = Sum(10, 20, 30, 40)
let s1 = Sum(10)
Help: a:000
Default value for arguments
Python:
def Powerof(base, exp = 2):
    return base ** exp
VimScript:
function PowerOf(base, exp = 2)
    return float2nr(pow(a:base, a:exp))
endfunction
let val = PowerOf(4)
let val = PowerOf(4, 3)
Help: optional-function-argument
Accessing global variables
Python:
counter = 1
def Incr():
    global counter
    counter += 1
VimScript:
let counter = 1
function Incr()
    let g:counter += 1
endfunction
cal Incr()
Help: global-variable
Function reference
Python:
def Foo():
    print("Foo")
Bar = Foo
Bar()
VimScript:
function Foo()
    echo "Foo"
endfunction
let Bar = function("Foo")
call Bar()
Help: Funcref

Lambda Function
Python:
F = lambda x , y: x - y
print(F(5,2))
VimScript:
let F = {x, y -> x - y}
echo F(5,2)
Help: lambda

Partial Function
Python:
import functools
def Mylog(subsys, msg):
    print("%s: %s" % (subsys, msg))

ErrLog = functools.partial(Mylog, 'ERR')
ErrLog("Failed to open file")
VimScript:
function Mylog(subsys, msg)
    echo printf("%s: %s", a:subsys, a:msg)
endfunction

let ErrLog = function('Mylog', ['ERR'])
call ErrLog("Failed to open file")
Help: Partial

Closures
Closure with a lambda function
Python:
def foo(arg):
  i = 3
  return lambda x: x + i - arg

bar = foo(4)
print(bar(6))
VimScript:
function Foo(arg)
  let i = 3
  return {x -> x + i - a:arg}
endfunction

let Bar = Foo(4)
echo Bar(6)
Help: closure
Closure with a function reference
Python:
def Foo(base):
    def Bar(val):
	return base + val
    return Bar

F = Foo(10)
print(F(2))
F = Foo(20)
print(F(2))
VimScript:
function Foo(base)
    function Bar(val) closure
	return a:base + a:val
    endfunction
    return funcref('Bar')
endfunction

let F = Foo(10)
echo F(2)
let F = Foo(20)
echo F(2)
Help: func-closure

Classes
Defining a class
Python:
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def setX(self, x):
        self.x = x

    def setY(self, y):
        self.y = y

    def Print(self):
        print("Pt = (" + str(self.x) + ", " + str(self.y) + ")")

pt = Point(10, 20)
pt.setX(40)
pt.setY(50)
pt.Print()
VimScript:
function s:new(x, y) dict
  let newpt = copy(self)
  let newpt.x = a:x
  let newpt.y = a:y
  return newpt
endfunction

function s:getX() dict
  return self.x
endfunction

function s:getY() dict
  return self.y
endfunction

function s:setX(x) dict
  let self.x = a:x
endfunction

function s:setY(y) dict
  let self.y = a:y
endfunction

function s:Print() dict
  echo "Pt = (" .. self.x .. ", " .. self.y .. ")"
endfunction

let Point = {}
let Point.new = function("s:new")
let Point.getX = function("s:getX")
let Point.getY = function("s:getY")
let Point.setX = function("s:setX")
let Point.setY = function("s:setY")
let Point.Print = function("s:Print")

let p = Point.new(10, 20)
call p.setX(40)
call p.setY(50)
call p.Print()
Help: Dictionary-function, numbered-function, :func-dict

Exception Handling
Basic exception handling
Python:
try:
    f = open('buf.java', 'r')
    lines = f.readlines()
    f.close()
except IOError:
    print("Failed to open file")
VimScript:
try
    let l = readfile('buf.java')
catch /E484:/
    echo "Failed to read file"
endtry
Help: exception-handling
Catching all exceptions
Python:
try:
    f = open('buf.java', 'r')
    lines = f.readlines()
    f.close()
except Exception as e:
    print("Caught " + str(e))
VimScript:
try
    let l = readfile('buf.java')
catch
    echo "Caught " .. v:exception
endtry
Help: catch-errors
Executing code after a try block (finally)
Python:
try:
    f = open('buf.java', 'r')
    lines = f.readlines()
    f.close()
finally:
    print("executing code in finally block")
VimScript:
try
    let l = readfile('buf.java')
finally
    echo "executing code in finally block"
endtry
Help: try-finally
Raising a custom exception
Python:
try:
    raise Exception('MyException')
except Exception as e:
    if str(e) == 'MyException':
	print("Caught MyException")
finally:
    print("Finally block")
VimScript:
try
    throw 'MyException'
catch /MyException/
    echo "Caught MyException"
finally
    echo "Finally block"
endtry
Help: throw-catch

Formatted Output
Python:
name = "John"
id = 1001
print("Name: %s, ID: %d" % (name, id))
VimScript:
let name = "John"
let id = 1001
echo printf("Name: %s, ID: %d", name, id)
Help: printf()

Line Continuation
Python:
a = 1 + 2 + 3 + \
      4 + 5 + 6
VimScript:
let a = 1 + 2 + 3 +
      \ 4 + 5 + 6
Help: line-continuation

File Operations
Reading all the lines in a file
Python:
with open('myfile.txt', 'r') as f:
    lines = f.readlines()
VimScript:
let lines = readfile("myfile.txt")
Help: readfile()
Writing lines to a file
Python:
lines = ['line1', 'line2']
with open('myfile.txt', 'w') as fh:
    fh.writelines("\n".join(lines))
VimScript:
call writefile(['line1', 'line2'], 'myfile.txt')
Help: writefile()
Checking whether a file exists
Python:
import os.path
if os.path.isfile('myfile.txt'):
    print("File exists")
VimScript:
if filereadable('myfile.txt')
    echo "File is readable"
endif
Help: filereadable()
Deleting a file
Python:
import os
os.remove('myfile.txt')
VimScript:
call delete('myfile.txt')
Help: remove()
Renaming a file
Python:
import os
os.rename('myfile.txt', 'somefile.txt)
VimScript:
call rename('myfile.txt', 'somefile.txt')
Help: rename()
Getting the size of a file
Python:
import os
sz = os.path.getsize('move.py')
VimScript:
let sz = getfsize('move.py')
Help: getfsize()

Directory Operations
Creating a directory
Python:
os.mkdir('somedir')
VimScript:
call mkdir('somedir')
Help: mkdir()
Changing to a directory
Python:
os.chdir('someotherdir')
VimScript:
call chdir('someotherdir')
Help: chdir()
Getting the current directory
Python:
dir = os.getcwd()
VimScript:
let dir = getcwd()
Help: getcwd()
Deleting a directory
Python:
os.rmdir('somedir')
VimScript:
call delete('somedir', 'd')
Help: delete()

Random numbers
Generating a random number
Python:
import random
r = random.randint(0, 2147483647)
VimScript:
let r = rand()
Help: rand()
Generating a random number from a seed
Python:
import random
random.seed()
r = random.randint(0, 2147483647)
print(r)
VimScript:
let seed = srand()
let r = rand(seed)
Help: srand()

Mathematical functions
Python:
import math
f = math.ceil(1.2)
f = math.fabs(-10)
f = math.floor(1.4)
f = math.fmod(4, 3)
f = math.trunc(1.3)
f = math.exp(2)
f = math.log(12)
f = math.log10(100)
f = math.pow(2, 3)
f = math.sqrt(9)
f = math.cos(4)
f = math.sin(4)
f = math.tan(4)
f = math.cosh(4)
f = math.sinh(4)
f = math.tanh(4)
f = math.acos(0.8)
f = math.asin(0.8)
f = math.atan(0.8)
f = math.atan2(0.4, 0.8)
VimScript:
let f = ceil(1.2)
let f = abs(-10)
let f = floor(1.4)
let f = fmod(4, 3)
let f = trunc(1.3)
let f = exp(2)
let f = log(12)
let f = log10(100)
let f = pow(2, 3)
let f = sqrt(9)
let f = cos(4)
let f = sin(4)
let f = tan(4)
let f = cosh(4)
let f = sinh(4)
let f = tanh(4)
let f = acos(0.8)
let f = asin(0.8)
let f = atan(0.8)
let f = atan2(0.4, 0.8)
Help: ceil(), abs(), floor(), fmod(), trunc(), exp(), log(), log10(), pow(), sqrt(), cos(), sin(), tan(), cosh(), sinh(), tanh(), acos(), asin(), atan(), atan2()

Date/Time functions
Get current date and time
Python:
from datetime import date
d = date.today()
print d.strftime("%c")
VimScript:
echo strftime("%c")
Help: strftime()
Parse a date/time string
Python:
from datetime import datetime
print(datetime.strptime("1997 Apr 27 11:49:23", "%Y %b %d %X"))
VimScript:
echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
Help: strptime()
Getting the time in seconds since epoch
Python:
import time
print int(time.time())
VimScript:
echo localtime()
Help: localtime()

External commands
Getting the output of an external command as a string
Python:
import subprocess
procObj = subprocess.Popen('grep class *.java',
			stdout=subprocess.PIPE,
			shell=True)
lines, err = procObj.communicate()
print(lines)
print("Error = " + str(procObj.returncode))
VimScript:
let lines = system('grep class *.java')
echo lines
echo "Error = " .. v:shell_error
Help: system(), v:shell_error
Splitting the output of an external command into lines
Python:
import subprocess
procObj = subprocess.Popen('grep class *.java',
			stdout=subprocess.PIPE,
			shell=True)
lines, err = procObj.communicate()
print("Number of matches = " + str(len(lines.split("\n"))))
VimScript:
let lines = systemlist('grep class *.java')
echo "Number of matches = " .. len(lines)
Help: systemlist()
Sending input to an external command and getting the output
Python:
import subprocess
procObj = subprocess.Popen('wc',
			stdout=subprocess.PIPE,
			stdin=subprocess.PIPE,
			shell=True)
lines, err = procObj.communicate("one\ntwo\n")
print(lines)
print("Error = " + str(procObj.returncode))
VimScript:
let lines = system('wc', "one\ntwo\n")
echo lines
echo "Error = " .. v:shell_error
Help: system()

Environment Variables
Getting the value of an environment variable
Python:
import os
h = os.environ.get('HOME', '')
if h == '':
    print("HOME is not set")
else:
    print("HOME = " + h)
VimScript:
let h = getenv('HOME')
if h == v:null
    echo 'HOME is not set'
else
    echo 'HOME = ' .. h
endif

if !exists('$HOME')
    echo 'HOME is not set'
else
    echo 'HOME = ' .. $HOME
endif
Help: getenv(), expr-env, exists()
Setting an environment variable
Python:
import os
os.environ['FOO'] = "BAR"
VimScript:
call setenv('FOO', 'BAR')

let $FOO = 'BAR'
Help: setenv(), :let-environment
Removing an environment variable
Python:
import os
del os.environ['FOO']
VimScript:
call setenv('FOO', v:null)

unlet $FOO
Help: setenv(), :unlet-environment
Getting all the environment variables
Python:
import os
print(os.environ)
VimScript:
echo environ()
Help: environ()

Command-line Arguments
Displaying the command-line arguments
Python:
import sys
print("Number of arguments = " + str(len(sys.argv)))
print("Arguments = " + str(sys.argv))
for arg in sys.argv:
    print(arg)
VimScript:
echo "Number of arguments = " .. len(v:argv)
echo "Arguments = " .. string(v:argv)
for arg in v:argv
    echo arg
endfor
Help: v:argv

Regular Expressions
Finding whether a pattern matches a string
Python:
import re
s = 'Test failed with error E123:'
if re.search(r'E\d+:', s):
    print('Error code found')

s = 'Test successful'
if re.search(r'E\d+:', s) == None:
    print("Test passed")
VimScript:
let s = 'Test failed with error E123:'
if s =~# 'E\d\+:'
    echo "Error code found"
endif

let s = 'Test successful'
if s !~# 'E\d\+:'
    echo "Test passed"
endif
Help: expr-=~, expr-!~
Finding the beginning or ending index of a pattern in a string
Python:
import re
m = re.search(r'\d+', "Abc 123 Def")
if m != None:
    idx = m.start()
    end_idx = m.end()
VimScript:
let idx = match("Abc 123 Def", '\d\+')
let end_idx = matchend("Abc 123 Def", '\d\+')

let l = matchstrpos("Abc 123 Def", '\d\+')
echo "start:" l[1] "end:" l[2]
Help: match(), matchend(), matchstrpos()
Getting matching substring using a pattern
Python:
import re
m = re.search(r'\d+', "Abc 123 Def")
if m != None:
    s = m.group(0)
    print s
VimScript:
let s = matchstr("Abc 123 Def", '\d\+')
Help: matchstr()
Getting multiple matches using a pattern
Python:
import re
m = re.match(r'(\w+) (\w+) (\w+)', "foo bar baz")
if m != None:
    print("Full match: " + m.group(0))
    print("1: " + m.group(1) + " 2: " + m.group(2) + " 3: " + m.group(3))
VimScript:
let list = matchlist("foo bar baz", '\(\w\+\) \(\w\+\) \(\w\+\)')
echo "Full match:" list[0]
echo "1:" list[1] "2:" list[2] "3:" list[3]
Help: matchlist()
Substituting text using a pattern
Python:
import re
s = re.sub(r'bar', r'baz', "foo bar")
print(s)
VimScript:
let s = substitute("foo bar", 'bar', 'baz', '')
echo s
Help: substitute()
Using a function to get the replacement string
Python:
import re
def Dashrepl(m):
  if m.group(0) == '-':
    return ' '
  else:
    return '-'
s = re.sub('-{1,2}', Dashrepl, 'pro----gram-files')
print(s)
VimScript:
function Dashrepl(m)
  if a:m[0] == '-'
    return ' '
  else
    return '-'
  endif
endfunction
let s = substitute("pro----gram-files", '-\{1,2}', function('Dashrepl'), 'g')
echo s
Help: substitute()
Regular expression comparison
Note that the below table shows only the regular expressions that are present in both Python and Vim.


What
Python
Vim


single character
.
.


start of string
^
^


end of string
$
$


0 or more matches
*
*


1 or more matches
+
\+


0 or 1 match
?
\?


non-greedy match
*?
\{-}


fixed matches
{n}
\{n}


m to n matches
{m,n}
\{m,n}


m to n non-greedy matches
{m,n}?
\{-m,n}


character class
[...]
[...]


negated character class
[^...]]
[^...]]


range
[a-z]
[a-z]


either-or branch
|
\|


capturing group
(...)
\(...\)


non-capturing match
(?:...)
\%(...\)


positive look-ahead
(?=...)
\(...\)\@=


negative look-ahead
(?!...)
\(...\)\@!


positive look-behind
(?<=...)
\(...\)\@<=


negative look-behind
(?<!...)
\(...\)\@<!


start of word
\b
\<


end of word
\b
\>


digit
\d
\d


non-digit
\D
\D


whitespace
\s
\s


non-whitespace
\S
\S


word character
\w
\w


non-word character
\W
\W


ignore case
(?i)
\c


Binary Data
Storing binary data in a variable
Python:
data = bytearray(b'\x12\xF6\xAB\xFF\x49\xC0\x88\x3A\xE2\xC1\x42\xAA')
print(data)
print(data[0:4])
VimScript:
let data = 0z12F6ABFF.49C0883A.E2C142AA
echo data
echo data[0:3]
Help: blob
Manipulating binary data stored in a variable
Python:
data = bytearray(b'')
data.append(0xC2)
data += b'\xB3\xF7\xA5'
del data[2]
print(data)
VimScript:
let data = 0z
let data[0] = 0xC2
let data += 0zB3F7A5
call remove(data, 2)
echo data
Help: blob-index, blob-modification
Reading and writing binary data from a file
Python:
with open("datafile.bin", "rb") as bin_fh:
    data = bytearray(bin_fh.read())

with open("data2.bin", "wb") as bin_fh:
    bin_fh.write(data)
VimScript:
let data = readfile('datafile.bin', 'B')
call writefile(data, 'data2.bin')
Help: readfile(), writefile()
What	Python	Vim
single character	.	.
start of string	^	^
end of string	$	$
0 or more matches	*	*
1 or more matches	+	\+
0 or 1 match	?	\?
non-greedy match	*?	\{-}
fixed matches	{n}	\{n}
m to n matches	{m,n}	\{m,n}
m to n non-greedy matches	{m,n}?	\{-m,n}
character class	[...]	[...]
negated character class	[^...]]	[^...]]
range	[a-z]	[a-z]
either-or branch	\|	\\|
capturing group	(...)	\(...\)
non-capturing match	(?:...)	\%(...\)
positive look-ahead	(?=...)	\(...\)\@=
negative look-ahead	(?!...)	\(...\)\@!
positive look-behind	(?<=...)	\(...\)\@<=
negative look-behind	(?<!...)	\(...\)\@<!
start of word	\b	\<
end of word	\b	\>
digit	\d	\d
non-digit	\D	\D
whitespace	\s	\s
non-whitespace	\S	\S
word character	\w	\w
non-word character	\W	\W
ignore case	(?i)	\c