zoukankan      html  css  js  c++  java
  • 三元表达式, 迭代器, 生成器, 列表推导式, 字典生成式, 生成器生成式. 递归

    三元表达式

    x = 10
    y = 20
    print(x) if x>y	else print(y)
    

    条件成立执行左边代码,条件不成立执行右边代码

    迭代器

    迭代器

    不是函数,知识一个称呼而已

    python中一切皆对象(数据类型)

    可迭代对象

    含有__iter__方法的数据类型就叫做可迭代对象

    x = 10
    # x.__iter__    #不含.__iter__方法,不是可迭代对象
    
    s = '蔡启龙'
    s.__iter__()
    
    lt = [1,2,3]
    lt.__iter__()
    
    tup = (1,2,3)
    tup.__iter__()
    
    dic = {'a':1,'b':2}
    dic.__iter__()
    
    sets = {1,2,3}
    sets.__iter__()
    
    fr = open('yhxx.txt','r')
    fr.__iter__()
    

    除了数字类型,其他所有数据类型都是可迭代对象

    迭代器对象

    含有__iter____next__方法的对象就是迭代器对象

    为什么要有迭代器对象

    提供了不依赖索引取值的手段

    for循环原理---迭代循环

    循环迭代取值,超出迭代范围报错

    for循环本质就是一个while循环,只不过是一个一定可控的while循环

    dic = {'a':1,'b':2,'c':3}
    dic.__iter__()
    m = dic.__iter__()
    while True:
        try:
            print(m.__next__())
        except StopIteration:
            break
    

    可迭代对象使用.__iter__方法变成迭代器

    只有文件是迭代器对象--迭代器使用.__iter__方法依然是迭代器

    可迭代对象不一定是迭代器,但是迭代器一定是可迭代对象

    列表推导式

    生成一个长度为l的列表

    方法一:

    lt = []
    for i in range(10):
        lt.append(i**2)
    

    方法二:列表生成式

    将方法一种的三行代码简化成一行

    lt1 = [i for i in rang(10)]
    print(lt1)
    lt2 = [0 for i in range(10)]
    print(lt2)
    lt3 = [i**i for i in range(10)]
    print(lt3)
    from typing import Iterable
    print(isinstance(range(10),Iterable)
    from typing import Iterable
    print(isinstance(range(10),Iterable))
    print(isinstance(range(10),list))	#判断是否属于某种数据类型
    print(isinstance(1,Iterable))
    

    语法: # lt = [列表每个元素值 for i in range(列表长度)],其中range(10)也可以是其他可迭代对象

    字典生成式

    生成一个长度为l的字典

    方法一:

    dic = {}
    for i in range(3):
        dic[f'第{i+1}个key']=i**3
    print(dic)
    

    方法二:字典生成式

    dic = {f'第{i+1}个key':(i+1)**3 for i in range(3)}
    print(dic)
    

    语法:# dic = {key:value for i in range(字典长度)} 其中key为不可变数据类型,value可以为运算表达式

    zip()方法---如何使用未知方法-->三步

    1.鼠标左键 + ctrl 点击关键字查看该方法注释-->将注释翻译

    2.方法中的参数的中括号([])内的参数可加可不加: zip(iter1 [,iter2 [...]]) --> zip object

    3.注释看不懂的跳过,整体看完再回过头看看不懂的,还是不懂就把能看懂的打印尝试

    res = zip([1,2,3])	#res接收的是一个迭代器对象,.__next__方法返回的是一个元组
    print(zip([1,2,3]))
    print(res)
    print(zip([1,2,3]).__next__())	#tuple,调用zip函数每次返回一个新的对象,类似光标一直停留在头部
    print(zip([1,2,3]).__next__())
    print(zip([1,2,3]).__next__())
    print(res.__next__())	#tuple
    print(res.__next__())	
    print(res.__next__())
    # print(res.__next__())
    res2 = zip([1,2,3],{'x':147,'y':258,'z':369},'abcafffg')
    print(res2.__next__())
    print(res2.__next__())
    print(res2.__next__())
    

    给定两个列表lt1,lt2;生成一个以lt1元素为key,以,含有lt2元素的运算表达式,的结果,为value的字典

    lt1 = ['a','b','c']
    lt2 = [1,2,3]
    dic = {m:n**4 for m,n in zip(lt1,lt2)}
    print(dic)
    
    s = 'abc'
    res = s.__iter__()
    for i in res:
        print(i)
    print(list(res))
    print(list(s))
    

    生成器表达式

    概念

    generator本质是一个迭代器,可以看成一个自定义的迭代器

    生成器:含有yield关键字的函数叫做生成器

    def g():
        yield 3000	#一个yiled产出一个生成器(本质为自定义的迭代器对象)对象中的可迭代元素,可用.__next__()方法取值
        yield 2000
        print('蔡启龙')
        yield 1000
        yield 0000
    print(g)	#不调用g解释器将g判别为函数,调用g()执行代码中的关键字yield解释器将g()判别为一个生成器对象,即本质上为一个自定义的迭代器对象
    print(g())
    res = g()
    print(res)
    print(g().__next__())	
    print(g().__next__())	#每次生成新的生成器对象
    print(res.__next__())	#res接收之后固定为一个生成器对象
    print(res.__next__())
    #print(res.__next__())	#yield能暂停函数,通过.__next__()方法取值
    

    return和yield两者的不同特性

    return

    1.终止函数

    2.通过调用函数拿到return值

    yield

    1.通过g()得到一个生成器

    2.暂停函数

    3.通过.__next__方法取值

    用生成器写一个range函数方法---range函数本质上就是一个生成器

    1.可边长参数

    2.生成器

    # print(range(1,20))
    def range(*args):
        if len(args) == 1:
            count = 0
            i = args[0]
            while count < i:
                yield count
                count += 1
        if len(args) == 2:
            i,j = args
            while i<j:
                yield i
                i += 1
        if len(args) == 3:
            i,j,k = args
            while i<j:
                yield i
                i += k
    for i in range(1,8,3):
        print(i)
    

    生成器表达式

    语法:g = (i for i in range(10)) for i in g: print(i)

    生成器表达式与列表推导式区别

    生成器表达式:只占一块内存,节省内存,取值可控

    列表推导器:非常占用内存

    递归

    释义

    1.传递回归,函数a内部直接调用函数本身

    2.真正的递归必须要有退出条件

    def a():
        x = 1
        print(id(x))  #小整数池
        a()
    a()	#递归死循环
    

    3.递归必须要有规律

    打印1~10

    count = 0
    def print_n():
        global count
        count += 1
        print(count)
        print_n()	#卡在这里显然死循环递归调用
        if count == 10:
            return
    print_n()
    
    count = 0
    def print_n():
        global count
        if count == 10:
            return
        count += 1
        print(count)
        print_n()
    print_n()
    

    写一个递归函数:

    求解:第一个同学 20岁 ; 他后面的同学年龄依次递增2岁,求第i位同学的年龄

    def age(x):
        if x==1:
            res = 20
            return res
        x = x-1
        res = age(x) + 2
        return res
    print(age(6))
    
    def age(x):
        firth = 20
        if x == 1:
            return firth
        return (age(x-1)+2)
    print(age(6))
    
  • 相关阅读:
    Java:volatile 关键字的一点理解
    Java:准备学习的高级主题
    ASP.NET MVC:看 MVC 源码,学习:如何将 Area 中的 Controller 放到独立的程序集?
    Tomcat:基础安装和使用教程
    Javascript:看 Javascript 规范,学 this 引用,你会懂的。
    T4:T4 笔记 + Trait 示例
    Java:Java快速入门
    .NET:C#的匿名委托 和 Java的匿名局部内部类
    FAQ:如何修改领域模型?
    设计原则:对象之间的关系
  • 原文地址:https://www.cnblogs.com/-406454833/p/11595718.html
Copyright © 2011-2022 走看看