标签：运算符 变量 Python True 基础 语法 第二章 数据 表达式

 

   目   录

1. 第一个Python程序 

2. 数据与数据类型 

3. 数据类型转换 

4. 标识符 

5. 变量 

6. 常量 

7. Python运算符 

8. 表达式 

9. 语句 

10. 实例：

 

语法基础

        任何一段计算机程序都是由一组计算机能够理解的指令构成，其中每条指令都表现为遵循一定语法规则的字符串序列。因此，学习Python编程，首先要学习Python语言的语法规则，然后，才能实现满足一定逻辑过程的程序代码来。在开始学习Python编程之前，我们有必要先从语法结构的视角来理解一下Python程序，以便我们该如何入门学习Python编程，也可避免在后续的学习过程中只见树木，不见森林。

总的来说，一段Python程序就是能够完成一定功能的代码的集合，这些代码可以分解为模块、语句、表达式和对象这四个层次。如果从自顶向下的角度来分解一段程序，那就是：

1、程序由模块构成；

2、模块包含着不同的语句；

3、语句包含着表达式；

4、表达式由数据对象和运算符构成。

如果从自底向上的角度来看，那就是：

1、数据对象和运算符组成表达式；

2、表达式构成语句；

3、语句构成模块；

4、模块组成最终的程序。

因此，在这章中我们按照自底向上的顺序依次介绍：对象、表达式、语句这几部分知识。

第一个Python程序

        我们首先来看一个问题：身体质量指数（Body Mass Index, BMI）是衡量人肥胖的一个指标，它是通过一个人的体重（kg）和身高(m)来计算的数值，计算的公式是：

中国官方发布的《中国成人超重和肥胖症预防控制指南》所认定中国人的BMI值与肥胖间的关系为：

1. BMI < 18.5：偏瘦
2. 18.5 <= BMI <= 24：正常
3. BMI > 24：偏胖

        下面我们设计一段Python程序来根据一个人的体重和身高计算其BMI指数，进而判断其肥胖程度。

程序如下：

1. weight = input('请输入您的体重（kg）：')
2. height = input('请输入您的身高（m）：')
3. weight = int(weight)
4. height = float(height)
5. BMI = weight / height**2
6. if BMI > 24:
7.     print('您的BMI值为 %2.2f, 体型%s'% (BMI, '偏胖'))
8. elif BMI < 18.5:
9.     print('您的 MI值为 %2.2f, 体型%s'% (BMI, '偏瘦'))
10. else:
11.     print('您的BMI值为 %2.2f, 体型%s'% (BMI, '正常'))

可以从三个视角来分析这段程序：

第一个视角：程序 = 业务逻辑 + 语法规则

        首先分析一下整个程序的逻辑流程。程序第1、2行分别用来接收用户输入的体重和身高值。由于Python程序接收到的两个数值是字符串格式的，不能直接进行数值运算，因此第3、4行将这两个字符串型的数字转换为数值型的数字。第5行是计算BMI指数值。从第6行至末尾的11行，是通过一个if-else复合语句来根据BMI值判断这个人的肥胖程度，同时在屏幕上显示判断结果。

从代码可以看出程序流程遵循着这样的逻辑过程：

1. 获取用户的体重身高值→②计算BMI值→③判断肥胖程序→④输出结果

这就说明，设计程序的时候必须遵守所要解决问题的逻辑过程，这样的程序才能正确解决问题。

        同时，确定了逻辑过程只是确定了解决问题的方法步骤，那么如何用Python语言实现每一步设定的功能呢？那就必须要遵守Python语言规定的语法规则。例如在计算BMI值时，虽然我们知道计算的方法，可是要用Python语言实现这个方法，还必须要懂得和遵守Python的语法规则（例如程序中第5行的代码）。

从上面的分析可知，一段程序要能够正确解决问题，它必须要遵守解决问题的逻辑流程，同时还必须遵守编程语言的语法规则。因此，我们可以说：

程序 = 业务逻辑 + 语法规则

第二个视角：程序 = 数据 + 操作

