1666929780

EAGO is an open-source development environment for robust and global optimization in Julia.

## EAGO's Optimizer Capabilities

EAGO is a deterministic global optimizer designed to address a wide variety of optimization problems, emphasizing nonlinear programs (NLPs), by propagating McCormick relaxations along the factorable structure of each expression in the NLP. Most operators supported by modern automatic differentiation (AD) packages (e.g. +, sin, cosh) are supported by EAGO and a number utilities for sanitizing native Julia code and generating relaxations on a wide variety of user-defined functions have been included. Currently, EAGO supports problems that have a priori variable bounds defined and have differentiable constraints. That is, problems should be specified in the generic form below:

## EAGO's Relaxations

For each nonlinear term, EAGO makes use of factorable representations to construct bounds and relaxations. In the case of F = y(y-5)sin(y), a list is generated and rules for constructing McCormick relaxations are used to formulate relaxations in the original Y decision space1:

• v1 = y
• v2 = v1 - 5
• v3 = sin(v1)
• v4 = v1v2
• v5 = v4v3
• F = v5

Either these original relaxations, differentiable McCormick relaxations2, or affine relaxations thereof can be used to construct relaxations of optimization problems useful in branch and bound routines for global optimization. Utilities are included to combine these with algorithms for relaxing implicit functions3 and forward-reverse propagation of McCormick arithmetic4.

## Sample Usage

EAGO makes use of the JuMP algebraic modeling language to improve the user's experience in setting up optimization models. Consider the familiar "process" problem instance5:

This model can be formulated using JuMP code as:

``````using JuMP, EAGO

m = Model(EAGO.Optimizer)

# Define bounded variables
xL = [10.0; 0.0; 0.0; 0.0; 0.0; 85.0; 90.0; 3.0; 1.2; 145.0]
xU = [2000.0; 16000.0; 120.0; 5000.0; 2000.0; 93.0; 95.0; 12.0; 4.0; 162.0]
@variable(m, xL[i] <= x[i=1:10] <= xU[i])

# Define nonlinear constraints
@NLconstraint(m, e1, -x[1]*(1.12+0.13167*x[8]-0.00667* (x[8])^2)+x[4] == 0.0)
@NLconstraint(m, e3, -0.001*x[4]*x[9]*x[6]/(98-x[6])+x[3] == 0.0)
@NLconstraint(m, e4, -(1.098*x[8]-0.038* (x[8])^2)-0.325*x[6]+x[7] == 57.425)
@NLconstraint(m, e5, -(x[2]+x[5])/x[1]+x[8] == 0.0)

# Define linear constraints
@constraint(m, e2, -x[1]+1.22*x[4]-x[5] == 0.0)
@constraint(m, e6, x[9]+0.222*x[10] == 35.82)
@constraint(m, e7, -3*x[7]+x[10] == -133.0)

# Define nonlinear objective
@NLobjective(m, Max, 0.063*x[4]*x[7] - 5.04*x[1] - 0.035*x[2] - 10*x[3] - 3.36*x[5])

# Solve the optimization problem
JuMP.optimize!(m)
``````

Special handling has been included for linear/quadratic functions defined using the `@constraint` macro in JuMP and these can generally be expected to perform better than specifying quadratic or linear terms with the `@NLconstraint` macro.

## A Cautionary Note on Global Optimization

As a global optimization platform, EAGO's solvers can be used to find solutions of general nonconvex problems with a guaranteed certificate of optimality. However, global solvers suffer from the curse of dimensionality and therefore their performance is outstripped by convex/local solvers. For users interested in large-scale applications, be warned that problems generally larger than a few variables may prove challenging for certain types of global optimization problems.

## Package Capabilities

The EAGO package has numerous features: a solver accessible from JuMP/MathOptInterface, domain reduction routines, McCormick relaxations, and specialized non-convex semi-infinite program solvers. A full description of all EAGO features is available in the documentation website. A series of example have been provided in the form of Jupyter notebooks in the separate EAGO-notebooks repository.

## Recent News

• 2/5/2021: EAGO v0.6.0 has been tagged.
• License changed from CC BY-NC-SA 4.0 to MIT
• Fix deprecated Ipopt constructor
• Fix discrepancy between the returned objective value and the objective evaluated at the solution.
• Dramatically decrease allocates and first-run performance of SIP routines.
• Add two algorithms which modify SIPres detailed in Djelassi, H. and Mitsos A. 2017.
• Fix objective interval fallback function.
• New SIP interface with extendable subroutines.
• Fix x^y relaxation bug.

## Installing EAGO

EAGO is a registered Julia package and it can be installed using the Julia package manager. From the Julia REPL, type ] to enter the Pkg REPL mode and run the following command

``````pkg> add EAGO
``````

