码迷,mamicode.com
首页 > 编程语言 > 详细

Python基础(十一)

时间:2019-09-22 16:42:55      阅读:107      评论:0      收藏:0      [点我收藏+]

标签:空间换时间   结果   取值   文件句柄   两种   机制   for循环   类型   寻址   

今日主要内容

  • 补充:三目运算
  • f-strings
  • 迭代器
  • 生成器

补充:三目运算

  1. 三目运算(三元运算)结构:
  • 表达式1 if 条件表达式 else 表达式2
  • c = a if a > b else b
  1. 执行流程:

    • 判断条件,如果条件正确将a赋值给c
    • 如果条件不正确将b赋值给c
    a = 10
    b = 20
    c = a if a > b else b  # 三目运算
    print(c)
    
    运行结果:
    20

一、f-strings

  • f-strings之前我们已经说过了,python3.6以上的版本可以使用,用来格式化输出,非常的方便,今天来详细说一下
  1. f-strings的格式:

    • f"xxxx{传入的变量}xxxx"(建议使用f
    • F"xxxx{传入的变量}xxxx"(不建议使用F
    name = "zxd"
    age = 23
    print(f"姓名:{name} 年龄:{age}")
    
    运行结果:
    姓名:zxd 年龄:23
  2. 引号中如果需要大括号{}时,用两个{{}}代表

    print(f"{{'a'}}")  # 用两个大括号表示
    
    运行结果:
    {'a'}
  3. 引号中需要使用引号时,一定用两个单引号‘‘表示

    print(f"{{'a'}}")  # 用单引号表示
    
    运行结果:
    {'a'}
  4. 传入的参数可以是三目表达式

    a = 10
    b = 10
    print(f"{a if a > b else b}")
    
    运行结果:
    10

二、迭代器

(一)可迭代对象

  • 说迭代器之前咱们来看一看可迭代对象,什么是可迭代对象?

    • 可以一个一个取值的对象就是可迭代对象
    s = "12345"
    lst = [1, 2, 3, 4, 5]
    dic = {1: 1, 2: 2, 3: 3}
    .......
    
    # 这些都是可迭代对象
    • 他们共有的一个特点就是可以被for循环
    s = "12345"
    lst = [1, 2, 3, 4, 5]
    dic = {1: 1, 2: 2, 3: 3}
    
    for el in s:
      print(el)
    for el in lst:
      print(el)
    for el in dic:
      print(el)   
  1. 查看可迭代对象的官方方法:

    • 查看对象是否有__iter__()方法,只要使用有此方法的对象全部都是可迭代对象
    • dir()函数可以查看对象所有的方法
    lst = [1, 2, 3, 4, 5]
    print("__iter__" in dir(lst))
    
    运行结果:
    True
  2. 可迭代对象的特点:

    • 空间换时间的理念(用大量的空间节省时间)
    • 优点:
      • 使用灵活,每个可迭代对象都有自己的方法
      • 能够直接查看元素个数
      • 可以重复取值
    • 缺点:
      • 占内存
  3. 应用:内存空间大,当数据量比较少,建议使用可迭代对象

(二)迭代器

  • 迭代器可以理解成可迭代对象的实体化,它只继承了迭代性(可以一个一个取值),同时节约了内存(唯一的优点)
  • 文件句柄就是一个迭代器
  1. 迭代器的生成方法:

    • 两种生成方法效果相同
    • iter(可迭代对象)
      • 生成可迭代对象的迭代器
      • 打印的是迭代器的地址
    lst = [1, 2, 3, 4, 5]
    l = iter(lst)
    print(l)
    
    运行结果:
    <list_iterator object at 0x0000020BAFCEA940>
    
    • 可迭代对象.__iter__()
      • 生成可迭代对象的迭代器
      • 打印的是迭代器的地址
    lst = [1, 2, 3, 4, 5]
    l = lst.__iter__()
    print(l)
    
    运行结果:
    <list_iterator object at 0x000002490EFDA8D0>
    
  2. 迭代器的取值

    • 迭代器最大的特点就是惰性机制,如果不主动向迭代器取值,迭代器是不会给你值的,同时也正因为惰性机制节约了内存
    • next(迭代器)
    lst = [1, 2, 3, 4, 5]
    l = iter(lst)
    print(next(l))
    print(next(l))
    print(next(l))
    print(next(l))
    print(next(l))
    
    运行结果:
    1 2 3 4 5
    
    • 迭代器.__next__()
    lst = [1, 2, 3, 4, 5]
    l = lst.__iter__()
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    
    运行结果:
    1 2 3 4 5
    
    • 每次执行取值函数只向迭代器取一个值,按顺序向下取值,不能重复取值,迭代器中有多少个元素就只能next多少次,超出最大个数会报错
    lst = [1, 2, 3, 4, 5]
    l = lst.__iter__()
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    print(l.__next__())
    
    运行结果:
    1 2 3 4 5
    StopIteration
    
  3. 迭代器的特点:

    • 时间换空间理念(用大量的时间去节省空间)
    • 节省内存
    • 惰性机制
    • 只能向下取值,不能往复
  4. for循环的本质就是一个迭代器

    • 捕获异常:向迭代器取值超出迭代器元素数量时,会捕获StopIteration异常,从而终止while循环
    lst = [1, 2, 3, 4, 5]
    l = iter(lst)
    while True:
     try:
         print(next(l))
     except StopIteration:  # 捕获异常
         break
    
  5. 向同一个迭代器取值,迭代器内部会记录取值位置,赋值给变量,变量会指向地址和上次取值位置

    lst = [1, 2, 3, 4, 5]
    l_iter = iter(lst)
    print(next(l_iter))
    print(next(l_iter))
    print(next(l_iter))
    print(next(l_iter))
    print(next(l_iter))  # l_iter指向取值记录位置
    
    运行结果:
    1 2 3 4 5
    
    • l_iter指向迭代器的地址,每一次取值,l_iter指向上一次取值位置
    • 可以理解成通过熟人买东西,每次买都是上次的优惠价
  6. 向同一个迭代器取值,迭代器内部会记录取值位置,若不赋值,每一次取值都从开头取值,相当于每次寻址后都从头开始

    lst = [1, 2, 3, 4, 5]
    print(next(iter(lst)))
    print(next(iter(lst)))
    print(next(iter(lst)))
    print(next(iter(lst)))
    print(next(iter(lst)))
    print(next(iter(lst)))  # 每次都从头开始取值
    
    运行结果:
    1 1 1 1 1
    
    • 没有赋值每次通过func()直接寻址,都从头部开始取值
    • 可以理解成没有熟人了,每次买东西都是原价
  7. 应用:内存小,数据量巨大时,建议使用迭代器

(三)两者关系

  • 迭代器一定是可迭代对象,可迭代对象不一定是迭代器
  • 迭代器可以通过iter(可迭代对象)可迭代对象.__iter__()得到

三、生成器

(一)什么是生成器

  • 生成器的本质就是迭代器

  • 生成器就是一个自己写的迭代器,而迭代器只能通过iter()函数得到

  • 生成器的目的是不通过数据转换实现,通过代码实现

    • 列表转换成了迭代器,但是列表依旧加载到了内存,没有达到省内存的效果
    lst = [1, 2, 3, 4, 5]
    l_iter = iter(lst)
    print(next(l_iter))
    print(next(l_iter))
    print(next(l_iter))
    print(next(l_iter))
    print(next(l_iter))
    
    运行结果:
    1 2 3 4 5
    
    • 通过生成器真正达到省内存的效果
    def func():
      yield 1
      yield 2
      yield 3
      yield 4
      yield 5
    
    f_gen = func()
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    
    运行结果:
    1 2 3 4 5
    

(二)生成器

  1. 通过函数实现生成器

    • 先来看一个函数
    def func():
     print(1)
     return 1
    
    print(func())
    
    运行结果:
    1 1
    
    • 将函数中return替换成yield就变成了一个生成器
    def func():
     print(1)
     yield 1
    
    print(func())
    
    运行结果:
    <generator object func at 0x000001B27042C50>
    
    • 如果定义的是函数,函数名加括号是调用函数;而如果定义的是生成器,函数名加括号是得到的是生成器的内存地址
    • yield
      • yield能返回多个值,以元组形式存储
      • yield能返回各种数据类型
      • yield能够写多个并且都能执行
      • yield能够记录执行位置
      • yield后面不写内容,默认返回None
      • yield只能向下进行,不能往复,一次性取值
  2. 生成器的取值

    • next(生成器)
    def func():
    yield 1
     yield 2
    yield 3
     yield 4
    yield 5
    
    f_gen = func()
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    
    运行结果:
    1 2 3 4 5
    
    • 生成器.__next__()
    def func():
     yield 1
    yield 2
     yield 3
     yield 4
     yield 5
    
    print(func().__next__())
    print(func().__next__())
    print(func().__next__())
    print(func().__next__())
    print(func().__next__())
    
    运行结果:
    1 2 3 4 5
    
  3. 生成器的本质就是一个迭代器,所以它拥有迭代器的所有特点

    • 时间换空间理念(用大量的时间去节省空间)
    • 节省内存
    • 惰性机制
    • 只能向下取值,不能往复
  4. 向同一个生成器取值,yield会记录取值位置,赋值给变量,变量会指向地址和上次取值位置

    def func():
     yield 1
     yield 2
     yield 3
     yield 4
     yield 5
    
    f_gen = func()
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))
    print(next(f_gen))  # f_gen指向生成器地址和yiele记录的位置
    
    运行结果:
    1 2 3 4 5
    
  5. 向同一个生成器取值,yield会记录取值位置,若不赋值,每一次取值都从开头取值,相当于每次寻址后都从头开始

    def func():
     yield 1
     yield 2
     yield 3
     yield 4
     yield 5
    
    print(next(func()))
    print(next(func()))
    print(next(func()))
    print(next(func()))
    print(next(func()))  # 每次都从头开始取值
    
    运行结果:
    1 2 3 4 5
    
  6. 若yield的值是个可迭代对象,还可以将其对象逐个返回

    • yield from
    def func():
     yield from [1, 2, 3]
     yield from [4, 5, 6]
    
    print(next(func()))
    print(next(func()))
    print(next(func()))
    print(next(func()))
    print(next(func()))
    print(next(func()))
    
    运行结果:
    1 2 3 4 5 6
    

四、三者区分

(一)可迭代对象

  • 只要是可以使用__iter__()方法的对象都是可迭代对象
  • 迭代器和生成器都是可迭代对象

(二)迭代器

  • 查看对象的内存地址,如果有iterator就是一个迭代器
  • 拥有__iter__()__next__()放法的就是一个迭代器

(三)生成器

  • 查看对象的内存地址,如果有generator就是一个生成器
  • 可以使用send()方法的就是一个生成器

Python基础(十一)

标签:空间换时间   结果   取值   文件句柄   两种   机制   for循环   类型   寻址   

原文地址:https://www.cnblogs.com/tianlangdada/p/11567942.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!