<?xml version="1.0" encoding="utf-8" standalone="yes"?>

<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">

<channel>

<title>Programs on sin-coder</title>

<link>https://sin-coder.github.io/program/</link>

<description>Recent content in Programs on sin-coder</description>

<generator>Hugo -- gohugo.io</generator>

<language>en-us</language>

<lastBuildDate>Sat, 01 Feb 2020 16:08:30 +0800</lastBuildDate>

<atom:link href="https://sin-coder.github.io/program/index.xml" rel="self" type="application/rss+xml" />

<item>

<title>Python之美</title>

<link>https://sin-coder.github.io/program/beauty/</link>

<pubDate>Sat, 01 Feb 2020 16:08:30 +0800</pubDate>

<guid>https://sin-coder.github.io/program/beauty/</guid>

<description>Python之美 新建一个Python文件，写入下面语句 &amp;quot;import this&amp;quot; 执行下看看发生了什么

终端会打出这样的信息：

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&#39;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.</description>

</item>

<item>

<title>Python高级容器数据结构</title>

<link>https://sin-coder.github.io/program/pycollect/</link>

<pubDate>Sat, 28 Dec 2019 20:44:56 +0800</pubDate>

<guid>https://sin-coder.github.io/program/pycollect/</guid>

<description>Python高级容器数据结构 Python内置了4种数据类型，包括了list、tuple、set、dict，可以满足绝大部分程序使用的需求，但是在

某些场景下使用这些数据结构的效率是比较低的，比如set和dict的无序、list的插入和删除操作复杂度较高，

这时Python内建的collections模块就派上用场了，下面分别介绍几种典型的高级数据结构

一、orderedDict 在Python3.6之前的字典是无序的，orderedDict解决了这一问题，它是可以记住字典插入的顺序。那么

在3.6版本之后它是不是就没用了呢？不是的，orderedDict仍有它自己独特的一些特性是dict所无法达到的。

经典的dict非常擅长映射操作，而orderedDict比较擅长重新排序操作，适合用于实现LRU算法，下面介

绍其典型的方法

popitem（last = True）： 有序字典的popitem（）方法移除并返回一个（key,value）键值对；如果last值为真 则按照后进先出的顺序返回键值对；否则就按照先进先出的顺序返回键值对

move_to_end（key，last = True）： 将key移动到有序字典的任一端，如果last值为真，则将元素移至末尾， 否则则将元素移至开头，如果key不存在将会触发keyError

具有reversed()的方法，可以返回一个反向的迭代器

注意，orderedDict还有一个特性，如果新条目覆盖现有的条目，则原始插入位置将更改并移至末尾

基于这些特性我们可以非常方便的实现一个LRU

class LRU(OrderedDict): def __init__(self,maxsize = 128): self.maxsize = maxsize def __getitem__(self,key): if super().__getitem__(key): self.move_to_end(key) return value else: return None def __setitem__(self,key,value): super().__setitem__(key,value) if len(self) &amp;gt; self.maxsize: #获取开头的元素 iter()函数用来生成一个迭代器，next()返回迭代器中的下一项 oldest = next(iter(self)) del self[oldest] #删除开头的对象 二、deque Python中的list可以用作队列，也可以被用作栈，但是它底层是基于数组实现的，查找容易，但是插入和删</description>

</item>

<item>

<title>Python中的魔法方法</title>

<link>https://sin-coder.github.io/program/magic/</link>

<pubDate>Tue, 24 Dec 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/magic/</guid>

<description>Python中的魔法方法 一、什么是Python的魔法方法？ 魔法方法就是Python的内置方法，不需要主动调用，存在的目的就是给Python的解释器进行调用，几乎每个

魔法方法都有一个对应的内置函数或者运算符，它们经常是使用两个下划线包围来命名的，最为常见的就是

__ init __方法了。总的来说魔法方法就是让我们对类添加魔法的特殊方法（说跟没有说一样）

