python while 循环 全局变量_第4章 ：Python基础知识之数据类型

Python中的注释

Python中的注释可用于解释任何程序代码。它也可以用来隐藏代码。注释不是程序的一部分，但它增强了程序的交互性并使程序可读。

---

Python中的注释可用于解释任何程序代码。它也可以用来隐藏代码。

评论是任何计划中最有用的东西。它使我们能够理解程序的运作方式。在python中，任何与＃符号一起写的语句都称为注释。口译员不解释评论。

注释不是程序的一部分，但它增强了程序的交互性并使程序可读。

Python支持两种类型的注释：

1)单行注释：

如果用户想要指定单行注释，则注释必须以？＃开头？

例如：

＃这是单行评论。

print“Hello Python”

输出：

Hello Python

2)多行评论：

可以在三重引号内给出多行注释。

例如：

''' 这个

是

多行评论'''

例如：

#single line commentprint“Hello Python”'''这是多行评论'''

输出：

Hello Python

Python中的变量

变量是用于引用内存位置的名称。变量也称为标识符，用于保存值。标识符命名有一定的规则，需要严格遵守。

---

什么是变量？

变量是用于引用内存位置的名称。变量也称为标识符，用于保存值。

在Python中，我们不需要指定变量的类型，因为Python是一种类型推断语言，可以自动获得变量类型。

变量名称可以是字母和数字的组合，但它们必须以字母或下划线开头。

建议使用小写字母作为变量名。Rahul和rahul都是两个不同的变量。

标识符命名

变量是标识符的示例。标识符用于标识程序中使用的文字。下面给出了命名标识符的规则。

•变量的第一个字符必须是字母或下划线(_)。•除第一个字符之外的所有字符可以是小写字母(az)，大写字母(AZ)，下划线或数字(0-9)的字母表。标识符名称不得包含任何空格或特殊字符(！，@，＃，％，^，＆，*)。•标识符名称不得与该语言中定义的任何关键字相似。•标识符名称区分大小写，例如我的名称，MyName不相同。

有效标识符的示例：a123，_n，n_9等。无效标识符的示例：1a，n％4，n 9等。

声明变量和赋值

在使用应用程序之前，Python并没有限制我们声明变量。它允许我们在所需的时间创建变量。

我们不需要在Python中声明显式变量。当我们为变量赋值时，自动声明变量。

equal(=)运算符用于为变量赋值。

例如：

输出：

>>> 10ravi20000.67

多重赋值

Python允许我们在单个语句中为多个变量赋值，这也称为多重赋值。

我们可以通过两种方式应用多个赋值，方法是将单个值分配给多个变量，或者将多个值分配给多个变量。让我们看看给出的例子。

1.为多个变量分配单个值

例如：

X = Y = Z = 50Print xPrint yPrint z

输出：

>>> 505050

2.将多个值分配给多个变量，将按变量出现的顺序分配值。：

例如：

A，B，C = 5,10,15Print aPrint bPrint c

输出：

>>> 51015

type()函数

变量可以保存不同数据类型的值。Python是一种动态类型语言，因此我们无需在声明变量时定义变量的类型。解释器隐式地将值与其类型绑定。

Python使我们能够检查程序中使用的变量的类型。Python为我们提供了type()函数，它返回传递的变量的类型。

请考虑以下示例来定义不同数据类型的值并检查其类型。

 A=10  b="Hi Python"  c = 10.5  print(type(a));   print(type(b));   print(type(c));

输出：

Python 关键字

Python关键字是特殊的保留字，它为编译器/解释器传达了特殊的含义。每个关键字都有特殊含义和特定操作。这些关键字不能用作变量。

---

Python关键字是特殊的保留字，它为编译器/解释器传达了特殊的含义。每个关键字都有特殊含义和特定操作。这些关键字不能用作变量。以下是Python关键字列表。

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

部分关键字解释：

1.and：表示逻辑‘与’

2.del：用于list列表操作，删除一个或者连续几个元素。

3.from：导入相应的模块，用import或者from...import

4.not：表示逻辑‘非’

5.while：while循环，允许重复执行一块语句，一般无限循环的情况下用它。示例如下：

while Ture:        if a > b:                add()#调用函数求和        else:                print "输入错误！重新输入！"

