Python：简介、变量、字符串、运算符

本文主要是介绍Python：简介、变量、字符串、运算符，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1，Python简介

1.1，Python特点

Python是一种面向对象、解释型、弱类型的脚本语言，它也使一种功能强大而完善的通用性语言。

相比其他编程语言（Java），Python代码非常简单，上手非常容易。比如我们想要完成某个功能，如果用Java需要100行代码，但用Python可能只需要20行代码，这是Python具有巨大吸引力的一大特点。

Python的两大特色是清晰的语法和可扩展性。Python语法非常清晰，它甚至不是一种格式自由的语言。例如，if下一行必须向右缩进，否则不能通过编译。Python的可扩展性体现为它的模块，Python具有脚本语言最丰富和强大的类库，这些类库覆盖了文件I/O、GUI、网络编程、数据库访问、文件操作等绝大部分应用场景。此外，Python的社区也很发达，即使一些小众的应用场景，Python往往也有对应的开源模块来提供决绝方案。

Python作为一门解释型语言，它天生具有跨平台的特征，只要为平台提供了相应的Python解释器，Python就可以在该平台上运行。（解释型语言几乎天然是跨平台的）

Python自然也具有解释型语言的一些弱点：

• 速度慢：Python比Java、C、C++等程序的运行效率都要慢，
• 源代码加密困难：不像编译型语言的源程序会被编译成目标程序，Python直接运行源程序，因此对源代码加密比较困难。

但是，由于目前计算机的硬件速度越来越快，软件工程往往更关注开发过程的效率和可靠性，而不是软件的运行效率；而显著软件行业的大势本来就是开源，就像Java程序同样很容易反编译，但丝毫不会影响它的流行。

1.2，Python程序的运行机制

Python是一门解释型的编程语言，因此它具有解释型语言的运行机制。

计算机程序，其实就是一组计算机指令集，能真正驱动机器运行的是机器指令，但让普通开发者直接编写机器指令是不现实的，因此就出现了计算机高级语言。高级语言允许使用自然语言来编程，但高级语言最终必须被翻译成机器指令来执行。

高级语言按程序的执行方式可以分为编译型和解释型两种。

编译型

编译型语言是指专门的编译器，针对特定平台（操作系统）将某种高级语言源代码一次性“翻译”成可被该平台硬件执行的机器码（包括机器指令和操作数），并包装成该平台所能识别的可执行程序的格式，这个转换过程称为编译。编译生成的可执行程序可以脱离开发环境，在特定的平台上独立运行。

有些程序编译结束后，还可能需要对其他编译好的目标代码进行链接，即组装两个以上的目标代码模块生成最终的可执行程序，通过这种方式实现低层次的代码复用。

因为编译语言是一次性编译成机器码的，所以可以脱离开发环境独立运行，而且通常运行效率较高。但因为编译型语言的程序被编译成特定平台上的机器码，因此编程生成的可执行程序通常无法移植到其他平台上运行；如果需要移植，则必须将源代码复制到特定平台上，针对特定平台进行修改，至少需要采用特定平台上的编译器重新编译。

现有的C、C++、Objective-C、Pascale等高级语言。Java是编译型+解释型语言。

编译原理：引论_燕双嘤-CSDN博客之前一直忙于比赛项目，疏忽对编译原理的学习，从此日更编译原理，往监督。一，万恶的开始语言特点举例高级语言符合人们的习惯，更容易理解和修改。int x = 2;汇编语言具有一定意义的文字命令，与机器语言一一对应。MOV x 2机器语言二进制命令，能被计算机直接识别。C706 0000 0002二，编...https://shao12138.blog.csdn.net/article/details/105181329#t2

解释型

解释型语言是指使用专门的解释器对源代码逐行解释成特定平台的机器码并立即执行的语言。解释型语言通常不会进行整体性的编译和链接处理，解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。

可以认为：每次执行解释型语言的程序都需要进行一次编译，因此解释型语言的运行效率通常较低，而不能脱离解释器独立运行。但解释型语言有一个优势，就是跨平台比较容易，只需提供特定平台的解释器即可，每个特定平台上的解释器都负责将源程序解释成特定平台的机器指令。解释型语言可以方便地实现源程序级的移植，但这是以牺牲程序执行效率为代价的。

Python语言属于解释型语言，因此运行Python程序时需要使用特定的解释器进行解释、执行。

解释型的Python语言天生具有跨平台的能力，只要为Python提供相应平台的解释器即可。

2，变量

2.1，注释

Python中的注释有两种：单行注释&多行注释。

#我是单行注释
'''
我是
多行注释
'''
"""
我也是
多行注释
"""