二、常见的魔法方法 1.构造方法 最为常用的魔法方法就是__ init __方法了，我们可以使用它来指明一个对象初始化的行为。实际上，

当我们再实例化对象时，__ init __方法并不是第一个被调用的方法。事实上应该是new方法，当这个对

象的生命周期结束的时候，__ del __方法会被调用。下面具体阐述

（1）__ new __(cls,[....])

__ new __是对象实例化第一个调用的方法，它只取下cls参数并把其他的参数传递给init方法，它很少使用

（2）__ init __(self,[....])

这是类的初始化方法，它能获取任何传给构造器的参数，这个方法在类的定义中使用到的是最多的

（3）__ del __(self)

new和init都是对象的构造器，__ del __是对象的销毁器，它不是实现了语句del x,而是定义了对象被垃圾

回收时的行为。当对象需要销毁做一些处理的时候这个方法很有用，比如socket对象、文件对象。但是当

Python解释器退出但对象仍然存活的时候，__ del __并不会执行，所以要及时地手工清理对象

下面是一个示例：

from os.path import join class FileObject: #文件对象的装饰类，用来保证文件被删除时能够正确关闭 def __init__(self,filepath = &#39;~&#39;,filename = &#39;sample.txt&#39;): self.file = open(join(filepath,filename),&#39;r+&#39;) def __del__(self): self.file.close() del self.file 2.</description>

</item>

<item>

<title>Java面向对象之接口</title>

<link>https://sin-coder.github.io/program/javaintf/</link>

<pubDate>Sun, 22 Dec 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/javaintf/</guid>

<description>Java面向对象和接口 在Java编程语言中接口是一个抽象类型，是抽象方法的结合，一个类通过继承接口的方法来继承接口的

抽象方法；除非实现接口的类是抽象类，否则该类要实现接口中的所有方法；接口无法被实例化，但是可以

被实现；在Java中，接口类型可以用来声明一个变量

一、接口和类的异同 1.接口和类的相似点 一个接口可以有多个方法

接口文件保存在.java文件中，文件名使用接口名

接口的字节码文件保存在.class文件中

接口相应的字节码文件必须在与包名称匹配的目录中

2.接口和类的主要区别 接口不能用于实例化对象

接口没有构造方法

接口的所有方法必须是抽象方法

接口不能包含成员变量，除了static和final变量

接口可以被类继承或者实现

3.接口特性 接口中的方法会被隐式地指定为public abstract

接口可以含有变量，但是会被隐式地指定为public static final

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

