Python3入门（五）

Python入门（五）

一、Python3 迭代器与生成器

1.迭代器

• 迭代是python最强大的功能之一，是访问集合元素的一种方式。
• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不能后退。
• 迭代器有两个基本的方法：iter() 和 next()。
• 字符串，列表或元组对象都可用于创建迭代器：

list = [1, 2, 3, 4]

it = iter(list)
print(next(it))
print(next(it))

#输出结果：
#1
#2

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

list = [1, 2, 3, 4]

it = iter(list)
for x in it:
    print(x, end=' ')

#输出结果：
1 2 3 4

也可以使用next函数：

import sys  # 引入 sys 模块

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象

while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

2.创建一个迭代器

• 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__()与 __next__()。

• __iter__()方法返回一个特殊的迭代器对象，这个迭代器对象实现了__next__()方法并通过StopIteration异常标志迭代的完成。

• __next__()方法会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为1，逐步递增1：

class Mynumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x

myclass = Mynumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

#输出结果：
#1
#2
#3
#4
#5

StopIteration

• StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

实例：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x, end=' ')
  
#输出结果：
#1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 

二、Python3 函数

• 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

• 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

1.定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

• 函数内容以冒号 : 起始，并且缩进。

• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0VDa661g-1618368054116)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210412112621106.png)]

2.语法

python 定义函数使用 def 关键字，一般格式如下：

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

默认情况下，参数值和参数名称是按函数声明中的定义的顺序匹配连接起来的。

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

#输出结果：
#Hello World!	

3.函数调用

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

实例：

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

#输出函数：
#我要调用用户自定义函数!
#再次调用同一函数

4.参数传递

在Python中，类型属于对象，变量是没有类型的:

a = [1, 2]
a = "hello"

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象

可更改(mutable) 与不可更改 (immutable) 对象

• 在Python中，strings,tulpes和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传不可变对象实例

通过id() 函数来查看内存地址变化：

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)

#输出结果
#140720676699200
#140720676699200
#140720676699488

可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

传可变对象实例

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

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

#输出结果：
#函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
#函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

5.参数

以下是调用函数时可使用的正式参数类型：

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

必需参数

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

#调用printme() 函数，你必须传入一个参数，不然会出现语法错误。

def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

#输出结果：
#Traceback (most recent call last):
#  File "D:/python_project/main.py", line 8, in <module>
#    printme()
#TypeError: printme() missing 1 required positional argument: 'str'

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够使用参数名匹配参数值。

实例：

#在函数 printme() 调用时使用参数名：
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "hello")

#输出结果：
#hello

#函数参数的使用不需要使用指定顺序：
def printinfo(name, age):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=50, name="runoob")

#输出结果：
#名字:  runoob
#年龄:  50

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。

def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

#输出结果：
#名字:  runoob
#年龄:  50
#------------------------
#名字:  runoob
#年龄:  35

不定长参数

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

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

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

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

#输出结果：
#70
#(60, 50)

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

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

#输出结果
#10
#70
#60
#50

还有一种就是参数带两个星号 ******基本语法如下：

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

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

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

#输出结果：
#1
#{'a': 2, 'b': 3}

声明函数时，参数中* 星号可以单独出现，例如：

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

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

print(f(1, 2 ,3))   #报错
print(f(1, 2, c=3))  #输出6

6.匿名函数

python 使用 lamnda 来创建匿名函数。

所谓匿名，即不再使用 def 语句这样的标准形式定义一个函数。

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

语法

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

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

实例：

sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))

#输出结果：
#相加后的值为 :  30
#相加后的值为 :  40

7.return语句

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

def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2
    print("函数内 : ", total)
    return total


# 调用sum函数
total = sum(10, 20)
print("函数外 : ", total)

#输出结果：
#函数内 :  30
#函数外 :  30

8.强制位置参数

Python 3.8 新增了一个函数形参语法/ 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

#形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    
    
#函数的正确使用：
f(10, 20, 30, d=40, e=50, f=60)

#错误用法：
f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

urn total

调用sum函数

total = sum(10, 20)
print("函数外 : ", total)

#输出结果：
#函数内 : 30
#函数外 : 30

### 8.强制位置参数

Python 3.8 新增了一个函数形参语法/ 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

```python
#形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    
    
#函数的正确使用：
f(10, 20, 30, d=40, e=50, f=60)

#错误用法：
f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式