Python基础知识

Python基础知识

Python注释

Python单行注释

Python中使用井号（#）作为单行注释的符号，语法格式为：

 # 注释内容

也就是说，从符号#处开始，直到换行处结束，此部分内容都作为注释的内容，当程序执行时，这部分内容会被忽略。
单行注释放置的位置，既可以是要注释代码的前一行，例如：

#这是一行简单的注释
print ("Hello World!")

也可以是注释代码的右侧，例如：

print ("Hello World!") #这是一行简单的注释

基于注释在程序中所起到的作用，以上两种方式虽然放置位置不同，但程序的执行结果是相同的，都是输出“Hello World!”。

Python多行注释

多行注释指的是可以一次性注释程序中多行的内容（包含一行）。多行注释的语法有 2 种，分别是：

'''
使用 3 个单引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
'''

或者

"""
使用 3 个双引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
"""

多行注释通常用来为Python文件、模块、类或者函数等添加版权、功能描述等信息。需要注意的是，在 Python中，如果多行注释标记（三单引号或三双引号）作为语句的一部分出现，就不能再将它们视为多行注释的标记，而应看做是字符串的标志（同双引号的作用相同），例如：

print('''Hello,World!''')

该语句的执行结果为：Hello，World! 。由此可见，Python解释器没有将这里的三个单引号看做是注释，而是将它们看作是字符串的标志。

Python中文编码声明注释

Python还提供了一种特殊的中文编码声明注释，其主要用来解决Python 2.x中不支持直接写中文的问题。虽然此问题在Python 3.x中已经不存在啦，但为了规范编码，增强代码的可执行性，方便其他程序员及时了解程序所用的编码，建议初学者在程序开头处加上中文编码声明注释。

 # -*- coding:编码 -*-
 或者
 # coding=编码

语法中的编码，指的是编写程序所用的字符编码类型，比如UTF-8、GBK编码等。另外，在第一种语法中，‘-*-’并没有实际意义，只是为了美观才加上去了，因此，第一种语法格式中可以直接将前后的‘-*-’去掉。

 # coding:utf-8
 或者
 # coding=utf-8

注意，给代码添加注释，是注释的基本用法，它还有一个更实用的功能，即用来调试程序。举个例子，如果你觉得某段代码可能有问题，可以先把这段代码注释起来，让Python解释器忽略这段代码，然后运行。如果程序可以正常执行，则可以说明错误就是由这段代码引起的；反之，如果依然出现相同的错误，则可以说明错误不是由这段代码引起的。

Python缩进规则

和其它程序设计语言（如Java、C语言）采用大括号{}分隔代码块不同，Python采用代码缩进和冒号:来区分代码块之间的层次。
在Python中，对于类定义、函数定义、流程控制语句、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束。
注意，Python中实现对代码的缩进，可以使用空格或者Tab键实现。但无论是手动敲空格，还是使用Tab键，通常情况下都是采用4个空格长度作为一个缩进量（默认情况下，一个Tab键就表示4个空格）。

Python编码规范

Python采用PEP 8作为编码规范，其中PEP是Python Enhancement Proposal（Python增强建议书）的缩写，8 代表的是Python代码的样式指南。下面仅给大家列出PEP 8中初学者应严格遵守的一些编码规则：

1. 每个import语句只导入一个模块，尽量避免一次导入多个模块，例如：

   #推荐
   import os
   import sys
   
   #不推荐
   import os,sys
   

   关于 import 的含义和用法会在后续介绍，这里不必深究。
2. 不要在行尾添加分号，也不要用分号将两条命令放在同一行，例如：

   #不推荐
   height=float(input("输入身高：")) ; weight=fioat(input("输入体重：")) ;
   

3. 建议每行不超过80个字符，如果超过，建议使用小括号将多行内容隐式的连接起来，而不推荐使用反斜杠\进行连接。例如，如果一个字符串文本无法实现一行完全显示，则可以使用小括号将其分开显示，代码如下：

   #推荐
   s=("C语言中文网是中国领先的C语言程序设计专业网站，"
   "提供C语言入门经典教程、C语言编译器、C语言函数手册等。")
   #不推荐
   s="C语言中文网是中国领先的C语言程序设计专业网站，\
   提供C语言入门经典教程、C语言编译器、C语言函数手册等。"
   

   注意，此编程规范适用于绝对大多数情况，但以下2种情况除外：
   1. 导入模块的语句过长。
   2. 注释里的URL。
