Python变量及其使用

无论使用什么语言编程，其最终目的都是对数据进行处理。程序在编程过程中，为了处理数据更加方便，通常会将其存储在变量中。

形象地看，变量就像一个个小容器，用于“盛装”程序中的数据。除了变量，还有常量，它也能用来“盛装”数据，它们的区别是，常量一旦保存某个数据之后，该数据就不能发生改变；但变量保存的数据则可以多次发生改变，只要程序对变量重新赋值即可。

Python 使用等号(＝)作为赋值运算符，例如 a = 20 就是一条赋值语句，这条语句用于将 20 装入变量 a 中，这个过程就被称为赋值，即将 20 赋值给变量 a。

注意，变量名其实就是标识符，因此在命名时，既要遵守 Python 标识符命名规范，还要避免和 Python 内置函数以及 Python 保留字重名。

如果你接触过 C、C++、Java 这些高级编程语言会发现，它们在使用变量存储数据时，必须指定该变量所能存储的数据类型，以 C 语言为例：int a = 20

这行 C 语言代码的意思是，声明一个整形变量 a 来存储整数 20，这就意味着，我们无法用 a 存储小数、字符以及字符串等其他类型数据，这类编程语言被称为强类型语言。

和强类型语言相对应的是弱类型语言，Python 就是典型代表之一。弱类型语言有以下 2 个特征：变量无须声明即可直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。

变量的数据类型可以动态改变：同一个变量可以一会儿被赋值为整数值，一会儿被赋值为字符串。

对于没有编程基础的读者，可以先不编写真正的 Python 程序，而是先打开 Python 的交互式解释器，在这个交互式解释器中“试验” Python。首先，在 Python 解释器中输入如下内容：>>> a = 5

>>>

上面代码没有生成任何输出，只是向交互式解释器中存入了一个变量 a，该变量 a 的值为 5。

如果我们想看到某个变量的值，可以直接在交互式解释器中输入该变量。例如，此处想看到变量 a 的值，可以直接输入 a。>>> a

5

>>>

可以看到，Python 解释器输出变量 a 的值为 5。

接下来，我们尝试改变变量 a 的值，将新的值赋给变量 a，例如：>>>a = 'Hello , Charlie'

>>>

这会导致变量原来的值被新值覆盖掉，换句话说，此时变量 a 的值就不再是 5 了，而是字符串“Hello , Charlie”，a 的类型也变成了字符串。现在再输入 a，让交互式解释器显示 a 的值：>>> a

'Hello , Charlie'

如果想查看此时 a 的类型，可以使用 Python 的 type() 内置函数。>>> type(a)

>>>

可以看到，a 的类型是 str(表示字符串类型)。

形象地说，函数就相当于一个有魔法的“黑盒子”，你可以向这个“黑盒子“提供”一些数据，这个“黑盒子”会对这些数据进行处理，这种处理包括转换和输出结果。比如 print() 也是一个函数，它的作用就是输出传入的数据。此处 type() 函数的作用则用于输出传入数据的类型。

最后，如果想把上面的交互过程转换成真正的 Python 程序，只要将过程中输入的每行代码放在一个文件中，并使用 print() 函数来输出变量，最后将该文件保存为以 .py 结尾的源文件即可。

在交互式解释器中，只要输入变量名，交互式解释器就会输出变量的值，但在 Python 程序中则必须使用 print() 函数来输出变量。

上面的交互过程对应的程序如下：#定义一个数值类型变量

a = 5

print(a)

#重新将字符串赋值给a变量

a = 'Hello , Charlie'

print(a)

print(type(a))

Python变量命名规则(超级详细)

Python 需要使用标识符给变量命名，其实标识符就是用于给程序中变量、类、方法命名的符号(简单来说，标识符就是合法的名字)。

Python 语言的标识符必须以字母、下画线(_)开头，后面可以跟任意数目的字母、数字和下画线(_)。此处的字母并不局限于 26 个英文字母，可以包含中文字符、日文字符等。

由于 Python 3 支持 UTF-8 字符集，因此 Python 3 的标识符可以使用 UTF-8 所能表示的多种语言的字符。Python 语言是区分大小写的，因此 abc 和 Abc 是两个不同的标识符。

Python 2.x 对中文支持较差，如果要在 Python 2.x 程序中使用中文字符或中文变量，则需要在 Python 源程序的第一行增加“#coding:utf-8”，当然别忘了将源文件保存为 UTF-8 字符集。

在使用标识符时，需要注意如下规则：标识符可以由字母、数字、下画线(_)组成，其中数字不能打头。

