Python3 基础运算

发表于 | 分类于 ， | 阅读次数: |
字数统计: 2.4k | 阅读时长 10 分钟

前言:
包括条件控制if – elif – else、循环语句for和while、迭代器与生成器等内容的介绍与基本操作

条件控制 if – elif – else

if

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

1
2
3
4
5
6
if condition_1:	# 条件1：condition_1
    statement_block_1	# 逻辑1：statement_block_1
elif condition_2:	# 条件2：condition_2
    statement_block_2	# 逻辑2：statement_block_2
else:
    statement_block_3	# 逻辑3：statement_block_3
  • 每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块
  • 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
  • 在Python中没有switch – case语句
  • 条件为真：1,非零数值,True, 非空字符串,至少有一个元素的容器对象,非None对象 条件为假：0,0.0, False, ‘’(空字符串),[],(),{},set(),None

    if嵌套

    在嵌套if语句中，可以把if...elif...else结构放在另外一个if...elif...else结构中
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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")

输出结果：

1
2
3
$ python3 test.py 
输入一个数字：6
你输入的数字可以整除 2 和 3

循环语句 for 和 while

Python中的循环语句有for和while

while语句

(1)基本用法：计算 1 到 100 的总和(5050):

1
2
3
4
5
n,sum,counter = 100,0,1
while counter <= n:
	sum = sum + counter
	counter += 1
print("1 到 %d 之和为: %d" % (n,sum))

(2)while 循环使用 else 语句：
在while … else在条件语句为false时执行else的语句块:

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

for语句

(1)for循环可以遍历任何序列的项目，如一个列表或者一个字符串，for循环的一般格式如下：

1
2
3
4
for <variable> in <sequence>:
    <statements>
else:
    <statements>

(2)for实例中可以使用break语句，break语句用于跳出当前循环体：

1
2
3
4
5
6
7
8
9
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

输出结果：

1
2
3
4
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

range()函数

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

1
2
for i in range(5):
	print(i,end=' ')	# 0 1 2 3 4

(2)range指定区间的值：

1
2
for i in range(5,9) :
	print(i,end=' ')	# 5 6 7 8

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

1
2
3
4
for i in range(0,10,3) :
	print(i,end=' ')	# 0 3 6 9
for i in range(-10,-100,-30) :
	print(i,end=' ')	# -10 -40 -70

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

1
2
3
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
	print(i, a[i],end=' | ')	# 0 Google | 1 Baidu | 2 Runoob | 3 Taobao | 4 QQ |

break 和 continue 语句及循环中的 else 子句

(1)break语句可以跳出for和while的循环体。如果你从for或while循环中终止，任何对应的循环else块将不执行

1
2
3
4
5
6
7
n = 5
while n > 0:
	n -= 1
	if n == 2:
		break
	print(n,end=' ')
print('循环结束')	# 4 3 循环结束

(2) continue 语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环

1
2
3
4
5
6
7
n = 5
while n > 0:
	n -= 1
	if n == 2:
		continue
	print(n,end=' ')
print('循环结束')	# 4 3 1 0 循环结束

循环语句可以有else子句，它在穷尽列表(以for循环)或条件变为false(以while循环)导致循环终止时被执行，但循环被break终止时不执行

(3)冒泡排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def maopao_sort(li):
	max=0
	print('排序前：',li)
	for  i in range(len(li)-1):
		for j in range(len(li)-1-i):
			if li[j]>li[j+1]:
				max=li[j]
				li[j]=li[j+1]
				li[j+1]=max
			else:
				max=li[j+1]
	print('排序后：',li)

li=[41,23344,9353,5554,44,7557,6434,500,2000]
maopao_sort(li)
# 排序前： [41, 23344, 9353, 5554, 44, 7557, 6434, 500, 2000]
# 排序后： [41, 44, 500, 2000, 5554, 6434, 7557, 9353, 23344]

pass 语句

(1) pass是空语句，是为了保持程序结构的完整性，pass不做任何事情，一般用做占位语句

1
2
3
4
5
6
for letter in 'Runoob': 
   if letter == 'o':
      pass
      print (end='**pass**')
   print (' 字母 :', letter,end=' | ')
print ("循环结束")	# 字母 : R |  字母 : u |  字母 : n | **pass** 字母 : o | **pass** 字母 : o |  字母 : b | 循环结束

迭代器

(1)迭代是Python最强大的功能之一，是访问集合元素的一种方式，迭代器是一个可以记住遍历的位置的对象
(2)迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退
(3)迭代器有两个基本的方法：iter()和next()，字符串，列表或元组对象都可用于创建迭代器 

1
2
3
4
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for i in it:
    print( i, end=' | ') # 1 | 2 | 3 | 4 |

创建迭代器

