本文主要向大家介绍了【云计算】python变量的作用域：局部变量和全局变量，通过具体的内容向大家展现，希望对大家学习云计算有所帮助。

变量定义以后，是有一定的使用范围，称之为变量的作用域。比如Java中，变量的使用范围是变量声明时所在的{}范围，而python的作用域对应的为同一个缩进。按着变量的使用范围给变量划分成如下两种：

1.全局变量：就

import java.util.ArrayList;

public class MyAVL, V> {

private class Node{

public K key;

public V value;

public Node left, right;

public int high;

public Node(K key, V value){

this.key = key;

this.value = value;

high=1;

left = null;

right = null;

}

}

//返回节点的高度标注

private int getHigh(Node node){

if(node ==null)

return 0;

return node.high;

}

private Node root;

private int size;

public MyAVL(){

root = null;

size = 0;

}

public int getSize(){

return size;

}

public boolean isEmpty(){

return size == 0;

}

// 向二分搜索树中添加新的元素(key, value)

public void add(K key, V value){

root = add(root, key, value);

}

// 向以node为根的二分搜索树中插入元素(key, value)，递归算法

// 返回插入新节点后二分搜索树的根

private Node add(Node node, K key, V value){

if(node == null){

size ++;

return new Node(key, value);

}

if(key.compareTo(node.key) < 0)

node.left = add(node.left, key, value);

else if(key.compareTo(node.key) > 0)

node.right = add(node.right, key, value);

else // key.compareTo(node.key) == 0

node.value = value;

//不论这个添加的点往那个子树上添加 都要更新高度标注 相等的话无影响

node.high = Math.max(getHigh(node.left),getHigh(node.right))+1;

//计算平衡因子并递归到根节点

int b = getB(node);

//LL 进行右旋转

if(b>1 && getB(node.left)>=0)//右旋转

return rightB(node);

//RR 左旋转

if (b<-1 && getB(node.right)<=0)

return leftB(node);

//LR 先对node.left进行左旋转 再对node右旋转

if(b>1 && getB(node.left)<0){

node.left=leftB(node.left);

return rightB(node);

}

//RL 先对右子树进行右旋转 再对node左旋转

if(b<-1 && getB(node.right)>=0){

node.right=rightB(node.right);

return leftB(node);

}

return node;

}

//左旋转操作 插入节点 在右孩子的右孩子

private Node leftB(Node node){

Node down =node.right;

Node one = down.left;

down.left=node;

node.right=one;

//维护高度

node.high = Math.max(getHigh(node.left),getHigh(node.right))+1;

down.high = Math.max(getHigh(down.left),getHigh(node.right))+1;

return down;

}

//右旋转操作 插入点在左孩子的左节点

private Node rightB(Node node){

Node down=node.left;

Node one = down.right;

down.right=node;

node.left=one;

//维护高度

node.high = Math.max(getHigh(node.left),getHigh(node.right))+1;

down.high = Math.max(getHigh(down.left),getHigh(down.right))+1;

return down;

}

//方法 判断当前tree是不是二分搜索树 满足中大于左小于右

public boolean isBST(){

ArrayList list= new ArrayList<>();

isBST(root,list);

//遍历list判断是否有序

for(int i=1;i0)

return false;

return true;

}

//返回当前节点的 平衡因子

public int getB(Node node){

//不需要取绝对值,后期要判断左旋转还是右旋转

return getHigh(node.right)-getHigh(node.left);

}

//判断树是不是平衡树

public boolean isB(){

return isB(root);

}

private boolean isB(Node node){

//终止条件

if(node==null)

return true;

//判断当前节点 平衡因子

if(Math.abs(getB(node))>1)

return false;

//左右子孩子平衡因子

return isB(node.left)&&isB(node.right);

}

private void isBST(Node node,ArrayList list){

//递归遍历

if(node == null)

return;

isBST(node.left,list);

list.add(node.key);

isBST(node.right,list);

}

// 返回以node为根节点的二分搜索树中，key所在的节点

private Node getNode(Node node, K key){

if(node == null)

return null;

if(key.equals(node.key))

return node;

else if(key.compareTo(node.key) < 0)

return getNode(node.left, key);

else // if(key.compareTo(node.key) > 0)

return getNode(node.right, key);

}

public boolean contains(K key){

return getNode(root, key) != null;

}

public V get(K key){

Node node = getNode(root, key);

return node == null null : node.value;

}

public void set(K key, V newValue){

Node node = getNode(root, key);

if(node == null)

throw new IllegalArgumentException(key + " doesn't exist!");

node.value = newValue;

}

// 返回以node为根的二分搜索树的最小值所在的节点

private Node minimum(Node node){

if(node.left == null)

return node;

return minimum(node.left);

}

// 删除掉以node为根的二分搜索树中的最小节点

// 返回删除节点后新的二分搜索树的根

private Node removeMin(Node node){

if(node.left == null){

Node rightNode = node.right;

node.right = null;

size --;

return rightNode;

}

node.left = removeMin(node.left);

return node;

}

// 从二分搜索树中删除键为key的节点

public V remove(K key){

Node node = getNode(root, key);

if(node != null){

root = remove(root, key);

return node.value;

}

return null;

}

private Node remove(Node node, K key){

if( node == null )

return null;

Node del;

if( key.compareTo(node.key) < 0 ){

node.left = remove(node.left , key);

del= node;

}

else if(key.compareTo(node.key) > 0 ){

node.right = remove(node.right, key);

del = node;

}

else{ // key.compareTo(node.key) == 0

// 待删除节点左子树为空的情况

if(node.left == null){

Node rightNode = node.right;

node.right = null;

size --;

del = rightNode;

}

// 待删除节点右子树为空的情况

else if(node.right == null){

Node leftNode = node.left;

node.left = null;

size --;

del= leftNode;

}else{

// 待删除节点左右子树均不为空的情况

// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点

// 用这个节点顶替待删除节点的位置

Node successor = minimum(node.right);

successor.right = remove(node.right,successor.key);

successor.left = node.left;

node.left = node.right = null;

del= successor;

}

}

if(del==null)

return null;

del.high = Math.max(getHigh(del.left),getHigh(del.right))+1;

//计算平衡因子并递归到根节点

int b = getB(del);

//LL 进行右旋转

if(b>1 && getB(del.left)>=0)//右旋转

return rightB(del);

//RR 左旋转

if (b<-1 && getB(del.right)<=0)

return leftB(del);

//LR 先对node.left进行左旋转 再对node右旋转

if(b>1 && getB(del.left)<0){

del.left=leftB(del.left);

return rightB(del);

}

//RL 先对右子树进行右旋转 再对node左旋转

if(b<-1 && getB(del.right)>=0){

del.right=rightB(del.right);

return leftB(del);

}

return del;

}

}