Currently, EAGO is tied to a 0.19+ or greater version of JuMP. This allows a replication of some of the internal features shared by EAGO and JuMP's AD scheme aka generation of Wengert Tapes pass evaluators between JuMP and EAGO etc.

``````pkg> add JuMP
``````

EAGO v0.6.0 is the current tagged version and requires Julia 1.2+ for full functionality (however Julia 1.0+ versions support partial functionality). Use with version 1.5 is recommended as the majority of in-house testing has occurred using this version of Julia. The user is directed to the High-Performance Configuration for instructions on how to install a high performance version of EAGO (rather than the basic entirely open-source version). If any issues are encountered when loading EAGO (or when using it), please submit an issue using the Github issue tracker.

## Bug reporting, support and feature requests

Please report bugs or feature requests by opening an issue using the Github issue tracker. All manners of feedback are encouraged.

## Current limitations

• Nonlinear handling assumes that box-constraints of nonlinear terms are available or can be inferred from bounds-tightening.
• Only currently supports continuous functions. Support for mixed-integer problems is forthcoming.

## Work In Progress

• Extensions for nonconvex dynamic global & robust optimization.
• Provide support for mixed-integer problems.
• Update EAGO to support nonsmooth problems (requires: a nonsmooth local nlp optimizer or lexiographic AD, support for relaxations is already included).
• Performance assessment of nonlinear (differentiable) relaxations and incorporation into main EAGO routine.
• Evaluation and incorporation of implicit relaxation routines in basic solver.

## Citing EAGO

Please cite the following paper when using EAGO. In plain text form this is:

`````` M. E. Wilhelm & M. D. Stuber (2020) EAGO.jl: easy advanced global optimization in Julia,
Optimization Methods and Software, DOI: 10.1080/10556788.2020.1786566
``````

A corresponding bibtex entry text is given below and a corresponding .bib file is given in citation.bib.

``````@article{doi:10.1080/10556788.2020.1786566,
author = { M. E.   Wilhelm  and  M. D.   Stuber },
title = {EAGO.jl: easy advanced global optimization in Julia},
journal = {Optimization Methods and Software},
pages = {1-26},
year  = {2020},
publisher = {Taylor & Francis},
doi = {10.1080/10556788.2020.1786566},
URL = {https://doi.org/10.1080/10556788.2020.1786566},
eprint = {https://doi.org/10.1080/10556788.2020.1786566}
}
``````

## Related Packages

• ValidatedNumerics.jl:A Julia library for validated interval calculations, including basic interval extensions, constraint programming, and interval contactors
• MAiNGO: An open-source mixed-integer nonlinear programming package in C++ that utilizes MC++ for relaxations.
• MC++: A mature McCormick relaxation package in C++ that also includes McCormick-Taylor, Chebyshev Polyhedral and Ellipsoidal arithmetics.

## References

1. A. Mitsos, B. Chachuat, and P. I. Barton. McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2):573–601, 2009.
2. K.A. Khan, HAJ Watson, P.I. Barton. Differentiable McCormick relaxations. Journal of Global Optimization, 67(4):687-729 (2017).
3. Stuber, M.D., Scott, J.K., Barton, P.I.: Convex and concave relaxations of implicit functions. Optim. Methods Softw. 30(3), 424–460 (2015)
4. A., Wechsung JK Scott, HAJ Watson, and PI Barton. Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1):1-36 (2015).
5. Bracken, Jerome and McCormick, Garth P. Selected Applications of Nonlinear Programming, John Wiley and Sons, New York, 1968.

Author: PSORLab
Source Code: https://github.com/PSORLab/EAGO.jl

## Buddha Community

1666929780

EAGO is an open-source development environment for robust and global optimization in Julia.

## EAGO's Optimizer Capabilities

EAGO is a deterministic global optimizer designed to address a wide variety of optimization problems, emphasizing nonlinear programs (NLPs), by propagating McCormick relaxations along the factorable structure of each expression in the NLP. Most operators supported by modern automatic differentiation (AD) packages (e.g. +, sin, cosh) are supported by EAGO and a number utilities for sanitizing native Julia code and generating relaxations on a wide variety of user-defined functions have been included. Currently, EAGO supports problems that have a priori variable bounds defined and have differentiable constraints. That is, problems should be specified in the generic form below:

## EAGO's Relaxations

For each nonlinear term, EAGO makes use of factorable representations to construct bounds and relaxations. In the case of F = y(y-5)sin(y), a list is generated and rules for constructing McCormick relaxations are used to formulate relaxations in the original Y decision space1:

• v1 = y
• v2 = v1 - 5
• v3 = sin(v1)
• v4 = v1v2
• v5 = v4v3
• F = v5

Either these original relaxations, differentiable McCormick relaxations2, or affine relaxations thereof can be used to construct relaxations of optimization problems useful in branch and bound routines for global optimization. Utilities are included to combine these with algorithms for relaxing implicit functions3 and forward-reverse propagation of McCormick arithmetic4.