6.as：as单独没有意思，是这样使用：with....as用来代替传统的try...finally语法的。

基本思想是with所求值的对象必须有一个enter()方法，一个exit()方法。

紧跟with后面的语句被求值后，返回对象的enter()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面 返回对象的exit()方法。示例如下：

class Sample:        def __enter__(self):        print "In __enter__()"        return "Foo"    def __exit__(self, type, value, trace):        print "In __exit__()"  def get_sample():        return Sample()     with get_sample() as sample:        print "sample:", sample

输出结果：

In __enter__()sample: FooIn __exit__()

第一步： enter()方法被执行

第二步： enter()方法返回的值 - 这个例子中是"Foo"，赋值给变量'sample'

第三步：执行代码块，打印变量"sample"的值为 "Foo"

第四步： exit()方法被调用with真正强大之处是它可以处理异常。可能你已经注意到Sample类的exit方法有三个参数- val, type 和 trace。这些参数在异常处理中相当有用。

你也可以参考这里:http://zhoutall.com/archives/325

7.elif:和if配合使用的，if语句中的一个分支用elif表示。

8.global :定义全局变量，我的理解就是：要想给全局变量重新赋值，就要global一下全局变量(相当于告诉你：哦，注意了！下面我要设定全局变量的值的)，之后在重新赋值。示例如下：

#coding:utf-8#熟悉global#定义全局变量，变量名全部大写NAME = "xueweihan"#得到NAME值def get_NAME():        return NAME#重新设定NAME值def set_NAME(name_value):        global NAME        NAME = name_value        print u"输出全局变量NAME的值:",get_NAME()new_name = "521xueweihan"set_NAME(new_name)    #为全局变量重新赋值    print u"输出赋值完的全局变量NMAE的值:",get_NAME()

输出结果：

输出全局变量NAME的值: xueweihan输出赋值完的全局变量NMAE的值：521xueweihan

9.or：表示逻辑“或”

10.with：和as一起用，使用的方法请看as，在上面！

11.assert：表示断言(断言一个条件就是真的，如果断言出错则抛出异常)用于声明某个条件为真，如果该条件不是真的，则抛出异常：AssertionError

12.else：看下面if的解释

13.if：if语句用于选择分支，依据条件选择执行那个语句块。(这里多说一句：if语句中最好不要嵌套if语句，你可以把嵌套的if语句写在另一个函数中)

if a > b:    print "a > belif a < b:        print "a < b"else:        print "a = b"

14.pass ：pass的意思就是什么都不做。用途及理解：当我们写一个软件的框架的时候，具体方法啊，类啊之类的都不写，等着后续工作在做。那么就在方法和类里面加上pass，那样编译起来就不会报错了！就像这样：

#理解pass的用途def test_pass():    pass  #如果不加pass，抛出错误：IndentationError: expected an indented blocktest_pass()

15.yield ：用起来和return很像，但它返回的是一个生成器。我这样说不是很生动。你可以去看看这个关于Python中的yield(最后写的那个斐波那契，我觉得他就是大神)，或者请看下面的代码：

#理解yielddef test_yield(n):        for i in range(n):            yield i*2#每次的运算结果都返回                  for j in test_yield(8):        print j,":",print u"结束理解yield"       #利用yield输出斐波那契数列def fab(max):        a,b = 0,1        while a < max:                yield a                a, b = b, a+b    print u"斐波那契数列！"    for i in fab(20):            print i,",",

输出结果：

0 : 2 : 4 : 6 : 8 : 10 : 12 : 14 : 结束理解yield

斐波那契数列！

0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 ,

16.break ：作用是终止循环，程序走到break的地方就是循环结束的时候。(有点强行终止的意思)注意：如果从for或while循环中终止(break)之后 ，else语句不执行。

17.except ：和try一起使用，用来捕获异常。

try:         block  except [exception,[data…]]:         block   try:      block  except [exception,[data...]]:         block  else:         block

该种 Python异常处理语法的规则是：

◆执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句。

◆如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句。

◆如果引发的异常不匹配第一个except，则会搜索第二个 except，允许编写的except数量没有限制。

◆如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

◆ 如果没有发生异常，则执行else块代码。

第一种格式：

