第四章迭代器等

迭代器

定义

 迭代器是一个可以遍历容器的一个对象

1. 迭代器返回一个对象
2. 那些东西可以进行迭代

  容器类型的---list  set  字典 字符串

方法

"""

 迭代器

  #注意是两个下划线

  list01.__iter__() 返回一个迭代器对象

     <list_iterator object at 0x0000024037E0C588>

"""

list01 = [1,2,3,4]

#注意是两个下划线

a =  list01.__iter__()

print(a) #<list_iterator object at 0x0000024037E0C588>

"""

 1.我听要他何用，他是一个对象，我想要的是值

 迭代器对象.__next__() 返回一个值

 2.他只能返回第一个值吗  no

  因为next()可以记忆位置，每次你调用一次，他会记住这位置，然后下一次从下一个位置开始

 3.我要是一直调用，可以吗

    报错StopIteration，没有数据了

    我们的next没有办法回头，不会从头开始，他只会从记忆的位置的开始

"""

print(a.__next__()) #1

print(a.__next__()) #2

print(a.__next__()) #3

print(a.__next__()) #4

print(a.__next__()) #报错

迭代

list01 = [1,2,3,4]

#注意是两个下划线

a =  list01.__iter__()

"""

 迭代对象的遍历

 1.__next__() 不会从头开始， 每次从记忆的位置开始

 2.for循环就相当于是不断的打印__next__()。但是为什么没报错

   自己抛出StopIteration，然后停止循环

"""

for i in list01:

   print(i)

迭代对象

1. 那些东西可以进行迭代

  容器类型的---list  set  字典 字符串

为什么是两个下划线

有些方法以双下划线 “__” 开头和结尾，它们是Python的魔法函数，用于特殊用途

Next()

.next()

.__Next__()

__init__()

__iter__()

Func_sum()

生成器

定义

生成器也是一种迭代器，但是你只能对其迭代一次。

>>> a = func_add01([2,3,5,7,9])

>>> a

<generator object func_add01 at 0x000001AD11F8D148>

>>> for i in a:

    print(i)

   

3

4

6

8

10

>>> a.__next__()

Traceback (most recent call last):

  File "<pyshell#18>", line 1, in <module>

    a.__next__()

StopIteration

>>> b = func_add01([2,3,5,7,9])

>>> b.__next__()

3

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个特殊的迭代器。

>>> func_add01([1,2,3,4])

<generator object func_add01 at 0x000001AD11F8D148

生成器可以一边循环一边计算

优点是节省内存

关键字是：yield

代码

>>> def func_add(list01):

       list02 = []

       for i in list01:

              list02.append(i+1)

       return list02

>>> func_add([1,2,3,4])

[2, 3, 4, 5]

>>> def func_add01(list01):

       for i in list01:

              yield i+1

             

>>> func_add01([1,2,3,4])

<generator object func_add01 at 0x000001AD11F8D148>

>>> list(func_add01([1,2,3,4]))

[2, 3, 4, 5]

>>> a = func_add01([2,3,5,7,9])

>>> a

<generator object func_add01 at 0x000001AD11F8D148>

>>> for i in a:

       print(i)

      

3

4

6

8

10

>>> a.__next__()

Traceback (most recent call last):

  File "<pyshell#18>", line 1, in <module>

    a.__next__()

StopIteration

>>> b = func_add01([2,3,5,7,9])

>>> b.__next__()

3

>>>

语法

 由于生成器是一个返回迭代器的函数

生成器一边循环一边计算

关键字是yield

def func_name(canshu):

     for i in canshu:

          yield luoji

总结

1. 生成器都是迭代器，迭代器不一定是生成器
2. 字符串，列表，元组，字典，集合都可以被for循环，说明他们都是可迭代对象
3. 迭代器的两个方法：1.有__iter__() 2. 有__next__()
4. isinstance() 类型判断。isinstance(a,Iterable) 判断a 是否是可迭代对象。

推导式

引入

"""

普通循环

"""

for i in [1,2,3,4]:

    print(i)

"""

推导式

"""

[print(i) for i in [1,2,3,4]]

定义

推导式是从一个或者多个迭代器快速创建序列的一种方法。

语法

