Most of the current formatters for Python --- e.g., autopep8, and pep8ify ---
are made to remove lint errors from code. This has some obvious limitations.
For instance, code that conforms to the PEP 8 guidelines may not be
reformatted. But it doesn't mean that the code looks good.
YAPF takes a different approach. It's based off of 'clang-format', developed by Daniel Jasper. In essence,
the algorithm takes the code and reformats it to the best formatting that
conforms to the style guide, even if the original code didn't violate the
style guide. The idea is also similar to the 'gofmt' tool for the Go programming language: end all holy wars about
formatting - if the whole codebase of a project is simply piped through YAPF
whenever modifications are made, the style remains consistent throughout the
project and there's no point arguing about style in every code review.
The ultimate goal is that the code YAPF produces is as good as the code that a
programmer would write if they were following the style guide. It takes away
some of the drudgery of maintaining your code.
(optional) If you are using Python 2.7 and want to enable multiprocessing:
$ pip install futures
YAPF is still considered in "alpha" stage, and the released version may change
often; therefore, the best way to keep up-to-date with the latest development
is to clone this repository.
Note that if you intend to use YAPF as a command-line tool rather than as a
library, installation is not necessary. YAPF supports being run as a directory
by the Python interpreter. If you cloned/unzipped YAPF into DIR, it's
possible to run:
YAPF supports Python 2.7 and 3.6.4+. (Note that some Python 3 features may fail
to parse with Python versions before 3.6.4.)
YAPF requires the code it formats to be valid Python for the version YAPF itself
runs under. Therefore, if you format Python 3 code with YAPF, run YAPF itself
under Python 3 (and similarly for Python 2).
usage: yapf [-h] [-v] [-d | -i | -q] [-r | -l START-END] [-e PATTERN]
[--style STYLE] [--style-help] [--no-local-style] [-p]
[-vv]
[files ...]
Formatter for Python code.
positional arguments:
files reads from stdin when no files are specified.
optional arguments:
-h, --help show this help message and exit
-v, --version show program's version number and exit
-d, --diff print the diff for the fixed source
-i, --in-place make changes to files in place
-q, --quiet output nothing and set return value
-r, --recursive run recursively over directories
-l START-END, --lines START-END
range of lines to reformat, one-based
-e PATTERN, --exclude PATTERN
patterns for files to exclude from formatting
--style STYLE specify formatting style: either a style name (for
example "pep8" or "google"), or the name of a file
with style settings. The default is pep8 unless a
.style.yapf or setup.cfg or pyproject.toml file
located in the same directory as the source or one
of its parent directories (for stdin, the current
directory is used).
--style-help show style settings and exit; this output can be
saved to .style.yapf to make your settings
permanent
--no-local-style don't search for local style definition
-p, --parallel run YAPF in parallel when formatting multiple
files. Requires concurrent.futures in Python 2.X
-vv, --verbose print out file names while processing
Normally YAPF returns zero on successful program termination and non-zero otherwise.
If --diff is supplied, YAPF returns zero when no changes were necessary, non-zero
otherwise (including program error). You can use this in a CI workflow to test that code
has been YAPF-formatted.
In addition to exclude patterns provided on commandline, YAPF looks for additional
patterns specified in a file named .yapfignore or pyproject.toml located in the
working directory from which YAPF is invoked.
.yapfignore's syntax is similar to UNIX's filename pattern matching:
* matches everything
? matches any single character
[seq] matches any character in seq
[!seq] matches any character not in seq
Note that no entry should begin with ./.
If you use pyproject.toml, exclude patterns are specified by ignore_pattens key
in [tool.yapfignore] section. For example:
The formatting style used by YAPF is configurable and there are many "knobs"
that can be used to tune how YAPF does formatting. See the style.py module
for the full list.
To control the style, run YAPF with the --style argument. It accepts one of
the predefined styles (e.g., pep8 or google), a path to a configuration
file that specifies the desired style, or a dictionary of key/value pairs.
The config file is a simple listing of (case-insensitive) key = value pairs
with a [style] heading. For example:
The based_on_style setting determines which of the predefined styles this
custom style is based on (think of it like subclassing). Four
styles are predefined:
The two main APIs for calling YAPF are FormatCode and FormatFile, these
share several arguments which are described below:
>>>fromyapf.yapflib.yapf_apiimportFormatCode# reformat a string of code>>>formatted_code, changed=FormatCode("f ( a = 1, b = 2 )")
>>>formatted_code'f(a=1, b=2)\n'>>>changedTrue
A style_config argument: Either a style name or a path to a file that contains
formatting style settings. If None is specified, use the default style
as set in style.DEFAULT_STYLE_FACTORY.
A lines argument: A list of tuples of lines (ints), [start, end],
that we want to format. The lines are 1-based indexed. It can be used by
third-party code (e.g., IDEs) when reformatting a snippet of code rather
than a whole file.
>>>FormatCode("def g( ):\n a=1\n b = 2\n return a==b", lines=[(1, 1), (2, 3)])[0]
'def g():\n a = 1\n b = 2\n return a==b\n'
A print_diff (bool): Instead of returning the reformatted source, return a
diff that turns the formatted source into reformatted source.
usage: yapf-diff [-h] [-i] [-p NUM] [--regex PATTERN] [--iregex PATTERN][-v]
[--style STYLE] [--binary BINARY]
This script reads input from a unified diff and reformats all the changed
lines. This is useful to reformat all the lines touched by a specific patch.
Example usage for git/svn users:
git diff -U0 --no-color --relative HEAD^ | yapf-diff -i
svn diff --diff-cmd=diff -x-U0 | yapf-diff -p0 -i
It should be noted that the filename contained in the diff is used
unmodified to determine the source file to update. Users calling this script
directly should be careful to ensure that the path in the diff is correct
relative to the current working directory.
optional arguments:
-h, --help show this help message and exit
-i, --in-place apply edits to files instead of displaying a diff
-p NUM, --prefix NUM strip the smallest prefix containing P slashes
--regex PATTERN custom pattern selecting file paths to reformat
(case sensitive, overrides -iregex)
--iregex PATTERN custom pattern selecting file paths to reformat
(case insensitive, overridden by -regex)
-v, --verbose be more verbose, ineffective without -i
--style STYLE specify formatting style: either a style name (for
example "pep8" or "google"), or the name of a file
with style settings. The default is pep8 unless a
.style.yapf or setup.cfg or pyproject.toml file
located in the same directory as the source or one of
its parent directories (for stdin, the current
directory is used).
--binary BINARY location of binary to use for YAPF
The style for continuation alignment. Possible values are:
SPACE: Use spaces for continuation alignment. This is default
behavior.
FIXED: Use fixed number (CONTINUATION_INDENT_WIDTH) of columns
(ie: CONTINUATION_INDENT_WIDTH/INDENT_WIDTH tabs or CONTINUATION_INDENT_WIDTH
spaces) for continuation alignment.
VALIGN-RIGHT: Vertically align continuation lines to multiple of
INDENT_WIDTH columns. Slightly right (one tab or a few spaces) if cannot
vertically align continuation lines with indent characters.
CONTINUATION_INDENT_WIDTH
Indent width used for line continuations.
DEDENT_CLOSING_BRACKETS
Put closing brackets on a separate line, dedented, if the bracketed
expression can't fit in a single line. Applies to all kinds of brackets,
including function definitions and calls. For example:
config= {
'key1': 'value1',
'key2': 'value2',
} # <--- this bracket is dedented and on a separate linetime_series=self.remote_client.query_entity_counters(
entity='dev3246.region1',
key='dns.query_latency_tcp',
transform=Transformation.AVERAGE(window=timedelta(seconds=60)),
start_ts=now()-timedelta(days=3),
end_ts=now(),
) # <--- this bracket is dedented and on a separate line
DISABLE_ENDING_COMMA_HEURISTIC
Disable the heuristic which places each list element on a separate line if
the list is comma-terminated.
EACH_DICT_ENTRY_ON_SEPARATE_LINE
Place each dictionary entry onto its own line.
FORCE_MULTILINE_DICT
Respect EACH_DICT_ENTRY_ON_SEPARATE_LINE even if the line is shorter than
COLUMN_LIMIT.
I18N_COMMENT
The regex for an internationalization comment. The presence of this comment
stops reformatting of that line, because the comments are required to be
next to the string they translate.
I18N_FUNCTION_CALL
The internationalization function call names. The presence of this function
stops reformatting on that line, because the string it has cannot be moved
away from the i18n comment.
INDENT_DICTIONARY_VALUE
Indent the dictionary value if it cannot fit on the same line as the
dictionary key. For example:
Set to True to prefer indented blank lines rather than empty
INDENT_CLOSING_BRACKETS
Put closing brackets on a separate line, indented, if the bracketed
expression can't fit in a single line. Applies to all kinds of brackets,
including function definitions and calls. For example:
config= {
'key1': 'value1',
'key2': 'value2',
} # <--- this bracket is indented and on a separate linetime_series=self.remote_client.query_entity_counters(
entity='dev3246.region1',
key='dns.query_latency_tcp',
transform=Transformation.AVERAGE(window=timedelta(seconds=60)),
start_ts=now()-timedelta(days=3),
end_ts=now(),
) # <--- this bracket is indented and on a separate line
JOIN_MULTIPLE_LINES
Join short lines into one line. E.g., single line if statements.
NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS
Do not include spaces around selected binary operators. For example:
1+2*3-4/5
will be formatted as follows when configured with *, /:
1+2*3-4/5
SPACES_AROUND_POWER_OPERATOR
Set to True to prefer using spaces around **.
SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN
Set to True to prefer spaces around the assignment operator for default
or keyword arguments.
SPACES_AROUND_DICT_DELIMITERS
Adds a space after the opening '{' and before the ending '}' dict delimiters.
{1: 2}
will be formatted as:
{ 1: 2 }
SPACES_AROUND_LIST_DELIMITERS
Adds a space after the opening '[' and before the ending ']' list delimiters.
[1, 2]
will be formatted as:
[ 1, 2 ]
SPACES_AROUND_SUBSCRIPT_COLON
Use spaces around the subscript / slice operator. For example:
my_list[1 : 10 : 2]
SPACES_AROUND_TUPLE_DELIMITERS
Adds a space after the opening '(' and before the ending ')' tuple delimiters.
(1, 2, 3)
will be formatted as:
( 1, 2, 3 )
SPACES_BEFORE_COMMENT
The number of spaces required before a trailing comment.
This can be a single value (representing the number of spaces
before each trailing comment) or list of of values (representing
alignment column values; trailing comments within a block will
be aligned to the first column value that is greater than the maximum
line length within the block). For example:
With spaces_before_comment=5:
1+1# Adding values
will be formatted as:
1+1# Adding values <-- 5 spaces between the end of the statement and comment
With spaces_before_comment=15, 20:
1+1# Adding valuestwo+two# More addinglonger_statement# This is a longer statementshort# This is a shorter statementa_very_long_statement_that_extends_beyond_the_final_column# Commentshort# This is a shorter statement
will be formatted as:
1+1# Adding values <-- end of line comments in block aligned to col 15two+two# More addinglonger_statement# This is a longer statement <-- end of line comments in block aligned to col 20short# This is a shorter statementa_very_long_statement_that_extends_beyond_the_final_column# Comment <-- the end of line comments are aligned based on the line lengthshort# This is a shorter statement
SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET
Insert a space between the ending comma and closing bracket of a list, etc.
SPACE_INSIDE_BRACKETS
Use spaces inside brackets, braces, and parentheses. For example:
Split before arguments if the argument list is terminated by a comma.
SPLIT_ALL_COMMA_SEPARATED_VALUES
If a comma separated list (dict, list, tuple, or function
def) is on a line that is too long, split such that each element
is on a separate line.
SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES
Variation on SPLIT_ALL_COMMA_SEPARATED_VALUES in which, if a
subexpression with a comma fits in its starting line, then the
subexpression is not split. This avoids splits like the one for
b in this code:
abcdef(
aReallyLongThing: int,
b: [Int,
Int])
With the new knob this is split as:
abcdef(
aReallyLongThing: int,
b: [Int, Int])
SPLIT_BEFORE_BITWISE_OPERATOR
Set to True to prefer splitting before &, | or ^ rather
than after.
SPLIT_BEFORE_ARITHMETIC_OPERATOR
Set to True to prefer splitting before +, -, *, /, //,
or @ rather than after.
SPLIT_BEFORE_CLOSING_BRACKET
Split before the closing bracket if a list or dict literal doesn't
fit on a single line.
SPLIT_BEFORE_DICT_SET_GENERATOR
Split before a dictionary or set generator (comp_for). For example, note
the split before the for:
foo= {
variable: 'Hello world, have a nice day!'forvariableinbarifvariable!=42
}
SPLIT_BEFORE_DOT
Split before the . if we need to split a longer expression:
foo= ('This is a really long string: {}, {}, {}, {}'.format(a, b, c, d))
would reformat to something like:
foo= ('This is a really long string: {}, {}, {}, {}'
.format(a, b, c, d))
SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN
Split after the opening paren which surrounds an expression if it doesn't
fit on a single line.
SPLIT_BEFORE_FIRST_ARGUMENT
If an argument / parameter list is going to be split, then split before the
first argument.
SPLIT_BEFORE_LOGICAL_OPERATOR
Set to True to prefer splitting before and or or rather than
after.
请发表评论