#理解excepttry:        num = 5/0except:        print u"计算出错"

第二种：

try:         f = open("file.txt","r")      #如果该文件不存在except IOError, e:  #捕获IO异常       print u"IO错误！"       print e   #输出错误信息，这里e是错误信息

输出结果：

计算出错IO错误！[Errno 2] No such file or directory: 'file.txt'

18.import ：用来导入模块，有时这样用from....import

19.print：输出

20.class：定义类

21exec：我还没弄懂exec语句用来执行储存在字符串或者文件中的python语句。可以生成一个包含python代码的字符串，然后使用exec语句执行这些语句。

22.in：查找列表中是否包含某个元素，或者字符串a是否包含字符串b。需要注意的是：不可以查看list1是否包含list2。代码如下：

#理解infirst_list = [1, 2]second_list = [1, 2, 3]element = 1red = 'red'red_clothes = "red clothes"print red in red_clothes #trueprint first_list in second_list  #falseprint element in first_list      #true

输出结果为：

TrueFalseTrue

23.raise：raise可以显示地引发异常。一旦执行raise语句，后面的代码就不执行了

#理解raisetry:    raise IOError     #这里可以raise一个自定义的错误类。那样就叫做自定义异常了        print u"是否执行?" #不执行except IOError:        print "IOError test raise"

输出结果如下：

IOError test raise

24.continue：跳过continue后面循环块中的语句，继续进行下一轮循环。

25.finally:看到finally语句，必然执行finally语句的代码块。

python异常总结，请看下面的代码：

One：

#打开一个文件，但有可能找不到try:        f = open('xxx')        do somethingexcept:        do somethingfinally:        f.close()

Two：

try:        f = open('xxx')except:        print 'fail to open'        exit(-1)try:        do somethingexcept:        do somethingfinally:        f.close()

我们为什么要写finally，是因为防止程序抛出异常最后不能关闭文件，但是需要关闭文件有一个前提就是文件已经打开了。

在第一段错误代码中，如果异常发生在f=open(‘xxx’)的时候，比如文件不存在，立马就可以知道执行f.close()是没有意义的。改正后的解决方案就是第二段代码。

26.is：Python中的对象包含三要素：id、type、value

其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值

is判断的是a对象是否就是b对象，是通过id来判断的

==判断的是a对象的值是否和b对象的值相等，是通过value来判断的

#理解ise = 1es = 1.0ess = 1print u"""is就是比对id的值，看是否指向同一对象，这里需要注意的是：同一对象,不是值相等就是同一对象。"""print id(e)print id(es)print id(ess)

27.return：用于跳出函数，也可以在跳出的同时返回一个值。

28.def：用于定义方法

29.for：for....in 一起使用：它在一序列的对象上递归，就是遍历队列中的每个项目

30.lambda:即匿名函数，不用想给函数起什么名字。提升了代码的简洁程度。如：

#理解lambdag = lambda :"lambda test."print g()num1 = lambda x, y=1:x + yprint num1(1)      #多个变量的时候，可以不给有默认值的变量传值print num1(10,10)  #值得注意的是，如果y没有默认值而且不给它传值的话报错！

输出结果：

lambda test.220

31.try：出现在异常处理中，使用格式为：try...except，try中放想要执行的语句，except捕获异常

Python的数据类型

变量可以包含不同类型的值。同时Python提供了各种标准数据类型，用于定义每个数据类型的存储方法。Python中有这几种数据类型：数字、字符串、列表、元组、字典。

---

什么是标准的数据类型？

变量可以包含不同类型的值。例如，一个人的名字必须存储为字符串，而其id必须存储为整数。

Python提供了各种标准数据类型，用于定义每个数据类型的存储方法。Python中定义的数据类型：数字、字符串、列表、元组、字典。

数字Number

数字存储数值。当数字分配给变量时，Python会创建Number对象。例如;

a =  3  ，b =  5 #a，b是数字对象

Python支持4种类型的Number数据。

•int(有符号整数，如10,2,29等)•long(长整数用于更高范围的值，如908090800L，-0x1929292L等)•float(float用于存储浮点数，如1.9,9.902,15.2等)•complex(复杂的数字，如2.14j，2.0 + 2.3j等)

