If_pyth

コマンド python-commands

:python print("Hello")

function! IcecreamInitialize()
python << EOF
class StrawberryIcecream:
        def __call__(self):
                print('EAT ME')
EOF
endfunction

:python print(sys.version)

:pydo return "%s\t%d" % (line[::-1], len(line))
:pydo if line: return "%4d: %s" % (linenr, line)

:py3 << EOF
needle = vim.eval('@a')
replacement = vim.eval('@b')
def py_vim_string_replace(str):
        return str.replace(needle, replacement)
EOF
:'<,'>py3do return py_vim_string_replace(line)

:python sys.argv = ["foo", "bar"]
:pyfile myscript.py

:python from vim import *
:python current.line = str.upper(current.line)
:python print("Hello")
:python str = current.buffer[42]

if has('python')
  python << EOF
    print("python works")
EOF
endif

vim モジュール python-vim

:python import vim

:py print("Hello")                # displays a message
:py vim.command(cmd)                # execute an Ex command
:py w = vim.windows[n]                # gets window "n"
:py cw = vim.current.window        # gets the current window
:py b = vim.buffers[n]                # gets buffer "n"
:py cb = vim.current.buffer        # gets the current buffer
:py w.height = lines                # sets the window height
:py w.cursor = (row, col)        # sets the window cursor position
:py pos = w.cursor                # gets a tuple (row, col)
:py name = b.name                # gets the buffer file name
:py line = b[n]                        # gets a line from the buffer
:py lines = b[n:m]                # gets a list of lines
:py num = len(b)                # gets the number of lines
:py b[n] = str                        # sets a line in the buffer
:py b[n:m] = [str1, str2, str3]        # sets a number of lines at once
:py del b[n]                        # deletes a line
:py del b[n:m]                        # deletes a number of lines

:py vim.command("set tw=72")
:py vim.command("%s/aaa/bbb/g")

def normal(str):
        vim.command("normal "+str)
# Note the use of single quotes to delimit a string containing
# double quotes
normal('"a2dd"aP')

:py text_width = vim.eval("&tw")
:py str = vim.eval("12+12")                # NB result is a string! Use
                                    # int() to convert to a
                                    # number.

try:
        vim.command("put a")
except vim.error:
        # nothing in register a

:py b = vim.buffers[i]        # Indexing (read-only)
:py b in vim.buffers        # Membership test
:py n = len(vim.buffers)        # Number of elements
:py for b in vim.buffers:        # Iterating over buffer list

:py w = vim.windows[i]        # Indexing (read-only)
:py w in vim.windows        # Membership test
:py n = len(vim.windows)        # Number of elements
:py for w in vim.windows:        # Sequential access

:py t = vim.tabpages[i]        # Indexing (read-only)
:py t in vim.tabpages        # Membership test
:py n = len(vim.tabpages)        # Number of elements
:py for t in vim.tabpages:        # Sequential access

py << EOF
saved_eventignore = vim.options['eventignore']
vim.options['eventignore'] = 'all'
try:
    vim.current.buffer = vim.buffers[2] # Switch to buffer 2
finally:
    vim.options['eventignore'] = saved_eventignore
EOF

from imp import find_module, load_module
import vim
import sys
class VimModuleLoader(object):
    def __init__(self, module):
        self.module = module
    def load_module(self, fullname, path=None):
        return self.module
def _find_module(fullname, oldtail, path):
    idx = oldtail.find('.')
    if idx > 0:
        name = oldtail[:idx]
        tail = oldtail[idx+1:]
        fmr = find_module(name, path)
        module = load_module(fullname[:-len(oldtail)] + name, *fmr)
        return _find_module(fullname, tail, module.__path__)
    else:
        fmr = find_module(fullname, path)
        return load_module(fullname, *fmr)
# It uses vim module itself in place of VimPathFinder class: it does not
# matter for python which object has find_module function attached to as
# an attribute.
class VimPathFinder(object):
    @classmethod
    def find_module(cls, fullname, path=None):
        try:
            return VimModuleLoader(_find_module(fullname, fullname, path or vim._get_paths()))
        except ImportError:
            return None
    @classmethod
    def load_module(cls, fullname, path=None):
        return _find_module(fullname, fullname, path or vim._get_paths())
def hook(path):
    if path == vim.VIM_SPECIAL_PATH:
        return VimPathFinder
    else:
        raise ImportError
sys.path_hooks.append(hook)

バッファオブジェクト python-buffer

:py b.append(f.readlines())

:py print(b.name)                # write the buffer file name
:py b[0] = "hello!!!"                # replace the top line
:py b[:] = None                        # delete the whole buffer
:py del b[:]                        # delete the whole buffer
:py b[0:0] = [ "a line" ]        # add a line at the top
:py del b[2]                        # delete a line (the third)
:py b.append("bottom")                # add a line at the bottom
:py n = len(b)                        # number of lines
:py (row,col) = b.mark('a')        # named mark
:py r = b.range(1,5)                # a sub-range of the buffer
:py b.vars["foo"] = "bar"        # assign b:foo variable
:py b.options["ff"] = "dos"        # set fileformat
:py del b.options["ar"]                # same as :set autoread<

範囲オブジェクト python-range

ウィンドウオブジェクト python-window

タブページオブジェクト python-tabpage

pyeval()とpy3eval() Vim関数 python-pyeval

Python 3 python3

:py3 print("Hello")

:py3 import sys
:py3 print(sys.version)

:py vim.command("qall!")

if has('pythonx')
  echo 'there is Python'
endif
if has('python3')
  echo 'there is Python 3.x'
endif

Python X python_x pythonx

:pyx print("Hello")

:pyx import sys
:pyx print(sys.version)

if has('pythonx')
  echo 'pyx* commands are available. (Python ' .. &pyx .. ')'
endif