## Sample Usage

EAGO makes use of the JuMP algebraic modeling language to improve the user's experience in setting up optimization models. Consider the familiar "process" problem instance5:

This model can be formulated using JuMP code as:

``````using JuMP, EAGO

m = Model(EAGO.Optimizer)

# Define bounded variables
xL = [10.0; 0.0; 0.0; 0.0; 0.0; 85.0; 90.0; 3.0; 1.2; 145.0]
xU = [2000.0; 16000.0; 120.0; 5000.0; 2000.0; 93.0; 95.0; 12.0; 4.0; 162.0]
@variable(m, xL[i] <= x[i=1:10] <= xU[i])

# Define nonlinear constraints
@NLconstraint(m, e1, -x[1]*(1.12+0.13167*x[8]-0.00667* (x[8])^2)+x[4] == 0.0)
@NLconstraint(m, e3, -0.001*x[4]*x[9]*x[6]/(98-x[6])+x[3] == 0.0)
@NLconstraint(m, e4, -(1.098*x[8]-0.038* (x[8])^2)-0.325*x[6]+x[7] == 57.425)
@NLconstraint(m, e5, -(x[2]+x[5])/x[1]+x[8] == 0.0)

# Define linear constraints
@constraint(m, e2, -x[1]+1.22*x[4]-x[5] == 0.0)
@constraint(m, e6, x[9]+0.222*x[10] == 35.82)
@constraint(m, e7, -3*x[7]+x[10] == -133.0)

# Define nonlinear objective
@NLobjective(m, Max, 0.063*x[4]*x[7] - 5.04*x[1] - 0.035*x[2] - 10*x[3] - 3.36*x[5])

# Solve the optimization problem
JuMP.optimize!(m)
``````

Special handling has been included for linear/quadratic functions defined using the `@constraint` macro in JuMP and these can generally be expected to perform better than specifying quadratic or linear terms with the `@NLconstraint` macro.

## A Cautionary Note on Global Optimization

As a global optimization platform, EAGO's solvers can be used to find solutions of general nonconvex problems with a guaranteed certificate of optimality. However, global solvers suffer from the curse of dimensionality and therefore their performance is outstripped by convex/local solvers. For users interested in large-scale applications, be warned that problems generally larger than a few variables may prove challenging for certain types of global optimization problems.

## Package Capabilities

The EAGO package has numerous features: a solver accessible from JuMP/MathOptInterface, domain reduction routines, McCormick relaxations, and specialized non-convex semi-infinite program solvers. A full description of all EAGO features is available in the documentation website. A series of example have been provided in the form of Jupyter notebooks in the separate EAGO-notebooks repository.

## Recent News

• 2/5/2021: EAGO v0.6.0 has been tagged.
• License changed from CC BY-NC-SA 4.0 to MIT
• Fix deprecated Ipopt constructor
• Fix discrepancy between the returned objective value and the objective evaluated at the solution.
• Dramatically decrease allocates and first-run performance of SIP routines.
• Add two algorithms which modify SIPres detailed in Djelassi, H. and Mitsos A. 2017.
• Fix objective interval fallback function.
• New SIP interface with extendable subroutines.
• Fix x^y relaxation bug.

## Installing EAGO

EAGO is a registered Julia package and it can be installed using the Julia package manager. From the Julia REPL, type ] to enter the Pkg REPL mode and run the following command

``````pkg> add EAGO
``````

Currently, EAGO is tied to a 0.19+ or greater version of JuMP. This allows a replication of some of the internal features shared by EAGO and JuMP's AD scheme aka generation of Wengert Tapes pass evaluators between JuMP and EAGO etc.

``````pkg> add JuMP
``````

EAGO v0.6.0 is the current tagged version and requires Julia 1.2+ for full functionality (however Julia 1.0+ versions support partial functionality). Use with version 1.5 is recommended as the majority of in-house testing has occurred using this version of Julia. The user is directed to the High-Performance Configuration for instructions on how to install a high performance version of EAGO (rather than the basic entirely open-source version). If any issues are encountered when loading EAGO (or when using it), please submit an issue using the Github issue tracker.

## Bug reporting, support and feature requests

Please report bugs or feature requests by opening an issue using the Github issue tracker. All manners of feedback are encouraged.

## Current limitations

• Nonlinear handling assumes that box-constraints of nonlinear terms are available or can be inferred from bounds-tightening.
• Only currently supports continuous functions. Support for mixed-integer problems is forthcoming.

## Work In Progress

• Extensions for nonconvex dynamic global & robust optimization.
• Provide support for mixed-integer problems.
• Update EAGO to support nonsmooth problems (requires: a nonsmooth local nlp optimizer or lexiographic AD, support for relaxations is already included).
• Performance assessment of nonlinear (differentiable) relaxations and incorporation into main EAGO routine.
• Evaluation and incorporation of implicit relaxation routines in basic solver.

