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

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

<channel>

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

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

<description>Recent content in Python 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/tags/python/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>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和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>

<item>

<title>数据结构之容器</title>

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

<pubDate>Thu, 28 Nov 2019 17:01:10 +0800</pubDate>

<guid>https://sin-coder.github.io/datastructure/container/</guid>

<description>一、概述 1.什么是数据结构中的容器？ 容器是一种把多个元素组织在一起的数据结构，也可以理解为一种可以包含其他类型对象作为元素的

的对象。容器是仅仅用来存放数据的，本身没有取出元素这种能力，大多数情况下是通过可迭代对象来

操作容器

容器这种数据结构在各种编程语言中都有相应的实现，比如我们经常会比较熟悉的C++的标准模板库

（Standard Template Library，STL）、Java的集合框架（Java Collections Framework，JCF）、而在

Python中更是将容器类型的数据结构作为其基本数据类型、Go语言也有内建的容器和相应的标准库，

本篇博客便是在总结各种容器使用及原理的基础上，对Java、Python中相同的类型的容器做一个横向的

对比，以便于日后的总结和复习

2.Java集合框架简介 （1）泛型的机制

Java中的容器就是可以容纳其他Java对象的对象，且Java容器中只能存放对象，对于一些基本的数据

类型（比如int、long、float、double等），需要将其包装成对象类型之后（Interger、Long、Float、Double

等）才能放到容器里，很多时候拆包装和解包装使能够自动完成的

Java容器能够容纳任何类型的对象，表面上是通过泛型机制完成的。事实上，所有容器的内部存放的都

是Object类的对象，所有的对象都是Object类型的子类。泛型机制只是简化了编程，由编译器自动帮助我们

完成了强制类型的转换而已，示例代码如下

ArrayList&amp;lt;String&amp;gt; list = new ArrayList&amp;lt;String&amp;gt;(); //参数化类型 list.add(new String(&amp;quot;csuyzz&amp;quot;)); String name = list,get(0); //容器中存放的Object类的对象隐式转换成为String类型的对象 此外，Java里的对象都在堆上，且对象只能通过引用（reference）来访问，容器里存放的其实是对

象的引用而不是对象的本身

（2）接口和实现（Interfaces and Implementations）

在Java 的集合框架中共定义了14种容器的接口，关系图如下所示，Map接口没有继承自Collection的

接口，因为Map接口是关联式的容器而不是集合，但也可以从Map转换到Coolection；Stack已经被Deque

所取代

接口的实现如下表所示

ImplementationsHash TableResizable ArrayBalanced TreeLinked ListHash Table + Linked ListInterfacesSetHashSetTreeSetLinkedHashSetListArrayListLinkedListDequeArrayDequeLinkedListMapHashMapTreeMapLinkedHashMap &amp;gt; (3) 迭代器</description>

</item>

<item>

<title>常见数据结构的定义</title>

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

<pubDate>Fri, 15 Nov 2019 14:01:10 +0800</pubDate>

<guid>https://sin-coder.github.io/datastructure/defindatastructure/</guid>

<description>常见数据结构的定义 一、链表（以singly-linked list为例） 1.Java public class ListNode{ int val; ListNode next; //如果是双向链表，则会为left or right ListNode(int x) { val = x; next = null; } } 2.Python class ListNode: def __init__(self,x): self.val = x self.next = Node 3.C struct ListNode{ int val; struct ListNode *next; }; 4.Go type ListNode struct{ Val int Next *ListNode } 二、二叉树（Binary Tree Node） 1.Java //Definition for a binary tree node public class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int x){val = x;} } 2.</description>

</item>

</channel>

</rss>