4. 使用必要的空行可以增加代码的可读性，通常在顶级定义（如函数或类的定义）之间空两行，而方法定义之间空一行，另外在用于分隔某些功能的位置也可以空一行。
5. 通常情况下，在运算符两侧、函数参数之间以及逗号两侧，都建议使用空格进行分隔。

编码规范的自动化工具

首先，你需要根据自己的具体工作环境，选择或者制定适合自己公司或团队的编码规范。市面上可以参考的规范，也就是在文章开头提到的PEP 8和Google Style。
一旦确定了整个团队所遵从的编码规范，就一定要强制执行，有什么好的办法呢？靠强制代码评审和强制静态或者动态linter。具体流程是：

1. 在代码评审工具里，添加必须的编码规范环节；
2. 把团队确定的代码规范写进[Pylint ](https://www.pylint.org/)里，能够在每份代码提交前自动检查，不通过的代码无法提交。

Python标识符命名规范

Python中标识符的命名不是随意的，而是要遵守一定的命令规则，比如说：

1. 标识符是由字符（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字。
2. 标识符不能和 Python 中的保留字相同。有关保留字，后续章节会详细介绍。
3. Python中的标识符中，不能包含空格、@、%以及$等特殊字符。
   例如，下面所列举的标识符是合法的：

   UserID
   name
   mode12
   user_age
   

   以下命名的标识符不合法：

   word   #不能以数字开头
   try    #try是保留字，不能作为标识符
   $money #不能包含特殊字符
   

4. 在Python中，标识符中的字母是严格区分大小写的，也就是说，两个同样的单词，如果大小格式不一样，多代表的意义也是完全不同的。比如说，下面这3个变量之间，就是完全独立、毫无关系的，它们彼此之间是相互独立的个体。

   number = 0
   Number = 0
   NUMBER = 0
   

5. Python语言中，以下划线开头的标识符有特殊含义，例如:
   1. 以单下划线开头的标识符（如_width），表示不能直接访问的类属性，其无法通过from...import*的方式导入；
   2. 以双下划线开头的标识符（如__add）表示类的私有成员；
   3. 以双下划线作为开头和结尾的标识符（如__init__），是专用标识符。
      因此，除非特定场景需要，应避免使用以下划线开头的标识符。

Python关键字

保留字是Python语言中一些已经被赋予特定意义的单词，这就要求开发者在开发程序时，不能用这些保留字作为标识符给变量、函数、类、模板以及其他对象命名。
Python包含的保留字可以执行如下命令进行查看：

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

Python内置函数一览表

为了提高程序员的开发效率，Python提供了很多可以直接拿来用的函数，每个函数都可以帮助程序员实现某些具体的功能。
可通过访问https://docs.python.org/zh-cn/3/library/functions.html进行查看。

内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slicea()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

Python变量

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

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

以C语言为例：

 int a = 20

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

1. 变量无须声明即可直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
2. 变量的数据类型可以动态改变：同一个变量可以一会儿被赋值为整数值，一会儿被赋值为字符串。

#定义一个数值类型变量
a = 5
print(a)
#重新将字符串赋值给a变量
a = 'Hello , Charlie'
print(a)
print(type(a))

输出结果：

5
Hello , Charlie
<type 'str'>

整型

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

#定义变量a，赋值为56
a = 56
print(a)
#为a赋值一个大整数
a = 9999999999999999999999
print(a)
#type()函数用于返回变量的类型
print(type (a))

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

56
9999999999999999999999
<class 'int'>

Python的整型数值有 4 种表示形式：

1. 十进制形式：最普通的整数就是十进制形式的整数，在使用十进制表示整数值时，不能以0（零）作为十进制数的开头（数值是0除外）。
2. 二进制形式：由0和1组成，以0b或0B开头。例如，101对应十进制数是5；
3. 八进制形式：八进制整数由0~7组成，以0o或 0O开头（第一个字母是零，第二个字母是大写或小写的 O）。需要注意的是，在Python 2.x中，八进制数值还可以直接以0（零）开头。
4. 十六进制形式：由0~9以及A~F（或 a~f）组成，以0x或0X开头

#以0x或0X开头的整型数值是十六进制形式的整数
hex_value1 = 0x13
hex_value2 = 0XaF
print("hexValue1 的值为：",hex_value1)
print("hexValue2 的值为：",hex_value2)
#以0b或0B开头的整型数值是二进制形式的整数
bin_val = 0b111
print('bin_val的值为：',bin_val)
bin_val = 0B101
print('bin_val的值为：',bin_val)
#以0o或0O开头的整型数值是八进制形式的整数
oct_val = 0o54
print('oct_val 的值为：',oct_val)
oct_val = 0O17
print('oct_val 的值为：',oct_val)

浮点型

浮点型数值用于保存带小数点的数值，Python的浮点数有两种表示形式：

1. 十进制形式：这种形式就是平常简单的浮点数，例如5.12、512.0、0.512。浮点数必须包含一个小数点，否则会被当成整数类型处理。
2. 科学计数形式：例如5.12e2（即5.12×102）、5.12E2（也是5.12 ×102）。

af1 = 5.2345556
#输出af1的值
print("af1的值为：",af1)
af2 = 25.2345
print("af2的类型为：",type(af2))
f1=5.12e2
print("f1的值为：",f1)
f2 = 5e3
print("f2的值为：",f2)
print("f2的类型为：",type(f2))#看到类型为float

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

字符串

Python要求，字符串必须使用引号括起来，可以使用单引号或者双引号，只要成对即可。字符串中的内容几乎可以包含任何字符，英文字符也行，中文字符也行。

str1 = 'c.biancheng.net'
str2 = "C语言中文网"
print(str1)
print(str2)

如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理：

1. 使用不同的引号将字符串括起来。
2. 对引号进行转义。
   假如字符串内容中包含了单引号，则可以使用双引号将字符串括起来。

str3 = "I'm a coder"
print(str3)

假如字符串内容本身包含双引号，则可使用单引号将字符串括起来 。

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

假如字符串既包含单引号，又包含双引号，此时就可以使用转义字符， Python 允许使用反斜线（\）将字符串中的特殊字符进行转义。

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

Python允许使用转义字符（\）对换行符进行转义，转义之后的换行符不会“中断”字符串， 故程序使用了转义字符（\）对内容进行了转义，这样就可以把一个字符串写成两行。

s2 = 'The quick brown fox \
jumps over the lazy dog'
print(s2)

长字符串

Python使用三个引号（单引号、双引号都行）来包含多行注释内容，其实这是长字符串的写法，只是由于在长字符串中可以放置任何内容，包括放置单引号、双引号都可以，如果所定义的长字符串没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就相当于注释掉了。
实际上，使用三个引号括起来的长字符串完全可以赋值给变量，例如如下程序：

s = '''"Let's go fishing", said Mary.
"OK, Let's go", said her brother.
they walked to a lake'''
print(s)

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

原始字符串

由于字符串中的反斜线都有特殊的作用，因此当字符串中包含反斜线时，就需要使用转义字符\对字符串中包含的每个'\'进行转义。
比如说，我们要写一个关于Windows路径G:\publish\codes\02\2.4这样的字符串，如果在Python程序中直接这样写肯定是不行的，需要使用\转义字符，对字符串中每个'\'进行转义，即写成G:\\publish\\codes\\02\\2.4这种形式才行。
原始字符串以r开头，它不会把反斜线当成特殊字符。因此，上面的Windows路径可直接写成如下这种形式：

s1 = r'G:\publish\codes\02\2.4'
print(s1)

Python的字符编码

Python默认采用UTF-8编码， 但它也提供了encode()方法，可以轻松实现将Unicode编码格式的字符串转化为其它编码格式。

bytes类型

Python3 新增了bytes类型，用于代表字节串。字符串（str）由多个字符组成，以字符为单位进行操作；字节串（bytes）由多个字节组成，以字节为单位进行操作。
如果希望将一个字符串转换成bytes对象，有如下三种方式：

1. 如果字符串内容都是ASCII字符，则可以通过直接在字符串之前添加b来构建字节串值。
2. 调用bytes()函数（其实是bytes的构造方法）将字符串按指定字符集转换成字节串，如果不指定字符集，默认使用UTF-8字符集。
3. 调用字符串本身的encode()方法将字符串按指定字符集转换成字节串，如果不指定字符集，默认使用UTF-8字符集。

# 创建一个空的bytes
b1 = bytes()
# 创建一个空的bytes值
b2 = b''
# 通过b前缀指定hello是bytes类型的值
b3 = b'hello'
print(b3)
print(b3[0])
print(b3[2:4])
# 调用bytes方法将字符串转成bytes对象
b4 = bytes('我爱Python编程',encoding='utf-8')
print(b4)
# 利用字符串的encode()方法编码成bytes，默认使用utf-8字符集
b5 = "学习Python很有趣".encode('utf-8')
print(b5)

运行上面程序，可以看到如下输出结果：

b'hello'
104
b'll'
b'\xe6\x88\x91\xe7\x88\xb1Python\xe7\xbc\x96\xe7\xa8\x8b'
b'\xe5\xad\xa6\xe4\xb9\xa0Python\xe5\xbe\x88\xe6\x9c\x89\xe8\xb6\xa3'

bool布尔类型

Python提供了bool类型来表示真（对）或假（错）。
比如常见的5 > 3比较算式，这个是正确的，在程序世界里称之为真（对），Python使用True来代表；
再比如4 > 20比较算式，这个是错误的，在程序世界里称之为假（错），Python使用False来代表。

>>> 5>3
True
>>> 4>20
False

input()函数

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

msg ＝ input("请输入你的值：")
print (type(msg))
print(msg)

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

请输入你的值：2
<class 'str'>
2

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

请输入你的值： 1.2
<class 'str'>
1.2

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

请输入你的值：Hello
<class 'str'>
Hello

print()函数

前面print()函数时，都只输出了一个变量，但实际上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()函数关闭文件。

格式化输出

Python提供了“%”对各种类型的数据进行格式化输出，例如如下代码：

price = 108
print ("the book's price is %s" % price)

user = "Charli"
age = 8
# 格式化字符串有两个占位符，第三部分提供2个变量
print("%s is a %s years old boy" % (user , age))

上面程序中的print函数包含以下三个部分，第一部分是格式化字符串（相当于字符串模板），该格式化字符串中包含一个%s占位符，它会被第三部分的变量或表达式的值代替；第二部分固定使用%作为分隔符。
格式化字符串中的%s被称为转换说明符（Conversion Specifier），其作用相当于一个占位符，它会被后面的变量或表达式的值代替。%s指定将变量或值使用str()函数转换为字符串。
如果格式化字符串中包含多个%s占位符，第三部分也应该对应地提供多个变量，并且使用圆括号将这些变量括起。

1. 当使用上面的转换说明符时，可指定转换后的最小宽度，例如如下代码：

   num = -28
   print("num is: %6i" % num)
   print("num is: %6d" % num)
   print("num is: %6o" % num)
   print("num is: %6x" % num)
   print("num is: %6X" % num)
   print("num is: %6s" % num)
   

   运行上面代码，可以看到如下输出结果：

   num is:  -28
   num is:  -28
   num is:  -34
   num is:  -1c
   num is:  -1C
   num is:  -28
   

   从上面的输出结果可以看出，此时指定了字符串的最小宽度为6，因此程序转换数值时总宽度为6，程序自动在数值前面补充了三个空格。
2. 在默认情况下，转换出来的字符串总是右对齐的，不够宽度时左边补充空格。Python也允许在最小宽度之前添加一个标志来改变这种行为，Python支持如下标志：
   • ``：指定左对齐。
   • +：表示数值总要带着符号（正数带“+”，负数带“-”）。
   • 0：表示不补充空格，而是补充0。
     例如如下代码：

   num2 = 30
   # 最小宽度为0，左边补0
   print("num2 is: %06d" % num2)
   # 最小宽度为6，左边补0，总带上符号
   print("num2 is: %+06d" % num2)
   # 最小宽度为6，右对齐
   print("num2 is: %-6d" % num2)
   

   运行上面代码，可以看到如下输出结果：

   num2 is: 000030
   num2 is: +00030
   num2 is: 30
   

3. 对于转换浮点数，Python还允许指定小数点后的数字位数：如果转换的是字符串，Python允许指定转换后的字符串的最大字符数。这个标志被称为精度值

   my_value = 3.001415926535
   # 最小宽度为8，小数点后保留3位
   print("my_value is: %8.3f" % my_value)
   # 最小宽度为8，小数点后保留3位，左边补0
   print("my_value is: %08.3f" % my_value)
   # 最小宽度为8，小数点后保留3位，左边补0，始终带符号
   print("my_value is: %+08.3f" % my_value)
   the_name = "Charlie"
   # 只保留3个字符
   print("the name is: %.3s" % the_name)
   # 输出Cha# 只保留2个字符，最小宽度10
   print("the name is: %10.2s" % the_name)
   

   运行上面代码，可以看到如下输出结果：

   my_value is:  3.001
   my_value is: 0003.001
   my_value is: +003.001
   the name is: Cha
   the name is:     Ch
   

Python运算符

算术运算符

算术运算符是处理四则运算的符号，在数字的处理中应用得最多。

运算符	说明	实例	结果
+	加	12.45 + 15	27.45
-	减	4.56 - 0.26	4.3
*	乘	5 * 3.6	18.0
/	除	7 / 2	3.5
%	取余，即返回除法的余数	7 % 2	1
//	整除，返回商的整数部分	7 // 2	3
**	幂，即返回x的y次方	2 ** 4	16，即24

加法运算符

例如如下代码：

a = 5.2
b = 3.1
the_sum = a + b
# sum的值为8.3
print("the_sum的值为：", the_sum)

除此之外，+还可以作为字符串（包括后续要介绍的序列）的连接运算符。例如如下代码：

s1 = 'Hello, '
s2 = 'Charlie'
# 使用+连接两个字符串
print(s1 + s2)

减法运算符

例如如下代码：

c = 5.2
d = 3.1
sub = c - d
# sub的值为2.1
print("sub的值为：", sub)

此外，-除了可以作为减法运算符之外，还可以作为求负的运算符。请看如下代码：

# 定义变量x，其值为-5.0
x = -5.0
# 将x求负，其值变成5.0
x = -x
print(x)

乘法运算符

例如如下代码：

e = 5.2
f = 3.1
multiply = e * f
# multiply的值为16.12
print("multiply的值为：", multiply)

此外，*还可以作为字符串（包括后续要介绍的序列）的连接运算符，表示将N个字符串连接起来。例如如下代码：

s3 = 'crazyit '
# 使用*将5个字符串连接起来
print(s3 * 5)

上面代码将会输出：

crazyit crazyit crazyit crazyit crazyit

除法运算符

Python的除法运算符有两个：/表示普通除法，使用它除出来的结果与平常数学计算的结果是相同的（即除不尽时，会产生小数部分）；而//表示整除，使用它除出来的结果只有整数部分，小数部分将会被舍弃。

记住，在Python 3.x中，除法运算的结果都是浮点类型。

例如如下代码：

print("19/4的结果是:", 19/4)
print("19//4的结果是:", 19//4)
aa = 5.2
bb = 3.1
# aa / bb的值将是1.67741935483871
print("aa/bb的值是:", aa / bb)
# aa // bb值将是1.0
print("aa//bb的值是:", aa // bb)

求余运算符

Python不要求求余运算符的两个操作数都是整数，Python的求余运算符完全支持对浮点数求余。求余运算的结果不一定总是整数，它是使用第一个操作数来除以第二个操作数，得到一个整除的结果后剩下的值就是余数。
由于求余运算也需要进行除法运算，因此求余运算的第二个操作数不能是 0，否则程序会报出ZeroDivisionError错误。
例如如下程序：

print("5%3的值为：", 5 % 3) # 输出2
print("5.2%3.1的值为：",5.2 % 3.1) # 输出2.1
print("-5.2%-3.1的值为：", -5.2 % -3.1) # 输出-2.1
print("5.2%-2.9的值为：", 5.2 % -2.9) # 输出-0.6
print("5.2%-1.5的值为：", 5.2 % -1.5) # 输出-0.8
print("-5.2%1.5的值为：", -5.2 % 1.5) # 输出0.8
#print("5对0.0求余的结果是:", 5 % 0.0) # 导致错误

乘方运算符

Python支持使用**作为乘方运算符，这是一个使用非常方便的运算符。由于开方其实是乘方的逆运算，因此实际上使用**也可进行开方运算。例如如下代码：

print('5 的 2 次方：', 5 ** 2) # 25
print('4 的 3 次方：', 4 ** 3) # 64
print('4 的开平方：', 4 ** 0.5) # 2.0
print('27 的开 3 次方：',27 **(1 / 3 )) # 3.0

赋值运算符

基本赋值运算符

python使用＝作为赋值运算符，常用于将表达式的值赋给另一个变量。例如如下代码：

# 为变量st赋值为
Pythonst = "Python"
# 为变量pi赋值为3.14
pi = 3.14
# 为变量visited赋值为True
visited  = True

除此之外，也可使用赋值运算利将一个变量的值赋给另一个变量。例如，如下代码也是正确的：

# 将变量st的值赋给st2
st2 = st
print(st2)

扩展后的赋值运算符

=赋值运算符还可与其他运算符（算术运算符、位运算符等）结合，成为功能更强大的赋值运算符。

运算符	说 明	举 例	展开形式
=	最基本的赋值运算	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指的是右移的位数
这里举几个简单的例子：

a = 1
b = 2
a += b
print("a+b=",a)#1+2=3
a -= b
print("a-b=",a)#3-2=1
a *= b
print("a*b=",a)#1*2=2
a /= b
print("a/b=",a)#2/2=1.0
a %= b
print("a%b=",a)#1%2=1.0
c = 0
d = 2
c &= d
print("c&d=",c)#0&2=0
c |= d
print("c|d=",c)#0|2=2

运行结果为：

a+b= 3
a-b= 1
a*b= 2
a/b= 1.0
a%b= 1.0
c&d= 0
c|d= 2

位运算符

位运算符的操作对象是整数类型，它会把数字看做对应的二进制数来进行计算。

位运算符	说 明	使用形式	举 例
&	按位与	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位

按位与运算符

按位与运算的运算符是&，它有2个操作数，其运算法则是，按位将2个操作数对应的二进制数一一对应，只有对应数位都是1时，此为对应的结果位才是1；反之，就是0。

第一个操作数	第二个操作数	结果位的值
0	0	0
0	1	0
1	0	0
1	1	1
例如，在Python交互式解释器中，计算12 & 8的值，执行过程如下：

>>> 12 & 8
8

按位或运算符

按位或运算的运算符是|，它有2个操作数，运算法则是，按位将2个操作数对应的二进制数一一对应，只有对应数位都是0，所得结果才是0；反之，就是1。

第一个操作数	第二个操作数	结果位的值
0	0	0
0	1	1
1	0	1
1	1	1

例如，在Python交互式解释器上计算4 | 8的值，执行过程如下：

>>> 4 | 8
12

按位异或运算符

按位异或运算的运算符是^，它有2个操作数，运算法则是，按位将 2个操作数对应的二进制数一一对应，当对应位的二进制值相同（同为0或同为1）时，所得结果为 0；反之，则为1。

第一个操作数	第二个操作数	结果位的值
0	0	0
0	1	1
1	0	1
1	1	0
例如，在Python交互式解释器中，计算31 ^ 22的值，其执行过程为：

>>> 31 ^ 22
9

按位取反运算符

按位取反，也常称为“按位非”运算，此运算的运算符为~，它只有1个操作数，其运算法则为：将操作数的所有二进制位，1改为0，0改为1。

 >>> ~-5
 4

注意，此运算过程涉及与计算机存储相关的内容，首先需要了解什么是原码、反码以及补码：

• 原码是直接将一个数值换算成二进制数。有符号整数的最高位是符号位，符号位为0代表正数，符号位为 1 代表负数。无符号整数则没有符号位，因此无符号整数只能表示0和正数。
• 反码的计算规则是：对原码按位取反，只是最高位（符号位）保持不变。
• 补码的计算规则是：正数的补码和原码完全相同，负数的补码是其反码+1；

左移运算符

左移运算符是将操作数补码形式的二进制数，整体左移指定位数，左移后，左边溢出的位直接丢弃，右边空出来的位以0来填充。例如如下代码：

>>> 5 << 2
20
>>>-5 << 2
-20

右移运算符

Python的右移运算符为>>，其运行法则是，把操作数补码形式的二进制右移指定位数后，左边空出来的位以符号位来填充，右侧溢出位直接丢弃。

>>> -5 >> 2
-2

比较运算符

比较运算符，也成关系运算符，用于对常量、变量或表达式的结果进行大小、真假等比较，如果比较结果为真，则返回True；反之，则返回False。

比较运算符	功能
>	大于，如果运算符前面的值大于后面的值，则返回True；否则返回False
>=	大于或等于，如果运算符前面的值大于或等于后面的值，则返回True；否则返回False
<	小于，如果运算符前面的值小于后面的值，则返回True；否则返回False
<=	小于或等于，如果运算符前面的值小于或等于后面的值，则返回True；否则返回False
==	等于，如果运算符前面的值等于后面的值，则返回True；否则返回False
!=	不等于，如果运算符前面的值不等于后面的值，则返回True；否则返回False
is	判断两个变量所引用的对象是否相同，如果相同则返回True
is not	判断两个变量所引用的对象是否不相同，如果不相同则返回True
下面程序示范了比较运算符的基本用法：

>>> print("5是否大于 4：", 5 > 4)
5是否大于 4： True
>>> print("3的4次方是否大于等于90.0：", 3 ** 4 >= 90)
3的4次方是否大于等于90.0： False
>>> print("20是否大于等于20.0：", 20 >= 20.0)
20是否大于等于20.0： True
>>> print("5和5.0是否相等：", 5 == 5.0)
5和5.0是否相等： True
>>> print("True和False是否相等：", True == False)
True和False是否相等： False
>>>

比较运算符==和is的区别

==用来比较两个变量的值是否相等，而is则用来比对两个变量引用的是否是同一个对象，例如：

import time
# 获取当前时间
a = time.gmtime()
b =  time.gmtime()
print(a == b) # a和b两个时间相等，输出True
print(a is b) # a和b不是同一个对象，输出False

上面代码中a、b两个变量都代表当前系统时间，因此a、b两个变量的时间值是相等的（代码运行速度很快，能保证是同一时间），故程序使用“==”判断返回True。但由于a、b两个变量分别引用不同的对象（每次调用gmtime()函数都返回不同的对象），因此a is b返回False。
Python提供了一个全局的id()函数，它可以用来判断变量所引用的对象的内存地址，如果两个对象所在的内存地址相同，则说明这两个对象其实是同一个对象。
再举一个例子：

>>> a = 'cheesezh'
>>> b = 'cheesezh'
>>> id(a)
2680257978480
>>> id(b)
2680257978480
>>> a is b
True

逻辑运算符

逻辑运算符是对真和假两种布尔值进行运算（操作bool类型的变量、常量或表达式），逻辑运算的返回值也是 bool类型值。
Python中的逻辑运算符主要包括and（逻辑与）、or（逻辑或）以及not（逻辑非）

逻辑运算符	含义	基本格式	功能
and	逻辑与（简称“与”）	a and b	有2个操作数a和b，只有它们都是True时，才返回True，否则返回 False。
or	逻辑或（简称“或”）	a or b	有2个操作数a和b，只有它们都是False时，才返回False，否则返回True。
not	逻辑非（简称“非”）	not a	只需要 1 个操作数 a，如果 a 的值为 True，则返回False；反之，如果 a 的值为False，则返回True。
下面代码示范了与、或、非这三个逻辑运算符的使用：

# 直接对False求非运算，将返回True
print(not False)
# 5>3返回True，20.0大于10，因此结果返回True
print(5 > 3 and 20.0 > 10)
# 4>=5返回False，"c">"a"返回True。求或后返回True
print(4 >= 5 or "c" > "a")