python3 循环 - 函数相关

一、循环控制

   1、相对 c 语言，又新增了 while . . . else:条件语句为 false 时执行 else 的语句块。

    2、for 语句

for <variable> in <sequence>:

    <statements>

else:

    <statements>

    3、当 for 实例使用了 break 语句，break 语句用于跳出当前循环体。

    4、当需要遍历数字序列，可以使用内置range()函数。它会生成数列。

     for i in range(5):

     ...     print(i)

• 也可以使用range指定区间的值

     for i in range(5,9) :

          print(i)

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

     eg : range(0, 10, 3)

• 可以结合range()和len()函数以遍历一个序列的索引,

     a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']

     >>> for i in range(len(a)):

     ...     print(i, a[i])

• 还可以使用range()函数来创建一个列表

     >>>list(range(5))

     [ 0, 1, 2, 3, 4 ]

     

     5、break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

     6、pass 语句，pass 不做任何事情，一般用做占位语句。

  最小的类：class MyEmptyClass:      pass

     7、使用内置 enumerate 函数进行遍历:

for index, item in enumerate(sequence):

    process(index, item)

二 、迭代器与生成器

• 迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。（而C++中的迭代器是可以后退的）
• 迭代器有两个常用的方法：iter() 和 next()。

#!/usr/bin/python3

import sys         # 引入 sys 模块

list=[1,2,3,4]

it = iter(list)    # 创建迭代器对象

while True:

    try:

        print (next(it))

    except StopIteration:

        sys.exit()

• 生成器  - - - > Python 中，使用了 yield 的函数被称为生成器（generator）, 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
• 调用生成器时，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next( )方法时从当前位置继续运行。
• • 详细介绍可参见：点击打开链接

三 、函数相关

     3.1  函数的定义语法

• • 以 def 关键词开头，后接函数标识符名称和圆括号( )
  •  传入参数和自变量放在圆括号中间，圆括号之间可以用于定义参数。函数内容以冒号起始，并且需要缩进。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

eg:  def print( str ):

        "打印任何传入的字符串"

         print (str);

• • return [表达式] 结束函数，若没写，默认返回None

    

      3.2  函数参数的传递

     

• python 中，类型属于对象，变量是没有类型的：例如，a = [1,2,3,4]     a = 'chen'  其中，[1,2,3] 是 List 类型，'chen' 是 String 类型，而变量 a 是没有类型的，它仅仅是一个对象的引用（即一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
• 可更改 (mutable) 与不可更改 (immutable) 对象
• • 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而list , dict 等则是可以修改的对象。
  • • 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
    • 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
  • python 函数的参数传递：
  • • 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身 。
    • 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响 。
• 总结：python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

     

     实际参数调用方式：

• • 必需参数
  • • 参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
  • 关键字参数
  • • 函数调用使用关键字参数来确定传入的参数值，使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

                     例如：   print(  str = ' chen '  )

• • 默认参数
  • • 调用函数时，如果没有传递参数，则会使用默认参数。
  • 不定长参数      
  • • 当需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明它时，不用命名。 

 

基本语法：

def functionname([formal_args,] *var_args_tuple ):

   "函数_文档字符串"

   function_suite

   return [expression]

• • •  加了星号（ * ）的变量名会存放所有未命名的变量参数 。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量，比如直接传递数字。  

      3.3  匿名函数  - - -  lambda表达式

          

     描述：

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

     语法：  lambda 函数的语法只包含一个语句

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

      3.4   变量作用域

• Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。

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

• • L （Local） 局部作用域
  • E （Enclosing） 闭包函数外的函数中
  • G （Global） 全局作用域
  • B （Built-in） 内建作用域  

x = int(2.9)  # 内建作用域

g_count = 0  # 全局作用域

def outer():

    o_count = 1  # 闭包函数外的函数中

    def inner():

        i_count = 2  # 局部作用域

      以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

          

•  Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问，

     

     3.5  全局变量和局部变量

•  定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

     

#!/usr/bin/python3

total = 0; # 这是一个全局变量

# 可写函数说明

def sum( arg1, arg2 ):

    #返回2个参数的和."

    total = arg1 + arg2; # total在这里是局部变量.

    print ("函数内是局部变量 : ", total)

    return total;

#调用sum函数

sum( 10, 20 );

print ("函数外是全局变量 : ", total)

输出：

     函数内是局部变量 : 30

     函数外是全局变量 : 0

• global 和 nonlocal关键字： 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

实例修改全局变量 num：

#!/usr/bin/python3

num = 1

def fun1():

    global num  # 需要使用 global 关键字声明

    print(num)

    num = 123

    print(num)

fun1()

输出：   1 123

• 如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了。

#!/usr/bin/python3

def outer():

    num = 10

    def inner():

        nonlocal num   # nonlocal关键字声明

        num = 100

        print(num)

    inner()

    print(num)

outer()

输出结果： 100   100