接着，我们再换一个视角来分析同样这段程序。

        程序的第1、2行是接收用户输入的体重、身高数据，并将这两个数据分别保存在weight和height这两个变量中。接着第3、4行是将这两个数据由字符型转换为数值型。第5行是将接收的两个数值按照BMI的计算方法进行计算，获得BMI指数值。第6-11行是对获得的BMI值进行判断，并将判断结果显示在屏幕上。

        从上述的分析过程可以清楚感受到这段程序就是在不断地对数据进行各种处理：接收数据、转换数据类型、计算数据、在屏幕上显示数据。事实上，任何程序皆是如此（注意：在编程中，数字和字符以及字符串都被认为是数据）。因此，我们又可以说任何一个程序都是由数据和对数据的操作构成的，即：

程序 = 数据 + 操作

第三个视角：程序的语法层次

最后，我们再从语法结构的角度来看，一段程序是由一行一行的语句构成的的（符合语句占有多行位置），每条语句都完成一个很具体的小功能，例如上面程序中的语句分别完成接收数据、计算BMI指数、在屏幕显示数据。所以，程序是由语句构成的。

        有些语句又包含着表达式。例如第7、9、11行分别是独立的打印语句，打印的内容（即print()函数的参数）是一个表达式。第5行是一个赋值语句，将计算结果赋给变量BMI，但是其中对数据的计算公式“weight / height**2”又是一个表达式，表达式负责完成一个计算。因此，可以说语句是由表达式构成的。

        每个表达式都是完成一个具体的计算过程，因此从语法上说，表达式是由操作数（数据）和操作符（对数据进行的操作）构成的。

        因此，从语法层次上可以说，程序是由语句构成的，语句是由表达式构成的，表达式又是由操作数和操作符构成的。这一思想用下图来表示：

计算机程序 语句 表达式 数据 + 运算符

学习编程的方法路线：

        通过对这段程序从不同角度进行分析，我们不但对计算机程序的认识更深刻了，同时也就知道了学习一门编程语言的顺序：先学习这门语言的语法基础，其中包括：数据分为哪些类型？数据是如何表示的？有哪些运算符？什么是表达式和语句？有了这些基础的语法知识后，就能够顺利地学习这门编程语言的其它知识了。

数据与数据类型

计算机程序的运行过程从本质上说就是对数据的操作过程。例如在示例程序中用户输入的体重和身高值，以及程序中计算出来的BMI值，这都是程序处理的数据。可以说数据是计算机程序加工的原材料，因此，数据在一个程序中扮演着非常重要的作用。

数据表示的两种形式

首先我们要明白程序中是如何表示数据的。一般来说，在程序中的数据有两种表示方式：字面值（literal values）形式和变量（variables）形式。

字面值（也叫字面量）就是直接用该数值本身表示该数据。例如要打印出整数100的打印语句“print(100)”，其中的“100”就是整数100的字面值。类似的，'Hello'，3.14，True分别是字符串、浮点数和布尔值的字面值。

       字面值是表示和使用数据的最直接方法，也被称为数据的硬编码。但是，在编程中我们更常用的方式就是用“变量”来表示一个数据。在这里，我们可以先把变量理解成是给数据起的一个名字，它同时也是对计算机中一个内存地址的引用。例如下面程序中用变量name来表示人名字符串'WangJun'，用变量age表示年龄18。

>>> name = 'WangJun'

>>> age = 18

 

这时，在程序中使用变量“name”或者“age”时，就等同于使用数据“WangJun”或者18。例如：

>>> print(name)

WangJun

>>> print(age + 3)

21

 

数据的类型

       程序设计语言还将数据划分为不同的类型，不同类型的数据在内存中存储的机制不同、存储时占用的内存空间大小不同，而且对不同类型的数据提供的操作也是不同的。例如两个整数可以进行加减乘除四则运算，但是两个字符或字符串就不能进行减法或者乘除运算。

Python基本数据类型：

类型	名称	是否可变对象	示例
整型Integer	int	No	25, 36
浮点型Float	float	No	3.14, 2.3e5
复数Complex	complex	No	3j, 2+3j
布尔型Boolean	bool	No	True, False
字符串String	str	No	'a', 'hello'
列表List	list	Yes	['apple', 'orange', '']
元组Tuple	tuple	No	(2, 3, 6)
字节串Bytes	bytes	No	b'ab\xff'
字节数组ByteArray	bytearray	yes	bytearray(...)
集合Set	set	Yes	set([5, 3, 8])
集合Frozen set	frozenset	no
字典Dictionary	dict	yes	{'name':'ZhangLei', 'age':18}

上表中第一列显示了Python的不同的数据类型。紧接着第二列是相应数据类型在Python语言中的名称。如果我们想知道一个数据对象的类型，可以用Python的内置函数type()来查看，该函数返回表中第二列中的名称来表示相应类型。请看示例：

