Day2 Python的运算符及三大语句控制结构

Python的运算符

Python语言支持以下类型的运算符:

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

Python的三大语句控制结构：

• 顺序结构
• 分支结构
• 循环结构

接下来让我们一个个来学习Python的运算符。

Python算术运算符

以下实例演示了Python所有算术运算符的操作：

#!/usr/bin/python3
a = 21
b = 10
c = 0
print("a 的值为:",a," b 的值为:",b)
c = a + b
print ("a + b的值为：", c)
c = a - b
print ("a - b的值为：", c)
c = a * b
print ("a * b 的值为：", c)
c = a / b
print ("a / b的值为：", c)
c = a % b
print ("a % b 的值为：", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print("修改a b的值，a:",a," b:",b)
print ("a**b 的值为：", c)
a = 10
b = 5
c = a//b
print("修改a b的值，a:",a," b:",b)
print ("a//b 的值为：", c)

Python比较运算符

以下实例演示了Python所有比较运算符的操作：

a = 21
b = 10
c = 0
print("a为：",a," b为:",b)
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")

if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")

if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")

if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")

# 修改变量 a 和 b 的值
a = 5;
b = 20;
print("修改a b的值以后，a为：",a," b为:",b)
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于  b")

if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")

Python赋值运算符

以下实例演示了Python所有赋值运算符的操作：

a = 21
b = 10
c = 0
print("a的值为:",a," b的值为",b)
c = a + b
print ("a + b 的值为：", c)
c += a
print ("c += a 的值为：", c)
c *= a
print ("c *= a 的值为：", c)
c /= a
print ("c /= a 的值为：", c)
c = 2
c %= a
print ("c %= a 的值为：", c)
c **= a
print ("c **= a的值为：", c)
c //= a
print ("c //= a 的值为：", c)

Python位运算符

注意：位运算符是把数字看作二进制来进行计算的。

Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a  =   0011 1100

b  =   0000 1101

-----------------

a&b = 0000 1100

a|b =  0011 1101

a^b = 0011 0001

~a  = 1100 0011

以下实例演示了Python所有位运算符的操作：

a = 60            # 60 = 0011 1100
b = 13            # 13 = 0000 1101
c = 0
c = a & b;        # 12 = 0000 1100
print("a的值为：",a,"b的值为:",b)
print ("a & b 的值为：", c)
c = a | b;        # 61 = 0011 1101
print ("a | b 的值为：", c)
c = a ^ b;        # 49 = 0011 0001
print ("a ^ b 的值为：", c)
c = ~a;           # -61 = 1100 0011
print ("~a 的值为：", c)
c = a << 2;       # 240 = 1111 0000
print ("a << 2 的值为：", c)
c = a >> 2;       # 15 = 0000 1111
print ("a >> 2 的值为：", c)

Python逻辑运算符

a = 10
b = 20
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")

if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")

if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")

if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

 注意1：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

 注意2：

　　　　python 中的 and 从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值；

　　　　or 也是从左到右计算表达式，返回第一个为真的值；

　　　　其中数字 0 是假，其他都是真；

　　　　字符 "" 是假，其他都是真；

如下代码演示:

print(5 and 4)
print(5 and 4 and 0)
print(5 and 4 and "")
print(5 or 4)
print(0 or 4)
print("" or 5)

Python成员运算符。

Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

以下实例演示了Python成员运算符的操作：

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];

if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")

if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")

# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

Python身份运算符

以下实例演示了Python所有身份运算符的操作：

a = 20
b = 20

if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")

if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")

# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")

if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

注意：is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

a = [1, 2, 3]
b = a
print(b is a) #True
print(b == a)#True
b = a[:]
print(b is a)#False
print(b == a)#True

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

以下实例演示了Python所有运算符优先级的操作：

a = 20
b = 10
c = 15
d = 5
e = 0
print(type(a*b))
print("a=",a," b=",b," c=",c," d=",d)
print(type(b/d))
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：",  e)
e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：",  e)
e = (a + b) * (c / d);    # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：",  e)
e = a + (b * c) / d;      #  20 + (150/5)
print ("a + (b * c) / d 运算结果为：",  e)

Python的三大语句控制结构：

顺序结构

顺序结构也是python中三大语句控制结构中最基本的语句控制结构，可以这么说：我们写的代码都会用到顺序控制结构，如下所示：

a = 9
b = 5
c = a + b
print(c)

分支结构

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

if 语句

Python中if语句的一般形式如下所示：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

• 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
• 如果 "condition_1" 为False，将判断 "condition_2"
• 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
• 如果 "condition_2" 为False，将执行"statement_block_3"块语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

• 1、每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。

简单if语句：

var1 = 100
if var1:
   print ("1 - if 表达式条件为 true")
   print (var1)

var2 = 0
if var2:
   print ("2 - if 表达式条件为 true")
   print (var2)
print ("Good bye!")

单分支语句：

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
    print("你是在逗我吧!")
else:
    print("你是人啊")

多分支语句：

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)

### 退出提示
input("点击 enter 键退出")

以下为if中常用的操作运算符:

Demo:猜字游戏：

# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
    guess = int(input("请输入你猜的数字："))

    if guess == number:
        print("恭喜，你猜对了！")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else
        语句
elif 表达式4:
    语句
else:
    语句

演示代码如下:

num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")

