Python~(语言基础二)计算控制流与代码组织块

计算控制流

计算机内部运行过程

基本步骤

1. 控制器从存储器中取出程序语句和额外数据；
2. 数据齐全的语句交给运算器进行算术或者逻辑运算；
3. 运算结果再存回存储器；
4. 控制器确定下一条程序语句，回到步骤1继续。
   

控制流：条件分支语句（if）

• 基本要素
  1：预设的判断条件
  2：达成条件后执行的语句
• 扩展要素
  1：当条件不满足时执行的语句
  2：多条件时哪个满足执行哪个的条件
• 条件语句

Python中条件分支的实现
if <逻辑表达式>:
<语句块1>
……
else:
<语句块2>
if和else都是“保留字”
“逻辑表达式”是指所有运算的结果为逻辑类型（True或False）的表达式
“语句块”就是条件满足后执行的一组语句
冒号表示语句层次
语句块缩进
各种类型中某些值会自动被转换为False，其它值则是True：
None, 0, 0.0, ‘’, [], (), {}, set()

使用elif语句进行判定
if <逻辑表达式1>:
<语句块1>
elif <逻辑表达式2>:
<语句块2>
elif <逻辑表达式3>:
<语句块3>
… …
else:
<语句块n>

控制流：条件循环（while）

• 让计算机执行冗长单调的重复性任务
  根据需要对一系列操作进行设定次数或者设定条件的重复，这样的控制流程，就称作循环结构
• 作用
  能持续对大量数据进行处理
  在长时间里对一些未知状况进行连续监测循环结构
• 基本要素
  循环前提和执行语句
• 循环前提的类型

从某个容器或者潜在的数据集中逐一获取数据项，什么时候取不到数据项了，循环的前提就消失
只要逻辑表达式计算结果为真(True)，循环的前提就存在，什么时候逻辑表达式计算结果为假(False)，循环的前提就消失了

• 扩展要素
  当循环前提消失，停止执行这组语句的时候，执行一次另一组语句 (但是注意使用break退出就不再执行另外的一组语句)

while <逻辑表达式>:
<语句块>
break #跳出循环
continue #略过余下循环语句
<语句块>
else: #条件不满足退出循环，则执行
<语句块>
while、else：保留字
逻辑表达式：指所有运算的结果为逻辑类型（True或False）的表达式
else 语句块：一组语句

• 对比下面俩段代码

n = 5
while n > 0:
    n = n - 1
    if n < 2:
        break
    print(n)
else:
    print("END")
print("==========")
n = 5
while n > 0:
    n = n - 1
    if n < 2:
        continue
    print(n)
else:
    print("END")

• 由while处的循环前提判断结束会执行else语句 但是由break额技术循环不会执行else语句

控制流：迭代循环（for)

• 迭代循环语句

Python语言中的for语句实现了循环结构的一种 (注意else语句和while一样性质 如果是break退出就不执行)
for <循环变量> in <可迭代对象>:
<语句块1>
break #跳出循环
continue #略过余下循环语句
else: #迭代完毕，则执行
<语句块2>

for循环语法
for、in和else都是“保留字”
可迭代对象表示从这个数据对象中可以逐个取出数据项赋值给“循环变量”
可迭代对象有很多类型，如字符串、列表、元组、字典、集合等，也可以有后面提到的生成器、迭代器等

• 如下面代码

for n in range(5):
    print(n)

print("============")
alist = ["a", 123, "b", 'v']
for m in alist:
    print(m)

print("============")
adic = {"name": "listen", "age": 20, "grade": 100}
for k, v in adic.items():
    print(k, v)

print("============")
# 这里的item只是获取字典的key
for item in adic:
    print(item, adic[item])

• range函数

range函数
range(<终点>)
返回一个从0开始到终点的数列 (左闭右开)
range(<起点>,<终点>)
从0以外的任何整数开始构建数列
range(<起点>,<终点>,<步长>)
修改数列的步长，通过将步长设置为负数能够实现反向数列
range构建的数列，包含起点整数，而不包含终点整数

• range类型的对象
  直接当做序列转换为list或者tuple等容器类型
  

验证3x+1问题

%从任意一个正整数开始，重复对其进行下面的操作：
%如果这个数是偶数，把它除以 2 ；
%如果这个数是奇数，则把它扩大到原来的 3 倍后再加 1
%你会发现，序列最终总会变成 4, 2, 1, 4, 2, 1, … 的循环。
接下来我们就利用代码验证
我们验证的方式就是 只要这个数字能到1 那么这个数字就成功验证3x+1问题

for i in range(1, 1000):
    n = i
    step = 0
    while n != 1:
        if n % 2 == 0:
            n = n / 2
        else:
            n = n * 3 + 1
        step = step +1
    else:
        print(i, "是", step, "步")

给定n，计算1+2!+3!+…+n!的值

• 从1~n计算每个数的阶乘 然后累加