>>> type(25)

<class 'int'>

>>> type((2,3,6))

<class 'tuple'>

 

        第二列中的类型名称还有一个重要的用途：当我们在程序中需要判断一个数据对象是否为某种数据类型，并根据判断结果做不同的操作时，我们可以利用Python的一个内置函数isinstance(object, classinfo)。该函数接收两个参数：第一个参数是待判断的数据对象，第二个参数就是某种数据对象的类型，可用上表中的类型名称来表示。当第一个参数中的数据对象类型与第二参数中的类型吻合时，函数返回True，否则返回False。如果再结合Python中的if语句，就是可以完成一个判断过程。例如程序：

person = {'name':'WangJun', 'age':18}

if isinstance(person, dict):

print('yes')

else:

print('no')

 

        为方便起见，可以将Python数据的类型分为四类：数值型、布尔型、字符串型、复合数据类型。其中数值型包括：int（整型）、float（浮点型）、complex（复数），布尔型只有一种bool，字符串型也只有一种：str。

Python数据类型

数值型

布尔型

字符串型

复合型

（一）整数（int）

在编程中，整型数是最基本和常用的数值，可用来表示人的年龄、物品的数量等。在很多编程语言（包括Python2）中，整型数据都分为短整型（int）和长整型（long）两种类型，分别对应着不同的取值范围。但是在Python3中，对此不作区分，统一为一种int型。Python3中的int型数值的取值范围是没有限制的，其取值范围是由系统的内存大小来确定的。例如执行程序：

>>>print(123456789123456789123456789123456789 + 10)

 

        可返回结果：123456789123456789123456789123456799。因此，Python3中的int型已经能够承担其它语言中的长整型（long）的功能了。但是须注意，Python并非为所有的int型数分配固定大小的内存，而是根据数的实际大小来分配适合的内存。也就是说，随着整数值的增大，Python会动态的增大内存以便容纳该数。下面示例就说明了该问题：

>>> sys.getsizeof(1)

   28

>>> sys.getsizeof(123456789123456789123456789123456789)

   40

 

这就是Python方便了我们，但要付出运行速度慢的代价。

（二）浮点数（float）

Python中将带小数点的数字称为浮点数。

>>>type(12.3)

<class 'float'>

>>>2.

2.0

>>>.2

0.2

 

注意：整型数和浮点数都可以与“e”或者“E”结合，进行科学表示法，但表示结果都为浮点数：

>>>2e3

2000.0

>>>2E-3

0.002

>>>0.2e3

200.0

>>>0.2e-3

0.0002

 

（三）复数（complex）

复数表示格式为：<real part> + <imaginary part>j。例如：

>>>2+3j

(2+3j)

>>>type(2+3j)

<class 'complex'>

 

（四）布尔数（bool）

        在Python中，bool型数据用来表示逻辑判断中的“真”和“假”两种情况。bool型数据只有两个字面值，即“True”和“False”，分别表示逻辑上的“真”和“假”。它们也都是Python的关键字。需要注意的一个细节是，Python中的两个bool值必须是首字母大写的形式，如果将“True”写作“true”，则不会被认为是bool值了。

关于bool型数据，Python语言有一个特殊之处就是它除了将“True”和“False”按照逻辑值来对待的同时，也将所有的内置对象当作bool型对象来对待和使用。Python规定除了下面这些内置对象被视作是“假”外，其余的均被视为“真”:

• • 常量：None和False
  • 数值类型中：0，0.0，0j，以及Decimal(0), Fraction(0, 1)
  • 空的序列和多项集: '', (), [], {}, set(), range(0)

例如：

if 3:

print('yes')

else:

print('no')

 

程序运行后会输出“yes”。如果将if后的数字换为0，则会输出“no”。

同时，对于整型和浮点型数，Python不但将其当作bool型数据，也将bool值的“True”和“False”看作是int型数据：将“True”看作整数1，将“False”看作0，允许bool型数与int型、float型数进行运算。例如：

>>> True + 2

3

>>> False + 2

2

 

（五）字符串（str）

        字符串就是一串字符，用来表示字母、人名、文本等数据。在很多数编程语言中，单个字符和字符串是区别对待的，前者用一对单引号括起来，而后者用一对双引号括起来。但是在Python语言中，不区分单个字符和字符串，统一按照字符串来处理，并且用单引号或者双引号来表示，结果是一样的。

