|
557
|
1 *if_pyth.txt* For Vim version 7.0aa. Last change: 2005 Oct 14
|
|
7
|
2
|
|
|
3
|
|
|
4 VIM REFERENCE MANUAL by Paul Moore
|
|
|
5
|
|
|
6
|
|
|
7 The Python Interface to Vim *python* *Python*
|
|
|
8
|
|
|
9 1. Commands |python-commands|
|
|
|
10 2. The vim module |python-vim|
|
|
|
11 3. Buffer objects |python-buffer|
|
|
|
12 4. Range objects |python-range|
|
|
|
13 5. Window objects |python-window|
|
|
557
|
14 6. Dynamic loading |python-dynamic|
|
|
7
|
15
|
|
|
16 {Vi does not have any of these commands}
|
|
|
17
|
|
|
18 The Python interface is available only when Vim was compiled with the
|
|
|
19 |+python| feature.
|
|
|
20
|
|
|
21 ==============================================================================
|
|
|
22 1. Commands *python-commands*
|
|
|
23
|
|
|
24 *:python* *:py* *E205* *E263* *E264*
|
|
|
25 :[range]py[thon] {stmt}
|
|
|
26 Execute Python statement {stmt}.
|
|
|
27
|
|
|
28 :[range]py[thon] << {endmarker}
|
|
|
29 {script}
|
|
|
30 {endmarker}
|
|
|
31 Execute Python script {script}.
|
|
|
32 Note: This command doesn't work when the Python
|
|
|
33 feature wasn't compiled in. To avoid errors, see
|
|
|
34 |script-here|.
|
|
|
35
|
|
|
36 {endmarker} must NOT be preceded by any white space. If {endmarker} is
|
|
|
37 omitted from after the "<<", a dot '.' must be used after {script}, like
|
|
|
38 for the |:append| and |:insert| commands.
|
|
|
39 This form of the |:python| command is mainly useful for including python code
|
|
|
40 in Vim scripts.
|
|
|
41
|
|
|
42 Example: >
|
|
|
43 function! IcecreamInitialize()
|
|
|
44 python << EOF
|
|
|
45 class StrawberryIcecream:
|
|
|
46 def __call__(self):
|
|
|
47 print 'EAT ME'
|
|
|
48 EOF
|
|
|
49 endfunction
|
|
|
50 <
|
|
|
51 Note: Python is very sensitive to the indenting. Also make sure the "class"
|
|
|
52 line and "EOF" do not have any indent.
|
|
|
53
|
|
|
54 *:pyfile* *:pyf*
|
|
|
55 :[range]pyf[ile] {file}
|
|
|
56 Execute the Python script in {file}. The whole
|
|
|
57 argument is used as a single file name. {not in Vi}
|
|
|
58
|
|
|
59 Both of these commands do essentially the same thing - they execute a piece of
|
|
|
60 Python code, with the "current range" |python-range| set to the given line
|
|
|
61 range.
|
|
|
62
|
|
|
63 In the case of :python, the code to execute is in the command-line.
|
|
|
64 In the case of :pyfile, the code to execute is the contents of the given file.
|
|
|
65
|
|
|
66 Python commands cannot be used in the |sandbox|.
|
|
|
67
|
|
|
68 To pass arguments you need to set sys.argv[] explicitly. Example: >
|
|
|
69
|
|
|
70 :python import sys
|
|
|
71 :python sys.argv = ["foo", "bar"]
|
|
|
72 :pyfile myscript.py
|
|
|
73
|
|
|
74 Here are some examples *python-examples* >
|
|
|
75
|
|
|
76 :python from vim import *
|
|
|
77 :python from string import upper
|
|
|
78 :python current.line = upper(current.line)
|
|
|
79 :python print "Hello"
|
|
|
80 :python str = current.buffer[42]
|
|
|
81
|
|
|
82 (Note that changes - like the imports - persist from one command to the next,
|
|
|
83 just like in the Python interpreter.)
|
|
|
84
|
|
|
85 ==============================================================================
|
|
|
86 2. The vim module *python-vim*
|
|
|
87
|
|
|
88 Python code gets all of its access to vim (with one exception - see
|
|
236
|
89 |python-output| below) via the "vim" module. The vim module implements two
|
|
7
|
90 methods, three constants, and one error object. You need to import the vim
|
|
|
91 module before using it: >
|
|
|
92 :python import vim
|
|
|
93
|
|
|
94 Overview >
|
|
20
|
95 :py print "Hello" # displays a message
|
|
|
96 :py vim.command(cmd) # execute an ex command
|
|
|
97 :py w = vim.windows[n] # gets window "n"
|
|
|
98 :py cw = vim.current.window # gets the current window
|
|
|
99 :py b = vim.buffers[n] # gets buffer "n"
|
|
|
100 :py cb = vim.current.buffer # gets the current buffer
|
|
|
101 :py w.height = lines # sets the window height
|
|
|
102 :py w.cursor = (row, col) # sets the window cursor position
|
|
|
103 :py pos = w.cursor # gets a tuple (row, col)
|
|
|
104 :py name = b.name # gets the buffer file name
|
|
|
105 :py line = b[n] # gets a line from the buffer
|
|
|
106 :py lines = b[n:m] # gets a list of lines
|
|
|
107 :py num = len(b) # gets the number of lines
|
|
|
108 :py b[n] = str # sets a line in the buffer
|
|
|
109 :py b[n:m] = [str1, str2, str3] # sets a number of lines at once
|
|
|
110 :py del b[n] # deletes a line
|
|
|
111 :py del b[n:m] # deletes a number of lines
|
|
7
|
112
|
|
|
113
|
|
|
114 Methods of the "vim" module
|
|
|
115
|
|
|
116 vim.command(str) *python-command*
|
|
236
|
117 Executes the vim (ex-mode) command str. Returns None.
|
|
7
|
118 Examples: >
|
|
20
|
119 :py vim.command("set tw=72")
|
|
|
120 :py vim.command("%s/aaa/bbb/g")
|
|
7
|
121 < The following definition executes Normal mode commands: >
|
|
|
122 def normal(str):
|
|
|
123 vim.command("normal "+str)
|
|
|
124 # Note the use of single quotes to delimit a string containing
|
|
|
125 # double quotes
|
|
|
126 normal('"a2dd"aP')
|
|
|
127 < *E659*
|
|
|
128 The ":python" command cannot be used recursively with Python 2.2 and
|
|
|
129 older. This only works with Python 2.3 and later: >
|
|
20
|
130 :py vim.command("python print 'Hello again Python'")
|
|
7
|
131
|
|
|
132 vim.eval(str) *python-eval*
|
|
|
133 Evaluates the expression str using the vim internal expression
|
|
236
|
134 evaluator (see |expression|). Returns the expression result as a
|
|
7
|
135 string.
|
|
|
136 Examples: >
|
|
20
|
137 :py text_width = vim.eval("&tw")
|
|
|
138 :py str = vim.eval("12+12") # NB result is a string! Use
|
|
7
|
139 # string.atoi() to convert to
|
|
|
140 # a number.
|
|
|
141
|
|
|
142 Error object of the "vim" module
|
|
|
143
|
|
|
144 vim.error *python-error*
|
|
|
145 Upon encountering a Vim error, Python raises an exception of type
|
|
|
146 vim.error.
|
|
|
147 Example: >
|
|
|
148 try:
|
|
|
149 vim.command("put a")
|
|
|
150 except vim.error:
|
|
|
151 # nothing in register a
|
|
|
152
|
|
|
153 Constants of the "vim" module
|
|
|
154
|
|
|
155 Note that these are not actually constants - you could reassign them.
|
|
|
156 But this is silly, as you would then lose access to the vim objects
|
|
|
157 to which the variables referred.
|
|
|
158
|
|
|
159 vim.buffers *python-buffers*
|
|
236
|
160 A sequence object providing access to the list of vim buffers. The
|
|
7
|
161 object supports the following operations: >
|
|
20
|
162 :py b = vim.buffers[i] # Indexing (read-only)
|
|
|
163 :py b in vim.buffers # Membership test
|
|
|
164 :py n = len(vim.buffers) # Number of elements
|
|
|
165 :py for b in vim.buffers: # Sequential access
|
|
7
|
166 <
|
|
|
167 vim.windows *python-windows*
|
|
236
|
168 A sequence object providing access to the list of vim windows. The
|
|
7
|
169 object supports the following operations: >
|
|
20
|
170 :py w = vim.windows[i] # Indexing (read-only)
|
|
|
171 :py w in vim.windows # Membership test
|
|
|
172 :py n = len(vim.windows) # Number of elements
|
|
|
173 :py for w in vim.windows: # Sequential access
|
|
7
|
174 <
|
|
|
175 vim.current *python-current*
|
|
|
176 An object providing access (via specific attributes) to various
|
|
|
177 "current" objects available in vim:
|
|
|
178 vim.current.line The current line (RW) String
|
|
|
179 vim.current.buffer The current buffer (RO) Buffer
|
|
|
180 vim.current.window The current window (RO) Window
|
|
|
181 vim.current.range The current line range (RO) Range
|
|
|
182
|
|
236
|
183 The last case deserves a little explanation. When the :python or
|
|
7
|
184 :pyfile command specifies a range, this range of lines becomes the
|
|
236
|
185 "current range". A range is a bit like a buffer, but with all access
|
|
|
186 restricted to a subset of lines. See |python-range| for more details.
|
|
7
|
187
|
|
|
188
|
|
|
189 Output from Python *python-output*
|
|
|
190 Vim displays all Python code output in the Vim message area. Normal
|
|
|
191 output appears as information messages, and error output appears as
|
|
|
192 error messages.
|
|
|
193
|
|
|
194 In implementation terms, this means that all output to sys.stdout
|
|
|
195 (including the output from print statements) appears as information
|
|
|
196 messages, and all output to sys.stderr (including error tracebacks)
|
|
|
197 appears as error messages.
|
|
|
198
|
|
|
199 *python-input*
|
|
|
200 Input (via sys.stdin, including input() and raw_input()) is not
|
|
236
|
201 supported, and may cause the program to crash. This should probably be
|
|
7
|
202 fixed.
|
|
|
203
|
|
|
204 ==============================================================================
|
|
|
205 3. Buffer objects *python-buffer*
|
|
|
206
|
|
236
|
207 Buffer objects represent vim buffers. You can obtain them in a number of ways:
|
|
7
|
208 - via vim.current.buffer (|python-current|)
|
|
|
209 - from indexing vim.buffers (|python-buffers|)
|
|
|
210 - from the "buffer" attribute of a window (|python-window|)
|
|
|
211
|
|
|
212 Buffer objects have one read-only attribute - name - the full file name for
|
|
236
|
213 the buffer. They also have three methods (append, mark, and range; see below).
|
|
7
|
214
|
|
236
|
215 You can also treat buffer objects as sequence objects. In this context, they
|
|
7
|
216 act as if they were lists (yes, they are mutable) of strings, with each
|
|
236
|
217 element being a line of the buffer. All of the usual sequence operations,
|
|
7
|
218 including indexing, index assignment, slicing and slice assignment, work as
|
|
236
|
219 you would expect. Note that the result of indexing (slicing) a buffer is a
|
|
|
220 string (list of strings). This has one unusual consequence - b[:] is different
|
|
|
221 from b. In particular, "b[:] = None" deletes the whole of the buffer, whereas
|
|
7
|
222 "b = None" merely updates the variable b, with no effect on the buffer.
|
|
|
223
|
|
236
|
224 Buffer indexes start at zero, as is normal in Python. This differs from vim
|
|
|
225 line numbers, which start from 1. This is particularly relevant when dealing
|
|
7
|
226 with marks (see below) which use vim line numbers.
|
|
|
227
|
|
|
228 The buffer object methods are:
|
|
|
229 b.append(str) Append a line to the buffer
|
|
|
230 b.append(list) Append a list of lines to the buffer
|
|
|
231 Note that the option of supplying a list of strings to
|
|
|
232 the append method differs from the equivalent method
|
|
|
233 for Python's built-in list objects.
|
|
|
234 b.mark(name) Return a tuple (row,col) representing the position
|
|
|
235 of the named mark (can also get the []"<> marks)
|
|
|
236 b.range(s,e) Return a range object (see |python-range|) which
|
|
|
237 represents the part of the given buffer between line
|
|
|
238 numbers s and e |inclusive|.
|
|
|
239
|
|
20
|
240 Note that when adding a line it must not contain a line break character '\n'.
|
|
|
241 A trailing '\n' is allowed and ignored, so that you can do: >
|
|
|
242 :py b.append(f.readlines())
|
|
|
243
|
|
7
|
244 Examples (assume b is the current buffer) >
|
|
20
|
245 :py print b.name # write the buffer file name
|
|
|
246 :py b[0] = "hello!!!" # replace the top line
|
|
|
247 :py b[:] = None # delete the whole buffer
|
|
|
248 :py del b[:] # delete the whole buffer
|
|
|
249 :py b[0:0] = [ "a line" ] # add a line at the top
|
|
|
250 :py del b[2] # delete a line (the third)
|
|
|
251 :py b.append("bottom") # add a line at the bottom
|
|
|
252 :py n = len(b) # number of lines
|
|
|
253 :py (row,col) = b.mark('a') # named mark
|
|
|
254 :py r = b.range(1,5) # a sub-range of the buffer
|
|
7
|
255
|
|
|
256 ==============================================================================
|
|
|
257 4. Range objects *python-range*
|
|
|
258
|
|
236
|
259 Range objects represent a part of a vim buffer. You can obtain them in a
|
|
7
|
260 number of ways:
|
|
|
261 - via vim.current.range (|python-current|)
|
|
|
262 - from a buffer's range() method (|python-buffer|)
|
|
|
263
|
|
236
|
264 A range object is almost identical in operation to a buffer object. However,
|
|
7
|
265 all operations are restricted to the lines within the range (this line range
|
|
|
266 can, of course, change as a result of slice assignments, line deletions, or
|
|
|
267 the range.append() method).
|
|
|
268
|
|
|
269 The range object attributes are:
|
|
|
270 r.start Index of first line into the buffer
|
|
|
271 r.end Index of last line into the buffer
|
|
|
272
|
|
|
273 The range object methods are:
|
|
|
274 r.append(str) Append a line to the range
|
|
|
275 r.append(list) Append a list of lines to the range
|
|
|
276 Note that the option of supplying a list of strings to
|
|
|
277 the append method differs from the equivalent method
|
|
|
278 for Python's built-in list objects.
|
|
|
279
|
|
|
280 Example (assume r is the current range):
|
|
|
281 # Send all lines in a range to the default printer
|
|
|
282 vim.command("%d,%dhardcopy!" % (r.start+1,r.end+1))
|
|
|
283
|
|
|
284 ==============================================================================
|
|
|
285 5. Window objects *python-window*
|
|
|
286
|
|
236
|
287 Window objects represent vim windows. You can obtain them in a number of ways:
|
|
7
|
288 - via vim.current.window (|python-current|)
|
|
|
289 - from indexing vim.windows (|python-windows|)
|
|
|
290
|
|
236
|
291 You can manipulate window objects only through their attributes. They have no
|
|
7
|
292 methods, and no sequence or other interface.
|
|
|
293
|
|
|
294 Window attributes are:
|
|
|
295 buffer (read-only) The buffer displayed in this window
|
|
|
296 cursor (read-write) The current cursor position in the window
|
|
|
297 This is a tuple, (row,col).
|
|
|
298 height (read-write) The window height, in rows
|
|
|
299 width (read-write) The window width, in columns
|
|
|
300 The height attribute is writable only if the screen is split horizontally.
|
|
|
301 The width attribute is writable only if the screen is split vertically.
|
|
|
302
|
|
|
303 ==============================================================================
|
|
557
|
304 6. Dynamic loading *python-dynamic*
|
|
|
305
|
|
|
306 On MS-Windows the Python library can be loaded dynamically. The |:version|
|
|
|
307 output then includes |+python/dyn|.
|
|
|
308
|
|
|
309 This means that Vim will search for the Python DLL file only when needed.
|
|
|
310 When you don't use the Python interface you don't need it, thus you can use
|
|
|
311 Vim without this DLL file.
|
|
|
312
|
|
|
313 To use the Python interface the Python DLL must be in your search path. In a
|
|
|
314 console window type "path" to see what directories are used.
|
|
|
315
|
|
|
316 The name of the DLL must match the Python version Vim was compiled with.
|
|
|
317 Currently the name is "python24.dll". That is for Python 2.4. To know for
|
|
|
318 sure edit "gvim.exe" and search for "python\d*.dll\c".
|
|
|
319
|
|
|
320 ==============================================================================
|
|
7
|
321 vim:tw=78:ts=8:ft=help:norl:
|