二、接口的操作 1.接口的声明 [可见度] interface 接口名称 [extends 其他的接口名]{ //声明变量 //声明方法 } 2.接口的实现 类使用implements关键字来实现接口，类声明中，implements关键字放在class声明后

...implements 接口名称[,其他接口名称,.....] 类实现接口的时候必须实现接口的所有方法，否则就要被定义为抽象类

重写接口中声明的方法时，有以下要求

类实现接口中的方法时，不能抛出强制性的异常，只能在接口中，或者继承接口的抽象类中抛出

类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型</description>

</item>

<item>

<title>Java中的包(Package)</title>

<link>https://sin-coder.github.io/program/package/</link>

<pubDate>Sat, 21 Dec 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/package/</guid>

<description>Java中的包（Package） 一、Java中包的作用 在Java中为了更好的组织类，提供了包机制，可以看成是区别类名的命名空间，主要作用如下：

把功能相似或者相关的类或接口组织在同一个包中，方便类的查找和使用

包采用了类似文件夹一样的树形目录的存储方式，同一个包中类的名字是不同的，不同包中类的名字可以是

相同的，当同时调用不同包中相同类名的类时，应该加上包名加以区分，避免冲突

包限定了访问权限，拥有包访问权限的类才能访问某个包中的类 二、包的使用 1.包语句的格式 包语句的语法格式为

package pkg1[.pkg2[.pkg3]] //示例如下 package net.java.util; //注意包声明语句后有分号 public class Test{} //那么这个文件的保存路径应该是这样的：net/java/util/Test.java 一个包可以定义为一组相互联系的类型，为这些类型提供访问保护和命名空间管理的功能；在实际的应用

中，可以将自己完成的一组类或者接口等打包，方便管理和使用

2.创建包 包声明应该在源文件的第一行，每个源文件只能有一个包的声明，这个文件中的每个类型都应用于它；如

果一个源文件没有包的声明，那么其中的类都将被放到一个无名的包中，创建包的包名应该最好使用小写的

3.使用包 为了能够使用某一个包的成员，需要在Java程序中明确导入该包，使用import语句即可完成；

在Java源文件中的import语句应位于package语句之后，所有类的定义之前；格式如下：

import package1[.package2...](classname|*); 如果在一个包中一个类想要使用本包中的任何一个类，包名是可以忽略的

值得注意的是import是导入包所包含的类，而不能导入包，通常情况下，我们也不是只导入包中的某个类

而是导入包下所有的类；Java编译器默认为所有的Java程序导入了JDK中java.lang包中的所有类，其中定义了

一些常用的类，如Objetc、Math等，因此我们可以直接使用这些类而不必显示导入，当使用其他类时必须导入

并且import实际上导入的是每一个类的.class文件，并不是.java类型的文件

4.Java中类的搜索路径 在安装JDK时，我们已经设置了环境变量CLASSPATH，在Windos下的cmd中可以通过set命令查看

#一个CLASSPATH可能包含好几个路径，多路径应该使用分割符进行分开 C:\Users\Administrator&amp;gt;set CLASSPATH CLASSPATH=.;C:\Program Files\Java\jdk1.8.0_91\lib; C:\Program Files\Java\jdk1.</description>

</item>

<item>

<title>Java面向对象之抽象类</title>

<link>https://sin-coder.github.io/program/abstract/</link>

<pubDate>Sat, 21 Dec 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/abstract/</guid>

<description> Java面向对象之抽象类 面向对象的设计原因中所有的对象都是通过类来进行描绘的，但是并不是所有的类都是用来描述对象的，

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的就是抽象类

抽象类正常类最大的区别就是不能实例化对象，所以抽象类必须被继承，才能被使用；但是抽象类的其

它功能如：成员变量、成员方法和构造方法依然存在

一、抽象类的定义和使用 在Java语言中使用abstract class来定义抽象类，而且只能通过其他类来继承抽象类

//文件名为Test.java public abstract class Test{} //文件名为smallTest public class smallTest extends Test{} 二、抽象方法 抽象方法必须是一个特别的成员方法，该方法的具体实现是由它的子类确定的，那么可以在父类中声明

该方法是一个抽象方法；而且抽象方法所在的类一定是抽象类；

abstract关键词同样可以用来声明抽象方法，抽象方法只包含一个方法名而没有方法体；抽象方法没有定

义，方法名后面直接跟上一个分号，而不是花括号

public abstract class Employee{ public abstract int getMsg();//抽象方法 } 任何子类必须重写父类的抽象方法，或者声明自身是一个抽象类；

三、其他规定 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类

抽象类中的抽象方法只是声明，不包含方法体，即不给出方法的具体实现

构造方法和类方法（用static方法修饰的方法）不能声明为抽象的方法

</description>

</item>

<item>

<title>Python中的面向对象</title>

<link>https://sin-coder.github.io/program/oop/</link>

<pubDate>Fri, 20 Dec 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/oop/</guid>

<description>Python中的面向对象 说起面向对象，大家都不陌生，常用的Java就是一门面向对象的语言，但是很少人会觉得Python是一门

面向对象的语言，习惯使用Python的人更会觉得它有点像面向过程的语言，毕竟那流程化的操作让人觉得

是从哪里冒出来的对象啊，今天是时候为Python平反了，Python和Java都是面向对象的语言

但是我们所说的面向对象通常指的是编程的一种设计思想，更加准确的说应该是Python和Java都是支持

面向对象的语言，而且Python和Java都不是纯碎的面向对象，当然我们也不必过于纠结什么是纯碎。这篇

讲解一些Python中面向对象的一些特性

一、面向对象的主要特性 在面向对象编程中，函数和变量被进一步的封装成类，类是程序的基本元素，类和类的实例是面向对象

的核心概念，面向对象的主要编程框架如下：

导入各种外部库

设计各种全局变量

决定你要的类

给每个类提供完整的一组操作

明确的使用继承来表现不同类的特点

根据需要决定是否要写一个mian函数作为程序入口

面向对象中一些基础的概念是多态、继承、封装、抽象、类、对象、实例、方法、重载，下面对一些主要

的概念稍作解释

类变量：所有实例公有的变量，类变量定义在类中，但是在方法体之外

实例变量：是实例本身所拥有的变量，每个实例变量在内存都是不一样的

静态方法：不需要实例化就可以由类指向的方法

类方法：类方法是将类本身作为对象进行操作的方法

重写：从父类继承的方法不能满足子类的需求，这个过程称为override

封装：将内部实现包装起来，对外透明

继承：子类继承父类的变量和方法

多态：根据对象类型的不同以不同的方式进行处理

二、类与对象 1.类和对象的创建 Python中类和对象的创建是这样进行的

class test: classVar = &amp;quot;Test&amp;quot; #类变量 def __init__(self,para1,para2): #理解为构造函数 self.para1 = para1 self.</description>

</item>

<item>

<title>Java面向对象总结</title>

<link>https://sin-coder.github.io/program/javaoop/</link>

<pubDate>Fri, 20 Dec 2019 00:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/javaoop/</guid>

<description>Java面向对象总结 一、类和对象 Java中的类可以包含局部变量、成员变量、类变量

局部变量：在方法、构造方法中定义的变量

成员变量：定义在类中，方法体之外的变量。可以被类中的各种方法使用

类变量：定义在各种类中，方法体之外。必须声明为static类型

构造方法 : 如果没有显式地为类定义构造方法，Java编译器会为该类提供一个默认的构造方法。在创

建一个对象的时候，至少要调用一个构造方法

Java中import语句执行的过程，import语句主要是提供一个合理的路径，使得编译器能够找到某个类

Java中的类有若干访问级别：抽象类、final类、内部类、匿名类

Java中强制要求类名和文件名相同，是因为在引用其他类的时候无需显式的声明，在编译时会根据类

名去寻找同名文件

Java中包的作用就是防止名字相同的类产生冲突。编译器在编译时直接根据package指定的信息直接

将生成的class文件生成到对应文件的目录中，比如package com.util.Test，编译器就将生成的.java文件

放于./com/util/Test/这个目录下

import的作用是为了简化使用package之后的实例化的代码，就是将new java.net.Socket()简化成

new Socket（）

一个Java文件中只能包含一个Public的类

this是指向对象本身的指针，super是指向父类对象的一个指针

new关键字的一个作用，为对象分配内存空间、引起对象构造方法的调用，为对象返回一个引用

对象和引用的区别，对象是具体的一个实例，使用new创建一个对象时，是在堆内存中开辟一块空间

引用名称存放的对象的地址

二、Java中的继承 在Java中可以通过extends关键字可以声明一个类是从另外一个类继承而来的

Java中不支持多继承，但是支持多重继承

子类可以拥有父类非private的属性和方法，子类可以用自己的方式实现父类的方法

Java中所有的类都是继承于java.lang.Object这个祖先类，如果一个类没有显示继承，则默认情况

下继承Object 祖先类

implements关键字可以变相的使Java具有多继承的特性，同时实现多个接口

final关键字声明类可以把类定义为不能继承的，即是最终类。或者用于修饰方法，该方法不能被子类重写

final修饰类中的属性或者变量时，无论是基本类型还是引用类型

Java文件被编译成class文件时，在子类的所有构造函数中的第一行会默认添加super()语句，在执行子类

的构造函数前，总是会先执行父类的构造函数，执行父类构造函数的语句只能放在函数内语句的首句，不然

报错；如果父类不含默认的构造函数，子类中的super()语句就会执行失败

Object类是所有类的根父类，可以用于参数的传递，当你不清楚函数需要的参数是什么类型的，可以使

用Object类来代替，Object可以代替任何类

三、重写和重载 1.重写（Override） 重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和参数都不能变</description>

</item>

<item>

<title>Java和Python中如何使用大顶堆</title>

<link>https://sin-coder.github.io/program/javapqueue/</link>

<pubDate>Tue, 03 Dec 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/javapqueue/</guid>

<description>Java和Python中如何使用大顶堆 在数据结构之容器的那篇文章中，我们对于优先队列即堆这种数据结构的底层实现进行了剖析，在实际的

应用中我们不必自己去实现一个堆，主流的编程语言都提供了相关的集合模块，比如Java中的PriorityQueue

类，Python中的heapq模块。但是这两种语言中实现的堆都是小顶堆（根节点的元素小于左右节点元素的值），

当需要使用大顶堆时该如何解决呢？比如典型的最大的K个元素需要用小顶堆解决，但是最小的K个元素不就

是需要使用一个大顶堆来解决了吗！

具体的解决方案如下：

一、通用的方法: 取反 通用的解决方法就是跟语言没有关系的解法，想要构造一个大顶堆，只要保证根节点大于左右节点即可，

所以我们可以将数据取成相反数再添加到小顶堆中去，取出时再对数据进行取反即可实现大顶堆的效果

二、针对Java的方法 优先队列中存放的是基本数据类型的包装类（Integer、Long）或者自定义的包装类。对于基本数据类型

的包装器类，优先队列中元素默认排列顺序是升序排列的，也就是说是小顶堆，但是既然是默认的就可以进

行更改。此外，对于自定义的类来说，需要自己定义比较器，比如：

//自定义比较器，降序排列 public static Comparator&amp;lt;Integer&amp;gt; cmp = new Comparator&amp;lt;Integer&amp;gt;(){ public int compare(Integer e1,Integer e2){ return e2 - e1; } } //声明对象时 Queue&amp;lt;Integer&amp;gt; pqueue = new PriorityQueue&amp;lt;Integer&amp;gt;(); //不使用比较器，默认升序排列，即小顶堆 Queue&amp;lt;Integer&amp;gt; pqueue = new PriorityQueue&amp;lt;Integer&amp;gt;(cmp); //使用比较器，降序排列，即为大顶堆 //比较器升降序的声明 Comparator&amp;lt;Object&amp;gt; cmp = new Comparator&amp;lt;Object&amp;gt;(){ public int compare(Object o1,Object o2){ return o1 - o2 //升序 return o2 - o1 //降序 } } 所以在实际解决问题的过程中如果需要使用大顶堆可以这样声明</description>

</item>

<item>

<title>Python中的sort()和sorted</title>

<link>https://sin-coder.github.io/program/sort_sorted/</link>

<pubDate>Thu, 28 Nov 2019 21:14:28 +0800</pubDate>

<guid>https://sin-coder.github.io/program/sort_sorted/</guid>

<description>Python中sort和sorted的区别和使用 一、函数介绍 sort函数和sorted函数的功能是非常强大的，在有些leetcode题目中，使用了这些函数，几行代码就可以

搞定了（只要你不怕被面试官打死），下面我们先看看这两个函数的介绍吧

&amp;gt;&amp;gt;&amp;gt; help(list.sort) Help on method_descriptor: sort(self, /, *, key=None, reverse=False) Stable sort *IN PLACE*. #inplace &amp;gt;&amp;gt;&amp;gt; help(sorted) Help on built-in function sorted in module builtins: sorted(iterable, /, *, key=None, reverse=False) Return a new list containing all items from the iterable in ascending order. #new list A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.</description>

</item>

</channel>

</rss>