Python变量的定义和使用
Python 变量的赋值Python 变量的使用Python 是弱类型的语言 Python整数类型（int）详解
关于 Python 2.x整数的不同进制
1) 十进制形式2) 二进制形式3) 八进制形式4) 十六进制形式 数字分隔符 Python小数/浮点数（float）类型详解
1) 十进制形式2) 指数形式 Python复数类型（complex）详解Python浮点数精度问题（包含解决方案）Python字符串详解（包含长字符串和原始字符串）
处理字符串中的引号的
1) 对引号进行转义2) 使用不同的引号包围字符串 字符串的换行Python长字符串Python原始字符串
原始字符串中的引号 Python字符串使用哪种编码格式？
什么是编码？什么是字符编码？Python使用哪种字符编码？ Python bytes类型及用法Python bool布尔类型Python缓存重用机制Python input()函数：获取用户输入的字符串
关于 Python 2.x Python print()函数高级用法Python格式化字符串（格式化输出）
指定最小输出宽度指定对齐方式指定小数精度 Python转义字符及用法Python类型转换，Python数据类型转换函数大全Python算术运算符及用法详解
+ 加法运算符
拼接字符串 - 减法运算符
求负 ＊乘法运算符
重复字符串 / 和 // 除法运算符
Python 2.x 中的除法 % 求余运算符** 次方（乘方）运算符 Python赋值运算符（入门必读）
基本赋值运算符
连续赋值= 和 == 扩展后的赋值运算符 Python位运算符详解
& 按位与运算符| 按位或运算符^按位异或运算符~按位取反运算符<<左移运算符>>右移运算符 Python比较运算符（关系运算符）
== 和 is 的区别 Python逻辑运算符及其用法
打脸某些 Python 教程逻辑运算符的本质 Python三目运算符（三元运算符）用法详解
三目运算符的嵌套 Python运算符优先级和结合性一览表
Python 运算符优先级Python 运算符结合性总结
转载于
http://c.biancheng.net/python/
所有的编程语言都支持变量，Python 也不例外。变量是编程的起点，程序需要将数据存储到变量中。
变量在 Python 内部是有类型的，比如 int、float 等，但是我们在编程时无需关注变量类型，所有的变量都无需提前声明，赋值后就能使用。另外，可以将不同类型的数据赋值给同一个变量，所以变量的类型是可以改变的。
本章的另一个重点内容是运算符，运算符将各种类型的数据连接在一起形成表达式。Python 的运算符丰富但不混乱，比如 Python 支持自增和自减运算符，但是它只支持一种形式，就是前自增和前自减，而取消了后自增和后自减，避免了给程序员造成混乱。
Python变量的定义和使用任何编程语言都需要处理数据，比如数字、字符串、字符等，我们可以直接使用数据，也可以将数据保存到变量中，方便以后使用。
变量（Variable）可以看成一个小箱子，专门用来“盛装”程序中的数据。每个变量都拥有独一无二的名字，通过变量的名字就能找到变量中的数据。
从底层看，程序中的数据最终都要放到内存（内存条）中，变量其实就是这块内存的名字。
和变量相对应的是常量（Constant），它们都是用来“盛装”数据的小箱子，不同的是：变量保存的数据可以被多次修改，而常量一旦保存某个数据之后就不能修改了。
Python 变量的赋值在编程语言中，将数据放入变量的过程叫做赋值（Assignment）。Python 使用等号=作为赋值运算符，具体格式为：
name = value
name 表示变量名；value 表示值，也就是要存储的数据。
注意，变量是标识符的一种，它的名字不能随便起，要遵守 Python 标识符命名规范，还要避免和 Python 内置函数以及 Python 保留字重名。
例如，下面的语句将整数 10 赋值给变量 n：
n = 10
从此以后，n 就代表整数 10，使用 n 也就是使用 10。
更多赋值的例子：
pi = 3.1415926 #将圆周率赋值给变量 pi url = "http://c.biancheng.net/python/" #将 Python 教程的地址赋值给变量 str real = True #将布尔值赋值给变量 real
变量的值不是一成不变的，它可以随时被修改，只要重新赋值即可；另外你也不用关心数据的类型，可以将不同类型的数据赋值给同一个变量。请看下面的演示：
n = 10 #将10赋值给变量n n = 95 #将95赋值给变量n n = 200 #将200赋值给变量n abc = 12.5 #将小数赋值给变量abc abc = 85 #将整数赋值给变量abc abc = "http://c.biancheng.net/" #将字符串赋值给变量abc
注意，变量的值一旦被修改，之前的值就被覆盖了，不复存在了，再也找不回了。换句话说，变量只能容纳一个值。
除了赋值单个数据，你也可以将表达式的运行结果赋值给变量，例如：
sum = 100 + 20 #将加法的结果赋值给变量 rem = 25 * 30 % 7 #将余数赋值给变量 str = "C语言中文网" + "http://c.biancheng.net/" #将字符串拼接的结果赋值给变量Python 变量的使用
使用 Python 变量时，只要知道变量的名字即可。
几乎在 Python 代码的任何地方都能使用变量，请看下面的演示：
>>> n = 10 >>> print(n) #将变量传递给函数 10 >>> m = n * 10 + 5 #将变量作为四则运算的一部分 >>> print(m) 105 >>> print(m-30) #将由变量构成的表达式作为参数传递给函数 75 >>> m = m * 2 #将变量本身的值翻倍 >>> print(m) 210 >>> url = "http://c.biancheng.net/cplus/" >>> str = "C++教程：" + url #字符串拼接 >>> print(str) C++教程：http://c.biancheng.net/cplus/Python 是弱类型的语言
在强类型的编程语言中，定义变量时要指明变量的类型，而且赋值的数据也必须是相同类型的，C语言、C++、Java 是强类型语言的代表。
下面我们以 C++ 为例来演示强类型语言中变量的使用：
int n = 10; //int表示整数类型 n = 100; n = "http://c.biancheng.net/socket/"; //错误：不能将字符串赋值给整数类型 url = "http://c.biancheng.net/java/"; //错误：没有指明类型的变量是没有定义的，不能使用。
和强类型语言相对应的是弱类型语言，Python、Javascript、PHP 等脚本语言一般都是弱类型的。
弱类型语言有两个特点：
变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。变量的数据类型可以随时改变，比如，同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。
注意，弱类型并不等于没有类型！弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型，例如：
>>> num = 10 >>> type(num)Python整数类型（int）详解>>> num = 15.8 >>> type(num) >>> num = 20 + 15j >>> type(num) >>> type(3*15.6)
整数就是没有小数部分的数字，Python 中的整数包括正整数、0 和负整数。
有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。例如C语言提供了 short、int、long、long long 四种类型的整数，它们的长度依次递增，初学者在选择整数类型时往往比较迷惑，有时候还会导致数值溢出。
而 Python 则不同，它的整数不分类型，或者说它只有一种类型的整数。Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。
当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。
请看下面的代码：
#将 78 赋值给变量 n n = 78 print(n) print( type(n) ) #给x赋值一个很大的整数 x = 8888888888888888888888 print(x) print( type(x) ) #给y赋值一个很小的整数 y = -7777777777777777777777 print(y) print( type(y) )
运行结果：
78
8888888888888888888888
-7777777777777777777777
x 是一个极大的数字，y 是一个很小的数字，Python 都能正确输出，不会发生溢出，这说明 Python 对整数的处理能力非常强大。
不管对于多大或者多小的整数，Python 只用一种类型存储，就是 int。
关于 Python 2.xPython 3.x 只用 int 一种类型存储整数，但是 Python 2.x 会使用 long 类型来存储较大的整数。以上代码在 Python 2.x 下的运行结果为：
78
8888888888888888888888
-7777777777777777777777
但是不管哪个版本的 Python，都能轻松处理极大和极小的数字，而且程序员也不用 *** 心底层到底使用了 int 还是 long 类型。
整数的不同进制在 Python 中，可以使用多种进制来表示整数：
1) 十进制形式我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。
注意，使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。
2) 二进制形式由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。
3) 八进制形式八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。
在 Python 2.x 中，八进制数字还可以直接以0（数字零）开头。
4) 十六进制形式由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头，
如果你对不同进制以及它们之间的转换方法不了解，请猛击下面的链接：
进制详解：二进制、八进制和十六进制进制转换：二进制、八进制、十六进制、十进制之间的转换
【实例】不同进制整数在 Python 中的使用：
#十六进制
hex1 = 0x45
hex2 = 0x4Af
print("hex1Value: ", hex1)
print("hex2Value: ", hex2)
#二进制
bin1 = 0b101
print('bin1Value: ', bin1)
bin2 = 0B110
print('bin2Value: ', bin2)
#八进制
oct1 = 0o26
print('oct1Value: ', oct1)
oct2 = 0O41
print('oct2Value: ', oct2)
运行结果：
hex1Value: 69
hex2Value: 1199
bin1Value: 5
bin2Value: 6
oct1Value: 22
oct2Value: 33
本例的输出结果都是十进制整数。
数字分隔符为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。
【实例】使用下划线书写数字：
click = 1_301_547
distance = 384_000_000
print("Python教程阅读量：", click)
print("地球和月球的距离：", distance)
运行结果：
Python教程阅读量：1301547
地球和月球的距离：384000000
在编程语言中，小数通常以浮点数的形式存储。浮点数和定点数是相对的：小数在存储过程中如果小数点发生移动，就称为浮点数；如果小数点不动，就称为定点数。
如果你对浮点数的底层存储格式不了解，请猛击：小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）
Python 中的小数有两种书写形式：
1) 十进制形式这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。
书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。
2) 指数形式Python 小数的指数形式的写法为：
aEn 或 aen
a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。
指数形式的小数举例：
2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。3.7E-2 = 3.7×10-2，其中 3.7 是尾数，-2 是指数。0.5E7 = 0.5×107，其中 0.5 是尾数，7 是指数。
注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。
Python 只有一种小数类型，就是 float。C语言有两种小数类型，分别是 float 和 double：float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。
【实例】小数在 Python 中的使用：
f1 = 12.5
print("f1Value: ", f1)
print("f1Type: ", type(f1))
f2 = 0.34557808421257003
print("f2Value: ", f2)
print("f2Type: ", type(f2))
f3 = 0.0000000000000000000000000847
print("f3Value: ", f3)
print("f3Type: ", type(f3))
f4 = 345679745132456787324523453.45006
print("f4Value: ", f4)
print("f4Type: ", type(f4))
f5 = 12e4
print("f5Value: ", f5)
print("f5Type: ", type(f5))
f6 = 12.3 * 0.1
print("f6Value: ", f6)
print("f6Type: ", type(f6))
运行结果：
f1Value: 12.5
f1Type:
f2Value: 0.34557808421257
f2Type:
f3Value: 8.47e-26
f3Type:
f4Value: 3.456797451324568e+26
f4Type:
f5Value: 120000.0
f5Type:
f6Value: 1.2300000000000002
f6Type:
从运行结果可以看出，Python 能容纳极小和极大的浮点数。print 在输出浮点数时，会根据浮点数的长度和大小适当的舍去一部分数字，或者采用科学计数法。
f5 的值是 120000，但是它依然是小数类型，而不是整数类型。
让人奇怪的是 f6，12.3*0.1的计算结果很明显是 1.23，但是 print 的输出却不精确。这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的。有兴趣的读者请猛击下面的链接深入学习：
进制转换：二进制、八进制、十六进制、十进制之间的转换小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文） Python复数类型（complex）详解
复数（Complex）是 Python 的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。
复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：
a + bj
a 表示实部，b 表示虚部。
【实例】Python 复数的使用：
c1 = 12 + 0.2j
print("c1Value: ", c1)
print("c1Type", type(c1))
c2 = 6 - 1.2j
print("c2Value: ", c2)
#对复数进行简单计算
print("c1+c2: ", c1+c2)
print("c1*c2: ", c1*c2)
运行结果：
c1Value: (12+0.2j)
c1Type
c2Value: (6-1.2j)
c1+c2: (18-1j)
c1*c2: (72.24-13.2j)
可以发现，复数在 Python 内部的类型是 complex，Python 默认支持对复数的简单计算。
Python浮点数精度问题（包含解决方案）前面章节提到，Python 中浮点类型之间的运算，其结果并不像我们想象的那样，例如：
>>> 0.1+0.2
0.30000000000000004
>>> 0.1+0.1-0.2
0.0
>>> 0.1+0.1+0.1-0.3
5.551115123125783e-17
>>> 0.1+0.1+0.1-0.2
0.10000000000000003
为什么在计算这么简单的问题上，计算机会出现这样的低级错误呢？真正的原因在于十进制和数和二进制数的转换。
我们知道，计算机其实是不认识十进制数，它只认识二进制数，也就是说，当我们以十进制数进行运算的时候，计算机需要将各个十进制数转换成二进制数，然后进行二进制间的计算。
以类似 0.1 这样的浮点数为例，如果手动将其转换成二进制，其结果为：
0.1(10)=0.00011001100110011…(2)
可以看到，结果是无限循环的，也就是说，0.1 转换成二进制数后，无法精确到等于十进制数的 0.1。同时，由于计算机存储的位数是有限制的，所以如果要存储的二进制位数超过了计算机存储位数的最大值，其后续位数会被舍弃（舍弃的原则是“0 舍 1 入”）。
这种问题不仅在 Python 中存在，在所有支持浮点数运算的编程语言中都会遇到，它不光是 Python 的 Bug。
明白了问题产生的原因之后，那么该如何解决呢？就 Python 的浮点数运算而言，大多数计算机每次计算误差不会超过 253，这对于大多数任务来说已经足够了。
如果需要非常精确的结果，可以使用 decimal 模块（其实就是别人开发好的程序，我们可以直接拿来用），它实现的十进制数运算适合会计方面的应用和有高精度要求的应用。例如：
#使用模块前，需要使用 import 引入
import decimal
a = decimal.Decimal("10.0")
b = decimal.Decimal("3")
print(10.0/3)
print(a/b)
运行结果为：
3.3333333333333335
3.333333333333333333333333333
可以看到，相比普通运算的结果，使用 decimal 模块得到的结果更精确。
如果 decimal 模块还是无法满足需求，还可以使用 fractions 模块，例如：
#引入 decimal 模块 from fractions import Fraction print(10/3) print(Fraction(10,3))
运行结果为：
3.3333333333333335
10/3
可以看到，通过 fractions 模块能很好地解决浮点类型数之间运算的问题。
Python字符串详解（包含长字符串和原始字符串）本节涉及到了有关模块的使用，读者不用研究细节，会用即可，后续章节会详细介绍模块。
若干个字符的集合就是一个字符串（String）。Python 中的字符串必须由双引号" "或者单引号' '包围，具体格式为：
“字符串内容”
‘字符串内容’
字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。
下面都是合法的字符串：
“123789”“123abc”“http://c.biancheng.net/python/”“C语言中文网成立8年了”
Python 字符串中的双引号和单引号没有任何区别。而有些编程语言的双引号字符串可以解析变量，单引号字符串一律原样输出，例如 PHP 和 Javascript。
处理字符串中的引号的当字符串内容中出现引号时，我们需要进行特殊处理，否则 Python 会解析出错，例如：
‘I’m a great coder!’
由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把'I'当成字符串，而后面的m a great coder!'就变成了多余的内容，从而导致语法错误。
对于这种情况，我们有两种处理方案：
1) 对引号进行转义在引号前面添加反斜杠就可以对引号进行转义，让 Python 把它作为普通文本对待，例如：
str1 = 'I'm a great coder!' str2 = "引文双引号是"，中文双引号是“" print(str1) print(str2)
运行结果：
I’m a great coder!
引文双引号是"，中文双引号是“
如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。例如：
str1 = "I'm a great coder!" #使用双引号包围含有单引号的字符串 str2 = '引文双引号是"，中文双引号是“' #使用单引号包围含有双引号的字符串 print(str1) print(str2)
运行结果和上面相同。
字符串的换行Python 不是格式自由的语言，它对程序的换行、缩进都有严格的语法要求。要想换行书写一个比较长的字符串，必须在行尾添加反斜杠，请看下面的例子：
s2 = 'It took me six months to write this Python tutorial.
Please give me more support.
I will keep it updated.'
上面 s2 字符串的比较长，所以使用了转义字符对字符串内容进行了换行，这样就可以把一个长字符串写成多行。
另外，Python 也支持表达式的换行，例如：
num = 20 + 3 / 4 +
2 * 3
print(num)
Python长字符串
在《Python注释》一节中我们提到，使用三个单引号或者双引号可以对多行内容进行注释，这其实是 Python 长字符串的写法。所谓长字符串，就是可以直接换行（不用加反斜杠）书写的字符串。
Python 长字符串由三个双引号"""或者三个单引号'''包围，语法格式如下：
“”“长字符串内容”""
‘’‘长字符串内容’’’
在长字符串中放置单引号或者双引号不会导致解析错误。
如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于被注释掉了。
注意，此时 Python 解释器并不会忽略长字符串，也会按照语法解析，只是长字符串起不到实际作用而已。
当程序中有大段文本内容需要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以在字符串中放置任何内容，包括单引号和双引号。
【实例】将长字符串赋值给变量：
longstr = '''It took me 6 months to write this Python tutorial. Please give me a to 'thumb' to keep it updated. The Python tutorial is available at http://c.biancheng.net/python/.''' print(longstr)
长字符串中的换行、空格、缩进等空白符都会原样输出，所以你不能写成下面的样子：
longstr = '''
It took me 6 months to write this Python tutorial.
Please give me a to 'thumb' to keep it updated.
The Python tutorial is available at http://c.biancheng.net/python/.
'''
print(longstr)
虽然这样写格式优美，但是输出结果将变成：
It took me 6 months to write this Python tutorial.
Please give me a to ‘thumb’ to keep it updated.
The Python tutorial is available at http://c.biancheng.net/python/.
字符串内容前后多出了两个空行，并且每一行的前面会多出四个空格。
Python原始字符串Python 字符串中的反斜杠有着特殊的作用，就是转义字符，例如上面提到的'和"，我们将在《Python转义字符》一节中详细讲解，这里大家先简单了解。
转义字符有时候会带来一些麻烦，例如我要表示一个包含 Windows 路径D:Program FilesPython 3.8python.exe这样的字符串，在 Python 程序中直接这样写肯定是不行的，不管是普通字符串还是长字符串。因为的特殊性，我们需要对字符串中的每个都进行转义，也就是写成D:\Program Files\Python 3.8\python.exe这种形式才行。
这种写法需要特别谨慎，稍有疏忽就会出错。为了解决转义字符的问题，Python 支持原始字符串。在原始字符串中，不会被当作转义字符，所有的内容都保持“原汁原味”的样子。
在普通字符串或者长字符串的开头加上r前缀，就变成了原始字符串，具体格式为：
str1 = r’原始字符串内容’
str2 = r""“原始字符串内容”""
将上面的 Windows 路径改写成原始字符串的形式：
rstr = r'D:Program FilesPython 3.8python.exe' print(rstr)原始字符串中的引号
如果普通格式的原始字符串中出现引号，程序同样需要对引号进行转义，否则 Python 照样无法对字符串的引号精确配对；但是和普通字符串不同的是，此时用于转义的反斜杠会变成字符串内容的一部分。
请看下面的代码：
str1 = r'I'm a great coder!' print(str1)
输出结果：
I’m a great coder!
需要注意的是，Python 原始字符串中的反斜杠仍然会对引号进行转义，因此原始字符串的结尾处不能是反斜杠，否则字符串结尾处的引号会被转义，导致字符串不能正确结束。
在 Python 中有两种方式解决这个问题：一种方式是改用长字符串的写法，不要使用原始字符串；另一种方式是单独书写反斜杠，这是接下来要重点说明的。
例如想表示D:Program FilesPython 3.8，可以这样写：
str1 = r'D:Program FilesPython 3.8' '\' print(str1)
我们先写了一个原始字符串r'D:Program FilesPython 3.8'，紧接着又使用'\'写了一个包含转义字符的普通字符串，Python 会自动将这两个字符串拼接在一起，所以上面代码的输出结果是：
D:Program FilesPython 3.8
由于这种写法涉及到了字符串拼接的相关知识，这里读者只需要了解即可，后续会对字符串拼接做详细介绍。
Python字符串使用哪种编码格式？在实践中，很多初学者都遇到过“文件显示乱码”的情况，其多数都是由于在打开文件时，没有选对编码格式导致的。因此，学习 Python 中的字符或字符串，了解其底层的编码格式是非常有必要的。
鉴于有些读者并不了解什么是编码格式，本节先从编码开始讲起。
什么是编码？虽然很多教程中有关于编码的定义，但对初学者来说并不容易理解，这里先举一个例子。古代打仗，击鼓为号、鸣金收兵，即把要传达给士兵的命令对应为公认的其他形式，这就和编码有相似之处。
以发布进攻命令为例，相比用嗓子喊，敲鼓发出的声音传播的更远，并且士兵听到后也不会引起歧义，因此长官下达进攻命令后，传令员就将此命令转化为对应的鼓声，这个转化的过程称为编码；由于士兵都接受过训练，听到鼓声后，他们可以将其转化为对应的进攻命令，这个转化的过程称为解码。
需要说明的是，此例只是形象地描述了编码和解码的原理，真实的编码和解码过程比这要复杂的多。
了解了编码的含义之后，接下来再介绍一下字符编码。
什么是字符编码？我们知道，计算机是以二进制的形式来存储数据的，即它只认识 0 和 1 两个数字。 20 世纪 60 年代，是计算机发展的早期，这时美国是计算机领域的老大，它制定了一套编码标准，解决了 128 个英文字符与二进制之间的对应关系，被称为 ASCII 字符编码（简称 ASCII 码）。
ASCII 码，全称为美国信息交换标准代码，是基于拉丁字母的一套字符编码，主要用于显示现代英语，因为万维网的出现，使得 ASCII 码广为使用，其直到 2007 年 12 月才逐渐被 Unicode 取代。
虽然英语用 128 个字符编码已经够用，但计算机不仅仅用于英语，如果想表示其他语言，128 个符号显然不够用，所以很多其他国家都在 ASCII 的基础上发明了很多别的编码，例如包含了汉语简体中文格式的 GB2312 编码格式（使用 2 个字节表示一个汉字）。
也正是由于出现了很多种编码格式，导致了“文件显示乱码”的情况。比如说，发送邮件时，如果发信人和收信人使用的编码格式不一样，则收信人很可能看到乱码的邮件。基于这个原因，Unicode 字符集应运而生。
Unicode 字符集又称万国码、国际码、统一码等。从名字就可以看出来，它是以统一符号为目标的字符集。Unicode 对世界上大部分的文字系统进行了整理、编码，使得电脑可以用更简单的方式来呈现和处理文字。
注意，在实际使用时，人们常常混淆字符集和字符编码这两个概念，我认为它们是不同的：
字符集定义了字符和二进制的对应关系，为每个字符分配了唯一的编号。可以将字符集理解成一个很大的表格，它列出了所有字符和二进制的对应关系，计算机显示文字或者存储文字，就是一个查表的过程；而字符编码规定了如何将字符的编号存储到计算机中，要知道，有些字符编码（如 GB2312 和 GBK）规定，不同字符在存储时所占用的字节数是不一样的，因此为了区分一个字符到底使用了几个字节，就不能将字符的编号直接存储到计算机中，字符编号在存储之前必须要经过转换，在读取时还要再逆向转换一次，这套转换方案就叫做字符编码。
Unicode 字符集可以使用的编码方案有三种，分别是：
- UTF-8：一种变长的编码方案，使用 1~6 个字节来存储；UTF-32：一种固定长度的编码方案，不管字符编号大小，始终使用 4 个字节来存储；UTF-16：介于 UTF-8 和 UTF-32 之间，使用 2 个或者 4 个字节来存储，长度既固定又可变。
其中，UTF-8 是目前使用最广的一种 Unicode字符集的实现方式，可以说它几乎已经一统江湖了。
Python使用哪种字符编码？了解了什么是编码，以及什么是字符编码之后，最后解决“Python 使用哪种字符编码？”这个问题。
Python 3.x 中，字符串采用的是 Unicode 字符集，可以用如下代码来查看当前环境的编码格式：
>>> import sys
>>> sys.getdefaultencoding()
‘utf-8’
同时，在 Python 3.x 中也可以用 ord() 和 chr() 函数实现字符和编码数字之间的转换，例如：
>>> ord(‘Q’)
81
>>> chr(81)
‘Q’
>>> ord(“网”)
32593
>>> chr(32593)
‘网’
Python 2.x 中无法使用 ord() 得到指定字符对应的编码数字。
由此可以知道，在 Unicode 字符集中，字符‘Q’对应的编码数字为 81，而中文‘网’对应的编码数字为 32593。
值得一提的是，虽然 Python 默认采用 UTF-8 编码，但它也提供了 encode() 方法，可以轻松实现将 Unicode 编码格式的字符串转化为其它编码格式。有关 encode() 方法的用法，可阅读《Python encode()和decode()方法》 一节。
Python bytes类型及用法Python bytes 类型用来表示一个字节串。“字节串“不是编程术语，是我自己“捏造”的一个词，用来和字符串相呼应。
bytes 是 Python 3.x 新增的类型，在 Python 2.x 中是不存在的。
字节串（bytes）和字符串（string）的对比：
字符串由若干个字符组成，以字符为单位进行 *** 作；字节串由若干个字节组成，以字节为单位进行 *** 作。字节串和字符串除了 *** 作的数据单元不同之外，它们支持的所有方法都基本相同。字节串和字符串都是不可变序列，不能随意增加和删除数据。
bytes 只负责以字节序列的形式（二进制形式）来存储数据，至于这些数据到底表示什么内容（字符串、数字、图片、音频等），完全由程序的解析方式决定。如果采用合适的字符编码方式（字符集），字节串可以恢复成字符串；反之亦然，字符串也可以转换成字节串。
说白了，bytes 只是简单地记录内存中的原始数据，至于如何使用这些数据，bytes 并不在意，你想怎么使用就怎么使用，bytes 并不约束你的行为。
bytes 类型的数据非常适合在互联网上传输，可以用于网络通信编程；bytes 也可以用来存储图片、音频、视频等二进制格式的文件。
字符串和 bytes 存在着千丝万缕的联系，我们可以通过字符串来创建 bytes 对象，或者说将字符串转换成 bytes 对象。有以下三种方法可以达到这个目的：
如果字符串的内容都是 ASCII 字符，那么直接在字符串前面添加b前缀就可以转换成 bytes。bytes 是一个类，调用它的构造方法，也就是 bytes()，可以将字符串按照指定的字符集转换成 bytes；如果不指定字符集，那么默认采用 UTF-8。字符串本身有一个 encode() 方法，该方法专门用来将字符串按照指定的字符集转换成对应的字节串；如果不指定字符集，那么默认采用 UTF-8。
【实例】使用不同方式创建 bytes 对象：
#通过构造函数创建空 bytes
b1 = bytes()
#通过空字符串创建空 bytes
b2 = b''
#通过b前缀将字符串转换成 bytes
b3 = b'http://c.biancheng.net/python/'
print("b3: ", b3)
print(b3[3])
print(b3[7:22])
#为 bytes() 方法指定字符集
b4 = bytes('C语言中文网8岁了', encoding='UTF-8')
print("b4: ", b4)
#通过 encode() 方法将字符串转换成 bytes
b5 = "C语言中文网8岁了".encode('UTF-8')
print("b5: ", b5)
运行结果：
b3: b’http://c.biancheng.net/python/’
112
b’c.biancheng.net’
b4: b’Cxe8xafxadxe8xa8x80xe4xb8xadxe6x96x87xe7xbdx918xe5xb2x81xe4xbax86’
b5: b’Cxe8xafxadxe8xa8x80xe4xb8xadxe6x96x87xe7xbdx918xe5xb2x81xe4xbax86’
从运行结果可以发现，对于非 ASCII 字符，print 输出的是它的字符编码值（十六进制形式），而不是字符本身。非 ASCII 字符一般占用两个字节以上的内存，而 bytes 是按照单个字节来处理数据的，所以不能一次处理多个字节。
如果你对进制不了解，请猛击：
进制详解：二进制、八进制和十六进制进制转换：二进制、八进制、十六进制、十进制之间的转换
如果你对字符集（字符编码）不了解，请猛击：
ASCII编码，将英文存储到计算机GB2312编码和GBK编码，将中文存储到计算机Unicode字符集，将全世界的文字存储到计算机
bytes 类也有一个 decode() 方法，通过该方法可以将 bytes 对象转换为字符串。紧接上面的程序，添加以下代码：
#通过 decode() 方法将 bytes 转换成字符串
str1 = b5.decode('UTF-8')
print("str1: ", str1)
输出结果：
str1: C语言中文网8岁了
Python bool布尔类型Python 提供了 bool 类型来表示真（对）或假（错），比如常见的5 > 3比较算式，这个是正确的，在程序世界里称之为真（对），Python 使用 True 来代表；再比如4 > 20比较算式，这个是错误的，在程序世界里称之为假（错），Python 使用 False 来代表。
True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错。
值得一提的是，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。因此，下边这些运算都是可以的：
>>> False+1
1
>>> True+1
2
注意，这里只是为了说明 True 和 Flase 对应的整型值，在实际应用中是不妥的，不要这么用。
总的来说，bool 类型就是用于代表某个事情的真（对）或假（错），如果这个事情是正确的，用 True（或 1）代表；如果这个事情是错误的，用 False（或 0）代表。
【例 1】
>>> 5>3
True
>>> 4>20
False
在 Python 中，所有的对象都可以进行真假值的测试，包括字符串、元组、列表、字典、对象等，由于目前尚未学习，因此这里不做过多讲述，后续遇到时会做详细的介绍。
Python缓存重用机制Python 缓冲机制是为提高程序执行的效率服务的，实际上就是在 Python 解释器启动时从内存空间中开辟出一小部分，用来存储高频使用的数据，这样可以大大减少高频使用的数据创建时申请内存和销毁时撤销内存的开销。
Python 在存储数据时，会根据数据的读取频繁程度以及内存占用情况来考虑，是否按照一定的规则将数据存储缓存中。那么问题来了，内存重用机制适用于哪些基本数据类型呢？
表 1 罗列了 Python 是否将指定数据存入缓存中的规则：
下面直接通过一段程序来演示 Python 缓存机制的规则。
#范围在 [-5, 256] 之间的小整数
int1 = -5
int2 = -5
print("[-5, 256] 情况下的两个变量：", id(int1), id(int2))
#bool类型
bool1 = True
bool2 = True
print("bool类型情况下的两个变量：",id(bool1),id(bool2))
#对于字符串
s1 = "3344"
s2 = "3344"
print("字符串情况下的两个交量", id(s1), id(s2))
#大于 256 的整数
int3 = 257
int4 = 257
print("大于 256 的整数情况下的两个变量", id(int3), id(int4))
#大于 0 的浮点数
f1 = 256.4
f2 = 256.4
print("大于 0 的浮点数情况下的两个变量", id(f1), id(f2))
#小于 0 的浮点数
f3 = -2.45
f4 = -2.45
print("小于 0 的浮点数情况下的两个变量", id(f3), id(f4))
#小于 -5 的整数
n1 = -6
n2 = -6
print("小于 -5 的整数情况下的两个变量", id(n1), id(n2))
注意，此程序中，大量使用 id() 内置函数，该函数的功能是获取变量（对象）所在的内存地址。运行该程序，其输出结果为：
[-5, 256] 情况下的两个变量： 1792722416 1792722416
bool类型情况下的两个变量： 1792241888 1792241888
字符串情况下的两个交量 2912801330712 2912801330712
大于 256 的整数情况下的两个变量 2912801267920 2912801267920
大于 0 的浮点数情况下的两个变量 2912762210728 2912762210728
小于 0 的浮点数情况下的两个变量 2912762211016 2912762211040
小于 -5 的整数情况下的两个变量 2912801267952 2912801267984
以上输出结果中，每行都输出了 2 个相对应的变量所在的内存地址，如果相等，则表明 Python 内部对其使用了缓存机制，反之则没有。读者可对照以上输出结果来理解表 1 中有关变量缓存机制的规则。
另外，对于表 1 中所提到的代码块，Python 中的函数和类都被认为是在程序中开辟了一块新的代码块。以函数为例，函数内部的代码分属一个代码块，函数外部的代码属于另一个代码块。
有关函数的具有用法，后续章节会详细介绍，这里读者只需要知道函数中包含的代码，属于一个新的代码块即可。
由表 1 可以看到，Python 缓存机制在不同的代码块中也会有不同的表现。举一个例子，在上面例子代码的基础上，继续编写如下程序：
def fun():
#[-5,256]
int1 = -5
print("fun中 -5 的存储状态",id(int1), id(int2))
#bool类型
bool3 = True
print("fun中 bool 类型的存储状态",id(bool3),id(bool2))
#字符串类型
s1 = "3344"
print("fun 中 3344 字符串的存储状态", id(s1), id(s2))
#大于 256
int3 = 257
print("fun中 257 的存储状态", id(int3), id(int4))
#浮点类型
f1 = 256.4
print("fun 中 256.4 的存储状态",id(f1), id(f2))
#小于 -5
n1 = -6
print("fun 中 -6 的存储状态", id(n1), id(n2))
fun()
输出结果为：
fun中 -5 的存储状态 1792722416 1792722416
fun中 bool 类型的存储状态 1792241888 1792241888
fun 中 3344 字符串的存储状态 1976405206496 1976405206496
fun中 257 的存储状态 1976405225648 1976405225680
fun 中 256.4 的存储状态 1976394459752 1976394459872
fun 中 -6 的存储状态 1976404744880 1976405225744
根据输出结果可以分析出：
- 从 -5 、bool 类型以及字符串 “3344” 的输出结果可以得知，无论是在同一代码块，还是不同的代码块，它们都使用相同的缓存内容；从 257 和 256.4 的输出结果可以得知，如果位于同一代码块，则使用相同的缓存内容；反之，则不使用；从 -6 的输出结果得知，Python 没有对其缓存进行 *** 作。
input() 是 Python 的内置函数，用于从控制台读取用户输入的内容。input() 函数总是以字符串的形式来处理用户输入的内容，所以用户输入的内容可以包含任何字符。
input() 函数的用法为：
str = input(tipmsg)
说明：
str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样的内容；如果不写 tipmsg，就不会有任何提示信息。
【实例】input() 函数的简单使用：
a = input("Enter a number: ")
b = input("Enter another number: ")
print("aType: ", type(a))
print("bType: ", type(b))
result = a + b
print("resultValue: ", result)
print("resultType: ", type(result))
运行结果示例：
Enter a number: 100↙
Enter another number: 45↙
aType:
bType:
resultValue: 10045
resultType:
↙表示按下回车键，按下回车键后 input() 读取就结束了。
本例中我们输入了两个整数，希望计算出它们的和，但是事与愿违，Python 只是它们当成了字符串，+起到了拼接字符串的作用，而不是求和的作用。
我们可以使用 Python 内置函数将字符串转换成想要的类型，比如：
int(string) 将字符串转换成 int 类型；float(string) 将字符串转换成 float 类型；bool(string) 将字符串转换成 bool 类型。
修改上面的代码，将用户输入的内容转换成数字：
a = input("Enter a number: ")
b = input("Enter another number: ")
a = float(a)
b = int(b)
print("aType: ", type(a))
print("bType: ", type(b))
result = a + b
print("resultValue: ", result)
print("resultType: ", type(result))
运行结果：
Enter a number: 12.5↙
Enter another number: 64↙
aType:
bType:
resultValue: 76.5
resultType:
上面讲解的是 Python 3.x 中 input() 的用法，但是在较老的 Python 2.x 中情况就不一样了。Python 2.x 共提供了两个输入函数，分别是 input() 和 raw_input()：
Python 2.x raw_input() 和 Python 3.x input() 效果是一样的，都只能以字符串的形式读取用户输入的内容。Python 2.x input() 看起来有点奇怪，它要求用户输入的内容必须符合 Python 的语法，稍有疏忽就会出错，通常来说只能是整数、小数、复数、字符串等。
比较强迫的是，Python 2.x input() 要求用户在输入字符串时必须使用引号包围，这有违 Python 简单易用的原则，所以 Python 3.x 取消了这种输入方式。
修改本节第一段代码，去掉 print 后面的括号：
a = input("Enter a number: ")
b = input("Enter another number: ")
print "aType: ", type(a)
print "bType: ", type(b)
result = a + b
print "resultValue: ", result
print "resultType: ", type(result)
在 Python 2.x 下运行该代码：
Enter a number: 45↙
Enter another number: 100↙
aType:
bType:
resultValue: 145
resultType:
前面使用 print() 函数时，都只输出了一个变量，但实际上 print() 函数完全可以同时输出多个变量，而且它具有更多丰富的功能。
print() 函数的详细语法格式如下：
print (value,…,sep=’’,end=’n’,file=sys.stdout,flush=False)
从上面的语法格式可以看出，value 参数可以接受任意多个变量或值，因此 print() 函数完全可以输出多个值。例如如下代码：
user_name ＝ 'Charlie'
user_age = 8
#同时输出多个变量和字符串
print("读者名：",user_name,"年龄：",user_age)
运行上面代码，可以看到如下输出结果：
读者名： Charlie 年龄： 8
从输出结果来看，使用 print() 函数输出多个变量时，print() 函数默认以空格隔开多个变量，如果读者希望改变默认的分隔符，可通过 sep 参数进行设置。例如输出语句：
#同时输出多个变量和字符串，指定分隔符
print("读者名：" ,user_name,"年龄：",user_age,sep='|')
运行上面代码，可以看到如下输出结果：
读者名：|Charlie|年龄：|8
在默认情况下，print() 函数输出之后总会换行，这是因为 print() 函数的 end 参数的默认值是“n”，这个“n”就代表了换行。如果希望 print() 函数输出之后不会换行，则重设 end 参数即可，例如如下代码：
#设置end 参数，指定输出之后不再换行 print(40,'t',end＝"") print(5O,'t',end＝"") print(60,'t',end＝"")
上面三条 print() 语句会执行三次输出，但由于它们都指定了 end＝""，因此每条 print() 语句的输出都不会换行，依然位于同一行。运行上面代码，可以看到如下输出结果：
40 50 60
file 参数指定 print() 函数的输出目标，file 参数的默认值为 sys.stdout，该默认值代表了系统标准输出，也就是屏幕，因此 print() 函数默认输出到屏幕。实际上，完全可以通过改变该参数让 print() 函数输出到特定文件中，例如如下代码：
f = open("demo.txt","w")#打开文件以便写入
print('沧海月明珠有泪',file=f)
print('蓝回日暖玉生烟',file=f)
f.close()
上面程序中，open() 函数用于打开 demo.txt 文件，接连 2 个 print 函数会将这 2 段字符串依次写入此文件，最后调用 close() 函数关闭文件，教程后续章节还会详细介绍关于文件 *** 作的内容。
print() 函数的 flush 参数用于控制输出缓存，该参数一般保持为 False 即可，这样可以获得较好的性能。
Python格式化字符串（格式化输出）我们在《第一个Python程序——在屏幕上输出文本》中讲到过 print() 函数的用法，这只是最简单最初级的形式，print() 还有很多高级的玩法，比如格式化输出，这就是本节要讲解的内容。
熟悉C语言 printf() 函数的读者能够轻而易举学会 Python print() 函数，它们是非常类似的。
print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表。
转换说明符（Conversion Specifier）只是一个占位符，它会被后面表达式（变量、常量、数字、字符串、加减乘除等各种形式）的值代替。
【实例】输出一个整数：
age = 8
print("C语言中文网已经%d岁了！" % age)
运行结果：
C语言中文网已经8岁了！
在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%d说明符，它最终会被后面的 age 变量的值所替代。
中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。
当然，格式化字符串中也可以包含多个转换说明符，这个时候也得提供多个表达式，用以替换对应的转换说明符；多个表达式必须使用小括号( )包围起来。请看下面的例子：
name = "C语言中文网"
age = 8
url = "http://c.biancheng.net/"
print("%s已经%d岁了，它的网址是%s。" % (name, age, url))
运行结果：
C语言中文网已经8岁了，它的网址是http://c.biancheng.net/。
总之，有几个占位符，后面就得跟着几个表达式。
指定最小输出宽度当使用表1中的转换说明符时，可以使用下面的格式指定最小输出宽度（至少占用多少个字符的位置）：
%10d 表示输出的整数宽度至少为 10；%20s 表示输出的字符串宽度至少为 20。
请看下面的演示：
n = 1234567
print("n(10):%10d." % n)
print("n(5):%5d." % n)
url = "http://c.biancheng.net/python/"
print("url(35):%35s." % url)
print("url(20):%20s." % url)
运行结果：
n(10): 1234567. n(5):1234567. url(35): http://c.biancheng.net/python/. url(20):http://c.biancheng.net/python/.
从运行结果可以发现，对于整数和字符串，当数据的实际宽度小于指定宽度时，会在左侧以空格补齐；当数据的实际宽度大于指定宽度时，会按照数据的实际宽度输出。
你看，这里指定的只是最小宽度，当数据的实际宽度足够时，指定的宽度就没有实际意义了。
指定对齐方式默认情况下，print() 输出的数据总是右对齐的。也就是说，当数据不够宽时，数据总是靠右边输出，而在左边补充空格以达到指定的宽度。Python 允许在最小宽度之前增加一个标志来改变对齐方式，Python 支持的标志如下：
几点说明：
对于整数，指定左对齐时，在右边补 0 是没有效果的，因为这样会改变整数的值。对于小数，以上三个标志可以同时存在。对于字符串，只能使用-标志，因为符号对于字符串没有意义，而补 0 会改变字符串的值。
请看下面的代码：
n = 123456
# %09d 表示最小宽度为9，左边补0
print("n(09):%09d" % n)
# %+9d 表示最小宽度为9，带上符号
print("n(+9):%+9d" % n)
f = 140.5
# %-+010f 表示最小宽度为10，左对齐，带上符号
print("f(-+0):%-+010f" % f)
s = "Hello"
# %-10s 表示最小宽度为10，左对齐
print("s(-10):%-10s." % s)
运行结果：
n(09):000123456 n(+9): +123456 f(-+0):+140.500000 s(-10):Hello .指定小数精度
对于小数（浮点数），print() 还允许指定小数点后的数字位数，也即指定小数的输出精度。
精度值需要放在最小宽度之后，中间用点号.隔开；也可以不写最小宽度，只写精度。具体格式如下：
%m.nf
%.nf
m 表示最小宽度，n 表示输出精度，.是必须存在的。
请看下面的代码：
f = 3.141592653
# 最小宽度为8，小数点后保留3位
print("%8.3f" % f)
# 最小宽度为8，小数点后保留3位，左边补0
print("%08.3f" % f)
# 最小宽度为8，小数点后保留3位，左边补0，带符号
print("%+08.3f" % f)
运行结果：
3.142 0003.142 +003.142Python转义字符及用法
在《Python字符串》一节中我们曾提到过转义字符，就是那些以反斜杠开头的字符。
ASCII 编码为每个字符都分配了唯一的编号，称为编码值。在 Python 中，一个 ASCII 字符除了可以用它的实体（也就是真正的字符）表示，还可以用它的编码值表示。这种使用编码值来间接地表示字符的方式称为转义字符（Escape Character）。
如果你对 ASCII 编码不了解，请猛击：
ASCII 编码，将英文存储到计算机ASCII 码一览表，ASCII 码对照表（完整版）
转义字符以或者x开头，以开头表示后跟八进制形式的编码值，以x开头表示后跟十六进制形式的编码值，Python 中的转义字符只能使用八进制或者十六进制。具体格式如下：
dd
xhh
dd 表示八进制数字，hh 表示十六进制数字。
ASCII 编码共收录了 128 个字符，和x后面最多只能跟两位数字，所以八进制形式并不能表示所有的 ASCII 字符，只有十六进制形式x才能表示所有 ASCII 字符。
我们一直在说 ASCII 编码，没有提及 Unicode、GBK、Big5 等其它编码（字符集），是因为 Python 转义字符只对 ASCII 编码（128 个字符）有效，超出范围的行为是不确定的。
字符 1、2、3、x、y、z 对应的 ASCII 码的八进制形式分别是 61、62、63、170、171、172，十六进制形式分别是 31、32、33、78、79、7A。下面的例子演示了转义字符的用法：
str1 = "Oct: 616263" str2 = "Hex: x31x32x33x78x79x7A" print(str1) print(str2)
运行结果：
Oct: 123
Hex: 123xyz
注意，使用八进制形式的转义字符没法表示 xyz，因为它们的编码值转换成八进制以后有三位。
对于 ASCII 编码，0~31（十进制）范围内的字符为控制字符，它们都是看不见的，不能在显示器上显示，甚至无法从键盘输入，只能用转义字符的形式来表示。不过，直接使用 ASCII 码记忆不方便，也不容易理解，所以，针对常用的控制字符，C语言又定义了简写方式，完整的列表如下。
转义字符在书写形式上由多个字符组成，但 Python 将它们看作是一个整体，表示一个字符。
Python 转义字符综合示例：
#使用t排版
str1 = '网站tt域名ttt年龄tt价值'
str2 = 'C语言中文网tc.biancheng.nettt8tt500W'
str3 = '百度ttwww.baidu.comtt20tt500000W'
print(str1)
print(str2)
print(str3)
print("--------------------")
# n在输出时换行，在书写字符串时换行
info = "Python教程：http://c.biancheng.net/python/n
C++教程：http://c.biancheng.net/cplus/n
Linux教程：http://c.biancheng.net/linux_tutorial/"
print(info)
运行结果：
网站 域名 年龄 价值 C语言中文网 c.biancheng.net 8 500W 百度 www.baidu.com 20 500000W -------------------- Python教程：http://c.biancheng.net/python/ C++教程：http://c.biancheng.net/cplus/ Linux教程：http://c.biancheng.net/linux_tutorial/Python类型转换，Python数据类型转换函数大全
虽然 Python 是弱类型编程语言，不需要像 Java 或 C 语言那样还要在使用变量前声明变量的类型，但在一些特定场景中，仍然需要用到类型转换。
比如说，我们想通过使用 print() 函数输出信息“您的身高：”以及浮点类型 height 的值，如果在交互式解释器中执行如下代码：
>>> height = 70.0
>>> print(“您的身高”+height)
Traceback (most recent call last):
File “
print(“您的身高”+height)
TypeError: must be str, not float
你会发现这是错误的，解释器提示我们字符串和浮点类型变量不能直接相连，需要提前将浮点类型变量 height 转换为字符串才可以。
庆幸的是，Python 已经为我们提供了多种可实现数据类型转换的函数，如表 1 所示。
需要注意的是，在使用类型转换函数时，提供给它的数据必须是有意义的。例如，int() 函数无法将一个非数字字符串转换成整数：
>>> int(“123”) #转换成功
123
>>> int(“123个”) #转换失败
Traceback (most recent call last):
File “
int(“123个”)
ValueError: invalid literal for int() with base 10: ‘123个’
>>>
算术运算符也即数学运算符，用来对数字进行数学运算，比如加减乘除。下表列出了 Python 支持所有基本算术运算符。
接下来将对表 1 中各个算术运算符的用法逐一讲解。
+ 加法运算符加法运算符很简单，和数学中的规则一样，请看下面的代码：
m = 10
n = 97
sum1 = m + n
x = 7.2
y = 15.3
sum2 = x + y
print("sum1=%d, sum2=%.2f" % (sum1, sum2) )
运行结果：
sum1=107, sum2=22.50
当+用于数字时表示加法，但是当+用于字符串时，它还有拼接字符串（将两个字符串连接为一个）的作用，请看代码：
name = "C语言中文网" url = "http://c.biancheng.net/" age = 8 info = name + "的网址是" + url + "，它已经" + str(age) + "岁了。" print(info)
运行结果：
C语言中文网的网址是http://c.biancheng.net/，它已经8岁了。
str() 函数用来将整数类型的 age 转换成字符串。
- 减法运算符减法运算也和数学中的规则相同，请看代码：
n = 45 m = -n x = -83.5 y = -x print(m, ",", y)
运行结果：
-45 , 83.5
-除了可以用作减法运算之外，还可以用作求负运算（正数变负数，负数变正数），请看下面的代码：
n = 45 n_neg = -n f = -83.5 f_neg = -f print(n_neg, ",", f_neg)
运行结果：
-45 , 83.5
注意，单独使用+是无效的，不会改变数字的值，例如：
n = 45 m = +n x = -83.5 y = +x print(m, ",", y)
运行结果：
45 , -83.5
乘法运算也和数学中的规则相同，请看代码：
n = 4 * 25 f = 34.5 * 2 print(n, ",", f)
运行结果：
100 , 69.0
*除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来，请看代码：
str1 = "hello " print(str1 * 4)
运行结果：
hello hello hello hello
Python 支持/和//两个除法运算符，但它们之间是有区别的：
/表示普通除法，使用它计算出来的结果和数学中的计算结果相同。//表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。
请看下面的例子：
#整数不能除尽
print("23/5 =", 23/5)
print("23//5 =", 23//5)
print("23.0//5 =", 23.0//5)
print("-------------------")
#整数能除尽
print("25/5 =", 25/5)
print("25//5 =", 25//5)
print("25.0//5 =", 25.0//5)
print("-------------------")
#小数除法
print("12.4/3.5 =", 12.4/3.5)
print("12.4//3.5 =", 12.4//3.5)
运行结果：
23/5 = 4.6
23//5 = 4
23.0//5 = 4.0
-------------------
25/5 = 5.0
25//5 = 5
25.0//5 = 5.0
-------------------
12.4/3.5 = 3.542857142857143
12.4//3.5 = 3.0
从运行结果可以发现：
/的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。当有小数参与运算时，//结果才是小数，否则就是整数。
需要注意的是，除数始终不能为 0，除以 0 是没有意义的，这将导致 ZeroDivisionError 错误。在某些编程语言中，除以 0 的结果是无穷大（包括正无穷大和负无穷大）。
Python 2.x 中的除法Python 2.x 只提供了一种除法运算，就是/，它的行为和大部分编程语言中/的行为是一样的：
当/两边都是整数时，结果始终是整数；如果不能除尽，就直接舍弃小数部分。当/两边有一个是小数时，结果始终是小数；如果恰好除尽，小数部分就是 0。
请看下面的代码：
#整数除法 print "18/6 =", 18/6 print "47/7 =", 47/7 print "----------------" #小数除法 print "18.0/6 =", 18.0/6 print "47.0/7 =", 47.0/7 print "29.5/4.2 =", 29.5/4.2
运行结果：
18/6 = 3
47/7 = 6
----------------
18.0/6 = 3.0
47.0/7 = 6.71428571429
29.5/4.2 = 7.02380952381
你可以将 Python 2.x 中的/看作 Python 3.x 中/和//的结合体，因为 Python 2.x 中/的行为有点奇怪，所以 Python 3.x 增加了//运算符，用以规范除法运算的行为。
% 求余运算符Python % 运算符用来求得两个数相除的余数，包括整数和小数。Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。
注意，求余运算的本质是除法运算，所以第二个数字也不能是 0，否则会导致 ZeroDivisionError 错误。
Python % 使用示例：
print("-----整数求余-----")
print("15%6 =", 15%6)
print("-15%6 =", -15%6)
print("15%-6 =", 15%-6)
print("-15%-6 =", -15%-6)
print("-----小数求余-----")
print("7.7%2.2 =", 7.7%2.2)
print("-7.7%2.2 =", -7.7%2.2)
print("7.7%-2.2 =", 7.7%-2.2)
print("-7.7%-2.2 =", -7.7%-2.2)
print("---整数和小数运算---")
print("23.5%6 =", 23.5%6)
print("23%6.5 =", 23%6.5)
print("23.5%-6 =", 23.5%-6)
print("-23%6.5 =", -23%6.5)
print("-23%-6.5 =", -23%-6.5)
运行结果：
-----整数求余-----
15%6 = 3
-15%6 = 3
15%-6 = -3
-15%-6 = -3
-----小数求余-----
7.7%2.2 = 1.0999999999999996
-7.7%2.2 = 1.1000000000000005
7.7%-2.2 = -1.1000000000000005
-7.7%-2.2 = -1.0999999999999996
—整数和小数运算—
23.5%6 = 5.5
23%6.5 = 3.5
23.5%-6 = -0.5
-23%6.5 = 3.0
-23%-6.5 = -3.5
从运行结果可以发现两点：
只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。%两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。
本例中小数求余的四个结果都不精确，而是近似值，这和小数在底层的存储有关系，有兴趣的读者请猛击《小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）》了解更多。
** 次方（乘方）运算符Python ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。
由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算。
Python ** 运算符示例：
print('----次方运算----')
print('3**4 =', 3**4)
print('2**5 =', 2**5)
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))
运行结果：
----次方运算----
34 = 81
25 = 32
----开方运算----
81**(1/4) = 3.0
32**(1/5) = 2.0
赋值运算符用来把右侧的值传递给左侧的变量（或者常量）；可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。
Python 中最基本的赋值运算符是等号=；结合其它运算符，=还能扩展出更强大的赋值运算符。
基本赋值运算符=是 Python 中最常见、最基本的赋值运算符，用来将一个表达式的值赋给另一个变量，请看下面的例子：
#将字面量（直接量）赋值给变量 n1 = 100 f1 = 47.5 s1 = "http://c.biancheng.net/python/" #将一个变量的值赋给另一个变量 n2 = n1 f2 = f1 #将某些运算的值赋给变量 sum1 = 25 + 46 sum2 = n1 % 6 s2 = str(1234) #将数字转换成字符串 s3 = str(100) + "abc"连续赋值
Python 中的赋值表达式也是有值的，它的值就是被赋的那个值，或者说是左侧变量的值；如果将赋值表达式的值再赋值给另外一个变量，这就构成了连续赋值。请看下面的例子：
a = b = c = 100
=具有右结合性，我们从右到左分析这个表达式：
c = 100 表示将 100 赋值给 c，所以 c 的值是 100；同时，c = 100 这个子表达式的值也是 100。b = c = 100 表示将 c = 100 的值赋给 b，因此 b 的值也是 100。以此类推，a 的值也是 100。
最终结果就是，a、b、c 三个变量的值都是 100。
= 和 === 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆。
扩展后的赋值运算符=还可与其他运算符（包括算术运算符、位运算符和逻辑运算符）相结合，扩展成为功能更加强大的赋值运算符，如表 1 所示。扩展后的赋值运算符将使得赋值表达式的书写更加优雅和方便。
这里举个简单的例子：
n1 = 100
f1 = 25.5
n1 -= 80 #等价于 n1=n1-80
f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )
print("n1=%d" % n1)
print("f1=%.2f" % f1)
运行结果为：
n1=20
f1=255.00
通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。
但是请注意，这种赋值运算符只能针对已经存在的变量赋值，因为赋值过程中需要变量本身参与运算，如果变量没有提前定义，它的值就是未知的，无法参与运算。例如，下面的写法就是错误的：
n += 10
该表达式等价于 n = n + 10，n 没有提前定义，所以它不能参与加法运算。
Python位运算符详解Python 位运算按照数据在内存中的二进制位（Bit）进行 *** 作，它一般用于底层开发（算法设计、驱动、图像处理、单片机等），在应用层开发（Web 开发、Linux 运维等）中并不常见。想加快学习进度，或者不关注底层开发的读者可以先跳过本节，以后需要的话再来学习。
Python 位运算符只能用来 *** 作整数类型，它按照整数在内存中的二进制形式进行计算。Python 支持的位运算符如表 1 所示。
按位与运算符&的运算规则是：只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似。
例如，9&5可以转换成如下的运算：
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） & 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在内存中的存储）
&运算符会对参与运算的两个整数的所有二进制位进行&运算，9&5的结果为 1。
又如，-9&5可以转换成如下的运算：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） & 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-9&5的结果是 5。
不了解整数在内存中如何存储的读者，请猛击：整数在内存中是如何存储的，为什么它堪称天才般的设计？
再强调一遍，&运算符 *** 作的是数据在内存中存储的原始二进制位，而不是数据本身的二进制形式；其他位运算符也一样。以-9&5为例，-9 的在内存中的存储和 -9 的二进制形式截然不同：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） -0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （-9 的二进制形式，前面多余的0可以抹掉）
按位与运算通常用来对某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以进行n & 0xFFFF运算（0xFFFF 在内存中的存储形式为 0000 0000 – 0000 0000 – 1111 1111 – 1111 1111）。
使用 Python 代码对上面的分析进行验证：
n = 0x8FA6002D
print("%X" % (9&5) )
print("%X" % (-9&5) )
print("%X" % (n&0xFFFF) )
运行结果：
1
5
2D
按位或运算符|的运算规则是：两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为 1，0|0为0，1|0 为1，这和逻辑运算中的||非常类似。
例如，9 | 5可以转换成如下的运算：
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） | 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 （13 在内存中的存储）
9 | 5的结果为 13。
又如，-9 | 5可以转换成如下的运算：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） | 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-9 | 5的结果是 -9。
按位或运算可以用来将某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以进行n | 0xFFFF0000运算（0xFFFF0000 在内存中的存储形式为 1111 1111 – 1111 1111 – 0000 0000 – 0000 0000）。
使用 Python 代码对上面的分析进行验证：
n = 0x2D
print("%X" % (9|5) )
print("%X" % (-9|5) )
print("%X" % (n|0xFFFF0000) )
运行结果：
D
-9
FFFF002D
按位异或运算^的运算规则是：参与运算的两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为 1，0^0为 0，1^1为 0。
例如，9 ^ 5可以转换成如下的运算：
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） ^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 （12 在内存中的存储）
9 ^ 5的结果为 12。
又如，-9 ^ 5可以转换成如下的运算：
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） ^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 （-14 在内存中的存储）
-9 ^ 5的结果是 -14。
按位异或运算可以用来将某些二进制位反转。例如要把 n 的高 16 位反转，保留低 16 位，可以进行n ^ 0xFFFF0000运算（0xFFFF0000 在内存中的存储形式为 1111 1111 – 1111 1111 – 0000 0000 – 0000 0000）。
使用 Python 代码对上面的分析进行验证：
n = 0x0A07002D
print("%X" % (9^5) )
print("%X" % (-9^5) )
print("%X" % (n^0xFFFF0000) )
运行结果：
C
-E
F5F8002D
按位取反运算符~为单目运算符（只有一个 *** 作数），右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似。
例如，~9可以转换为如下的运算：
~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 （-10 在内存中的存储）
所以~9的结果为 -10。
例如，~-9可以转换为如下的运算：
~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 （8 在内存中的存储）
所以~-9的结果为 8。
使用 Python 代码对上面的分析进行验证：
print("%X" % (~9) )
print("%X" % (~-9) )
运行结果：
-A
8
Python 左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补 0。
例如，9<<3可以转换为如下的运算：
<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 （72 在内存中的存储）
所以9<<3的结果为 72。
又如，(-9)<<3可以转换为如下的运算：
<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 （-72 在内存中的存储）
所以(-9)<<3的结果为 -72
如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。
使用 Python 代码对上面的分析进行验证：
print("%X" % (9<<3) )
print("%X" % ((-9)<<3) )
运行结果：
48
-48
Python 右移运算符>>用来把 *** 作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1。
例如，9>>3可以转换为如下的运算：
>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在内存中的存储）
所以9>>3的结果为 1。
又如，(-9)>>3可以转换为如下的运算：
>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 （-2 在内存中的存储）
所以(-9)>>3的结果为 -2
如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方（但被移除的位中经常会包含 1）。
使用 Python 代码对上面的分析进行验证：
print("%X" % (9>>3) )
print("%X" % ((-9)>>3) )
运行结果：
1
-2
比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。
True 和 False 都是 bool 类型，它们专门用来表示一件事情的真假，或者一个表达式是否成立，我们将在《Python bool布尔类型》中详细讲解。
Python 支持的比较运算符如表 1 所示。
Python 比较运算符的使用举例：
print("89是否大于100：", 89 > 100)
print("24*5是否大于等于76：", 24*5 >= 76)
print("86.5是否等于86.5：", 86.5 == 86.5)
print("34是否等于34.0：", 34 == 34.0)
print("False是否小于True：", False < True)
print("True是否等于True：", True < True)
运行结果：
89是否大于100： False
24*5是否大于等于76： True
86.5是否等于86.5： True
34是否等于34.0： True
False是否小于True： True
True是否等于True： False
初学 Python，大家可能对 is 比较陌生，很多人会误将它和 == 的功能混为一谈，但其实 is 与 == 有本质上的区别，完全不是一码事儿。
== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象，例如：
import time #引入time模块 t1 = time.gmtime() # gmtime()用来获取当前时间 t2 = time.gmtime() print(t1 == t2) #输出True print(t1 is t2) #输出False
运行结果：
True
False
time 模块的 gmtime() 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快，所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等，所以返回 True。
虽然 t1 和 t2 的值相等，但它们是两个不同的对象（每次调用 gmtime() 都返回不同的对象），所以t1 is t2返回 False。这就好像两个双胞胎姐妹，虽然她们的外貌是一样的，但它们是两个人。
那么，如何判断两个对象是否相同呢？答案是判断两个对象的内存地址。如果内存地址相同，说明两个对象使用的是同一块内存，当然就是同一个对象了；这就像两个名字使用了同一个身体，当然就是同一个人了。
Python逻辑运算符及其用法高中数学中我们就学过逻辑运算，例如 p 为真命题，q 为假命题，那么“p且q”为假，“p或q”为真，“非q”为真。Python 也有类似的逻辑运算，请看下表：
逻辑运算符一般和关系运算符结合使用，例如：
14>6 and 45.6 > 90
14>6 结果为 True，成立，45.6>90 结果为 False，不成立，所以整个表达式的结果为 False，也即不成立。
再看一个比较实用的例子：
age = int(input("请输入年龄："))
height = int(input("请输入身高："))
if age>=18 and age<=30 and height >=170 and height <= 185 :
print("恭喜，你符合报考飞行员的条件")
else:
print("抱歉，你不符合报考飞行员的条件")
可能的运行结果：
请输入年龄：23↙
请输入身高：178↙
恭喜，你符合报考飞行员的条件
有些不负责任的 Python 教程说：Python 逻辑运算符用于 *** 作 bool 类型的表达式，执行结果也是 bool 类型，这两点其实都是错误的！
Python 逻辑运算符可以用来 *** 作任何类型的表达式，不管表达式是不是 bool 类型；同时，逻辑运算的结果也不一定是 bool 类型，它也可以是任意类型。请看下面的例子：
print(100 and 200)
print(45 and 0)
print("" or "http://c.biancheng.net/python/")
print(18.5 or "http://c.biancheng.net/python/")
运行结果：
200
0
http://c.biancheng.net/python/
18.5
你看，本例中 and 和 or 运算符 *** 作的都不是 bool 类型表达式， *** 作的结果也不是 bool 值。
逻辑运算符的本质在 Python 中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。
另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。
以上两点极其重要，了解这两点不会让你在使用逻辑运算的过程中产生疑惑。
对于 and 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python 按照下面的规则执行 and 运算：
如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 and 会把左边表达式的值作为最终结果。如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
对于 or 运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以 Python 按照下面的规则执行 or 运算：
如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 or 会把左边表达式的值作为最终结果。如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
使用代码验证上面的结论：
url = "http://c.biancheng.net/cplus/"
print("----False and xxx-----")
print( False and print(url) )
print("----True and xxx-----")
print( True and print(url) )
print("----False or xxx-----")
print( False or print(url) )
print("----True or xxx-----")
print( True or print(url) )
运行结果：
----False and xxx-----
False
----True and xxx-----
http://c.biancheng.net/cplus/
None
----False or xxx-----
http://c.biancheng.net/cplus/
None
----True or xxx-----
True
第 4 行代码中，and 左边的值为假，不需要再执行右边的表达式了，所以 print(url) 没有任何输出。
第 6 行代码中，and 左边的值为真，还需要执行右边的表达式才能得到最终的结果，所以 print(url) 输出了一个网址。
第 8、10 行代码也是类似的。
Python三目运算符（三元运算符）用法详解我们从一个具体的例子切入本节内容。假设现在有两个数字，我们希望获得其中较大的一个，那么可以使用 if else 语句，例如：
if a>b:
max = a;
else:
max = b;
但是 Python 提供了一种更加简洁的写法，如下所示：
max = a if a>b else b
这是一种类似于其它编程语言中三目运算符? :的写法。Python 是一种极简主义的编程语言，它没有引入? :这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。
使用 if else 实现三目运算符（条件运算符）的格式如下：
exp1 if contion else exp2
condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。
前面的语句max = a if a>b else b的含义是：
如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。 三目运算符的嵌套
Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：
a if a>b else c if c>d else d
应该理解为：
a if a>b else ( c if c>d else d )
【实例】使用 Python 三目运算符判断两个数字的关系：
a = int( input("Input a: ") )
b = int( input("Input b: ") )
print("a大于b") if a>b else ( print("a小于b") if a
可能的运行结果：
Input a: 45↙
Input b: 100↙
a小于b
该程序是一个嵌套的三目运算符。程序先对 a>b 求值，如果该表达式为 True，程序就返回执行第一个表达式 print(“a大于b”)，否则将继续执行 else 后面的内容，也就是：
( print(“a小于b”) if a
进入该表达式后，先判断 a
Python运算符优先级和结合性一览表
优先级和结合性是 Python 表达式中比较重要的两个概念，它们决定了先执行表达式中的哪一部分。
Python 运算符优先级
所谓优先级，就是当多个运算符同时出现在一个表达式中时，先执行哪个运算符。
例如对于表达式a + b * c，Python 会先计算乘法再计算加法；b * c的结果为 8，a + 8的结果为 24，所以 d 最终的值也是 24。先计算*再计算+，说明*的优先级高于+。
Python 支持几十种运算符，被划分成将近二十个优先级，有的运算符优先级不同，有的运算符优先级相同，请看下表。
运算符说明 Python运算符 优先级 结合性 优先级顺序 小括号( )19无高 ︿ | | | | | | | | | | | | | | | | | | | | | | 低 索引运算符x[i] 或 x[i1: i2 [:i3]]18左 属性访问x.attribute17左 乘方**16右 按位取反~15右 符号运算符+（正号）、-（负号）14右 乘除*、/、//、%13左 加减+、-12左 位移>>、<<11左 按位与&10右 按位异或^9左 按位或|8左 比较运算符==、!=、>、>=、<、<=7左 is 运算符is、is not6左 in 运算符in、not in5左 逻辑非not4右 逻辑与and3左 逻辑或or2左 逗号运算符exp1, exp21左
结果表1中的运算符优先级，我们尝试分析下面表达式的结果：
4+4<<2
+的优先级是 12，<<的优先级是 11，+的优先级高于<<，所以先执行 4+4，得到结果 8，再执行 8<<2，得到结果 32，这也是整个表达式的最终结果。
像这种不好确定优先级的表达式，我们可以给子表达式加上( )，也就是写成下面的样子：
(4+4) << 2
这样看起来就一目了然了，不容易引起误解。
当然，我们也可以使用( )改变程序的执行顺序，比如：
4+(4<<2)
则先执行 4<<2，得到结果 16，再执行 4+16，得到结果20。
虽然 Python 运算符存在优先级的关系，但我不推荐过度依赖运算符的优先级，这会导致程序的可读性降低。因此，我建议读者：
不要把一个表达式写得过于复杂，如果一个表达式过于复杂，可以尝试把它拆分来书写。不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用( )来控制表达式的执行顺序。
Python 运算符结合性
所谓结合性，就是当一个表达式中出现多个优先级相同的运算符时，先执行哪个运算符：先执行左边的叫左结合性，先执行右边的叫右结合性。
例如对于表达式对于100 / 25 * 16，/和*的优先级相同，应该先执行哪一个呢？这个时候就不能只依赖运算符优先级决定了，还要参考运算符的结合性。/和*都具有左结合性，因此先执行左边的除法，再执行右边的乘法，最终结果是 64。
Python 中大部分运算符都具有左结合性，也就是从左到右执行；只有 ** 乘方运算符、单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们具有右结合性，也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性。
总结
当一个表达式中出现多个运算符时，Python 会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）