Python允许我们使用小写L来使用长整数。但是，我们必须始终使用大写L来避免混淆。

复数包含有序对，即x + iy，其中x和y分别表示实部和虚部。

字符串String

字符串可以定义为引号中表示的字符序列。在python中，我们可以使用单引号，双引号或三引号来定义字符串。

python中的字符串处理是一项简单的任务，因为提供了各种内置函数和运算符。

在字符串处理的情况下，operator +用于连接两个字符串，因为操作“hello”+“python”返回“hello python”。

operator 被称为重复运算符，因为操作“Python” 2返回“Python Python”。

以下示例说明了python中的字符串处理。

str1 = 'hello javatpoint' #string str1  str2 = ' how are you' #string str2  print (str1[0:2]) #printing first two character using slice operator  print (str1[4]) #printing 4th character of the string  print (str1*2) #printing the string twice  print (str1 + str2) #printing the concatenation of str1 and str2

输出：

heohello javatpointhello javatpointhello javatpoint how are you

列表list

列表类似于C中的数组。但是; 列表可以包含不同类型的数据。存储在列表中的项目用逗号(，)分隔，并用方括号[]括起来。

我们可以使用slice [：]运算符来访问列表的数据。连接运算符(+)和重复运算符(*)以与处理字符串相同的方式使用列表。

如下示例：

l  = [1, "hi", "python", 2]  print (l[3:]);  print (l[0:2]);  print (l);  print (l + l);  print (l * 3);

输出：

[2][1, 'hi'][1, 'hi', 'python', 2][1, 'hi', 'python', 2, 1, 'hi', 'python', 2][1, 'hi', 'python', 2, 1, 'hi', 'python', 2, 1, 'hi', 'python', 2]

元组tuple

元组在很多方面类似于列表。与列表一样，元组也包含不同数据类型的项集合。元组的项用逗号(，)分隔并括在括号()中。

元组是只读数据结构，因为我们无法修改元组项的大小和值。

让我们看一个元组的简单例子。

t  = ("hi", "python", 2)  print (t[1:]);  print (t[0:1]);  print (t);  print (t + t);  print (t * 3);   print (type(t))  t[2] = "hi";

输出：

('python', 2)('hi',)('hi', 'python', 2)('hi', 'python', 2, 'hi', 'python', 2)('hi', 'python', 2, 'hi', 'python', 2, 'hi', 'python', 2)Traceback (most recent call last):  File "main.py", line 8, in     t[2] = "hi";TypeError: 'tuple' object does not support item assignment

字典dictionary

Dictionary是键值对项的有序集合。它就像一个关联数组或一个哈希表，其中每个键存储一个特定的值。Key可以保存任何原始数据类型，而value是任意Python对象。

字典中的项目用逗号分隔，并用花括号{}括起来。

请考虑以下示例。

d = {1:'Jimmy', 2:'Alex', 3:'john', 4:'mike'};   print("1st name is "+d[1]);  print("2nd name is "+ d[4]);  print (d);  print (d.keys());  print (d.values());

输出：

1st name is Jimmy2nd name is mike{1: 'Jimmy', 2: 'Alex', 3: 'john', 4: 'mike'}[1, 2, 3, 4]['Jimmy', 'Alex', 'john', 'mike']

Python Literals

Python Literals是Python中的文字类型，文字可以定义为以变量或常量给出的数据。Python中的文字包括字符串文字、数字文字、布尔文字、特殊文字和集合文字。

---

文字可以定义为以变量或常量给出的数据。

Python支持以下文字：

I.字符串文字

可以通过在引号中包含文本来形成字符串文字。我们可以对String使用单引号和双引号。

例如：

“aman”，“12345”

字符串的类型：

Python支持两种类型的字符串：

a)单行字符串 - 终止在一行内的字符串称为单行字符串。

例如：

>>> text1 ='你好'

b)多行字符串 - 沿多行传播的一段文本称为多行字符串。

有两种方法可以创建多行字符串：

1)在每行末尾添加黑色斜杠

例如：

>>> text1 ='hello\user'>>> text1'hellouser'

2)。使用三重引号

例如：

>>> str2='''''welcome to SSSIT'''  >>> print str2  welcome  to  SSSIT

II.Numeric literals

