Основы Python — кратко. Часть 6. Расширенное определение функций.
В этом разделе мы поговорим более подробно про определение функций, и раскроем некоторые Python-специфичные особенности данного процесса. Так как информации много, то постараюсь излагать все достаточно кратко.
Параметры по-умолчанию
Для всех параметров функций можно указывать значения по-умолчанию, это дает возможность вызвать функцию с меньшим числом параметров. Например, у нас есть функция для авторизации пользователя на сайте:
В общем, те параметры что есть – сопоставляются слева направо (если имя не указано конкретно), остальные заменяются значениями по-умолчанию (если они конечно заданы).
Важной особенностью в данном случае является то, что значения по-умолчанию вычисляются и ассоциируются только один раз – в момент объявления функции. Все вытекающие из этого недостатки наглядно продемонстрирует пример:
Более неприятное следствие из этого. Допустим, мы хотим объявить функцию, принимающую на вход список, что-то с ним делающую и печатающую его. Причем если список не задан, то по умолчанию он равен пустому.
Попытка сделать это «в лоб» будет работать не совсем так как хотелось бы:
Собственно, проблема тут в том, что переменная lst будет ассоциирована с пустым списком один раз, и между вызовами будет сохранять свое значение.
В данном случае, правильно будет описать нашу функцию следующим образом (как рекомендуют все учебники):
Данная функция как раз будет работать так как хотелось бы изначально.
Position и keyword аргументы.
Зачастую случается необходимость сделать функцию, которая обрабатывает неопределенное число параметров. Например функция расчета суммы элементов списка.
Мы конечно можем передавать все аргументы как один параметр типа list, но это выглядит некрасиво. Потому в Пайтоне был придуман специальный механизм, называемый position-arguments. Вот пример, демонстрирующий использование.
В данном случае, все наши параметры «упаковываются» в список args в соответствии с их «порядковым номером» при передаче.
Возможна и обратная операция, допустим у нас есть список значений, и мы хотим передать их как список параметров функции:
В этом примере список lst был «распакован» и подставлен на место параметров функции range, то есть вызов был аналогичен:
Кроме position, можно использовать и т.н. keyword аргументы. Они отличаются тем что для них надо явно задавать имя. Вот пример – функция, генерирующая insert выражение для базы данных (NB: максимальная оптимизация не ставилась в данном случае за самоцель).
На выходе мы получим то что и ожидалось:
Обратите внимание на второй вызов функции gen_insert – так мы можем вызвать функцию имея только словарь параметров. Это применимо к любой функции. Так же возможны различные сочетания positional и keyword аргументов.
В качестве завершающего примера рассмотрим такую функцию:
Это – простейший способ отладки функции, мы как бы «оборачиваем» вызов одной функции другой что бы вывести промежуточную информацию.
Забегая вперед – скажу что в Пайтоне есть очень мощный инструмент для более удобного использования подобного рода «оборачивающих» функций, называемый декораторами, но про это позже.
На этом на сегодня все. Продолжение следует (либо мое, либо уважаемого Gerlion), оставайтесь с нами.
Python — Function and Function Parameters
In a nutshell when we defined a function, we may or may not pass parameters. But most of the time parameters are passed while defining a function. Semantically we defined function as below:
So when we call the function,
In this context x and y are arguments of myfunction and most importantly note that x and y are passed by reference. i.e. the memory address of x and y are passed.
We can pass positional and keyword arguments to a function.
Positional and Keyword Arguments
We normally assign the arguments to parameters of a function in the order in which they are passed, i.e. the position of the parameter.
Let’s define a function, which takes two arguments and return the concatenation of two strings.
So when we call above function by passing arguments,
Where the first argument “hello” assigned to first parameter i.e. a and second argument “world!!”assigned to second parameter i.e. b.
We can make positional argument as optional by specifying a “Default” value for the corresponding parameter. Let’s modify our concatenate function by adding additional parameter,
We added third variable “c” with default value as “Welcome”. So if we call above function without passing third argument, then default value for third positional parameter will be referred.
So if we call the above function,
The output will be:
Now if we pass third argument then the function will not consider the default value of third parameter (which is obvious ��). To illustrate let’s modify our code :
When we run the above code, the output will be:
Hello, this is my first story in Medium
So far so good and pretty straightforward to understand. However, there might be a situation where we have function, in which any one of the parameter is optional. To be more precise, let’s say we have addition function which have three parameters and one of them or to simplify the second positional parameter is optional.
If we call this function by passing only two arguments, for example:
then python will not able to identify whether the second argument i.e. 150 refers to second parameter i.e. b or third parameter i.e. c. So it will throw error while executing.
The error could be something like:
So, in order to avoid such error, we need to follow following rule while passing positional parameter with default value.
If we defined a positional parameter with default value then for every positional parameter(s) after it we must also be given default value.
So we need to modify our addition function by assigning default value to third parameter i.e. c
Now when we run below code:
For the addition function , we can now pass one argument as well. For example:
Now what if you want to skip the second second argument and pass first and third arguments to addition function. We can achieve this by using “Keyword Arguments” which also known as “Named Arguments”.
Using Keyword or named arguments, we can invoke the function by passing 1st and 3rd arguments leaving default values for 2nd argument.
Notes:
1. We can specify positional arguments by using their parameter name, no matter they have assigned values or not.
Example: Let’s define a function which takes 4 parameters and return all 4 values passed to the function.
You can call the function either passing all the four arguments without using Keyword arguments or with keyword arguments.
val1 = 120, val2 =140, val3 =300, val4 =400
If we are using keyword arguments, then order of passing parameter does not matter and that is the advantage of using keyword arguments.
However there is a caveat when using Keyword argument.
2. If you started using keyword argument then all arguments thereafter must be keyword arguments.
When we run the above code, below error message will display:
Arbitrary Arguments (*args)
When we define a function with parameters and access the function with arguments then eventually we are accessing the parameters by their relative positions.
For example, my_returnargs function takes 3 positional arguments and returns these value.
Let’s define a list variable which has three values:
Now let’s pass list as an arguments to my_returnargs function, rather we will unpack list so that all the values will be passed as an argument:
The output will be
First Positional Value = Hello
Second Positional Value = World
Third Positional Value = Learn Python
In the above example we have 3 arguments passed in the function and since list has 3 elements so when unpacked all the three arguments assigned with value.
Now what if we have same list which has more than 3 elements and tries to unpack in function arguments then what will happen ?
So when we execute the above code, python will throw error:
We can avoid such error by passing arbitrary arguments (*args) in the function. We can modify the function to take two positional arguments and post that arbitrary arguments.
Now let’s run the same code where we have unpacked the list with 4 values
The output will be:
First Positional Value = Hello
Second Positional Value = World
Arbitrary Argument Values = (‘Learn Python’, ‘Some Extra Arguments’)
Note: The args argument returns the value as tuple
Also you can not add any positional argument after the *args. Which means *args eventually exhaust all the positional arguments.
We can define a function by passing a positional arguments after *args. Python will never complain about while defining such function 🙂
The problem will occur when we call the function by passing arguments and python will throw TypeError
However, we can get rid of such issue by enforcing user to pass mandatory keyword arguments.
Keyword Arguments *
The question will always crops that when can we use mandatory keyword arguments ? So the answer is, once we exhausts out of all the positional arguments.
To illustrate let’s see below example:
When we run the above code the out put will be:
First Positional Value = Hello
Second Positional Value = World
Arbitrary Argument Values = (‘Learn Python’, ‘Some Extra Arguments’)
Another positional argument Value = This is a keyword argument
We can restrict function explicitly not to pass any positional argument by passing * as parameter. For example:
If we try to pass positional argument along with Keyword argument then python will through TypeError
The Output will be:
But if we pass only Keyword argument then Python will not show any error
The Output will be:
Only Keyword Argument : Hello World!!
Now let’s combine positional arguments, optional positional arguments, *args, no positional argument and mandatory keyword arguments.
In the above function, we have :
· Mandatory Positional parameter i.e. val1
· Optional Positional parameter i.e. val2
· Optional arbitrary number of positional arguments i.e. *args
· Mandatory Keyword Parameter i.e. val3
· Finally optional positional parameter i.e. val4
So when we call the function:
And the output will be:
val1 = 101
val2 = Python
args = (‘Hello’, ‘Welcome’, 20, 30)
val3 = This is a mandatory keyword arguments after args
val4 = Hello World.
What if we restrict no positional arguments followed by mandatory keyword arguments and then optional positional argument within a function.
Let’s modify the same function as below:
In the above function, we have :
· Mandatory Positional parameter i.e. val1
· Optional Positional parameter i.e. val2
· No positional arguments i.e. *
· Mandatory Keyword Parameter i.e. val3
· Finally optional positional parameter i.e. val4
So when we call the function by passing three positional arguments followed by keyword arguments
then we will encounter below error:
The reason is the first two arguments refer to positional arguments i.e. val1 and val2 (though val2 is optional positional argument which has default value of 50 but here we pass 25.) . However when we pass the third argument i.e. 1000 before keyword argument i.e. val3 then the Python could not process as the function is defined as after the two positional arguments there should not be any positional arguments to be passed rather mandatory keyword argument i.e. val3 and followed by another optional positional parameter.
Let’s modify the arguments while calling the function as below:
val1 = test
val2 = 25
val3 = 100.1005
val4 = Welcome to pythonic way of writing python
Quite interesting but very important (more specifically it’s a caveat ), if you call a function with named or keyword arguments though you declare these as positional argument followed by *args then Python will throw Syntax error stating Positional argument follows keyword argument.
To illustrate this , let’s run below code:
So when we run the above code, below error will display:
What if we call the function and tries to pass the option argument at end of *args. Well certainly Python will throw error as it finds multiple values of positional argument val3.
Arbitrary number of keyword arguments (**kwargs)
In python we can add arbitrary number of keyword arguments to a function using **kwargs.
User can specify **kwargs even though the positional arguments are not exhausted (which is not true for *args). However, there should not be any positional parameters that can come after **kwargs.
But there is a caveat to **kwargs. If we declare a function where the first parameter is * i.e. no positional arguments followed by **kwargs then Python will not process rather throws a syntax error:
However, the above function will work if we pass mandatory keyword or optional positional argument followed by **kwargs.
Note: The kwargs argument returns the value as dictionary
val 0.6
A validator for arbitrary Python objects. Works with Python 2 and 3.
Inspired by some of the wonderful ideas in schema and flatland, many of which I outright stole.
The goal is to make validation faster than either, while keeping the very pythonic and minimal style of schema , at the expense of more advanced features.
Current status is: used in production code, but only in one place that I know of.
I have not optimized much, but for the kind of schemas I need (specifically: to validate JSON that has been loaded into python structures as part of a REST API,) I have some anecdotal evidence that it’s around ten times faster than both schema and flatland. (Again, that is mostly because it does way less.)
The schemas understood by val are very similar to the ones in schema , but not 100% compatible.
Syntax
Elements that can occur in a schema are:
Literals
Simple literal values will match equal values:
Types
Types and classes will validate anything that is an instance of the type:
Lists
Lists will validate list values all of whose elements are validated by at least one of the elements in the schema (order or number of elements do not matter, see Ordered()):
Dictionaries
Dictionaries will validate dictionaries all of whose key value pairs are validated by at least one of the key value pairs in the schema, and that are not missing any of the keys specified (unless they are specified as Optional()):
Callables
Callables (that aren’t of type type ) will validate any value for which the callable returns a truthy value. TypeErrors or ValueErrors in the call will result in a NotValid exception:
To get nicer error messages, use functions rather than lambdas (if the function has a doc string it will be used in the error message, otherwise the name of the funtion will):
Convert()
Convert(callable) will call the callable on the value being validated, and substitute the result of that call for the original value in the validated structure. TypeErrors or ValueErrors in the call will result in a NotValid exception. This or supplying Default Values are the only ways to modify the data during validation. For that reason it should be used sparingly.
Convert is useful to convert between representations (for instance from timestamps to datetime objects, or uuid string representations to uuid objects, etc.):
Or(element1, element2, . ) will validate a value validated by any of the elements passed into the Or:
And(element1, element2, . ) will validate a value validated by all of the elements passed into the And:
Optional()
Ordered()
Ordered([element1, element2, element3]) will validate a list with exactly 3 elements, each of which must be validated by the corresponding element in the schema. If order and number of elements do not matter, just use Lists:
Parsed Schemas
Other parsed schema objects. So this works:
How do I validate only some of the keys in a dictionary?
Often when validating input there will be values present that your code doesn’t act upon, and doesn’t care about the presence or absence of. You can make your schema similarly indifferent by adding str: object (assuming the keys in the dictionary are all strings, like they are when your data comes from JSON. If even the type of the keys is variable, you can use object: object .) This will match and validate any keys in the dictionary that you didn’t explicitly specify.
Advanced Topics
Default Values
One can supply a default value to any (subclass of) Schema, which will be used in place of the validated value if that evaluates to False .
Note that the original value must still be valid for the schema, so this will not work:
Default values will also work for dictionary keys that are specified as Optional :
Additional Validators
Sometimes it is useful to do validation that depends on multiple parts of the data at once. For this purpose, Schemas can be initialized with additional validators.
Serializing Schemas
When your application receives JSON from clients, it can be useful to define explicit schemas that those clients have to abide by. Pointing to source code isn’t an especially great way to communicate to other developers what is or isn’t considered valid JSON by your application, especially if they aren’t developing in Python. For this purpose, teleport, a lightweight JSON format to describe schemas, is better suited.
A subset of valid val schemas is serializable/exportable to teleport. Note that things like default values and additional validators will be lost when serializing to teleport, because it has no way to express them.
Combining doctests with this serialization provides a way to specify what your application considers valid, and verify in your tests that you didn’t unintentionally break clients’ assumptions.
If your code contains the following schema for todo items:
Then in your API documentation you could use the document() helper and have doctests verify the output, as is the case here.
Val python что это
Developers often have a need to interact with users, either to get data or to provide some sort of result. Most programs today use a dialog box as a way of asking the user to provide some type of input. While Python provides us with two inbuilt functions to read the input from the keyboard.
input() function
Python input() function is used to take the values from the user. This function is called to tell the program to stop and wait for the user to input the values. It is a built-in function. The input() function is used in both the version of Python 2.x and Python 3.x. In Python 3.x, the input function explicitly converts the input you give to type string. But Python 2.x input function takes the value and type of the input you enter as it is without modifying the type.
Example program in Python3
Python3
Input and Output
Here, the value “python3” take from the user and store it in the val1 variable. The type of the value stored is always string for input function only for Python 3.x. The value “1997” take from the user and store it in the variable val2. Now, the type of variable val2 is a string and we have to convert the type to an integer using int() function. The val2 variable stores the value “1997” as an integer type.
Example program in Python2
Python3
Input and Output
Here, the value “python3” take from the user and store it in the val1 variable. The function takes the value and type of the input you enter as it is without modifying the type. The type of value in val1 is string type. The value “1997” takes from the user and store it in the variable val2. Now, the type of variable val2 is integer type. We don’t need to explicitly change the variable type.
raw_input() function
Python raw_input function is used to get the values from the user. We call this function to tell the program to stop and wait for the user to input the values. It is a built-in function. The input function is used only in Python 2.x version. The Python 2.x has two functions to take the value from the user. The first one is input function and another one is raw_input() function. The raw_input() function is similar to input() function in Python 3.x. Developers are recommended to use raw_input function in Python 2.x. Because there is a vulnerability in input function in Python 2.x version.