精华内容
下载资源
问答
  • 对象感必须是
    千次阅读
    2021-04-27 01:34:53

    python类对象和实例对象有什么区别吗

    发布时间:2020-07-20 14:10:37

    来源:亿速云

    阅读:119

    作者:清晨

    这篇文章主要介绍python类对象和实例对象有什么区别吗,文中介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们一定要看完!

    面向对象最重要的概念就是类(Class)和实例(Instance),必须牢记类是抽象的模板,比如Student类,而实例是根据类创建出来的一

    个个具体的“对象”,每个对象都拥有相同的方法,但各自的数据可能不同。

    推荐:Python教程

    仍以Student类为例,在Python中,定义类是通过class关键字:class Student(object):

    pass

    class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,继承的概念我

    们后面再讲,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类。

    定义好了Student类,就可以根据Student类创建出Student的实例,创建实例是通过类名+()实现的:>>> bart = Student()

    >>> bart

    >>> Student

    可以看到,变量bart指向的就是一个Student的实例,后面的0x10a67a590是内存地址,每个object的地址都不一样,而Student本身则

    是一个类。

    可以自由地给一个实例变量绑定属性,比如,给实例bart绑定一个name属性:>>> bart.name = 'Bart Simpson'

    >>> bart.name

    'Bart Simpson'

    由于类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法,在创建实例的时候,就把name,score等属性绑上去:class Student(object):

    def __init__(self, name, score):

    self.name = name

    self.score = score

    注意到__init__方法的第一个参数永远是self,表示创建的实例本身,因此,在__init__方法内部,就可以把各种属性绑定到self,因为self

    就指向创建的实例本身。

    有了__init__方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去:>>> bart = Student('Bart Simpson', 59)

    >>> bart.name

    'Bart Simpson'

    >>> bart.score

    59

    以上是python类对象和实例对象有什么区别吗的所有内容,感谢各位的阅读!希望分享的内容对大家有帮助,更多相关知识,欢迎关注亿速云行业资讯频道!

    更多相关内容
  • OpenCV 对象跟踪

    千次阅读 2022-02-07 22:23:09
    OpenCV 对象跟踪 这篇文章使用 OpenCV 中内置的八种不同的对象跟踪算法,实现对物体的跟踪。 首先,介绍一下8种跟踪算法。 然后,演示如何使用OpenCV实现这些...仅出于遗留原因和比较其他算法而兴趣。 (最低 OpenC

    OpenCV 对象跟踪

    这篇文章使用 OpenCV 中内置的八种不同的对象跟踪算法,实现对物体的跟踪。

    首先,介绍一下8种跟踪算法。

    然后,演示如何使用OpenCV实现这些跟踪算法。

    最后,对本文做总结。

    OpenCV 对象跟踪器

    OpenCV 八种对象跟踪器:

    • BOOSTING Tracker:基于用于驱动 Haar 级联 (AdaBoost) 背后的机器学习的相同算法,但与 Haar 级联一样,已有十多年的历史。这个跟踪器很慢,而且效果不太好。仅出于遗留原因和比较其他算法而感兴趣。 (最低 OpenCV 3.0.0)
    • MIL Tracker:比 BOOSTING 跟踪器更准确,但在报告失败方面做得很差。 (最低 OpenCV 3.0.0)
    • KCF 跟踪器:内核化相关过滤器。比 BOOSTING 和 MIL 更快。与 MIL 和 KCF 类似,不能很好地处理完全遮挡。 (最低 OpenCV 3.1.0)
    • CSRT Tracker:判别相关滤波器(具有通道和空间可靠性)。往往比 KCF 更准确,但速度稍慢。 (最低 OpenCV 3.4.2)
    • MedianFlow Tracker:很好地报告失败;但是,如果运动中的跳跃太大,例如快速移动的物体,或者外观快速变化的物体,模型就会失败。 (最低 OpenCV 3.0.0)
    • TLD 跟踪器:我不确定 TLD 跟踪器的 OpenCV 实现或实际算法本身是否存在问题,但 TLD 跟踪器极易出现误报。我不推荐使用这个 OpenCV 对象跟踪器。 (最低 OpenCV 3.0.0)
    • MOSSE Tracker:非常非常快。不如 CSRT 或 KCF 准确,但如果您需要纯粹的速度,这是一个不错的选择。 (最低 OpenCV 3.4.1)
    • GOTURN Tracker:OpenCV 中唯一基于深度学习的目标检测器。它需要额外的模型文件才能运行(本文不会涉及)。我最初的实验表明,尽管据说它可以很好地处理查看变化,但使用起来还是有点痛苦(尽管我最初的实验并没有证实这一点)。我将尝试在以后的帖子中介绍它,但与此同时,请看一下 Satya 的文章。 (最低 OpenCV 3.2.0)

    个人建议:

    • 当需要更高的对象跟踪精度并且可以容忍较慢的 FPS 吞吐量时,请使用 CSRT
    • 当需要更快的 FPS 吞吐量但可以处理稍低的对象跟踪精度时使用 KCF
    • 当需要纯粹的速度时使用 MOSSE

    物体跟踪

    在开始算法之前,先写辅助方法和类。

    fps类:

    import datetime
    
    class FPS:
    	def __init__(self):
    		# 定义开始时间、结束时间和总帧数
    		self._start = None
    		self._end = None
    		self._numFrames = 0
    
    	def start(self):
    		# 开始计时
    		self._start = datetime.datetime.now()
    		return self
    
    	def stop(self):
    		# 停止计时
    		self._end = datetime.datetime.now()
    
    	def update(self):
    		# 增加在开始和结束间隔期间检查的总帧数
    		self._numFrames += 1
    
    	def elapsed(self):
    		# 返回开始和结束间隔之间的总秒数
    		return (self._end - self._start).total_seconds()
    
    	def fps(self):
    		# 计算每秒帧数
    		return self._numFrames / self.elapsed()
    

    请打开一个新文件,将其命名为 object_tracker.py ,定义resize方法,等比例缩放图片。

    import cv2
    from fps import FPS
    def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
        # 初始化要调整大小的图像的尺寸并抓取图像大小
        dim = None
        (h, w) = image.shape[:2]
        # 如果宽高都为None,则返回原图
        if width is None and height is None:
            return image
        # 检查宽度是否为None
        if width is None:
            # 计算高度的比例并构造尺寸
            r = height / float(h)
            dim = (int(w * r), height)
        # 否则,高度为 None
        else:
    		# 计算宽度的比例并构造尺寸
            r = width / float(w)
            dim = (width, int(h * r))
        resized = cv2.resize(image, dim, interpolation=inter)
        return resized
    

    定义全局变量:

    videos = 0
    tracker_type = 'kcf'
    

    我们的命令行参数包括:

    videos:输入视频文件或者摄像头的ID。

    tracker_type:跟踪器的类型,接下来的代码定义了跟踪器列表。

    接下来定义不同类型的跟踪器:

    # 提取 OpenCV 版本信息
    (major, minor) = cv2.__version__.split(".")[:2]
    # 如果我们使用 OpenCV 3.2 或之前版本,我们可以使用特殊的工厂函数来创建我们的对象跟踪器
    if int(major) == 3 and int(minor) < 3:
        tracker = cv2.Tracker_create(tracker_type)
    # 否则,对于 OpenCV 3.3 或更新版本,我们需要显式调用对应的对象跟踪器构造函数:
    else:
        # 初始化一个字典,将字符串映射到其对应的 OpenCV 对象跟踪器实现
        OPENCV_OBJECT_TRACKERS = {
            "csrt": cv2.TrackerCSRT_create,
            "kcf": cv2.TrackerKCF_create,
            "boosting": cv2.legacy.TrackerBoosting_create,
            "mil": cv2.TrackerMIL_create,
            "tld": cv2.legacy.TrackerTLD_create,
            "medianflow": cv2.legacy.TrackerMedianFlow_create,
            "mosse": cv2.legacy.TrackerMOSSE_create
        }
        # 使用我们的 OpenCV 对象跟踪器对象字典获取适当的对象跟踪器
        tracker = OPENCV_OBJECT_TRACKERS[tracker_type]()
    

    在OpenCV 3.3之前,必须使用cv2.Tracker_create创建跟踪器对象,并传递跟踪器名称的大写字符串。

    对于OpenCV 3.3+,可以使用各自的函数调用创建每个跟踪器,例如cv2.TrackerCSRT_create。字典OPENCV_OBJECT_TRACKERS包含8个内置OpenCV对象跟踪器中的七个。它将对象跟踪器命令行参数字符串(键)与实际的OpenCV对象跟踪器函数(值)进行映射。

    # 初始化我们要追踪的物体的边界框坐标
    initBB = None
    vs = cv2.VideoCapture(videos)
    fps = None
    

    initBB初始化为None,此变量将保存我们使用鼠标选择的对象的边界框坐标。

    接下来,初始化VideoCapture对象和FPS计数器。

    让我们开始循环来自视频流的帧:

    # 循环播放视频流中的帧
    while True:
        # 抓取当前帧。
        (grabbed, frame) = vs.read()
        if not grabbed:
            break
        # 调整框架大小并获取框架尺寸。
        frame = resize(frame, width=500)
        (H, W) = frame.shape[:2]
    
        # 检查是否正在跟踪一个对象
        if initBB is not None:
            # 抓取物体的新边界框坐标
            (success, box) = tracker.update(frame)
            # 检查跟踪是否成功
            if success:
                (x, y, w, h) = [int(v) for v in box]
                cv2.rectangle(frame, (x, y), (x + w, y + h),
                              (0, 255, 0), 2)
            # 更新 FPS 计数器
            fps.update()
            fps.stop()
            # 初始化在框架上显示的信息集
            info = [
                ("Tracker", tracker_type),
                ("Success", "Yes" if success else "No"),
                ("FPS", "{:.2f}".format(fps.fps())),
            ]
            # 遍历信息元组并将它们绘制在框架上
            for (i, (k, v)) in enumerate(info):
                text = "{}: {}".format(k, v)
                cv2.putText(frame, text, (10, H - ((i * 20) + 20)),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
    
        # 显示输出帧
        cv2.imshow("Frame", frame)
        key = cv2.waitKey(1) & 0xFF
    

    抓住一个帧,如果获取不到帧,则退出。

    为了使对象跟踪算法能够更快地处理帧,我们将输入帧的大小调整为500像素。

    然后输出框架的高和宽。

    如果已选择对象,则需要更新对象的位置。 update方法将定位对象的新位置并返回成功布尔值和对象的边界框。

    如果成功,我们在框架上绘制新的,更新的边界框位置。

    更新FPS。

    初始化显示的文本信息列表。随后,绘制到frame上。

    显示输出帧。

       # 使用's'键选择一个边界框来跟踪
        if key == ord("s"):
            # 选择跟踪的对象的边界框(选择 ROI 后按 ENTER 或 SPACE)
            initBB = cv2.selectROI("Frame", frame, fromCenter=False,
                                   showCrosshair=True)
            # 使用提供的边界框坐标启动 OpenCV 对象跟踪器,然后也启动 FPS 吞吐量估计器
            tracker.init(frame, initBB)
            fps = FPS().start()
        # 如果 `q` 键被按下,则退出循环
        elif key == ord("q"):
            break
    vs.release()
    cv2.destroyAllWindows()
    
    

    按下“s”键时,使用cv2.selectROI“选择”对象ROI。此时,视频帧冻结,用鼠标绘制跟踪对象的边界框。

    绘制完边界框,然后按“ENTER”或“SPACE”确认选择。如果需要重新选择区域,只需按“ESCAPE”即可。

    然后,启动OpenCV 对象跟踪器,再启动 FPS 吞吐量估计器。

    最后一个段代码只是处理我们已经脱离循环的情况。释放所有指针并关闭窗口。

    总结

    在今天的博客文章中,您学习了如何利用OpenCV进行对象跟踪。具体来说,我们回顾了OpenCV库中包含的8个对象跟踪算法(从OpenCV 3.4开始):

    CSRT、KCF、Boosting、MIL、TLD、MedianFlow、MOSSE、GOTURN。

    建议对大多数对象跟踪应用程序使用CSRT,KCF或MOSSE:

    当需要更高的对象跟踪精度并且可以容忍更慢的FPS吞吐量时,请使用CSRT

    当需要更快的FPS吞吐量时使用KCF,但可以处理稍低的对象跟踪精度

    当需要纯粹的速度时使用MOSSE

    完整代码:

    https://download.csdn.net/download/hhhhhhhhhhwwwwwwwwww/79602278

    展开全文
  • 在java中new一个对象的流程是怎样的

    千次阅读 多人点赞 2021-04-19 19:46:58
    对象怎么创建,这个太熟悉了,new一下(其实还有很多途径,比如反射、反序列化、clone等,这里拿最简单的new来讲): Dog dog = new Dog(); 我们总是习惯于固定语句的执行,却对于背后的实现过程缺乏认知,而理解这个...

    对象怎么创建,这个太熟悉了,new一下(其实还有很多途径,比如反射、反序列化、clone等,这里拿最简单的new来讲):

    Dog dog = new Dog();
    

    我们总是习惯于固定语句的执行,却对于背后的实现过程缺乏认知,而理解这个过程对后面晦涩难懂的反射和代理其实会有很大帮助,所以请务必学好这块内容。

    在看这篇文章之前,啰嗦一句:如果你死记硬背下面所说的流程等于白看,就算现在记住了,一个礼拜后呢,一个月后你又能记得多少,因为对象创建过程这个知识点平常的工作中基本不会涉及到,太底层了,背熟的知识点不经常加以运用容易遗忘,所以我的建议是什么呢,流程做到心里大概有个数,其中涉及到关键的知识点记牢就可以了。

    JVM内存

    先简单说下java虚拟机内存模型和存放内容的区别,两部分:

    • 栈内存 存放基本类型数据和对象的引用变量,数据可以直接拿来访问,速度比堆快
    • 堆内存 存放创建的对象和数组,会由java虚拟机的自动垃圾回收来管理(GC),创建一个对象放入堆内的同时也会在栈中创建一个指向该对象堆内存中的地址引用变量,下面说的对象就是存在该内存中

    下面我们就按照对象生成的过程来一一讲解参与其中过程的各个概念

    首先有这么一个类,后面的初始化基于这个讲解:

    /**
     * @author 炜哥
     * @since 2021-04-18 11:01:41
     *
     * 执行顺序:(优先级从高到低。)静态代码块>构造代码块>构造方法>普通方法。
     * 其中静态代码块只执行一次。构造代码块在每次创建对象是都会执行。
     */
    public class Dog {
    
        //默认狗狗的最大年龄是16岁
        private static int dog_max_age = 16;
    
        //狗狗的名字
        private String dog_name;
        
        {
            System.out.println("狗狗的构造代码块");
        }
    
        static {
            System.out.println("狗狗的静态代码块");
        }
    
        //无参构造器故意没设
        //有参构造器
        public Dog(String dog_name) {
            this.dog_name = dog_name;
        }
    
        public void getDogInfo(){
            System.out.println("名字是:"+dog_name + "  年龄:" + dog_max_age);
        }
    
        //狗叫
        public static void barking(){
            System.out.println("汪汪汪~~~");
        }
    }
    

    JVM生成.class文件

    一个java文件会在编译期间被初始化生成.class字节码文件,字节码文件是专门给JVM阅读的,我们平时吭哧吭哧写的一行行代码最终都会被编译成机器能看懂的语句,这个文件后面会被类加载器加载到内存。
    image.png

    类加载器加载.class文件

    《深入理解Java的虚拟机》中大概有这么一句话:在虚拟机遇到一条new的指令时,会去检查一遍在静态常量池中能否定位到一个类的符号引用 (就这个类的路径+名字),并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果不是第一次使用,那必须先执行相应的类加载过程,这个过程由类加载器来完成
    类加载字面意思就可以理解成加载class文件,更准确点的说法就是会把class文件变成一个二进制流加载到内存中,即把类的描述信息加载到Metaspace,至于类加载器如何找到并把一个class文件转成IO流加载到内存中,我后面会专门写一篇关于类加载器的文章,这里就只要理解创建对象中有这么一步就行了。不过这里面有很重要的概念不得不讲:Class对象

    知识扩展:Class对象

    划重点,这是个非常重要的概念,理解它对于理解后面的反射和代理会有很大的帮助
    类加载器 ClassLoader 加载class文件时,会把类里的一些数值常量、方法、类信息等加载到内存中,称之为类的元数据,最终目的是为了生成一个Class对象用来描述类,这个对象会被保存在.class文件里,可能有新手看到这里会比较懵逼,class也有对象?当然了,Class是个实实在在的类(用来描述类的类,比较拗口),有构造方法( private ,意味着可以生成对象,但不能手动生成,由JVM自动创建Class对象),类加载器会给每个java文件都创建一个Class对象,用来描述类,我画个图:
    image.png

    //以下操作只能由jvm完成,我们手动做不了
    Class cls1 = new Class(Dog.class.getClassLoader());
    Class cls2 = new Class(Cat.class.getClassLoader());
    Class cls3 = new Class(People.class.getClassLoader());
    

    image.png
    这个Class对象除了描述对应的类之外还有什么作用呢?也可以生成对象,就是java的反射概念(通过Class实例获取类信息)
    上面说了,Class类是用来描述像People.Class类的类,那么它里面肯定包含了所有能够描述该class的所有属性,比如类名、方法、接口等,我们先到Class类源码中瞄一眼:
    image.png
    这里面有个方法 newInstance(),即创建对象, 我把源代码贴出来并简单解析下:

    @CallerSensitive
    public T newInstance()
        throws InstantiationException, IllegalAccessException
        {
        	
            if (System.getSecurityManager() != null) {
                checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
            }
            
            if (cachedConstructor == null) {
                if (this == Class.class) {
                    throw new IllegalAccessException(
                        "Can not call newInstance() on the Class for java.lang.Class"
                    );
                }
                try {
                    Class<?>[] empty = {};
                    //声明无参构造对象
                    final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
                    // Disable accessibility checks on the constructor
                    // since we have to do the security check here anyway
                    // (the stack depth is wrong for the Constructor's
                    // security check to work)
                    java.security.AccessController.doPrivileged(
                        new java.security.PrivilegedAction<Void>() {
                            public Void run() {
                                    c.setAccessible(true);
                                    return null;
                                }
                            });
                    cachedConstructor = c;
                } catch (NoSuchMethodException e) {
                	//如果class中没有无参构造方法,那么抛InstantiationException错误
                    throw (InstantiationException)
                        new InstantiationException(getName()).initCause(e);
                }
            }
            Constructor<T> tmpConstructor = cachedConstructor;
            // Security check (same as in java.lang.reflect.Constructor)
            int modifiers = tmpConstructor.getModifiers();
            if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                if (newInstanceCallerCache != caller) {
                    Reflection.ensureMemberAccess(caller, this, null, modifiers);
                    newInstanceCallerCache = caller;
                }
            }
            // Run constructor
            try {
            	//最终还是调用了无参构造器对象的newInstance方法
                return tmpConstructor.newInstance((Object[])null);
            } catch (InvocationTargetException e) {
                Unsafe.getUnsafe().throwException(e.getTargetException());
                // Not reached
                return null;
            }
        }
    

    首先搞清楚 newInstance 两种方法区别:

    • Class.newInstance() 只能够调用无参的构造函数,即默认的构造函数,我们在Class源码里也看到了其实最终还是调用了无参构造器对象 ConstructornewInstance 方法,举个栗子:Dog.class 中是没有无参构造方法,那么会直接抛出 InstantiationException 异常:
    //Dog类中只有一个dog_name的有参构造方法
    Class c = Class.forName("com.service.ClassAnalysis.Dog");
    Dog dog = (Dog) c.newInstance();//直接抛InstantiationException异常
    

    image.png

    • Constructor.newInstance() 可以根据传入的参数,调用任意构造构造函数,也可以反射私有构造器(了解就行)
    //Dog类中只有一个dog_name的有参构造方法
    Constructor cs = Dog.class.getConstructor(String.class);
    Dog dog = (Dog) cs.newInstance("小黑");//执行没有问题
    

    但是这里面的 newInstance跟我们这次要说的 new 方法存在区别,两者创建对象的方式不同,创建条件也不同:

    • 使用 newInstance 时必须要保证这类已经加载并且已经建立连接,就是已经被类记载器加载完毕,而 new 不需要
    • class对象的 newInstance 方法只能用无参构造,上面已经提到了,而 new 不需要
    • 前者使用的是类加载机制,是一种方法,后者是创建一个新类,一种关键字

    这个不能说newInstance 不方便,相反它在反射、工厂设计模式、代理中发挥了重要作用,后续我也会写下代理和反射,因为理解起来确实有点绕。还有一点需要注意,不管以哪种方式创建对象,对应的Class对象都是同一个

    Dog dog1 = new Dog("旺财");
    Dog dog2 = new Dog("小黑");
    Class c = Class.forName("com.service.classload.Dog");//为了测试,加了无参构造
    Dog dog3 = (Dog) c.newInstance();
    System.out.println(dog1.getClass() == dog2.getClass());
    System.out.println(dog1.getClass() == dog3.getClass());
    

    image.png

    连接和初始化

    在此阶段首先为静态static变量内存中分配存储空间,设立初始值(还未被初始化)比如:

    public static int i = 666;//被类加载器加载到内存时会执行,赋予一个初始值
    public static Integer ii = new Integer(666);//也被赋值一个初始值
    

    但请注意,实际上i 的初始值是0,不是666,其他基本数据类型比如boolean的初始值就是false,以此类推。如果是引用类型的成员变量 ii 那么初始值就是null。(对基本数据类型引用类型不熟悉的可以看我的另外一篇文章《 java的数据类型&自动装箱/拆箱浅谈》,这里就不多说了)

    Dog dog = new Dog("旺财");//在这里打个断点
    

    执行,首先会执行静态成员变量初始化,默认值是0:
    image.png
    但有例外,如果加上了 final 修饰词那么初始值就是设定的值。
    image.png
    接着对已经分配存储空间的静态变量真正赋值,比如为上面的dog_max_age 赋值16,还有执行静态代码块,也就是类似下面的代码:

    static {
        System.out.println("狗狗的静态代码块");
    }
    

    到这为止,类的加载过程才算完成。

    创建实例

    在加载类完毕后,对象的所需大小根据类信息就可以确认了,具体创建的步骤如下:

    1. 先给对象分配内存(包括本类和父类的所有实例变量,不包括上面的静态变量),并设置默认值,如果有引用对象那么会在栈内存中申请一个空间用来指向的实际对象。
    2. 执行初始化代码实例化,先初始化父类再初始化子类,赋予给定值(尊重长辈是java的传统美德)
    3. 对象实例化完毕后如果存在引用对象的话还需要**把第一步的栈对象指向到堆内存中的实际对象,**这样一个真正可用的对象才被创建出来。

    **说了这么多估计很多人都没概念,懵逼状态中,其实很简单,我们只要记住new的创建对象就两步:初始化和实例化,再给你们搞一张图:可以简单理解②③④为初始化⑤实例化(可恶,我这该死的责任感!

    在这里插入图片描述

    本文不指望你能使劲弄懂java虚拟机底层加载创建对象的过程(其实有些步骤我都懒得讲了,因为说出来也都非常理论化,没多大意思),是想让你知道对象的诞生过程有哪几个重要概念参与了,弄懂这些概念比起单单知道对象创建的过程有意义的多:

    1. 类加载器,可以找找网上的资料,蛮多的,这块内容做个了解就行
    2. Class类和Class对象的概念,请重点掌握,不然理解反射和动态代理很费劲,spring的源码也会难以理解
    3. 栈内存和堆内存以及对应的基本类型和引用类型,也很重要,争取能基本理解

    OVER

    展开全文
  • python可迭代对象概念讲解

    千次阅读 2020-12-05 14:14:15
    python可迭代对象怎么理解什么是可迭代对象?简单的理解是可以用for循环的对象,就是可迭代对象。比如:list,字符串,dict,元组,生成器等。具有可迭代的特征。(推荐学习:Python视频教程)自定义可迭代对象(本质)...

    python可迭代对象怎么理解

    什么是可迭代对象?

    简单的理解是可以用for循环的对象,就是可迭代对象。比如:list,字符串,dict,元组,生成器等。

    具有可迭代的特征。(推荐学习:Python视频教程)

    自定义可迭代对象(本质)

    语法层面,如果一个对象实现了__iter__方法,那么这个对象就是可迭代对象

    判断是否是可迭代对象(Iterable)

    通过调用Python内置的isinstance来判断是否是Iterable的实例

    In [9]: isinstance([],Iterable)

    Out[9]: True

    In [10]: isinstance('',Iterable)

    Out[10]: True

    In [11]: isinstance({},Iterable)

    Out[11]: True

    In [12]: class MyList(object):

    ....: def __init__(self):

    ....: self.list = []

    ....: def add(self,item):

    ....: self.list.append(item)

    ....:

    In [13]: mylist = MyList()

    In [14]: isinstance(mylist,Iterable)

    Out[14]: False

    通过上面例子可以看出,Python中的内置类型dict,list,str的对象都是可迭代的,我们自定义了一个类MyList,由于这个类没有实现iter方法,所以这个类的实例不是可迭代对象。

    更多Python相关技术文章,请访问Python教程栏目进行学习!

    展开全文
  • 要看的懂对象的创建过程,首先你得有对Java虚拟机和Java基础以及JUC很是熟悉,比如类的加载过程,CAS、多线程、JVM的GC等等 首先好看一个图,我大概会根据图中的内容来分享这六个步骤(其实几个步骤不重要,只要包括...
  • 【实战】到底什么是C语言对象编程?

    万次阅读 2020-09-01 20:36:40
    ID:技术让梦想更伟大作者:ZhengNL整理:李肖遥前言在之前肖遥分享写过一篇关于面都对象的文章,真的可以,用C语言实现面向对象编程OOP , 本篇肖遥给大家整理了ZhengNL三合一...
  • 如果大家兴趣,我后面专门出一篇文章,全面介绍下逃逸分析。 在Java代码运行时,通过JVM参数可指定是否开启逃逸分析,   -XX:+DoEscapeAnalysis  : 表示开启逃逸分析   -XX:-DoEscapeAnalysis  : ...
  • ES6对象操作实例详解

    千次阅读 2021-01-13 18:57:49
    本文实例讲述了ES6对象操作。分享给大家供大家参考,具体如下:1.对象赋值es5中的对象赋值方式如下:let name="小明";let skill= 'es6开发';var obj= {name:name,skill:skill};console.log(obj);结果为:ES6允许把...
  • COS对象存储

    千次阅读 2020-12-31 18:51:20
    最近公司有用到COS对象存储,接下来和大家一起聊聊对象存储,实际上存储这一块在我之前的博客中有提到,博客中讲述了分布式文件系统存储、块存储和对象存储的相关工作原理及三者之间的区别,大家兴趣的话可以去看...
  • 对象头的内部结构一张图了解所有细节 1、创建了Customer()实例 和 Account()实例 2、对象头里包括:运行时元数据、类型指针、实例数据、对齐填充 ① 运行时元数据里又包括:哈希值(HashCode)、GC分代年龄、锁状态...
  • 我呢也是我比较兴趣的部分,复述一遍,当然会有错误。特别感谢纠正。 文章目录前言 前言 其实整个JVM参数的调优,大体上就是围绕着如何去减少垃圾回收的次数。尽可能地不要让full GC发生。因为不管是哪一种垃圾...
  • 对他提出的这个问题很兴趣,深入研究了一下,便有了这篇文章。 更新引用是JVM的职责 任何一款JVM的设计,采用任何一种GC算法进行对象的移动操作时,如何更新对象引用都是JVM的基本职责。也就是说,当移动对象时,...
  • 获取图像的兴趣区域

    热门讨论 2012-12-17 13:26:28
    MFC基于对话框程序,实现显示源图像和通过自定义选择兴趣区域,并显示截取后的兴趣图像
  • 工厂模式创建对象

    千次阅读 2022-03-27 19:10:10
    开发工具与关键技术:工厂模式创建对象 Object 作者:魏钦 撰写时间:2022/3/27 首先打开我们的VS软件,CTRL+ N新建一个HTML文档,在body标签里放一个script标签,作为写JS的区域。 然后给个初始值var 空格num...
  • JAVA如何实现返回不同类型的对象

    千次阅读 2021-03-15 02:27:26
    JAVA如何实现返回不同类型的对象发布时间:2020-11-10 16:11:51来源:亿速云阅读:96作者:Leah这篇文章运用简单易懂的例子给大家介绍JAVA如何实现返回不同类型的对象,内容非常详细,兴趣的小伙伴们可以参考借鉴...
  • C++类和对象详解

    千次阅读 多人点赞 2020-05-08 00:43:54
    另外一种是在堆上使用 new 关键字创建,必须要用一个指针指向它,读者要记得 delete 掉不再使用的对象。 通过对象名字访问成员使用点号.,通过对象指针访问成员使用箭头->,这和结构体非常类似。 成员变量和函数...
  • 第一章 对象的概念

    千次阅读 2020-04-02 23:05:47
    第一章 对象的概念 “我们没有意识到惯用语言的结构有多大的力量。可以毫不夸张地说,它通过语义反应机制奴役我们。语言表现出来并在无意识中给我们留下深刻印象的结构会自动投射到我们周围的世界。” -- Alfred ...
  • 文章目录C++类的对象和类的指针的区别指向地址的指针指针本身的大小指向数组的指针指针数组指向指针数组的指针多维指针数组函数参数中使用指针数组指针传址实现数组求和函数指针模仿C++ 类别函数指针数组对象指针...
  • 在这篇文章中我实现了目标检测和语义分割这一块,之前有说我们得到这个图像之后,可以方便我们去做很多事情,在这里我们就提出了,当我们要对某一个目标进行操作时,那怎么去提取出我们兴趣的目标对象呢?...
  • 哈希值:它是一个地址,用于栈对堆空间中对象的引用指向,不然栈是无法找到堆中对象的 GC分代年龄:记录幸存者区对象被GC之后的年龄age,,一般age为15之后下一次GC就会直接进入老年代 锁状态标志:记录一些加锁的...
  • 你好呀,我是沉默王二,是《Web 全栈开发进阶之路》的作者,...本篇来谈一谈“面向对象编程”中的所有概念。 因为是第一次做付费专栏,所以有一定的压力,虽然只需要 9.9 元,但我对自己的要求是至少要达到 199 元...
  • MyBatis4大核心对象前言MyBatis四大核心对象SqlSessionFactoryBuiler(2+1)方法分析InputStream和ReaderSqlSessionFactoryDefaultSqlSessionFactoryExecutorSqlSessionManagerSqlSessionMapper四大对象生命周期总结 ...
  • 什么是IDOR(不安全的直接对象引用)

    千次阅读 2019-08-29 15:37:16
    自从2010年开始,不安全的直接对象引用(IDOR)就已经成为了OWASP Top 10 Web应用安全风险中影响程度排名第四的安全漏洞了。 IDOR将允许一名授权用户获取其他用户的信息,意指一个已经授权的用户通过更改访问时的一...
  • 在科学技术水平不断进步的今天,每一个人都在努力地迎合时代的发展,以获得更好的回报。...首先说一下如何删除对象中的某一属性,代码展示如下:varobj={name:'zhagnsan',age:19}deleteobj.name//truetypeo...
  • Java对象与Java类

    千次阅读 多人点赞 2021-07-28 22:23:35
    面向对象是什么?2.Java类1.什么是类2.Java类类的结构Java类的格式3.java对象4.类和对象5.类中的变量,方法1.变量分类2.方法分类6.方法重载7.对象与引用基本类型和引用类型的区别:值传递与引用传递8.static关键字概念...
  • java中的知识点繁多又庞大,今天就来为大家介绍在java中怎么给对象添加属性和方法并用实例分享,一起来看看吧。一、首先说一下,在定义对象时,直接添加属性和方法,代码展示如下:functionPerson(name,age){this....
  • 在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。 具体如下图 java 普通对象结构 java 数组对象结构 对象结构组成 对象头 ...
  • 本文实例讲述了python对象转字典的两种实现方式。分享给大家供大家参考,具体如下:一. 方便但不完美的__dict__对象转字典用到的方法为__dict__. 比如对象对象a的属性a.name='wk', a.age=18, 那么如果直接将使用a.__...
  • kotlin 定义对象数组 我最初打算写这篇文章是因为我在玩一些反射代码,并认为自己发现了一些有趣的东西。 las,绝对不是这样。 相反,它只是Kotlin的基本功能,我不需要使用或关注。 尽管这篇文章并没有表明我希望...
  • js中数组删除对象的几种方式总结

    万次阅读 2021-12-16 19:54:59
    站长不易,兴趣的大家可以点击查看原文支持支持。 数组中元素的删除通过删除的方法的不同可以分为: 关键字删除 splice删除 特殊位置删除 关键字删除 关键字删除是通过js提供的关键字 delete手动删除数组的某...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 386,995
精华内容 154,798
热门标签
关键字:

对象感必须是