Python3语句与函数

Python3语句与函数

条件控制

if 语句

一般形式格式：

if condition1:
    statement1
elif condition2:
    statement2
else:
    statement3
    
-condition为True,非0数字,非None,非空字符串,非空序列则执行相应statement
-if语句关键字：if--elif--else
    每条语句后都要用冒号:，表示接下来是满足条件后要执行的语句块
    通过使用缩进划分语句块
    没有switch-case语句

if中常用运算符：

<,<=,>,>=,==,!=

if三目运算符：

status = 'true' if condition else 'false'
condition为真status为true否则status为false

if嵌套：

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

assert关键字：

assert工作原理类似如下：
    if not condition:
        crash program
若不满足某些条件则程序报错，即若满足条件则程序继续运行
assert 0 < age <100 
    若age>=100 and age<=0 则抛异常AssertionError

可在条件后天添加一个字符串对断言说明
assert 0 < age < 100, 'The age must be realistic'
抛异常：
    AssertionError: The age must be realistic

循环语句

python中的循环语句有for和while

while

一般形式格式：

while 判断条件:
    语句
    pass
else:
    语句
-判断条件为True则执行语句，若判断条件为False则执行else内语句
-注意冒号和缩进，附：python没有do--while循环
-若while循环体中只有一条语句，可将该语句与while写在同一行：
    while condition:print('one statement')

for

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

for循环的一般格式：

for <variable> in <sequence>:
    <statements>
    pass
else:
    <statement>
    pass
-实例：循环1到10
    for x in range(10):
        print(x+1)
-for循环体中可以使用break语句，相当于跳出当前循环体且不执行当前循环的else语句
-else仅在被迭代的迭代器内部为空时执行即循环完迭代器执行

range()函数：

如果需要遍历数字序列，可以使用内置函数range()：生成一个数字数列
    for i in range(3):
    相当于
    for i in [0,1,2]
而：
    for i in range(1,3):
    相当于
    for i in [1,2]
