Mercurial > vim
annotate runtime/doc/if_pyth.txt @ 4851:96e154e825a7 v7.3.1172
updated for version 7.3.1172
Problem: Python 2: loading modules doesn't work well.
Solution: Fix the code. Add more tests. (ZyX)
author | Bram Moolenaar <bram@vim.org> |
---|---|
date | Wed, 12 Jun 2013 14:20:36 +0200 |
parents | 70b1178dec79 |
children | 52850ef928f8 |
rev | line source |
---|---|
4780 | 1 *if_pyth.txt* For Vim version 7.3. Last change: 2013 Jun 02 |
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| |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
15 7. vim.bindeval objects |python-bindeval-objects| |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
16 8. pyeval(), py3eval() Vim functions |python-pyeval| |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
17 9. Dynamic loading |python-dynamic| |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
18 10. Python 3 |python3| |
7 | 19 |
20 {Vi does not have any of these commands} | |
21 | |
2350
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
22 The Python 2.x interface is available only when Vim was compiled with the |
7 | 23 |+python| feature. |
2350
06feaf4fe36a
Rename some "python3" symbols to "py3", as the command name.
Bram Moolenaar <bram@vim.org>
parents:
2345
diff
changeset
|
24 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
|
25 |+python3| feature. |
7 | 26 |
27 ============================================================================== | |
28 1. Commands *python-commands* | |
29 | |
30 *:python* *:py* *E205* *E263* *E264* | |
31 :[range]py[thon] {stmt} | |
3750 | 32 Execute Python statement {stmt}. A simple check if |
33 the `:python` command is working: > | |
34 :python print "Hello" | |
7 | 35 |
36 :[range]py[thon] << {endmarker} | |
37 {script} | |
38 {endmarker} | |
39 Execute Python script {script}. | |
40 Note: This command doesn't work when the Python | |
41 feature wasn't compiled in. To avoid errors, see | |
42 |script-here|. | |
43 | |
44 {endmarker} must NOT be preceded by any white space. If {endmarker} is | |
45 omitted from after the "<<", a dot '.' must be used after {script}, like | |
46 for the |:append| and |:insert| commands. | |
47 This form of the |:python| command is mainly useful for including python code | |
48 in Vim scripts. | |
49 | |
50 Example: > | |
51 function! IcecreamInitialize() | |
52 python << EOF | |
53 class StrawberryIcecream: | |
54 def __call__(self): | |
55 print 'EAT ME' | |
56 EOF | |
57 endfunction | |
58 < | |
4073 | 59 Note: Python is very sensitive to the indenting. Make sure the "class" line |
60 and "EOF" do not have any indent. | |
7 | 61 |
4435 | 62 *:pydo* |
63 :[range]pydo {body} Execute Python function "def _vim_pydo(line, linenr): | |
64 {body}" for each line in the [range], with the | |
65 function arguments being set to the text of each line | |
66 in turn, without a trailing <EOL>, and the current | |
67 line number. The function should return a string or | |
68 None. If a string is returned, it becomes the text of | |
69 the line in the current turn. The default for [range] | |
70 is the whole file: "1,$". | |
71 {not in Vi} | |
72 | |
73 Examples: | |
74 > | |
75 :pydo return "%s\t%d" % (line[::-1], len(line)) | |
76 :pydo if line: return "%4d: %s" % (linenr, line) | |
77 < | |
7 | 78 *:pyfile* *:pyf* |
79 :[range]pyf[ile] {file} | |
80 Execute the Python script in {file}. The whole | |
81 argument is used as a single file name. {not in Vi} | |
82 | |
83 Both of these commands do essentially the same thing - they execute a piece of | |
84 Python code, with the "current range" |python-range| set to the given line | |
85 range. | |
86 | |
87 In the case of :python, the code to execute is in the command-line. | |
88 In the case of :pyfile, the code to execute is the contents of the given file. | |
89 | |
90 Python commands cannot be used in the |sandbox|. | |
91 | |
92 To pass arguments you need to set sys.argv[] explicitly. Example: > | |
93 | |
94 :python import sys | |
95 :python sys.argv = ["foo", "bar"] | |
96 :pyfile myscript.py | |
97 | |
98 Here are some examples *python-examples* > | |
99 | |
100 :python from vim import * | |
101 :python from string import upper | |
102 :python current.line = upper(current.line) | |
103 :python print "Hello" | |
104 :python str = current.buffer[42] | |
105 | |
106 (Note that changes - like the imports - persist from one command to the next, | |
107 just like in the Python interpreter.) | |
108 | |
109 ============================================================================== | |
110 2. The vim module *python-vim* | |
111 | |
112 Python code gets all of its access to vim (with one exception - see | |
236 | 113 |python-output| below) via the "vim" module. The vim module implements two |
7 | 114 methods, three constants, and one error object. You need to import the vim |
115 module before using it: > | |
116 :python import vim | |
117 | |
118 Overview > | |
20 | 119 :py print "Hello" # displays a message |
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
120 :py vim.command(cmd) # execute an Ex command |
20 | 121 :py w = vim.windows[n] # gets window "n" |
122 :py cw = vim.current.window # gets the current window | |
123 :py b = vim.buffers[n] # gets buffer "n" | |
124 :py cb = vim.current.buffer # gets the current buffer | |
125 :py w.height = lines # sets the window height | |
126 :py w.cursor = (row, col) # sets the window cursor position | |
127 :py pos = w.cursor # gets a tuple (row, col) | |
128 :py name = b.name # gets the buffer file name | |
129 :py line = b[n] # gets a line from the buffer | |
130 :py lines = b[n:m] # gets a list of lines | |
131 :py num = len(b) # gets the number of lines | |
132 :py b[n] = str # sets a line in the buffer | |
133 :py b[n:m] = [str1, str2, str3] # sets a number of lines at once | |
134 :py del b[n] # deletes a line | |
135 :py del b[n:m] # deletes a number of lines | |
7 | 136 |
137 | |
138 Methods of the "vim" module | |
139 | |
140 vim.command(str) *python-command* | |
236 | 141 Executes the vim (ex-mode) command str. Returns None. |
7 | 142 Examples: > |
20 | 143 :py vim.command("set tw=72") |
144 :py vim.command("%s/aaa/bbb/g") | |
7 | 145 < The following definition executes Normal mode commands: > |
146 def normal(str): | |
147 vim.command("normal "+str) | |
148 # Note the use of single quotes to delimit a string containing | |
149 # double quotes | |
150 normal('"a2dd"aP') | |
151 < *E659* | |
152 The ":python" command cannot be used recursively with Python 2.2 and | |
153 older. This only works with Python 2.3 and later: > | |
20 | 154 :py vim.command("python print 'Hello again Python'") |
7 | 155 |
156 vim.eval(str) *python-eval* | |
157 Evaluates the expression str using the vim internal expression | |
633 | 158 evaluator (see |expression|). Returns the expression result as: |
159 - a string if the Vim expression evaluates to a string or number | |
160 - a list if the Vim expression evaluates to a Vim list | |
856 | 161 - a dictionary if the Vim expression evaluates to a Vim dictionary |
633 | 162 Dictionaries and lists are recursively expanded. |
7 | 163 Examples: > |
20 | 164 :py text_width = vim.eval("&tw") |
165 :py str = vim.eval("12+12") # NB result is a string! Use | |
7 | 166 # string.atoi() to convert to |
167 # a number. | |
168 | |
856 | 169 :py tagList = vim.eval('taglist("eval_expr")') |
633 | 170 < The latter will return a python list of python dicts, for instance: |
171 [{'cmd': '/^eval_expr(arg, nextcmd)$/', 'static': 0, 'name': | |
172 'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}] | |
173 | |
3682 | 174 vim.bindeval(str) *python-bindeval* |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
175 Like |python-eval|, but returns special objects described in |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
176 |python-bindeval-objects|. These python objects let you modify (|List| |
4698
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
177 or |Dictionary|) or call (|Funcref|) vim objects. |
633 | 178 |
4700
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
179 vim.strwidth(str) *python-strwidth* |
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
180 Like |strwidth()|: returns number of display cells str occupies, tab |
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
181 is counted as one cell. |
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
182 |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
183 vim.foreach_rtp(callable) *python-foreach_rtp* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
184 Call the given callable for each path in 'runtimepath' until either |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
185 callable returns something but None, the exception is raised or there |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
186 are no longer paths. If stopped in case callable returned non-None, |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
187 vim.foreach_rtp function returns the value returned by callable. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
188 |
4704
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
189 vim.chdir(*args, **kwargs) *python-chdir* |
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
190 vim.fchdir(*args, **kwargs) *python-fchdir* |
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
191 Run os.chdir or os.fchdir, then all appropriate vim stuff. |
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
192 Note: you should not use these functions directly, use os.chdir and |
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
193 os.fchdir instead. Behavior of vim.fchdir is undefined in case |
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
194 os.fchdir does not exist. |
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
195 |
7 | 196 Error object of the "vim" module |
197 | |
198 vim.error *python-error* | |
199 Upon encountering a Vim error, Python raises an exception of type | |
200 vim.error. | |
201 Example: > | |
202 try: | |
203 vim.command("put a") | |
204 except vim.error: | |
205 # nothing in register a | |
206 | |
207 Constants of the "vim" module | |
208 | |
209 Note that these are not actually constants - you could reassign them. | |
210 But this is silly, as you would then lose access to the vim objects | |
211 to which the variables referred. | |
212 | |
213 vim.buffers *python-buffers* | |
4393 | 214 A mapping object providing access to the list of vim buffers. The |
7 | 215 object supports the following operations: > |
20 | 216 :py b = vim.buffers[i] # Indexing (read-only) |
217 :py b in vim.buffers # Membership test | |
218 :py n = len(vim.buffers) # Number of elements | |
4397 | 219 :py for b in vim.buffers: # Iterating over buffer list |
7 | 220 < |
221 vim.windows *python-windows* | |
236 | 222 A sequence object providing access to the list of vim windows. The |
7 | 223 object supports the following operations: > |
20 | 224 :py w = vim.windows[i] # Indexing (read-only) |
225 :py w in vim.windows # Membership test | |
226 :py n = len(vim.windows) # Number of elements | |
227 :py for w in vim.windows: # Sequential access | |
4698
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
228 < Note: vim.windows object always accesses current tab page. |
4401 | 229 |python-tabpage|.windows objects are bound to parent |python-tabpage| |
230 object and always use windows from that tab page (or throw vim.error | |
231 in case tab page was deleted). You can keep a reference to both | |
232 without keeping a reference to vim module object or |python-tabpage|, | |
4589
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
233 they will not lose their properties in this case. |
4401 | 234 |
235 vim.tabpages *python-tabpages* | |
236 A sequence object providing access to the list of vim tab pages. The | |
237 object supports the following operations: > | |
238 :py t = vim.tabpages[i] # Indexing (read-only) | |
239 :py t in vim.tabpages # Membership test | |
240 :py n = len(vim.tabpages) # Number of elements | |
241 :py for t in vim.tabpages: # Sequential access | |
7 | 242 < |
243 vim.current *python-current* | |
244 An object providing access (via specific attributes) to various | |
245 "current" objects available in vim: | |
246 vim.current.line The current line (RW) String | |
4407 | 247 vim.current.buffer The current buffer (RW) Buffer |
248 vim.current.window The current window (RW) Window | |
249 vim.current.tabpage The current tab page (RW) TabPage | |
7 | 250 vim.current.range The current line range (RO) Range |
251 | |
236 | 252 The last case deserves a little explanation. When the :python or |
7 | 253 :pyfile command specifies a range, this range of lines becomes the |
236 | 254 "current range". A range is a bit like a buffer, but with all access |
255 restricted to a subset of lines. See |python-range| for more details. | |
7 | 256 |
4407 | 257 Note: When assigning to vim.current.{buffer,window,tabpage} it expects |
258 valid |python-buffer|, |python-window| or |python-tabpage| objects | |
259 respectively. Assigning triggers normal (with |autocommand|s) | |
260 switching to given buffer, window or tab page. It is the only way to | |
261 switch UI objects in python: you can't assign to | |
262 |python-tabpage|.window attribute. To switch without triggering | |
263 autocommands use > | |
264 py << EOF | |
265 saved_eventignore = vim.options['eventignore'] | |
266 vim.options['eventignore'] = 'all' | |
267 try: | |
268 vim.current.buffer = vim.buffers[2] # Switch to buffer 2 | |
269 finally: | |
270 vim.options['eventignore'] = saved_eventignore | |
271 EOF | |
272 < | |
4323 | 273 vim.vars *python-vars* |
274 vim.vvars *python-vvars* | |
275 Dictionary-like objects holding dictionaries with global (|g:|) and | |
276 vim (|v:|) variables respectively. Identical to `vim.bindeval("g:")`, | |
277 but faster. | |
7 | 278 |
4350 | 279 vim.options *python-options* |
280 Object partly supporting mapping protocol (supports setting and | |
281 getting items) providing a read-write access to global options. | |
282 Note: unlike |:set| this provides access only to global options. You | |
283 cannot use this object to obtain or set local options' values or | |
284 access local-only options in any fashion. Raises KeyError if no global | |
285 option with such name exists (i.e. does not raise KeyError for | |
286 |global-local| options and global only options, but does for window- | |
287 and buffer-local ones). Use |python-buffer| objects to access to | |
288 buffer-local options and |python-window| objects to access to | |
289 window-local options. | |
290 | |
4496 | 291 Type of this object is available via "Options" attribute of vim |
292 module. | |
293 | |
7 | 294 Output from Python *python-output* |
295 Vim displays all Python code output in the Vim message area. Normal | |
296 output appears as information messages, and error output appears as | |
297 error messages. | |
298 | |
299 In implementation terms, this means that all output to sys.stdout | |
300 (including the output from print statements) appears as information | |
301 messages, and all output to sys.stderr (including error tracebacks) | |
302 appears as error messages. | |
303 | |
304 *python-input* | |
305 Input (via sys.stdin, including input() and raw_input()) is not | |
236 | 306 supported, and may cause the program to crash. This should probably be |
7 | 307 fixed. |
308 | |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
309 *python2-directory* *python3-directory* *pythonx-directory* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
310 Python 'runtimepath' handling *python-special-path* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
311 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
312 In python vim.VIM_SPECIAL_PATH special directory is used as a replacement for |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
313 the list of paths found in 'runtimepath': with this directory in sys.path and |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
314 vim.path_hooks in sys.path_hooks python will try to load module from |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
315 {rtp}/python2 (or python3) and {rtp}/pythonx (for both python versions) for |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
316 each {rtp} found in 'runtimepath'. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
317 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
318 Implementation for python 2 is similar to the following, but written in C: > |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
319 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
320 from imp import find_module, load_module |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
321 import vim |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
322 import sys |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
323 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
324 class VimModuleLoader(object): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
325 def __init__(self, module): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
326 self.module = module |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
327 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
328 def load_module(self, fullname, path=None): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
329 return self.module |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
330 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
331 def _find_module(fullname, oldtail, path): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
332 idx = oldtail.find('.') |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
333 if idx > 0: |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
334 name = oldtail[:idx] |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
335 tail = oldtail[idx+1:] |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
336 fmr = find_module(name, path) |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
337 module = load_module(fullname[:-len(oldtail)] + name, *fmr) |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
338 return _find_module(fullname, tail, module.__path__) |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
339 else: |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
340 fmr = find_module(fullname, path) |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
341 return load_module(fullname, *fmr) |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
342 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
343 # It uses vim module itself in place of VimPathFinder class: it does not |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
344 # matter for python which object has find_module function attached to as |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
345 # an attribute. |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
346 class VimPathFinder(object): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
347 def find_module(cls, fullname, path=None): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
348 try: |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
349 return VimModuleLoader(_find_module(fullname, fullname, path or vim._get_paths())) |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
350 except ImportError: |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
351 return None |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
352 find_module = classmethod(find_module) |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
353 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
354 def load_module(cls, fullname, path=None): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
355 return _find_module(fullname, fullname, path or vim._get_paths()) |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
356 load_module = classmethod(load_module) |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
357 |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
358 def hook(path): |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
359 if path == vim.VIM_SPECIAL_PATH: |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
360 return VimPathFinder |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
361 else: |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
362 raise ImportError |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
363 |
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
364 sys.path_hooks.append(hook) |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
365 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
366 Implementation for python 3 is cleaner: code is similar to the following, but, |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
367 again, written in C: > |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
368 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
369 from importlib.machinery import PathFinder |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
370 import sys |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
371 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
372 class Finder(PathFinder): |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
373 @classmethod |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
374 def find_module(cls, fullname): |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
375 # see vim._get_paths below |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
376 new_path = _get_paths() |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
377 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
378 # super().find_module is also a class method |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
379 # super() is not used because this variant is easier to implement |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
380 # in C |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
381 return PathFinder.find_module(fullname, new_path) |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
382 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
383 def path_hook(path): |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
384 if path == VIM_SPECIAL_PATH: |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
385 return Finder |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
386 raise ImportError |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
387 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
388 sys.path_hooks.append(path_hook) |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
389 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
390 vim.VIM_SPECIAL_PATH *python-VIM_SPECIAL_PATH* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
391 String constant used in conjunction with vim path hook. If path hook |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
392 installed by vim is requested to handle anything but path equal to |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
393 vim.VIM_SPECIAL_PATH constant it raises ImportError. In the only other |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
394 case it uses special loader. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
395 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
396 Note: you must not use value of this constant directly, always use |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
397 vim.VIM_SPECIAL_PATH object. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
398 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
399 vim.find_module(...) *python-find_module* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
400 vim.path_hook(path) *python-path_hook* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
401 Methods or objects used to implement path loading as described above. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
402 You should not be using any of these directly except for vim.path_hook |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
403 in case you need to do something with sys.meta_path. It is not |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
404 guaranteed that any of the objects will exist in the future vim |
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
405 versions. In fact, find_module methods do not exists |
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
406 in python3. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
407 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
408 vim._get_paths *python-_get_paths* |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
409 Methods returning a list of paths which will be searched for by path |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
410 hook. You should not rely on this method being present in future |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
411 versions, but can use it for debugging. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
412 |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
413 It returns a list of {rtp}/python2 (or {rtp}/python3) and |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
414 {rtp}/pythonx directories for each {rtp} in 'runtimepath'. |
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
415 |
7 | 416 ============================================================================== |
417 3. Buffer objects *python-buffer* | |
418 | |
236 | 419 Buffer objects represent vim buffers. You can obtain them in a number of ways: |
7 | 420 - via vim.current.buffer (|python-current|) |
421 - from indexing vim.buffers (|python-buffers|) | |
422 - from the "buffer" attribute of a window (|python-window|) | |
423 | |
3312 | 424 Buffer objects have two read-only attributes - name - the full file name for |
425 the buffer, and number - the buffer number. They also have three methods | |
426 (append, mark, and range; see below). | |
7 | 427 |
236 | 428 You can also treat buffer objects as sequence objects. In this context, they |
7 | 429 act as if they were lists (yes, they are mutable) of strings, with each |
236 | 430 element being a line of the buffer. All of the usual sequence operations, |
7 | 431 including indexing, index assignment, slicing and slice assignment, work as |
236 | 432 you would expect. Note that the result of indexing (slicing) a buffer is a |
433 string (list of strings). This has one unusual consequence - b[:] is different | |
434 from b. In particular, "b[:] = None" deletes the whole of the buffer, whereas | |
7 | 435 "b = None" merely updates the variable b, with no effect on the buffer. |
436 | |
236 | 437 Buffer indexes start at zero, as is normal in Python. This differs from vim |
438 line numbers, which start from 1. This is particularly relevant when dealing | |
7 | 439 with marks (see below) which use vim line numbers. |
440 | |
4350 | 441 The buffer object attributes are: |
442 b.vars Dictionary-like object used to access | |
443 |buffer-variable|s. | |
444 b.options Mapping object (supports item getting, setting and | |
445 deleting) that provides access to buffer-local options | |
446 and buffer-local values of |global-local| options. Use | |
447 |python-window|.options if option is window-local, | |
448 this object will raise KeyError. If option is | |
449 |global-local| and local value is missing getting it | |
450 will return None. | |
4589
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
451 b.name String, RW. Contains buffer name (full path). |
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
452 Note: when assigning to b.name |BufFilePre| and |
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
453 |BufFilePost| autocommands are launched. |
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
454 b.number Buffer number. Can be used as |python-buffers| key. |
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
455 Read-only. |
4780 | 456 b.valid True or False. Buffer object becomes invalid when |
4700
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
457 corresponding buffer is wiped out. |
4350 | 458 |
7 | 459 The buffer object methods are: |
460 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
|
461 b.append(str, nr) Idem, below line "nr" |
7 | 462 b.append(list) Append a list of lines to the buffer |
463 Note that the option of supplying a list of strings to | |
464 the append method differs from the equivalent method | |
465 for Python's built-in list objects. | |
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
466 b.append(list, nr) Idem, below line "nr" |
7 | 467 b.mark(name) Return a tuple (row,col) representing the position |
468 of the named mark (can also get the []"<> marks) | |
469 b.range(s,e) Return a range object (see |python-range|) which | |
470 represents the part of the given buffer between line | |
471 numbers s and e |inclusive|. | |
472 | |
20 | 473 Note that when adding a line it must not contain a line break character '\n'. |
474 A trailing '\n' is allowed and ignored, so that you can do: > | |
475 :py b.append(f.readlines()) | |
476 | |
4496 | 477 Buffer object type is available using "Buffer" attribute of vim module. |
478 | |
7 | 479 Examples (assume b is the current buffer) > |
20 | 480 :py print b.name # write the buffer file name |
481 :py b[0] = "hello!!!" # replace the top line | |
482 :py b[:] = None # delete the whole buffer | |
483 :py del b[:] # delete the whole buffer | |
484 :py b[0:0] = [ "a line" ] # add a line at the top | |
485 :py del b[2] # delete a line (the third) | |
486 :py b.append("bottom") # add a line at the bottom | |
487 :py n = len(b) # number of lines | |
488 :py (row,col) = b.mark('a') # named mark | |
489 :py r = b.range(1,5) # a sub-range of the buffer | |
4323 | 490 :py b.vars["foo"] = "bar" # assign b:foo variable |
4350 | 491 :py b.options["ff"] = "dos" # set fileformat |
492 :py del b.options["ar"] # same as :set autoread< | |
7 | 493 |
494 ============================================================================== | |
495 4. Range objects *python-range* | |
496 | |
236 | 497 Range objects represent a part of a vim buffer. You can obtain them in a |
7 | 498 number of ways: |
499 - via vim.current.range (|python-current|) | |
500 - from a buffer's range() method (|python-buffer|) | |
501 | |
236 | 502 A range object is almost identical in operation to a buffer object. However, |
7 | 503 all operations are restricted to the lines within the range (this line range |
504 can, of course, change as a result of slice assignments, line deletions, or | |
505 the range.append() method). | |
506 | |
507 The range object attributes are: | |
508 r.start Index of first line into the buffer | |
509 r.end Index of last line into the buffer | |
510 | |
511 The range object methods are: | |
512 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
|
513 r.append(str, nr) Idem, after line "nr" |
7 | 514 r.append(list) Append a list of lines to the range |
515 Note that the option of supplying a list of strings to | |
516 the append method differs from the equivalent method | |
517 for Python's built-in list objects. | |
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
518 r.append(list, nr) Idem, after line "nr" |
7 | 519 |
4496 | 520 Range object type is available using "Range" attribute of vim module. |
521 | |
7 | 522 Example (assume r is the current range): |
523 # Send all lines in a range to the default printer | |
524 vim.command("%d,%dhardcopy!" % (r.start+1,r.end+1)) | |
525 | |
526 ============================================================================== | |
527 5. Window objects *python-window* | |
528 | |
236 | 529 Window objects represent vim windows. You can obtain them in a number of ways: |
7 | 530 - via vim.current.window (|python-current|) |
531 - from indexing vim.windows (|python-windows|) | |
4401 | 532 - from indexing "windows" attribute of a tab page (|python-tabpage|) |
533 - from the "window" attribute of a tab page (|python-tabpage|) | |
7 | 534 |
236 | 535 You can manipulate window objects only through their attributes. They have no |
7 | 536 methods, and no sequence or other interface. |
537 | |
538 Window attributes are: | |
539 buffer (read-only) The buffer displayed in this window | |
540 cursor (read-write) The current cursor position in the window | |
541 This is a tuple, (row,col). | |
542 height (read-write) The window height, in rows | |
543 width (read-write) The window width, in columns | |
4323 | 544 vars (read-only) The window |w:| variables. Attribute is |
545 unassignable, but you can change window | |
546 variables this way | |
4350 | 547 options (read-only) The window-local options. Attribute is |
548 unassignable, but you can change window | |
549 options this way. Provides access only to | |
550 window-local options, for buffer-local use | |
551 |python-buffer| and for global ones use | |
552 |python-options|. If option is |global-local| | |
553 and local value is missing getting it will | |
554 return None. | |
4379 | 555 number (read-only) Window number. The first window has number 1. |
556 This is zero in case it cannot be determined | |
557 (e.g. when the window object belongs to other | |
558 tab page). | |
4431 | 559 row, col (read-only) On-screen window position in display cells. |
4383 | 560 First position is zero. |
4431 | 561 tabpage (read-only) Window tab page. |
4780 | 562 valid (read-write) True or False. Window object becomes invalid |
4700
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
563 when corresponding window is closed. |
4383 | 564 |
7 | 565 The height attribute is writable only if the screen is split horizontally. |
566 The width attribute is writable only if the screen is split vertically. | |
567 | |
4496 | 568 Window object type is available using "Window" attribute of vim module. |
569 | |
7 | 570 ============================================================================== |
4401 | 571 6. Tab page objects *python-tabpage* |
572 | |
573 Tab page objects represent vim tab pages. You can obtain them in a number of | |
574 ways: | |
575 - via vim.current.tabpage (|python-current|) | |
576 - from indexing vim.tabpages (|python-tabpages|) | |
577 | |
578 You can use this object to access tab page windows. They have no methods and | |
579 no sequence or other interfaces. | |
580 | |
581 Tab page attributes are: | |
582 number The tab page number like the one returned by | |
583 |tabpagenr()|. | |
584 windows Like |python-windows|, but for current tab page. | |
585 vars The tab page |t:| variables. | |
586 window Current tabpage window. | |
4780 | 587 valid True or False. Tab page object becomes invalid when |
4700
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
588 corresponding tab page is closed. |
4401 | 589 |
4496 | 590 TabPage object type is available using "TabPage" attribute of vim module. |
591 | |
4401 | 592 ============================================================================== |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
593 7. vim.bindeval objects *python-bindeval-objects* |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
594 |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
595 vim.Dictionary object *python-Dictionary* |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
596 Dictionary-like object providing access to vim |Dictionary| type. |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
597 Attributes: |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
598 Attribute Description ~ |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
599 locked One of *python-.locked* |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
600 Value Description ~ |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
601 zero Variable is not locked |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
602 vim.VAR_LOCKED Variable is locked, but can be unlocked |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
603 vim.VAR_FIXED Variable is locked and can't be unlocked |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
604 Read-write. You can unlock locked variable by assigning |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
605 `True` or `False` to this attribute. No recursive locking |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
606 is supported. |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
607 scope One of |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
608 Value Description ~ |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
609 zero Dictionary is not a scope one |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
610 vim.VAR_DEF_SCOPE |g:| or |l:| dictionary |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
611 vim.VAR_SCOPE Other scope dictionary, |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
612 see |internal-variables| |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
613 Methods (note: methods do not support keyword arguments): |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
614 Method Description ~ |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
615 keys() Returns a list with dictionary keys. |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
616 values() Returns a list with dictionary values. |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
617 items() Returns a list of 2-tuples with dictionary contents. |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
618 update(iterable), update(dictionary), update(**kwargs) |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
619 Adds keys to dictionary. |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
620 get(key[, default=None]) |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
621 Obtain key from dictionary, returning the default if it is |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
622 not present. |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
623 pop(key[, default]) |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
624 Remove specified key from dictionary and return |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
625 corresponding value. If key is not found and default is |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
626 given returns the default, otherwise raises KeyError. |
4698
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
627 popitem() |
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
628 Remove random key from dictionary and return (key, value) |
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
629 pair. |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
630 has_key(key) |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
631 Check whether dictionary contains specified key, similar |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
632 to `key in dict`. |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
633 |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
634 __new__(), __new__(iterable), __new__(dictionary), __new__(update) |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
635 You can use `vim.Dictionary()` to create new vim |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
636 dictionaries. `d=vim.Dictionary(arg)` is the same as |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
637 `d=vim.bindeval('{}');d.update(arg)`. Without arguments |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
638 constructs empty dictionary. |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
639 |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
640 Examples: > |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
641 d = vim.Dictionary(food="bar") # Constructor |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
642 d['a'] = 'b' # Item assignment |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
643 print d['a'] # getting item |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
644 d.update({'c': 'd'}) # .update(dictionary) |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
645 d.update(e='f') # .update(**kwargs) |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
646 d.update((('g', 'h'), ('i', 'j'))) # .update(iterable) |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
647 for key in d.keys(): # .keys() |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
648 for val in d.values(): # .values() |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
649 for key, val in d.items(): # .items() |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
650 print isinstance(d, vim.Dictionary) # True |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
651 for key in d: # Iteration over keys |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
652 class Dict(vim.Dictionary): # Subclassing |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
653 < |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
654 Note: when iterating over keys you should not modify dictionary. |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
655 |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
656 vim.List object *python-List* |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
657 Sequence-like object providing access to vim |List| type. |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
658 Supports `.locked` attribute, see |python-.locked|. Also supports the |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
659 following methods: |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
660 Method Description ~ |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
661 extend(item) Add items to the list. |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
662 |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
663 __new__(), __new__(iterable) |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
664 You can use `vim.List()` to create new vim lists. |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
665 `l=vim.List(iterable)` is the same as |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
666 `l=vim.bindeval('[]');l.extend(iterable)`. Without |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
667 arguments constructs empty list. |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
668 Examples: > |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
669 l = vim.List("abc") # Constructor, result: ['a', 'b', 'c'] |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
670 l.extend(['abc', 'def']) # .extend() method |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
671 print l[1:] # slicing |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
672 l[:0] = ['ghi', 'jkl'] # slice assignment |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
673 print l[0] # getting item |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
674 l[0] = 'mno' # assignment |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
675 for i in l: # iteration |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
676 print isinstance(l, vim.List) # True |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
677 class List(vim.List): # Subclassing |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
678 |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
679 vim.Function object *python-Function* |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
680 Function-like object, acting like vim |Funcref| object. Supports `.name` |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
681 attribute and is callable. Accepts special keyword argument `self`, see |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
682 |Dictionary-function|. You can also use `vim.Function(name)` constructor, |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
683 it is the same as `vim.bindeval('function(%s)'%json.dumps(name))`. |
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
684 |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
685 Examples: > |
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
686 f = vim.Function('tr') # Constructor |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
687 print f('abc', 'a', 'b') # Calls tr('abc', 'a', 'b') |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
688 vim.command(''' |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
689 function DictFun() dict |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
690 return self |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
691 endfunction |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
692 ''') |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
693 f = vim.bindeval('function("DictFun")') |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
694 print f(self={}) # Like call('DictFun', [], {}) |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
695 print isinstance(f, vim.Function) # True |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
696 |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
697 ============================================================================== |
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
698 8. pyeval() and py3eval() Vim functions *python-pyeval* |
3682 | 699 |
700 To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| | |
701 functions to evaluate Python expressions and pass their values to VimL. | |
702 | |
703 ============================================================================== | |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
704 9. Dynamic loading *python-dynamic* |
557 | 705 |
706 On MS-Windows the Python library can be loaded dynamically. The |:version| | |
707 output then includes |+python/dyn|. | |
708 | |
709 This means that Vim will search for the Python DLL file only when needed. | |
710 When you don't use the Python interface you don't need it, thus you can use | |
711 Vim without this DLL file. | |
712 | |
713 To use the Python interface the Python DLL must be in your search path. In a | |
714 console window type "path" to see what directories are used. | |
715 | |
716 The name of the DLL must match the Python version Vim was compiled with. | |
717 Currently the name is "python24.dll". That is for Python 2.4. To know for | |
718 sure edit "gvim.exe" and search for "python\d*.dll\c". | |
719 | |
720 ============================================================================== | |
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
721 10. Python 3 *python3* |
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
722 |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
723 *:py3* *:python3* |
4435 | 724 The `:py3` and `:python3` commands work similar to `:python`. A simple check |
4098 | 725 if the `:py3` command is working: > |
3750 | 726 :py3 print("Hello") |
727 < *:py3file* | |
4435 | 728 The `:py3file` command works similar to `:pyfile`. |
4431 | 729 *:py3do* *E863* |
4435 | 730 The `:py3do` command works similar to `:pydo`. |
4417 | 731 |
3682 | 732 |
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
733 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
|
734 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
|
735 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
|
736 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
|
737 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
|
738 |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
739 Some more details on the special case 4: |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
740 |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
741 When Python 2 and Python 3 are both supported they must be loaded dynamically. |
2540 | 742 |
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
743 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
|
744 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
|
745 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
|
746 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
|
747 symbols to be provided by Vim. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
748 *E836* *E837* |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
749 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
|
750 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
|
751 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
|
752 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
|
753 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
|
754 |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
755 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
|
756 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
|
757 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
|
758 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
|
759 libPython. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
760 |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
761 To work around such problems there are these options: |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
762 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
|
763 libpython.so. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
764 2. Vim is recompiled for only one Python version. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
765 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
|
766 may crash Vim though. |
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
767 |
2826 | 768 *has-python* |
769 You can test what Python version is available with: > | |
770 if has('python') | |
3082 | 771 echo 'there is Python 2.x' |
2826 | 772 elseif has('python3') |
773 echo 'there is Python 3.x' | |
774 endif | |
775 | |
776 Note however, that when Python 2 and 3 are both available and loaded | |
777 dynamically, these has() calls will try to load them. If only one can be | |
778 loaded at a time, just checking if Python 2 or 3 are available will prevent | |
779 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
|
780 |
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
781 ============================================================================== |
7 | 782 vim:tw=78:ts=8:ft=help:norl: |