Python菜鸟入门：day08函数概念

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

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

Python学习:day08

Python迭代器与生成器
- 迭代器
- - iter()函数
  - next（）函数
- 生成器
Python函数
- - 定义一个函数
  - 语法
  - 函数调用
  - 参数传递
  - - 可更改与不可更改对象
    - 传不可变对象
    - 传可变对象
- 参数
- - 必需参数
  - 关键字参数
  - 默认参数
  - 不定长参数
- 匿名函数
- return语句

Python迭代器与生成器

迭代器

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

iter()函数

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

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

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

next（）函数

#!/usr/bin/python3import 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/python3import sysdef fibonacci(n): # 生成器函数 - 斐波那契a, b, counter = 0, 1, 0while True:if (counter > n): returnyield aa, b = b, a + bcounter += 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 * heightdef 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/python3def ChangeInt( a ):a = 10b = 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_suitereturn [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 + arg2print ("函数内 : ", total)return total# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)