标识符不能是 Python 关键字，但可以包含关键字。

标识符不能包含空格。

例如下面变量，有些是合法的，有些是不合法的：abc_xyz：合法。

HelloWorld：合法。

abc：合法。

xyz#abc：不合法，标识符中不允许出现“#”号。

abc1：合法。

1abc：不合法，标识符不允许数字开头。

Python 的关键字和内置函数

Python 还包含一系列关键字和内置函数，一般也不建议使用它们作为变量名：如果开发者尝试使用关键字作为变量名，Python 解释器会报错。

如果开发者使用内置函数的名字作为变量名，Python 解释器倒不会报错，只是该内置函数就被这个变量覆盖了，该内置函数就不能使用了。

Python 包含了如表 1 所示的关键字：

表 1 Python 关键字FalseNoneTrueandasassert breakclasscontinuedefdelelifelse exceptfinallyforfromglobalifimportinislambdanonlocalnotorpassraisereturntrywhilewithyield

实际上 Python 非常方便，开发者可以通过 Python 程序来查看它所包含的关键字。例如，对于如下程序：#导入keyword 模块

import keyword

#显示所有关键字

keyword.kwlist

从上面代码可以看出，程序只要先导入 keyword 模块，然后调用 keyword.kwlist 即可查看 Python 包含的所有关键字。运行上面程序，可以看到如下输出结果：

['False','None','True','and','as','assert','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','With','yield']

上面这些关键字都不能作为变量名。

此外，Python 3 还提供了如表 2 所示的内置函数。

表 2 Python内置函数abs()all()any()basestring()bin()bool()bytearray()callable()chr()classmethod()cmp()compile() complex()delattr()dict()dir()divmod()enumerate() eval()execfile()file()filter()float() format()frozenset()getattr()globals()hasattr()hash()help()hex()id()input()int() isinstance()issubclass()iter()len()list()locals()long()map() max()memoryview()min()next() object()oct() open() ord()pow()print()property()range()raw_input()reduce()reload()repr()reversed()zip()round() set()setattr()slice()sorted()staticmethod()str()sum()super()tuple()type()unichr()unicode() vars()xrange()Zip()__import__()apply()buffer()coerce()intern

上面这些内置函数的名字也不应该作为标识符，否则 Python 的内置函数会被覆盖。

注意：在 Python 2.x 中，print 是关键字而不是函数。上面这些内置函数(如 unicode())只是 Python 2.x 的内置函数，为了保证 Python 程序具有更好的兼容性，程序也不应该使用这些内置函数的名字作为标识符。

Python数值类型(整形、浮点型和复数)及其用法

实际开发中，我们经常需要使用数字记录游戏中用户的得分、游戏中角色的生命值、伤害值等信息，Python 语言提供了数值类型用于保存这些数值。

需要注意的是，Python 中这些数值类型都是不可改变的，也就是说，如果我们要修改数字类型变量的值，那么其底层实现的过程是，先将新值存放到内存中，然后修改变量让其指向新的内存地址，换句话说，Python 中修改数值类型变量的值，其实只是修改变量名所表示的内存空间。

数值类型只是一个泛泛的统称，Python 中的数值类型主要包括整形、浮点型和复数类型。

Python整型

整形专门用来表示整数，即没有小数部分的数。在 Python 中，整数包括正整数、0 和负整数。

和其他强类型语言不同，它们会提供多种整形类型，开发者要根据数值的大小，分别用不同的整形类型存储，以 C 语言为例，根据数值的大小，开发者要合理选择 short、int、long 整形类型存储，大大增加了开发难度。

Python 则不同，它的整型支持存储各种整数值，无论多大或者多小，Python 都能轻松处理(当所用数值超过计算机自身的计算功能时，Python 会自动转用高精度计算)。

例如如下代码：#定义变量a，赋值为56

a = 56

print(a)

#为a赋值一个大整数

a = 9999999999999999999999

print(a)

#type()函数用于返回变量的类型

print(type (a))

对于没有编程基础的读者， 同样可以在交互式解释器中逐行“试验”上面程序来观看运行效果。由于篇幅限制，本教程后面的程序不再详细列出在交互式解释器中逐行“试验”的过程。

上面程序中，将 9999999999999999999999 大整数赋值给变量 a，Python 也不会发生溢出等问题，程序运行一样正常，这足以证明 Python 的强大。

使用 Python 3.x 运行上面程序，可以看到如下输出结果：56

9999999999999999999999

从上面的输出结果可以看出，此时 a 依然是 int 类型。

