变量赋值
name = value
name 表示变量名;value 表示值,也就是要存储的数据。
在强类型的编程语言中,定义变量时要指明变量的类型,而且赋值的数据也必须是相同类型的,C语言、C++、Java(是强类型语言的代表。
和强类型语言相对应的是弱类型语言,Python、JavaScript、PHP等脚本语言一般都是弱类型的。
弱类型语言特点
注意,弱类型并不等于没有类型!弱类型是说在书写代码时不用刻意关注类型,但是在编程语言的内部仍然是有类型的。我们可以使用type()
内置函数类检测某个变量或者表达式的类型。
>>> num = 10
>>> type(num)
<class 'int'>
>>> num = 15.8
>>> type(num)
<class 'float'>
>>> num = 20 + 15j
>>> type(num)
<class 'complex'>
>>> type(3*15.6)
<class 'float'>
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。
在 Python 中,可以使用多种进制来表示整数:
我们平时常见的整数就是十进制形式,它由 0~9 共十个数字排列组合而成。
注意,使用十进制形式的整数不能以 0 作为开头,除非这个数值本身就是 0。
由 0 和 1 两个数字组成,书写时以0b
或0B
开头。例如,101 对应十进制数是 5。
八进制整数由 0~7 共八个数字组成,以0o
或0O
开头。注意,第一个符号是数字 0,第二个符号是大写或小写的字母 O。
在 Python 2.x 中,八进制数字还可以直接以0
(数字零)开头。
由 0~9 十个数字以及 A~F(或 a~f)六个字母组成,书写时以0x
或0X
开头。
#十六进制
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
float
小数/浮点数类型在编程语言中,小数通常以浮点数的形式存储。浮点数和定点数是相对的:小数在存储过程中如果小数点发生移动,就称为浮点数;如果小数点不动,就称为定点数。
Python中小数有两种书写形式
十进制形式:34.6、346.0、0.346
书写小数时必须包含一个小数点,否则会被 Python 当作整数处理。
指数形式
aEn 或 aen
a 为尾数部分,是一个十进制数;n 为指数部分,是一个十进制整数;E
或e
是固定的字符,用于分割尾数部分和指数部分。整个表达式等价于 a×10n。
指数形式的小数举例:
**只要写成指数形式就是小数,即使它的最终值看起来像一个整数。**例如 14E3 等价于 14000,但 14E3 是一个小数。
**Python 只有一种小数类型,就是 float。**C语言有两种小数类型,分别是 float 和 double:float 能容纳的小数范围比较小,double 能容纳的小数范围比较大。
应用
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.456797451324568e+26
f4Type: <class 'float'>
f5Value: 120000.0
f5Type: <class 'float'>
f6Value: 1.2300000000000002
f6Type: <class 'float'>
从运行结果可以看出,Python 能容纳极小和极大的浮点数。print 在输出浮点数时,会根据浮点数的长度和大小适当的舍去一部分数字,或者采用科学计数法。
f5 的值是 1让人奇怪的是 f6,12.3*0.1
的计算结果很明显是 1.23,但是 print 的输出却不精确。这是因为小数在内存中是以二进制形式存储的,小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字,无论如何都不能精确表示,所以小数的计算结果一般都是不精确的。0000,但是它依然是小数类型,而不是整数类型。
complex
复数类型复数(Complex)是 Python的内置类型,直接书写即可。换句话说,Python 语言本身就支持复数,而不依赖于标准库或者第三方库。
复数由实部(real)和虚部(imag)构成,在 Python 中,复数的虚部以j
或者J
作为后缀,具体格式为:
a + bj
a 表示实部,b 表示虚部。
使用
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 <class 'complex'>
c2Value: (6-1.2j)
c1+c2: (18-1j)
c1*c2: (72.24-13.2j)
可以发现,复数在 Python 内部的类型是 complex,Python 默认支持对复数的简单计算。
若干个字符的集合就是一个字符串(String)。Python中的字符串必须由双引号" "
或者单引号' '
包围,具体格式为:
"字符串内容"
'字符串内容'
字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。
Python 字符串中的双引号和单引号没有任何区别。
当字符串内容中出现引号时,我们需要进行特殊处理,否则 Python 会解析出错,例如:
'I'm a great coder!'
由于上面字符串中包含了单引号,此时 Python 会将字符串中的单引号与第一个单引号配对,这样就会把'I'
当成字符串,而后面的m a great coder!'
就变成了多余的内容,从而导致语法错误。
处理方案
对引号进行转义
在引号前面添加反斜杠\
就可以对引号进行转义,让 Python 把它作为普通文本对待。
使用不同的引号包围字符串
如果字符串内容中出现了单引号,那么我们可以使用双引号包围字符串,反之亦然。
Python 不是格式自由的语言,它**对程序的换行、缩进都有严格的语法要求。**要想换行书写一个比较长的字符串,必须在行尾添加反斜杠\
。
s2 = 'It took me six months to write this Python tutorial. \
Please give me more support. \
I will keep it updated.'
运行结果
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 解释器并不会忽略长字符串,也会按照语法解析,只是长字符串起不到实际作用而已。
当程序中有大段文本内容需要定义成字符串时,优先推荐使用长字符串形式,因为这种形式非常强大,可以在字符串中放置任何内容,包括单引号和双引号。
longstr = '''It took me 6 months to write this Python tutorial.
Please give me a to 'thumb' to keep it updated.'''
print(longstr)
长字符串中的换行、空格、缩进等空白符都会原样输出。
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"""原始字符串内容"""
应用
rstr = r'D:\Program Files\Python 3.8\python.exe'
print(rstr)
原始字符串的引号
如果普通格式的原始字符串中出现引号,程序同样需要对引号进行转义,否则 Python 照样无法对字符串的引号精确配对;但是和普通字符串不同的是,此时用于转义的反斜杠会变成字符串内容的一部分。
demo
str1 = r'I\'m a good coder!'
print(str1)
运行结果
I\'m a good coder!
Python 原始字符串中的反斜杠仍然会对引号进行转义,因此原始字符串的结尾处不能是反斜杠,否则字符串结尾处的引号会被转义,导致字符串不能正确结束
那我们该怎么写D:\Program Files\Python 3.8\
呢?
可以这样
str1 = r'D:\Program Files\Python 3.8' '\\'
print(str1)
运行结果
D:\Program Files\Python 3.8\
我们先写了一个原始字符串r'D:\Program Files\Python 3.8'
,紧接着又使用'\\'
写了一个包含转义字符的普通字符串,Python 会自动将这两个字符串拼接在一起。
由于这种写法涉及到了字符串拼接的相关知识,这里读者只需要了解即可,后续会对字符串拼接做详细介绍。
注意上面的波浪线信息。
PEP 8: W605 invalid escape sequence '\P'
所以使用原始字符串更好,可以解决转义字符的问题。
bytes
类型bytes 类型用来表示一个字节串。“字节串“不是编程术语,是我自己“捏造”的一个词,用来和字符串相呼应。
bytes 是 Python 3.x 新增的类型,在 Python 2.x 中是不存在的。
字节串bytes和字符串string对比
bytes 只负责以字节序列的形式(二进制形式)来存储数据,至于这些数据到底表示什么内容(字符串、数字、图片、音频等),完全由程序的解析方式决定。
说白了,bytes 只是简单地记录内存中的原始数据,至于如何使用这些数据,bytes 并不在意,你想怎么使用就怎么使用,bytes 并不约束你的行为。
bytes 类型的数据非常适合在互联网上传输,可以用于网络通信编程;bytes 也可以用来存储图片、音频、视频等二进制格式的文件。
字符串 ——> 字节串
字符串和 bytes 存在着千丝万缕的联系,我们可以通过字符串来创建 bytes 对象,或者说将字符串转换成 bytes 对象。三种方法:
b
前缀就可以转换成 bytes。【示例】使用不同方式创建bytes对象
# 通过构造函数创建空 bytes
b1 = bytes()
# 通过空字符串构建空 bytes
b2 = b''
print("b1: ", b1)
print("b2: ", b2)
# 通过b前缀将字符串转换成 bytes
b3 = b'http://c.biancheng.net/python/'
print("b3: ", b3)
print(b3[3])
print(b3[7:22])
# 为 bytes() 方法指定字符集
b4 = bytes('我8岁了', encoding='UTF-8')
print("b4: ", b4)
运行结果
b1: b''
b2: b''
b3: b'http://c.biancheng.net/python/'
112
b'c.biancheng.net'
b4: b'\xe6\x88\x918\xe5\xb2\x81\xe4\xba\x86'
b5: b'\xe6\x88\x918\xe5\xb2\x81\xe4\xba\x86'
对于非 ASCII 字符,print 输出的是它的字符编码值(十六进制形式),而不是字符本身。非 ASCII 字符一般占用两个字节以上的内存,而 bytes 是按照单个字节来处理数据的,所以不能一次处理多个字节。
字节串 ——> 字符串
decode() 方法,通过该方法可以将 bytes 对象转换为字符串。
# 通过decode()方法将bytes转换成字符串
str1 = b5.decode('UTF-8')
print("str1: ", str1)
运行结果
str1: 我8岁了
bool
类型True
和False
是 Python 中的关键字,当作为 Python 代码输入时,一定要注意字母的大小写,否则解释器会报错。
值得一提的是,布尔类型可以当做整数来对待,即 True 相当于整数值 1,False 相当于整数值 0。
>>> True + 1
2
>>> False + 1
1
总的来说,bool 类型就是用于代表某个事情的真(对)或假(错),如果这个事情是正确的,用 True(或 1)代表;如果这个事情是错误的,用 False(或 0)代表。
input
函数:获取用户输入的字符串内置函数,用于从控制台读取用户输入的内容。。input() 函数总是以字符串的形式来处理用户输入的内容,所以用户输入的内容可以包含任何字符。
** input
用法**:
str = input(tipmsg)
说明:
【示例】
a = input("Enter a number: ")
b = input("Enter another number: ")
print("aType: ", type(a))
print("bType: ", type(b))
result = a+b
print("result: ", result)
print("resultType: ", type(result))
运行结果
Enter a number: 2
Enter another number: 3
aType: <class 'str'>
bType: <class 'str'>
result: 23
resultType: <class 'str'>
本例中我们输入了两个整数,希望计算出它们的和,但是事与愿违,Python 只是它们当成了字符串,+
起到了拼接字符串的作用,而不是求和的作用。
使用 Python 内置函数将字符串转换成想要的类型
【修改上述demo】
a = input("Enter a number: ")
b = input("Enter another number: ")
a = float(a)
b = float(b)
print("aType: ", type(a))
print("bType: ", type(b))
result = a+b
print("result: ", result)
print("resultType: ", type(result))
运行结果
Enter a number: 2
Enter another number: 3
aType: <class 'float'>
bType: <class 'float'>
result: 5.0
resultType: <class 'float'>
print()函数高级用法
** print()
函数详细语法格式 **:
print (value,...,sep='',end='\n',file=sys.stdout,flush=False)
例如
user_name = 'Charlie'
user_age = 8
#同时输出多个变量和字符串
print("读者名:",user_name,"年龄:",user_age)
运行结果
读者名: Charlie 年龄: 8
#同时输出多个变量和字符串,指定分隔符print
("读者名:" ,user_name,"年龄:",user_age,sep='|')
运行上面代码,可以看到如下输出结果:
读者名:|Charlie|年龄:|8
#设置end 参数,指定输出之后不再换行
print(40,'\t',end="")
print(5O,'\t',end="")
print(60,'\t',end="")
运行结果
40 50 60
f = open("demo.txt","w")#打开文件以便写入
print('沧海月明珠有泪',file=f)
print('蓝回日暖玉生烟',file=f)
f.close()
print() 函数使用以%
开头的转换说明符对各种类型的数据进行格式化输出。
转换说明符 | 解释 |
---|---|
%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)**只是一个占位符,它会被后面表达式(变量、常量、数字、字符串、加减乘除等各种形式)的值代替。
demo
age = 8
print("已经%d岁了!" % age)
在 print() 函数中,由引号包围的是格式化字符串,它相当于一个字符串模板,可以放置一些转换说明符(占位符)。本例的格式化字符串中包含一个%d
说明符,它最终会被后面的 age 变量的值所替代。
中间的%
是一个分隔符,它前面是格式化字符串,后面是要输出的表达式。
格式化字符串中也可以包含多个转换说明符,这个时候也得提供多个表达式,用以替换对应的转换说明符;多个表达式必须使用小括号( )
包围起来。
demo
print("%s已经%d岁了,它的网址是%s。" % (name, age, url))
总之,有几个占位符,后面就得跟着几个表达式。
对于整数和字符串,当数据的实际宽度小于指定宽度时,会在左侧以空格补齐;当数据的实际宽度大于指定宽度时,会按照数据的实际宽度输出。
n = 1234567
print("n(10): %3d" % n)
print("n(10): %10d" % n)
//运行结果
n(10): 1234567
n(10): 1234567
默认情况下,print() 输出的数据总是右对齐的。也就是说,当数据不够宽时,数据总是靠右边输出,而在左边补充空格以达到指定的宽度。Python 允许在最小宽度之前增加一个标志来改变对齐方式,Python 支持的标志如下:
标志 | 说明 |
---|---|
- | 指定左对齐 |
+ | 表示输出的数字总要带着符号;正数带+ ,负数带- 。 |
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 .
对于小数(浮点数),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
转义字符以\0
或者\x
开头,以\0
开头表示后跟八进制形式的编码值,以\x
开头表示后跟十六进制形式的编码值,Python 中的转义字符只能使用八进制或者十六进制。具体格式如下:
\0dd
\xhh
dd 表示八进制数字,hh 表示十六进制数字。
ASCII 编码共收录了 128 个字符,\0
和\x
后面最多只能跟两位数字,所以八进制形式\0
并不能表示所有的 ASCII 字符,只有十六进制形式\x
才能表示所有 ASCII 字符。
我们一直在说 ASCII 编码,没有提及 Unicode、GBK、Big5 等其它编码(字符集),是因为 Python 转义字符只对 ASCII 编码(128 个字符)有效,超出范围的行为是不确定的。
str1 = "Oct: \061\062\063"
str2 = "Hex: \x31\x32\x33\x78\x79\x7A"
print(str1)
print(str2)
运行结果
Oct: 123
Hex: 123xyz
**Python 支持的转义字符 **
转义字符 | 说明 |
---|---|
\n | 换行符,将光标位置移到下一行开头。 |
\r | 回车符,将光标位置移到本行开头。 |
\t | 水平制表符,也即 Tab 键,一般相当于四个空格。 |
\a | 蜂鸣器响铃。注意不是喇叭发声,现在的计算机很多都不带蜂鸣器了,所以响铃不一定有效。 |
\b | 退格(Backspace),将光标位置移到前一列。 |
\ | 反斜线 |
’ | 单引号 |
" | 双引号 |
\ | 在字符串行尾的续行符,即一行未完,转到下一行继续写。 |
函 数 | 作 用 |
---|---|
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 转换为一个八进制的字符串 |
运算符 | 说明 | 实例 | 结果 |
---|---|---|---|
+ | 加 | 12.45 + 15 | 27.45 |
- | 减 | 4.56 - 0.26 | 4.3 |
* | 乘 | 5 * 3.6 | 18.0 |
/ | 除法(和数学中的规则一样) | 7 / 2 | 3.5 |
// | 整除(只保留商的整数部分) | 7 // 2 | 3 |
% | 取余,即返回除法的余数 | 7 % 2 | 1 |
** | 幂运算/次方运算,即返回 x 的 y 次方 | 2 ** 4 | 16,即 24 |
Python 支持/
和//
两个除法运算符,但它们之间是有区别的:
/
表示普通除法,使用它计算出来的结果和数学中的计算结果相同。//
表示整除,只保留结果的整数部分,舍弃小数部分;注意是直接丢掉小数部分,而不是四舍五入。/
的计算结果总是小数,不管是否能除尽,也不管参与运算的是整数还是小数。//
结果才是小数,否则就是整数。需要注意的是,除数始终不能为 0,除以 0 是没有意义的,这将导致 ZeroDivisionError
错误。在某些编程语言中,除以 0 的结果是无穷大(包括正无穷大和负无穷大)。
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))
运算符 | 说 明 | 用法举例 | 等价形式 |
---|---|---|---|
= | 最基本的赋值运算 | x = y | x = y |
+= | 加赋值 | x += y | x = x + y |
-= | 减赋值 | x -= y | x = x - y |
*= | 乘赋值 | x *= y | x = x * y |
/= | 除赋值 | x /= y | x = x / y |
%= | 取余数赋值 | x %= y | x = x % y |
**= | 幂赋值 | x **= y | x = x ** y |
//= | 取整数赋值 | x //= y | x = x // y |
&= | 按位与赋值 | x &= y | x = x & y |
|= | 按位或赋值 | x |= y | x = x | y |
^= | 按位异或赋值 | x ^= y | x = x ^ y |
<<= | 左移赋值 | x <<= y | x = x << y,这里的 y 指的是左移的位数 |
>>= | 右移赋值 | x >>= y | x = x >> y,这里的 y 指的是右移的位数 |
Python 位运算符只能用来操作整数类型,它按照整数在内存中的二进制形式进行计算。
位运算符 | 说明 | 使用形式 | 举 例 |
---|---|---|---|
& | 按位与 | a & b | 4 & 5 |
| | 按位或 | a | b | 4 | 5 |
^ | 按位异或 | a ^ b | 4 ^ 5 |
~ | 按位取反 | ~a | ~4 |
<< | 按位左移 | a << b | 4 << 2,表示整数 4 按位左移 2 位 |
>> | 按位右移 | a >> b | 4 >> 2,表示整数 4 按位右移 2 位 |
比较运算符,也称关系运算符,用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的,则返回 True(真),反之则返回 False(假)。
比较运算符 | 说明 |
---|---|
> | 大于,如果> 前面的值大于后面的值,则返回 True,否则返回 False。 |
< | 小于,如果< 前面的值小于后面的值,则返回 True,否则返回 False。 |
== | 等于,如果== 两边的值相等,则返回 True,否则返回 False。 |
>= | 大于等于(等价于数学中的 ≥),如果>= 前面的值大于或者等于后面的值,则返回 True,否则返回 False。 |
<= | 小于等于(等价于数学中的 ≤),如果<= 前面的值小于或者等于后面的值,则返回 True,否则返回 False。 |
!= | 不等于(等价于数学中的 ≠),如果!= 两边的值不相等,则返回 True,否则返回 False。 |
is | 判断两个变量所引用的对象是否相同,如果相同则返回 True,否则返回 False。 |
is not | 判断两个变量所引用的对象是否不相同,如果不相同则返回 True,否则返回 False。 |
==
和 is
的区别== 用来比较两个变量的值是否相等,而 is 则用来比对两个变量引用的是否是同一个对象(内存地址是否相同)。
import time #引入time模块
t1 = time.gmtime() # gmtime()用来获取当前时间
t2 = time.gmtime()
print(t1 == t2) #输出True
print(t1 is t2) #输出False
time 模块的 gmtime() 方法用来获取当前的系统时间,精确到秒级,因为程序运行非常快,所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等,所以返回 True。
虽然 t1 和 t2 的值相等,但它们是两个不同的对象(每次调用 gmtime() 都返回不同的对象),所以t1 is t2
返回 False。这就好像两个双胞胎姐妹,虽然她们的外貌是一样的,但它们是两个人。**
那么,如何判断两个对象是否相同呢?答案是判断两个对象的内存地址。如果内存地址相同,说明两个对象使用的是同一块内存,当然就是同一个对象了;这就像两个名字使用了同一个身体,当然就是同一个人了。
逻辑运算符 | 含义 | 基本格式 | 说明 |
---|---|---|---|
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 取反。 |
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
max = a if a>b else b
这是一种类似于其它编程语言中三目运算符? :
的写法。Python 是一种极简主义的编程语言,它没有引入? :
这个新的运算符,而是使用已有的 if else 关键字来实现相同的功能。
等价于
if a>b:
max = a;
else:
max = b;
语法
exp1 if contion else exp2
三目运算符嵌套
语法:
a if a>b else ( c if c>d else d )
demo
a = int(input("Input a: "))
b = int(input("Input b: "))
print("a大于b") if a>b else (print("a小于b") if a<b else print("a等于b"))
运算符说明 | Python运算符 | 优先级 | 结合性 | 优先级顺序 |
---|---|---|---|---|
小括号 | ( ) | 19 | 无 | 高 |
索引运算符 | x[i] 或 x[i1: i2 [:i3]] | 18 | 左 | |
属性访问 | x.attribute | 17 | 左 | |
乘方 | ** | 16 | 右 | |
按位取反 | ~ | 15 | 右 | |
符号运算符 | +(正号)、-(负号) | 14 | 右 | |
乘除 | *、/、//、% | 13 | 左 | |
加减 | +、- | 12 | 左 | |
位移 | >>、<< | 11 | 左 | |
按位与 | & | 10 | 右 | |
按位异或 | ^ | 9 | 左 | |
按位或 | | | 8 | 左 | |
比较运算符 | ==、!=、>、>=、<、<= | 7 | 左 | |
is 运算符 | is、is not | 6 | 左 | |
in 运算符 | in、not in | 5 | 左 | |
逻辑非 | not | 4 | 右 | |
逻辑与 | and | 3 | 左 | |
逻辑或 | or | 2 | 左 | |
逗号运算符 | exp1, exp2 | 1 | 左 | 低 |