Python 快速入门 – 流程控制与函数

条件控制

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
没有switch - case语句
只有一条语句，可以写在一行if test<10: print(test)
可以嵌套
- 控制好缩进
- 嵌套不要超过三层

`while`循环

没有do...while循环
无限循环
- while...True
- 可以使用CTRL+C可退出当前的无限循环
while...else语句：在条件判断**False的情况下执行一次else**的语句块

`for`循环

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

range()函数的使用要熟练掌握

`break` 语句和`continue`语句

break语句跳出循环，不执行对应循环的else块
continue跳过当前循环剩余语句，继续进行下一轮循环

函数的定义与形式

def fuction_name ():
    '''
    第一行关于对象用途的简介，这一行应该以大写字母开头，以句号结尾，第二行空行.
    详细描述应有一或多段以描述对象的调用约定、边界效应等.
    <fuction_documents>
    '''
    pass

参数传递

不可变类型传值：`int, str, tuple`

如fun(a)，传递的只是a的值，没有影响a对象本身，在 fun(a)内部修改 a的值，只是修改另一个复制的对象，不会影响a本身

def fa(a):
    a = 100
    print(hex(id(a)))
    print(hex(id(100)))
a = 10
print(hex(id(a)))
print(hex(id(10)))
fa(a)
print(hex(id(a)))
print(hex(id(10)))
------------------
 
0x106351a80 #main_a
0x106351a80 #main_100
0x1063525c0 #func_a
0x1063525c0 #func_100
0x106351a80 #main_a
0x106351a80 #main_100

可变类型传引用：`list, dict, set`

fun(L)修改后fun外部的L也会受影响

def fc(a):
    a.append(100)
    print(hex(id(a)))
l=[1,2,3]
print(l)
print(hex(id(l)))
fc(l)
print(l)
-------------------
 
[1, 2, 3]
0x7fbf9a87fd40
0x7fbf9a87fd40
[1, 2, 3, 100]

必需参数（位置参数）

必须顺序正确
调用一致原则

关键字参数

关键字参数来确定传入的参数值
关键字的参数应跟随在位置参数后
允许函数调用时参数的顺序与声明时不一致
- 解释器能够用参数名匹配参数值

def fun(name,key):
    pass
fun(key='lambda x:x[1]',name='test')

默认参数

如果没有传递参数并调用函数，使用默认参数

def fun(name='zjc',key):
    python
fun(key = 'lambda x:x[1]')

默认值只被赋值一次，这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例

def f(a, L=[]):
    print(hex(id(L)))
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))
--------------------
0x7f8b6a880dc0
[1]
0x7f8b6a880dc0
[1, 2]
0x7f8b6a880dc0
[1, 2, 3]

修改方法：

def f(a, L=None):
    if L is None:
        L = []
    print(hex(id(L)))
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))
---------------------
0x7fbc4f080540
[1]
0x7fbc4f080540
[2]
0x7fbc4f080540
[3]

不定长参数

加*的参数会以Tuple：元组的形式导入，存放所有未命名的参数变量

def ptest(arg1, *vartuple):
    print(arg1, end=' , ')
    print(vartuple)
ptest(70, 'test', 50)
------------------------
70 , ('test', 50)

加**的参数会以Dictionary：字典 dict的形式导入

def ptest2(arg1, **vardict):
    print(arg1)
    print(vardict)
ptest2(10, a=2, b=4)
---------------- 
10
{'a': 2, 'b': 4}

通常这些可变参数是参数列表中的最后一个
任何出现在不定长参数的后面的参数只能是关键字参数，不能是位置有关参数

def concat(*args, sep="/"):
    pass

声明函数时，参数中星号 * 可以单独出现，* 后的参数必须用关键字传入

>>>def f(a,b,*,c):
...     return a+b+c
...
>>> f(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3)
6

参数列表的分拆

要传递的参数已经是一个数据结构如列表等，但要调用的函数却只接受分成一个一个的参数值
可以使用操作符来自动把参数列表拆开:*

args=[3,6]
x=list(range(*args)) 
print(x)
-------------------
[3, 4, 5]

可以使用 ** 操作符分拆关键字参数为字典:

d={'name':'zjc','age':35,'job':'prof.'}
def printInfo(name,age,job):
   print("Name:{0}\tAge:{1}\tJob:{2}".format\
   (name,age,job))
   pass
printInfo(**d) #字典分拆(**)
--------------------
Name:zjc  Age:35  Job:prof.

匿名参数

不再使用def语句标准的形式定义函数
使用lambda来创建匿名函数
- lambda只是一个表达式，函数体比def简单很多
- lambda的主体是一个表达式，而不是一个代码块
- 仅仅能在lambda表达式中封装有限的逻辑
- 普通函数定义中的一个语法技巧
- 格式是lambda [arg1 [,arg2,.....argn]]:expression

>>> sum = lambda arg1, arg2: arg1 + arg2
>>> sum(1, 2)
3

`return`语句

用于退出函数并有选择性地返回一个表达式
不带参数的return语句返回None
没有return语句返回None

嵌套函数

def func():
    [statements]
    def func_inner():
        [statements]

lambda 如何从外部作用域引用变量?待掌握[151]03NOTICE

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f=make_incrementor(1)
>>> f(0)
1

函数的闭包

在一个外函数中定义了一个内函数，内函数里运用了外函数的变量，并且外函数的返回值是对内函数的引用
闭包变量实际上只有一份，每次开启内函数时都在使用同一份闭包变量
调用某些功能时，需要做一些准备工作
装饰器

def outer(x):
    b = [x]  # python 2.x
    def inner(y):
        nonlocal x  # python 3.x
        x += y
        b[0] += y
        return x
    return inner
f1 = outer(10)
print(f1(1))
print(f1(2))
------------------
11
13

当在一个嵌套的函数中对变量申明为nonlocal时，就明确表示这个变量是外部函数中定义的变量。