Читать книгу SAS Viya - Kevin D. Smith - Страница 19

We have already seen a few action parameters being used on the help action (action, actionset, and verbose). When a CAS action is added to the CAS object, all action parameters are mapped to Python keyword parameters. Let’s look at the function signature of help to see the supported action parameters.

In [12]: conn.help?

Type: builtins.Help

String form: ?.builtins.Help()

File: swat/cas/actions.py

Definition: ?.help(_self_, action=None,

actionset=None,

verbose=True, **kwargs)

... truncated ...

You see that there is one positional argument (_self_2). It is simply the Python object that help is being called on. The rest of the arguments are keyword arguments that are converted to action parameters and passed to the action. The **kwargs argument is always specified on actions as well. It enables the use of extra parameters for debugging and system use. Now let’s look at the descriptions of the parameters (the following output is continued from the preceding help? invocation).

Docstring:

Shows the parameters for an action or lists all available actions

Parameters

----------

action : string, optional

specifies the name of the action for which you want help. The name

can be in the form 'actionSetName.actionName' or just

'actionName’.

actionset : string, optional

specifies the name of the action set for which you want help. This

parameter is ignored if the action parameter is specified.

verbose : boolean, optional

when set to True, provides more detail for each parameter.

Default: True

You see that action and actionset are declared as strings, and verbose is declared as a Boolean. Action parameters can take many types of values. The following table shows the supported types:

CAS Type	Python Type	Description
Boolean	bool	Value that indicates true or false. This should always be specified using Python’s True or False values.
double	floatswat.float64	64-bit floating point number
int32	intswat.int32	32-bit integer
int64	long (Python 2)int (Python 3)swat.int64	64-bit integer
string	Unicode (Python 2)str (Python 3)	Character content. Note that if a byte string is passed as an argument, SWAT attempts to convert it to Unicode using the default encoding.
value list	list or dict	Collection of items. Python lists become indexed CAS value lists. Python dicts become keyed CAS value lists.

The easiest way to practice more complex arguments is by using the echo action. This action simply prints the value of all parameters that were specified in the action call. The following code demonstrates the echo action with all of the parameter types in the preceding table.

In [13]: out = conn.echo(

...: boolean_true = True,

...: boolean_false = False,

...: double = 3.14159,

...: int32 = 1776,

...: int64 = 2**60,

...: string = u'I like snowmen! \u2603',

...: list = [u'item1', u'item2', u'item3'],

...: dict = {'key1': 'value1',

...: 'key2': 'value2',

...: 'key3': 3}

...: )

NOTE: builtin.echo called with 8 parameters.

NOTE: parameter 1: int32 = 1776

NOTE: parameter 2: boolean_false = false

NOTE: parameter 3: list = {'item1', 'item2', 'item3'}

NOTE: parameter 4: boolean_true = true

NOTE: parameter 5: int64 = 1152921504606846976

NOTE: parameter 6: double = 3.14159

NOTE: parameter 7: string = 'I like snowmen! '

NOTE: parameter 8: dict = {key1 = 'value1', key3 = 3,

key2 = 'value2'}

You might notice that the parameters are printed in a different order than what was specified in the echo call. This is simply because keyword parameters in Python are stored in a dictionary, and dictionaries don’t keep keys in a specified order.

You might also notice that the printed syntax is not Python syntax. It is a pseudo-code syntax more similar to the Lua programming language. Lua is used in other parts of CAS as well (such as the history action), so most code-like objects that are printed from CAS are in Lua or syntax that is like Lua. However, the syntax of the two languages (as far as parameter data structures goes) are similar enough that it is easy to see the mapping from one to the other. The biggest differences are in the value list parameters. Indexed lists in the printout use braces, whereas Python uses square brackets. Also, in the keyed list, Python’s keys must be quoted, and the separator that is used between the key and the value is a colon (:) rather than an equal sign (=).

The complexity of the parameter structures is unlimited. Lists can be nested inside dictionaries, and dictionaries can be nested inside lists. A demonstration of nested structures in echo follows:

In [14]: out = conn.echo(

...: list = ['item1',

...: 'item2',

...: {

...: 'key1': 'value1',

...: 'key2': {

...: 'value2': [0, 1, 1, 2, 3]

...: }

...: }

...: ])

NOTE: builtin.echo called with 1 parameters.

NOTE: parameter 1: list = {'item1', 'item2',

{key1 = 'value1',

key2 = {value2 = {0, 1, 1, 2, 3}}}}

Nested dictionary parameters are fairly common in CAS and can create some confusion with the nesting levels and differences between keyword arguments and dictionary literals. Because of this, some utility functions have been added to SWAT to aid in the construction of nested parameters.