是在函数外部定义的变量

2.局部变量：就是在函数内部定义的变量

1.全局函数和局部函数的作用域

局部变量作用域：只能在被声明的函数内部访问，函数外部使用不了。这也是不同函数里可以定义名称一样变量的原因

全局变量作用域：可以在整个程序范围内访问，任意函数都可以访问

#1.局部变量，外部访问不了

def f1 (v1,v2): #参数也属于局部变量

sum = v1+v2

a = 5 #局部变量，函数外部访问不了

return sum

--------------------------------

print(a) #报错，NameError: name 'a' is not defined

=====================================================================

#2.全部变量,函数里外都可以访问

a =3

def f3(v2):

# a = a+1 注意：报错，因为局部作用域内只能引用全局域变量的值，而不能修改全局作用域的值。

# b = a+1 则不会报错，引用全局变量的值，运算后给赋给局部变量b.

return a+1 #外部的全局变量函数内部使用

print(f3(1))

=============结果如下======================

4

===================================-===================================

#3.如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的

sum =5

def f2(v2):

sum =0

while v2 < 10:

sum += v2 #这里sum使用的是局部变量的初始值0，而不是全局sum=5

v2 += 1

return sum

print(sum)

print(f2(0))

===========结果如下=========================

5

45

===========================================

2.局部变量声明为全局变量global

val =10

def f1(v1):

val =5

return val

print(val ) #结果是10，因为局部变量val作用域只是函数内

print(f1(1)) #5

#使用global将局部变量声明为全局变量

val =10

def f1(v1):

global val

val = 30

return val

print(val ) #结果是10.虽然声明了global，但是函数要调用才会执行，才会更新val的值

val =10

def f1(v1):

global val

val = 30

return val

f1(2)

print(val ) #结果是30.调用函数f1后，将val的值给刷新了。

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标大数据云计算大数据安全频道！