精华内容
下载资源
问答
  • Zen of python实际上一种python编程原理指导(有点像小时候老师教写字的时候教的口诀:横平竖直之类的话) 通过import this来打印zen of python 以下给出TIM PETERS写的PYTHON口诀 The Zen of Python, by Tim ...

    本节主要总结pythonicness&packaing

    Zen of python实际上是一种python编程原理指导(有点像小时候老师教写字的时候教的口诀:横平竖直之类的话)

    通过import this来打印zen of python

    以下给出TIM PETERS写的PYTHON口诀
    The Zen of Python, by Tim Peters
    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren’t special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you’re Dutch.
    Now is better than never.
    Although never is often better than right now.
    If the implementation is hard to explain, it’s a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea – let’s do more of those!

    附上翻译

    优美胜于丑陋
    明了胜于晦涩
    简单胜过复杂
    复杂胜过凌乱
    扁平胜于嵌套
    间隔胜于紧凑
    可读性很重要
    即使假借特例的实用性之名,也不违背这些规则
    虽然实用性次于纯度
    错误不应该被无声的忽略
    除非明确的沉默       
    当存在多种可能时,不要尝试去猜测
    应该有一个,最好只有一个,明显能做到这一点
    虽然这种 方式可能不容易,除非你是python之父
    现在做总比不做好
    虽然过去从未比现在好
    如果这个实现不容易解释,那么它肯定是坏主意
    如果这个实现容易解释,那么它很可能是个好主意
    命名空间是一种绝妙的理念,应当多加利用

    展开全文
  • 这几天,脑海里面一直回绕着一个声音,尼尔森,尼尔森交互,尼尔森交互十大原则。blues老师的讲解至今让我记忆犹新,如果真的让我选择一款产品进行尼尔森交互分析,我想应该就是简书了。尼尔森第一点提到,系统可见...
  • 工作量证明的最长链原则到底说的是什么? 前几天的一篇关于比特币的标准的文章引起了很多人的关注。在这篇文章中介绍了比特币的标准是什么以及Bitcoin Core(BCE)和Bitcoin Cash(BCH)符合哪些标准不符合哪些标准...

    工作量证明的最长链原则到底说的是什么?

    前几天的一篇关于比特币的标准的文章引起了很多人的关注。在这篇文章中介绍了比特币的标准是什么以及Bitcoin Core(BCE)和Bitcoin Cash(BCH)符合哪些标准不符合哪些标准。最终经过对比,BCH只在白皮书中的工作量证明的最长链原则这一标准中输给了BCE,这也是在众多比特币标准中BCH唯一不符合的标准。

    有些朋友看到之后对此产生了疑惑:目前BCH的区块高度不是比BCE要高吗?不已经是最长的链了吗?为什么还说它不符合最长链的原则?今天小编就对这个问题做一个简单的科普,希望能够帮助大家更好的理解。

    什么是工作量证明的最长链原则

    这一说法最初来自于中本聪的论文《比特币:一种点对点的电子现金系统》。文中提到:“信息尽最大努力在全网传播即可,节点(nodes)可以随时离开和重新加入网络,并将最长的工作量证明链条作为在该节点离线期间发生的交易的证明。”以及“工作量证明机制的本质则是一CPU一票。大多数的决定表达为最长的链,因为最长的链包含了最大的工作量。”

    通俗来说就是,比特币区块是依靠矿工们不断进行数学运算而产生的,每一个区块都必须引用其上一个区块。如果想生成一个新的区块并写入区块链,必须解出比特币网络出的工作量证明的迷题。这道题关键的三个要素是工作量证明函数、区块及难度值。工作量证明函数是这道题的计算方法也就是SHA256,区块决定了这道题的输入数据,难度值决定了这道题的所需要的计算量。只有工作量最大的那条链才能被称为最长链,节点永远认为最长链才是有效的区块链,也只有在最长链上挖矿的矿工才能够获得奖励,这就是我们常说的比特币最长链原则。因此也可以说,累积难度值最大的那条链才是最长链。这也是比特币的重要标准之一。

    为什么要制定这一规则?

    因为比特币是去中心化的,是没有中心机构的,想要让所有的完整节点都有一份相同的公共总帐本,就需要达成共识。这一规则就是一种共识,能够保证比特币不停的在工作量最大的区块链上运转,工作量最大的区块链就是权威的公共总帐本。尤其当两个矿工同时挖出区块的时候,系统就会根据最长链原则进行取舍,即哪个新产生的区块能使其所在的区块链变得更长,则哪个区块得以被记录。如果两者一起记账就会造成区块链的分叉,这时会把其中有更多工作量的一条会继续作为主链,另一条作为备用链保存,如果新添加的区块使备用链累积了更多的工作量,那么这条备用链将被作为新的主链。

    为什么BCH不是工作量证明的最长链?

    由于BCH的挖矿难度比BCE小,所以现在BCH的区块高度确实比BCE要高,但是这并不是说明最长的链。因为BCH累积的难度值是远远小于BCE的。这一切都归结于BCH诞生之初为了能够在小算力环境下顺利的生存下来,修改了难度值的算法,降低了挖矿难度,所以现在的它还不是那条工作量证明的最长链。

    虽然目前来说,BCH不是最长的链,但是BCH却是最符合中本聪白皮书的点对点电子现金系统。而且它现在在不断的高速发展,在未来当BCH的价格、用户和总市值都超过BTC之后,BCH超越BCE成为最长链也是有可能的。

    展开全文
  • 原创:小姐姐味道(微信公众号ID:xjjdog),欢迎分享,转载请保留出处。温馨提示:泛型相关。以下内容请在安静的场所、充足的时间下查看,因为它非常的绕,容易把人绕晕。PECS的全程P...

    原创:小姐姐味道(微信公众号ID:xjjdog),欢迎分享,转载请保留出处。

    温馨提示:泛型相关。以下内容请在安静的场所、充足的时间下查看,因为它非常的绕,容易把人绕晕。

    PECS的全程是Producer Extends Consumer Super,第一次听说,我一脸懵逼。但看到jdk中越来越多的泛型代码,我决定去了解一下。

    java的泛型,只在编译期有效。也就是说,编译之后的字节码,已经抹除了泛型信息。

    其实,对于常年接触业务代码的同学来说,泛型用的并不是特别多。当你使用设计模式设计代码,或者在设计一些比较底层的框架时,肯定会碰到这个问题。

    一个例子

    泛型该怎么写?我们首先看一下jdk中的一些例子。

    java.util.function.Consumer

    @FunctionalInterface
    public interface Consumer<T> {
        void accept(T t);
        default Consumer<T> andThen(Consumer<? super T> after) {
            Objects.requireNonNull(after);
            return (T t) -> { accept(t); after.accept(t); };
        }
    }

    java8的interface新增了staticdefault方法,我们不去过多关注。你会发现,里面有<T,R>字样,<? super V, ? extends T>字样等。

    那什么时候该用super,什么时候该用extends?这就是PECS原则。

    为了解释这个原理,我们创建三个类。

    A,B,C。

    其中。A extends B,B extends C。

    static class A extends B{}
    static class B extends C{}
    static class C {}

    然后,我们使用测试类测试一下。

    static class Example<T>{
        }
    
        public static void main(String[] args) {
            {
                Example<? extends A> testAA = new Example<A>();
                Example<? extends A> testAB = new Example<B>();//报错
                Example<? extends A> testAC = new Example<C>();//报错
                Example<? extends B> testBA = new Example<A>();
                Example<? extends B> testBC = new Example<C>();//报错
                Example<? extends C> testCA = new Example<A>();
                Example<? extends C> testCB = new Example<B>();
            }
            {
                Example<? super A> testAA = new Example<A>();
                Example<? super A> testAB = new Example<B>();
                Example<? super A> testAC = new Example<C>();
                Example<? super B> testBA = new Example<A>();//报错
                Example<? super B> testBC = new Example<C>();
                Example<? super C> testCA = new Example<A>();//报错
                Example<? super C> testCB = new Example<B>();//报错
            }
    
        }

    为了更直观一些,我们截个idea的图。

    我们返回头来再看<? extends T>,只要后面的new,声明的是T的子类或者T本身,那么都是没错的。反之,如果是它的父类,则报错。这很好理解,后半部分的实例,一定要能够全面覆盖前面的声明。这也就是Producer-Extends,它可以对外提供对象(难以理解的概念)。

    接下来我们看一下<? super T>。只要是T的父类或者T本身,都没有什么问题,甚至可以是Object。比如,下面的代码就不会报错。

    Example<? super C> testCO = new Example<Object>();

    根据字面意思,Consumer-super也比较晦涩,如果设计的类是消费者,那应该用super关键字为此类型指定一个子类。

    这张图只画了声明部分的原则。为了配合上面这张图,进行更精细的理解,我们创建一个7层的继承关系。

    static class Parent1{}
    static class Parent2 extends Parent1{}
    static class Parent3 extends Parent2{}
    
    static class T extends Parent3{}
    
    static class Child1 extends T{}
    static class Child2 extends Child1{}
    static class Child3 extends Child2{}

    同时,我们创建两个集合容器进行验证。

    List<? extends T> extendsT = new ArrayList<>();
    
    List<? super T > superT = new ArrayList<>();

    以下代码运行都是没有问题的。

    List<? super T > superT = new ArrayList<>();
    superT.add(new T());
    superT.add(new Child1());
    superT.add(new Child2());
    superT.add(new Child3());

    我们把代码分成两部分,一部分是泛型集合的声明部分。一部分是实例的初始化部分。可以看到,? super T界定了最小子类是T,则声明部分的最小类就是T,ArrayList后面的<>,可以是T的任何父类。但是,当向里面添加元素时,初始化的却是T的子类

    再来看extendsT。当我们往里添加数据的时候,无一例外的报错了。

    extendsT.add(new T());
    extendsT.add(new Child1());
    extendsT.add(new Parent1());
    extendsT.add(new Parent2());
    extendsT.add(new Object());

    那是因为,extendsT中存放的其实是T的一种子类(现象),如果我们去添加元素,其实不知道到底应该添加T的哪个子类,这个时候,在进行强转的时候,肯定会出错。但是如果是从集合中将元素取出来,我们则可以知道取出来的元素肯定是T类型(全是它的子类)。

    接下来,我们再强行分析一下 ? super TsuperT中,因为的都是类型T的父类(容器),所以如果去添加T类或者T的子类(操作),肯定没什么问题。但是如果将元素取出来,则不知道到底是什么类型,所以superT可以添加元素但是没法取出来。

    按照我们以往的经验,extendsT只出不进,属于生产者一类;superT只进不出,属于消费者。这也就有了我们上面所提到的“Producer Extends Consumer Super”,也就是PECS原则。

    这个过程可真是绕,我认为这是定义非常失败的一个名词。

    End

    现在,再来看我们文章头部jdk的类Consumer,是不是有了新的理解?其实,这个函数是和函数编程相关的。java8的四个核心函数接口有:Function、Consumer、Supplier、Predicate。

    Function<T, R> T:入参类型,R:出参类型。

    Consumer<T> T:入参类型;没有出参。

    Supplier<T> T:出参类型;没有入参。

    Predicate<T> T:入参类型;出参类型Boolean。

    想要对PECS有更深入的了解,可以深入了解一下函数编程相关的这四个接口。哪怕你只是看一下它的定义,也会有一种原来如此的感觉。

    作者简介:小姐姐味道  (xjjdog),一个不允许程序员走弯路的公众号。聚焦基础架构和Linux。十年架构,日百亿流量,与你探讨高并发世界,给你不一样的味道。我的个人微信xjjdog0,欢迎添加好友,进一步交流。

    近期热门文章

    996的乐趣,你是无法想象的
    魔幻现实主义,关爱神经衰弱

    一切荒诞的傲慢,皆来源于认知
    不要被标题给骗了,画面感十足的消遣文章

    《必看!java后端,亮剑诛仙》
    后端技术索引,中肯火爆。全网转载上百次。

    《学完这100多技术,能当架构师么?(非广告)》
    精准点评100多框架,帮你选型


    展开全文
  • PECS的全程Producer Extends Consumer Super,第一次听说,我一脸懵逼。但看到jdk中越来越多的泛型代码,我决定去了解一下。java的泛型,只在编译期有效。也就是说,编译之后的字节码,已经抹...

    593914420be66221ec1ddb3b59954215.gif

    原创:小姐姐味道(微信公众号ID:xjjdog),欢迎分享,转载请保留出处。

    温馨提示:泛型相关。以下内容请在安静的场所、充足的时间下查看,因为它非常的绕,容易把人绕晕。

    PECS的全程是Producer Extends Consumer Super,第一次听说,我一脸懵逼。但看到jdk中越来越多的泛型代码,我决定去了解一下。

    java的泛型,只在编译期有效。也就是说,编译之后的字节码,已经抹除了泛型信息。

    其实,对于常年接触业务代码的同学来说,泛型用的并不是特别多。当你使用设计模式设计代码,或者在设计一些比较底层的框架时,肯定会碰到这个问题。

    一个例子

    泛型该怎么写?我们首先看一下jdk中的一些例子。

    java.util.function.Consumer

    @FunctionalInterface
    public interface Consumer {
    void accept(T t);
    default Consumer andThen(Consumer super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
    }
    }

    java8的interface新增了staticdefault方法,我们不去过多关注。你会发现,里面有字样, super V, ? extends T>字样等。

    那什么时候该用super,什么时候该用extends?这就是PECS原则。

    为了解释这个原理,我们创建三个类。

    A,B,C。

    其中。A extends B,B extends C。

    static class A extends B{}
    static class B extends C{}
    static class C {}

    然后,我们使用测试类测试一下。

    static class Example{
    }
    public static void main(String[] args) {
    {
    Example extends A> testAA = new Example();
    Example extends A> testAB = new Example();//报错
    Example extends A> testAC = new Example();//报错
    Example extends B> testBA = new Example

    为了更直观一些,我们截个idea的图。

    15da5b81a608fa44aab3ce0f951c11f8.png

    我们返回头来再看 extends T>,只要后面的new,声明的是T的子类或者T本身,那么都是没错的。反之,如果是它的父类,则报错。这很好理解,后半部分的实例,一定要能够全面覆盖前面的声明。这也就是Producer-Extends,它可以对外提供对象(难以理解的概念)。

    接下来我们看一下 super T>。只要是T的父类或者T本身,都没有什么问题,甚至可以是Object。比如,下面的代码就不会报错。

    Example super C> testCO = new Example();

    根据字面意思,Consumer-super也比较晦涩,如果设计的类是消费者,那应该用super关键字为此类型指定一个子类。

    da61175d59fd329489fda16e492f1660.png

    这张图只画了声明部分的原则。为了配合上面这张图,进行更精细的理解,我们创建一个7层的继承关系。

    static class Parent1{}
    static class Parent2 extends Parent1{}
    static class Parent3 extends Parent2{}

    static class T extends Parent3{}

    static class Child1 extends T{}
    static class Child2 extends Child1{}
    static class Child3 extends Child2{}

    同时,我们创建两个集合容器进行验证。

    List extends T> extendsT = new ArrayList<>();

    List super T > superT = new ArrayList<>();

    以下代码运行都是没有问题的。

    List super T > superT = new ArrayList<>();
    superT.add(new T());
    superT.add(new Child1());
    superT.add(new Child2());
    superT.add(new Child3());

    我们把代码分成两部分,一部分是泛型集合的声明部分。一部分是实例的初始化部分。可以看到,? super T界定了最小子类是T,则声明部分的最小类就是T,ArrayList后面的<>,可以是T的任何父类。但是,当向里面添加元素时,初始化的却是T的子类

    再来看extendsT。当我们往里添加数据的时候,无一例外的报错了。

    extendsT.add(new T());
    extendsT.add(new Child1());
    extendsT.add(new Parent1());
    extendsT.add(new Parent2());
    extendsT.add(new Object());

    那是因为,extendsT中存放的其实是T的一种子类(现象),如果我们去添加元素,其实不知道到底应该添加T的哪个子类,这个时候,在进行强转的时候,肯定会出错。但是如果是从集合中将元素取出来,我们则可以知道取出来的元素肯定是T类型(全是它的子类)。

    接下来,我们再强行分析一下 ? super TsuperT中,因为的都是类型T的父类(容器),所以如果去添加T类或者T的子类(操作),肯定没什么问题。但是如果将元素取出来,则不知道到底是什么类型,所以superT可以添加元素但是没法取出来。

    按照我们以往的经验,extendsT只出不进,属于生产者一类;superT只进不出,属于消费者。这也就有了我们上面所提到的“Producer Extends Consumer Super”,也就是PECS原则。

    这个过程可真是绕,我认为这是定义非常失败的一个名词。

    End

    现在,再来看我们文章头部jdk的类Consumer,是不是有了新的理解?其实,这个函数是和函数编程相关的。java8的四个核心函数接口有:Function、Consumer、Supplier、Predicate。

    Function T:入参类型,R:出参类型。Consumer T:入参类型;没有出参。

    Supplier T:出参类型;没有入参。

    Predicate T:入参类型;出参类型Boolean。

    想要对PECS有更深入的了解,可以深入了解一下函数编程相关的这四个接口。哪怕你只是看一下它的定义,也会有一种原来如此的感觉。

    作者简介:小姐姐味道  (xjjdog),一个不允许程序员走弯路的公众号。聚焦基础架构和Linux。十年架构,日百亿流量,与你探讨高并发世界,给你不一样的味道。我的个人微信xjjdog0,欢迎添加好友,进一步交流。

    近期热门文章

    996的乐趣,你是无法想象的魔幻现实主义,关爱神经衰弱

    《一切荒诞的傲慢,皆来源于认知》不要被标题给骗了,画面感十足的消遣文章

    《必看!java后端,亮剑诛仙》后端技术索引,中肯火爆。全网转载上百次。

    《学完这100多技术,能当架构师么?(非广告)》精准点评100多框架,帮你选型

    5770002e71279f4548f511136015a273.gif

    展开全文
  • 想要成为优秀的Linux运维工程师,要学习的Linux技术很多,并掌握扎实的Linux技能,那么Linux运维工作中,Linux系统安全最小原则到底是什么? 最小化原则对Linux系统安全来说非常重要,一般包括如下几个方面: 1.安装...
  • 首先,为什么要编制合并报表呢?比如甲公司购买了乙公司80%的股权,两者还是独立的公司,那么甲公司和乙公司各自都会有各自的财务报表,这个就叫做甲乙公司的个别财务报表,但实际上,由于甲公司已经控制了乙公司,...
  • 如果望文生义(很多网文也都爱按字面意思翻译成“先行发生”),那就南辕北辙了,Happens-Before 并不说前面一个操作发生在后续操作的前面,它真正要表达的:前面一个操作的结果对后续操作可见的。 就像有心灵...
  • 不添乱都好的了,去参加代码QC会议,感觉像听天书似的,昏昏入睡,而且看他们程序员吵的厉害,萌新瑟瑟发抖……那么当团队QC代码的时候,质量人员需要做什么呢?首先纠正一个事情,当团队已经开始QC了,你才开始有...
  • 最近要做一个“前端零基础的入门课程分享”,很多非前端同学可能只是知道 React 个前端框架,整体对 React 的理解还是很模糊,借此机会,分享一下我对 React 的理解。最重要的写在前面React一个前端UI库。我对...
  • 但很多人常常搞不清楚,究竟什么是抽象,以及如何进行抽象。今天我们就来谈谈抽象。 什么是抽象? 首先,抽象这个词在中文里可以作为动词也可以作为名词。作为动词的抽象就是指一种行为,这种行为的结果,就是作为...
  • 项目群管理到底什么?之七大原则|项目群管理转自项目管理者联盟  项目群管理的全景图项目管理者联盟  那项目群管理到底什么?接下来我们一起看下面这张图。这张图其实来源于英国的一个管理方法论,我们把它...
  • 大数据思维,到底是什么? 时光 目录 大数据思维,到底是什么? 1. 大数据本质 2. 大数据思维 3. 应用领域 4. 思维转变 1. 大数据本质 大数据实际上是营销的科学导向的自然演化,将不同行业或者说渠道所...
  • 在mysql教程中char与varchar的区别呢,都用来存储字符串的,只是他们的保存方式不一样罢了,char有固定的长度,而varchar属于可变长的字符类型。 char与varchar的区别 char (13)长度固定, 如'www.jb51.net' ...
  • 面向对象Java作为一门主流编程语言的重要特性,那么什么是面向对象? 面向对象和面向过程 什么是面向对象? 面向对象一种编程思想,一种思考问题的思维方式;在使用面向对象的思想时,必须要坚持先整体再...
  • DevOps一种非常重要的方法论,该方法将解决一些最大型问题的基本原则和实践恰如其分地融为一体,很好地解决了此类机构的软件开发项目中一种最令人感觉悲凉的失败要素:开发者和运维人员之间的混乱之墙。...
  • 什么是依赖倒置原则?假设我们设计一辆汽车:先设计轮子,然后根据轮子大小设计底盘,接着根据底盘设计车身,最后根据车身设计好整个汽车。这里就出现了一个“依赖”关系:汽车依赖车身,车身依赖底盘,底盘依赖轮子...
  • 自动化框架到底是什么

    千次阅读 2020-09-30 21:16:46
    接下来,让我从实践出发,介绍一下什么是自动化测试框架。 什么是框架? 让我们从一个例子出发,而不是直接提供一个框架的粗俗定义。你应该参加过研讨会/讲座/会议,参与者会被要求遵守一些指导原则: 参加者应...
  • 原名:内核与ramdisk到底是什么关系? 个人Notes: (1)有这个必要吗? --相当有!不然内核太大!不符“内核”原则。 (2)作用:“既要内核小,又要内核不带草”,解决“先有鸡还是先有蛋的问题”。 ...
  • (1)为什么会造成线程安全问题 在java中,一般有2个原因造成线程不安全:一存在共享数据(也称临界资源),二存在多条线程共同操作共享数据。 (2)判断一个线程是否安全的一个重要原则 是否有多线程访问可变的...
  • 但一直不知道组件到底是什么? 另外 平时 工作的时候 我们公司 的代码都是在数据实现层 try -catch 然后我也就是这么做的。但是我并不知道为什么要这么做。不知道web 对于异常有没有什么可遵循的规则
  • 什么是面向对象 面向对象一种软件开发方法。...OOP面向对象编程,面向对象编程一种编码范式或编码风格,以类或者对象作为组织代码的基本原则,并将封装、抽象、继承、多态作为软件设计与实现的基本...
  • 什么是微服务?为什么要用微服务? 微服务解决什么问题,又引入了什么问题? 使用微服务应该要遵循哪些原则什么样的情况你不应该使用微服务? (PS:因为市面上太多对如果使用微服务框架工具的教程,所以本篇只是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 958
精华内容 383
关键字:

原则到底是什么