数字文字是不可变的。数字文字可以属于以下四种不同的数字类型。

Int(有符号整数)	long(长整数)	float(浮点)	complex(复杂)
数字(可以是正数和负数)，没有小数部分.eg：100	无限大小的整数，后跟小写或大写L，例如：87032845L	具有整数和小数部分的实数，例如：-26.2	以a + bj的形式，其中a形成实部，b形成复数的虚部。例如：3.14j

III.布尔文字

布尔文字可以包含以下两个值中的任何一个：True或False。

IV.特殊文字

Python包含一个特殊的文字，即None。

None用于指定未创建的字段。它也用于Python中的列表末尾。

例如：

>>> val1=10  >>> val2=None  >>> val1  10  >>> val2  >>> print val2  None  >>>

V.Literal Collections

Python中使用了诸如元组，列表和字典之类的集合。

列表：list

• list包含不同数据类型的项目。列表是可变的，即可修改的。

• 存储在List中的值用逗号(，)分隔，并用方括号([])括起来。我们可以在List中存储不同类型的数据。

• 可以使用切片运算符([]和[：])检索存储在List中的值。

• 加号(+)是列表串联，星号(*)是重复运算符。

例如：

>>> list=['aman',678,20.4,'saurav']  >>> list1=[456,'rahul']  >>> list  ['aman', 678, 20.4, 'saurav']  >>> list[1:3]  [678, 20.4]  >>> list+list1  ['aman', 678, 20.4, 'saurav', 456, 'rahul']  >>> list1*2  [456, 'rahul', 456, 'rahul']

Python运算符

在Python中可以将运算符定义为负责两个操作数之间的特定操作的符号。Python中的运算符包括算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符、运算符优先级。

---

在Python中可以将运算符定义为负责两个操作数之间的特定操作的符号。

运算符是程序运行的核心。Python提供了如下所述的各种运算符。

•算术运算符•比较运算符•赋值运算符•逻辑运算符•位运算符•成员运算符•身份运算符•运算符优先级

---

算术运算符

算术运算符用于在两个操作数之间执行算术运算。它包括+(加法)， -(减法)，*(乘法)，/(除法)，％(取余)，//(向下取整)和指数(**)。

请通过下表学习算术运算符的详细内容：

运算符	描述	示例
+(加法)	它用于两个操作数相加	例如：如果a = 20，b = 10 => a + b = 30
- (减法)	它用于从第一个操作数中减去第二个操作数。如果第一个操作数小于第二个操作数，则结果为负值	例如：如果a = 20，则b = 10 => a？b = 10
/(除)	它在将第一个操作数除以第二个操作数后返回商	例如：如果a = 20，则b = 10 => a / b = 2
*(乘法)	它用于将一个操作数与另一个操作数相乘	例如：如果a = 20，则b = 10 => a * b = 200
％(取余)	它在将第一个操作数除以第二个操作数后返回余数	例如：如果a = 20，则b = 10 => a％b = 0
**(指数)	它是一个指数运算符，表示为计算第二个操作数量的的第一个操作数相乘	例如：10**20 为10的20次方， 输出结果 100000000000000000000
//(向下取整)	它给出了通过两个操作数产生的商并进行向下取整	例如：9//2=4

---

比较运算符

比较运算符用于比较两个操作数的值，并相应地返回布尔值true或false。比较运算符如下表所述：示例中a=1,b=2

运算符	描述	示例
==	如果两个操作数的值相等，则条件变为真	(a == b) 返回 False
！=	如果两个操作数的值不相等，则条件变为真	(a ！= b)返回true
<=	如果第一个操作数小于或等于第二个操作数，则条件变为真，这个运算符类似 !=	(a <= b) 返回 true
> =	如果第一个操作数大于或等于第二个操作数，则条件变为真	(a >= b)返回false
<>	如果两个操作数的值不相等，则条件变为真	(a <> b)返回 true
>	如果第一个操作数大于第二个操作数，则条件变为真	(a > b)返回flase
<	如果第一个操作数小于第二个操作数，则条件为真	(a < b)返回true

---

Python赋值运算符

赋值运算符用于将右表达式的值赋给左操作数。赋值运算符如下表所述。