但如果用 Python 2.x 运行上面程序，由于输入的数值比较大，Python 会自动在其后面加上字母 L(或小写字母 l)，如下输出结果：

56

9999999999999999999999L

对比两种输出结果，不难发现：不管是 Python 3.x 还是 Python 2.x，Python 完全可以正常处理很大的整数，只是 Python 2.x 底层会将大整数当成 long 类型处理，但开发者通常不需要理会这种细节。

除此之外，Python 的整型还支持 None 值(空值)，例如如下代码：a = None

print(a) #什么都不输出

Python 的整型数值有 4 种表示形式：十进制形式：最普通的整数就是十进制形式的整数，在使用十进制表示整数值时，不能以 0(零)作为十进制数的开头(数值是 0 除外)。

二进制形式：由 0 和 1 组成，以 0b 或 0B 开头。例如，101 对应十进制数是 5；

八进制形式：八进制整数由 0~7 组成，以 0o 或 0O 开头(第一个字母是零，第二个字母是大写或小写的 O)。需要注意的是，在 Python 2.x 中，八进制数值还可以直接以 0(零)开头。

十六进制形式：由 0~9 以及 A~F(或 a~f)组成，以 0x 或 0X 开头，

下面代码片段使用了其他进制形式的数：#以0x或0X开头的整型数值是十六进制形式的整数

hex_value1 = 0x13

hex_value2 = 0xaF

print("hexValue1 的值为：",hex_value1)

print("hexValue2 的值为：",hex_value2)

#以0b或0B开头的整型数值是二进制形式的整数

bin_val = 0b111

print('bin_val的值为：',bin_val)

bin_val = 0B101

print('bin_val的值为：',bin_val)

#以0o或0O开头的整型数值是八进制形式的整数

oct_val = 0o54

print('oct_val 的值为：',oct_val)

oct_val = 0O17

print('oct_val 的值为：',oct_val)

为了提高数值(包括浮点型)的可读性，Python 3.x 允许为数值(包括浮点型)增加下画线作为分隔符。这些下画线并不会影响数值本身。例如如下代码：#在数值中使用下画线

one_million = 1000000

print(one_million)

price = 234_234_234 #price 实际的值为234234234

android = 1234_1234 #android 实际的值为12341234

Python浮点型

浮点型数值用于保存带小数点的数值，Python 的浮点数有两种表示形式：十进制形式：这种形式就是平常简单的浮点数，例如 5.12、512.0、0.512。浮点数必须包含一个小数点，否则会被当成整数类型处理。

科学计数形式：例如 5.12e2(即 5.12×102)、5.12E2(也是 5.12 ×102)。

必须指出的是，只有浮点型数值才可以使用科学计数形式表示。例如 51200 是一个整型值，但 512E2 则是浮点型值。

下面程序示范了上面介绍的关于浮点数的各个知识点：af1 = 5.2345556

#输出af1的值

print("af1的值为：",af1)

af2 = 25.2345

print("af2的类型为：",type(af2))

f1=5.12e2

print("f1的值为：",f1)

f2 = 5e3

print("f2的值为：",f2)

print("f2的类型为：",type(f2))#看到类型为float

通过第 8 行代码可以看出，虽然 5e3 的值是 5000，但它依然是浮点型值，而不是整型值，因为 Python 会自动将该数值变为 5000.0。

注意，使用浮点数进行计算时，可能会出现小数位数不确定的情况，比如说，计算 0.1+0.2，本来应该得到 0.3，但经过测试你会发现，Python解释器的运行结果为 0.30000000000000004。几乎所有编程语言都存在这个问题，这与浮点数在底层的存储方式有关系(后续章节会做详细介绍)。

Python复数

Python 甚至可以支持复数，复数的虚部用 j 或 J 来表示。

如果读者对虚数虚部感到困惑，请直接跳过本节，大部分编程并不会用到复数这么“高级”的数学知识。

如果需要在程序中对复数进行计算，可导入 Python 的 cmath 模块(c 代表 complex)，在该模块下包含了各种支持复数运算的函数。

模块就是一个 Python 程序，Python 正是通过模块提高了自身的可扩展性的；Python 本身内置了大量模块，此外还有大量第三方模块，导入这些模块即可直接使用这些程序中定义的函数。

下面程序示范了复数的用法：

纯文本复制ac1 = 3 + 0.2j

print (ac1)

print(type(ac1)) #输出复数类型

ac2 = 4 - 0.1j

print(ac2)

#复数运行

print(ac1 + ac2) #输出(7+0.1j)

