Invalid-name / C0103 - Pylint 2.15.0-dev0 Documentation

invalid-name / C0103¶

Message emitted:

%s name "%s" doesn't conform to %s

Description:

Used when the name doesn't conform to naming rules associated to its type (constant, variable, class...).

Problematic code:

classcat: # [invalid-name] defMeow(self, NUMBER_OF_MEOW): # [invalid-name, invalid-name] print("Meow" * NUMBER_OF_MEOW) return NUMBER_OF_MEOW Cat = cat().Meow(42) # [invalid-name]

Correct code:

classCat: defmeow(self, number_of_meow): print("Meow" * number_of_meow) return number_of_meow CAT = Cat().meow(42)

Additional details:

Pylint recognizes a number of different name types internally. With a few exceptions, the type of the name is governed by the location the assignment to a name is found in, and not the type of object assigned.

Name Type	Description
module	Module and package names, same as the file names.
const	Module-level constants: any name defined at module level that is not bound to a class object nor reassigned.
class	Names in class statements, as well as names bound to class objects at module level.
function	Functions, toplevel or nested in functions or methods.
method	Methods, functions defined in class bodies. Includes static and class methods.
attr	Attributes created on class instances inside methods.
argument	Arguments to any function type, including lambdas.
variable	Local variables in function scopes or module-level names that are assigned multiple times.
class-attribute	Attributes defined in class bodies.
class-const	Enum constants and class variables annotated with Final
inlinevar	Loop variables in list comprehensions and generator expressions.
typevar	Type variable declared with TypeVar.
paramspec	Parameter specification variable declared with ParamSpec.
typevartuple	Type variable tuple declared with TypeVarTuple.
typealias	Type alias declared with TypeAlias or assignments of Union.

Default behavior¶

By default, Pylint will enforce PEP8-suggested names.

Predefined Naming Styles¶

Pylint provides set of predefined naming styles. Those predefined naming styles may be used to adjust Pylint configuration to coding style used in linted project.

Following predefined naming styles are available:

• snake_case

• camelCase

• PascalCase

• UPPER_CASE

• any - fake style which does not enforce any limitations

The following options are exposed:

--module-naming-style=<style>¶ --const-naming-style=<style>¶ --class-naming-style=<style>¶ --function-naming-style=<style>¶ --method-naming-style=<style>¶ --attr-naming-style=<style>¶ --argument-naming-style=<style>¶ --variable-naming-style=<style>¶ --class-attribute-naming-style=<style>¶ --class-const-naming-style=<style>¶ --inlinevar-naming-style=<style>¶

Predefined Naming Patterns¶

Pylint provides predefined naming patterns for some names. These patterns are often based on a Naming Style but there is no option to choose one of the styles mentioned above. The pattern can be overwritten with the options discussed below.

The following types of names are checked with a predefined pattern:

Name type	Good names	Bad names
typevar	T, _CallableT, _T_co, AnyStr, DeviceTypeT, IPAddressT	DICT_T, CALLABLE_T, ENUM_T, DeviceType, _StrType
paramspec	P, _P	CALLABLE_P
typevartuple	Ts, _Ts	TUPLE_TS
typealias	GoodName, _GoodName, IPAddressType, GoodName2 and other PascalCase variants that don't start with T or Type. This is to distinguish them from typevars. Note that TopName is allowed but TTopName isn't.	BadNameT, badName, TBadName, TypeBadName, _1BadName

Before pylint 3.0, most predefined patterns also enforced a minimum length of three characters. If this behavior is desired in versions 3.0 and following, it can be had by providing custom regular expressions as described next. (Or, if the disallowed-name check is sufficient instead of invalid-name, providing the single option bad-names-rgxs="^..?$" will suffice to fail 1-2 character names.

Custom regular expressions¶

If predefined naming styles are too limited, checker behavior may be further customized. For each name type, a separate regular expression matching valid names of this type can be defined. If any of custom regular expressions are defined, it overrides *-naming-style option value.

Regular expressions for the names are anchored at the beginning, any anchor for the end must be supplied explicitly. Any name not matching the regular expression will lead to an instance of invalid-name.

--module-rgx=<regex>¶ --const-rgx=<regex>¶ --class-rgx=<regex>¶ --function-rgx=<regex>¶ --method-rgx=<regex>¶ --attr-rgx=<regex>¶ --argument-rgx=<regex>¶ --variable-rgx=<regex>¶ --class-attribute-rgx=<regex>¶ --class-const-rgx=<regex>¶ --inlinevar-rgx=<regex>¶ --typevar-rgx=<regex>¶ --paramspec-rgx=<regex>¶ --typevartuple-rgx=<regex>¶ --typealias-rgx=<regex>¶

Multiple naming styles for custom regular expressions¶

Large code bases that have been worked on for multiple years often exhibit an evolution in style as well. In some cases, modules can be in the same package, but still have different naming style based on the stratum they belong to. However, intra-module consistency should still be required, to make changes inside a single file easier. For this case, Pylint supports regular expression with several named capturing group.

Rather than emitting name warnings immediately, Pylint will determine the prevalent naming style inside each module and enforce it on all names.

Consider the following (simplified) example:

pylint --function-rgx='(?:(?P<snake>[a-z_]+)|(?P<camel>[a-z]+([A-Z][a-z]*)*))$' sample.py

The regular expression defines two naming styles, snake for snake-case names, and camel for camel-case names.

In sample.py, the function name on line 1 and 7 will mark the module and enforce the match of named group snake for the remaining names in the module:

defvalid_snake_case(arg): ... defInvalidCamelCase(arg): ... defmore_valid_snake_case(arg): ...

Because of this, the name on line 4 will trigger an invalid-name warning, even though the name matches the given regex.

Matches named exempt or ignore can be used for non-tainting names, to prevent built-in or interface-dictated names to trigger certain naming styles.

--name-group=<name1:name2:...,...>¶

Default value: empty

Format: comma-separated groups of colon-separated names.

This option can be used to combine name styles. For example, function:method enforces that functions and methods use the same style, and a style triggered by either name type carries over to the other. This requires that the regular expression for the combined name types use the same group names.

Name Hints¶

--include-naming-hint=y|n¶

Default: off

Include a hint (regular expression used) for the correct name format with every invalid-name warning.

Created by the basic checker.