Python菜鸟入门：day08函数概念

写在前面：
此博客仅用于记录个人学习进度，学识浅薄，若有错误观点欢迎评论区指出。欢迎各位前来交流。（部分材料来源网络，若有侵权，立即删除）
传送门：

day01基础知识
day02知识分类
day03运算符
day04数字与字符串
day05列表
day06元组与字典
day07条件与循环
day08函数概念
day09数据结构
day10模块介绍
day11文件操作
day12编程学习
day13编程学习
day14编程学习
day15编程学习
day16编程学习
day17编程学习
day18编程学习

Python迭代器与生成器

迭代器

• 迭代器是访问集合元素的一种方式；
• 迭代器是一个可以记住遍历的位置的对象；
• 迭代器对象从集合的第一个元素依次访问至最后一个元素，并且只往前不后退；
• 迭代器存在两个基本方法：iter（）和next（）；
• 字符串、列表或原则对象都可以用于创建迭代器；

iter()函数

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>> 

• 迭代器对象可以使用常规for语句进行遍历：

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

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的函数被称为生成器；
• 生成器是一个返回迭代器的函数，只能用于迭代操作；
• 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
• 调用一个生成器函数，返回的是一个迭代器对象。

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

• 这里只是粗略的描述一下，后续学到面向对象就深入写一下；

Python函数

• 函数：组织好的、可重复使用的、用来实现单一或者相关联功能的代码段；
• 函数有内建函数，如printf（），但也有用户自定义函数；

定义一个函数

• 函数代码块以def关键词开头，后面接函数标识符名称和圆括号（）；
• 传入的参数和自变量都必须放在圆括号中间，圆括号之间可以用于定义参数；
• 函数内容以冒号起始，并且缩进；
• return[表达式]结束函数，选择性地返回一个值给调用方，如不带表达式的return相当于返回None；

语法

def 函数名（参数列表）：
函数体

• 参数值和参数名称默认按照函数声明中定义的顺序匹配起来的；

一个简单的例子：

>>>def hello() :
   print("Hello World!")
 
   
>>> hello()
Hello World!
>>>

一个不那么简单的例子：

#!/usr/bin/python3
 
# 计算面积函数
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

函数调用

• 定义一个函数：给函数命名，指定函数里面包含的参数，和代码块结构；
• 函数基本结构完成以后，可以通过另一个函数调用执行，也可以直接从Python命令提示符中执行；

#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

参数传递

• Python中类型是属于对象的，而变量是没有类型的；

可更改与不可更改对象

• 在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没有动，只是其内部的一部分值被修改了。

传不可变对象

#!/usr/bin/python3
 
def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print( b ) # 结果是 2

• 实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象

• 可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

#!/usr/bin/python3
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

• 传入函数的和在末尾添加新内容的对象用的是同一个引用。

传参这一块有点模糊，后续再深究；

参数

必需参数

• 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

关键字参数

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

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "小白加油")

• 函数参数的使用不需要使用指定顺序：

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="zack" )

默认参数

• 调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数。
• 默认参数必须放在最后面，否则会报错；

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="xiaobai" )
print ("------------------------")
printinfo( name="xiobai" )

不定长参数

• 一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
• 基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

• 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

• 输出结果：

• 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

输出结果：

• 加了两个星号 ** 的参数会以字典的形式导入。

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

• 声明函数时，参数中星号 * 可以单独出现；

def f(a,b,*,c):
    return a+b+c

• 如果单独出现星号 * 后的参数必须用关键字传入。

>>> 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
>>>

匿名函数

• python 使用 lambda 来创建匿名函数。
• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

语法：

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

实例：

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

输出结果:

return语句

• return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

#!/usr/bin/python3
 
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

输出结果：

end
这段时间比较忙，有些知识点没有梳理清楚，后续会完善，坚持了8天，1希望明天也能坚持下去，加油。