[逻辑/结果 for i in 序列类型的变量]

你想要什么类型，就在外层包裹什么

序列类型

 []  () {k,v} {}

用法

列表类型

"""

 推导式

"""

list01 = [1,2,3,4]

a=  [i+1 for i in list01]

print(a) #[2, 3, 4, 5]

print(type(a)) #<class 'list'>

元组类型

list01 = [1,2,3,4]

#把里面的代码看成一个整体，一个对象

#利用我们的tuple()函数

a=  tuple(i+1 for i in list01)

print(a)  #(2, 3, 4, 5)

print(type(a)) #<class 'tuple'>

#把3+2变成一个整体

(3+2)/9

集合类型

list01 = [1,2,3,4]

a=  { i+1 for i in list01}

print(a) #{2, 3, 4, 5}

print(type(a)) #<class 'set'>

字典类型

dict01 = { "王五":20,"张三":50,"李四":80,"赵六":18}

for k,v in dict01.items():

    print(k,v)

{ print(k,v) for k,v in dict01.items()}

参数传递

参数传递机制

"""

函数参数传递机制和赋值机制是一样的，其本质就是传递内存地址，这就是引用传递

 a传进来的时候传进来的是内存地址

 如果实在不理解，你可以以为是  x= a

"""

def isid(x):

    #打印参数的内存地址

    print(id(x))

a = 10

#变量的内存地址

print(id(a)) #140731588047408

#a变成的参数，打印参数内存地址

isid(a) #140731588047408

默认参数

#定义一个带有默认参数的函数

def add(x,y=10):

    sum01 = x+y

    return sum01

"""

1.add(2)  x=2  y=10

2.add(2,3)  x=2  y=3

"""

print(add(2)) #12

print(add(2,3)) #5

"""

 能不能传参传入一个序列类型，比如list，让他默认是[]

"""

def add(list01 = []):

    list01.append(1)

    return list01

#第一调用

print(add()) #[1]

#第二次调用

print(add()) #[1, 1]

#第三次调用 

print(add()) #[1, 1, 1]

 

不定数目的参数

一个 *

"""

 一个* ：代表的是可变参数（就是可以是多个值）

"""

def add(x,*y):

    sum01 = x

    for i in y:

        sum01 += i

    return sum01

print(add(1,2,3,4,5)) #15

两个*

"""

 **y代表可以使用任意  键值（字典）  作为参数

 **y就相当于字典类型

"""

def func_add(x,**y):

    sum01 = x

    #切记这里是字典的循环

    for k,v in y.items():

        print(k,v)

        #把v（值）进行和x相加

        sum01 += v

    return sum01

"""

 调用

a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}

"""

print(func_add(1,a=3,b=4,c=5)) #13

name

1. 执行本文件的时候，name==main

#打印name这个属性

#执行本文件的时候，打印的是main，__name__ == __main__

print("1、"+__name__) #1、__main__

2.在被import导入到别的文件的时候，name==文件名字

"""

 一个文件就是一个模块，导入模块，就相当于导入文件，可以直接写

    import  文件名字

"""

import 本文件 as bwj

#在其他类中运行导入的文件名字，__name__==文件名字

print(bwj.__name__) #本文件

高阶函数

定义

高阶函数是一个（ 以函数为参数，或者以函数为返回值的）函数

函数可以是参数，参数是变量，那么函数可以是变量吗

参数其实就是变量进行了赋值，函数能不能是变量

函数为变量（补充）

  函数为变量并不是高阶函数，只是和大家补充这个知识点

"""

 函数为变量

"""

#定义一个函数，传入一个参数，求这个参数的平方

def func_pf(x):

    return pow(x,2)

#字典

#已知李四的年龄是5的平方，求李四的年龄

dict01 = { "张三":20,"李四":func_pf}

"""

 调用

  1.func_pf = dict01["李四"]  根据key获取value,vaule是一个函数对象

  2.age02 = func_pf(5) #调用函数就能获取年龄

"""

#字典的特点是根据key获取value

age01 = dict01["张三"]

print(age01) #20

#顾名思义，通过李四，我们可以拿到函数func_pf

#拿到的是函数对象，我们不能直接打印

func_pf = dict01["