[Python知识库]Python 基础学习07 控制语句与函数

判别语句

1.顺序执行与控制语句

s1={1,2,3}
s2={2,3,4}
#if判别语句
if s1&s2 !=set():   #空集合是set()
    print(s1&s2)
{2, 3}

2.if判别语句结构

if <条件> :? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?<语句>

其中if为条件语句关键词，后接条件语句+：，该条件语句返回结果为True/False，执行语句为if判别体内部的语句，需要缩进四格，当if条件成立（即条件语句返回结果为True）时执行，反之则跳过。

3.if-else判别语句结构

if <条件>:

????? ? <语句1>

????else:

????? ? <语句2>

????此时，当条件成立时执行语句1，不成立时执行语句2.

4.if-elif-else判别语句结构.

嵌套结构往往不利于代码本身的阅读，过多使用嵌套结构会很大程度上降低代码可读性，因此面对刚才的逻辑，“满足条件1执行代码1，满足条件2执行代码2，当这些条件都不满足时，执行代码3”，我们更推荐使用if-elif-else结构来进行表达。该语法基本结构为:

? ?if <条件1>:

????? ? <语句1>

???elif <条件2>:

????? ? <语句2>

???elif <条件3>:

????? ? <语句3>

????...

???else:

????? ? <语句3>

（相当于 if - else if - else）

循环语句

l=[1,2,3]
for i in range(len(l)):
    l[i]+=1
l
[2, 3, 4]
range(len(l))
range(0, 3)
l=[1,2,3,4,5,6,7]
for i in range(len(l)):
    l[i]+=1
l
[2, 3, 4, 5, 6, 7, 8]

1.for循环基本结构

for循环是最常见的循环结构，其基本语法结构为：? ?

????for <临时变量> in <容器>:

? ? ? ? ?<表达式>

其中for是循环体的提示符，在之前的例子中，i就是临时变量，range(len(l))是容器，l[i] += 1是包含临时变量的表达式，在实际的执行过程中，临时变量i依次取得range(len(l))容器中的每一个值（即0、1、2），并且每取得一个值就进行一次表达式的运算，最终通过一次次的循环计算，完成列表l中每个值+1的运算。

2.可迭代对象

容器属性可从可变、有序两个方面来考察。其中：

?- 数值型对象由于不可索引，因此不是容器

- 字符串型对象可以利用数值进行索引，但不能利用索引进行修改，因此是不可变的有序变量

- 列表对象可以利用数值进行索引，并且可以利用索引进行修改，因此是可变的有序变量?

- 元组类型对象可以利用数值进行索引，但不能利用索引进行修改，因此和字符串对象类似，是不可变的有序变量

- 字典类型对象不能利用数值进行索引，只能利用key来进行索引，而Key的索引结果是可以修改的，因此字典类型对象是无序可变类型对象

- 集合类型对象不能利用数值进行索引，但可以修改，因此集合类型对象和字典一样是无序可变类型对象

- 冻集合是在集合的基础之上进一步要求集合本身不可变，因此冻集合是不可变的无序类型对象

Points：

- 在这所有的对象类型中，除了int之外，都是可迭代类型对象，都可以作为for...in...的循环对象；

- 根据有序、无序的不同，临时变量取值效果会有所不同

- 若要利用循环对对象本身进行修改（类似上面把列表中的每个元素+1），仍然只能修改可变类型对象;

- 之前介绍的原容器类型对象（range、d.keys、d.values、d.items等）都是可迭代类型对象。

3.有序变量的循环

3.1 有序可变类型对象循环?

截止目前，我们接触到的有序可变类型对象只有列表，列表可以在for...in...结构中充当可迭代类型对象，同时也可以作为for循环修改对象。

l=[1,0,3]
l
[1, 0, 3]
for i in l:
    print (i)
1
0
3
for i in range(len(l)):
    l[i]+=1
l  
[2, 1, 4]

3.2 有序不可变类型对象的循环

截止目前，有序不可变类型对象有字符串对象和元组对象两种，对于有序不可变类型对象，由于本身是可迭代类型对象，因此可以出现在for...in...结构中，但由于是不可变的，因此不能通过循环对其进行修改。

s='Hello'
s
'Hello'
for i in s:
    print(i)
H
e
l
l
o
t=tuple([1,0,3])
t
(1, 0, 3)
for i in t:
    print(i)
1
0
3

4.无序变量的循环

无序变量又分为无序可变变量（如字典、集合）与无序不可变变量（如冻集合），同理，无序可变变量能够通过循环修改，不可变变量不能利用循环进行修改，同时需要注意的是无序变量在for...in...结构中遍历顺序的问题。

d=dict([('B',[1,2,3]),('A',1)])
d
{'B': [1, 2, 3], 'A': 1}
for i in d:
    print (i)
B
A
据此可知，对于无序变量的循环，本质上是根据显示顺序进行遍历。同时，若是针对字典进行循环，本质上是对字典的keys进行循环