运算符	描述	实例
=	它将右表达式的值赋给左操作数	c=a+b，将a+b的值赋值给c
+ =	它通过右操作数的值增加左操作数的值，并将修改后的值赋给左操作数	例如，如果a = 10，则b = 20 => a + = b将等于a = a + b，因此a = 30
- =	它将左操作数的值减小右操作数的值，并将修改后的值分配回左操作数	例如，如果a = 20，则b = 10 => a- = b将等于a = a-b，因此a = 10
* =	它将左操作数的值乘以右操作数的值，并将修改后的值赋值回左操作数	例如，如果a = 10，则b = 20 => a * = b将等于a = a * b，因此a = 200
％=	它将左操作数的值除以右操作数的值，并将提醒返回到左操作数	例如，如果a = 20，则b = 10 => a％= b将等于a = a％b，因此a = 0
**=	幂赋值运算符，a ** = b将等于a = a ** b	例如，如果a = 4，b = 2，a ** = b将4 ** 2 = 16分配给a
//=	取整除赋值运算符，A // = b将等于a = a // b	例如，如果a = 4，b = 3，则a // = b将4 // 3 = 1分配给a

---

按位运算符

按位运算符对两个操作数的值执行逐位操作。

例如，

if a = 7;     b = 6;   then, binary (a) = 0111      binary (b) = 0011  hence, a & b = 0011        a | b = 0111               a ^ b = 0100         ~ a = 1000

运算符	描述	实例
＆(二进制和)	如果两个操作数中相同位置的两个位都是1，则将1复制到结果中。否则，复制0。	(a & b) 输出结果 12 ，二进制解释：0000 1100
| (二进制或)	如果两个位都为零，则结果位为0，否则结果位为1。	(a | b) 输出结果 61 ，二进制解释：0011 1101
^(二进制xor)	如果两个位都不同，则结果位将为1，否则结果位将为0。	(a ^ b) 输出结果 49 ，二进制解释：0011 0001
〜(否定)	它计算操作数的每个位的否定，即，如果该位为0，则结果位为1，反之亦然。	(~a ) 输出结果 -61 ，二进制解释：1100 0011，在一个有符号二进制数的补码形式。
<	左操作数值向左移动右操作数中的位数。	a << 2 输出结果 240 ，二进制解释：1111 0000
>>(右移)	左操作数向右移动右操作数中的位数。	a >> 2 输出结果 15 ，二进制解释：0000 1111

---

逻辑运算符

逻辑运算符主要用于表达式求值以做出决策。Python支持以下逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	描述	实例
and	如果表达式都为真，则条件为真。如果a和b是两个表达式，则a→true，b→true => a和b→true	(a and b) 返回 20
not	如果其中一个表达式为真，则条件为真。如果a和b是两个表达式，则a→true，b→false => a或b→true	(a or b) 返回 10
or	如果表达式a为真，则不是(a)将为假，反之亦然	not(a and b) 返回 False

---

成员运算符

Python成员资格运算符用于检查数据结构中的值的成员资格。如果该值存在于数据结构中，则结果值为true，否则返回false。

运算符	描述	实例
in	如果在第二个操作数(列表，元组或字典)中找到第一个操作数，则将其评估为true。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
Not in	如果在第二个操作数(列表，元组或字典)中找不到第一个操作数，则将其评估为true。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

---

身份运算符

运算符	描述	实例
is	如果两侧存在的参数指向同一对象，则返回为真	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
not is	如果两侧存在的参数不指向同一对象，则返回为真。	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

---

运算符优先级

运算符的优先级很重要，因为它使我们能够知道应该首先执行哪个运算符。python中运算符的优先级表如下。

运算符	描述
**	指数运算符优先于表达式中使用的所有其他运算符。
〜+ -	否定，一元加减。
* /％//	乘法，除法，模块，提醒和楼层划分。
+ -	二进制加减
>> <<	左移和右移
＆	二进制和。
^ |	二元xor和or
<= <>> =	比较运算符(小于，小于等于，大于，大于等于)。
<> ==！=	比较运算符
=％= / = // = - = + =	等于运算符
* = ** =	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

---

END

时光，在物转星移中渐行渐远，春花一梦，流水无痕，没有在最想做的时候去做的事情，都是人生的遗憾。人生需要深思熟虑，也需要一时的冲动。