2.2，弱类型

Python是弱类型的语言，因此具有如下特征：

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

a = "燕双嘤"
print(a, type(a))
a = 22
print(a, type(a))
==================
燕双嘤 <class 'str'>
22 <class 'int'>

Python中使用print()函数输出变量，print()函数语法：

def print(self, *args, sep=' ', end='\n', file=None): 

• objects：复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep：用来间隔多个对象，默认值是一个空格。
• end：用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file：要写入的文件对象。
• flush：输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。通常为了获得更好的性能，flush设置为False。

import time

print("---Loading 效果---")
print("Loading",end = "")
for i in range(20):
    print(".",end = '',flush = True)
    time.sleep(0.5)

2.3，命名规则

Python需要使用标识符给变量命名，标识符必须以：字母、下划线（_）开头。后跟：字母、数字、下划线（_）。Python区分大小写。

Python3支持UFT-8字符集，因此Python3的标识符可以使用UTF-8所能表示的多种语言的字符。

Python标识符规则：

• 标识符可以由字母、数字、下划线（_）组成，其中数字不能打头。
• 标识符不能是Python关键字，但可以包含关键字。
• 标识符不能包含空格。

2.4，关键字&内置函数

Python中包含了一系列关键字和内置函数，一般也不建议使用它们作为变量名。

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

Python中的关键字

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

Python的内置函数

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

3，数值类型

3.1，整型

Python3的整型支持各种整数值，不管是小的整数型，还是大的整数值，Python都能轻松处理（不像Java，short、int、long等整型增加了开发难度）。

a = 999999999999999999999999999999999999999999999999999999999999999999999
print(a,type(a))
=====================================
999999999999999999999999999999999999999999999999999999999999999999999 <class 'int'>

如上面程序，Python不会发生溢出等问题，这就是Python的魅力：不搞那些乱七八糟的底层细节，非专业人士也不用关心什么字节之类的细节。

Python还允许数值（整型和浮点型）增加下画线作为分隔符，这些下画线并不影响数值本身。

a = 9999_99999999999_9999999999999_99999999999999999999999999999999999999999

 另外，Python整型支持None值（空值）。

a = None
print(a,type(a))
======================
None <class 'NoneType'>

Python的整型数值有4中表现形式：

• 十进制形式：最普通的整数。
• 二进制形式：以0b或0B开头的整数就是二进制形式的整数。
• 八进制形式：以0o或0O开头的整数就是八进制形式的整数。
• 十六进制形式：以0x或0X开头的整数就是十六进制形式的整数，其中10~15分别以a~f来表示。

a = 0x13
b = 0XaF
print(a,b)
===================
19 175

3.2，浮点型

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

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

PS：只有浮点型数值才可以使用科学计数形式表示。例如51200是一个整型值，但512E2则是浮点型数值。Python中不允许除0.不管是整数还是浮点型值。

f1 = 1.2345556
print(f1, type(f1))
f2 = 1.12e2
print(f1)
f3 = 5e3
print(f2, type(f2))
================================
1.2345556 <class 'float'>
1.2345556
112.0 <class 'float'>
#虽然5e3的值是5000，但它依然是浮点型数值，而不是整型值——因为Python会自动将该数值变为5000.0。

3.3，复数

Python中可以支持复数，复数的虚部用j或J来表示。如果需要在程序中对复数进行计算（基本不会用到），可导入Python的cmath模块，在该模块下包含了各种支持复数运算的函数。

import cmath
a = 3 + 1j
b = 4 - 5j
print(a+b)
print(cmath.sqrt(-1))
=====================
(7-4j)
1j

4，字符串

4.1，字符串和转义字符

字符串的内容几乎可以包含任何字符，英文字符也行，中文字符也行。字符串既可用单引号括起来，也可用双引号括起来，没有任何区别。

a = 'abc'
b = 'abc'
print(a==b)
============
True

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

• 使用不同的引号将字符串括起来。
• 对引号进行转义。

#如果字符串包含了单引号，则可以使用双引号将字符串括起来
a = "I'm a trash"
b = "he say:'I'm a trash'"
print(a,b)
=========================
I'm a trash he say:'I'm a trash'

#还可以使用转义字符
c = "he say:I/'m a trash"
print(c)
========================
he say:I'm a trash

4.2，拼接

字符串拼接字符串：Python使用（+）作为字符串的拼接运算符。

a = "I'm"
b = "a trash"
print(a+b)
============
I'ma trash

字符串拼接数值：在Python中不允许直接拼接数值和字符串，程序必须先将数值转换成字符串。为了将数值转换成字符串，可以使用str()或repr()函数。

