切片 订阅
切片是用特制刀具把生物体的组织或矿物切成的薄片。切片用来在显微镜下观察和研究。 展开全文
切片是用特制刀具把生物体的组织或矿物切成的薄片。切片用来在显微镜下观察和研究。
信息
出    处
《我是怎样学起美学来的》
拼    音
qiēpiàn
释    义
从物品上切出的扁薄部分
中文名
切片
切片词语概念
基本解释:切片 qiēpiàn1. [slice]∶从物品上切出的扁薄部分2.[section]∶适于显微镜检验的极薄片(如组织的或岩石的)切片 qiēpiàn[click] 用小刀或开动模切机切割出(如鞋帮的某些部分) [1]  引证解释:朱光潜《我是怎样学起美学来的》:“﹝我﹞解剖过鲨鱼,制过染色切片。”黄宗英《美丽的眼睛》:“夜班医生正在观察病理切片。” [1] 
收起全文
精华内容
参与话题
问答
  • Python笔记 - Python切片

    2019-10-16 16:35:22
    Python笔记 - Python切片 Python切片是对一个列表取其部分元素获得一个子序列的常见操作,切片操作的返回结果类型与被切片的对象一致。要创建一个已有列表的切片,通过指定切片的第一个列表元素和最后一个列表元素的...

    Python笔记 - Python切片

    Python切片是对一个列表取其部分元素获得一个子序列的常见操作,切片操作的返回结果类型与被切片的对象一致。要创建一个已有列表的切片,通过指定切片的第一个列表元素和最后一个列表元素的索引号即可。
    其基本语法如下:

    list_slice = source_list[start: end :step]

    其中,
    source_list:被切片的源列表
    list_slice:切片后生成的子序列列表
    start:切片起始索引位置,省略则从头开始
    end:切片结束索引位置,省略则切至列表末尾
    step:切片步长,可选参数,表示每N个元素取一个,默认为1

    注意:
    1、切片和range()函数一样,Python会自动到达所指定切片结束索引位置的前面一个元素停止。
    2、负数索引返回离列表末尾相应间隔的元素。列表末尾元素的索引是从-1开始的。

    例如:

    my_menu = ['fish','pork','pizza','carrot']
    print(my_menu[1:4:2]) #开始索引为1,结束索引为4,每2个取一个的第一个
    print(my_menu[:3])  #结束索引位置,其他默认
    print(my_menu[2:])  #开始索引位置,其他默认
    print(my_menu[-3:]) #负索引开始位置,其他默认
    

    输出结果:
    [‘pork’,‘carrot’]
    [‘fish’,‘pork’,‘pizza’]
    [‘pizza’,‘carrot’]
    [‘pork’,‘pizza’,‘carrot’]

    展开全文
  • 假设df是一个dataframe,列名为A B C D 具体如下: A B C D 0 ss 小红 8 1 aa 小明 d 4 f f 6 ak 小紫 7 ...dataframe里的属性不是指定的,空值默认为NA。...一、选取标签为A和C的列,并且选完的对象类型还是dataframe...
    假设df是一个dataframe,列名为A B C D
    具体如下:
    
    A    B    C    D
    
    0    ss   小红  8
    1    aa   小明  d
    4    f         f
    6    ak   小紫  7
    dataframe里的属性不是指定的,空值默认为NA。
    一、选取标签为A和C的列,并且选完的对象类型还是dataframe
    
    df = df.loc[:, ['A', 'C']]
    df = df.iloc[:, [0, 2]]
    
    二、选取标签为C并且只取前两行,并且选完的对象类型还是dataframe
    
    df = df.loc[0:2, ['A', 'C']]
    df = df.iloc[0:2, [0, 2]] 
    
    聪明的朋友已经看出iloc和loc的不同了:loc是根据dataframe的具体标签选取列,而iloc是根据标签所在的位置,从0开始计数。",
    "前面的":"表示选取整列,第二个示例中的的0:2表示选取第0行到第二行,这里的0:2相当于[0,2)前闭后开,2是不在范围之内的。
    
    需要注意的是,如果是
    
    df = df.loc[0:2, ['A', 'C']]
    或者
    
    df = df.loc[0:2, ['A', 'C']]
    ,切片之后类型依旧是dataframe,不能直接进行加减乘除等操作的。
    比如dataframe的一列是数学成绩(shuxue),另一列为语文成绩(yuwen),现在需要求两门课程的总和,可以使用
    
    df['shuxue'] + df['yuwen'] # 选取完之后类型为series
    来获得总分,而不能使用
    
    df.iloc[:,[2]]+df.iloc[:,[1]]
    df.iloc[:,['shuxue']]+df.iloc[:,['yuwen']]
    ,这会产生错误结果。
    
    还有一种方式是使用df.icol(i)来选取列,选取完的也不是dataframe而是series,i为该列所在的位置,从0开始计数。
    
    如果你想要选取某一行的数据,可以使用df.loc[[i]]或者df.iloc[[i]]。
    
    展开全文
  • Python 切片

    千次阅读 2018-08-09 09:58:02
    切片是指对操作的对象取出一部分的概念 字符串、列表、元组都支持切片语法 切片的语法为 [ 起始 : 结束 : 步长] 这里注意:选取的区间为左闭右开,即包括起始位置,不包括结束位置 1 字符串切片 以上...

    切片是指对操作的对象取出一部分的概念

    字符串、列表、元组都支持切片语法

    切片的语法为   [  起始  :   结束  : 步长]

    这里注意:选取的区间为左闭右开,即包括起始位置,不包括结束位置

    1 字符串切片

    以上表示截取wangl这几个字符

    2 进阶

    (1)步长

    以上为基本用法,步长表示每隔几位截取

    如:

    截取的字符串应该是wnl

    (2)-1的用法

    在切片中-1 表示最后一位的意思

    截取的字符串应该为wnl,为什么没有取到  i  呢,因为-1表示最后一位,即第六位,但是切片区域为左闭右开。所以不包括i

     

    展开全文
  • 1、同样的切片命令,当mp3文件有封面图片时,切片就会失败,下面是切片命令: ffmpeg -y -i E:\音视频转换后文件\没有封面.mp3 -hls_time 50 -hls_list_size 0 -hls_key_info_file E:\音视频转换后文件\key_info_...
  • 1、地理坐标下切片系统的计算 地理坐标下切片系统的计算,主要适用于google地球中切片系统,以及目标底图参考系统为EPSG:4326的情况。 public class GlobalGeodetic { private int tileSize; private ...

    1、地理坐标下切片系统的计算

    地理坐标下切片系统的计算,主要适用于google地球中切片系统,以及目标底图参考系统为EPSG:4326的情况。

    public class GlobalGeodetic {
        private int tileSize;
        private double resFact;
    
        public GlobalGeodetic(String tmscompatible, int tileSize) {
            this.tileSize = tileSize;
            if (tmscompatible != null && tmscompatible.length() > 0) {
            	// Defaults the resolution factor to 0.703125 (2 tiles @ level 0)
                this.resFact = 180.0D / (double)this.tileSize;
            } else {
            	//Defaults the resolution factor to 1.40625 (1 tile @ level 0)
                this.resFact = 360.0D / (double)this.tileSize;
            }
    
        }
    
        public double[] lonlatToPixels(double lon, double lat, int zoom) {
            double res = this.resFact / Math.pow(2.0D, (double)zoom);
            return new double[]{(180.0D + lon) / res, (90.0D + lat) / res};
        }
    
        public int[] pixelsToTile(double px, double py) {
            int tx = (int)(Math.ceil(px / (double)this.tileSize) - 1.0D);
            int ty = (int)(Math.ceil(py / (double)this.tileSize) - 1.0D);
            return new int[]{tx, ty};
        }
    
        public int[] lonlatToTile(double lon, double lat, int zoom) {
            double[] pxpy = this.lonlatToPixels(lon, lat, zoom);
            return this.pixelsToTile(pxpy[0], pxpy[1]);
        }
    
        public double resolution(int zoom) {
            return this.resFact / Math.pow(2.0D, (double)zoom);
        }
    
        public int zoomForPixelSize(double pixelSize) {
            for(int i = 0; i < 32; ++i) {
                if (pixelSize > this.resolution(i)) {
                    if (i != 0) {
                        return i - 1;
                    }
    
                    return 0;
                }
            }
    
            return 0;
        }
    
        public double[] tileBounds(int tx, int ty, int zoom) {
            double res = this.resFact / Math.pow(2.0D, (double)zoom);
            return new double[]{(double)(tx * this.tileSize) * res - 180.0D, (double)(ty * this.tileSize) * res - 90.0D, (double)((tx + 1) * this.tileSize) * res - 180.0D, (double)((ty + 1) * this.tileSize) * res - 90.0D};
        }
    
        public double[] tileLatLonBounds(int tx, int ty, int zoom) {
            double[] b = this.tileBounds(tx, ty, zoom);
            return new double[]{b[1], b[0], b[3], b[2]};
        }
    }
    

    2、投影坐标系下计算类

    目前绝大多数切片系统内部实现都是采用这种方式实现。

    public class GlobalMercator {
        private int tileSize;
        private double initialResolution;
        private double originSh;
       //6378137 为地球半径		
       public GlobalMercator(int tileSize) {
            this.tileSize = tileSize;
            this.initialResolution = 2 * Math.PI * 6378137 / this.tileSize;
            this.originShift = 2 * Math.PI * 6378137 / 2.0;
        }
    
        public double[] latLonToMeters(double lat, double lon) {
            double mx = lon * this.originShift / 180.0;
            double my = Math.log(Math.tan((90 + lat) * Math.PI / 360.0)) / (Math.PI / 180.0);
            my = my * this.originShift / 180.0;
            return new double[]{mx, my};
        }
    
        public double[] metersToLatLon(double mx, double my) {
            double lon = (mx / this.originShift) * 180.0;
            double lat = (my / this.originShift) * 180.0;
            lat = 180 / Math.PI * (2 * Math.atan(Math.exp(lat * Math.PI / 180.0)) - Math.PI / 2.0);
            return new double[]{lat, lon};
        }
    
        public double[] pixelsToMeters(int px, int py, int zoom) {
            double res = this.resolution(zoom);
            double mx = px * res - this.originShift;
            double my = py * res - this.originShift;
            return new double[]{mx, my};
        }
    
        public double[] metersToPixels(double mx, double my, int zoom) {
            double res = this.resolution(zoom);
            double px = (mx + this.originShift) / res;
            double py = (my + this.originShift) / res;
            return new double[]{px, py};
        }
    
        public int[] pixelsToTile(double px, double py) {
            int tx = (int) (Math.ceil(px / (float) (this.tileSize)) - 1);
            int ty = (int) (Math.ceil(py / (float) (this.tileSize)) - 1);
            return new int[]{tx, ty};
        }
    
        public double[] pixelsToRaster(double px, double py, int zoom) {
            double mapSize = this.tileSize << zoom;
            return new double[]{px, mapSize - py};
        }
    
        public int[] metersToTile(double mx, double my, int zoom) {
            double[] coordinate = this.metersToPixels(mx, my, zoom);
            return this.pixelsToTile(coordinate[0], coordinate[1]);
        }
    
        public double[] tileBounds(int tx, int ty, int zoom) {
            double[] minxy = pixelsToMeters(tx * this.tileSize, ty * this.tileSize, zoom);
            double[] maxxy = pixelsToMeters((tx + 1) * this.tileSize, (ty + 1) * this.tileSize, zoom);
            return new double[]{minxy[0], minxy[1], maxxy[0], maxxy[1]};
        }
    
        public double[] tileLatLonBounds(int tx, int ty, int zoom) {
            double[] bounds = this.tileBounds(tx, ty, zoom);
            double[] minLatLon = this.metersToLatLon(bounds[0], bounds[1]);
            double[] maxLatlon = this.metersToLatLon(bounds[2], bounds[3]);
            return new double[]{minLatLon[0], minLatLon[1], maxLatlon[0], maxLatlon[1]};
        }
    
        public double resolution(int zoom) {
            return this.initialResolution / (Math.pow(2, zoom));
        }
    
        public int zoomForPixelSize(double pixelSize) {
            for (int i = 0; i < 32; i++) {
                if (pixelSize > this.resolution(i)) {
                    if (i != 0) {
                        return i - 1;
                    } else return 0;
                }
            }
            return 0;
        }
    	//XYZ切片系统转googleTSM切片系统,其实就是坐标系的Y轴的变换,由原点左上角变换为原点左下角。
        public int[] googleTile(int tx, int ty, int zoom) {
            return new int[]{tx, ((int) (Math.pow(2, zoom)) - 1) - ty};
        }
    
        public String quadTree(int tx, int ty, int zoom) {
            String quadKey = "";
            ty = (int) (Math.pow(2, zoom) - 1 - ty);
            for (int i = zoom; i > 0; i--) {
                int digit = 0;
                int mask = 1 << (i - 1);
                if ((tx & mask) != 0) {
                    digit += 1;
                }
                if ((ty & mask) != 0) {
                    digit += 2;
                    quadKey += digit;
                }
            }
            return quadKey;
        }
    	//XYZ转换为geohash编码
        public String tileXYToQuadKey(int tileX, int tileY, int levelOfDetail) {
            StringBuilder quadKey = new StringBuilder();
            for (int i = levelOfDetail; i > 0; i--) {
                char digit = '0';
                int mask = 1 << (i - 1);
                if ((tileX & mask) != 0) {
                    digit++;
                }
                if ((tileY & mask) != 0) {
                    digit++;
                    digit++;
                }
                quadKey.append(digit);
            }
            return quadKey.toString();
        }
    	//geohash编码转换为XYZ
        public int[] quadKeyToTileXY(String quadKey) throws Exception {
            int tileX = 0, tileY = 0;
            int levelOfDetail = quadKey.length();
            for (int i = levelOfDetail; i > 0; i--) {
                int mask = 1 << (i - 1);
                switch (quadKey.charAt(levelOfDetail - i)) {
                    case '0':
                        break;
                    case '1':
                        tileX |= mask;
                        break;
                    case '2':
                        tileY |= mask;
                        break;
                    case '3':
                        tileX |= mask;
                        tileY |= mask;
                        break;
                    default:
                        throw new Exception("Invalid QuadKey digit sequence.");
                }
            }
            return new int[]{tileX, tileY, levelOfDetail};
        }
    }
    

    3、使用例子

    • 根据XYZ计算经纬度范围
    //地理坐标(EPSG:4326)下计算方式
    double[] bbox = new GlobalGeodetic("", 256).tileLatLonBounds(x, y, z);
     //投影坐标(EPSG:3857)下的计算方式
    double[] bboxs = new GlobalMercator(256).tileLatLonBounds(x, y, z);
    
    • 根据经纬度范围计算XYZ
    //地理坐标(EPSG:4326)下计算方式
    ……待补充
    
    //投影坐标(EPSG:3857)下的计算方式
    Envelope envelope = new Envelope(xmin, xmax, ymin, ymax);
    GlobalMercator mercator = new GlobalMercator(256);
    double[] min = mercator.latLonToMeters(envelope.getMinY(), envelope.getMinX());
    double[] max = mercator.latLonToMeters(envelope.getMaxY(), envelope.getMaxX());
    
    //#region 计算
    for (int tz = tmaxz; tz > tminz - 1; tz--) {
        int[] tminxy = mercator.metersToTile(min[0], min[1], tz);
        int[] tmaxxy = mercator.metersToTile(max[0], max[1], tz);
        tminxy = new int[]{Math.max(0, tminxy[0]), Math.max(0, tminxy[1])};
        tmaxxy = new int[]{(int) Math.min(Math.pow(2, tz) - 1, tmaxxy[0]), (int) Math.min(Math.pow(2, tz) - 1, tmaxxy[1])};
        for (int tx = tminxy[0]; tx < tmaxxy[0] + 1; tx++) {
             for (int ty = tmaxxy[1]; ty > tminxy[1] - 1; ty--) {
       				//z,x,y坐标
       		}
        }
    }
    //endregion
    
    展开全文
  • Go 切片

    万次阅读 2019-09-21 14:17:44
    切片的内部实现和基础功能 文章目录切片的内部实现和基础功能1.内部实现2.创建和初始化a. make和切片字面量b. nil和控空切片3. 切片的使用a. 赋值和切片 切片是一种数据结构,这种数据结构便于使用和管理数据集合 ...
  • 地图切片详解

    万次阅读 2016-12-06 07:48:18
    地图切片很多做GIS的筒子都不陌生,但是其中的原理一直是马马虎虎,在此,就地图切片中的几个重要的概念做一个介绍,一则自己做个总结,二则希望能够帮助到有此困惑的战友们!
  • MapReduce切片机制

    千次阅读 2019-04-04 18:07:24
    MapReduce切片机制 为什么需要切片   MapReduce是一个分布式计算框架,处理的是海量数据的计算。那么并行运算必不可免,但是到底并行多少个Map任务来计算呢?每个Map任务计算哪些数据呢?这些我们数据我们不能够...
  • golang切片

    千次阅读 2020-09-04 23:33:53
    切片很重要
  • 切片 python 中针对 字符串、列表、元组 数据类型提供了切片方法,可以非常方便的进行对象切割和截取。 1、适用范围 切片 方法适用于 字符串、列表、元组 ,不适用于 字典 切片 使用 索引值 来限定范围...
  • numpy 切片操作

    千次阅读 2017-10-05 11:05:39
    numpy在处理数据的时候,经常会有切片操作,如提取指定几行的数据或者几列的数据,本文记录一些典型的切片方法以备日后查看。一维数组的切片:数组[start:end:step] 从start到end,以step为步长的元素 且:start>>...
  • Python切片切片赋值

    千次阅读 2018-07-23 22:13:33
    Python切片切片赋值 Python切片切片赋值 slicing与slice assignment区别 序列 切片 切片赋值 slicing与slice assignment区别 切片 slicing 切片赋值 slice assignment a = [1, 2, 3] b = a[:]...
  • demo.go(切片类型): package main import "fmt" func main() { // 定义切片 (数组长度固定,切片的长度可以不固定) var slice = []int{1,2,3,4,10:5} // 10表示下标 slice[1] = 100 fmt.Println(slice)...
  • M3U8视频切片

    2017-12-14 12:38:59
    可以将MP4转为M3U8切片,工具很好用了。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 为什么大厂都在用GO语言-读透GO语言的切片

    千次阅读 多人点赞 2020-03-11 16:48:42
    近日腾讯发布了《腾讯研发大数据报告》,笔者发现GO语言的使用在鹅厂已经上升到了TOP5的位置了, 我们知道腾讯尤其是Docker容器化这一块,是走在各大厂的前列的,尤其是他们的基于GO语言开发的DEVOPS蓝鲸平台,...
  • //矢量切片图层 var vectorTile = new ol.layer.VectorTile({ title:"武汉道路-VectorTile", style: initStyle, projection: projection4326,  //矢量切片数据 source: new ol.source.VectorTile({  ...
  • Python字符串的序号,索引和切片

    千次阅读 2019-07-06 22:46:51
    Python字符串的序号正向递增序号反向递减序号程序验证 正向递增序号 正向递增序号是我们以前熟悉的很多语言的下标标准,比如C语言和Java语言等等。 例如数组 "Hello_World" 标号为 0,1,2,3,4,5,6,7,8,9,...

空空如也

1 2 3 4 5 ... 20
收藏数 38,524
精华内容 15,409
关键字:

切片