>>> type('I am a String') #使用单引号

<class 'str'>

>>> type("I am a String") #使用双引号

<class 'str'>

>>> type('a') #单个字符也被当做str型数据

<class 'str'>

>>> type("a")

<class 'str'>

 

一个字符串可以包含任意多的字符，其限制只取决于计算机的内存。

如果一个字符串中包含单引号或者双引号，最简单的表示方法就是用不同的符号来表示，例如：

>>> print("I have a single quote (') character.")

I have a single quote (') character.

>>> print(' I have a double quote (") character.')

I have a double quote (") character.

 

由于字符串在程序中的使用非常频繁，第四章将专门讲解字符串方法的知识。

关于复合数据类型，会在后面专门介绍。

数据对象

        最后再说明一点，Python语言将每种类型的数据都封装为“类（class）”，每个具体的数据都是一个“对象（Object）”，所以经常会将一个数据称为“数据对象”。这里的“类”和“对象”是面向对象程序设计中的概念，此处不对其含义作详细介绍。我们可以先将其理解为：一个数据对象就是将数据本身以及相关信息进行的打包（或者称为盒子），其中的信息至少包含着：

• 数据
• 数据的类型
• 数据对象的唯一的id
• 对该数据的引用数

数据类型转换

        在编程过程中，经常需要将一个数据从一种类型转换为另一种类型，称为数据类型转换。例如在很多桌面应用程序和Web程序中，需要用户从交互式界面中输入自己的身高，这时程序所获得的身高值是一个字符串类型的数据，例如“182”厘米。这种字符串类型的数据不能当作整数来进行数值运算，因此需要将其转换为整数类型。隐式转换，显式转换

        Python提供了一组内置函数：int()、float()、complex()、bool()、str()，用来将一种类型的数据转换至指定类型的数据。例如函数int()可以将一个字符串或者浮点数转换为整数，而float()函数可以将一个整数或者字符串转换为浮点数。但输入的字符串必须是一个表示整数或者浮点数的字符串，否则函数会抛出异常。例如：

>>> float('23.5')

23.5

>>> float('abc')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: could not convert string to float: 'abc'

 

需要注意的是，在进行类型转换中，可能会发生数据丢失。例如通过int()函数将一个浮点数转换为整数时，浮点数中的小数部分就会被丢弃（不是四舍五入）。

Python语言中，上述的通过调用类型函数来进行数据类型转换的方式称为“显式类型转换”。相应的，还有一种“隐式类型转换”，即Python解释器自动进行的数据类型转换，不需要我们显式地干预。例如当一个整数与一个浮点数进行加法运算时，其结果为一个浮点数：

>>> 3 + 1.2

4.2

 

上述的计算过程就包含了一个隐式的数据类型转换：Python语言先将整型数“3”转换为浮点类型，然后再与浮点数“1.2”进行加法运算，从而运算结果也是浮点型数。

标识符

标识符就是给程序中的变量、函数、类以及对象等元素进行命名的字符串。例如：

>>> weight = 67

>>> height = 1.74

>>> def get_BMI( weight,height):

∙∙∙ return weight / height**2

 

上面程序中的“weight”、“height”、“get_BMI”等都是标识符。

        为了使整个程序能够正确编译和运行，在命名时所采用的标识符必须遵循一定的规则，否则就会导致一些问题。例如，如果某个变量名采用Python语言的关键字，那么程序在编译阶段就会报错，因为编译器仍然将该标识符按照关键字来对待，这是会出现语法。再例如，如果变量名采用了Python内置函数名，该函数就会被覆盖。如果整个程序并没有使用该函数，那么这个程序运行起来也没有问题。但是当程序其它地方调用该函数时就会报错。

总结起来，Python中的标识符应遵循下列规则：

• 标识符由字母、数字、下划线构成；
• 必须以字母或下划线开始；
• 不能是关键字；
• 可以是任意长度。

那么如何知道当前Python语言有哪些关键字呢？Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字。可以通过下面两行代码查看全部关键字：

import keyword

print( keyword.kwlist )

 

输出结果为：

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']

此外，在编程实践中要特别注意小写字母“l”和数字“1”的区别，以及字母“O”与数字“0”的区别。

变量

变量是数据的“名字”

在Python程序中表示和使用数据的方式有两种：（1）通过数据的字面值来表示和使用数据，（2）通过变量来表示和使用数据。前者是直接的方式，例如要计算两个整数23和15的和时：

>>> 23 + 15

38

 

上面程序中的“23”和“15”就是两个整数的字面值。

在Python程序中用变量来表示和使用数据是更加常见的方式。我们可以将变量理解为给数据起的一个名字，例如：

>>> age = 21

>>> height = 1.82

>>> print(height)

1.82

 

        上面程序中第一、二行代码分别创建了两个变量：“age”和“height”，它们分别表示整数“21”和浮点数“1.82”，也称变量“age”和“height”的值为“21”、“1.82”。在这之后，对变量的引用就等同于对相应数据的使用。例如打印输出浮点数1.82完全可以通过使用变量“height”来进行，即“print(height)”。

变量赋值

事实上，变量的价值不仅仅是给某个数据起个名字，变量的本质是用于引用程序中随时会变化的值。例如当程序中需要处理不同人的身高时，我们可以令变量height的值为某个人的身高1.82，也可以为另一个人的身高1.75。例如：

>>> height = 1.82

>>> print(height)

1.82

>>> height = 1.75

>>> print(height)

1.75

 

变量本身没有“类型”

        在Python语言中，有人也习惯于说“变量age是整型变量”、“变量height是浮点型便”。这实际上是来自于C++或者Java语言的程序员的习惯。在C++和Java语言中创建一个变量的时候必须指定其类型，紧接着，给该变量赋值时就必须赋予与其类型相符合的数据。但是在Python语言中并没有这种限制：在同一段程序中，一个变量可以引用不同类型的数据。因此，严格地讲，Python语言中的变量是没有类型的。例如

>>> a = 15

>>> type( a )

<class 'int’>

>>> a = 'Hello'

>>> type( a )

<class 'str’>

>>> a = True

>>> type( a )

<class 'bool'>

 

        此外，Java或C/C++中变量的“声明”和“赋值”是两个概念，可以只声明而不赋值，也可以先声明，然后再赋值，也可以将声明和赋值同时完成（一行代码）。但是在Python中不存在单独的“声明”变量，也就是将声明和赋值同时完成。因此我们称之为“定义变量”。

同时给多个变量赋值

定义变量除了上述方式外，还有两种同时给多个变量赋值的形式：

>>> a = b = c = 15 #三个变量赋相同的值

>>> a, b, c = 15, 16, 17 #三个变量赋不同的值

>>> a, b, c = 15, 'Hello', True #赋不同类型的值

 

        Python为字符串变量也提供了很多函数，用于对该字符串进行各种操作。例如：

>>> a = “Hello, Python!”

>>> print(a.upper()) #输出“HELLO, PYTHON!”

 

常用函数包括：

title()：将字符串中每个单词首字母大写

lower()：所有字母小写

lstrip()：删除起始空白

rstrip()：删除末尾空白

find(sub)：返回指定字符串sub 在当前字符串中出现的位置，不存在返回-1

常量

Python没有定义常量的语法，Python并未提供如C/C++/Java一样的const修饰符，也就是说Python中没有“常量”这个概念。只能用变量去表达常量。为了区别，python程序一般通过约定俗成的变量名全大写的形式表示这是一个常量。

Python运算符

        前面介绍了“数据”的基本概念，涉及到了数据的类型以及变量等重要概念。数据是计算机程序所处理的基本对象，也是构成计算机程序的基本“细胞”。单独的数据只能表示某种信息，是静态的，不能完成任何运算，更谈不上实现什么功能。数据首先需要和运算符结合起来，构成计算机程序的更高一级的单元：表达式，才能完成一定的运算，同时也为实现其它的功能做好准备。

Python语言有7大类运算符:算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符，此外，还包括：身份运算符、成员运算符。

（一）算术运算符：共7个

以下假设变量： a=10，b=20：

运算符	描述	实例
+	加 - 两个对象相加	20 + 10结果为30
-	减 - 得到负数或是一个数减去另一个数	20 - 10 结果为 10， -10 结果为10的相反数
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	20 * 3 输出结果 60。 'ab' * 3，结果为'ababab'
/	两个数相除	20 / 4，结果为5.0。
//	向下取整除，返回商的整数部分（向下取整，或向左靠齐）	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	求模运算：返回除法的余数	9 % 2，结果为1。 9.0 % 2，结果为1.0
**	幂运算，x**y结果为x的y次幂	2 ** 3，结果为8

上表中的7个算术运算符都是二目运算符：即每个运算符须关联两个运算数完成相应的运算，如上表中第三列“实例”所示。

当参加运算的两个变量的类型不同时，Python会进行隐式的类型转换，进而确定了运算结果的类型。类型转换遵循原则：

当int型与bool型进行加、减、乘运算时，bool型转换为int型，运算结果为int型，而两者进行除法运算时，结果转换为float型。

当int型或bool型与float型进行上述7中算术运算时，会将int型以及bool型转换为float型，从而结果是float型。

特别的，当两个int型数进行除法“/”运算时，在Python 2中，规定结果仍为int型，即使两个整数不能整数时，结果会去除小数部分，只保留整数部分。而在Python 3中，则规定除法“/”运算的结果统一为float型。例如：

>>> 9/6

1.5

>>> 9/3

3.0

 

（二）比较运算符：共6个

比较运算符用于对两个对象进行比较，判断两者间的关系，通常用于布尔测试，测试的结果（也就是比较运算的结果）只有两种：真（True）或者假（False）。Python提供了6个比较运算符。

（假设a、b是两个对象）

运算符	描述	实例
>	a > b ：判断对象a是否大于b，是则返回 True，否则返回 False。	20 > 10，结果为True 'a' > 'b'，结果为False 'abe' > 'abd'，结果为True
<	a < b ：判断对象a是否小于b，是则返回 True，否则返回 False。	20 < 10，结果为False
==	a == b ：判断对象a是否等于b，是则返回 True，否则返回 False	3 == 3：结果为True 3 == 4：结果为False 1 == True：结果为True
>=	a >= b ：判断对象a是否大于或等于b，是则返回 True，否则返回 False。	3 >= 2：结果为True 3 >= 3：结果为True
<=	a <= b ：判断对象a是否小于或等于b，是则返回 True，否则返回 False。	3 <= 2：结果为False 3 <= 3：结果为True
!=	a != b ：判断对象a是否不等于b，是则返回 True，否则返回 False。	3 != 2：结果为True 3 != 3：结果为False ‘ab’ != ‘ac’：结果为True

上表中的6个比较运算符也是二目运算符，例如针对两个变量a和b，表达式“a == b”用来表达“变量a和b相等吗？”这个判断意思，当两者相等时则返回“True”用以表示“是相等的”这个结论。否则，返回“False”以表示“不相等”这个结论。

当进行判断的两个对象是数值型数据时，上述的6种判断的含义是清楚的和容易理解的。但如果是其它类型对象时，就需要特别注意了。

例如，如果两个字母进行比较，则实际上是按照两个字母的ASCII码进行比较的。两个字符串进行比较时，是按照各自的首字母的ASCII码进行比较，如果首字母相同，就按照第二个字母的ASCII码进行比较，以此类推。例如：

>>> 'c' > 'd'

False

>>> 'c' < 'd'

True

>>> 'abc' < 'abd'

True

 

（三）逻辑运算符

共有3个:

运算符	描述	实例
and	a and b ：逻辑与，当a为真时，计算b的值，并返回b的值；当a为假时，直接返回a的值，不再计算b。	3 and 5：结果为5 3 and 5>2：结果为True 0 and 5：结果为0 2>3 and 5：结果为False
or	a or b ：逻辑或，当a为真时，直接返回a的值，不再计算b；当a为假时，计算b的值，并返回b的值。	3 or False：结果为3 3>2 or 5：结果为True 0 or 5：结果为5 2>3 or False：结果为False
not	not a ：逻辑非，返回对象a的否定。	not 3：结果为False not 2>3：结果为True

首先应注意到Python语言的3个逻辑运算符均采用英语单词的形式，这与C/C++、Java语言中的“&&、||”等符号不同。

其次，逻辑and 和逻辑或or的计算过程具有“惰性计算”的特点：即当第一个对象的结果可以判断整个表达式的结果时，就不再计算第二个对象了。

（四）位运算符

位运算符用于二进制数字的运算，共有6个：

运算符	描述	实例
&	按位与运算符：如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或运算符：只要两个相应的位有一个为1时，结果位就为1。
^	如果两个位中只有一位为 1，则将每个位设为 1。
~	反转所有位。
>>	通过从左侧推入最左边的位的副本向右移动，推掉最右边的位。
<<	左移动运算符：通过从右侧推入零来向左移动，推掉最左边的位。

（五）赋值运算符：13个

运算符	描述	实例
=	a = b：将b赋给a	x = 3：将3赋给变量a
+=	a += b：先将对象a和b相加，再将相加结果赋给a。	a += 3：等价于 a = a + 3
-=	a -= b：先将对象a和b相减，再将相减结果赋给a。	a -= 3：等价于 a = a - 3
*=	a *= b：先将对象a和b相乘，再将相减结果赋给a。 s *= n：先将字符串s重复n次，再将重复的结果赋给s。	a *= 3：等价于 a = a * 3 s *= 3：等价于 s = s * 3
/=	等同于 x = x / 5	x /= 5
%=	等同于 x = x % 5	x %= 5
//=	等同于 x = x // 5	x //= 5
**=	等同于 x = x ** 5	x **= 5
&=	等同于 x = x & 5	x &= 5
|=	等同于 x = x | 5	x |= 5
^=	等同于 x = x ^ 5	x ^= 5
>>=	等同于 x = x >> 5	x >>= 5
<<=	等同于 x = x << 5	x <<= 5

在编程实践中，注意赋值运算符“=”和比较运算符“==”的区别，前者仅仅是一个赋值操作，而后者会返回一个表示“是否相等”的bool型结果。

（六）成员运算符

共有2个：

运算符	描述	实例
in	如果在指定的序列中找到值返回True， 否则返回False	x in y
not in	如果在指定的序列中没有找到值返回 True，否则返回False	x not in y

（七）身份运算符

共有2个：

运算符	描述	实例
is	如果两个变量是同一个对象，则返回 true。	x is y
is not	如果两个变量不是同一个对象，则返回 true。	x is not y

 

表达式

前面学习了数据和运算符，现在，将数据和运算符通过一定的组合规则就可以构成一个表达式了。例如：3+5，5*8–3，a=3，a>=3，等等。

        一个表达式总是能够完成某种运算，并产生一个值作为运算的结果。事实上，构造表达式的目的就是要进行某种运算，其中运算符决定着运算的类型，数据就是运算要操作的对象（称为操作数、操作对象、操作数等）。因此，表达式也可以陈述为由运算符和运算对象组合起来的符号串，最终可以规约到某个值上。

        一个表达式中的运算对象可以是字面值形式的数据，也可以是变量的形式的数据，它也可以是一个表达式，甚至是一个函数调用。总之，最终都须规约到一个操作数上。例如“5 + 4”就是一个表达式，其中运算符是“+”，“5”和“4”就是字面值形式的两个操作数，它的运算结果就是整数“9”。例如“'Hello' + ' Python'”也是一个表达式，参加运算的两个操作数是字符串对象'Hello'和' Python'，运算结果是一个字符串'Hello Python'。“a = 4”是一个赋值表达式，“=”为赋值运算符，该表达式的运算结果是得到一个变量“a”，且其值为4。

再例如假设变量a = 4，那么“a * 5 + 2”是一个表达式。针对运算符“+”来说，它有两个操作数，一个是字面值形式的整数“2”，另一个操作数本身又是一个表达式“a * 5”。表达式“a * 5”可以规约到整数20，因此整个复合表达式的运算结果是整数22。

根据运算符的类型，Python语言中的表达式也分为：运算表达式、赋值表达式，布尔表达式（或条件测试表达式）等等。这些概念和规则与Java和C/C++相同。

语句

在一个计算机程序中，能够完成一定功能的最小单元是“语句”。表达式和语句是两个不同的概念，但是两个关系密切、容易混淆。

一个表达式只是通过将运算符和操作数组合起来完成一个特定运算，并得到一个运算结果“值”。而语句是指挥计算机完成某种事情的一个“指令”（或者“命令”）。

        很多时候，“语句做某事”和“表达式产生值”之间的区别可能非常模糊。例如，我们可能会这样理解：一个表达式完成了一个运算，那不就是命令计算机完成了一个计算的事情吗？这样理解也是对的，因此也就有了第一个结论：所有表达式都是语句。但是语句除了包括表达式外，它的范畴要更广泛。例如下面两行语句：

>>> x = 1

>>> print("hello, python!")

 

其中第一个语句为赋值语句，它同时也属于赋值表达式。而第二个语句为打印语句，它不能算作表达式。

标签：运算符,变量,Python,True,基础,语法,第二章,数据,表达式
From： https://www.cnblogs.com/mixiaoya/p/18014617