a = "我的编号是："
b = 12138
print(a+str(b))
print(a+repr(b))
================
我的编号是：12138
我的编号是：12138

str()和repr()函数都可以直接将数值转换成字符串。此外，repr还有一个功能，它会以Python表达式的形式来表示值。

a = "我的编号是：'12138'"
print(str(a))
print(repr(a))
===================
我的编号是：'12138'
"我的编号是：'12138'"

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

4.3，使用input获取用户输入

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

x = input("请输入内容：")
print(x,type(x))
=======================
请输入内容：1.2138
1.2138 <class 'str'>

4.4，转义字符

如果字符串包含反斜线\，则就需要使用\\来表示，\\就是转义字符的一种。

转义字符	说明
\b	退格符
\n	换行符
\r	回车符
\t	制表符
\"	双引号
\'	单引号
\\	反斜线

4.5，格式化输出

Python提供了“%”对各种类型的数据进行格式化输出：

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

代码中的print函数包含三个部分：第一部分是格式化字符串，包含一个“%s”占位符，它会被第三部分的变量或表达式的值代替；第二部分固定使用“%”作为占位符，它会被第三部分的变量或表达式代替。“%s”指定将变量或值使用str()函数转换为字符串。

如果第三部分包含多个“%s”占位符，第三部分也应该对应提供多个变量。

price = 108
print("the book's name is %s price is %s" %("荒古遗精宝典",price))
==============================================
the book's name is 荒古遗精宝典 price is 108

实际上，Python提供了大量的转换说明符：

转换说明符	说明
d，i	转换为带符号的十进制形式的整数
o	转换为带符号的八进制形式的整数
x	转换为带符号的十六进制形式的整数
X	转换为带符号的十六进制形式的整数
e	转换为科学计数法表示的浮点数（e小写）
E	转换为科学计数法表示的浮点数（E大写）
f，F	转换为十进制形式的浮点数
g	智能选择使用f或e格式
G	智能选择使用F或E格式
C	转换为单字符（只接受整数或单字符字符串）
r	使用repr()将变量或表达式转换为字符串
s	使用str()将变量或表达式转换为字符串

x = -12138
print("%6i" %x)
print("%6o" %x)
print("%6x" %x)
print("%6X" %x)
print("%6s" %x)
=================
-12138
-27552
 -2f6a
 -2F6A
-12138

从结果可以看出，此时指定了字符串的最小宽度为6，因此程序转换数值时总宽度为6，程序自动在数值前面补充三个空格。

在默认情况下，转换出来的字符串总是右对齐，不够宽度时左边补充空格。Python也允许在最小宽度之前添加一个标志来改变这种行为，Python支持如下标志：

• - ：指定左对齐。
• +：表示数值总要带着符号。
• 0：表示不补充空格，而是补充0。

x = 12138
print("%-6i" %x)
print("%-6o" %x)
print("%-+6x" %x)
print("%-06X" %x)
print("%-6s" %x)
==================
12138 
27552 
+2f6a 
2F6A  
12138

对于浮点数，Python还允许指定小数点后的数字位数；如果转换的是字符串，Python允许指定转换后的字符串的最大字符数。这个标志位被称为精度值，该精度值被放在最小宽度之后，中间用（.）隔开。

x = 1.213888888
print("%-6.1f" %x)
print("%-6.2f" %x)
print("%-+6.3f" %x)
print("%-06.4f" %x)
print("%-6.5s" %x)
====================
1.2   
1.21  
+1.214
1.2139
1.213  

4.6，序列相关方法

字符串本质上就是由多个字符组成的，因此程序允许通过索引来操作字符，比如获取指定索引处的字符，获取指定字符在字符串中的位置等。

Python字符串直接在方括号（[]）中使用索引即可获取对应的字符，字符串中第一个字符的索引为0、第二个字符的索引为1，后面依次类推。此外，Python还允许从后面开始计算索引，最后一个字符的索引为-1，倒数第二个字符的索引为-2，以此类推。

a = "I am a trash"
print(a[2], a[-2])
===================
a s

除了获取单个字符之外，也可在方括号中使用范围来获取字符串的一个子串。另外还可以使用索引运算符，设置索引的步长。

a = "I am a trash"
print(a[1:5:2], a[-5: -1])
=======================
 m tras

获取子串中还允许省略起始索引或结束索引。如果省略起始索引，相当于从字符串开始处开始截取；如果省略结束索引，相当于截取到字符串的结束处。

a = "I am a trash"
print(a[0:], a[:])
==================
I am a trash I am a trash

