-[Context Manager](#context-manager)

-[with statement](#with-statement)

-[Writing your own contextmanager using generator syntax](#writing-your-own-contextmanager-using-generator-syntax)

-[__main__ Top-level script environment](#main-top-level-script-environment)

-[Advantages](#advantages)

-[Virtual Environment](#virtual-environment)

-[virtualenv](#virtualenv)

-[pipenv](#pipenv)

Examples of expressions in the interactive shell:

The names```argsand kwargs``` are arbitrary- the important thing are the```*```and```**``` operators. They can mean:

1. In a function declaration,```*``` means “packall remaining positional arguments into atuple named<name>”,while```**```is the samefor keyword arguments (except it uses a dictionary,not atuple).

1. In a function declaration,```*``` means “packall remaining positional arguments into atuple named`<name>`”,while```**```is the samefor keyword arguments (except it uses a dictionary,not atuple).

2. In a function call,```*``` means “unpacktupleorlist named<name> to positional arguments at this position”,while```**```is the samefor keyword arguments.

2. In a function call,```*``` means “unpacktupleorlist named`<name>` to positional arguments at this position”,while```**```is the samefor keyword arguments.

For example you can make a function that you can use to callany other function, no matter what parameters it has:

[*Return to the Top*](#python-cheatsheet)

`__main__`is the name of the scopein which top-level code executes.

A module’s__name__isset equal to`__main__` when readfrom standardinput, a script,orfrom an interactive prompt.

A module can discover whetherornot itis runningin the main scope by checking its own`__name__`, which allows a common idiomfor conditionally executing codein a module when itis runas a scriptorwith`python-m` butnot when itis imported:

>>>if__name__=="__main__":

... main()

For a package, the same effect can be achieved by including a __main__.py module, the contents of which will be executed when the moduleis runwith-m

For example we are developing script whichis designed to be usedas module, we should do:

>>>def add(a, b):

...return a+b

>>> add(10,20)# we can test it by calling the function save it as calculate.py

>>>if__name__=="__main__":

... add(3,5)

>>>import calculate

>>> calculate.add(3,5)

1. Every Python module has it’s`__name__` definedandif thisis`__main__`, it implies that the moduleis being run standalone by the userand we can do corresponding appropriate actions.

2. If youimport this scriptas a modulein another script, the__name__isset to the name of the script/module.

3. Python files can actas either reusable modules,oras standalone programs.

4.if`__name__== “main”:`is used to execute some code onlyif thefile was run directly,andnot imported.

[*Return to the Top*](#python-cheatsheet)

The use of a Virtual Environmentis to test python codein encapsulated environmentsand to also avoid filling the base Python installationwith libraries we might usefor only one project.

-[Ternary Conditional Operator](#ternary-conditional-operator)

-[args and kwargs](#args-and-kwargs)

-[Context Manager](#context-manager)

-[__main__ Top-level script environment](#main-top-level-script-environment)

-[Virtual Environment](#virtual-environment)

The names```argsand kwargs``` are arbitrary- the important thing are the```*```and```**``` operators. They can mean:

1. In a function declaration,```*``` means “packall remaining positional arguments into atuple named<name>”,while```**```is the samefor keyword arguments (except it uses a dictionary,not atuple).

1. In a function declaration,```*``` means “packall remaining positional arguments into atuple named`<name>`”,while```**```is the samefor keyword arguments (except it uses a dictionary,not atuple).

2. In a function call,```*``` means “unpacktupleorlist named<name> to positional arguments at this position”,while```**```is the samefor keyword arguments.

2. In a function call,```*``` means “unpacktupleorlist named`<name>` to positional arguments at this position”,while```**```is the samefor keyword arguments.

For example you can make a function that you can use to callany other function, no matter what parameters it has:

Enter

Rightin the middlewithcm=3

Exit

```__main__```is the name of the scopein which top-level code executes.

A module’s__name__isset equal to```__main__``` when readfrom standardinput, a script,orfrom an interactive prompt.

`__main__`is the name of the scopein which top-level code executes.

A module’s__name__isset equal to`__main__` when readfrom standardinput, a script,orfrom an interactive prompt.

A module can discover whetherornot itis runningin the main scope by checking its own```__name__```, which allows a common idiomfor conditionally executing codein a module when itis runas a scriptorwith```python-m``` butnot when itis imported:

A module can discover whetherornot itis runningin the main scope by checking its own`__name__`, which allows a common idiomfor conditionally executing codein a module when itis runas a scriptorwith`python-m` butnot when itis imported:

>>>if__name__=="__main__":

... main()

For a package, the same effect can be achieved by including a __main__.py module, the contents of which will be executed when the moduleis runwith-m

For example we are developing script whichis designed to be usedas module, we should do:

>>> add(10,20)# we can test it by calling the function save it as calculate.py

>>>if__name__=="__main__":

... add(3,5)

1. Every Python module has it’s```__name__``` definedandif thisis```__main__```, it implies that the moduleis being run standalone by the userand we can do corresponding appropriate actions.

1. Every Python module has it’s`__name__` definedandif thisis`__main__`, it implies that the moduleis being run standalone by the userand we can do corresponding appropriate actions.

2. If youimport this scriptas a modulein another script, the__name__isset to the name of the script/module.

3. Python files can actas either reusable modules,oras standalone programs.

4.if```__name__== “main”:```is used to execute some code onlyif thefile was run directly,andnot imported.

4.if`__name__== “main”:`is used to execute some code onlyif thefile was run directly,andnot imported.

"- [Context Manager](#context-manager)\n",

" - [with statement](#with-statement)\n",

" - [Writing your own contextmanager using generator syntax](#writing-your-own-contextmanager-using-generator-syntax)\n",

"- [__main__ Top-level script environment](#main-top-level-script-environment)\n",

" - [Advantages](#advantages)\n",

"- [Virtual Environment](#virtual-environment)\n",

" - [virtualenv](#virtualenv)\n",

" - [pipenv](#pipenv)\n",

"source": [

"### set symetric_difference\n",

"\n",

]

},

{

"\n",

"The names ```args and kwargs``` are arbitrary - the important thing are the ```*``` and ```**``` operators. They can mean:\n",

"\n",

"1. In a function declaration, ```*``` means “pack all remaining positional arguments into a tuple named <name>”, while ```**``` is the same for keyword arguments (except it uses a dictionary, not a tuple).\n",

"1. In a function declaration, ```*``` means “pack all remaining positional arguments into a tuple named`<name>`”, while ```**``` is the same for keyword arguments (except it uses a dictionary, not a tuple).\n",

"\n",

"2. In a function call, ```*``` means “unpack tuple or list named <name> to positional arguments at this position”, while ```**``` is the same for keyword arguments.\n",

"2. In a function call, ```*``` means “unpack tuple or list named`<name>` to positional arguments at this position”, while ```**``` is the same for keyword arguments.\n",

"\n",

]

"cell_type":"markdown",

"metadata": {},

"source": [

"[*Return to the Top*](#python-cheatsheet)\n",

"\n",

"## __main__ Top-level script environment\n",

"\n",

"`__main__` is the name of the scope in which top-level code executes.\n",

"A module’s __name__ is set equal to `__main__` when read from standard input, a script, or from an interactive prompt.\n",

"\n",

]

},

{

"cell_type":"code",

"execution_count":null,

"metadata": {},

"outputs": [],

"source": [

">>> if __name__ ==\"__main__\":\n",

"... # execute only if run as a script\n",

]

},

{

"cell_type":"markdown",

"metadata": {},

"source": [

"For a package, the same effect can be achieved by including a __main__.py module, the contents of which will be executed when the module is run with -m\n",

"\n",

]

},

{

"cell_type":"code",

"execution_count":null,

"metadata": {},

"outputs": [],

"source": [

">>> # Python program to execute function directly\n",

">>> def add(a, b):\n",

"... return a+b\n",

"...\n",

">>> add(10, 20) # we can test it by calling the function save it as calculate.py\n",

"30\n",

">>> # Now if we want to use that module by importing we have to comment out our call,\n",

">>> # Instead we can write like this in calculate.py\n",

">>> if __name__ ==\"__main__\":\n",

"... add(3, 5)\n",

"...\n",

">>> import calculate\n",

">>> calculate.add(3, 5)\n",

]

},

{

"cell_type":"markdown",

"metadata": {},

"source": [

"### Advantages\n",

"\n",

"1. Every Python module has it’s `__name__` defined and if this is `__main__`, it implies that the module is being run standalone by the user and we can do corresponding appropriate actions.\n",

"2. If you import this script as a module in another script, the __name__ is set to the name of the script/module.\n",

"3. Python files can act as either reusable modules, or as standalone programs.\n",

"4. if `__name__ == “main”:` is used to execute some code only if the file was run directly, and not imported.\n",

"\n",

"[*Return to the Top*](#python-cheatsheet)\n",

"\n",

"## Virtual Environment\n",