## Citing EAGO

Please cite the following paper when using EAGO. In plain text form this is:

`````` M. E. Wilhelm & M. D. Stuber (2020) EAGO.jl: easy advanced global optimization in Julia,
Optimization Methods and Software, DOI: 10.1080/10556788.2020.1786566
``````

A corresponding bibtex entry text is given below and a corresponding .bib file is given in citation.bib.

``````@article{doi:10.1080/10556788.2020.1786566,
author = { M. E.   Wilhelm  and  M. D.   Stuber },
title = {EAGO.jl: easy advanced global optimization in Julia},
journal = {Optimization Methods and Software},
pages = {1-26},
year  = {2020},
publisher = {Taylor & Francis},
doi = {10.1080/10556788.2020.1786566},
URL = {https://doi.org/10.1080/10556788.2020.1786566},
eprint = {https://doi.org/10.1080/10556788.2020.1786566}
}
``````

## Related Packages

• ValidatedNumerics.jl:A Julia library for validated interval calculations, including basic interval extensions, constraint programming, and interval contactors
• MAiNGO: An open-source mixed-integer nonlinear programming package in C++ that utilizes MC++ for relaxations.
• MC++: A mature McCormick relaxation package in C++ that also includes McCormick-Taylor, Chebyshev Polyhedral and Ellipsoidal arithmetics.

## References

1. A. Mitsos, B. Chachuat, and P. I. Barton. McCormick-based relaxations of algorithms. SIAM Journal on Optimization, 20(2):573–601, 2009.
2. K.A. Khan, HAJ Watson, P.I. Barton. Differentiable McCormick relaxations. Journal of Global Optimization, 67(4):687-729 (2017).
3. Stuber, M.D., Scott, J.K., Barton, P.I.: Convex and concave relaxations of implicit functions. Optim. Methods Softw. 30(3), 424–460 (2015)
4. A., Wechsung JK Scott, HAJ Watson, and PI Barton. Reverse propagation of McCormick relaxations. Journal of Global Optimization 63(1):1-36 (2015).
5. Bracken, Jerome and McCormick, Garth P. Selected Applications of Nonlinear Programming, John Wiley and Sons, New York, 1968.

Author: PSORLab
Source Code: https://github.com/PSORLab/EAGO.jl

1604922206

Advanced Excel Certification offers numerous job opportunities that have come up. Lately, companies search for a talented personality who holds great knowledge in excel. However, simply basic knowledge isn’t sufficient. If you would like to be a part of a well-renowned company then you want to have the excel certification matching industrial standards.

Whether you’re seeking higher growth within an equivalent company or expecting an honest hike from the new company, complicated excel training courses with certification can surely increase your chances to be on the brink of the success ladder. Join an advanced online excel training class and improve your skills.

The word itself explains the meaning of this course. this is often one quite skill that sets a learning benchmark for MS Excel. It offers a transparent insight to all or any of the simplest and therefore the most advanced features that are now available within the current version of Microsoft Excel.

In this competitive era where your colleagues would equally be striving to urge a far better post than you, if you excel yourself in some good certification courses then surely there’s no looking back for you.

This type of certification is all about brushing up your administration, management, and analytical skills which in today’s market is sort of important. To match up with the flexible needs of the clients, it’s important for you to be advanced and for this such training can certainly be helpful.

Some Mind-Blowing Benefits You Get:

There are ample Excel Training Courses that you simply may encounter, but choosing a certification course in Advanced excel possesses its perks for you also as for the corporate. Listed are a few that you simply got to know.

1.There is a superior recognition that you simply get
2.As compared to non-certified professionals, you occupy the highest at the competition
3.Employers will have you ever within the priority for giant important projects
4.If you’re a freelancer, then such advanced training is often an excellent learning experience
5.For those that wish to urge within the management, the world can have a boosting knowledge
6.Administration skills also get brushed up and a replacement range of job opportunities opens
7.There is an honest hike in PayScale soon after you show your skills and certification to your HR

Quick Tip which will Help:

If you’re getting to join a web course to urge such certification then see thereto that the trainer who is going to be taking care of you during this course is very experienced and may provide you with the simplest possible assistance.

Now you’ll boost your knowledge during a spreadsheet, play with new financial

1652496780

## Python Global Variables – How to Define a Global Variable Example

To begin with, you will learn how to declare variables in Python and what the term 'variable scope' actually means.

Then, you will learn the differences between local and global variables and understand how to define global variables and how to use the `global` keyword.

## What Are Variables in Python and How Do You Create Them? An Introduction for Beginners

You can think of variables as storage containers.

They are storage containers for holding data, information, and values that you would like to save in the computer's memory. You can then reference or even manipulate them at some point throughout the life of the program.

A variable has a symbolic name, and you can think of that name as the label on the storage container that acts as its identifier.

The variable name will be a reference and pointer to the data stored inside it. So, there is no need to remember the details of your data and information – you only need to reference the variable name that holds that data and information.

When giving a variable a name, make sure that it is descriptive of the data it holds. Variable names need to be clear and easily understandable both for your future self and the other developers you may be working with.

Now, let's see how to actually create a variable in Python.

When declaring variables in Python, you don't need to specify their data type.

For example, in the C programming language, you have to mention explicitly the type of data the variable will hold.

So, if you wanted to store your age which is an integer, or `int` type, this is what you would have to do in C:

``````#include <stdio.h>

int main(void)
{
int age = 28;
// 'int' is the data type
// 'age' is the name
// 'age' is capable of holding integer values
// positive/negative whole numbers or 0
// '=' is the assignment operator
// '28' is the value
}
``````

However, this is how you would write the above in Python:

``````age = 28

#'age' is the variable name, or identifier
# '=' is the assignment operator
#'28' is the value assigned to the variable, so '28' is the value of 'age'
``````

The variable name is always on the left-hand side, and the value you want to assign goes on the right-hand side after the assignment operator.

Keep in mind that you can change the values of variables throughout the life of a program:

``````my_age = 28

print(f"My age in 2022 is {my_age}.")

my_age = 29

print(f"My age in 2023 will be {my_age}.")

#output

#My age in 2022 is 28.
#My age in 2023 will be 29.
``````

You keep the same variable name, `my_age`, but only change the value from `28` to `29`.

### What Does Variable Scope in Python Mean?

Variable scope refers to the parts and boundaries of a Python program where a variable is available, accessible, and visible.

There are four types of scope for Python variables, which are also known as the LEGB rule:

• Local,
• Enclosing,
• Global,
• Built-in.

For the rest of this article, you will focus on learning about creating variables with global scope, and you will understand the difference between the local and global variable scopes.

## How to Create Variables With Local Scope in Python

Variables defined inside a function's body have local scope, which means they are accessible only within that particular function. In other words, they are 'local' to that function.

You can only access a local variable by calling the function.

``````def learn_to_code():
#create local variable
coding_website = "freeCodeCamp"
print(f"The best place to learn to code is with {coding_website}!")

#call function
learn_to_code()

#output

#The best place to learn to code is with freeCodeCamp!
``````

Look at what happens when I try to access that variable with a local scope from outside the function's body:

``````def learn_to_code():
#create local variable
coding_website = "freeCodeCamp"
print(f"The best place to learn to code is with {coding_website}!")

#try to print local variable 'coding_website' from outside the function
print(coding_website)

#output

#NameError: name 'coding_website' is not defined
``````

It raises a `NameError` because it is not 'visible' in the rest of the program. It is only 'visible' within the function where it was defined.

## How to Create Variables With Global Scope in Python

When you define a variable outside a function, like at the top of the file, it has a global scope and it is known as a global variable.

A global variable is accessed from anywhere in the program.

You can use it inside a function's body, as well as access it from outside a function:

``````#create a global variable
coding_website = "freeCodeCamp"

def learn_to_code():
#access the variable 'coding_website' inside the function
print(f"The best place to learn to code is with {coding_website}!")

#call the function
learn_to_code()

#access the variable 'coding_website' from outside the function
print(coding_website)

#output

#The best place to learn to code is with freeCodeCamp!
#freeCodeCamp
``````

What happens when there is a global and local variable, and they both have the same name?

``````#global variable
city = "Athens"

def travel_plans():
#local variable with the same name as the global variable
city = "London"
print(f"I want to visit {city} next year!")

#call function - this will output the value of local variable
travel_plans()

#reference global variable - this will output the value of global variable
print(f"I want to visit {city} next year!")

#output

#I want to visit London next year!
#I want to visit Athens next year!
``````

In the example above, maybe you were not expecting that specific output.

Maybe you thought that the value of `city` would change when I assigned it a different value inside the function.

Maybe you expected that when I referenced the global variable with the line `print(f" I want to visit {city} next year!")`, the output would be `#I want to visit London next year!` instead of `#I want to visit Athens next year!`.

However, when the function was called, it printed the value of the local variable.

Then, when I referenced the global variable outside the function, the value assigned to the global variable was printed.

They didn't interfere with one another.

That said, using the same variable name for global and local variables is not considered a best practice. Make sure that your variables don't have the same name, as you may get some confusing results when you run your program.

### How to Use the `global` Keyword in Python

What if you have a global variable but want to change its value inside a function?

Look at what happens when I try to do that:

``````#global variable
city = "Athens"

def travel_plans():
#First, this is like when I tried to access the global variable defined outside the function.
# This works fine on its own, as you saw earlier on.
print(f"I want to visit {city} next year!")

#However, when I then try to re-assign a different value to the global variable 'city' from inside the function,
#after trying to print it,
#it will throw an error
city = "London"
print(f"I want to visit {city} next year!")

#call function
travel_plans()

#output

#UnboundLocalError: local variable 'city' referenced before assignment
``````

By default Python thinks you want to use a local variable inside a function.

So, when I first try to print the value of the variable and then re-assign a value to the variable I am trying to access, Python gets confused.

The way to change the value of a global variable inside a function is by using the `global` keyword:

``````#global variable
city = "Athens"

#print value of global variable
print(f"I want to visit {city} next year!")

def travel_plans():
global city
#print initial value of global variable
print(f"I want to visit {city} next year!")
#assign a different value to global variable from within function
city = "London"
#print new value
print(f"I want to visit {city} next year!")

#call function
travel_plans()

#print value of global variable
print(f"I want to visit {city} next year!")
``````

Use the `global` keyword before referencing it in the function, as you will get the following error: `SyntaxError: name 'city' is used prior to global declaration`.

Earlier, you saw that you couldn't access variables created inside functions since they have local scope.

The `global` keyword changes the visibility of variables declared inside functions.

``````def learn_to_code():
global coding_website
coding_website = "freeCodeCamp"
print(f"The best place to learn to code is with {coding_website}!")

#call function
learn_to_code()

#access variable from within the function
print(coding_website)

#output

#The best place to learn to code is with freeCodeCamp!
#freeCodeCamp
``````

## Conclusion

And there you have it! You now know the basics of global variables in Python and can tell the differences between local and global variables.

You'll start from the basics and learn in an interactive and beginner-friendly way. You'll also build five projects at the end to put into practice and help reinforce what you've learned.

Thanks for reading and happy coding!

1624291630

## Data Structures Easy to Advanced Course - Full Tutorial from a Google Engineer

Learn and master the most common data structures in this full course from Google engineer William Fiset. This course teaches data structures to beginners using high quality animations to represent the data structures visually.

You will learn how to code various data structures together with simple to follow step-by-step instructions. Every data structure presented will be accompanied by some working source code (in Java) to solidify your understanding.
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Abstract data types
⌨️ (0:04:28) Introduction to Big-O
⌨️ (0:17:00) Dynamic and Static Arrays
⌨️ (0:27:40) Dynamic Array Code
⌨️ (0:49:16) Doubly Linked List Code
⌨️ (0:58:26) Stack Introduction
⌨️ (1:09:40) Stack Implementation
⌨️ (1:12:49) Stack Code
⌨️ (1:15:58) Queue Introduction
⌨️ (1:22:03) Queue Implementation
⌨️ (1:27:26) Queue Code
⌨️ (1:31:32) Priority Queue Introduction
⌨️ (1:44:16) Priority Queue Min Heaps and Max Heaps
⌨️ (1:49:55) Priority Queue Inserting Elements
⌨️ (1:59:27) Priority Queue Removing Elements
⌨️ (2:13:00) Priority Queue Code
⌨️ (2:28:26) Union Find Introduction
⌨️ (2:33:57) Union Find Kruskal’s Algorithm
⌨️ (2:40:04) Union Find - Union and Find Operations
⌨️ (2:50:30) Union Find Path Compression
⌨️ (2:56:37) Union Find Code
⌨️ (3:03:54) Binary Search Tree Introduction
⌨️ (3:15:57) Binary Search Tree Insertion
⌨️ (3:21:20) Binary Search Tree Removal
⌨️ (3:34:47) Binary Search Tree Traversals
⌨️ (3:46:17) Binary Search Tree Code
⌨️ (3:59:26) Hash table hash function
⌨️ (4:16:25) Hash table separate chaining
⌨️ (4:24:10) Hash table separate chaining source code
⌨️ (4:35:44) Hash table open addressing
⌨️ (4:46:36) Hash table linear probing
⌨️ (5:00:21) Hash table quadratic probing
⌨️ (5:09:32) Hash table double hashing
⌨️ (5:23:56) Hash table open addressing removing
⌨️ (5:31:02) Hash table open addressing code
⌨️ (5:45:36) Fenwick Tree range queries
⌨️ (5:58:46) Fenwick Tree point updates
⌨️ (6:03:09) Fenwick Tree construction
⌨️ (6:09:21) Fenwick tree source code
⌨️ (6:14:47) Suffix Array introduction
⌨️ (6:17:54) Longest Common Prefix (LCP) array
⌨️ (6:21:07) Suffix array finding unique substrings
⌨️ (6:25:36) Longest common substring problem suffix array
⌨️ (6:37:04) Longest common substring problem suffix array part 2
⌨️ (6:43:41) Longest Repeated Substring suffix array
⌨️ (6:48:13) Balanced binary search tree rotations
⌨️ (6:56:43) AVL tree insertion
⌨️ (7:05:42) AVL tree removals
⌨️ (7:14:12) AVL tree source code
⌨️ (7:30:49) Indexed Priority Queue | Data Structure
⌨️ (7:55:10) Indexed Priority Queue | Data Structure | Source Code

📺 The video in this post was made by freeCodeCamp.org
The origin of the article: https://www.youtube.com/watch?v=RBSGKlAvoiM&list=PLWKjhJtqVAblfum5WiQblKPwIbqYXkDoC&index=3
🔥 If you’re a beginner. I believe the article below will be useful to you ☞ What You Should Know Before Investing in Cryptocurrency - For Beginner
⭐ ⭐ ⭐The project is of interest to the community. Join to Get free ‘GEEK coin’ (GEEKCASH coin)!
Thanks for visiting and watching! Please don’t forget to leave a like, comment and share!

1652450400

## Variables Globales De Python: Cómo Definir Un Ejemplo De Variable Glob

En este artículo, aprenderá los conceptos básicos de las variables globales.

Para empezar, aprenderá cómo declarar variables en Python y qué significa realmente el término 'ámbito de variable'.

Luego, aprenderá las diferencias entre variables locales y globales y comprenderá cómo definir variables globales y cómo usar la `global`palabra clave.

## ¿Qué son las variables en Python y cómo se crean? Una introducción para principiantes

Puede pensar en las variables como contenedores de almacenamiento .

Son contenedores de almacenamiento para almacenar datos, información y valores que le gustaría guardar en la memoria de la computadora. Luego puede hacer referencia a ellos o incluso manipularlos en algún momento a lo largo de la vida del programa.

Una variable tiene un nombre simbólico y puede pensar en ese nombre como la etiqueta en el contenedor de almacenamiento que actúa como su identificador.

El nombre de la variable será una referencia y un puntero a los datos almacenados en su interior. Por lo tanto, no es necesario recordar los detalles de sus datos e información; solo necesita hacer referencia al nombre de la variable que contiene esos datos e información.

Al dar un nombre a una variable, asegúrese de que sea descriptivo de los datos que contiene. Los nombres de las variables deben ser claros y fácilmente comprensibles tanto para usted en el futuro como para los otros desarrolladores con los que puede estar trabajando.

Ahora, veamos cómo crear una variable en Python.

Al declarar variables en Python, no necesita especificar su tipo de datos.

Por ejemplo, en el lenguaje de programación C, debe mencionar explícitamente el tipo de datos que contendrá la variable.

Entonces, si quisiera almacenar su edad, que es un número entero, o `int`tipo, esto es lo que tendría que hacer en C:

``````#include <stdio.h>

int main(void)
{
int age = 28;
// 'int' is the data type
// 'age' is the name
// 'age' is capable of holding integer values
// positive/negative whole numbers or 0
// '=' is the assignment operator
// '28' is the value
}
``````

Sin embargo, así es como escribirías lo anterior en Python:

``````age = 28

#'age' is the variable name, or identifier
# '=' is the assignment operator
#'28' is the value assigned to the variable, so '28' is the value of 'age'
``````

El nombre de la variable siempre está en el lado izquierdo y el valor que desea asignar va en el lado derecho después del operador de asignación.

Tenga en cuenta que puede cambiar los valores de las variables a lo largo de la vida de un programa:

``````my_age = 28

print(f"My age in 2022 is {my_age}.")

my_age = 29

print(f"My age in 2023 will be {my_age}.")

#output

#My age in 2022 is 28.
#My age in 2023 will be 29.
``````

Mantienes el mismo nombre de variable `my_age`, pero solo cambias el valor de `28`a `29`.

### ¿Qué significa el alcance variable en Python?

El alcance de la variable se refiere a las partes y los límites de un programa de Python donde una variable está disponible, accesible y visible.

Hay cuatro tipos de alcance para las variables de Python, que también se conocen como la regla LEGB :

• local ,
• Encerrando ,
• globales ,

En el resto de este artículo, se centrará en aprender a crear variables con alcance global y comprenderá la diferencia entre los alcances de variables locales y globales.

## Cómo crear variables con alcance local en Python

Las variables definidas dentro del cuerpo de una función tienen alcance local , lo que significa que solo se puede acceder a ellas dentro de esa función en particular. En otras palabras, son 'locales' para esa función.

Solo puede acceder a una variable local llamando a la función.

``````def learn_to_code():
#create local variable
coding_website = "freeCodeCamp"
print(f"The best place to learn to code is with {coding_website}!")

#call function
learn_to_code()

#output

#The best place to learn to code is with freeCodeCamp!
``````

Mire lo que sucede cuando trato de acceder a esa variable con un alcance local desde fuera del cuerpo de la función:

``````def learn_to_code():
#create local variable
coding_website = "freeCodeCamp"
print(f"The best place to learn to code is with {coding_website}!")

#try to print local variable 'coding_website' from outside the function
print(coding_website)

#output

#NameError: name 'coding_website' is not defined
``````

Plantea un `NameError`porque no es 'visible' en el resto del programa. Solo es 'visible' dentro de la función donde se definió.

## Cómo crear variables con alcance global en Python

Cuando define una variable fuera de una función, como en la parte superior del archivo, tiene un alcance global y se conoce como variable global.

Se accede a una variable global desde cualquier parte del programa.

Puede usarlo dentro del cuerpo de una función, así como acceder desde fuera de una función:

``````#create a global variable
coding_website = "freeCodeCamp"

def learn_to_code():
#access the variable 'coding_website' inside the function
print(f"The best place to learn to code is with {coding_website}!")

#call the function
learn_to_code()

#access the variable 'coding_website' from outside the function
print(coding_website)

#output

#The best place to learn to code is with freeCodeCamp!
#freeCodeCamp
``````

¿Qué sucede cuando hay una variable global y local, y ambas tienen el mismo nombre?

``````#global variable
city = "Athens"

def travel_plans():
#local variable with the same name as the global variable
city = "London"
print(f"I want to visit {city} next year!")

#call function - this will output the value of local variable
travel_plans()

#reference global variable - this will output the value of global variable
print(f"I want to visit {city} next year!")

#output

#I want to visit London next year!
#I want to visit Athens next year!
``````

En el ejemplo anterior, tal vez no esperaba ese resultado específico.

Tal vez pensaste que el valor de `city`cambiaría cuando le asignara un valor diferente dentro de la función.

Tal vez esperabas que cuando hice referencia a la variable global con la línea `print(f" I want to visit {city} next year!")`, la salida sería en `#I want to visit London next year!`lugar de `#I want to visit Athens next year!`.

Sin embargo, cuando se llamó a la función, imprimió el valor de la variable local.

Luego, cuando hice referencia a la variable global fuera de la función, se imprimió el valor asignado a la variable global.

No interfirieron entre sí.

Dicho esto, usar el mismo nombre de variable para variables globales y locales no se considera una buena práctica. Asegúrese de que sus variables no tengan el mismo nombre, ya que puede obtener algunos resultados confusos cuando ejecute su programa.

### Cómo usar la `global`palabra clave en Python

¿Qué sucede si tiene una variable global pero desea cambiar su valor dentro de una función?

Mira lo que sucede cuando trato de hacer eso:

``````#global variable
city = "Athens"

def travel_plans():
#First, this is like when I tried to access the global variable defined outside the function.
# This works fine on its own, as you saw earlier on.
print(f"I want to visit {city} next year!")

#However, when I then try to re-assign a different value to the global variable 'city' from inside the function,
#after trying to print it,
#it will throw an error
city = "London"
print(f"I want to visit {city} next year!")

#call function
travel_plans()

#output

#UnboundLocalError: local variable 'city' referenced before assignment
``````

Por defecto, Python piensa que quieres usar una variable local dentro de una función.

Entonces, cuando intento imprimir el valor de la variable por primera vez y luego reasignar un valor a la variable a la que intento acceder, Python se confunde.

La forma de cambiar el valor de una variable global dentro de una función es usando la `global`palabra clave:

``````#global variable
city = "Athens"

#print value of global variable
print(f"I want to visit {city} next year!")

def travel_plans():
global city
#print initial value of global variable
print(f"I want to visit {city} next year!")
#assign a different value to global variable from within function
city = "London"
#print new value
print(f"I want to visit {city} next year!")

#call function
travel_plans()

#print value of global variable
print(f"I want to visit {city} next year!")
``````

Utilice la `global`palabra clave antes de hacer referencia a ella en la función, ya que obtendrá el siguiente error: `SyntaxError: name 'city' is used prior to global declaration`.

Anteriormente, vio que no podía acceder a las variables creadas dentro de las funciones ya que tienen un alcance local.

La `global`palabra clave cambia la visibilidad de las variables declaradas dentro de las funciones.

``````def learn_to_code():
global coding_website
coding_website = "freeCodeCamp"
print(f"The best place to learn to code is with {coding_website}!")

#call function
learn_to_code()

#access variable from within the function
print(coding_website)

#output

#The best place to learn to code is with freeCodeCamp!
#freeCodeCamp
``````

## Conclusión

¡Y ahí lo tienes! Ahora conoce los conceptos básicos de las variables globales en Python y puede distinguir las diferencias entre las variables locales y globales.

Espero que hayas encontrado útil este artículo.

Comenzará desde lo básico y aprenderá de una manera interactiva y amigable para principiantes. También construirá cinco proyectos al final para poner en práctica y ayudar a reforzar lo que ha aprendido.

¡Gracias por leer y feliz codificación!