首先我们来了解一下什么是变量。在之前的文章中，小编介绍什么是常量，常量就是，在程序执行过程中，它的值不可以改变的量，那么相反的变量就是可以改变的哦。他们的命名都必须使用合法的标识符，标识符的使用小编再之前的文章中也有提到过。
接下来，小编要将变量的声明，就是定义一个变量。告诉编辑器，这个变量的数据类型，这样编辑器才可以很好的分配空间，还有这个变量要存放的数据。在程序运行时，空间内的值是变化的，这个内存空间就称为变量。我们可以声明变量名，也可以直接赋值。
比如：
int age;//声明int型的变量
char char1='1'//声明char型的变量，并赋值。
接下来，小编来说下使用变量时的一些注意事项。
创建多个变量时，变量的名字不可以重复。
对于float和long的数据类型来说，F和L的后缀不要丢掉。
如果使用byte和short类型的变量，右侧的数据值不可以超过左侧的范围。
变量赋值后才可以直接使用。
变量不能操过作用域的范围。那么什么是作用域呢?从定义变量的那一行开始，一直到直接所属的大括号结束。
可以通过一个语句创建多个变量。为了方便大家理解，小编就敲一些代码来加深一下大家对变量的理解。
package change;
public class change {
public static void main(String[] args){
int num1=10;//创建一个变量，名num1
//int num1=2;//创建一个变量，名num，报错，多个变量时，变量名不可以重复。
int num2=3;
int num3=4;
int num5;//没有赋值。
//System.out.println(num5);//变量没有赋值，不可以直接输出，报错。
//System.out.println(num6);//变量没有创建，无法使用。
int num6=20;
System.out.println(num6);
{
int num4=70;
System.out.println(num4);
}
//int num4;
//System.out.println(num6)已超出作用域，变量无法使用。
//同时创建三个int型的变量
int a,b,c;
a=1;
b=2;
c=3;
System.out.println(a);
System.out.println(b);
System.out.println(c);
//同时创建三个变量，并赋值
int x=99,y=88,z=77;
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}
通过这个代码，希望大家可以更加容易理解ava变量。
大连哪家医院看男科好 http://www.39552222.com/

这更像是一种好奇，但我注意到了以下几点。如果我定义一个自我参照的lambda，我可以很容易地做到：>>> f = lambda: f
>>> f() is f
True
但是，如果我要定义一个自我参照列表，我必须在多个语句中完成：
^{pr2}$
我还注意到，这不仅限于列表，而且似乎除了lambda之外的任何其他表达式都不能引用赋值左边的变量。例如，如果有一个具有一个节点的循环链表，则不能简单地执行以下操作：>>> class Node(object):
...     def __init__(self, next_node):
...         self.next = next_node
...
>>> n = Node(n)
Traceback (most recent call last):
File "", line 1, in 
NameError: name 'n' is not defined
相反，你必须用两个语句来完成：>>> n = Node(None)
>>> n.next = n
>>> n is n.next
True
有人知道这种差异背后的理念是什么吗？我知道递归lambda的使用频率要高得多，因此支持自引用对于lambda很重要，但是为什么不允许它用于任何赋值呢？在
编辑：下面的答案很好地阐明了这一点。原因是Python中lambda中的变量是在每次调用lambda时计算的，而不是在定义lambda时。从这个意义上说，它们与使用def定义的函数完全相似。我编写了下面的代码来试验这是如何工作的，包括lambdas和def函数，以防有助于向任何人澄清。在>>> f = lambda: f
>>> f() is f
True
>>> g = f
>>> f = "something else"
>>> g()
'something else'
>>> f = "hello"
>>> g()
'hello'
>>> f = g
>>> g() is f
True
>>> def f():
...     print(f)
...
>>> f()
>>> g = f
>>> g()
>>> f = "test"
>>> g()
test
>>> f = "something else"
>>> g()
something else

合法的变量名

变量名由大小写英文字母、数字和下划线_组成
	
变量不能用数字开头
	
变量尽量不要和Python关键字重合（比如前面学习过的：and、or、not，否则可能导致Python原有关键字发挥不出作用）
 

定义变量

变量名=数据

a=1

hello='hello'

在Python里面，一个变量可以先后存储多种不同类型的数据

 

这是一个好奇心比任何东西，但我只是注意到以下。如果我定义一个自引用lambda，我可以很容易做到：
>>> f = lambda: f
>>> f() is f
True
但是，如果我定义一个自引用列表，我必须在一个以上的语句：
>>> a = [a]
Traceback (most recent call last):
File "", line 1, in 
NameError: name 'a' is not defined
>>> a = []
>>> a.append(a)
>>> a[0] is a
True
>>> a
[[...]]
我也注意到，这不限于列表，但看起来像除了lambda之外的任何其他表达式不能引用分配的左侧的变量。例如，如果你有一个节点的循环链表，你不能简单地去：
>>> class Node(object):
...     def __init__(self, next_node):
...         self.next = next_node
...
>>> n = Node(n)
Traceback (most recent call last):
File "", line 1, in 
NameError: name 'n' is not defined
相反，你必须在两个语句中：
>>> n = Node(None)
>>> n.next = n
>>> n is n.next
True
有谁知道这种差异背后的哲学是什么？我理解递归lambda使用得更频繁，因此支持自引用对于lambdas很重要，但为什么不允许它为任何赋值？
编辑：下面的答案澄清这相当好。原因是每次调用lambda时，都会评估Python中lambdas中的变量，而不是在定义它时。在这个意义上，他们完全像使用def定义的函数。我写了下面的代码来试验如何工作，与lambdas和def函数，以防它可能有助于澄清任何人。
>>> f = lambda: f
>>> f() is f
True
>>> g = f
>>> f = "something else"
>>> g()
'something else'
>>> f = "hello"
>>> g()
'hello'
>>> f = g
>>> g() is f
True
>>> def f():
...     print(f)
...
>>> f()
>>> g = f
>>> g()
>>> f = "test"
>>> g()
test
>>> f = "something else"
>>> g()
something else