def func(n):
    sum = 0
    num = 1
    for i in range(1, n + 1):
        num *= i
        sum += num
    return sum


print(func(5))

代码组织块

代码组织：函数(def)

• 定义与调用函数

定义函数
用def语句创建一个函数
用return关键字指定函数返回的值
def <函数名> (<参数表>):
<缩进的代码段>
return <函数返回值> 〉
调用函数 <函数名>(<参数>)
注意括号！
无返回值：<函数名>(<参数表>)
返回值赋值：v = <函数名>(<参数表>)

• 定义一个列表求和函数

def sum_list(alist):
    sum_temp = 0
    for i in alist:
        sum_temp += i
    return sum_temp


alist = [10, 20, 30, 40, 50]
sum = sum_list(alist)
print(sum)

变量的作用域

局部变量
在函数内部定义的参数以及变量只在该函数定义范围内有效，函数外边无法访问到
全局变量
在函数外部定义的，作用域是整个代码段

# 全局变量
num1 = 1
num2 = 2


def addNum():
    # 局部变量
    num1, num2 = 2, 3
    return num1 + num2


print(addNum())
print(num1, num2)

局部变量和全局变量的无故不会互相产生影响

global关键字

Python虽然可以在一个函数内部得到某个全局变量的值， 但是无法对这个全局变量的值进行修改(如上面代码)，所以Python会在函数内部创建一个同名的局部变量 使用global关键字修饰就可以在函数中改变全局变量的值

num1 = 1
num2 = 2


def addNum():
    global num1, num2
    num1, num2 = 2, 3
    return num1 + num2


print(addNum())
print(num1, num2)

函数小技巧

map()函数

• 有时需要对列表中每个元素做一个相同的处理，得到新列表

例如：所有数据乘以3
所有字符串转换为整数
两个列表对应值相加

map(func, list1,list2…)
函数func有几个参数，后面跟几个列表

alist = [1, 2, 3, 4, 5]
blist = [1, 2, 3, 4, 5]


def addNUm(a, b):
    return a + b


print(list(map(addNUm, alist, blist)))

匿名函数lambda

• 有时函数只用一次，其名称也就不重要，可以无需费神去def一个

lambda表达式
返回一个匿名函数
lambda <参数表>:<表达式>

clist = [1, 2, 3, 4, 5]
dlist = [1, 2, 3, 4, 5]

print(list(map(lambda a, b: a + b, clist, dlist)))

代码组织：函数的参数

形式参数与实际参数

参数：传入到函数的值
当调用含参数的函数时，这些参数的值会被复制给函数中的对应参数
形式参数(parameter)
函数创建和定义过程中，函数名后面括号里的参数
实际参数(argument)
函数在调用过程中传入的参数

形式参数只是代表一个位置、一个变量名
实际参数是一个具体内容，赋值到变量的值

def add(a, b):
    return a + b


print(add(1, 2))

定义函数的参数

• 定义函数时，参数可以有两种

1. 一种是在参数表中写明参数名key的参数，固定了顺序和数量的固定参数

def func(key1, key2, key3…):
下面这种较为特殊 就是给他了一个,默认值 当然如果给key2了实参 默认值就不会存在
def func(key1, key2=value2…)

def printNum(num1, num2, num3=100):
    print("num1 = %s, num2 = %s, num3 = %s" % (num1, num2, num3))


printNum("listen", "grade")

• 传入num3 改变其默认值 并且python中如果使用参数名传参就可以不管顺序
• 如果混用，所有位置参数必须在前，关键字参数必须在后

def printNum(num1, num2, num3=100):
    print("num1 = %s, num2 = %s, num3 = %s" % (num1, num2, num3))


printNum(num2="grade", num1="listen", num3=90)

2. 一种是定义时还不知道会有多少参数传入 的可变参数

def func(*args): #不带key的多个参数
def func(**kwargs): #key=val形式的多个参数 相当于传入了字典容器

def func_test(*args):
    for i in args:
        print(i)


func_test(1, 2, 3, 4, "listen")
print("==========")
func_test("a", "b")

def func_test2(**kwargs):
    for k, v in kwargs.items():
        print(k, v)


func_test2(numa="listen", age=20, grade=100)
print("==========")
func_test2(numa="tom", age=20)

水仙花数判定

• 水仙花数：满足如果这个数为m位数，则每个位上的数字的m次幂之和等于它本身
  
• 结果返回True或者False
• 创建一个函数，接受一个参数max(max>=1000) 调用上题编写的判断函数，求 100到max之间的水仙花数

def func_flower(max):
    if max <= 100:
        return

    for i in range(100, max):
        a = int(i / 1 % 10)  # 个位
        b = int(i / 10 % 10)  # 十位
        c = int(i / 100 % 10)  # 百位

        if i == (a ** 3 + b ** 3 + c ** 3):
            print(i)


func_flower(1000)