faker.providers.python
¶
Subpackages¶
Package Contents¶
Classes¶
Attributes¶
- exception faker.providers.python.BaseFakerException¶
Bases:
Exception
The base exception for all Faker exceptions.
- class faker.providers.python.BaseProvider(generator: Any)¶
- __provider__ = 'base'¶
- __use_weighting__ = False¶
- language_locale_codes¶
- random_int(min: int = 0, max: int = 9999, step: int = 1) int ¶
Generate a random integer between two integers
min
andmax
inclusive while observing the providedstep
value.This method is functionally equivalent to randomly sampling an integer from the sequence
range(min, max + 1, step)
.- Sample
min=0, max=15
- Sample
min=0, max=15, step=3
- random_digit_or_empty() Union[int, str] ¶
Generate a random digit (0 to 9) or an empty string.
This method will return an empty string 50% of the time, and each digit has a 1/20 chance of being generated.
- random_digit_not_null_or_empty() Union[int, str] ¶
Generate a random non-zero digit (1 to 9) or an empty string.
This method will return an empty string 50% of the time, and each digit has a 1/18 chance of being generated.
- random_number(digits: Optional[int] = None, fix_len: bool = False) int ¶
Generate a random integer according to the following rules:
If
digits
isNone
(default), its value will be set to a random integer from 1 to 9.If
fix_len
isFalse
(default), all integers that do not exceed the number ofdigits
can be generated.If
fix_len
isTrue
, only integers with the exact number ofdigits
can be generated.
- Sample
fix_len=False
- Sample
fix_len=True
- Sample
digits=3
- Sample
digits=3, fix_len=False
- Sample
digits=3, fix_len=True
- random_letters(length: int = 16) Sequence[str] ¶
Generate a list of random ASCII letters (a-z and A-Z) of the specified
length
.- Sample
length=10
- random_elements(elements: ElementsType[T] = ('a', 'b', 'c'), length: Optional[int] = None, unique: bool = False, use_weighting: Optional[bool] = None) Sequence[T] ¶
Generate a list of randomly sampled objects from
elements
.Set
unique
toFalse
for random sampling with replacement, and setunique
toTrue
for random sampling without replacement.If
length
is set toNone
or is omitted,length
will be set to a random integer from 1 to the size ofelements
.The value of
length
cannot be greater than the number of objects inelements
ifunique
is set toTrue
.The value of
elements
can be any sequence type (list
,tuple
,set
,string
, etc) or anOrderedDict
type. If it is the latter, the keys will be used as the objects for sampling, and the values will be used as weighted probabilities ifunique
is set toFalse
. For example:# Random sampling with replacement fake.random_elements( elements=OrderedDict([ ("variable_1", 0.5), # Generates "variable_1" 50% of the time ("variable_2", 0.2), # Generates "variable_2" 20% of the time ("variable_3", 0.2), # Generates "variable_3" 20% of the time ("variable_4": 0.1), # Generates "variable_4" 10% of the time ]), unique=False ) # Random sampling without replacement (defaults to uniform distribution) fake.random_elements( elements=OrderedDict([ ("variable_1", 0.5), ("variable_2", 0.2), ("variable_3", 0.2), ("variable_4": 0.1), ]), unique=True )
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), unique=False
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), unique=True
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), length=10, unique=False
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), length=4, unique=True
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35),
(“c”, 0.15), (“d”, 0.05),
]), length=20, unique=False
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
]), unique=True
- random_choices(elements: ElementsType[T] = ('a', 'b', 'c'), length: Optional[int] = None) Sequence[T] ¶
Generate a list of objects randomly sampled from
elements
with replacement.For information on the
elements
andlength
arguments, please refer torandom_elements()
which is used under the hood with theunique
argument explicitly set toFalse
.- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’)
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’), length=10
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
])
- Sample
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
]), length=20
- random_element(elements: ElementsType[T] = ('a', 'b', 'c')) T ¶
Generate a randomly sampled object from
elements
.For information on the
elements
argument, please refer torandom_elements()
which is used under the hood with theunique
argument set toFalse
and thelength
argument set to1
.- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’)
- Sample size=10
- elements=OrderedDict([
(“a”, 0.45), (“b”, 0.35), (“c”, 0.15), (“d”, 0.05),
])
- random_sample(elements: ElementsType[T] = ('a', 'b', 'c'), length: Optional[int] = None) Sequence[T] ¶
Generate a list of objects randomly sampled from
elements
without replacement.For information on the
elements
andlength
arguments, please refer torandom_elements()
which is used under the hood with theunique
argument explicitly set toTrue
.- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’)
- Sample
elements=(‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’), length=3
- randomize_nb_elements(number: int = 10, le: bool = False, ge: bool = False, min: Optional[int] = None, max: Optional[int] = None) int ¶
Generate a random integer near
number
according to the following rules:If
le
isFalse
(default), allow generation up to 140% ofnumber
. IfTrue
, upper bound generation is capped at 100%.If
ge
isFalse
(default), allow generation down to 60% ofnumber
. IfTrue
, lower bound generation is capped at 100%.If a numerical value for
min
is provided, generated values less thanmin
will be clamped atmin
.If a numerical value for
max
is provided, generated values greater thanmax
will be clamped atmax
.If both
le
andge
areTrue
, the value ofnumber
will automatically be returned, regardless of the values supplied formin
andmax
.
- Sample
number=100
- Sample
number=100, ge=True
- Sample
number=100, ge=True, min=120
- Sample
number=100, le=True
- Sample
number=100, le=True, max=80
- Sample
number=79, le=True, ge=True, min=80
- numerify(text: str = '###') str ¶
Generate a string with each placeholder in
text
replaced according to the following rules:Number signs (‘#’) are replaced with a random digit (0 to 9).
Percent signs (‘%’) are replaced with a random non-zero digit (1 to 9).
Dollar signs (‘$’) are replaced with a random digit above two (2 to 9).
Exclamation marks (‘!’) are replaced with a random digit or an empty string.
At symbols (‘@’) are replaced with a random non-zero digit or an empty string.
Under the hood, this method uses
random_digit()
,random_digit_not_null()
,random_digit_or_empty()
, andrandom_digit_not_null_or_empty()
to generate the random values.- Sample
text=’Intel Core i%-%%##K vs AMD Ryzen % %%##X’
- Sample
text=’!!! !!@ !@! !@@ @!! @!@ @@! @@@’
- lexify(text: str = '????', letters: str = string.ascii_letters) str ¶
Generate a string with each question mark (‘?’) in
text
replaced with a random character fromletters
.By default,
letters
contains all ASCII letters, uppercase and lowercase.- Sample
text=’Random Identifier: ??????????’
- Sample
text=’Random Identifier: ??????????’, letters=’ABCDE’
- bothify(text: str = '## ??', letters: str = string.ascii_letters) str ¶
Generate a string with each placeholder in
text
replaced according to the following rules:Number signs (‘#’) are replaced with a random digit (0 to 9).
Question marks (‘?’) are replaced with a random character from
letters
.
By default,
letters
contains all ASCII letters, uppercase and lowercase.Under the hood, this method uses
numerify()
and andlexify()
to generate random values for number signs and question marks respectively.- Sample
letters=’ABCDE’
- Sample
text=’Product Number: ????-########’
- Sample
text=’Product Number: ????-########’, letters=’ABCDE’
- hexify(text: str = '^^^^', upper: bool = False) str ¶
Generate a string with each circumflex (‘^’) in
text
replaced with a random hexadecimal character.By default,
upper
is set to False. If set toTrue
, output will be formatted using uppercase hexadecimal characters.- Sample
text=’MAC Address: ^^:^^:^^:^^:^^:^^’
- Sample
text=’MAC Address: ^^:^^:^^:^^:^^:^^’, upper=True
- faker.providers.python.ElementsType¶
- faker.providers.python.TypesNames¶
- faker.providers.python.TypesSpec¶
- faker.providers.python.TEnum¶
- exception faker.providers.python.EmptyEnumException¶
Bases:
faker.exceptions.BaseFakerException
The base exception for all Faker exceptions.
- class faker.providers.python.Provider(generator: Any)¶
Bases:
faker.providers.BaseProvider
- default_value_types: faker.providers.ElementsType[str] = ('str', 'str', 'str', 'str', 'float', 'int', 'int', 'decimal', 'date_time', 'uri', 'email')¶
- _check_signature(value_types: Optional[TypesSpec], allowed_types: Optional[TypesSpec]) TypesSpec ¶
- pyobject(object_type: Optional[Type[Union[bool, str, float, int, tuple, set, list, Iterable, dict]]] = None) Optional[Union[bool, str, float, int, tuple, set, list, Iterable, dict]] ¶
Generates a random object passing the type desired.
- Object_type
the type of the object to generate.
- Returns
the random object generated.
- Raises
ValueError – if the object type passed is not supported
- pybool(truth_probability: int = 50) bool ¶
Generates a random boolean, optionally biased towards True or False.
- Truth_probability
Probability of generating a True value. Must be between 0 and 100 inclusive’.
- Returns
Random boolean.
- Raises
ValueError – If invalid truth_probability is provided.
- pystr(min_chars: Optional[int] = None, max_chars: int = 20, prefix: str = '', suffix: str = '') str ¶
Generates a random string of upper and lowercase letters.
- Parameters
min_chars – minimum length of the random part.
max_chars – maximum length of the random part.
prefix – an optional prefix to prepend to the random string.
suffix – an optional suffix to append to the random string.
- Returns
Random of random length between min and max characters.
- pystr_format(string_format: str = '?#-###{{random_int}}{{random_letter}}', letters: str = string.ascii_letters) str ¶
- pyfloat(left_digits=None, right_digits=None, positive=False, min_value=None, max_value=None)¶
- pydecimal(left_digits=None, right_digits=None, positive=False, min_value=None, max_value=None)¶
- pytuple(nb_elements: int = 10, variable_nb_elements: bool = True, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) Tuple[Any, Ellipsis] ¶
- pyset(nb_elements: int = 10, variable_nb_elements: bool = True, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) Set[Any] ¶
- pylist(nb_elements: int = 10, variable_nb_elements: bool = True, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) List[Any] ¶
- pyiterable(nb_elements: int = 10, variable_nb_elements: bool = True, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) Iterable[Any] ¶
- _pyiterable(nb_elements: int = 10, variable_nb_elements: bool = True, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) Iterator ¶
- pydict(nb_elements: int = 10, variable_nb_elements: bool = True, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) Dict[Any, Any] ¶
Returns a dictionary.
- Nb_elements
number of elements for dictionary
- Variable_nb_elements
is use variable number of elements for dictionary
- Value_types
type of dictionary values
- pystruct(count: int = 10, value_types: Optional[TypesSpec] = None, allowed_types: Optional[TypesSpec] = None) Tuple[List, Dict, Dict] ¶
- enum(enum_cls: Type[TEnum]) TEnum ¶
Returns a random enum of the provided input Enum type.
- Parameters
enum_cls – The Enum type to produce the value for.
- Returns
A randomly selected enum value.