嵌套条件语句会随着它潜逃数量层的增加而变得非常难理解和阅读，应该尽量避免多层嵌套。

补充： range()和random模块：

import random

x = random.choice(range(100))
y = random.choice(range(200))
if x > y:
    print('x:',x)
elif x == y:
    print('x+y', x + y)
else:
    print('y:',y)

choice() 方法返回一个列表，元组或字符串的随机项。

以下是 choice() 方法的语法:

import random
random.choice( seq  )

注意：choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

参数

• seq -- 可以是一个列表，元组或字符串。

---

返回值

返回随机项。

range()函数: 如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列.

eg:

a = range(10)
for i in a:
    print(i)

你也可以使用range指定区间的值：

for i in range(5,9) :
    print(i)

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):

#正数
for i in range(0, 10, 3) :
    print(i)

#负数
for i in range(-10, -100, -30) :
    print(i)

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i, a[i])

还可以使用range()函数来创建一个列表:

print(list(range(5)))

循环结构

Python中的循环语句有 for 和 while,另外Python中没有do..while循环。。

Python循环语句的控制结构图如下所示：

Python中while语句的一般形式：

while 判断条件：
    语句

需要注意冒号和缩进。

以下实例使用了 while 来计算 1 到 100 的总和：

n = 100

sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n,sum))

无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环:

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)

print ("Good bye!")

无限循环在服务器上接收客户端的实时请求非常有用。

while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块：

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

简单语句组

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中，

flag = 1
while (flag): print ('欢迎访问菜鸟教程!')

for 语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

Python loop循环实例：

languages = ["C", "C++", "Perl", "Python"]
for x in languages:
     print (x)
 

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体，并且for语句后面也可以用else语句：

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

注意：

Python中的for、while循环都有一个可选的else分支（类似if语句和try语句那样），在循环迭代正常完成之后执行。

换句话说，如果我们不是以除正常方式以外的其他任意方式退出循环，那么else分支将被执行。也就是在循环体内没有break语句、没有return语句，或者没有异常出现时就会执行else语句。

考虑一个简单的（无用的）例子：

for i in range(5):
    print(i)
else:
    print('Iterated over everything :)')

上面的代码中，我们在range(5)上迭代并打印每个数字。因为我们让循环正常完成，所以else分支也被执行，并打印出Iterated over everything :) 。

相反，如果我们用break语句终止循环，那么else分支将不会执行：

for i in range(5):
    if i == 2:
        break
    print(i)
else:
    print('Iterated over everything :)')

注意，尽管循环所迭代的序列是空的，else分支依然会被执行，毕竟循环仍然是正常完成的。

for i in []:
    print(i)
else:
    print('Still iterated over everything (i.e. nothing)')

同样不要忘记，以上所有也适应于while…else：

i = 0
while i <= 5:
    i += 1
    print(i)
else:
    print('Yep')

else语句在循环中的一个常见使用案例是实现循环查找。假说你在查找一个满足特定条件的项目（item），同时需要进行附加处理，或者在未发现可接受的值时生成一个错误：

for x in data:
    if meets_condition(x):
        break
else:
    # raise error or do additional processing

没有else语句的话，你需要设置一个标志，然后在后面对其检测，以此确定是否存在满足条件的值。

condition_is_met = False
for x in data:
    if meets_condition(x):
        condition_is_met = True
 
if not condition_is_met:
    # raise error or do additional processing

for、while循环支持嵌套，如下所示，输出一个9*9的乘法表：

i = 1
j=1
while i <= 9:
    while j <= 9:
        print("%s*%s = %s  "%(i,j,i*j),end="")
        j+=1
    i += 1
    j = 1
    print()

While

i = 1
j=1
for i in  range(1,10):
    for j in range(1,10):
        print("%s*%s = %s  "%(i,j,i*j),end="")
    print()

for

i = 1
j=1
for i in  range(1,10):
    while j <=9:
        print("%s*%s = %s  "%(i,j,i*j),end="")
        j+=1
    j = 1
    print()

for and while

注意：外层循环控制行，内层循环控制列！

循环语句和分支语句之间可以相互嵌套：

if 1 < 2:
    for i in range(1,5):
        for j in range(1,6):
            if j != 4:
                print(j,end=" ")
                pass
        print(i)

分支嵌套循环

for i in range(1,5):
    for j in range(1,6):
        if j < 2:
            print(j,end=" ")
            pass
    print(i)

循环嵌套分支

使用内置 enumerate 函数进行遍历:

for index, item in enumerate(sequence):
    print(index, item)

注意：enumerate返回的是元组！

案列：

sequence = [12, 34, 34, 23, 45, 76, 89]
for i, j in enumerate(sequence):
   print(i, j)

break,continue,pass语句
break:跳出当前循环不再循环；
continue:跳出本次循环下次循环继续；
pass:空语句什么都不干，为了保证代码的完整性；pass语句可以用在任何地方,eg:if语句中。
案列：

for i in range(5):
    if i == 2:
        continue
    print(i)

continue

 for i in range(5):
     if i == 2:
        break
     print(i)

 for i in range(1,5):
     for j in range(1,6):
         if j == 4:
             print(j,end=" ")
             break
     print(i)

break

for i in range(1,5):
    for j in range(1,6):
        if j != 4:
            print(j,end=" ")
            pass
    print(i)

pass