Mercurial > vim
annotate runtime/doc/if_pyth.txt @ 16553:0e473e9e70c2 v8.1.1280
patch 8.1.1280: remarks about functionality not in Vi clutters the help
commit https://github.com/vim/vim/commit/25c9c680ec4dfbb51f4ef21c3460a48d3c67ffc8
Author: Bram Moolenaar <Bram@vim.org>
Date: Sun May 5 18:13:34 2019 +0200
patch 8.1.1280: remarks about functionality not in Vi clutters the help
Problem: Remarks about functionality not in Vi clutters the help.
Solution: Move all info about what is new in Vim or already existed in Vi to
vi_diff.txt. Remove {not in Vi} remarks. (closes #4268) Add
"noet" to the help files modeline. Also include many other help
file improvements.
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sun, 05 May 2019 18:15:06 +0200 |
| parents | 40ef13331e02 |
| children | 2704c4e3e20a |
| rev | line source |
|---|---|
|
16553
0e473e9e70c2
patch 8.1.1280: remarks about functionality not in Vi clutters the help
Bram Moolenaar <Bram@vim.org>
parents:
14864
diff
changeset
|
1 *if_pyth.txt* For Vim version 8.1. Last change: 2019 May 04 |
| 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| |
|
10722
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
19 11. Python X |python_x| |
| 11160 | 20 12. Building with Python support |python-building| |
| 7 | 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. |
| 5220 | 26 Both can be available at the same time, but read |python-2-and-3|. |
| 7 | 27 |
| 28 ============================================================================== | |
| 29 1. Commands *python-commands* | |
| 30 | |
|
6091
7090d7f160f7
Update runtime files. Add vroom file support.
Bram Moolenaar <bram@vim.org>
parents:
5294
diff
changeset
|
31 *:python* *:py* *E263* *E264* *E887* |
| 7 | 32 :[range]py[thon] {stmt} |
| 3750 | 33 Execute Python statement {stmt}. A simple check if |
| 34 the `:python` command is working: > | |
| 35 :python print "Hello" | |
| 7 | 36 |
| 37 :[range]py[thon] << {endmarker} | |
| 38 {script} | |
| 39 {endmarker} | |
| 40 Execute Python script {script}. | |
| 41 Note: This command doesn't work when the Python | |
| 42 feature wasn't compiled in. To avoid errors, see | |
| 43 |script-here|. | |
| 44 | |
| 45 {endmarker} must NOT be preceded by any white space. If {endmarker} is | |
| 46 omitted from after the "<<", a dot '.' must be used after {script}, like | |
| 47 for the |:append| and |:insert| commands. | |
| 48 This form of the |:python| command is mainly useful for including python code | |
| 49 in Vim scripts. | |
| 50 | |
| 51 Example: > | |
| 52 function! IcecreamInitialize() | |
| 53 python << EOF | |
| 54 class StrawberryIcecream: | |
| 55 def __call__(self): | |
| 56 print 'EAT ME' | |
| 57 EOF | |
| 58 endfunction | |
|
10140
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
59 |
|
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
60 To see what version of Python you have: > |
|
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
61 :python print(sys.version) |
|
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
62 |
| 14864 | 63 There is no need to import sys, it's done by default. |
| 64 | |
| 4073 | 65 Note: Python is very sensitive to the indenting. Make sure the "class" line |
| 66 and "EOF" do not have any indent. | |
| 7 | 67 |
| 4435 | 68 *:pydo* |
| 69 :[range]pydo {body} Execute Python function "def _vim_pydo(line, linenr): | |
| 70 {body}" for each line in the [range], with the | |
| 71 function arguments being set to the text of each line | |
| 72 in turn, without a trailing <EOL>, and the current | |
| 73 line number. The function should return a string or | |
| 74 None. If a string is returned, it becomes the text of | |
| 75 the line in the current turn. The default for [range] | |
| 76 is the whole file: "1,$". | |
| 77 | |
| 78 Examples: | |
| 79 > | |
| 80 :pydo return "%s\t%d" % (line[::-1], len(line)) | |
| 81 :pydo if line: return "%4d: %s" % (linenr, line) | |
| 82 < | |
| 14668 | 83 One can use `:pydo` in possible conjunction with `:py` to filter a range using |
| 84 python. For example: > | |
| 85 | |
| 86 :py3 << EOF | |
| 87 needle = vim.eval('@a') | |
| 88 replacement = vim.eval('@b') | |
| 89 | |
| 90 def py_vim_string_replace(str): | |
| 91 return str.replace(needle, replacement) | |
| 92 EOF | |
| 93 :'<,'>py3do return py_vim_string_replace(line) | |
| 94 < | |
| 7 | 95 *:pyfile* *:pyf* |
| 96 :[range]pyf[ile] {file} | |
| 97 Execute the Python script in {file}. The whole | |
|
16553
0e473e9e70c2
patch 8.1.1280: remarks about functionality not in Vi clutters the help
Bram Moolenaar <Bram@vim.org>
parents:
14864
diff
changeset
|
98 argument is used as a single file name. |
| 7 | 99 |
| 100 Both of these commands do essentially the same thing - they execute a piece of | |
| 101 Python code, with the "current range" |python-range| set to the given line | |
| 102 range. | |
| 103 | |
| 104 In the case of :python, the code to execute is in the command-line. | |
| 105 In the case of :pyfile, the code to execute is the contents of the given file. | |
| 106 | |
| 107 Python commands cannot be used in the |sandbox|. | |
| 108 | |
| 109 To pass arguments you need to set sys.argv[] explicitly. Example: > | |
| 110 | |
| 111 :python sys.argv = ["foo", "bar"] | |
| 112 :pyfile myscript.py | |
| 113 | |
| 114 Here are some examples *python-examples* > | |
| 115 | |
| 116 :python from vim import * | |
| 117 :python from string import upper | |
| 118 :python current.line = upper(current.line) | |
| 119 :python print "Hello" | |
| 120 :python str = current.buffer[42] | |
| 121 | |
| 122 (Note that changes - like the imports - persist from one command to the next, | |
| 123 just like in the Python interpreter.) | |
| 124 | |
| 125 ============================================================================== | |
| 126 2. The vim module *python-vim* | |
| 127 | |
| 128 Python code gets all of its access to vim (with one exception - see | |
| 236 | 129 |python-output| below) via the "vim" module. The vim module implements two |
| 7 | 130 methods, three constants, and one error object. You need to import the vim |
| 131 module before using it: > | |
| 132 :python import vim | |
| 133 | |
| 134 Overview > | |
| 20 | 135 :py print "Hello" # displays a message |
|
2033
de5a43c5eedc
Update documentation files.
Bram Moolenaar <bram@zimbu.org>
parents:
1702
diff
changeset
|
136 :py vim.command(cmd) # execute an Ex command |
| 20 | 137 :py w = vim.windows[n] # gets window "n" |
| 138 :py cw = vim.current.window # gets the current window | |
| 139 :py b = vim.buffers[n] # gets buffer "n" | |
| 140 :py cb = vim.current.buffer # gets the current buffer | |
| 141 :py w.height = lines # sets the window height | |
| 142 :py w.cursor = (row, col) # sets the window cursor position | |
| 143 :py pos = w.cursor # gets a tuple (row, col) | |
| 144 :py name = b.name # gets the buffer file name | |
| 145 :py line = b[n] # gets a line from the buffer | |
| 146 :py lines = b[n:m] # gets a list of lines | |
| 147 :py num = len(b) # gets the number of lines | |
| 148 :py b[n] = str # sets a line in the buffer | |
| 149 :py b[n:m] = [str1, str2, str3] # sets a number of lines at once | |
| 150 :py del b[n] # deletes a line | |
| 151 :py del b[n:m] # deletes a number of lines | |
| 7 | 152 |
| 153 | |
| 154 Methods of the "vim" module | |
| 155 | |
| 156 vim.command(str) *python-command* | |
| 236 | 157 Executes the vim (ex-mode) command str. Returns None. |
| 7 | 158 Examples: > |
| 20 | 159 :py vim.command("set tw=72") |
| 160 :py vim.command("%s/aaa/bbb/g") | |
| 7 | 161 < The following definition executes Normal mode commands: > |
| 162 def normal(str): | |
| 163 vim.command("normal "+str) | |
| 164 # Note the use of single quotes to delimit a string containing | |
| 165 # double quotes | |
| 166 normal('"a2dd"aP') | |
| 167 < *E659* | |
| 168 The ":python" command cannot be used recursively with Python 2.2 and | |
| 169 older. This only works with Python 2.3 and later: > | |
| 20 | 170 :py vim.command("python print 'Hello again Python'") |
| 7 | 171 |
| 172 vim.eval(str) *python-eval* | |
| 173 Evaluates the expression str using the vim internal expression | |
| 633 | 174 evaluator (see |expression|). Returns the expression result as: |
| 175 - a string if the Vim expression evaluates to a string or number | |
| 176 - a list if the Vim expression evaluates to a Vim list | |
| 856 | 177 - a dictionary if the Vim expression evaluates to a Vim dictionary |
| 633 | 178 Dictionaries and lists are recursively expanded. |
| 7 | 179 Examples: > |
| 14637 | 180 :" value of the 'textwidth' option |
| 20 | 181 :py text_width = vim.eval("&tw") |
| 14637 | 182 : |
| 183 :" contents of the 'a' register | |
| 184 :py a_reg = vim.eval("@a") | |
| 185 : | |
| 186 :" Result is a string! Use string.atoi() to convert to a number. | |
| 187 :py str = vim.eval("12+12") | |
| 188 : | |
| 856 | 189 :py tagList = vim.eval('taglist("eval_expr")') |
| 633 | 190 < The latter will return a python list of python dicts, for instance: |
| 11062 | 191 [{'cmd': '/^eval_expr(arg, nextcmd)$/', 'static': 0, 'name': ~ |
| 192 'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}] ~ | |
| 633 | 193 |
| 3682 | 194 vim.bindeval(str) *python-bindeval* |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
195 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
|
196 |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
|
197 or |Dictionary|) or call (|Funcref|) vim objects. |
| 633 | 198 |
|
4700
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
199 vim.strwidth(str) *python-strwidth* |
|
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
200 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
|
201 is counted as one cell. |
|
0c25fa1dfd97
updated for version 7.3.1097
Bram Moolenaar <bram@vim.org>
parents:
4698
diff
changeset
|
202 |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
203 vim.foreach_rtp(callable) *python-foreach_rtp* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
204 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
|
205 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
|
206 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
|
207 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
|
208 |
|
4704
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
209 vim.chdir(*args, **kwargs) *python-chdir* |
|
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
210 vim.fchdir(*args, **kwargs) *python-fchdir* |
|
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
211 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
|
212 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
|
213 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
|
214 os.fchdir does not exist. |
|
542af01979be
updated for version 7.3.1099
Bram Moolenaar <bram@vim.org>
parents:
4700
diff
changeset
|
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 | |
|
4698
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
248 < Note: vim.windows object always accesses current tab page. |
| 4401 | 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|, | |
|
4589
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
253 they will not lose their properties in this case. |
| 4401 | 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 | |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
329 *python2-directory* *python3-directory* *pythonx-directory* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
330 Python 'runtimepath' handling *python-special-path* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
331 |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
332 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
|
333 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
|
334 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
|
335 {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
|
336 each {rtp} found in 'runtimepath'. |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
337 |
|
4855
52850ef928f8
updated for version 7.3.1174
Bram Moolenaar <bram@vim.org>
parents:
4851
diff
changeset
|
338 Implementation 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
|
339 |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
340 from imp import find_module, load_module |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
341 import vim |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
342 import sys |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
343 |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
344 class VimModuleLoader(object): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
345 def __init__(self, module): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
346 self.module = module |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
347 |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
348 def load_module(self, fullname, path=None): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
349 return self.module |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
350 |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
351 def _find_module(fullname, oldtail, path): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
352 idx = oldtail.find('.') |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
353 if idx > 0: |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
354 name = oldtail[:idx] |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
355 tail = oldtail[idx+1:] |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
356 fmr = find_module(name, path) |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
357 module = load_module(fullname[:-len(oldtail)] + name, *fmr) |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
358 return _find_module(fullname, tail, module.__path__) |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
359 else: |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
360 fmr = find_module(fullname, path) |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
361 return load_module(fullname, *fmr) |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
362 |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
363 # 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
|
364 # 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
|
365 # an attribute. |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
366 class VimPathFinder(object): |
|
4855
52850ef928f8
updated for version 7.3.1174
Bram Moolenaar <bram@vim.org>
parents:
4851
diff
changeset
|
367 @classmethod |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
368 def find_module(cls, fullname, path=None): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
369 try: |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
370 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
|
371 except ImportError: |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
372 return None |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
373 |
|
4855
52850ef928f8
updated for version 7.3.1174
Bram Moolenaar <bram@vim.org>
parents:
4851
diff
changeset
|
374 @classmethod |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
375 def load_module(cls, fullname, path=None): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
376 return _find_module(fullname, fullname, path or vim._get_paths()) |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
377 |
|
4851
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
378 def hook(path): |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
379 if path == vim.VIM_SPECIAL_PATH: |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
380 return VimPathFinder |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
381 else: |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
382 raise ImportError |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
383 |
|
96e154e825a7
updated for version 7.3.1172
Bram Moolenaar <bram@vim.org>
parents:
4833
diff
changeset
|
384 sys.path_hooks.append(hook) |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
385 |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
386 vim.VIM_SPECIAL_PATH *python-VIM_SPECIAL_PATH* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
387 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
|
388 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
|
389 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
|
390 case it uses special loader. |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
391 |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
392 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
|
393 vim.VIM_SPECIAL_PATH object. |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
394 |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
395 vim.find_module(...) *python-find_module* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
396 vim.path_hook(path) *python-path_hook* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
397 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
|
398 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
|
399 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
|
400 guaranteed that any of the objects will exist in the future vim |
|
4855
52850ef928f8
updated for version 7.3.1174
Bram Moolenaar <bram@vim.org>
parents:
4851
diff
changeset
|
401 versions. |
|
4833
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
402 |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
403 vim._get_paths *python-_get_paths* |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
404 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
|
405 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
|
406 versions, but can use it for debugging. |
|
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 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
|
409 {rtp}/pythonx directories for each {rtp} in 'runtimepath'. |
|
70b1178dec79
updated for version 7.3.1163
Bram Moolenaar <bram@vim.org>
parents:
4780
diff
changeset
|
410 |
| 7 | 411 ============================================================================== |
| 412 3. Buffer objects *python-buffer* | |
| 413 | |
| 236 | 414 Buffer objects represent vim buffers. You can obtain them in a number of ways: |
| 7 | 415 - via vim.current.buffer (|python-current|) |
| 416 - from indexing vim.buffers (|python-buffers|) | |
| 417 - from the "buffer" attribute of a window (|python-window|) | |
| 418 | |
| 3312 | 419 Buffer objects have two read-only attributes - name - the full file name for |
| 420 the buffer, and number - the buffer number. They also have three methods | |
| 421 (append, mark, and range; see below). | |
| 7 | 422 |
| 236 | 423 You can also treat buffer objects as sequence objects. In this context, they |
| 7 | 424 act as if they were lists (yes, they are mutable) of strings, with each |
| 236 | 425 element being a line of the buffer. All of the usual sequence operations, |
| 7 | 426 including indexing, index assignment, slicing and slice assignment, work as |
| 236 | 427 you would expect. Note that the result of indexing (slicing) a buffer is a |
| 428 string (list of strings). This has one unusual consequence - b[:] is different | |
| 429 from b. In particular, "b[:] = None" deletes the whole of the buffer, whereas | |
| 7 | 430 "b = None" merely updates the variable b, with no effect on the buffer. |
| 431 | |
| 236 | 432 Buffer indexes start at zero, as is normal in Python. This differs from vim |
| 433 line numbers, which start from 1. This is particularly relevant when dealing | |
| 7 | 434 with marks (see below) which use vim line numbers. |
| 435 | |
| 4350 | 436 The buffer object attributes are: |
| 437 b.vars Dictionary-like object used to access | |
| 438 |buffer-variable|s. | |
| 439 b.options Mapping object (supports item getting, setting and | |
| 440 deleting) that provides access to buffer-local options | |
| 441 and buffer-local values of |global-local| options. Use | |
| 442 |python-window|.options if option is window-local, | |
| 443 this object will raise KeyError. If option is | |
| 444 |global-local| and local value is missing getting it | |
| 445 will return None. | |
|
4589
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
446 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
|
447 Note: when assigning to b.name |BufFilePre| and |
|
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
448 |BufFilePost| autocommands are launched. |
|
fa39483a1363
updated for version 7.3.1042
Bram Moolenaar <bram@vim.org>
parents:
4502
diff
changeset
|
449 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
|
450 Read-only. |
| 4780 | 451 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
|
452 corresponding buffer is wiped out. |
| 4350 | 453 |
| 7 | 454 The buffer object methods are: |
| 455 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
|
456 b.append(str, nr) Idem, below line "nr" |
| 7 | 457 b.append(list) Append a list of lines to the buffer |
| 458 Note that the option of supplying a list of strings to | |
| 459 the append method differs from the equivalent method | |
| 460 for Python's built-in list objects. | |
|
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
461 b.append(list, nr) Idem, below line "nr" |
| 7 | 462 b.mark(name) Return a tuple (row,col) representing the position |
| 463 of the named mark (can also get the []"<> marks) | |
| 464 b.range(s,e) Return a range object (see |python-range|) which | |
| 465 represents the part of the given buffer between line | |
| 466 numbers s and e |inclusive|. | |
| 467 | |
| 20 | 468 Note that when adding a line it must not contain a line break character '\n'. |
| 469 A trailing '\n' is allowed and ignored, so that you can do: > | |
| 470 :py b.append(f.readlines()) | |
| 471 | |
| 4496 | 472 Buffer object type is available using "Buffer" attribute of vim module. |
| 473 | |
| 7 | 474 Examples (assume b is the current buffer) > |
| 20 | 475 :py print b.name # write the buffer file name |
| 476 :py b[0] = "hello!!!" # replace the top line | |
| 477 :py b[:] = None # delete the whole buffer | |
| 478 :py del b[:] # delete the whole buffer | |
| 479 :py b[0:0] = [ "a line" ] # add a line at the top | |
| 480 :py del b[2] # delete a line (the third) | |
| 481 :py b.append("bottom") # add a line at the bottom | |
| 482 :py n = len(b) # number of lines | |
| 483 :py (row,col) = b.mark('a') # named mark | |
| 484 :py r = b.range(1,5) # a sub-range of the buffer | |
| 4323 | 485 :py b.vars["foo"] = "bar" # assign b:foo variable |
| 4350 | 486 :py b.options["ff"] = "dos" # set fileformat |
| 487 :py del b.options["ar"] # same as :set autoread< | |
| 7 | 488 |
| 489 ============================================================================== | |
| 490 4. Range objects *python-range* | |
| 491 | |
| 236 | 492 Range objects represent a part of a vim buffer. You can obtain them in a |
| 7 | 493 number of ways: |
| 494 - via vim.current.range (|python-current|) | |
| 495 - from a buffer's range() method (|python-buffer|) | |
| 496 | |
| 236 | 497 A range object is almost identical in operation to a buffer object. However, |
| 7 | 498 all operations are restricted to the lines within the range (this line range |
| 499 can, of course, change as a result of slice assignments, line deletions, or | |
| 500 the range.append() method). | |
| 501 | |
| 502 The range object attributes are: | |
| 503 r.start Index of first line into the buffer | |
| 504 r.end Index of last line into the buffer | |
| 505 | |
| 506 The range object methods are: | |
| 507 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
|
508 r.append(str, nr) Idem, after line "nr" |
| 7 | 509 r.append(list) Append a list of lines to the range |
| 510 Note that the option of supplying a list of strings to | |
| 511 the append method differs from the equivalent method | |
| 512 for Python's built-in list objects. | |
|
2391
f1d95a986dfb
Document extra argument for Python append().
Bram Moolenaar <bram@vim.org>
parents:
2366
diff
changeset
|
513 r.append(list, nr) Idem, after line "nr" |
| 7 | 514 |
| 4496 | 515 Range object type is available using "Range" attribute of vim module. |
| 516 | |
| 7 | 517 Example (assume r is the current range): |
| 518 # Send all lines in a range to the default printer | |
| 519 vim.command("%d,%dhardcopy!" % (r.start+1,r.end+1)) | |
| 520 | |
| 521 ============================================================================== | |
| 522 5. Window objects *python-window* | |
| 523 | |
| 236 | 524 Window objects represent vim windows. You can obtain them in a number of ways: |
| 7 | 525 - via vim.current.window (|python-current|) |
| 526 - from indexing vim.windows (|python-windows|) | |
| 4401 | 527 - from indexing "windows" attribute of a tab page (|python-tabpage|) |
| 528 - from the "window" attribute of a tab page (|python-tabpage|) | |
| 7 | 529 |
| 236 | 530 You can manipulate window objects only through their attributes. They have no |
| 7 | 531 methods, and no sequence or other interface. |
| 532 | |
| 533 Window attributes are: | |
| 534 buffer (read-only) The buffer displayed in this window | |
| 535 cursor (read-write) The current cursor position in the window | |
| 536 This is a tuple, (row,col). | |
| 537 height (read-write) The window height, in rows | |
| 538 width (read-write) The window width, in columns | |
| 4323 | 539 vars (read-only) The window |w:| variables. Attribute is |
| 540 unassignable, but you can change window | |
| 541 variables this way | |
| 4350 | 542 options (read-only) The window-local options. Attribute is |
| 543 unassignable, but you can change window | |
| 544 options this way. Provides access only to | |
| 545 window-local options, for buffer-local use | |
| 546 |python-buffer| and for global ones use | |
| 547 |python-options|. If option is |global-local| | |
| 548 and local value is missing getting it will | |
| 549 return None. | |
| 4379 | 550 number (read-only) Window number. The first window has number 1. |
| 551 This is zero in case it cannot be determined | |
| 552 (e.g. when the window object belongs to other | |
| 553 tab page). | |
| 4431 | 554 row, col (read-only) On-screen window position in display cells. |
| 4383 | 555 First position is zero. |
| 4431 | 556 tabpage (read-only) Window tab page. |
| 4780 | 557 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
|
558 when corresponding window is closed. |
| 4383 | 559 |
| 7 | 560 The height attribute is writable only if the screen is split horizontally. |
| 561 The width attribute is writable only if the screen is split vertically. | |
| 562 | |
| 4496 | 563 Window object type is available using "Window" attribute of vim module. |
| 564 | |
| 7 | 565 ============================================================================== |
| 4401 | 566 6. Tab page objects *python-tabpage* |
| 567 | |
| 568 Tab page objects represent vim tab pages. You can obtain them in a number of | |
| 569 ways: | |
| 570 - via vim.current.tabpage (|python-current|) | |
| 571 - from indexing vim.tabpages (|python-tabpages|) | |
| 572 | |
| 573 You can use this object to access tab page windows. They have no methods and | |
| 574 no sequence or other interfaces. | |
| 575 | |
| 576 Tab page attributes are: | |
| 577 number The tab page number like the one returned by | |
| 578 |tabpagenr()|. | |
| 579 windows Like |python-windows|, but for current tab page. | |
| 580 vars The tab page |t:| variables. | |
| 581 window Current tabpage window. | |
| 4780 | 582 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
|
583 corresponding tab page is closed. |
| 4401 | 584 |
| 4496 | 585 TabPage object type is available using "TabPage" attribute of vim module. |
| 586 | |
| 4401 | 587 ============================================================================== |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
588 7. vim.bindeval objects *python-bindeval-objects* |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
589 |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
590 vim.Dictionary object *python-Dictionary* |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
591 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
|
592 Attributes: |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
593 Attribute Description ~ |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
594 locked One of *python-.locked* |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
595 Value Description ~ |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
596 zero Variable is not locked |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
597 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
|
598 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
|
599 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
|
600 `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
|
601 is supported. |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
602 scope One of |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
603 Value Description ~ |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
604 zero Dictionary is not a scope one |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
605 vim.VAR_DEF_SCOPE |g:| or |l:| dictionary |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
606 vim.VAR_SCOPE Other scope dictionary, |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
607 see |internal-variables| |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
608 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
|
609 Method Description ~ |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
610 keys() Returns a list with dictionary keys. |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
611 values() Returns a list with dictionary values. |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
612 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
|
613 update(iterable), update(dictionary), update(**kwargs) |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
614 Adds keys to dictionary. |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
615 get(key[, default=None]) |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
616 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
|
617 not present. |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
618 pop(key[, default]) |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
619 Remove specified key from dictionary and return |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
620 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
|
621 given returns the default, otherwise raises KeyError. |
|
4698
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
622 popitem() |
|
2db005052371
updated for version 7.3.1096
Bram Moolenaar <bram@vim.org>
parents:
4681
diff
changeset
|
623 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
|
624 pair. |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
625 has_key(key) |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
626 Check whether dictionary contains specified key, similar |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
627 to `key in dict`. |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
628 |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
629 __new__(), __new__(iterable), __new__(dictionary), __new__(update) |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
630 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
|
631 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
|
632 `d=vim.bindeval('{}');d.update(arg)`. Without arguments |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
633 constructs empty dictionary. |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
634 |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
635 Examples: > |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
636 d = vim.Dictionary(food="bar") # Constructor |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
637 d['a'] = 'b' # Item assignment |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
638 print d['a'] # getting item |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
639 d.update({'c': 'd'}) # .update(dictionary) |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
640 d.update(e='f') # .update(**kwargs) |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
641 d.update((('g', 'h'), ('i', 'j'))) # .update(iterable) |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
642 for key in d.keys(): # .keys() |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
643 for val in d.values(): # .values() |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
644 for key, val in d.items(): # .items() |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
645 print isinstance(d, vim.Dictionary) # True |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
646 for key in d: # Iteration over keys |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
647 class Dict(vim.Dictionary): # Subclassing |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
648 < |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
649 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
|
650 |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
651 vim.List object *python-List* |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
652 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
|
653 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
|
654 following methods: |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
655 Method Description ~ |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
656 extend(item) Add items to the list. |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
657 |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
658 __new__(), __new__(iterable) |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
659 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
|
660 `l=vim.List(iterable)` is the same as |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
661 `l=vim.bindeval('[]');l.extend(iterable)`. Without |
|
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
662 arguments constructs empty list. |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
663 Examples: > |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
664 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
|
665 l.extend(['abc', 'def']) # .extend() method |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
666 print l[1:] # slicing |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
667 l[:0] = ['ghi', 'jkl'] # slice assignment |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
668 print l[0] # getting item |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
669 l[0] = 'mno' # assignment |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
670 for i in l: # iteration |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
671 print isinstance(l, vim.List) # True |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
672 class List(vim.List): # Subclassing |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
673 |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
674 vim.Function object *python-Function* |
|
8889
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
675 Function-like object, acting like vim |Funcref| object. Accepts special |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
676 keyword argument `self`, see |Dictionary-function|. You can also use |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
677 `vim.Function(name)` constructor, it is the same as |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
678 `vim.bindeval('function(%s)'%json.dumps(name))`. |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
679 |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
680 Attributes (read-only): |
|
9119
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
681 Attribute Description ~ |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
682 name Function name. |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
683 args `None` or a |python-List| object with arguments. Note |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
684 that this is a copy of the arguments list, constructed |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
685 each time you request this attribute. Modifications made |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
686 to the list will be ignored (but not to the containers |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
687 inside argument list: this is like |copy()| and not |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
688 |deepcopy()|). |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
689 self `None` or a |python-Dictionary| object with self |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
690 dictionary. Note that explicit `self` keyword used when |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
691 calling resulting object overrides this attribute. |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
692 auto_rebind Boolean. True if partial created from this Python object |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
693 and stored in the Vim script dictionary should be |
|
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
694 automatically rebound to the dictionary it is stored in |
|
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
695 when this dictionary is indexed. Exposes Vim internal |
|
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
696 difference between `dict.func` (auto_rebind=True) and |
|
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
697 `function(dict.func,dict)` (auto_rebind=False). This |
|
9119
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
698 attribute makes no sense if `self` attribute is `None`. |
|
8889
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
699 |
|
9119
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
700 Constructor additionally accepts `args`, `self` and `auto_rebind` |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
701 keywords. If `args` and/or `self` argument is given then it constructs |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
702 a partial, see |function()|. `auto_rebind` is only used when `self` |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
703 argument is given, otherwise it is assumed to be `True` regardless of |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
704 whether it was given or not. If `self` is given then it defaults to |
|
39cc63e8df7c
commit https://github.com/vim/vim/commit/2177f9fe18a927ef65ccebb0856722a28dc00252
Christian Brabandt <cb@256bit.org>
parents:
8951
diff
changeset
|
705 `False`. |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
706 |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
707 Examples: > |
|
4639
52a4f66ae1f5
updated for version 7.3.1067
Bram Moolenaar <bram@vim.org>
parents:
4627
diff
changeset
|
708 f = vim.Function('tr') # Constructor |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
709 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
|
710 vim.command(''' |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
711 function DictFun() dict |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
712 return self |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
713 endfunction |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
714 ''') |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
715 f = vim.bindeval('function("DictFun")') |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
716 print f(self={}) # Like call('DictFun', [], {}) |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
717 print isinstance(f, vim.Function) # True |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
718 |
|
8889
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
719 p = vim.Function('DictFun', self={}) |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
720 print f() |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
721 p = vim.Function('tr', args=['abc', 'a']) |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
722 print f('b') |
|
8755d57debaa
commit https://github.com/vim/vim/commit/8110a091bc749d8748a20807a724a3af3ca6d509
Christian Brabandt <cb@256bit.org>
parents:
8673
diff
changeset
|
723 |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
724 ============================================================================== |
|
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
725 8. pyeval() and py3eval() Vim functions *python-pyeval* |
| 3682 | 726 |
| 727 To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| | |
|
10942
e05695e59f6d
patch 8.0.0360: sometimes VimL is used instead of "Vim script"
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
728 functions to evaluate Python expressions and pass their values to Vim script. |
|
10722
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
729 |pyxeval()| is also available. |
| 3682 | 730 |
|
12806
ef93c4415667
patch 8.0.1280: Python None cannot be converted to a Vim type
Christian Brabandt <cb@256bit.org>
parents:
12045
diff
changeset
|
731 The Python value "None" is converted to v:none. |
|
ef93c4415667
patch 8.0.1280: Python None cannot be converted to a Vim type
Christian Brabandt <cb@256bit.org>
parents:
12045
diff
changeset
|
732 |
| 3682 | 733 ============================================================================== |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
734 9. Dynamic loading *python-dynamic* |
| 557 | 735 |
|
7196
42717d048817
commit https://github.com/vim/vim/commit/d94464ee294a351ce7b6ba18e8bd3f24f1bef920
Christian Brabandt <cb@256bit.org>
parents:
6091
diff
changeset
|
736 On MS-Windows and Unix the Python library can be loaded dynamically. The |
|
42717d048817
commit https://github.com/vim/vim/commit/d94464ee294a351ce7b6ba18e8bd3f24f1bef920
Christian Brabandt <cb@256bit.org>
parents:
6091
diff
changeset
|
737 |:version| output then includes |+python/dyn| or |+python3/dyn|. |
| 557 | 738 |
|
7196
42717d048817
commit https://github.com/vim/vim/commit/d94464ee294a351ce7b6ba18e8bd3f24f1bef920
Christian Brabandt <cb@256bit.org>
parents:
6091
diff
changeset
|
739 This means that Vim will search for the Python DLL or shared library file only |
|
42717d048817
commit https://github.com/vim/vim/commit/d94464ee294a351ce7b6ba18e8bd3f24f1bef920
Christian Brabandt <cb@256bit.org>
parents:
6091
diff
changeset
|
740 when needed. When you don't use the Python interface you don't need it, thus |
|
42717d048817
commit https://github.com/vim/vim/commit/d94464ee294a351ce7b6ba18e8bd3f24f1bef920
Christian Brabandt <cb@256bit.org>
parents:
6091
diff
changeset
|
741 you can use Vim without this file. |
| 557 | 742 |
|
8673
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
743 |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
744 MS-Windows ~ |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
745 |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
746 To use the Python interface the Python DLL must be in your search path. In a |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
747 console window type "path" to see what directories are used. The 'pythondll' |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
748 or 'pythonthreedll' option can be also used to specify the Python DLL. |
| 557 | 749 |
|
10895
c391bfbdb452
Updated runtime files.
Christian Brabandt <cb@256bit.org>
parents:
10734
diff
changeset
|
750 The name of the DLL should match the Python version Vim was compiled with. |
|
c391bfbdb452
Updated runtime files.
Christian Brabandt <cb@256bit.org>
parents:
10734
diff
changeset
|
751 Currently the name for Python 2 is "python27.dll", that is for Python 2.7. |
|
13018
8862bf5adf7b
patch 8.0.1385: Python 3.5 is getting old
Christian Brabandt <cb@256bit.org>
parents:
12826
diff
changeset
|
752 That is the default value for 'pythondll'. For Python 3 it is python36.dll |
|
8862bf5adf7b
patch 8.0.1385: Python 3.5 is getting old
Christian Brabandt <cb@256bit.org>
parents:
12826
diff
changeset
|
753 (Python 3.6). To know for sure edit "gvim.exe" and search for |
|
10895
c391bfbdb452
Updated runtime files.
Christian Brabandt <cb@256bit.org>
parents:
10734
diff
changeset
|
754 "python\d*.dll\c". |
| 557 | 755 |
|
8673
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
756 |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
757 Unix ~ |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
758 |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
759 The 'pythondll' or 'pythonthreedll' option can be used to specify the Python |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
760 shared library file instead of DYNAMIC_PYTHON_DLL or DYNAMIC_PYTHON3_DLL file |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
761 what were specified at compile time. The version of the shared library must |
|
ed7251c3e2d3
commit https://github.com/vim/vim/commit/e18c0b39815c5a746887a509c2cd9f11fadaba07
Christian Brabandt <cb@256bit.org>
parents:
7228
diff
changeset
|
762 match the Python 2.x or Python 3 version Vim was compiled with. |
|
7196
42717d048817
commit https://github.com/vim/vim/commit/d94464ee294a351ce7b6ba18e8bd3f24f1bef920
Christian Brabandt <cb@256bit.org>
parents:
6091
diff
changeset
|
763 |
| 557 | 764 ============================================================================== |
|
4627
18ba89e06fab
updated for version 7.3.1061
Bram Moolenaar <bram@vim.org>
parents:
4589
diff
changeset
|
765 10. Python 3 *python3* |
|
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
766 |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
767 *:py3* *:python3* |
| 4435 | 768 The `:py3` and `:python3` commands work similar to `:python`. A simple check |
| 4098 | 769 if the `:py3` command is working: > |
| 3750 | 770 :py3 print("Hello") |
|
10218
584c835a2de1
commit https://github.com/vim/vim/commit/50ba526fbf3e9e5e0e6b0b3086a4d5df581ebc7e
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
771 |
|
10140
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
772 To see what version of Python you have: > |
|
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
773 :py3 import sys |
|
b11ceef7116e
commit https://github.com/vim/vim/commit/64d8e25bf6efe5f18b032563521c3ce278c316ab
Christian Brabandt <cb@256bit.org>
parents:
9119
diff
changeset
|
774 :py3 print(sys.version) |
|
10218
584c835a2de1
commit https://github.com/vim/vim/commit/50ba526fbf3e9e5e0e6b0b3086a4d5df581ebc7e
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
775 < *:py3file* |
| 4435 | 776 The `:py3file` command works similar to `:pyfile`. |
|
8951
0bdeaf7092bc
commit https://github.com/vim/vim/commit/aa3b15dbebf333282503d6031e2f9ba6ee4398ed
Christian Brabandt <cb@256bit.org>
parents:
8889
diff
changeset
|
777 *:py3do* |
| 4435 | 778 The `:py3do` command works similar to `:pydo`. |
| 4417 | 779 |
| 3682 | 780 |
|
2409
0ca06a92adfb
Add support for horizontal scroll wheel. (Bjorn Winckler)
Bram Moolenaar <bram@vim.org>
parents:
2391
diff
changeset
|
781 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
|
782 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
|
783 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
|
784 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
|
785 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
|
786 |
| 5220 | 787 Some more details on the special case 4: *python-2-and-3* |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
788 |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
789 When Python 2 and Python 3 are both supported they must be loaded dynamically. |
| 2540 | 790 |
|
2560
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
791 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
|
792 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
|
793 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
|
794 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
|
795 symbols to be provided by Vim. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
796 *E836* *E837* |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
797 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
|
798 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
|
799 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
|
800 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
|
801 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
|
802 |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
803 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
|
804 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
|
805 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
|
806 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
|
807 libPython. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
808 |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
809 To work around such problems there are these options: |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
810 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
|
811 libpython.so. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
812 2. Vim is recompiled for only one Python version. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
813 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
|
814 may crash Vim though. |
|
84ba6293f9d7
Preparations for 7.3f release.
Bram Moolenaar <bram@vim.org>
parents:
2554
diff
changeset
|
815 |
|
5088
34c629c3b4ba
updated for version 7.3.1287
Bram Moolenaar <bram@vim.org>
parents:
5055
diff
changeset
|
816 *E880* |
|
34c629c3b4ba
updated for version 7.3.1287
Bram Moolenaar <bram@vim.org>
parents:
5055
diff
changeset
|
817 Raising SystemExit exception in python isn't endorsed way to quit vim, use: > |
|
34c629c3b4ba
updated for version 7.3.1287
Bram Moolenaar <bram@vim.org>
parents:
5055
diff
changeset
|
818 :py vim.command("qall!") |
|
34c629c3b4ba
updated for version 7.3.1287
Bram Moolenaar <bram@vim.org>
parents:
5055
diff
changeset
|
819 < |
|
34c629c3b4ba
updated for version 7.3.1287
Bram Moolenaar <bram@vim.org>
parents:
5055
diff
changeset
|
820 |
| 2826 | 821 *has-python* |
| 822 You can test what Python version is available with: > | |
| 823 if has('python') | |
| 3082 | 824 echo 'there is Python 2.x' |
| 13125 | 825 endif |
| 826 if has('python3') | |
| 2826 | 827 echo 'there is Python 3.x' |
| 828 endif | |
| 829 | |
| 830 Note however, that when Python 2 and 3 are both available and loaded | |
| 831 dynamically, these has() calls will try to load them. If only one can be | |
| 832 loaded at a time, just checking if Python 2 or 3 are available will prevent | |
| 833 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
|
834 |
| 13125 | 835 To avoid loading the dynamic library, only check if Vim was compiled with |
| 836 python support: > | |
| 837 if has('python_compiled') | |
| 838 echo 'compiled with Python 2.x support' | |
| 13231 | 839 if has('python_dynamic') |
| 840 echo 'Python 2.x dynamically loaded' | |
| 13125 | 841 endif |
| 842 endif | |
| 843 if has('python3_compiled') | |
| 844 echo 'compiled with Python 3.x support' | |
| 13231 | 845 if has('python3_dynamic') |
| 846 echo 'Python 3.x dynamically loaded' | |
| 13125 | 847 endif |
| 848 endif | |
| 849 | |
| 850 This also tells you whether Python is dynamically loaded, which will fail if | |
| 851 the runtime library cannot be found. | |
| 852 | |
|
2340
99c1eba60b2d
Make automatic prototype generation work with more interfaces.
Bram Moolenaar <bram@vim.org>
parents:
2154
diff
changeset
|
853 ============================================================================== |
|
10722
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
854 11. Python X *python_x* *pythonx* |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
855 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
856 Because most python code can be written so that it works with python 2.6+ and |
| 11062 | 857 python 3 the pyx* functions and commands have been written. They work exactly |
|
10722
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
858 the same as the Python 2 and 3 variants, but select the Python version using |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
859 the 'pyxversion' setting. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
860 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
861 You should set 'pyxversion' in your |.vimrc| to prefer Python 2 or Python 3 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
862 for Python commands. If you change this setting at runtime you may risk that |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
863 state of plugins (such as initialization) may be lost. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
864 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
865 If you want to use a module, you can put it in the {rtp}/pythonx directory. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
866 See |pythonx-directory|. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
867 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
868 *:pyx* *:pythonx* |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
869 The `:pyx` and `:pythonx` commands work similar to `:python`. A simple check |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
870 if the `:pyx` command is working: > |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
871 :pyx print("Hello") |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
872 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
873 To see what version of Python is being used: > |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
874 :pyx import sys |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
875 :pyx print(sys.version) |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
876 < |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
877 *:pyxfile* *python_x-special-comments* |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
878 The `:pyxfile` command works similar to `:pyfile`. However you can add one of |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
879 these comments to force Vim using `:pyfile` or `:py3file`: > |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
880 #!/any string/python2 " Shebang. Must be the first line of the file. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
881 #!/any string/python3 " Shebang. Must be the first line of the file. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
882 # requires python 2.x " Maximum lines depend on 'modelines'. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
883 # requires python 3.x " Maximum lines depend on 'modelines'. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
884 Unlike normal modelines, the bottom of the file is not checked. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
885 If none of them are found, the 'pyxversion' setting is used. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
886 *W20* *W21* |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
887 If Vim does not support the selected Python version a silent message will be |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
888 printed. Use `:messages` to read them. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
889 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
890 *:pyxdo* |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
891 The `:pyxdo` command works similar to `:pydo`. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
892 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
893 *has-pythonx* |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
894 You can test if pyx* commands are available with: > |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
895 if has('pythonx') |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
896 echo 'pyx* commands are available. (Python ' . &pyx . ')' |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
897 endif |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
898 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
899 When compiled with only one of |+python| or |+python3|, the has() returns 1. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
900 When compiled with both |+python| and |+python3|, the test depends on the |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
901 'pyxversion' setting. If 'pyxversion' is 0, it tests Python 3 first, and if |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
902 it is not available then Python 2. If 'pyxversion' is 2 or 3, it tests only |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
903 Python 2 or 3 respectively. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
904 |
| 11062 | 905 Note that for `has('pythonx')` to work it may try to dynamically load Python 3 |
|
10722
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
906 or 2. This may have side effects, especially when Vim can only load one of |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
907 the two. |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
908 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
909 If a user prefers Python 2 and want to fallback to Python 3, he needs to set |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
910 'pyxversion' explicitly in his |.vimrc|. E.g.: > |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
911 if has('python') |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
912 set pyx=2 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
913 elseif has('python3') |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
914 set pyx=3 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
915 endif |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
916 |
|
7598ce51bf2a
patch 8.0.0251: not easy to select Python 2 or 3
Christian Brabandt <cb@256bit.org>
parents:
10218
diff
changeset
|
917 ============================================================================== |
| 11160 | 918 12. Building with Python support *python-building* |
| 919 | |
| 920 A few hints for building with Python 2 or 3 support. | |
| 921 | |
| 922 UNIX | |
| 923 | |
| 924 See src/Makefile for how to enable including the Python interface. | |
| 925 | |
| 926 On Ubuntu you will want to install these packages for Python 2: | |
| 927 python | |
| 928 python-dev | |
| 929 For Python 3: | |
| 930 python3 | |
| 12045 | 931 python3-dev |
| 11160 | 932 For Python 3.6: |
| 933 python3.6 | |
| 12045 | 934 python3.6-dev |
| 11160 | 935 |
| 936 If you have more than one version of Python 3, you need to link python3 to the | |
| 937 one you prefer, before running configure. | |
| 938 | |
| 939 ============================================================================== | |
| 14421 | 940 vim:tw=78:ts=8:noet:ft=help:norl: |