松滋网站定制,嵩明建设局网站,开发wap网站 转,全新的装修设计所有的编程语言都支持变量#xff0c;Python 也不例外。变量是编程的起点#xff0c;程序需要将数据存储到变量中。
变量在 Python 内部是有类型的#xff0c;比如 int、float 等#xff0c;但是我们在编程时无需关注变量类型#xff0c;所有的变量都无需提前声明#x…所有的编程语言都支持变量Python 也不例外。变量是编程的起点程序需要将数据存储到变量中。
变量在 Python 内部是有类型的比如 int、float 等但是我们在编程时无需关注变量类型所有的变量都无需提前声明赋值后就能使用。另外可以将不同类型的数据赋值给同一个变量所以变量的类型是可以改变的。
本章的另一个重点内容是运算符运算符将各种类型的数据连接在一起形成表达式。Python 的运算符丰富但不混乱比如 Python 支持自增和自减运算符但是它只支持一种形式就是前自增和前自减而取消了后自增和后自减避免了给程序员造成混乱。
一、Python变量的定义和使用
任何编程语言都需要处理数据比如数字、字符串、字符等我们可以直接使用数据也可以将数据保存到变量中方便以后使用。变量Variable可以看成一个小箱子专门用来“盛装”程序中的数据。每个变量都拥有独一无二的名字通过变量的名字就能找到变量中的数据。 从底层看程序中的数据最终都要放到内存内存条中变量其实就是这块内存的名字。 和变量相对应的是常量Constant它们都是用来“盛装”数据的小箱子不同的是变量保存的数据可以被多次修改而常量一旦保存某个数据之后就不能修改了。
1、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赋值给变量nabc 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/ #将字符串拼接的结果赋值给变量
2、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/
3、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 10type(num)
class intnum 15.8type(num)
class floatnum 20 15jtype(num)
class complextype(3*15.6)
class float
二、Python整数类型int详解
整数就是没有小数部分的数字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
class int
8888888888888888888888
class int
-7777777777777777777777
class int
x 是一个极大的数字y 是一个很小的数字Python 都能正确输出不会发生溢出这说明 Python 对整数的处理能力非常强大。 不管对于多大或者多小的整数Python 只用一种类型存储就是 int。
1、关于 Python 2.x
Python 3.x 只用 int 一种类型存储整数但是 Python 2.x 会使用 long 类型来存储较大的整数。以上代码在 Python 2.x 下的运行结果为
78
type int
8888888888888888888888
type long
-7777777777777777777777
type long
但是不管哪个版本的 Python都能轻松处理极大和极小的数字而且程序员也不用操心底层到底使用了 int 还是 long 类型。
2、整数的不同进制
在 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
本例的输出结果都是十进制整数。
3、数字分隔符
为了提高数字的的可读性Python 3.x 允许使用下划线_作为数字包括整数和小数的分隔符。通常每隔三个数字添加一个下划线类似于英文数字中的逗号。下划线不会影响数字本身的值。 【实例】使用下划线书写数字
click 1_301_547
distance 384_000_000
print(Python教程阅读量, click)
print(地球和月球的距离, distance)
运行结果
Python教程阅读量1301547
地球和月球的距离384000000
三、Python小数/浮点数float类型详解 在编程语言中小数通常以浮点数的形式存储。浮点数和定点数是相对的小数在存储过程中如果小数点发生移动就称为浮点数如果小数点不动就称为定点数。
如果你对浮点数的底层存储格式不了解请猛击小数在内存中是如何存储的揭秘诺贝尔奖级别的设计长篇神文
Python 中的小数有两种书写形式
1、十进制形式
这种就是我们平时看到的小数形式例如 34.6、346.0、0.346。书写小数时必须包含一个小数点否则会被 Python 当作整数处理。
2、指数形式
Python 小数的指数形式的写法为
aEn 或 aen
a 为尾数部分是一个十进制数n 为指数部分是一个十进制整数E或e是固定的字符用于分割尾数部分和指数部分。整个表达式等价于 。 指数形式的小数举例
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 和 doublefloat 能容纳的小数范围比较小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: class float
f2Value: 0.34557808421257
f2Type: class float
f3Value: 8.47e-26
f3Type: class float
f4Value: 3.456797451324568e26
f4Type: class float
f5Value: 120000.0
f5Type: class float
f6Value: 1.2300000000000002
f6Type: class float
从运行结果可以看出Python 能容纳极小和极大的浮点数。print 在输出浮点数时会根据浮点数的长度和大小适当的舍去一部分数字或者采用科学计数法。 f5 的值是 120000但是它依然是小数类型而不是整数类型。 让人奇怪的是 f612.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(c1c2: , c1c2)
print(c1*c2: , c1*c2)
运行结果
c1Value: (120.2j)
c1Type class complex
c2Value: (6-1.2j)
c1c2: (18-1j)
c1*c2: (72.24-13.2j)
可以发现复数在 Python 内部的类型是 complexPython 默认支持对复数的简单计算。
五、Python浮点数精度问题包含解决方案
为什么Python浮点类型存在误差
前面章节提到Python 中浮点类型之间的运算其结果并不像我们想象的那样例如 0.10.2
0.300000000000000040.10.1-0.2
0.00.10.10.1-0.3
5.551115123125783e-170.10.10.1-0.2
0.10000000000000003
为什么在计算这么简单的问题上计算机会出现这样的低级错误呢真正的原因在于十进制和数和二进制数的转换。 我们知道计算机其实是不认识十进制数它只认识二进制数也就是说当我们以十进制数进行运算的时候计算机需要将各个十进制数转换成二进制数然后进行二进制间的计算。 以类似 0.1 这样的浮点数为例如果手动将其转换成二进制其结果为 可以看到结果是无限循环的也就是说0.1 转换成二进制数后无法精确到等于十进制数的 0.1。同时由于计算机存储的位数是有限制的所以如果要存储的二进制位数超过了计算机存储位数的最大值其后续位数会被舍弃舍弃的原则是“0 舍 1 入”。 这种问题不仅在 Python 中存在在所有支持浮点数运算的编程语言中都会遇到它不光是 Python 的 Bug。 明白了问题产生的原因之后那么该如何解决呢就 Python 的浮点数运算而言大多数计算机每次计算误差不会超过 这对于大多数任务来说已经足够了。 如果需要非常精确的结果可以使用 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 中的字符串必须由双引号 或者单引号 包围具体格式为 字符串内容 字符串内容 字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。 下面都是合法的字符串 123789123abchttp://c.biancheng.net/python/C语言中文网成立8年了 Python 字符串中的双引号和单引号没有任何区别。而有些编程语言的双引号字符串可以解析变量单引号字符串一律原样输出例如 PHP 和 JavaScript。
1、处理字符串中的引号的
当字符串内容中出现引号时我们需要进行特殊处理否则 Python 会解析出错例如
Im a great coder!
由于上面字符串中包含了单引号此时 Python 会将字符串中的单引号与第一个单引号配对这样就会把I当成字符串而后面的m a great coder!就变成了多余的内容从而导致语法错误。 对于这种情况我们有两种处理方案
1对引号进行转义
在引号前面添加反斜杠\就可以对引号进行转义让 Python 把它作为普通文本对待例如
str1 I\m a great coder!
str2 引文双引号是\中文双引号是“
print(str1)
print(str2)
运行结果
Im a great coder! 引文双引号是中文双引号是“
2使用不同的引号包围字符串
如果字符串内容中出现了单引号那么我们可以使用双引号包围字符串反之亦然。例如
str1 Im a great coder! #使用双引号包围含有单引号的字符串
str2 引文双引号是中文双引号是“ #使用单引号包围含有双引号的字符串
print(str1)
print(str2)
运行结果和上面相同。
2、字符串的换行
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) 3、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/.
字符串内容前后多出了两个空行并且每一行的前面会多出四个空格。
4、Python原始字符串
Python 字符串中的反斜杠\有着特殊的作用就是转义字符例如上面提到的\和\我们将在《Python转义字符》一节中详细讲解这里大家先简单了解。 转义字符有时候会带来一些麻烦例如我要表示一个包含 Windows 路径D:\Program Files\Python 3.8\python.exe这样的字符串在 Python 程序中直接这样写肯定是不行的不管是普通字符串还是长字符串。因为\的特殊性我们需要对字符串中的每个\都进行转义也就是写成D:\\Program Files\\Python 3.8\\python.exe这种形式才行。 这种写法需要特别谨慎稍有疏忽就会出错。为了解决转义字符的问题Python 支持原始字符串。在原始字符串中\不会被当作转义字符所有的内容都保持“原汁原味”的样子。在普通字符串或者长字符串的开头加上r前缀就变成了原始字符串具体格式为 str1 r原始字符串内容 str2 r原始字符串内容 将上面的 Windows 路径改写成原始字符串的形式
rstr rD:\Program Files\Python 3.8\python.exe
print(rstr)
1原始字符串中的引号
如果普通格式的原始字符串中出现引号程序同样需要对引号进行转义否则 Python 照样无法对字符串的引号精确配对但是和普通字符串不同的是此时用于转义的反斜杠会变成字符串内容的一部分。 请看下面的代码
str1 rI\m a great coder!
print(str1)
输出结果
I\m a great coder!
需要注意的是Python 原始字符串中的反斜杠仍然会对引号进行转义因此原始字符串的结尾处不能是反斜杠否则字符串结尾处的引号会被转义导致字符串不能正确结束。 在 Python 中有两种方式解决这个问题一种方式是改用长字符串的写法不要使用原始字符串另一种方式是单独书写反斜杠这是接下来要重点说明的。 例如想表示D:\Program Files\Python 3.8\可以这样写
str1 rD:\Program Files\Python 3.8 \\
print(str1)
我们先写了一个原始字符串rD:\Program Files\Python 3.8紧接着又使用 写了一个包含转义字符的普通字符串Python 会自动将这两个字符串拼接在一起所以上面代码的输出结果是
D:\Program Files\Python 3.8\
由于这种写法涉及到了字符串拼接的相关知识这里读者只需要了解即可后续会对字符串拼接做详细介绍。
七、Python字符串使用哪种编码格式
在实践中很多初学者都遇到过“文件显示乱码”的情况其多数都是由于在打开文件时没有选对编码格式导致的。因此学习 Python 中的字符或字符串了解其底层的编码格式是非常有必要的。 鉴于有些读者并不了解什么是编码格式本节先从编码开始讲起。
1、什么是编码
虽然很多教程中有关于编码的定义但对初学者来说并不容易理解这里先举一个例子。古代打仗击鼓为号、鸣金收兵即把要传达给士兵的命令对应为公认的其他形式这就和编码有相似之处。 以发布进攻命令为例相比用嗓子喊敲鼓发出的声音传播的更远并且士兵听到后也不会引起歧义因此长官下达进攻命令后传令员就将此命令转化为对应的鼓声这个转化的过程称为编码由于士兵都接受过训练听到鼓声后他们可以将其转化为对应的进攻命令这个转化的过程称为解码。 需要说明的是此例只是形象地描述了编码和解码的原理真实的编码和解码过程比这要复杂的多。 了解了编码的含义之后接下来再介绍一下字符编码。
2、什么是字符编码
我们知道计算机是以二进制的形式来存储数据的即它只认识 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字符集的实现方式可以说它几乎已经一统江湖了。
3、Python使用哪种字符编码
了解了什么是编码以及什么是字符编码之后最后解决“Python 使用哪种字符编码”这个问题。 Python 3.x 中字符串采用的是 Unicode 字符集可以用如下代码来查看当前环境的编码格式 import syssys.getdefaultencoding()
utf-8
同时在 Python 3.x 中也可以用 ord() 和 chr() 函数实现字符和编码数字之间的转换例如 ord(Q)
81chr(81)
Qord(网)
32593chr(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 bhttp://c.biancheng.net/python/
print(b3: , b3)
print(b3[3])
print(b3[7:22])#为 bytes() 方法指定字符集
b4 bytes(C语言中文网8岁了, encodingUTF-8)
print(b4: , b4)#通过 encode() 方法将字符串转换成 bytes
b5 C语言中文网8岁了.encode(UTF-8)
print(b5: , b5)
运行结果
b3: bhttp://c.biancheng.net/python/
112
bc.biancheng.net
b4: bC\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x918\xe5\xb2\x81\xe4\xba\x86
b5: bC\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x918\xe5\xb2\x81\xe4\xba\x86
从运行结果可以发现对于非 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 相当于整数值 1False 相当于整数值 0。因此下边这些运算都是可以的 False1
1True1
2
注意这里只是为了说明 True 和 False 对应的整型值在实际应用中是不妥的不要这么用。 总的来说bool 类型就是用于代表某个事情的真对或假错如果这个事情是正确的用 True或 1代表如果这个事情是错误的用 False或 0代表。 【例 1】 53
True420
False
在 Python 中所有的对象都可以进行真假值的测试包括字符串、元组、列表、字典、对象等由于目前尚未学习因此这里不做过多讲述后续遇到时会做详细的介绍。
十、Python缓存重用机制
Python 缓冲机制是为提高程序执行的效率服务的实际上就是在 Python 解释器启动时从内存空间中开辟出一小部分用来存储高频使用的数据这样可以大大减少高频使用的数据创建时申请内存和销毁时撤销内存的开销。 Python 在存储数据时会根据数据的读取频繁程度以及内存占用情况来考虑是否按照一定的规则将数据存储缓存中。那么问题来了内存重用机制适用于哪些基本数据类型呢 表 1 罗列了 Python 是否将指定数据存入缓存中的规则 表 1 Python 缓存重用规则 数据类型是否可以重用生效范围范围在 [-5, 256] 之间的小整数如果之前在程序中创建过就直接存入缓存后续不再创建。全局bool 类型字符串类型数据大于 256 的整数只要在本代码块内创建过就直接缓存后续不再创建。本代码块大于 0 的浮点型小数小于 0 的浮点型小数不进行缓存每次都需要额外创建。小于 -5 的整数
下面直接通过一段程序来演示 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 没有对其缓存进行操作。
十一、Python input()函数获取用户输入的字符串
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: class str
bType: class str
resultValue: 10045
resultType: class str
↙表示按下回车键按下回车键后 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: class float
bType: class int
resultValue: 76.5
resultType: class float
1、关于 Python 2.x
上面讲解的是 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: type int
bType: type int
resultValue: 145
resultType: type int
十二、Python print()函数高级用法
前面使用 print() 函数时都只输出了一个变量但实际上 print() 函数完全可以同时输出多个变量而且它具有更多丰富的功能。 print() 函数的详细语法格式如下
print (value,...,sep,end\n,filesys.stdout,flushFalse)
从上面的语法格式可以看出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(沧海月明珠有泪,filef)
print(蓝田日暖玉生烟,filef)
f.close()
上面程序中open() 函数用于打开 demo.txt 文件接连 2 个 print 函数会将这 2 段字符串依次写入此文件最后调用 close() 函数关闭文件教程后续章节还会详细介绍关于文件操作的内容。 print() 函数的 flush 参数用于控制输出缓存该参数一般保持为 False 即可这样可以获得较好的性能。
十三、Python格式化字符串格式化输出
我们在《第一个Python程序——在屏幕上输出文本》中讲到过 print() 函数的用法这只是最简单最初级的形式print() 还有很多高级的玩法比如格式化输出这就是本节要讲解的内容。 熟悉C语言 printf() 函数的读者能够轻而易举学会 Python print() 函数它们是非常类似的。 print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出具体请看下表。 表 1 Python 转换说明符 转换说明符解释%d、%i转换为带符号的十进制整数%o转换为带符号的八进制整数%x、%X转换为带符号的十六进制整数%e转化为科学计数法表示的浮点数e 小写%E转化为科学计数法表示的浮点数E 大写%f、%F转化为十进制浮点数%g智能选择使用 %f 或 %e 格式%G智能选择使用 %F 或 %E 格式%c格式化字符及其 ASCII 码%r使用 repr() 函数将表达式转换为字符串%s使用 str() 函数将表达式转换为字符串
转换说明符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、指定最小输出宽度
当使用表1中的转换说明符时可以使用下面的格式指定最小输出宽度至少占用多少个字符的位置
%10d 表示输出的整数宽度至少为 10%20s 表示输出的字符串宽度至少为 20。 %s使用 str() 函数将表达式转换为字符串
请看下面的演示
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/.
从运行结果可以发现对于整数和字符串当数据的实际宽度小于指定宽度时会在左侧以空格补齐当数据的实际宽度大于指定宽度时会按照数据的实际宽度输出。 你看这里指定的只是最小宽度当数据的实际宽度足够时指定的宽度就没有实际意义了。
2、指定对齐方式
默认情况下print() 输出的数据总是右对齐的。也就是说当数据不够宽时数据总是靠右边输出而在左边补充空格以达到指定的宽度。Python 允许在最小宽度之前增加一个标志来改变对齐方式Python 支持的标志如下 Python 支持的标志 标志说明-指定左对齐表示输出的数字总要带着符号正数带负数带-。0表示宽度不足时补充 0而不是补充空格。
几点说明
对于整数指定左对齐时在右边补 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 .
3、指定小数精度
对于小数浮点数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.142
十四、Python转义字符及用法
在《Python字符串》一节中我们曾提到过转义字符就是那些以反斜杠\开头的字符。 ASCII 编码为每个字符都分配了唯一的编号称为编码值。在 Python 中一个 ASCII 字符除了可以用它的实体也就是真正的字符表示还可以用它的编码值表示。这种使用编码值来间接地表示字符的方式称为转义字符Escape Character。 如果你对 ASCII 编码不了解请猛击
ASCII 编码将英文存储到计算机ASCII 码一览表ASCII 码对照表完整版 转义字符以\0或者\x开头以\0开头表示后跟八进制形式的编码值以\x开头表示后跟十六进制形式的编码值Python 中的转义字符只能使用八进制或者十六进制。具体格式如下
\0dd
\xhh
dd 表示八进制数字hh 表示十六进制数字。 ASCII 编码共收录了 128 个字符\0和\x后面最多只能跟两位数字所以八进制形式\0并不能表示所有的 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: \061\062\063
str2 Hex: \x31\x32\x33\x78\x79\x7A
print(str1)
print(str2)
运行结果
Oct: 123
Hex: 123xyz
注意使用八进制形式的转义字符没法表示 xyz因为它们的编码值转换成八进制以后有三位。 对于 ASCII 编码0~31十进制范围内的字符为控制字符它们都是看不见的不能在显示器上显示甚至无法从键盘输入只能用转义字符的形式来表示。不过直接使用 ASCII 码记忆不方便也不容易理解所以针对常用的控制字符C语言又定义了简写方式完整的列表如下。 表 1 Python 支持的转义字符 转义字符说明\n换行符将光标位置移到下一行开头。\r回车符将光标位置移到本行开头。\t水平制表符也即 Tab 键一般相当于四个空格。\a蜂鸣器响铃。注意不是喇叭发声现在的计算机很多都不带蜂鸣器了所以响铃不一定有效。\b退格Backspace将光标位置移到前一列。\\反斜线\单引号\双引号\在字符串行尾的续行符即一行未完转到下一行继续写。 转义字符在书写形式上由多个字符组成但 Python 将它们看作是一个整体表示一个字符。 Python 转义字符综合示例
#使用\t排版
str1 网站\t\t域名\t\t\t年龄\t\t价值
str2 C语言中文网\tc.biancheng.net\t\t8\t\t500W
str3 百度\t\twww.baidu.com\t\t20\t\t500000W
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.0print(您的身高height)
Traceback (most recent call last):File pyshell#1, line 1, in moduleprint(您的身高height)
TypeError: must be str, not float
你会发现这是错误的解释器提示我们字符串和浮点类型变量不能直接相连需要提前将浮点类型变量 height 转换为字符串才可以。 庆幸的是Python 已经为我们提供了多种可实现数据类型转换的函数如表 1 所示。 表 1 常用数据类型转换函数 函 数作 用int(x)将 x 转换成整数类型float(x)将 x 转换成浮点数类型complex(real[,imag])创建一个复数str(x)将 x 转换为字符串repr(x)将 x 转换为表达式字符串eval(str)计算在字符串中的有效 Python 表达式并返回一个对象chr(x)将整数 x 转换为一个字符ord(x)将一个字符 x 转换为它对应的整数值hex(x)将一个整数 x 转换为一个十六进制字符串oct(x)将一个整数 x 转换为一个八进制的字符串 需要注意的是在使用类型转换函数时提供给它的数据必须是有意义的。例如int() 函数无法将一个非数字字符串转换成整数 int(123) #转换成功
123int(123个) #转换失败
Traceback (most recent call last):File pyshell#3, line 1, in moduleint(123个)
ValueError: invalid literal for int() with base 10: 123个十六、Python算术运算符及用法详解
算术运算符也即数学运算符用来对数字进行数学运算比如加减乘除。下表列出了 Python 支持所有基本算术运算符。 表 1 Python 常用算术运算符 运算符说明实例结果加12.45 1527.45-减4.56 - 0.264.3*乘5 * 3.618.0/除法和数学中的规则一样7 / 23.5//整除只保留商的整数部分7 // 23%取余即返回除法的余数7 % 21**幂运算/次方运算即返回 x 的 y 次方2 ** 416即 24
接下来将对表 1 中各个算术运算符的用法逐一讲解。
1、 加法运算符
加法运算符很简单和数学中的规则一样请看下面的代码
m 10
n 97
sum1 m nx 7.2
y 15.3
sum2 x yprint(sum1%d, sum2%.2f % (sum1, sum2) )
运行结果
sum1107, sum222.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 转换成字符串。
2、- 减法运算符
减法运算也和数学中的规则相同请看代码
n 45
m -nx -83.5
y -xprint(m, ,, y)
运行结果
-45 , 83.5
求负
-除了可以用作减法运算之外还可以用作求负运算正数变负数负数变正数请看下面的代码
n 45
n_neg -nf -83.5
f_neg -fprint(n_neg, ,, f_neg)
运行结果
-45 , 83.5
注意单独使用是无效的不会改变数字的值例如
n 45
m nx -83.5
y xprint(m, ,, y)
运行结果
45 , -83.5
3、乘法运算符
乘法运算也和数学中的规则相同请看代码
n 4 * 25
f 34.5 * 2
print(n, ,, f)
运行结果
100 , 69.0
重复字符串
*除了可以用作乘法运算还可以用来重复字符串也即将 n 个同样的字符串连接起来请看代码
str1 hello
print(str1 * 4)
str1 hello print(str1 * 4)
运行结果
hello hello hello hello
4、/ 和 // 除法运算符
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/7print ----------------#小数除法
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 增加了//运算符用以规范除法运算的行为。
5、% 求余运算符
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
从运行结果可以发现两点
只有当第二个数字是负数时求余的结果才是负数。换句话说求余结果的正负和第一个数字没有关系只由第二个数字决定。%两边的数字都是整数时求余的结果也是整数但是只要有一个数字是小数求余的结果就是小数。
本例中小数求余的四个结果都不精确而是近似值这和小数在底层的存储有关系有兴趣的读者请猛击《小数在内存中是如何存储的揭秘诺贝尔奖级别的设计长篇神文》了解更多。
6、** 次方乘方运算符
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))
运行结果
----次方运算----
3**4 81
2**5 32
----开方运算----
81**(1/4) 3.0
32**(1/5) 2.0
十七、Python赋值运算符入门必读
赋值运算符用来把右侧的值传递给左侧的变量或者常量可以直接将右侧的值交给左侧的变量也可以进行某些运算后再交给左侧的变量比如加减乘除、函数调用、逻辑运算等。Python 中最基本的赋值运算符是等号结合其它运算符还能扩展出更强大的赋值运算符。
1、基本赋值运算符
是 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
1连续赋值
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。
2 和 和 是两个不同的运算符 用来赋值而 用来判断两边的值是否相等千万不要混淆。
2、扩展后的赋值运算符
还可与其他运算符包括算术运算符、位运算符和逻辑运算符相结合扩展成为功能更加强大的赋值运算符如表 1 所示。扩展后的赋值运算符将使得赋值表达式的书写更加优雅和方便。 表 1 Python 扩展赋值运算符 运算符说 明用法举例等价形式最基本的赋值运算x yx y加赋值x yx x y-减赋值x - yx x - y*乘赋值x * yx x * y/除赋值x / yx x / y%取余数赋值x % yx x % y**幂赋值x ** yx x ** y//取整数赋值x // yx x // y按位与赋值x yx x y|按位或赋值x | yx x | y^按位异或赋值x ^ yx x ^ y左移赋值x yx x y这里的 y 指的是左移的位数右移赋值x yx x y这里的 y 指的是右移的位数
这里举个简单的例子
n1 100
f1 25.5n1 - 80 #等价于 n1n1-80
f1 * n1 - 10 #等价于 f1f1*( n1 - 10 )print(n1%d % n1)
print(f1%.2f % f1)
运行结果为
n120
f1255.00
通常情况下只要能使用扩展后的赋值运算符都推荐使用这种赋值运算符。 但是请注意这种赋值运算符只能针对已经存在的变量赋值因为赋值过程中需要变量本身参与运算如果变量没有提前定义它的值就是未知的无法参与运算。例如下面的写法就是错误的
n 10
该表达式等价于 n n 10n 没有提前定义所以它不能参与加法运算。
十八、Python位运算符详解
Python 位运算按照数据在内存中的二进制位Bit进行操作它一般用于底层开发算法设计、驱动、图像处理、单片机等在应用层开发Web 开发、Linux 运维等中并不常见。想加快学习进度或者不关注底层开发的读者可以先跳过本节以后需要的话再来学习。 Python 位运算符只能用来操作整数类型它按照整数在内存中的二进制形式进行计算。Python 支持的位运算符如表 1 所示。 表 1 Python 位运算符一览表 位运算符说明使用形式举 例按位与a b4 5|按位或a | b4 | 5^按位异或a ^ b4 ^ 5~按位取反~a~4按位左移a b4 2表示整数 4 按位左移 2 位按位右移a b4 2表示整数 4 按位右移 2 位
1、 按位与运算符
按位与运算符的运算规则是只有参与运算的两个位都为 1 时结果才为 1否则为 0。例如11为 100为 010也为 0这和逻辑运算符非常类似。 表 2 Python 运算符的规则 第一个Bit位第二个Bit位结果000010100111
例如95可以转换成如下的运算 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 在内存中的存储
运算符会对参与运算的两个整数的所有二进制位进行运算95的结果为 1。 又如-95可以转换成如下的运算 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 在内存中的存储
-95的结果是 5。 不了解整数在内存中如何存储的读者请猛击整数在内存中是如何存储的为什么它堪称天才般的设计 再强调一遍运算符操作的是数据在内存中存储的原始二进制位而不是数据本身的二进制形式其他位运算符也一样。
以-95为例-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 % (95) )
print(%X % (-95) )
print(%X % (n0XFFFF) )
运行结果
1
5
2D
2、| 按位或运算符
按位或运算符|的运算规则是两个二进制位有一个为 1 时结果就为 1两个都为 0 时结果才为 0。例如1|1为 10|0为01|0 为1这和逻辑运算中的||非常类似。 表 3 Python | 运算符的规则 第一个Bit位第二个Bit位结果000011101111
例如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
3、^按位异或运算符
按位异或运算^的运算规则是参与运算的两个二进制位不同时结果为 1相同时结果为 0。例如0^1为 10^0为 01^1为 0。 表 4 Python ^ 运算符的规则 第一个Bit位第二个Bit位结果000011101110
例如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
4、~按位取反运算符
按位取反运算符~为单目运算符只有一个操作数右结合性作用是对参与运算的二进制位取反。例如~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
5、左移运算符
Python 左移运算符用来把操作数的各个二进制位全部左移若干位高位丢弃低位补 0。 例如93可以转换为如下的运算 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 9 在内存中的存储
-----------------------------------------------------------------------------------0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 72 在内存中的存储
所以93的结果为 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 % (93) )
print(%X % ((-9)3) )
print(%X % (93) )print(%X % ((-9)3) )
运行结果
72
-72
6、右移运算符
Python 右移运算符用来把操作数的各个二进制位全部右移若干位低位丢弃高位补 0 或 1。如果数据的最高位是 0那么就补 0如果最高位是 1那么就补 1。 例如93可以转换为如下的运算 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 9 在内存中的存储
-----------------------------------------------------------------------------------0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 1 在内存中的存储
所以93的结果为 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 % (93) )
print(%X % ((-9)3) )
运行结果
1
-2
十九、Python比较运算符关系运算符
比较运算符也称关系运算符用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的则返回 True真反之则返回 False假。 True 和 False 都是 bool 类型它们专门用来表示一件事情的真假或者一个表达式是否成立我们将在《Python bool布尔类型》中详细讲解。 Python 支持的比较运算符如表 1 所示。 表 1 Python 比较运算符汇总 比较运符说明大于如果前面的值大于后面的值则返回 True否则返回 False。小于如果前面的值小于后面的值则返回 True否则返回 False。等于如果两边的值相等则返回 True否则返回 False。大于等于等价于数学中的 ≥如果前面的值大于或者等于后面的值则返回 True否则返回 False。小于等于等价于数学中的 ≤如果前面的值小于或者等于后面的值则返回 True否则返回 False。!不等于等价于数学中的 ≠如果!两边的值不相等则返回 True否则返回 False。is判断两个变量所引用的对象是否相同如果相同则返回 True否则返回 False。is not判断两个变量所引用的对象是否不相同如果不相同则返回 True否则返回 False。
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)
运行结果False是否小于True True True是否等于True False
89是否大于100 False
24*5是否大于等于76 True
86.5是否等于86.5 True
34是否等于34.0 True
False是否小于True True
True是否等于True False 和 is 的区别
初学 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 也有类似的逻辑运算请看下表 表 1 Python 逻辑运算符及功能 逻辑运算符含义基本格式说明and逻辑与运算等价于数学中的“且”a and b当 a 和 b 两个表达式都为真时a and b 的结果才为真否则为假。or逻辑或运算等价于数学中的“或”a or b当 a 和 b 两个表达式都为假时a or b 的结果才是假否则为真。not逻辑非运算等价于数学中的“非”not a如果 a 为真那么 not a 的结果为假如果 a 为假那么 not a 的结果为真。相当于对 a 取反。
逻辑运算符一般和关系运算符结合使用例如
146 and 45.6 90
146 结果为 True成立45.690 结果为 False不成立所以整个表达式的结果为 False也即不成立。 再看一个比较实用的例子
age int(input(请输入年龄))
height int(input(请输入身高))if age18 and age30 and height 170 and height 185 :
print(恭喜你符合报考飞行员的条件)
else:
print(抱歉你不符合报考飞行员的条件)
可能的运行结果
请输入年龄23↙
请输入身高178↙
恭喜你符合报考飞行员的条件
1、打脸某些 Python 教程
有些不负责任的 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 值。
2、逻辑运算符的本质
在 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 ab:max a;
else:max b;
但是 Python 提供了一种更加简洁的写法如下所示
max a if ab else b
这是一种类似于其它编程语言中三目运算符? :的写法。Python 是一种极简主义的编程语言它没有引入? :这个新的运算符而是使用已有的 if else 关键字来实现相同的功能。 使用 if else 实现三目运算符条件运算符的格式如下 exp1 if contion else exp2 condition 是判断条件exp1 和 exp2 是两个表达式。如果 condition 成立结果为真就执行 exp1并把 exp1 的结果作为整个表达式的结果如果 condition 不成立结果为假就执行 exp2并把 exp2 的结果作为整个表达式的结果。 前面的语句max a if ab else b的含义是
如果 ab 成立就把 a 作为整个表达式的值并赋给变量 max如果 a b 不成立就把 b 作为整个表达式的值并赋给变量 max。
三目运算符的嵌套
Python 三目运算符支持嵌套如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对例如
a if ab else c if cd else d
应该理解为
a if ab else ( c if cd else d )
【实例】使用 Python 三目运算符判断两个数字的关系
a int( input(Input a: ) )
b int( input(Input b: ) )
print(a大于b) if ab else ( print(a小于b) if ab else print(a等于b) )
可能的运行结果
Input a: 45↙
Input b: 100↙
a小于b
该程序是一个嵌套的三目运算符。程序先对 ab 求值如果该表达式为 True程序就返回执行第一个表达式 print(a大于b)否则将继续执行 else 后面的内容也就是
( print(a小于b) if ab else print(a等于b) )
进入该表达式后先判断 ab 是否成立如果 ab 的结果为 True将执行 print(a小于b)否则执行 print(a等于b)。
二十二、Python运算符优先级和结合性一览表
优先级和结合性是 Python 表达式中比较重要的两个概念它们决定了先执行表达式中的哪一部分。
1、Python 运算符优先级
所谓优先级就是当多个运算符同时出现在一个表达式中时先执行哪个运算符。 例如对于表达式a b * cPython 会先计算乘法再计算加法b * c的结果为 8a 8的结果为 24所以 d 最终的值也是 24。先计算*再计算说明*的优先级高于。 Python 支持几十种运算符被划分成将近二十个优先级有的运算符优先级不同有的运算符优先级相同请看下表。 表 1 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中的运算符优先级我们尝试分析下面表达式的结果
442
的优先级是 12的优先级是 11的优先级高于所以先执行 44得到结果 8再执行 82得到结果 32这也是整个表达式的最终结果。 像这种不好确定优先级的表达式我们可以给子表达式加上( )也就是写成下面的样子
(44) 2
这样看起来就一目了然了不容易引起误解。 当然我们也可以使用( )改变程序的执行顺序比如
4(42)
则先执行 42得到结果 16再执行 416得到结果20。 虽然 Python 运算符存在优先级的关系但我不推荐过度依赖运算符的优先级这会导致程序的可读性降低。因此我建议读者
不要把一个表达式写得过于复杂如果一个表达式过于复杂可以尝试把它拆分来书写。不要过多地依赖运算符的优先级来控制表达式的执行顺序这样可读性太差应尽量使用( )来控制表达式的执行顺序。
2、Python 运算符结合性
所谓结合性就是当一个表达式中出现多个优先级相同的运算符时先执行哪个运算符先执行左边的叫左结合性先执行右边的叫右结合性。 例如对于表达式对于100 / 25 * 16/和*的优先级相同应该先执行哪一个呢这个时候就不能只依赖运算符优先级决定了还要参考运算符的结合性。/和*都具有左结合性因此先执行左边的除法再执行右边的乘法最终结果是 64。Python 中大部分运算符都具有左结合性也就是从左到右执行只有 ** 乘方运算符、单目运算符例如 not 逻辑非运算符、赋值运算符和三目运算符例外它们具有右结合性也就是从右向左执行。表 1 中列出了所有 Python 运算符的结合性。
3、总结
当一个表达式中出现多个运算符时Python 会先比较各个运算符的优先级按照优先级从高到低的顺序依次执行当遇到优先级相同的运算符时再根据结合性决定先执行哪个运算符如果是左结合性就先执行左边的运算符如果是右结合性就先执行右边的运算符。
