精华内容
下载资源
问答
  • 综述迭代器对于原生支持随机访问的数据结构(如tuple、list),迭代...另外,迭代器的一大优点不要求事先准备好整个迭代过程所有的元素。迭代器仅仅迭代到某个元素时才计算该元素,而这之前或之后,元素可以...

    综述迭代器

    对于原生支持随机访问的数据结构(如tuple、list),迭代器和经典for循环的索引访问相比并无优势,反而丢失了索引值(可以使用内建函数enumerate()找回这个索引值)。但对于无法随机访问的数据结构(比如set)而言,迭代器是唯一的访问元素的方式。

    另外,迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合,比如几个G的文件,或是斐波那契数列等等。

    迭代器更大的功劳是提供了一个统一的访问集合的接口,只要定义了iter()方法对象,就可以使用迭代器访问。

    例如:

    List = [1,2,3]

    L = List.__iter__()

    >>> L.next()

    1

    >>> L.next()

    2

    >>> L.next()

    3

    为什么使用迭代器

    for i in range(1000): pass

    for i in xrange(1000): pass

    前一个返回1000个元素的列表,而后一个在每次迭代中返回一个元素,因此可以使用迭代器来解决复用可占空间的问题

    class Fab(object):

    def __init__(self, max):

    self.max = max

    self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):

    return self

    def next(self):

    if self.n < self.max:

    r = self.b

    self.a, self.b = self.b, self.a + self.b

    self.n = self.n + 1

    return r

    raise StopIteration()

    Fab 类通过 next() 不断返回数列的下一个数,内存占用始终为常数

    示例代码2

    def fab(max):

    n, a, b = 0, 0, 1

    while n < max:

    yield b

    a, b = b, a + b

    n = n = 1

    简单地讲,yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator,调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable 对象!

    在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。

    看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。

    以上这篇python 字典item与iteritems的区别详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • 前几天看了些python的代码,发现有些函数的参数前带有(*)号,有的甚至有两个(*)号,不清楚它们代表什么意思。 解释 查阅资料后发现,参数前面加上* 号 ,意味着参数的个数不止一个,另外带一个星号(*)参数的...
  • python ,*args 和 **kwargs 都代表 1个 或 多个 参数的意思。*args 传入tuple 类型的无名参数,而 **kwargs 传入的参数 dict 类型。下文举例说明。 1.*args 的用法,以下测试代码: def test(*args): ...

    在 python 中,*args**kwargs 都代表 1个 或 多个 参数的意思。*args 传入tuple 类型的无名参数,而 **kwargs 传入的参数是 dict 类型。下文举例说明。

    • 单星号形式(*args)用来传递非命名键可变参数列表。
    • 双星号形式(**kwargs)用来传递键值可变参数列表。

    1.*args 的用法,以下测试代码:

    def test(*args):  
        print(args)
        for i in args:
            print(i)
    
    test(1,2,3)
    
    # 输出值分别为
    # (1,2,3)
    # 1
    # 2
    # 3
    

    2.**kwargs 的用法,以下测试代码:

    def test(**kwargs):
        print(kwargs)
        keys = kwargs.keys()
        value = kwargs.values()
        print(keys)
        print(value)
    
    test(a=1,b=2,c=3,d=4)
    
    # 输出值分别为
    # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    # dict_keys(['a', 'b', 'c', 'd'])
    # dict_values([1, 2, 3, 4])
    

    3.实际例子

        def from_settings(cls, settings):
            dbparms = dict(
                host = settings["MYSQL_HOST"],
                db = settings["MYSQL_DBNAME"],
                user = settings["MYSQL_USER"],
                passwd = settings["MYSQL_PASSWORD"],
                charset='utf8',
                cursorclass=MySQLdb.cursors.DictCursor,
                use_unicode=True,
            )
            dbpool = adbapi.ConnectionPool("MySQLdb", **dbparms)
    
            return cls(dbpool)
    
    展开全文
  • 如何使用 C# Tuple

    2021-01-21 23:49:22
    首先声明的是 Tuple 不是什么新鲜概念,编程语言 F#,Python 早就有这个了,Tuple 是一种 有序的,有限不可变的,支持混杂类型的固定个数的 一种数据结构,有些朋友可能就想问了,这里的混杂是什么意思?...

    开局一张图,首先声明的是 Tuple 不是什么新鲜概念,在编程语言 F#,Python 中早就有这个了,Tuple 是一种 有序的,有限不可变的,支持混杂类型的固定个数的 一种数据结构,有些朋友可能就想问了,这里的混杂是什么意思? 其实就是说 Tuple 中的若干元素类型,即可以是同类型,也可以是不同类型。

    值得注意的是,Tuple 中的元素是 只读的,而且其元素的顺序也是在 Tuple 创建的时候指定好的,不能对其中的元素进行后续修改 也不能修改 Tuple 的大小。

    为什么要使用 Tuple

    下面罗列了几种使用 Tuple 的场景:

    • 如果你的方法需要返回多个值 或者 方法需要传递多个值。

    • 如果你不想为某些功能专门去定义一个类。

    • 如果你有若干个混杂元素,并且想提供对其简单的访问方式。

    上面三种情况都是 Tuple 最擅长的应用场景,值得用 Tuple 去解决。

    有些朋友可能会想到 匿名类,但仔细想想, 匿名类 也有其缺陷,比如说方法的返回值是不可能指定为匿名类型的,对吧。

    当然 Tuple 也是有缺陷的,罗列如下:

    • 当你访问 Tuple 中的元素时,你会发现只能使用 Item1, Item2, Item3 这样的形式,很显然这种太不易读了,而且一旦 Tuple 中的元素过多,维护起来也是一种负担。

    • Tuple 是引用类型不是值类型,意味着它会在 托管堆 上进行内存分配,如果 Tuple 过大并且没有很好的释放,对程序也是一个不小的性能挑战。

    C# 中使用 Tuple

    叨叨叨的说了这么多,接下来看看如何使用,在 C# 中提供了一个 Tuple 类,这个类下有一个静态方法 Create 可用来生成 Tuple 实例,顺便提一下,这个 Create 方法提供了 8 个重载方法,下面展示了这些方法签名清单。

    
    public static class Tuple
    {
        public static Tuple<T1> Create<T1>(T1 item1)
        {
            return new Tuple<T1>(item1);
        }
    
        public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
        {
            return new Tuple<T1, T2>(item1, item2);
        }
    
        public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
        {
            return new Tuple<T1, T2, T3>(item1, item2, item3);
        }
    
        public static Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4)
        {
            return new Tuple<T1, T2, T3, T4>(item1, item2, item3, item4);
        }
    
        public static Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
        {
            return new Tuple<T1, T2, T3, T4, T5>(item1, item2, item3, item4, item5);
        }
    
        public static Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
        {
            return new Tuple<T1, T2, T3, T4, T5, T6>(item1, item2, item3, item4, item5, item6);
        }
    
        public static Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
        {
            return new Tuple<T1, T2, T3, T4, T5, T6, T7>(item1, item2, item3, item4, item5, item6, item7);
        }
    
        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
        {
            return new Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>(item1, item2, item3, item4, item5, item6, item7, new Tuple<T8>(item8));
        }
    }
    

    接下来看看如何创建和初始化 Tuple。

                var listEmployee = new List<Tuple<int, string, string>>
                {
                  Tuple.Create(1, "Joydip Kanjilal", "INDIA"),
                  Tuple.Create(2, "Michael Stevens", "USA" ),
                  Tuple.Create(3, "Steve Barnes", "USA" )
                };
    

    一旦你的 Tuple 创建并初始化好,你可以像迭代其他集合一样迭代 Tuple,下面的代码清单展示了如何去实现。

    
                foreach (Tuple<int, string, string> tuple in listEmployee)
                {
                    Console.WriteLine(tuple.Item2);
                }
    

    下面是完整的代码清单展示了如何去 创建,初始化,迭代。

    
            static void Main(string[] args)
            {
                var listEmployee = new List<Tuple<int, string, string>>
                {
                    Tuple.Create(1, "Joydip Kanjilal", "INDIA"),
                    Tuple.Create(2, "Michael Stevens", "USA" ),
                    Tuple.Create(3, "Steve Barnes", "USA" )
                };
    
                foreach (Tuple<int, string, string> tuple in listEmployee)
                {
                    Console.WriteLine(tuple.Item2);
                }
                Console.Read();
            }
    

    你也可以创建 嵌套的 Tuple,如下代码所示:

    
            static void Main(string[] args)
            {
                var tuple = Tuple.Create(1, "Joydip Kanjilal", new Tuple<string, string>("Hyderabad", "India"));
            }
    

    译文链接:https://www.infoworld.com/article/3095242/how-to-work-with-a-tuple-in-c.html

    展开全文
  • 在python中,有时会看到这样的函数定义: def p1(*arg1,**arg2): pass也有看到这样的函数调用: i=5 function(*i)这些都是什么意思呢?1.传入的参数生成 tuple 和 dict def p1(*a1,**a2): print a1,/n,a2 p
    在python中,有时会看到这样的函数定义:
        def   p1(*arg1,**arg2):
              pass
    也有看到这样的函数调用:
        i=5
        function(*i)
    这些都是什么意思呢?
    1.传入的参数生成 tuple 和 dict
          def    p1(*a1,**a2):
                 print a1,'/n',a2
           p1(1,2,3,4,arg5=5,arg6=6)
           结果为:
           (1,2,3,4)
           {'arg5':5,'arg6':6}
    2.传入的tuple 或 dict解析成参数序列
        def   q1(arg1,arg2,arg3,arg4):
              print arg1,arg2,arg3,arg4
        tu=(1,2,3,4)
        print 'extract from tuple /n'
        q1(*tu)

        di={'arg1':1,'arg2':2,'arg3':3,'arg4':4}
        print '/nextract from dict /n'
        q1(**di)
        结果为:
        extract from tuple
        1234
        extract from dict
        1234
    它们是互逆过程,在需要传递函数和函数参数的时候很有用
    如:
        def    worker1(arg1):
              print arg1
        def    worker2(arg1,arg2):
              print arg1,arg2
        def   calling(callable,arg):
              callable(*arg)
    if __name__="__main__":
        calling(worker1,(1,))
        calling(worker2,(1,2))
    展开全文
  • openCV定义点的最佳方法是在tuple 。 将numpy.array.tolist()转换为list,然后转换为tuple,然后再输入openCV函数。 转换矩阵cv2.warpAffine()的排列顺序为(X,Y)。 要缩小图像,通常使用cv2.INTER_AREA插值时...
  • Python中的(1,)

    2020-05-09 11:59:01
    在python中,经常会看到 (1,) 这样的元组,这个元组代表什么意思呢?正常的元组不应该(1, 2)这样的吗? 答: 要定义一个只有1个元素的tuple,如果我们这么定义: tu = (1) 定义的不是tuple1这个数!这因为...
  • python 中参数传递 * 和 ** 的问题,以 ... 在python中,有时会看到这样的函数定义: def p1(*arg1,**arg2): pass也有看到这样的函数调用: i=5 function(*i)这些都是什么意思呢?1.传入的参数生成 tuple 和 dict def ...
  • 在python语言中,迭代的意思就是通过for循环遍历一个有序/无序的集合。 迭代通过for x in 集合 来完成的。 前面有提到python中有哪些集合,现在我们来梳理一下: (1)有序集合:list ,tuple,str 和unicode。 ...
  • 在Python中,有一个语法你可能之前都没见过,或者见过但不知道什么意思,他就是...(省略号的三个点),在这里先给大家看几个例子: 下面代码中函数中的...代表什么意思? def hello(): ... 下面代码中...
  • 在Python中迭代都由for…in…来完成,也就是任何可迭代的对象都可以用for循环,包括我们自己定义的数据类型只要符合迭代的条件的都可以。 那么我们下面来看一下到底怎么样的数据类型符合迭代形式的呢 1、...
  • 在python中进行循环迭代取数据大多使用for语句,for语句可以迭代的类型有许多,但是与Iterator和Iterable有什么关系呢? 字面翻译:Iterator迭代器,而Iterable可迭代的意思。 像我们常用的list,tuple,dict...
  • [Python学习]Iterator 和 Generator的学习心得Iterator迭代器的意思,它的作用一次产生一个数据项,直到没有为止。这样 for 循环就可以对它进行循环处理了。那么它与一般的序列类型(list, tuple等)有什么...
  • (一)、这两个参数是什么意思:*args,**kwargs?我们为什么要使用它们?答:如果我们不确定往一个函数传入多少参数,或者我们希望以元组(tuple)或者列表(list)的形式传参数的时候,我们可以使用...
  • 这样 for 循环就可以对它进行循环处理了。那么它与一般的序列类型(list, tuple等)有什么区别呢?它一次只返回一个数据项,占用更少的内存。但它需要记住当前的状态,以便返回下一数据项。它一个有...
  • 说明:关于Python中迭代器的解释 Iterator迭代器的意思,它的作用一次产生一个数据项,直到没有为止。这样 for 循环中就可以对它进行循环处理了。那么它与一般的序列类型(list, tuple等)有什么区别呢?它一次...
  • python 迭代器和生成器

    2017-06-07 22:27:00
    这样 for 循环就可以对它进行循环处理了。那么它与一般的序列类型(list, tuple等)有什么区别呢?它一次只返回一个数据项,占用更少的内存。但它需要记住当前的状态,以便返回下一数据项。它一个有着next()方法...
  • 这样 for 循环就可以对它进行循环处理了。那么它与一般的序列类型(list, tuple等)有什么区别呢?它一次只返回一个数据项,占用更少的内存。但它需要记住当前的状态,以便返回下一数据项。它一个有
  • Numpyb=a.reshpe(-1)

    2018-01-26 17:56:00
    在Python中,-1可以表示最后一个元素,可是Numpy的reshape成-1的形状是什么意思?注意,这里 并不是取最后一个维度! 并不是取最后一个维度! 并不是取最后一个维度! 其实原因很简单,如果是最后一个维度,...
  • 这样 for 循环就可以对它进行循环处理了。那么它与一般的序列类型(list, tuple等)有什么区别呢?它一次只返回一个数据项,占用更少的内存。但它需要记住当前的状态,以便返回下一数据项。它一个有着next()方法...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

在python中tuple是什么意思

python 订阅