range(start,end,step):start开始，不包含end，步长step
-结合range()和len()函数可以遍历一个序列的索引
    for i in range(len(seq)

break和continue语句

break语句可以跳出for和while的循环体，若你从for和while循环中终止，任何对应的循环else块将不执行

for <variable> in <sequence>:
    <statements>
    if flag:   # 满足flag则跳出不执行else
        break  
    pass
else:
    <statement>
    pass
    
while condition:
    statements
    if flag:  # 满足flag则跳出不执行else
        break
    pass
else:
    statements

python跳出多层循环：

1.自定义异常
    class exitloop(Exception):pass
    
    try:
        for i in seqi
            for j   seqj
                for k   seqk
                    if flag:
                        raise exitloop()  #直接跳到except
    except exitloop:pass
2.封装为函数return
    def exitloop():
        for i in seqi
            for j   seqj
                for k   seqk
                    if flag:
                        return  #直接跳出函数
3.定义状态条件，条件为false则跳出
    flag=False  #在循环中满足条件更改状态
    for i in seqi
        for j   seqj
            for k   seqk
                if flag:
                    break  #直接跳出k循环
            if flag:
                break  #直接跳出j循环
        if flag:
            break  #直接跳出i循环
            
while循环同上

continue语句用于跳出当前循环块中的剩余语句，然后继续进行下一轮循环

for <variable> in <sequence>:
    if flag:   # 满足flag则跳过<statements>执行下一次循环
        continue  
    <statements>
    pass
else:
    <statement>
    pass
    
while condition:
    if flag:  # 满足flag则跳过<statements>执行下一次循环
        continue
    statements
    pass
else:
    statements

pass语句

pass是空语句，目的是保持程序结构的完整性，一般不做任何事情，做占位语句

迭代器与生成器

迭代器

迭代器是访问集合元素的一种方式，迭代器是一个可以记住遍历的位置的对象，迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问结束

注意：迭代器只能往前不会后退
迭代器有两个基本的方法(内置函数)：iter()和next()
字符串，列表或元组对象都可以用于创建迭代器

迭代器的创建：

it=iter(seq):传入可迭代对象获得迭代器，序列就是可迭代对象
方法__iter__返回一个迭代器，它是包含方法__next__的对象且通过StopIteration 异常标识迭代的完成
可迭代对象:实现方法__iter__()的class对象  (__iter__是迭代器协议的基础)
自定义迭代器需要创建class实现__iter__和__next__方法

迭代器的遍历：

1.常规for语句遍历：
    it=iter(list)
    for i in it:
2.next()函数遍历：
    while True:
        try:
           next(it)
        except StopIteration:sys.exit()
3.__next__()方法遍历：
    同上
    next(it)等效于it.__next__()

迭代器和可迭代对象：

实现了方法__iter__的对象是可迭代的，而实现了方法__next__的对象是迭代器
通过对可迭代对象调用内置函数iter可获得一个迭代器 iter(obj)

迭代器创建序列：

list(iter)

生成器

在Python中，使用了yield的函数被称为生成器(generator)，与普通函数不同，生成器是一个返回迭代器的函数，只能用于迭代操作

生成器由两个单独的部分组成：生成器的函数和生成器的迭代器
    1.生成器的函数由def语句定义，其中包含yield
    2.生成器的迭代器是这个函数返回的结果
对于yield，在调用生成器运行的过程中，每次遇到yield函数会暂停保存当前所有的运行信息，返回yield的值并在下一次执行next()方法时从当前位置继续运行

简单生成器：

生成器推导，其工作原理与列表推导相同，但不是创建一个列表(即不立即执行循环),而是返回一个生成器，能够逐步执行计算
    g=(i**2 for i in range(10))
    next(g)
    生成器推导使用圆括号，在函数调用时使用可省略括号
    sum(i**2 for i in range(10)

递归式生成器用法：

递归遍历多层列表将所有元素放入一个列表中
def flatten(nest):
    try:
        #不迭代类似于字符串的对象
        try:nest+''
        except TypeError:pass
        else: raise TypeError
        
        for sub in nest:
            for ele in flatten(sub):
                yield ele
    except TypeError:
        yield nest
nest=[1,[2,['guyu',3]
f=flatten(nest)
list(f)
==>[1,2,'guyu',3]

模拟生成器：

def flatten(nest):
    result=[]
    try:
        #不迭代类似于字符串的对象
        try:nest+''
        except TypeError:pass
        else: raise TypeError
        
        for sub in nest:
            for ele in flatten(sub):
                result.append(ele)
    except TypeError:
        result.append(nest)
    return result

生成器的方法：

send
throw
close

函数

自定义函数

定义函数的规则:

-函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
-任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
-函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
-函数内容以冒号起始，并且缩进。
-return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。即所有函数都有返回值
    def 函数名(参数列表):
        函数体
        pass
    默认情况下，参数值和名称是按函数声明中定义的顺序匹配起来的
    函数可以设置默认值
    def function(name,age=18):
        name 是必选参数，age是默认参数(不传age则为18传递则覆盖)

函数调用：

1.function(name='',age=18)  #key=value的形式绑定参数，参数顺序可打乱
2.function('',18)  #按顺序传参数，参数顺序不可变

函数文档：

在函数开头的字符串称为文档字符串(docstring),将作为函数的一部分存储起来
    def square(x):
        'Calculates the square of the number x.'
        return x * x
通过.__doc__访问文档字符串：
    square.__doc__

参数传递

python中，类型属于对象，变量没有类型；python中的一切都是对象，传递参数就是传递对象

参数传递不可变对象 string，tuple，number 类似值传递
    参数改变不影响原值
参数传递可变对象 list，dict，set  类似引用传递
    实参和形参有相同的引用，参数改变影响原值

参数

参数有：

• 必须参数
• 关键字参数
• 默认参数
• 不定长参数

必须参数：必须参数须以正确的顺序传入函数，调用时的数量必须和声明时一样
关键字参数：关键字参数允许函数调用时参数的顺序与声明时不一致，key=value的形式被解释器匹配
默认参数：调用函数没有传递参数则会使用默认参数
不定长参数：声明时定义
    def funcation(*variable):
    加了*的参数会以元组的形式导入，存放所有未命名的变量参数，相当于java的可变数组...
    def funcation(**variable):
    加了**的参数会以字典的形式导入，传入的参数须是key=value的形式
    function(a=2,b=3)

匿名函数

python使用lambda来创建匿名函数

-lambda 只是一个表达式，函数体比 def 简单很多。
-lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
-lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
-虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法：

lambda [arg1 [,arg2,.....argn]]:expression

变量作用域

Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内置作用域（内置函数所在模块的范围）
  以 L –> E –> G –>B 的规则查找

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域

调用闭包的方式outer()()：第一个括号是outer()传入参数，第二个括号是inner()传入参数

global 和 nonlocal关键字:

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
修改全局变量需要用到global关键字
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了

vars：

vars()是内置函数，返回作用域的一个字典

x = 1
scope = vars()
scope['x']
=>1
scope['x'] += 1
x
=>2