(1)把一个类作为一个迭代器使用需要在类中实现两个方法__iter__()与__next__()
(2)__iter__()方法返回一个特殊的迭代器对象， 这个迭代器对象实现了__next__()方法并通过StopIteration异常标识迭代的完成
(3)__next__()方法（Python 2 里是next()）会返回下一个迭代器对象 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MyNumbers:    # 创建一个返回数字的迭代器，初始值为 1，逐步递增 3
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 3
        return x

myclass = MyNumbers()
myiter = iter(myclass)
for i in range(5):
    print('第 ', i, ' 次迭代值为：', next(myiter))

输出结果：

1
2
3
4
5
第  0  次迭代值为： 1
第  1  次迭代值为： 4
第  2  次迭代值为： 7
第  3  次迭代值为： 10
第  4  次迭代值为： 13

StopIteration

(1)StopIteration异常用于标识迭代的完成，防止出现无限循环的情况，在__next__()方法中我们可以设置在完成指定循环次数后触发StopIteration异常来结束迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyNumbers:    # 创建一个返回数字的迭代器，初始值为 1，逐步递增 3, 4次迭代后停止执行
    def __iter__(self):
        self.a,self.b = 1,1 # a为返回值，b为计数器
        return self

    def __next__(self):
        if self.b<20:
            self.b += 1
            x = self.a
            self.a += 3
            return x
        else:
            raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)
for i in myiter:
    print(i,end=' | ')  # 1 | 4 | 7 | 10 | 13 | 16 | 19 |

生成器

(1)使用了yield的函数被称为生成器generator
(2)跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
(3)在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值, 并在下一次执行next()方法时从当前位置继续运行
(4)调用一个生成器函数，返回的是一个迭代器对象，如下斐波那契数列打印使用和不使用yield进行比较
使用yield：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import sys

def fibonacci(n, w=0):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a # 使用yield
        print('a = ', a, end=' | ')
        a, b = b, a + b
        print('a = ', a, ' b = ', b)
        counter += 1

f = fibonacci(10, 0)  # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f), end=" ")
    except:
        sys.exit()

输出结果：

1
2
3
4
5
6
7
8
9
10
11
0 a =  0 | a =  1  b =  1
1 a =  1 | a =  1  b =  2
1 a =  1 | a =  2  b =  3
2 a =  2 | a =  3  b =  5
3 a =  3 | a =  5  b =  8
5 a =  5 | a =  8  b =  13
8 a =  8 | a =  13  b =  21
13 a =  13 | a =  21  b =  34
21 a =  21 | a =  34  b =  55
34 a =  34 | a =  55  b =  89
55 a =  55 | a =  89  b =  144

不使用yield：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import sys

def fibonacci(n, w=0):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        # yield a   # 不使用yield，函数只是简单执行，没有返回迭代器f
        print('a = ', a, end=' | ')
        a, b = b, a + b
        print('a = ', a, ' b = ', b)
        counter += 1

f = fibonacci(10, 0)  # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f), end=" ")
    except:
        sys.exit()

输出结果：

1
2
3
4
5
6
7
8
9
10
11
a =  0 | a =  1  b =  1
a =  1 | a =  1  b =  2
a =  1 | a =  2  b =  3
a =  2 | a =  3  b =  5
a =  3 | a =  5  b =  8
a =  5 | a =  8  b =  13
a =  8 | a =  13  b =  21
a =  13 | a =  21  b =  34
a =  21 | a =  34  b =  55
a =  34 | a =  55  b =  89
a =  55 | a =  89  b =  144

(5)yield使用场景：
一个函数fab，fab返回一个list，这个list是动态计算出来的，并且这个list会很大（无论是固定很大还是随着输入参数的增大而增大），这个时候，我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个list元素而不是直接得到一个完整的list来节省内存，这个时候yield就很有用
以斐波那契函数为例，我们一般希望从n返回一个n个数的list

1
2
3
4
5
6
7
8
9
10
11
def fab(max): 	# 简单输出斐波那契数列前 max 个数
    n, a, b = 0, 0, 1 
    L = [] 
    while n < max: 
        L.append(b) 
        a, b = b, a + b 
        n = n + 1 
    return L
 
for n in fab(100): 
    print n

fab函数从参数max返回一个有max个元素的list，当这个max很大的时候，会非常的占用内存
如果使用list的迭代器。那么我们可以让这个函数fab每次只返回一个迭代器(一个计算结果)，而不是一个完整的list，运行方式是每次的调用都在yield处中断并返回一个结果，然后再次调用的时候再恢复中断继续运行：

1
2
3
4
5
6
7
8
9
10
def fab(max): 	# 简单输出斐波那契数列前 max 个数
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1 
 
for n in fab(100): 
    print n
—— 感谢您的阅读 ( ﾟ∀ﾟ) 有什么疑问可以在下方留言哦 ——
坚持原创技术分享，您的支持将鼓励我继续创作！