s
s=set([1,2,3,(1,2)])
s
{(1, 2), 1, 2, 3}
for i in s:
    print(i)
(1, 2)
1
2
3
sf=frozenset(s)
sf
frozenset({(1, 2), 1, 2, 3})
for i in sf:
    print(i)
(1, 2)
1
2
3

5.循环的嵌套

d=dict([('B',[1,2,3]),('A',1)])
d
{'B': [1, 2, 3], 'A': 1}
==list
type(d['B'])==list
True
for i in d:
    if type(d[i])==list:
        for j in range(len(d[i])):
            d[i][j]+=1
    print(d[i])
[2, 3, 4]
1

条件循环

1.while循环基本结构

while <判别语句>:

????? ? <表达式>

其中，while的判别语句与if结构中的判别语句一样，当返回结果为True时执行表达式，而表达式则是执行循环功能的主体代码，同时，该部分也承担着控制循环是否执行的重要作用，例如：创建一个包含三个元素的列表，对前两个元素执行+1的操作

l=[1,0,2]
i=0
while i<2:
    l[i]+=1
    i+=1
l
[2, 1, 2]
i
2

- 只要是循环，就必须有实际参与每一次参与循环计算的临时变量，while循环也不例外，上述例子中i就是临时变量，在while循环中也被称为指示器；

?- 一个比较通用的做法是在循环开始前对临时变量进行赋值，然后临时变量实际参与条件判别，同时在表达式中需要对临时变量进行修改，从而使得条件循环真正意义上有条件可循，否则将会出现while条件一直成立，最终造成死循环。

控制结构语句continue

在循环体中，continue语句功能为结束本次循环进入到下一次循环中。合理利用continue+if结构能进行更加灵活的条件循环。

for i in range(len(l)):
    if i%2==1:
        l[i]+=1
    else:
        continue
l
[1, 1, 3, 3]

3.控制结构break

和continue不同，break一旦执行，就将终止整个循环，而不是结束本次循环。例如，还是上述列表，需要对前两个元素+1，第三个元素+2，其他元素不变，则：

l=[1,0,3,2]
l
[1, 0, 3, 2]
break
for i in range(len(l)):
    if i<2:
        l[i]+=1
    elif i==2:
        l[i]+=2
    else:
        break
l
[2, 1, 5, 2]

函数的使用

比较一系列数值（1，2，5，7）的大小，并挑选出其中最大的一个，则可以通过以下方式实现：

l =[1,2,5,7]
ma=l[0]
for i in range(1,len(l)):
    if ma < l[i]:
        ma=l[i]
    else:
        continue
ma
7

1.函数功能

函数的本质就是对现有的逻辑进行封装，以方便以后再次调用、将相同的逻辑用于处理其他对象。

2.函数结构详解

函数的定义其实并不复杂，总的来说分为两部分，其一是通过def关键词定义函数名称及参数，第二部分则是具体代码部分。例如，在上述函数中，我们通过def minmaxnorm(l):语句实际上定义了该函数的名称：minmaxnorm，以及该函数在实际执行过程中涉及到的对象，即函数参数。其中，函数名称取名要求尽量简洁易懂，同时和内嵌函数名称不能重复，而函数参数，其功能类似于方程组中变量X、Y的作用，表示函数体内将要用到的对象名，本质上起到占位的作用，而函数代码则用于表示函数参数所代表的对象实际操作逻辑，因此函数本质上其实是处理逻辑的封装。例如：

def sum_1(a,b):
    c=a+b
    return c
sum_1(1,2)
3
sum_1([1,2],[3,4])
[1, 2, 3, 4]

3.函数帮助文档

"""

内容

"""

调用帮助文档：

sum_1?

函数的参数

Python函数参数总结(位置参数、默认参数、可变参数、关键字参数和命名关键字参数) - 云+社区 - 腾讯云 (tencent.com)

参数顺序

一般来说，要求按照必要参数->可选参数->可变长参数->可变长关键字顺序设置参数。

变量作用域

- 函数体内最终返回（return）的不是局部变量，而是局部变量指代的对象

- 局部变量可以和全局变量重名，但在函数体内进行计算的过程中，优先会使用局部变量

不可变类型全局变量不能直接修改，若一定要在函数内申明需要优先全局变量或对其进行修改，则需要使用global关键字：

a
1
def sum_2(b):
    global a
    a+=b
    return(a)
sum_2(2)
3
a
3

3.lambda函数?

基本理解：lambda函数又被称为匿名函数，支持使用更加轻巧的方式定义轻便函数，例如：

f1=lambda x,y:x+y
f1(1,2)
3
本质上等价于
def f2(x,y):
    return(x+y)
f2(1,2)
3

当然，轻便的代价就是有诸多限制，例如冒号后的表达式中不能出现while循环、表达式中如果要用if条件判别就一定要有else等；

在lambda函数中使用if-else判别

d=lambda x:x+1 if x>10 else x-1
d(2)
1
d(11)
12