python函数作用域包括局部变量和参数_【云计算】python变量的作用域：局部变量和全局变量...-CSDN博客

本文主要向大家介绍了【云计算】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)

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

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=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)

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)

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

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=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))

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

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

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

sum =5

def f2(v2):

sum =0

while v2

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

v2 += 1

return sum

print(sum)

print(f2(0))

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

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

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的值给刷新了。

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