#导入cmath 模块

import cmath

#sqrt()是cmath 模块下的商数，用于计算平方根

ac3 = cmath.sqrt(-1)

print (ac3) #输出1j

Python字符串及基本操作(入门必看)

字符串的意思就是“一串字符”，比如“Hello,Charlie”是一个字符串，“How are you？”也是一个字符串。

Python 要求字符串必须使用引号括起来，使用单引号也行，使用双引号也行，只要两边的引号能配对即可。

Python字符串和转义字符

字符串的内容几乎可以包含任何字符，英文字符也行，中文字符也行。

Python 3.x 对中文字符支持较好，但 Python 2.x 则要求在源程序中增加“#coding:utf-8”才能支持中文字符。

字符串既可用单引号括起来，也可用双引号括起来，它们没有任何区别。例如如下程序：str1 = 'Charlie'

str2 = "C语言中文网"

print(str1)

print(str2)

但需要说明的是，Python 有时候没有我们期望的那么聪明。如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理：使用不同的引号将字符串括起来。

对引号进行转义。

先看第一种处理方式。假如字符串内容中包含了单引号，则可以使用双引号将字符串括起来。例如：str3 = 'I'm a coder'

由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把 'I' 当成字符串，而后面的 m a coder' 就变成了多余的内容，从而导致语法错误。

为了避免这种问题，可以将上面代码改为如下形式：

str3 = "I'm a coder"

上面代码使用双引号将字符串括起来，此时 Python 就会把字符串中的单引号当成字符串内容，而不是和字符串开始的引号配对。

假如字符串内容本身包含双引号，则可使用单引号将字有串括起来，例如如下代码：

str4 = '"Spring is here,let us jam!", said woodchuck.'

接下来看第二种处理方式：使用转义字符。Python 允许使用反斜线(\)将字符串中的特殊字符进行转义。假如字符串既包含单引号，又包含双引号，此时必须使用转义字符，例如如下代码：

str5 = '"we are scared,Let\'s hide in the shade",says the bird'

拼接字符串

如果直接将两个字符串紧挨着写在一起，Python 就会自动拼接它们，例如如下代码：s1 = "Hello,"'Charlie'

print(s1)

上面代码将会输出：Hello,Charlie

上面这种写法只是书写字符串的一种特殊方法，并不能真正用于拼接字符串。Python 使用加号(+)作为字符串的拼接运算符，例如如下代码：s2 = "Python "

s3 = "iS Funny"

#使用+拼接字符串

s4 = s2 + s3

print(s4)

repr 和字符串

有时候，我们需要将字符串与数值进行拼接，而 Python 不允许直接拼接数值和字符串，程序必须先将数值转换成字符串。

为了将数值转换成字符串，可以使用 str() 或 repr() 函数，例如如下代码：s1 = "这是数字: "

p = 99.8

#字符串直接拼接数值，程序报错

print(s1 + p)

#使用str()将数值转换成字符串

print(s1 + str(p))

#使用repr()将数值转换成字符串

print(s1 + repr(p))

上面程序中直接拼接字符串和数值，程序会报错。

str() 和 repr() 函数都可以将数值转换成字符串，其中 str 本身是 Python 内置的类型(和 int、float 一样)，而 repr() 则只是一个函数。此外，repr 还有一个功能，它会以 Python 表达式的形式来表示值。对比如下代码：st = "I will play my fife"

print (st)

print(repr(st))

上面代码中 st 本身就是一个字符串，但程序依然使用了 repr() 对字符串进行转换。运行上面程序，可以看到如下输出结果：

I will play my fife

'I will play my fife'

通过上面的输出结果可以看出，如果直接使用 print() 函数输出字符串，将只能看到字符串的内容，没有引号；但如果先使用 repr() 函数对字符串进行处理，然后再使用 print() 执行输出，将可以看到带引号的字符串，这就是字符串的 Python 的表达式形式。

在交互式解释器中输入一个主量或表达式时，Python 会自动使用 repr() 函数处理该变量或表达式。

使用 input 和 raw_input 获取用户输入

input() 函数用于向用户生成一条提示，然后获取用户输入的内容。由于 input() 函数总会将用户输入的内容放入字符串中，因此用户可以输入任何内容，input() 函数总是返回一个字符串。

例如如下程序：msg ＝ input("请输入你的值：")

print (type(msg))

print(msg)

第一次运行该程序，我们输入一个整数，运行过程如下：

请输入你的值：2

2

第二次运行该程序，我们输入一个浮点数，运行过程如下：