Python字符串还支持用in运算符判断是否包含某个子串。

print("燕" in "燕双嘤")

如果要获取字符串的长度，则可以使用Python内置函数len()函数。

print(len("燕双嘤"))

还可以使用全局的min()和max()函数获取字符串中最小字符和最大字符。值得注意的是，max和min不允许输入单个值，字符串类型本质上是字符数组。

print(min("燕双嘤"),max("燕双嘤"))
print(ord("燕"))
print(ord("双"))
print(ord("嘤"))
=================================
双 燕
29141
21452
22052

4.7，大小写

Python字符串大小写相关方法：

• title()：将每个单词的首字母改为大写。
• lower()：将整个字符串改为小写。
• upper()：将整个字符串改为大写。

print("I am a trash".lower())

4.8，删除空白

str还提供了如下常用方法删除空白。另外还可以进行指定删除字符。

• strip()：删除字符串前后的空白。
• lstrip()：删除字符串前面的空白。
• rstrip()：删除字符串后面的空白。

s = '    I am a trash'
print(s.lstrip())
print(s.rstrip("sh"))
print(s.rstrip("hijk,rstuv,abcd"))
print(s.lstrip("I"))
=====================
I am a trash
    I am a tra
    I am a 
    I am a trash

需要指出的是，如果从右边没有匹配到，就结束删除，找到则进行删除。 匹配的原则，待匹配字符串出现匹配字符串的一个字符就算匹配成功，删除。

4.9，查找、替换

str还提供了如下常用的执行查找、替换等操作的方法。

• startswitch()：判断字符串是否可以指定子串开头。
• endswitch()：判断字符串是否以指定子串结尾。
• find()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回-1。
• index()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发ValueError错误。
• replace()：使用指定子串替换字符串中的目标。
• translate()：使用指定的翻译映射表对字符串进行替换。

s = "I am a trash"
print(s.startswith("Y"))
print(s.endswith("h"))
print(s.find("am"))
print(s.index("am"))
print(s.replace("I am","You are"))
==================================
False
True
2
2
You are a trash

映射表

#定义翻译映射表，根据ASCII
s = "apple,banana,trash"
table = {97:945,98:946,116:964}
print(s.translate(table))
=========================
αpple,βαnαnα,τrαsh

但是这种方式过于麻烦，需要开发者记住每个字符的编码，而且编码起来极其不便。

#定义翻译映射表，根据ASCII
s = "apple,banana,trash"
table = str.maketrans("abt","αβτ")
print(s.translate(table))

4.10，分割、连接

Python还为str提供了分割和连接方法。

#定义翻译映射表，根据ASCII
s = "apple banana trash ysy"
print(s.split())
#最多只分割前两个词
print(s.split(None,2))
print(s.split(","))
list = s.split()
print("/".join(list))
print("*".join(list))
=====================
['apple', 'banana', 'trash', 'ysy']
['apple', 'banana', 'trash ysy']
['apple banana trash ysy']
apple/banana/trash/ysy
apple*banana*trash*ysy

5，运算符

运算符是一种特殊的符号，用来表示数据的运算、赋值和比较等。Python语言使用运算符将一个或多个操作数连接成可执行语句，用来实现特定功能。

Python语言中的运算符可分为如下几种：赋值运算符、算术运算符、位运算符、索引运算符、比较运算符、逻辑运算符。

5.1，赋值运算符

赋值运算符用于为变量或常量指定值，Python使用“=”作为赋值运算符。通常，使用赋值运算符将表达式的值赋给另一个变量。

a = "Python"
b = 3.14
c = True
print(a, b, c)
===============
Python 3.14 True

除此之外，也可使用赋值运算符将一个变量的值赋给另一个变量。

a = "Python"
b = c = d = e = a
f = e + "3"
print(a, b, c, d, e, f)
=================================
Python Python Python Python Python Python3

5.2，算术运算符

Python支持所有的基本算术运算符，这些算术运算符用于执行基本的数学运算，如加、减、乘、除和取余。

加

a = 5.2
b = 4.8
print(a + b)
c = "Hello"
d = "trash"
print(c + " " + d)
==================
10.0
Hello trash

减

c = 5.2
d = -3.1
print(c - d)
============
8.3

乘

e = 5.2
f = 3.1
g = "燕双嘤，" * 3
print(e * f, g)
============
16.12 燕双嘤，燕双嘤，燕双嘤，

除

