精华内容
下载资源
问答
  • 大数据的三个特征(重要挑战)
    千次阅读
    2018-06-07 10:44:00

    3V
    Volumn 数据量巨大
    Variety 数据种类繁多
    Velocity 数据产生、更新速度快

    转载于:https://www.cnblogs.com/ShaneSun/p/9149428.html

    更多相关内容
  • 如果这原始数据集足够大且足够通用,那么预训练网络学到的特征的空间层次结构可以有效地作为视觉世界的通用模型,因此这些特征可用于各种不同的计算机视觉问题,即使这些新问题涉及的类别和原始任务完全不同。举...

    想要将深度学习应用于小型图像数据集,一种常用且非常高效的方法是使用预训练网络。预训练网络(pretrained network)是一个保存好的网络,之前已在大型数据集(通常是大规模图像分类任务)上训练好。如果这个原始数据集足够大且足够通用,那么预训练网络学到的特征的空间层次结构可以有效地作为视觉世界的通用模型,因此这些特征可用于各种不同的计算机视觉问题,即使这些新问题涉及的类别和原始任务完全不同。举个例子,你在 ImageNet 上训练了一个网络(其类别主要是动物和日常用品),然后将这个训练好的网络应用于某个不相干的任务,比如在图像中识别家具。这种学到的特征在不同问题之间的可移植性,是深度学习与许多早期浅层学习方法相比的重要优势,它使得深度学习对小数据问题非常有效。
    本例中,假设有一个在 ImageNet 数据集(140 万张标记图像,1000 个不同的类别)上训练好的大型卷积神经网络。ImageNet 中包含许多动物类别,其中包括不同种类的猫和狗,因此可以认为它在猫狗分类问题上也能有良好的表现。
    使用预训练网络有两种方法:特征提取(feature extraction)和微调模型(fine-tuning)。两种方法我们都会介绍。首先来看特征提取。
    特征提取是使用之前网络学到的表示来从新样本中提取出有趣的特征。然后将这些特征输入一个新的分类器,从头开始训练。
    如前所述,用于图像分类的卷积神经网络包含两部分:首先是一系列池化层和卷积层,最后是一个密集连接分类器。第一部分叫作模型的卷积基(convolutional base)。对于卷积神经网络而言,特征提取就是取出之前训练好的网络的卷积基,在上面运行新数据,然后在输出上面训练一个新的分类器。
     保持卷积基不变,改变分类器
    上图表示的为保持卷积基不变,改变分类器。
    为什么仅重复使用卷积基?我们能否也重复使用密集连接分类器?一般来说,应该避免这么做。原因在于卷积基学到的表示可能更加通用,因此更适合重复使用。卷积神经网络的特征图表示通用概念在图像中是否存在,无论面对什么样的计算机视觉问题,这种特征图都可能很有用。但是,分类器学到的表示必然是针对于模型训练的类别,其中仅包含某个类别出现在整张图像中的概率信息。此外,密集连接层的表示不再包含物体在输入图像中的位置信息。密集连接层舍弃了空间的概念,而物体位置信息仍然由卷积特征图所描述。如果物体位置对于问题很重要,那么密集连接层的特征在很大程度上是无用的。
    注意,某个卷积层提取的表示的通用性(以及可复用性)取决于该层在模型中的深度。模型中更靠近底部的层提取的是局部的、高度通用的特征图(比如视觉边缘、颜色和纹理),而更靠近顶部的层提取的是更加抽象的概念(比如“猫耳朵”或“狗眼睛”)。因此,如果你的新数据集与原始模型训练的数据集有很大差异,那么最好只使用模型的前几层来做特征提取,而不是使用整个卷积基。
    本文中使用的卷积基为vgg16,我们来打印下vgg16的网络结构:

    from tensorflow.keras.applications import VGG16
    
    '''
    weights 指定模型初始化的权重检查点。
    
    include_top 指定模型最后是否包含密集连接分类器。默认情况下,这个密集连接分
    类器对应于 ImageNet 的 1000 个类别。因为我们打算使用自己的密集连接分类器(只有
    两个类别:cat 和 dog),所以不需要包含它。
    
    input_shape 是输入到网络中的图像张量的形状。这个参数完全是可选的,如果不传
    入这个参数,那么网络能够处理任意形状的输入。
    '''
    conv_base=VGG16(weights='imagenet',
                    include_top=False,
                    input_shape=(150,150,3))
    
    conv_base.summary()
    

    网络结构为:

    _________________________________________________________________
    Layer (type)                 Output Shape              Param #
    =================================================================
    input_1 (InputLayer)         [(None, 150, 150, 3)]     0
    _________________________________________________________________
    block1_conv1 (Conv2D)        (None, 150, 150, 64)      1792
    _________________________________________________________________
    block1_conv2 (Conv2D)        (None, 150, 150, 64)      36928
    _________________________________________________________________
    block1_pool (MaxPooling2D)   (None, 75, 75, 64)        0
    _________________________________________________________________
    block2_conv1 (Conv2D)        (None, 75, 75, 128)       73856
    _________________________________________________________________
    block2_conv2 (Conv2D)        (None, 75, 75, 128)       147584
    _________________________________________________________________
    block2_pool (MaxPooling2D)   (None, 37, 37, 128)       0
    _________________________________________________________________
    block3_conv1 (Conv2D)        (None, 37, 37, 256)       295168
    _________________________________________________________________
    block3_conv2 (Conv2D)        (None, 37, 37, 256)       590080
    _________________________________________________________________
    block3_conv3 (Conv2D)        (None, 37, 37, 256)       590080
    _________________________________________________________________
    block3_pool (MaxPooling2D)   (None, 18, 18, 256)       0
    _________________________________________________________________
    block4_conv1 (Conv2D)        (None, 18, 18, 512)       1180160
    _________________________________________________________________
    block4_conv2 (Conv2D)        (None, 18, 18, 512)       2359808
    _________________________________________________________________
    block4_conv3 (Conv2D)        (None, 18, 18, 512)       2359808
    _________________________________________________________________
    block4_pool (MaxPooling2D)   (None, 9, 9, 512)         0
    _________________________________________________________________
    block5_conv1 (Conv2D)        (None, 9, 9, 512)         2359808
    _________________________________________________________________
    block5_conv2 (Conv2D)        (None, 9, 9, 512)         2359808
    _________________________________________________________________
    block5_conv3 (Conv2D)        (None, 9, 9, 512)         2359808
    _________________________________________________________________
    block5_pool (MaxPooling2D)   (None, 4, 4, 512)         0
    =================================================================
    Total params: 14,714,688
    Trainable params: 14,714,688
    Non-trainable params: 0
    

    最后的特征图形状为 (4, 4, 512)。我们将在这个特征上添加一个密集连接分类器。
    接下来,下一步有两种方法可供选择。
    1、在你的数据集上运行卷积基,将输出保存成硬盘中的 Numpy 数组,然后用这个数据作为输入,输入到独立的密集连接分类器中(与本书第一部分介绍的分类器类似)。这种方法速度快,计算代价低,因为对于每个输入图像只需运行一次卷积基,而卷积基是目前流程中计算代价最高的。但出于同样的原因,这种方法不允许你使用数据增强。
    2、在顶部添加 Dense 层来扩展已有模型(即 conv_base),并在输入数据上端到端地运行整个模型。这样你可以使用数据增强,因为每个输入图像进入模型时都会经过卷积基。但出于同样的原因,这种方法的计算代价比第一种要高很多。

    1 不使用数据增强的快速特征提取

    训练代码如下:

    from cProfile import label
    from statistics import mode
    from tensorflow.keras.preprocessing.image import ImageDataGenerator
    from PIL import Image
    from tensorflow.keras import layers
    from tensorflow.keras import models
    from tensorflow.keras import optimizers
    import matplotlib.pyplot as plt
    from tensorflow.keras.preprocessing import image as kimage
    from tensorflow.keras.applications import VGG16
    import numpy as np
    
    
    conv_base=VGG16(weights='imagenet',
                    include_top=False,
                    input_shape=(150,150,3))
    
    #训练样本的目录
    train_dir='./dataset/training_set/'
    #验证样本的目录
    validation_dir='./dataset/validation_set/'
    #测试样本目录
    test_dir='./dataset/test_set/'
    
    datagen=ImageDataGenerator(rescale=1./255)
    batch_size=20
    #卷积基提取特征
    def extract_features(dir,sample_count):
        features=np.zeros(shape=(sample_count,4,4,512))
        labels=np.zeros(shape=(sample_count,))
        generator=datagen.flow_from_directory(
            dir,
            target_size=(150,150),
            batch_size=batch_size,
            class_mode='binary'
        )
        i=0
        for inputs_batch,lables_batch in generator:
            features_batch=conv_base.predict(inputs_batch)
            features[i*batch_size:(i+1)*batch_size]=features_batch
            labels[i*batch_size:(i+1)*batch_size]=lables_batch
            i+=1
            if i*batch_size>=sample_count:
                break
    
        return features,labels
    
    
    
    if __name__=='__main__':
        #提取卷积特征
        train_features, train_labels = extract_features(train_dir, 3200) 
        validation_features, validation_labels = extract_features(validation_dir, 800) 
        test_features, test_labels = extract_features(test_dir, 1000)
    
        #将特征展平 以便传入全连接层
        train_features=train_features.reshape(3200,-1)
        validation_features=validation_features.reshape(800,-1)
        test_features=test_features.reshape(1000,-1)
    
        #构建训练网络
        model=models.Sequential()
        model.add(layers.Dense(units=256,activation='relu',input_dim=4*4*512))
        model.add(layers.Dropout(rate=0.25))
        model.add(layers.Dense(units=1,activation='sigmoid'))
    
        model.compile(optimizer=optimizers.RMSprop(lr=2e-5),
                      loss='binary_crossentropy',
                      metrics=['acc'])
        history = model.fit(train_features, train_labels,
                            epochs=30,
                            batch_size=20,
                            validation_data=(validation_features, validation_labels))
        test_eval=model.evaluate(x=test_features,y=test_labels)
        print(test_eval)
        
        acc = history.history['acc']
        val_acc = history.history['val_acc']
        loss = history.history['loss']
        val_loss = history.history['val_loss']
        epochs = range(1, len(acc) + 1)
        plt.plot(epochs, acc, 'bo', label='Training acc')
        plt.plot(epochs, val_acc, 'b', label='Validation acc')
        plt.title('Training and validation accuracy')
        plt.legend()
        plt.figure()
        plt.plot(epochs, loss, 'bo', label='Training loss')
        plt.plot(epochs, val_loss, 'b', label='Validation loss')
        plt.title('Training and validation loss')
        plt.legend()
        plt.show()
        
    

    准确率的变化曲线如下:
    在这里插入图片描述
    损失函数的变化曲线如下:
    在这里插入图片描述
    采用这种方法的验证集准确率可以达到90%。

    2 采用数据增强的特征提取

    训练代码如下:

    from tensorflow.keras.preprocessing.image import ImageDataGenerator
    from PIL import Image
    from tensorflow.keras import layers
    from tensorflow.keras import models
    from tensorflow.keras import optimizers
    import matplotlib.pyplot as plt
    from tensorflow.keras.preprocessing import image as kimage
    from tensorflow.keras.applications import VGG16
    import numpy as np
    
    '''
    ImageDataGenerator可完成读取图像数据
    读取图像文件
    将jpeg图像解码为RGB像素网络
    将这些像素转换到为浮点型张量并缩放到0~1之间
    '''
    #训练样本的目录
    train_dir='./dataset/training_set/'
    #验证样本的目录
    validation_dir='./dataset/validation_set/'
    #测试样本目录
    test_dir='./dataset/test_set/'
    
    #训练样本生成器
    #注意数据增强只能用于训练数据,不能用于验证数据和测试数据
    '''
    进行数据增强
    '''
    #设置数据增强
    '''
    rotation_range 是角度值(在 0~180 范围内),表示图像随机旋转的角度范围。
    width_shift 和 height_shift 是图像在水平或垂直方向上平移的范围(相对于总宽
    度或总高度的比例)。
    shear_range 是随机错切变换的角度。
    zoom_range 是图像随机缩放的范围。
    horizontal_flip 是随机将一半图像水平翻转。如果没有水平不对称的假设(比如真
    实世界的图像),这种做法是有意义的。
    fill_mode是用于填充新创建像素的方法,这些新像素可能来自于旋转或宽度/高度平移。
    '''
    train_datagen=ImageDataGenerator(
        rescale=1./255,
        rotation_range=40,
        width_shift_range=0.2,
        height_shift_range=0.2,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest')
    
    train_generator=train_datagen.flow_from_directory(
        directory=train_dir,
        target_size=(150,150),
        class_mode='binary',
        batch_size=20
    )
    
    #验证样本生成器
    validation_datagen=ImageDataGenerator(rescale=1./255)
    validation_generator=train_datagen.flow_from_directory(
        directory=validation_dir,
        target_size=(150,150),
        class_mode='binary',
        batch_size=20
    )
    
    #测试样本生成器
    test_datagen=ImageDataGenerator(rescale=1./255)
    test_generator=train_datagen.flow_from_directory(
        directory=test_dir,
        target_size=(150,150),
        class_mode='binary',
        batch_size=20
    )
    
    
    
    if __name__=='__main__':
        conv_base=VGG16(weights='imagenet',
                    include_top=False,
                    input_shape=(150,150,3))
        #冻结卷积基 保证其权重在训练过程中不变
        conv_base.trainable=False
        #构建训练网络
        model=models.Sequential()
        model.add(conv_base)
        model.add(layers.Flatten())
        model.add(layers.Dense(units=256,activation='relu'))
        model.add(layers.Dense(units=1,activation='sigmoid'))
    
        model.compile(optimizer=optimizers.RMSprop(learning_rate=1e-4),
                      loss='binary_crossentropy',
                      metrics=['acc'])
    
        model.summary()
    
        #拟合模型
        history=model.fit_generator(
            train_generator,
            steps_per_epoch=100,
            epochs=100,
            validation_data=validation_generator,
            validation_steps=50
        )
    
        #测试测试集的准确率
        test_eval=model.evaluate_generator(test_generator)
        print(test_eval)
    
        acc = history.history['acc']
        val_acc = history.history['val_acc']
        loss = history.history['loss']
        val_loss = history.history['val_loss']
        epochs = range(1, len(acc) + 1)
        plt.plot(epochs, acc, 'bo', label='Training acc')
        plt.plot(epochs, val_acc, 'b', label='Validation acc')
        plt.title('Training and validation accuracy')
        plt.legend()
        plt.figure()
        plt.plot(epochs, loss, 'bo', label='Training loss')
        plt.plot(epochs, val_loss, 'b', label='Validation loss')
        plt.title('Training and validation loss')
        plt.legend()
        plt.show()
    
    

    使用数据增强的准确率变化曲线:
    在这里插入图片描述
    使用数据增强的损失函数变化曲线:
    在这里插入图片描述

    展开全文
  • 用常规石蜡切片法研究了牡丹三个种七个品种的雄蕊发育过程,结果表明3个种极为相似,大部分差别表现在数量特征上,说明种的特征在这一阶段的组织和细胞水平尚未明显反映出来,但就牡丹各种及品种在不同发育期所表现出的...
  • 面向对象的特征

    千次阅读 2021-05-28 18:22:50
    Java知识点总结:想看的可以从这里进入 3、 面向对象特征 面向对象的特征:继承、封装、多态 3.1、封装 封装是面向对象编程的核心思想,将对象的属性和行为封装隐藏起来。而这些封装起来的属性和行为通常...

    Java知识点总结:想看的可以从这里进入

    3、 面向对象三大特征


    面向对象的三大特征:继承、封装、多态

    3.1、封装

    封装是面向对象编程的核心思想,将对象的属性和行为封装隐藏起来。而这些封装起来的属性和行为通常对外隐藏细节,只允许外部使用公开的数据,避免外部操作导致内部数据改变,来保证类内部数据和结果的完整性,提高程序的可维护性。

    现实中的遥控器、电脑等等都有封装的思想在里面,我们可以在不了解内部结构的情况下直接使用其提供给我们的功能。

    • 按照类别封装成不同的类,把代码按功能封装成一个个的方法。
    • 通过权限相关的关键字对属性、方法进行权限控制,在提供一些方法进行操作、获取。

    在最初没有接触对象和类的时候,我们往往都是把代码直接写在main方法中,如果代码较少的情况下,这样是可行的,但是随着学习的深入,代码量逐渐增加,逻辑逐渐复杂,所以全写在main方法中不利于代码的维护,而且无法解决一些复杂的问题。所以随着学习的深入,我们开始创建新的方法,每个方法只解决一个问题,最后在main方法中逐个调用,这样的好处就是那个相关的问题出现错误,直接去找相应的方法即可。后来我们开始封装不同的类,通过面向对象的思想去解决更复杂的问题。而这个学习的过程就是对封装一步步的理解的过程。

    在这里插入图片描述

    3.2、 继承

    ​ 类和类之间有些也会具有一定的关系,比方说四边形,可以分为正方形、长方形、菱形,他们不但继承了四边形的特征,也具有属于自己的特征,这就是一种继承的关系。

    在这里插入图片描述

    有时候我们希望基于某一个类进行扩展,使一个新类直接拥有基类的基本特征,而不需要重复去写,这就是继承的思想。比如说手机的逐步发展,最早的大哥大只有通话功能,后来的按键手机增加则界面等操作,再主键的变成现在的智能手机,它们不是一蹴而就的,而是通过在保留原有的功能上再增加新功能而逐渐演变过来的,就其实就是一种继承的直观体现。继承原有的功能,增加自己新的功能,实现了拓展和复用。

    在Java继承可以使用 extends 关键字来实现,其中Java规定了java.lang.Object 类作为所有的类直接或间接的父类(当类没有继承其他类时,java默认继承Object类,当类继承了其他类时,可以向上追溯,最终继承的类就是Object类)。java规定类只能继承一个类。

    继承是受权限修饰符影响的

    子类不会继承父类的构造方法,但是会调用。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

    • 子类无法继承private修饰的属性和方法
    • 子类和父类在同一包下,可以继承default权限的属性方法
    • 子类可以对父类进行扩展,拥有自己的属性和方法
    • 子类可以对父类的方法进行重写

    在这里插入图片描述

    public class School {
        String name = "学校";
        void category(){
            System.out.println("一所学校");
        }
    }
    //定义一所大学继承学校,大学这个类就能使用父类的方法和属性
    public class University extends School {
    	String name = "大学";
        public void category(String name){
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(super.name);
        }
    }
    

    在这里插入图片描述

    继承中的关键字:extends、super 、this、final
    1、extends:单一继承,可以让一个类继承一个父类
    2、super:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
    3、this:指向自己的引用。引用自身的属性和方法。
    4、final:当用final修饰类时,是把类定义为不能继承的,即最终类;
    用于修饰方法时,该方法不能被子类重写:
    用于修饰属性时,和static一起使用,表明为一个常量,各类的所有对象共用一个值

    3.3、 多态

    多态指同一个实体同时具有多种形式。同字面意思,及一个对象在不同的情况下会有不同的体现。

    在这里插入图片描述

    3.3.1 类的多态

    类的多态其实就是一种继承关系。

    1、向上转型

    向上转型其实就是父类对子类的引用。等边三角形是一种特殊的三角形,但是不管再怎么特殊它也是一个三角形。不管什么品种的狗我们都可以说它是一只动物。

    //狗继承与Animals ,所以可以向上转型,用Animals引用Dog类
    //能引用是因为狗至少是一种动物,它有动物类所有属性和方法
    Animals animals= new Dog();
    
    2、向下转型

    向下转型是讲父类转型位子类,这种转型通常会出现问题,在具体使用向下转型的时候需要使用显式类型转换。

    • 父类对象指向的是子类对象,(实际上还是得先向上转型一下)
    • 再用强制类型转换进行转型

    向下转型通常配合 instanceof关键字使用,用于判断一个实例对象是否属于某个类,判断一个类是否实现了某个接口。

    当我们使用向下转型时,可能会出现一些问题,所以在之前需要先判断一下。

    class Animals {
        public void sound(){
            System.out.println("动物叫声");
        }
    }
    class Dog extends Animals{
        @Override
        public void sound() {
            System.out.println("狗叫声");
        }
    }
    class main{
        public static void main(String[] args) {
            //向上转型
            Animals a = new Dog();
            a.sound();
            //向下转型,先判断是否属于Dog的实例
            if(a instanceof Dog){
                Dog dog = (Dog)a;
                dog.sound();
            }
        }
    }
    

    3.3.2 方法的多态

    1、重写

    重写父类的方法,名字、参数、返回值相同

    public class Persion {
    	public void say(String name){
           System.out.println("名字是:"+name);
        }
    }
    public class Student extends Persion{
        public void say(String name) {		//重写了父类的方法,方法名和参数相同
            System.out.println(name+"是一个学生");
        }
    }
    
    2、重载

    同一个类中的相同名字不同参数的方法

    public void say(String name , String sex){}
    public void say(String name,int age){	//重载方法,名字相同,但是传递参数的类型必须有不同   
    }
    public void say(String sex,String name){	//传递的参数类型相同数量相同,所以系统无法判定,错误 
    }
    

    重写(Override)和重载(Overload):

    1、重写(Override)
    	重写是子类对父类允许访问的方法进行重写, 返回类型与被重写方法的返回类型可以不相同,但是必须是父类返回值的派生类
    	子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 privatefinal 的方法。
    	子类和父类不在同一个包中,那么子类只能够重写父类的声明为 publicprotected 的非 final 方法。
    	访问权限不能比父类中被重写的方法的访问权限更低。
    	父类的成员方法只能被它的子类重写,子类能够根据需要实现父类的方法
    	重写方法抛出的异常范围不能大于父类。异常也有继承关系,所以子类能抛出的异常不能高于父类
    	参数列表与被重写方法的参数列表必须完全相同。
    	声明为 final 的方法不能被重写。声明为 static 的方法不能被重写,但是能够被再次声明。
    	构造方法不能被重写。
    	如果不能继承一个类,则不能重写该类的方法。
    2、重载(Overload)
    	重载是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。
    	方法能够在同一个类中或者在一个子类中被重载。
    	被重载的方法必须改变参数列表(参数个数或类型不一样);
    	被重载的方法可以改变返回类型;
    	被重载的方法可以改变访问修饰符;
    	被重载的方法可以声明新的或更广的检查异常;
    	无法以返回值类型作为重载函数的区分标准。
    3、方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载可以理解成多态的具体表现形式。
    	(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载
    	(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写
    	(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
    
    展开全文
  • 这项研究旨在诊断来自这两科的七七叶树种类的茎特征,以更新现有知识。 具体而言,诊断出新鲜茎的横断面产生一关键。 结果表明,所有七物种都发育出十冈比亚变种类型之一,即。 段中的轴向血管元素。 在...
  • 利用FS920荧光光谱仪测量得到国内生产的26绿茶样品的维荧光光谱矩阵(EEMs),建立了不同种类绿茶在特定范围内(激发波长为300~550 nm,发射波长为310~750 nm)的维荧光光谱图和等高线光谱图。采用平行因子分析法...
  • 酒的数据来源是UCI数据库,记录的是在意大利同一区域上种不同品种的葡萄酒的化学成分分析,数据里含有178样本,每样本含有13个特征分量(化学成分),每样本的类别标签已给。将这178样本的50%作为训练集,...
  • 一:什么是集合?1、集合(set)是可变的容器。2、集合内的数据对象是唯一的(是不能重复的)。3、集合是无序的存储...二:集合的创建1、创建空的集合: s = set()2、创建非空集合: s = {1,2,3} #集合中的三个整数:1...

    一:什么是集合?

    1、集合(set)是可变的容器。

    2、集合内的数据对象是唯一的(是不能重复的)。

    3、集合是无序的存储结构,集合中的数据没有先后关系(特点:插入、删除比较快)。

    4、集合内的元素必须是不可变对象。

    5、集合是可迭代的。

    6、集合是相当于只有键没有值的字典(键则是集合的数据)。

    二:集合的创建

    1、创建空的集合: s = set()

    2、创建非空集合: s = {1,2,3} #集合中的三个整数:1,2, 3

    3、集合的构造函数:

    Set() 创建空集合

    Set(iterable) 用可迭代对象创建一个新的集合

    示例:

    s = set(‘ABC’)

    s = set(‘ABCCBA’) ---- 多了一个A和C,默认会把多余的A\C删除

    s = set({1:’一’, 2:’二’, 3:’三’}) 用字典生成的集合,只有键,没有值

    s = set([1, 3.14, False])

    s = set((2,3,5,7)) ----- 元组转换成集合

    三:集合的运算:交集、 并集 、补集、 子集、 超集

    1、生成两个集合的交集: &

    S1 = {1,2,3}

    S2 = {2,3,4}

    S3 = s1 & s2

    2、生成两个集合的并集:| (即存在s1中,也存在s2中,去掉重复项)

    S1 = {1,2,3}

    S2 = {2,3,4}

    S3 = s1 | s2

    4、生成两个集合的补集:- 生成属于s1,但不属于s2的所有元素的元素的集合。

    S1 = {1,2,3}

    S2 = {2,3,4}

    S3 = s1 - s2

    5、生成两个集合的对称补集:^

    S1 = {1,2,3}

    S2 = {2,3,4}

    S3 = s1 ^ s2

    6、判断一个集合是另一个集合的子集: <

    S1 = {1, 2, 3}

    S2 = {2, 3}

    S2 < s1 #True 判断子集

    7、判断一个集合是另一个集合的超集: >

    S1 = {1, 2, 3}

    S2 = {2, 3}

    S1 > s2 #True 判断超集

    8、== != 集合相同/不同

    S1 = {1, 2, 3}

    S2 = {2, 3,1}

    S1 == s2 #True

    S1 != s2 # 集合的数据没有先后关系

    9、 in /not in 运算符

    等同于字典,in运算符用于集合中,当某个值存在于集合中,则为真,否则为假,not in与in返回值相反。

    示例:

    S = {1, ‘Two’3.14}

    1 in s #True

    2 in s #False

    3.14 not in s #False

    4not in s #True

    四:集合的方法:集合是可变对象,可用方法添加、删除集合的数据。

    A:集合与列表等一些常用的方法相似

    1、s.add(e) 在集合中添加一个新的元素e;如果元素已经存在,则不添加

    2、s.remove(e) 从集合中删除一个元素,如果元素不存于集合中,则会产生一个KeyError

    3、s.clear(e) 清空集合内的所有元素

    4、s.discard(e) 从集合s中移除一个元素e,在元素e不存在时什么都不做

    5、s.copy() 将集合进行一次浅拷贝

    6、s.pop() 从集合中删除一个随机元素,如果此集合为空,则引发错误

    7、update(s2) 用s与s2得到的全集更新

    B:集合专用方法

    1、s.difference(s2) 用s – s2运算,返回存在于在s中,但不在s2中的所有元素

    2、s.difference_update(s2) 等同于s = s – s2

    3、s.intersection(s2) 等同于s & s2

    4、s.intersection_update(s2) 等现于 s = s &s2

    5、s.isdisjoint(s2) 如果s与s2交集为空返回True,非空则返回False

    6、s.issubset(s2) 如果s与s2交集为非空返回True,空则返回False

    7、s.issuperset() 如果s 为s2的子集返回True,否则返回False

    8、s.symmetric_difference(s2) 返回对称补集,等同于s^s2

    9、s.symmetric_difference_update(s2) 用s与s2的对称补集更新s

    10、s.union(s2) 生成s与s2的全集

    五:练习

    任意输入一个单词,存入集合中,当输入回车时,结束输入

    1、打印您输入的单词的种类数(去重)

    2、每个字母都打印到终端上显示

    结语

    今天要记的东西有点多,朋友们,多多加油哦!如果喜欢IT时代的内容请加粉、评论、关注!

    展开全文
  • 描述数据的“三个维度”

    万次阅读 2018-01-24 00:00:00
    虽然数据的类型有很多,但是所有的结构化数据都可以从三个维度进行描述,这三个维度就是数据的集中趋势描述,数据的离散程度描述和数据的分布形态描述。如图2-6所示,在每个数据描述维度,分别包含数量不定的几个...
  • java大特性是什么?

    千次阅读 2021-02-12 10:13:43
    3、多态,一方法可以有多种实现版本,即“一种定义, 多种实现”。Java 大特性,算是Java独特的表现,提到Java 的大特性, 我们都会想到封装, 继承和多态 这是我们Java 最重要的特性。封装(Encapsulat...
  • 文学形象有哪些特点?文学形象是具体的感性的现象形态:...从三国演义曹操形象看文学典型的四基本特征?反面形象 1、生性多疑,善于猜忌:代表案例为因言,拔刀直入杀吕伯奢一家八口,以及梦中杀近侍。 2、奸诈...
  • 首先这者均属于互联网行业,我们不能说这其中哪一肯定是最好的。因为即使都是互联网行业但他们都各自有各自的特点。我们只能去选择更合适自己的。 在选择进入互联网行业之前,我们首先应该去全面地了解这行业...
  • 玄凤鹦鹉_种类_特征_宠物鸟百科

    千次阅读 2020-12-24 02:06:09
    品种玄凤羽色有两种:一种是白色,红色的眼睛,头和冠是黄色的,两只眼睛斜后颈部有一圆的红斑,就像涂料腮红一样非常漂亮。玄凤鹦鹉图集食物:玄凤鹦鹉是杂食科鸟类,从进食到排便二小时左右直肠子,一般正常的鸟...
  • 图像特征

    千次阅读 2019-05-22 17:23:38
    转 图像特征 2016年10月30日 21:59:01 SingDancer 阅读数:24860更多 ...
  • 近几年,随着“教育均衡化”理念的提出,“努力让每个孩子都能享有公平而有质量的教育”成为义务教育阶段新的目标,有关部门在师资力量、软硬件建设等方面加大投入,...三个课堂是教学深度融合信息技术的产物。早在2...
  • 它们都具有输入、输出和公共端 (接地)三个引出脚。它们输出的电压不能调整,是一个定值电压。 1)其特点是该集成电路的封装形式与晶体三极管的标准相同,其外形与三极管完全一样。用它组成的稳压源外围元件很少,...
  • 小型RF电感器被使用于手机为主的RF电路中,小型RE电感器按照工艺方法不同可以分为三个类型的电感器。电感器类型不同,特征也不一样,本次将介绍电感器的特征和选择要点。
  • 想来我应该是惹人怜爱的吧(认真脸),因为我仿佛听到了无数初入计算机世界的同学的呐喊声(????)。 我作为一门简单学科,看到有很多的在半途弃我而去,我很是痛心疾首。于是,委托这位靓仔将我蕴藏的知识传播...
  • 在文本分类中,假设我们有一文档d∈X,X是文档向量空间(document space),和一固定的类集合C={c1,c2,…,cj},类别又称为标签。显然,文档向量空间是一高维度空间。我们把一堆打了标签的文档集合<d,c>...
  • 展开全部计划的正文主体一般由以下三个部分构成62616964757a686964616fe78988e69d8331333366306462:1、文章式,即把计划按照指导思想、目标和任务、措施和步骤等分条列项地编写成文,这种形式有较强的说明性和概括...
  • 图像特征提取大算法:HOG特征,LBP特征,Haar特征

    万次阅读 多人点赞 2017-03-21 10:49:21
    (一)HOG特征  from:http://dataunion.org/20584.html 1、HOG特征: 方向梯度直方图(Histogram of Oriented Gradient, HOG)特征是一种在计算机视觉和图像处理中用来进行物体检测的特征描述子。它...
  • 常用数据库的种类特点

    千次阅读 2019-03-01 20:30:39
    常用数据库的种类特点 记录目前工业上常用的数据库的种类特点。 数据库分类 早期数据库模型有种,分别为层次式数据库、网络式数据库和关系型数据库。 而在当今的互联网中,通常把数据库分为两类,即关系型...
  • 为实现对红枣品种的判别,利用高光谱技术并结合机器学习算法对金丝大枣、骏枣和滩枣这三个品种的新疆红枣进行研究。首先,分别利用多元散射校正(MSC)、标准正态变量变换(SNV)、一阶导(1-Der)和Savitzky-Golay(SG)平滑...
  • 产品特点如下: 1,拥有一属于自己的网络维世界 2,拥有自己的维化身,多人的维交互环境 3, 配套的论坛系统,功能强大,完全属于你自己(可以结合任何种类的论坛,BBS,如
  • 1.行内元素:(常用): ...特点: 1.和其他元素可以并排 2.元素的高度宽度 以及上边距和下边距取决于内容的宽高   以&lt;span&gt;标签为例    2.块级元素 &lt;div&gt; &l
  • ML之k-NN:k-NN实现对150朵共种花的实例的萼片长度、宽,花瓣长、宽数据统计,根据一朵新花的四个特征来预测其种类 目录 输出结果 实现代码 输出结果 实现代码 from sklearn import ...
  • C语言_种结构

    2020-06-21 11:54:48
    非数值算法目的:常见用于事务管理领域(应用领域广,种类多) 2.算法的特点 (1)有穷性 (2)确定性 (3)有零或多输入 (4)有一或者多输出 (5)有效性 3.算法的表示 (1)用自然语言表示 (2...
  • 最近做一些关于Faster R-CNN、SSD和YOLO模型选择和优化的项目,之前只了解Faster R-CNN系列目标检测方法,于是抽空梳理一下这几检测模型。先上两张简单的精确度和运算量的对比图,有粗略的了解,虽然图中缺了...
  • (一)HOG特征 1、HOG特征: 方向梯度直方图(Histogram of Oriented Gradient, HOG)特征是一种在计算机视觉和图像处理中用来进行物体检测的特征描述子。它通过计算和统计图像局部区域的梯度方向直方图来构成特征...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 160,077
精华内容 64,030
关键字:

品种的三个特点