Mercurial > vim
annotate runtime/doc/if_pyth.txt @ 4502:605c9ce57ec3
Updated runtime files, language files and translations.
author | Bram Moolenaar <bram@vim.org> |
---|---|
date | Tue, 21 May 2013 21:01:10 +0200 |
parents | ebd94eabfd80 |
children | fa39483a1363 |
rev | line source |
---|---|
4502
605c9ce57ec3
Updated runtime files, language files and translations.
Bram Moolenaar <bram@vim.org>
parents:
4496
diff
changeset
|
1 *if_pyth.txt* For Vim version 7.3. Last change: 2013 May 21 |
7 | 2 |
3 | |
4 VIM REFERENCE MANUAL by Paul Moore | |
5 | |
6 | |
7 The Python Interface to Vim *python* *Python* | |
8 | |
3682 | 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| | |
4496 | 14 6. Tab page objects |python-tabpage| |
15 7. pyeval(), py3eval() Vim functions |python-pyeval| | |
16 8. Dynamic loading |python-dynamic| | |
17 9. Python 3 |python3| | |
7 | 18 |
19 {Vi does not have any of these commands} | |
20 | |
2350
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
21 The Python 2.x interface is available only when Vim was compiled with the |
7 | 22 |+python| feature. |
2350
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
23 The Python 3 interface is available only when Vim was compiled with the |
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
24 |+python3| feature. |
7 | 25 |
26 ============================================================================== | |
27 1. Commands *python-commands* | |
28 | |
29 *:python* *:py* *E205* *E263* *E264* | |
30 :[range]py[thon] {stmt} | |
3750 | 31 Execute Python statement {stmt}. A simple check if |
32 the `:python` command is working: > | |
33 :python print "Hello" | |
7 | 34 |
35 :[range]py[thon] << {endmarker} | |
36 {script} | |
37 {endmarker} | |
38 Execute Python script {script}. | |
39 Note: This command doesn't work when the Python | |
40 feature wasn't compiled in. To avoid errors, see | |
41 |script-here|. | |
42 | |
43 {endmarker} must NOT be preceded by any white space. If {endmarker} is | |
44 omitted from after the "<<", a dot '.' must be used after {script}, like | |
45 for the |:append| and |:insert| commands. | |
46 This form of the |:python| command is mainly useful for including python code | |
47 in Vim scripts. | |
48 | |
49 Example: > | |
50 function! IcecreamInitialize() | |
51 python << EOF | |
52 class StrawberryIcecream: | |
53 def __call__(self): | |
54 print 'EAT ME' | |
55 EOF | |
56 endfunction | |
57 < | |
4073 | 58 Note: Python is very sensitive to the indenting. Make sure the "class" line |
59 and "EOF" do not have any indent. | |
7 | 60 |
4435 | 61 *:pydo* |
62 :[range]pydo {body} Execute Python function "def _vim_pydo(line, linenr): | |
63 {body}" for each line in the [range], with the | |
64 function arguments being set to the text of each line | |
65 in turn, without a trailing <EOL>, and the current | |
66 line number. The function should return a string or | |
67 None. If a string is returned, it becomes the text of | |
68 the line in the current turn. The default for [range] | |
69 is the whole file: "1,$". | |
70 {not in Vi} | |
71 | |
72 Examples: | |
73 > | |
74 :pydo return "%s\t%d" % (line[::-1], len(line)) | |
75 :pydo if line: return "%4d: %s" % (linenr, line) | |
76 < | |
7 | 77 *:pyfile* *:pyf* |
78 :[range]pyf[ile] {file} | |
79 Execute the Python script in {file}. The whole | |
80 argument is used as a single file name. {not in Vi} | |
81 | |
82 Both of these commands do essentially the same thing - they execute a piece of | |
83 Python code, with the "current range" |python-range| set to the given line | |
84 range. | |
85 | |
86 In the case of :python, the code to execute is in the command-line. | |
87 In the case of :pyfile, the code to execute is the contents of the given file. | |
88 | |
89 Python commands cannot be used in the |sandbox|. | |
90 | |
91 To pass arguments you need to set sys.argv[] explicitly. Example: > | |
92 | |
93 :python import sys | |
94 :python sys.argv = ["foo", "bar"] | |
95 :pyfile myscript.py | |
96 | |
97 Here are some examples *python-examples* > | |
98 | |
99 :python from vim import * | |
100 :python from string import upper | |
101 :python current.line = upper(current.line) | |
102 :python print "Hello" | |
103 :python str = current.buffer[42] | |
104 | |
105 (Note that changes - like the imports - persist from one command to the next, | |
106 just like in the Python interpreter.) | |
107 | |
108 ============================================================================== | |
109 2. The vim module *python-vim* | |
110 | |
111 Python code gets all of its access to vim (with one exception - see | |
236 | 112 |python-output| below) via the "vim" module. The vim module implements two |
7 | 113 methods, three constants, and one error object. You need to import the vim |
114 module before using it: > | |
115 :python import vim | |
116 | |
117 Overview > | |
20 | 118 :py print "Hello" # displays a message |
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
119 :py vim.command(cmd) # execute an Ex command |
20 | 120 :py w = vim.windows[n] # gets window "n" |
121 :py cw = vim.current.window # gets the current window | |
122 :py b = vim.buffers[n] # gets buffer "n" | |
123 :py cb = vim.current.buffer # gets the current buffer | |
124 :py w.height = lines # sets the window height | |
125 :py w.cursor = (row, col) # sets the window cursor position | |
126 :py pos = w.cursor # gets a tuple (row, col) | |
127 :py name = b.name # gets the buffer file name | |
128 :py line = b[n] # gets a line from the buffer | |
129 :py lines = b[n:m] # gets a list of lines | |
130 :py num = len(b) # gets the number of lines | |
131 :py b[n] = str # sets a line in the buffer | |
132 :py b[n:m] = [str1, str2, str3] # sets a number of lines at once | |
133 :py del b[n] # deletes a line | |
134 :py del b[n:m] # deletes a number of lines | |
7 | 135 |
136 | |
137 Methods of the "vim" module | |
138 | |
139 vim.command(str) *python-command* | |
236 | 140 Executes the vim (ex-mode) command str. Returns None. |
7 | 141 Examples: > |
20 | 142 :py vim.command("set tw=72") |
143 :py vim.command("%s/aaa/bbb/g") | |
7 | 144 < The following definition executes Normal mode commands: > |
145 def normal(str): | |
146 vim.command("normal "+str) | |
147 # Note the use of single quotes to delimit a string containing | |
148 # double quotes | |
149 normal('"a2dd"aP') | |
150 < *E659* | |
151 The ":python" command cannot be used recursively with Python 2.2 and | |
152 older. This only works with Python 2.3 and later: > | |
20 | 153 :py vim.command("python print 'Hello again Python'") |
7 | 154 |
155 vim.eval(str) *python-eval* | |
156 Evaluates the expression str using the vim internal expression | |
633 | 157 evaluator (see |expression|). Returns the expression result as: |
158 - a string if the Vim expression evaluates to a string or number | |
159 - a list if the Vim expression evaluates to a Vim list | |
856 | 160 - a dictionary if the Vim expression evaluates to a Vim dictionary |
633 | 161 Dictionaries and lists are recursively expanded. |
7 | 162 Examples: > |
20 | 163 :py text_width = vim.eval("&tw") |
164 :py str = vim.eval("12+12") # NB result is a string! Use | |
7 | 165 # string.atoi() to convert to |
166 # a number. | |
167 | |
856 | 168 :py tagList = vim.eval('taglist("eval_expr")') |
633 | 169 < The latter will return a python list of python dicts, for instance: |
170 [{'cmd': '/^eval_expr(arg, nextcmd)$/', 'static': 0, 'name': | |
171 'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}] | |
172 | |
3682 | 173 vim.bindeval(str) *python-bindeval* |
174 Like |python-eval|, but | |
175 1. if expression evaluates to |List| or |Dictionary| it is returned as | |
176 vimlist or vimdictionary python type that are connected to original | |
177 list or dictionary. Thus modifications to these objects imply | |
178 modifications of the original. | |
3830 | 179 |
4496 | 180 Additionally, vim.List and vim.Dictionary type have read-write |
3830 | 181 `.locked` attribute that returns |
182 Value Meaning ~ | |
183 zero Variable is not locked | |
184 vim.VAR_LOCKED Variable is locked, but can be unlocked | |
3847 | 185 vim.VAR_FIXED Variable is locked and can't be unlocked |
3830 | 186 integer constants. If variable is not fixed, you can do |
187 `var.locked=True` to lock it and `var.locked=False` to unlock. | |
188 There is no recursive locking like |:lockvar|! does. There is also | |
189 no way to lock a specific key or check whether it is locked (in any | |
190 case these locks are ignored by anything except |:let|: |extend()| | |
191 does not care, neither does python interface). | |
192 | |
4496 | 193 vim.Dictionary type also supports `.scope` attribute which is one |
194 of | |
3830 | 195 Value Meaning ~ |
196 zero Dictionary is not a scope one | |
197 vim.VAR_DEF_SCOPE Function-local or global scope dictionary | |
198 vim.VAR_SCOPE Other scope dictionary | |
199 | |
3682 | 200 2. if expression evaluates to a function reference, then it returns |
4496 | 201 callable vim.Function object. Use self keyword argument to assign |
3682 | 202 |self| object for dictionary functions. |
203 | |
204 Note: this function has the same behavior as |lua-eval| (except that | |
205 lua does not support running vim functions), |python-eval| is | |
206 kept for backwards compatibility in order not to make scripts | |
207 relying on outputs of vim.eval() being a copy of original or | |
208 vim.eval("1") returning a string. | |
209 | |
4496 | 210 You can use "List", "Dictionary" and "Function" vim module attributes |
211 to test whether object has given type. These types are currently not | |
212 subclassable, neither they contain constructors, so you can use them | |
213 only for checks like `isinstance(obj, vim.List)`. | |
633 | 214 |
215 | |
7 | 216 Error object of the "vim" module |
217 | |
218 vim.error *python-error* | |
219 Upon encountering a Vim error, Python raises an exception of type | |
220 vim.error. | |
221 Example: > | |
222 try: | |
223 vim.command("put a") | |
224 except vim.error: | |
225 # nothing in register a | |
226 | |
227 Constants of the "vim" module | |
228 | |
229 Note that these are not actually constants - you could reassign them. | |
230 But this is silly, as you would then lose access to the vim objects | |
231 to which the variables referred. | |
232 | |
233 vim.buffers *python-buffers* | |
4393 | 234 A mapping object providing access to the list of vim buffers. The |
7 | 235 object supports the following operations: > |
20 | 236 :py b = vim.buffers[i] # Indexing (read-only) |
237 :py b in vim.buffers # Membership test | |
238 :py n = len(vim.buffers) # Number of elements | |
4397 | 239 :py for b in vim.buffers: # Iterating over buffer list |
7 | 240 < |
241 vim.windows *python-windows* | |
236 | 242 A sequence object providing access to the list of vim windows. The |
7 | 243 object supports the following operations: > |
20 | 244 :py w = vim.windows[i] # Indexing (read-only) |
245 :py w in vim.windows # Membership test | |
246 :py n = len(vim.windows) # Number of elements | |
247 :py for w in vim.windows: # Sequential access | |
4401 | 248 < Note: vim.windows object always accesses current tab page,. |
249 |python-tabpage|.windows objects are bound to parent |python-tabpage| | |
250 object and always use windows from that tab page (or throw vim.error | |
251 in case tab page was deleted). You can keep a reference to both | |
252 without keeping a reference to vim module object or |python-tabpage|, | |
253 they will not loose their properties in this case. | |
254 | |
255 vim.tabpages *python-tabpages* | |
256 A sequence object providing access to the list of vim tab pages. The | |
257 object supports the following operations: > | |
258 :py t = vim.tabpages[i] # Indexing (read-only) | |
259 :py t in vim.tabpages # Membership test | |
260 :py n = len(vim.tabpages) # Number of elements | |
261 :py for t in vim.tabpages: # Sequential access | |
7 | 262 < |
263 vim.current *python-current* | |
264 An object providing access (via specific attributes) to various | |
265 "current" objects available in vim: | |
266 vim.current.line The current line (RW) String | |
4407 | 267 vim.current.buffer The current buffer (RW) Buffer |
268 vim.current.window The current window (RW) Window | |
269 vim.current.tabpage The current tab page (RW) TabPage | |
7 | 270 vim.current.range The current line range (RO) Range |
271 | |
236 | 272 The last case deserves a little explanation. When the :python or |
7 | 273 :pyfile command specifies a range, this range of lines becomes the |
236 | 274 "current range". A range is a bit like a buffer, but with all access |
275 restricted to a subset of lines. See |python-range| for more details. | |
7 | 276 |
4407 | 277 Note: When assigning to vim.current.{buffer,window,tabpage} it expects |
278 valid |python-buffer|, |python-window| or |python-tabpage| objects | |
279 respectively. Assigning triggers normal (with |autocommand|s) | |
280 switching to given buffer, window or tab page. It is the only way to | |
281 switch UI objects in python: you can't assign to | |
282 |python-tabpage|.window attribute. To switch without triggering | |
283 autocommands use > | |
284 py << EOF | |
285 saved_eventignore = vim.options['eventignore'] | |
286 vim.options['eventignore'] = 'all' | |
287 try: | |
288 vim.current.buffer = vim.buffers[2] # Switch to buffer 2 | |
289 finally: | |
290 vim.options['eventignore'] = saved_eventignore | |
291 EOF | |
292 < | |
4323 | 293 vim.vars *python-vars* |
294 vim.vvars *python-vvars* | |
295 Dictionary-like objects holding dictionaries with global (|g:|) and | |
296 vim (|v:|) variables respectively. Identical to `vim.bindeval("g:")`, | |
297 but faster. | |
7 | 298 |
4350 | 299 vim.options *python-options* |
300 Object partly supporting mapping protocol (supports setting and | |
301 getting items) providing a read-write access to global options. | |
302 Note: unlike |:set| this provides access only to global options. You | |
303 cannot use this object to obtain or set local options' values or | |
304 access local-only options in any fashion. Raises KeyError if no global | |
305 option with such name exists (i.e. does not raise KeyError for | |
306 |global-local| options and global only options, but does for window- | |
307 and buffer-local ones). Use |python-buffer| objects to access to | |
308 buffer-local options and |python-window| objects to access to | |
309 window-local options. | |
310 | |
4496 | 311 Type of this object is available via "Options" attribute of vim |
312 module. | |
313 | |
7 | 314 Output from Python *python-output* |
315 Vim displays all Python code output in the Vim message area. Normal | |
316 output appears as information messages, and error output appears as | |
317 error messages. | |
318 | |
319 In implementation terms, this means that all output to sys.stdout | |
320 (including the output from print statements) appears as information | |
321 messages, and all output to sys.stderr (including error tracebacks) | |
322 appears as error messages. | |
323 | |
324 *python-input* | |
325 Input (via sys.stdin, including input() and raw_input()) is not | |
236 | 326 supported, and may cause the program to crash. This should probably be |
7 | 327 fixed. |
328 | |
329 ============================================================================== | |
330 3. Buffer objects *python-buffer* | |
331 | |
236 | 332 Buffer objects represent vim buffers. You can obtain them in a number of ways: |
7 | 333 - via vim.current.buffer (|python-current|) |
334 - from indexing vim.buffers (|python-buffers|) | |
335 - from the "buffer" attribute of a window (|python-window|) | |
336 | |
3312 | 337 Buffer objects have two read-only attributes - name - the full file name for |
338 the buffer, and number - the buffer number. They also have three methods | |
339 (append, mark, and range; see below). | |
7 | 340 |
236 | 341 You can also treat buffer objects as sequence objects. In this context, they |
7 | 342 act as if they were lists (yes, they are mutable) of strings, with each |
236 | 343 element being a line of the buffer. All of the usual sequence operations, |
7 | 344 including indexing, index assignment, slicing and slice assignment, work as |
236 | 345 you would expect. Note that the result of indexing (slicing) a buffer is a |
346 string (list of strings). This has one unusual consequence - b[:] is different | |
347 from b. In particular, "b[:] = None" deletes the whole of the buffer, whereas | |
7 | 348 "b = None" merely updates the variable b, with no effect on the buffer. |
349 | |
236 | 350 Buffer indexes start at zero, as is normal in Python. This differs from vim |
351 line numbers, which start from 1. This is particularly relevant when dealing | |
7 | 352 with marks (see below) which use vim line numbers. |
353 | |
4350 | 354 The buffer object attributes are: |
355 b.vars Dictionary-like object used to access | |
356 |buffer-variable|s. | |
357 b.options Mapping object (supports item getting, setting and | |
358 deleting) that provides access to buffer-local options | |
359 and buffer-local values of |global-local| options. Use | |
360 |python-window|.options if option is window-local, | |
361 this object will raise KeyError. If option is | |
362 |global-local| and local value is missing getting it | |
363 will return None. | |
364 | |
7 | 365 The buffer object methods are: |
366 b.append(str) Append a line to the buffer | |
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
367 b.append(str, nr) Idem, below line "nr" |
7 | 368 b.append(list) Append a list of lines to the buffer |
369 Note that the option of supplying a list of strings to | |
370 the append method differs from the equivalent method | |
371 for Python's built-in list objects. | |
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
372 b.append(list, nr) Idem, below line "nr" |
7 | 373 b.mark(name) Return a tuple (row,col) representing the position |
374 of the named mark (can also get the []"<> marks) | |
375 b.range(s,e) Return a range object (see |python-range|) which | |
376 represents the part of the given buffer between line | |
377 numbers s and e |inclusive|. | |
378 | |
20 | 379 Note that when adding a line it must not contain a line break character '\n'. |
380 A trailing '\n' is allowed and ignored, so that you can do: > | |
381 :py b.append(f.readlines()) | |
382 | |
4496 | 383 Buffer object type is available using "Buffer" attribute of vim module. |
384 | |
7 | 385 Examples (assume b is the current buffer) > |
20 | 386 :py print b.name # write the buffer file name |
387 :py b[0] = "hello!!!" # replace the top line | |
388 :py b[:] = None # delete the whole buffer | |
389 :py del b[:] # delete the whole buffer | |
390 :py b[0:0] = [ "a line" ] # add a line at the top | |
391 :py del b[2] # delete a line (the third) | |
392 :py b.append("bottom") # add a line at the bottom | |
393 :py n = len(b) # number of lines | |
394 :py (row,col) = b.mark('a') # named mark | |
395 :py r = b.range(1,5) # a sub-range of the buffer | |
4323 | 396 :py b.vars["foo"] = "bar" # assign b:foo variable |
4350 | 397 :py b.options["ff"] = "dos" # set fileformat |
398 :py del b.options["ar"] # same as :set autoread< | |
7 | 399 |
400 ============================================================================== | |
401 4. Range objects *python-range* | |
402 | |
236 | 403 Range objects represent a part of a vim buffer. You can obtain them in a |
7 | 404 number of ways: |
405 - via vim.current.range (|python-current|) | |
406 - from a buffer's range() method (|python-buffer|) | |
407 | |
236 | 408 A range object is almost identical in operation to a buffer object. However, |
7 | 409 all operations are restricted to the lines within the range (this line range |
410 can, of course, change as a result of slice assignments, line deletions, or | |
411 the range.append() method). | |
412 | |
413 The range object attributes are: | |
414 r.start Index of first line into the buffer | |
415 r.end Index of last line into the buffer | |
416 | |
417 The range object methods are: | |
418 r.append(str) Append a line to the range | |
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
419 r.append(str, nr) Idem, after line "nr" |
7 | 420 r.append(list) Append a list of lines to the range |
421 Note that the option of supplying a list of strings to | |
422 the append method differs from the equivalent method | |
423 for Python's built-in list objects. | |
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
424 r.append(list, nr) Idem, after line "nr" |
7 | 425 |
4496 | 426 Range object type is available using "Range" attribute of vim module. |
427 | |
7 | 428 Example (assume r is the current range): |
429 # Send all lines in a range to the default printer | |
430 vim.command("%d,%dhardcopy!" % (r.start+1,r.end+1)) | |
431 | |
432 ============================================================================== | |
433 5. Window objects *python-window* | |
434 | |
236 | 435 Window objects represent vim windows. You can obtain them in a number of ways: |
7 | 436 - via vim.current.window (|python-current|) |
437 - from indexing vim.windows (|python-windows|) | |
4401 | 438 - from indexing "windows" attribute of a tab page (|python-tabpage|) |
439 - from the "window" attribute of a tab page (|python-tabpage|) | |
7 | 440 |
236 | 441 You can manipulate window objects only through their attributes. They have no |
7 | 442 methods, and no sequence or other interface. |
443 | |
444 Window attributes are: | |
445 buffer (read-only) The buffer displayed in this window | |
446 cursor (read-write) The current cursor position in the window | |
447 This is a tuple, (row,col). | |
448 height (read-write) The window height, in rows | |
449 width (read-write) The window width, in columns | |
4323 | 450 vars (read-only) The window |w:| variables. Attribute is |
451 unassignable, but you can change window | |
452 variables this way | |
4350 | 453 options (read-only) The window-local options. Attribute is |
454 unassignable, but you can change window | |
455 options this way. Provides access only to | |
456 window-local options, for buffer-local use | |
457 |python-buffer| and for global ones use | |
458 |python-options|. If option is |global-local| | |
459 and local value is missing getting it will | |
460 return None. | |
4379 | 461 number (read-only) Window number. The first window has number 1. |
462 This is zero in case it cannot be determined | |
463 (e.g. when the window object belongs to other | |
464 tab page). | |
4431 | 465 row, col (read-only) On-screen window position in display cells. |
4383 | 466 First position is zero. |
4431 | 467 tabpage (read-only) Window tab page. |
4383 | 468 |
7 | 469 The height attribute is writable only if the screen is split horizontally. |
470 The width attribute is writable only if the screen is split vertically. | |
471 | |
4496 | 472 Window object type is available using "Window" attribute of vim module. |
473 | |
7 | 474 ============================================================================== |
4401 | 475 6. Tab page objects *python-tabpage* |
476 | |
477 Tab page objects represent vim tab pages. You can obtain them in a number of | |
478 ways: | |
479 - via vim.current.tabpage (|python-current|) | |
480 - from indexing vim.tabpages (|python-tabpages|) | |
481 | |
482 You can use this object to access tab page windows. They have no methods and | |
483 no sequence or other interfaces. | |
484 | |
485 Tab page attributes are: | |
486 number The tab page number like the one returned by | |
487 |tabpagenr()|. | |
488 windows Like |python-windows|, but for current tab page. | |
489 vars The tab page |t:| variables. | |
490 window Current tabpage window. | |
491 | |
4496 | 492 TabPage object type is available using "TabPage" attribute of vim module. |
493 | |
4401 | 494 ============================================================================== |
4496 | 495 7. pyeval() and py3eval() Vim functions *python-pyeval* |
3682 | 496 |
497 To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| | |
498 functions to evaluate Python expressions and pass their values to VimL. | |
499 | |
500 ============================================================================== | |
4496 | 501 8. Dynamic loading *python-dynamic* |
557 | 502 |
503 On MS-Windows the Python library can be loaded dynamically. The |:version| | |
504 output then includes |+python/dyn|. | |
505 | |
506 This means that Vim will search for the Python DLL file only when needed. | |
507 When you don't use the Python interface you don't need it, thus you can use | |
508 Vim without this DLL file. | |
509 | |
510 To use the Python interface the Python DLL must be in your search path. In a | |
511 console window type "path" to see what directories are used. | |
512 | |
513 The name of the DLL must match the Python version Vim was compiled with. | |
514 Currently the name is "python24.dll". That is for Python 2.4. To know for | |
515 sure edit "gvim.exe" and search for "python\d*.dll\c". | |
516 | |
517 ============================================================================== | |
4496 | 518 9. Python 3 *python3* |
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
519 |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
520 *:py3* *:python3* |
4435 | 521 The `:py3` and `:python3` commands work similar to `:python`. A simple check |
4098 | 522 if the `:py3` command is working: > |
3750 | 523 :py3 print("Hello") |
524 < *:py3file* | |
4435 | 525 The `:py3file` command works similar to `:pyfile`. |
4431 | 526 *:py3do* *E863* |
4435 | 527 The `:py3do` command works similar to `:pydo`. |
4417 | 528 |
3682 | 529 |
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
530 Vim can be built in four ways (:version output): |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
531 1. No Python support (-python, -python3) |
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
532 2. Python 2 support only (+python or +python/dyn, -python3) |
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
533 3. Python 3 support only (-python, +python3 or +python3/dyn) |
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
534 4. Python 2 and 3 support (+python/dyn, +python3/dyn) |
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
535 |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
536 Some more details on the special case 4: |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
537 |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
538 When Python 2 and Python 3 are both supported they must be loaded dynamically. |
2540 | 539 |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
540 When doing this on Linux/Unix systems and importing global symbols, this leads |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
541 to a crash when the second Python version is used. So either global symbols |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
542 are loaded but only one Python version is activated, or no global symbols are |
2608
7d8af31066c8
Updated runtime files and translations.
Bram Moolenaar <bram@vim.org>
parents:
2577
diff
changeset
|
543 loaded. The latter makes Python's "import" fail on libraries that expect the |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
544 symbols to be provided by Vim. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
545 *E836* *E837* |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
546 Vim's configuration script makes a guess for all libraries based on one |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
547 standard Python library (termios). If importing this library succeeds for |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
548 both Python versions, then both will be made available in Vim at the same |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
549 time. If not, only the version first used in a session will be enabled. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
550 When trying to use the other one you will get the E836 or E837 error message. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
551 |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
552 Here Vim's behavior depends on the system in which it was configured. In a |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
553 system where both versions of Python were configured with --enable-shared, |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
554 both versions of Python will be activated at the same time. There will still |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
555 be problems with other third party libraries that were not linked to |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
556 libPython. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
557 |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
558 To work around such problems there are these options: |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
559 1. The problematic library is recompiled to link to the according |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
560 libpython.so. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
561 2. Vim is recompiled for only one Python version. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
562 3. You undefine PY_NO_RTLD_GLOBAL in auto/config.h after configuration. This |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
563 may crash Vim though. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
564 |
2826 | 565 *has-python* |
566 You can test what Python version is available with: > | |
567 if has('python') | |
3082 | 568 echo 'there is Python 2.x' |
2826 | 569 elseif has('python3') |
570 echo 'there is Python 3.x' | |
571 endif | |
572 | |
573 Note however, that when Python 2 and 3 are both available and loaded | |
574 dynamically, these has() calls will try to load them. If only one can be | |
575 loaded at a time, just checking if Python 2 or 3 are available will prevent | |
576 the other one from being available. | |
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
577 |
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
578 ============================================================================== |
7 | 579 vim:tw=78:ts=8:ft=help:norl: |