请输入你的值： 1.2

1.2

第三次运行该程序，我们输入一个字符串，运行过程如下：请输入你的值：Hello

Hello

从上面的运行过程可以看出，无论输入哪种内容，始终可以看到 input() 函数返回字符串，程序总会将用户输入的内容转换成字符串。

需要指出的是，Python 2.x 提供了一个 raw_input() 函数，该 raw_input() 函数就相当于 Python 3.x 中的 input() 函数。

而 Python 2.x 也提供了一个 input() 函数，该 input() 函数则比较怪异：要求用户输入的必须是符合 Python 语法的表达式。通常来说，用户只能输入整数、浮点数、复数、字符串等。重点是格式必须正确，比如输入字符串时必须使用双引号，否则 Python 就会报错。

使用 Python 2.x 来运行上面程序，假如输入一个整数，运行过程如下：

请输入你的值：2

2

使用 Python 2.x 来运行上面程序，假如输入一个复数，运行过程如下：请输入你的值： 2+3j

(2+3j)

使用 Python 2.x 来运行上面程序，假如输入一个字符串，运行过程如下：

请输入你的值：Hello

NameError : name 'Hello' is not defined

上面程序报错的原因是：Python 2.x 的 input() 函数要求用户输入字符串时必须用引号把字符串括起来。

在 Python 2.x 中应该尽量使用 raw_input() 函数来获取用户输入；Python 2.x 中的 raw_input() 等同于 Python 3.x 中的 input()。

Python长字符串

前面介绍 Python 多行注释时提到使用三个引号(单引号、双引号都行)来包含多行注释内容，其实这是长字符串写法，只是由于在长字符串中可以放置任何内容，包括放置单引号、双引号都可以，如果所定义的长字符串没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就相当于注释掉了。

实际上，使用三个引号括起来的长字符串完全可以赋值给变量，例如如下程序：s = '''"Let's go fishing", said Mary.

"OK, Let's go", said her brother.

they walked to a lake'''

print(s)

上面程序使用三个引号定义了长字符串，该长字符串中既可包含单引号，也可包含双引号。

当程序中有大段文本内容要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以让字符串中包含任何内容，既可包含单引号，也可包含双引号。

此外，Python 还允许使用转义字符(\)对换行符进行转义，转义之后的换行符不会“中断”字符串。例如如下代码：s2 = 'The quick brown fox \

jumps over the lazy dog'

print(s2)

上面 s2 字符串的内容较长，故程序使用了转义字符(\)对内容进行了转义，这样就可以把一个字符串写成两行。

需要说明的是，Python 不是格式自由的语言，因此 Python 程序的换行、缩进都有其规定的语法。所以，Python 的表达式不允许随便换行。如果程序需要对 Python 表达式换行，同样需要使用转义字符(\)进行转义，代码如下：num = 20 + 3 / 4 + \

2 * 3

print(num)

上面程序中有一个表达式，为了对该表达式换行，程序需要使用转义字符。

Python原始字符串

由于字符串中的反斜线都有特殊的作用，因此当字符串中包含反斜线时，就需要对其进行转义。

比如写一条 Windows 的路径 G:\publish\codes\02\2.4，如果在 Python 程序中直接这样写肯定是不行的，需要写成 G:\\publish\\codes\\02\\2.4，这很烦人，此时可借助于原始字符串来解决这个问题。

原始字符串以“r”开头，原始字符串不会把反斜线当成特殊字符。因此，上面的 Windows 路径可直接写成 r'G:\publish\codes\02\2.4'。

关于原始字符串的用法看如下程序：s1 = r'G:\publish\codes\02\2.4'

print(s1)

如果原始字符串中包含引号，程序同样需要对引号进行转义(否则 Python 同样无法对字符串的引号精确配对)，但此时用于转义的反斜线会变成字符串的一部分。

例如如下代码：# 原始字符串包含的引号，同样需要转义

s2 = r'"Let\'s go", said Charlie'

print(s2)

上面代码会生成如下输出结果："Let\'s go", said Charlie

由于原始字符串中的反斜线会对引号进行转义，因此原始字符串的结尾处不能是反斜线，否则字符串结尾处的引号就被转义了，这样就导致字符串不能正确结束。

如果确实要在原始字符串的结尾处包含反斜线怎么办呢？一种方式是不要使用原始字符串，而是改为使用长字符串写法(三引号字符串)；另一种方式就是将反斜线单独写。

例如如下代码：

纯文本复制s3 = r'Good Morning' '\\'

print(s3)

有什么学的蒙的可以交流