h = 5.2
i = 3.1
print(h / i, h // i)
============
1.6774193548387097 1.0

乘方：乘方运算符。Python支持使用“**”作为乘方运算符，这是一个非常方便的运算符。

print(5 ** 2)
print(4 ** 3)
print(4 ** 0.5)
print(27 ** (1 / 3))
====================
25
64
2.0
3.0

取余：取余运算，Python不要求取余运算符的两个操作数都是整数，Python的求余运算符完成支持对浮点数求余。求余运算的结果不一定总是整数，它是使用第一个操作数除以第二个操作数，得到一个整除的结果后剩下的值就是余数。

print(5 % 3)
print(5.2 % 3.1)
print(-5.2 % -3.1)
print(5.2 % -2.9)
print(5.2 % -1.5)
print(-5.2 % 1.5)
print(5 % 0.0)
=================
2
2.1
-2.1
-0.5999999999999996
-0.7999999999999998
0.7999999999999998
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 7, in <module>
    print(5 % 0.0)
ZeroDivisionError: float modulo

这里有两个问题：

• 第一个问题：为什么预计5.2%-2.9的结果是-0.6呢？因为Python求余运算的逻辑是用被减数减去除数的N倍，此处的N是-2，因此得到的结果是-0.6。
• 第二个问题：为什么实际输出的是-0.5999999999999996呢？这是由浮点数的存储机制导致的。计算机底层的浮点数的存储机制并不是精确保存每一个浮点数的值，浮点数在Python中可能产生精度丢失的问题就行。比如，此处正常计算的结果应该是-0.6，但实际计算出来的结果是一个非常接近-0.6的值。

5.3，位运算符

位运算通常在图形、图像处理和创建设备驱动等底层开发中使用。使用位运算符可以直接操作数值的原始bit位，尤其是在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码也非常有效。

Python支持的位运算符：

• &：按位与。
• |：按位或。
• ^：按位异或。
• ~：按位取反。
• <<：左位移运算符。
• >>：右位移运算符。

位运算法则：

第一个操作数	第二个操作数	按位与	按位或	按位异或
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

print(5 & 9)
print(5 | 6)
============
1
7

原理：参考燕双嘤的组成原理专栏内容。 

5.4，比较运算符

Python提供了bool类型来表示真（True或1）或假（False或0），比较运算符用于判断两个值之间的大小，比较运算的结果是bool值。Python支持如下比较运算符：>、>=、<、<=、==、!=、is（变量所引用对象）、not is。

print(5 * 5 == 25)
print(1 == True, 0 == False)
============================
True
True True

==与is看上去很相似，但有实质区别，==比较两个变量的值，但is要求两个变量引用同一个对象。（和Java中的类似，==与equal()的区别）

import time
a = time.gmtime()
b = time.gmtime()
print(a == b, a is b)
=====================
True False

实际上，Python提供了一个全局id()函数来判断变量所引用的对象的内存地址，如果两个对象所在的内存地址相同，则说明两个对象其实是同一个对象。由此可见，is判断其实就是要求通过id()函数计算两个对象时返回相同的地址。

import time

a = time.gmtime()
b = time.gmtime()
c = 1
d = 1
print(id(a), id(b), id(c), id(d))
=================================
2587347852960 2587380144600 1358200944 1358200944

5.5，逻辑运算符、三目运算符、in运算符

逻辑运算符用于操作bool类型的变量、常量或表达式，逻辑运算符的返回值也是bool值。Python的逻辑运算符有三种：and、or、not。

a=1
print(a<3 and a<2)
==================
True

三目运算符的语法：True_statement if expression else False_statement

三目运算符的规则：先对逻辑表达式expression求值，如果逻辑表达式返回True，则执行并返回True_statement的值；如果逻辑表达式返回False，则执行并返回False_statement的值。

a = 5
b = 3
flag = "a 大于 b" if a > b else "b 大于 a"
print(flag)
========================================
a 大于 b

Python提供了in运算符，用于判断某个成员是否位于序列中。除此之外，Python还提供了not in。

a = "我是个废物"
print("废物" in a)
print("我" not in a)
===================
True
False

5.6，运算符的优先级

运算符说明	Python运算符	优先级
索引运算符	x[index]或x[index:index2[:index3]]	18、19
属性访问	x.attribute	17
乘方	**	16
按位取反	~	15
符号运算符	+或-	14
乘、除	*、/、//、%	13
加、减	+、-	12
位移	>>、<<	11
按位与	&	10
按位或	|	9
比较运算符	==、!=、>、>=、<、<=	8
is运算符	is、is not	7
in运算符	in、not in	6
逻辑非	not	4
逻辑与	and	3
逻辑或	or	2

这篇关于Python：简介、变量、字符串、运算符的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！