杰智 × BLOG

许家印被抓要玩完

Wed, 13 Dec 2023 11:17:13 +0800

许家印被抓要玩完

千百年来少见的怪现象已显现

当权者抓的不情不愿

寄望他还债填坑保交楼

以免自己来接盘

购房者也左右为难

不抓他不知要等到猴年马月

抓了他又等到何夕何年？

要说他的波及面有多宽

试问还有几个城没有恒大楼盘？

深陷囹圄心释然

却定有人身卧裘榻夜难眠

拔个萝卜带点泥那也太简单

盘根错节，剪不断理还乱

且看，且看

2023初雪：清晨的雪景，唤醒的心情

Tue, 12 Dec 2023 09:49:25 +0800

虽生在北方，每年冬日的雪，仍令人欣喜，期盼!

大雪节气已过，却还未见半片雪花。终于，早晨预报将有暴雪天气，到了午后却变为中雪了，还好吧，总归是有雪的，可直到夜幕来临，也只是哩哩啦啦的雨点落下。

寒风开始呼啸，略感遗憾中睡下，一夜安睡，竟破例的早早醒来，天刚刚蒙蒙亮，翻身下床到窗前，啊！下雪了。

穿戴暖和下楼，白茫茫的一片冲进眼帘。很大的雪呀！比印象中的中雪要大，雪地上已有了些零零散散的脚印?，天空中仍飞舞着雪花，大口的呼吸，些许清凉，些许舒畅！儿时沉睡的快乐记忆在一点点唤醒，我在小区里快乐的游走！

做学问的境界

Mon, 26 Dec 2022 09:05:37 +0800

做学问的八层境界

梁漱溟 1928年在广州中山大学的讲演

所谓学问，就是对问题说得出道理，有自己的想法。我从来没有想过要做学问，走上现在这条路，只是因为我喜欢提问题。大约从十四岁开始，总有问题占据在我的心里，从一个问题转入另一个问题，一直想如何解答，解答不完就欲罢不能，就一路走了下来。提得出问题，然后想要解决它，这大概是做学问的起点吧。以下分八层来说明我走的一条路：

第一层境界：形成主见

用心想一个问题，便会对这个问题有主见，形成自己的判断。

说是主见，称之为偏见亦可。我们的主见也许是很浅薄的，但即使浅薄，也终究是自己的意见。

有所见便将之视为普遍的道理，因执于其所见而极端地排斥旁人的意见，不承认有两个或两个以上的道理。学问不学问，并不在读书之多少。

第二层境界：发现不能解释的事情

没有学问的人并非肚里没有道理，脑里没有理论，而是心里没有问题。

将古今中外的学问都学了，道理有了一大堆，问题却没有一个，就成了莫可奈何的绝物。

有主见，才有自己；有自己，才有旁人，才会发觉前后左右都是与我意见不同的人。

这时候，你感觉到种种冲突，种种矛盾，种种没有道理，又种种有道理。于是就不得不用心思考。面对各种问题，自己说不出道理，不甘心随便跟别人说，也不敢轻易自信，这时就走上了求学问道的正确道路了。

第三层境界：融会贯通

从此以后，前人的主张、今人的言论，都不会轻易放过，稍有与自己不同之处，便知道加以注意。你看到与自己想法相同的，感到亲切；看到与自己想法不同的，感到隔膜。有不同，就非求解决不可；有隔膜，就非求了解不可。

于是，古人今人所曾用过的心思，慢慢融汇到自己，自己最初的一点主见，成为以后大学问的萌芽。从这点萌芽，你才可以吸收养料，才可以向上生枝发叶，向下入土生根。待得上边枝叶扶疏，下边根深蒂固，学问便成了。

这是读书唯一正确的方法，不然读书也没用处，会读书的人说话时，说他自己的话，不堆砌名词，不旁征博引；反之，引书越多的人越不会读书。

第四层境界：知不足

学然后知不足。只怕你不用心，用心之后，就知道要虚心了。自己当初一点浮浅见解，不足以解决问题。

学问的进步，不单是见解有进步，还表现在心思头脑锻炼得精密了，心气态度锻炼得谦虚了。心虚思密是求学的必要条件。

对于前人之学，总不要说自己都懂。因为自己觉得不懂，才可以除去一切浮见，虚心地先去了解它。两句话希望大家常常存记于心，第一，"担心他的出乎我之外"；第二，"担心我的出乎他之下"。

第五层境界：以简御繁

辨察愈密，追究愈深，零碎的知识，片段的见解，都没有了，心里全是一贯的系统，整个的组织。如此，就可以算成功了。到了这个时候，才能以简御繁，才可以学学问多而不觉得多。

凡有系统的思想，在心里都很简单，仿佛只有一两句话。所谓举重若轻，便即使是很复杂很沉重的宇宙，在手心里也是异常轻松的。

如果肩背上负着太多沉重的学问，那是不对的；如果当初觉得有什么，现在才晓得原来没有什么，那就对了。道理越看得明透，越觉得无话可说，还是一点不说的好。心里明白，口里讲不出来。

反过来说，学问浅的人说话愈多，思想不清楚的人名词越多。让一个没有学问的人看见，真要把他吓坏了！其实道理明透了，名词便可用，可不用，或随意拾用。

第六层境界：运用自如

有无学问在于能否解决问题。比如学武术的十八般武艺都学会了，表演起来五花八门很像个样，等到打仗对敌，轮刀上阵，却发现一套武艺白学了。

如果不能解决问题，那学问必是没到家。如果学问已经通了，就可以解决问题。真学问的人，学问可以完全归自己运用。假学问的人，学问在他手里完全不会用。

第七层境界：一览众山小

学问里面的甘苦都尝过了，再看旁人的见解主张，其中得失长短都能够看得出来。这个浅薄，那个到家，这个是什么分数，那个是什么程度，都知道得很清楚；因为自己从前也是这样，一切从深浅精粗的层次都曾经历过。

第八层境界：通透

思精理熟之后，心里就没有一点不透的了，讲出的每一句话都非常的晶亮透辟。

古之成大事业、大学问者必经过三种之境界。

清·王国维《人间词话》

“昨夜西风凋碧树，独上高楼，望尽天涯路。” 此第一境界也；

萧瑟的秋风中，游子登高望远，怀念亲人，见不到又音信难通，就如一名学者刚开始在学问时那种对知识的惆怅迷惘的心情跃然纸上。作为一个做学问者，首先要高瞻远瞩认清前人所走的路，也就是说，总结和学习前人的经验是做学问的起点。

出处：

“衣带渐宽终不悔，为伊消得人憔悴。”此第二境界也；

沉溺于热恋中的情人对爱情的执着，人消瘦了，但决不后悔，就如学者在追求知识的过程中所表现出一种认定了目标就呕心沥血孜孜以求的执着精神。作为一名做学问者，应深思熟虑，就象热恋中的情人那样热切、不惜一切的追求自己的目标。

出处：

“众里寻他千百度，蓦然回首，那人却在灯火阑珊处。”此第三境界也。

没有千百度的上下求索，不会有瞬间的顿悟和理解。作为一个做学问者，只有在学习和苦苦钻研的基础上，才能够功到自然成，一朝顿悟，发前人所未发之秘，辟前人所未辟之境。

出处：

“看山是山，看山不是山，看山还是山。此人生三大境界”

唐·青原惟信禅师《指月录》

这就是说一个人的人生之初纯洁无暇，初识世界，一切都是新鲜的，眼睛看见什么就是什么，人家告诉他这是山，他就认识了山，告诉他这是水，他就认识了水。

随着年龄渐长，经历的世事渐多，就发现这个世界的问题了。这个世界的问题越来越多，越来越复杂，经常是黑白颠倒，是非混淆，无理走天下，有理寸步难行，好人无好报，恶人行千年。进入这个阶段，人是激情的，不平的，忧虑的，疑问的，警惕的，复杂的。人不愿意再轻易地相信什么。人在这个时候看山也感慨，看水也叹息，借古讽今，指桑骂槐。山自然不再是单纯的山，水自然不再是单纯的水。

通过”看山是山，看山不是山，看山还是山。三大境界”认识世界的三个层级，如下：

第一层：蒙昧状态

我们来到这个世界，看到这个世界一切都无比真实可信，相信我们眼见的就是全部。

第二层：认识真理

我们苦苦寻觅世界的真相，慢慢明白这个世界不过是虚幻的泡影。

第三层：开悟

明白了这份如泡影般的世界存在是有目的，之所以人不能看出其中的真相也是有目的，我们不要因为纠结这些而错过了世界本身的精彩，我们应该积极坦然的接受和拥抱这个世界，从中活出自己的乐趣和精彩。

出处：

原话出自青原惟信禅师《指月录》中。相关记载引用如下：吉州青原惟信禅师。上堂。老僧三十年前。未参禅时。见山是山。见水是水。及至后来亲见知识。有个入处。见山不是山。见水不是水。而今得个休歇处。依前见山祇是山。见水祇是水。大众。这三般见解。是同是别。有人缁素得出。许汝亲见老僧(更参三十年迥无入处在)。《指月录・卷二十八・六祖下第十四世》（明瞿汝稷）

佛教禅宗说法

执着于相。执着于空。空即空，相即相；空即相，相即空。

Python入门之面向对象编程(四)Python描述器详解

Tue, 04 Oct 2022 19:57:18 +0800

本文分为如下部分

引言——用@property批量使用的例子来引出描述器的功能
描述器的基本理论及简单实例
描述器的调用机制
描述器的细节
实例方法、静态方法和类方法的描述器原理
property装饰器的原理
描述器的应用
参考资料

引言

前面python面向对象的文章中我们讲到过，我们可以用@property装饰器将方法包装成属性，这样的属性，相比于其他属性有一个优点就是可以在对属性赋值时，进行变量检查，举例代码如下

class A:
    def __init__(self, name, score):
        self.name = name # 普通属性
        self._score = score
        
    @property
    def score(self):
        return self._score
    
    @score.setter
    def score(self, value):
        print('setting score here')
        if isinstance(value, int):
            self._score = value
        else:
            print('please input an int')
        
a = A('Bob',90)
a.name # 'Bob'
a.score # 90
a.name = 1
a.name # 1 ，名字本身不应该允许赋值为数字，但是这里无法控制其赋值
a.score = 83
a.score # 83，当赋值为数值型的时候，可以顺利运行
a.score = 'bob' # please input an int
a.score # 83，赋值为字符串时，score没有被改变

当我们有很多这样的属性时，如果每一个都去使用@property，代码就会过于冗余。如下

class A:
    def __init__(self, name, score, age):
        self.name = name # 普通属性
        self._score = score
        self._age = age
        
    @property
    def score(self):
        return self._score
    
    @score.setter
    def score(self, value):
        print('setting score here')
        if isinstance(value, int):
            self._score = value
        else:
            print('please input an int')
            
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self, value):
        print('setting age here')
        if isinstance(value, int):
            self._age = value
        else:
            print('please input an int')
            
a = A('Bob', 90, 20)

因为每一次检验的方法都是一样的，所以最好有方法可以批量实现这件事，只写一次if isinstance。描述器就可以用来实现这件事。

为了能够更清楚地理解描述器如何实现，我们先跳开这个话题，先讲一讲描述器的基本理论。

描述器基本理论及简单实例

描述器功能强大，应用广泛，它可以控制我们访问属性、方法的行为，是@property、super、静态方法、类方法、甚至属性、实例背后的实现机制，是一种比较底层的设计，因此理解起来也会有一些困难。

定义：从描述器的创建来说，一个类中定义了__get__、__set__、__delete__中的一个或几个，这个类的实例就可以叫做一个描述器。

为了能更真切地体会描述器是什么，我们先看一个最简单的例子，这个例子不实现什么功能，只是使用了描述器

# 创建一个描述器的类，它的实例就是一个描述器
# 这个类要有__get__  __set__ 这样的方法
# 这种类是当做工具使用的，不单独使用
class M:
    def __init__(self, x=1):
        self.x = x
        
    def __get__(self, instance, owner):
        return self.x
    
    def __set__(self, instance, value):
        self.x = value
        
# 调用描述器的类
class AA:
    m = M() # m就是一个描述器
    
aa = AA()
aa.m # 1
aa.m = 2
aa.m # 2

我们分析一下上面这个例子

创建aa实例和普通类没什么区别，我们从aa.m开始看
aa.m是aa实例调用了m这个类属性，然而这个类属性不是普通的值，而是一个描述器，所以我们从访问这个类属性变成了访问这个描述器
如果调用时得到的是一个描述器，python内部就会自动触发一套使用机制
访问的话自动触发描述器的__get__方法
修改设置的话就自动触发描述器的__set__方法
这里就是aa.m触发了__get__方法，得到的是self.x的值，在前面__init__中定义的为1
aa.m = 2则触发了__set__方法，赋的值2传到value参数之中，改变了self.x的值，所以下一次aa.m调用的值也改变了

进一步思考：当访问一个属性时，我们可以不直接给一个值，而是接一个描述器，让访问和修改设置时自动调用__get__方法和__set__方法。再在__get__方法和__set__方法中进行某种处理，就可以实现更改操作属性行为的目的。这就是描述器做的事情。

相信有的读者已经想到了，开头引言部分的例子，就是用描述器这样实现的。在讲具体如何实现之前，我们要先了解更多关于描述器的调用机制

描述器的调用机制

aa.m命令其实是查找m属性的过程，程序会先到哪里找，没有的话再到哪里找，这是有一个顺序的，说明访问顺序时需要用到__dict__方法。

先看下面的代码了解一下__dict__方法

class C:
    x = 1
    def __init__(self, y):
        self.y = y
        
    def fun(self):
        print(self.y)
        
c = C(2)
# 实例有哪些属性
print(c.__dict__) # {'y': 2}
# 类有什么属性
print(C.__dict__) # 里面有 x fun
print(type(c).__dict__) # 和上一条一样

print(vars(c)) # __dict__ 也可以用 vars 函数替代，功能完全相同

# 调用
c.fun() # 2
c.__dict__['y'] # 2
# type(c).__dict__['fun']() # 报错，说明函数不是这么调用的

__dict__方法返回的是一个字典，类和实例都可以调用，键就是类或实例所拥有的属性、方法，可以用这个字典访问属性，但是方法就不能这样直接访问，原因我们之后再说。

下面我们来说一下，当我们调用aa.m时的访问顺序

程序会先查找aa.__dict__['m'] 是否存在
不存在再到type(aa).__dict__['m']中查找
然后找type(aa)的父类
期间找到的是普通值就输出，如果找到的是一个描述器，则调用__get__方法

下面我们来看一下__get__方法的调用机制

class M:
    def __init__(self):
        self.x = 1
        
    def __get__(self, instance, owner):
        return self.x
    
    def __set__(self, instance, value):
        self.x = value
        
# 调用描述器的类
class AA:
    m = M() # m就是一个描述器
    n = 2
    def __init__(self, score):
        self.score = score
    
        
aa = AA(3)
print(aa.__dict__) # {'score': 3}
print(aa.score) # 3, 在 aa.__dict__ 中寻找，找到了score直接返回
print(aa.__dict__['score']) # 3, 上面的调用机制实际上是这样的

print(type(aa).__dict__) # 里面有n和m
print(aa.n) # 2, 在aa.__dict__中找不到n，于是到type(aa).__dict__中找到了n，并返回其值
print(type(aa).__dict__['n']) # 2, 其实是上面一条的调用机制

print(aa.m) # 1, 在aa.__dict__中找不到n，于是到type(aa).__dict__中找到了m
# m是一个描述器对象，于是调用__get__方法，将self.x的值返回，即1
print(type(aa).__dict__['m'].__get__(aa,AA)) # 1, 上面一条的调用方式是这样的
# __get__的定义中，除了self，还有instance和owner，其实分别表示的就是描述器所在的实例和类，这里的细节我们后文会讲

print('-'*20)
print(AA.m) # 1, 也是一样调用了描述器
print(AA.__dict__['m'].__get__(None, AA)) # 类相当于调用这个

此外还有特例，与描述器的种类有关

同时定义了__get__和__set__方法的描述器称为资料描述器
只定义了__get__的描述器称为非资料描述器
二者的区别是：当属性名和描述器名相同时，在访问这个同名属性时，如果是资料描述器就会先访问描述器，如果是非资料描述器就会先访问属性举例如下

# 既有__get__又有__set__，是一个资料描述器
class M:
    def __init__(self):
        self.x = 1
        
    def __get__(self, instance, owner):
        print('get m here') # 打印一些信息，看这个方法何时被调用
        return self.x
    
    def __set__(self, instance, value):
        print('set m here') # 打印一些信息，看这个方法何时被调用
        self.x = value + 1 # 这里设置一个+1来更清楚了解调用机制

# 只有__get__是一个非资料描述器
class N:
    def __init__(self):
        self.x = 1
        
    def __get__(self, instance, owner):
        print('get n here') # 打印一些信息，看这个方法何时被调用
        return self.x
        
# 调用描述器的类
class AA:
    m = M() # m就是一个描述器
    n = N()
    def __init__(self, m, n):
        self.m = m # 属性m和描述器m名字相同，调用时发生一些冲突
        self.n = n # 非资料描述器的情况，与m对比
    
aa = AA(2,5)
print(aa.__dict__) # 只有n没有m, 因为资料描述器同名时，不会访问到属性，会直接访问描述器，所以属性里就查不到m这个属性了
print(AA.__dict__) # m和n都有
print(aa.n) # 5, 非资料描述器同名时调用的是属性，为传入的5
print(AA.n) # 1, 如果是类来访问，就调用的是描述器，返回self.x的值

print(aa.m) # 3, 其实在aa=AA(2,5)创建实例时，进行了属性赋值，其中相当于进行了aa.m=2
# 但是aa调用m时却不是常规地调用属性m，而是资料描述器m
# 所以定义实例aa时，其实触发了m的__set__方法，将2传给value，self.x变成3
# aa.m调用时也访问的是描述器，返回self.x即3的结果
# 其实看打印信息也能看出什么时候调用了__get__和__set__

aa.m = 6 # 另外对属性赋值也是调用了m的__set__方法
print(aa.m) # 7，调用__get__方法

print('-'*20)
# 在代码中显式调用__get__方法
print(AA.__dict__['n'].__get__(None, AA)) # 1
print(AA.__dict__['n'].__get__(aa, AA)) # 1

注：要想制作一个只读的资料描述器，需要同时定义 __set__ 和 __get__,并在 __set__ 中引发一个 AttributeError 异常。定义一个引发异常的 __set__ 方法就足够让一个描述器成为资料描述器。

描述器的细节

本节分为如下两个部分

调用描述器的原理
__get__和__set__方法中的参数解释

1.首先是调用描述器的原理当调用一个属性，而属性指向一个描述器时，为什么就会去调用这个描述器呢，其实这是由object.__getattribute__()方法控制的，其中object是新式类定义时默认继承的类，即py2这么写的class(object)中的object。新定义的一个类继承了object类，也就继承了__getattribute__方法。当访问一个属性比如b.x时，会自动调用这个方法 __getattribute__()的定义如下

def __getattribute__(self, key):
    "Emulate type_getattro() in Objects/typeobject.c"
    v = object.__getattribute__(self, key)
    if hasattr(v, '__get__'):
        return v.__get__(None, self)
    return v

上面的定义显示，如果b.x是一个描述器对象，即能找到__get__方法，则会调用这个get方法，否则就使用普通的属性。如果在一个类中重写__getattribute__，将会改变描述器的行为，甚至将描述器这一功能关闭。

2.__get__和__set__方法中的参数解释官网中标明了这三个方法需要传入哪些参数，还有这些方法的返回结果是什么，如下所示

descr.__get__(self, obj, type=None) --> value
descr.__set__(self, obj, value) --> None
descr.__delete__(self, obj) --> None

我们要了解的就是self obj type value分别是什么看下面一个例子

class M:
    def __init__(self, name):
        self.name = name
        
    def __get__(self, obj, type):
        print('get第一个参数self: ', self.name)
        print('get第二个参数obj: ', obj.age)
        print('get第三个参数type: ', type.name)
        
    def __set__(self, obj, value):
        obj.__dict__[self.name] = value
        
class A:
    name = 'Bob'
    m = M('age')
    def __init__(self, age):
        self.age = age

a = A(20) # age是20
a.m
# get第一个参数self:  age
# get第二个参数obj:  20
# get第三个参数type:  Bob
a.m = 30
a.age # 30

总结如下

self是描述器类M中的实例
obj是调用描述器的类a中的实例
type是调用描述器的类A
value是对这个属性赋值时传入的值，即上面的30

上面的代码逻辑如下

a.m访问描述器，调用__get__方法
三次打印分别调用了m.name a.age A.name
a.m = 30调用了__set__方法，令a(即obj)的属性中的'age'(即M('age')这里传入的self.name)为30

实例方法、静态方法和类方法的描述器原理

本节说明访问些方法其实都访问的是描述器，并说明它们调用顺序是怎样的，以及类方法和静态方法描述器的python定义。

class B:
    @classmethod
    def print_classname(cls):
        print('Bob')
        
    @staticmethod
    def print_staticname():
        print('my name is bob')
        
    def print_name(self):
        print('this name')
        
b = B()
b.print_classname() # 调用类方法
b.print_staticname() # 调用静态方法
b.print_name() # 调用实例方法
print(B.__dict__) # 里面有实例方法、静态方法和类方法

# 但其实字典里的还不是可以直接调用的函数
print(B.__dict__['print_classname'])
print(b.print_classname) # 和上不一样
print(B.__dict__['print_staticname'])
print(b.print_staticname) # 和上不一样
print(B.__dict__['print_name'])
print(b.print_name) # 和上不一样

# <classmethod object at 0x0000024A92DA67B8>
# <bound method B.print_classname of <class '__main__.B'>>
# <staticmethod object at 0x0000024A92DA6860>
# <function B.print_staticname at 0x0000024A92D889D8>
# <function B.print_name at 0x0000024A92D88158>
# <bound method B.print_name of <__main__.B object at 0x0000024A92DA6828>>

上面结果表明，实例直接调用时，类方法和实例方法都是bound method，而静态方法是function。因为静态方法本身就是定义在类里面的函数，所以不属于方法范畴。

除此之外，由于实例直接调用后得到的结果可以直接接一个括号，当成函数来调用。而使用字典调用时，得到的结果和实例调用都不一样，所以它们是不可以直接接括号当成函数使用的。

其实从显示的结果我们可以看出，静态方法和类方法用字典调用得到的其实分别是staticmethod和classmethod两个类的对象，这两个类其实是定义描述器的类，所以用字典访问的两个方法得到的都是描述器对象。它们需要用一个__get__方法才可以在后面接括号当成函数调用。

而普通实例方法用字典调用得到的是一个function即函数，理论上是可以用括号直接调用的，但是调用时报错说少了self参数，其实它也是描述器对象，用通过__get__方法将self传入来调用

三种方法本质上调用__get__方法的情况展示如下

B.__dict__['print_classname'].__get__(None, B)()
B.__dict__['print_staticname'].__get__(None, B)()
B.__dict__['print_name'].__get__(b, B)()

print(B.__dict__['print_classname'].__get__(None, B))
print(B.__dict__['print_staticname'].__get__(None, B))

print(B.__dict__['print_name'])
print(B.__dict__['print_name'].__get__(None, B)) # 这是不传入实例即self的情况，和直接从字典调用结果相同，在python2中是一个unbound method
print(B.__dict__['print_name'].__get__(b, B))

# B.print_name() # 报错，说少输入一个self参数
# B.print_name(B()) # this name  输入实例即不会报错

所以说我们平常调用的方法都是本质上在调用描述器对象，访问描述器时自动调用__get__方法。

上面调用时注意到，前两个__get__的第一个参数都是None，而实例方法是一个b，这是因为实例方法需要具体的实例来调用而不能用类直接调用。在python2中，用类直接调用实例方法得到的是一个unbound method，用实例调用才是一个bound method，（在python3删除了unbound method的概念，改为function），而类方法本身就可以被类调用，所以参数是None时就是一个bound method了。所以说__get__的第一个参数使用b可以理解成方法的bound过程。

既然三种方法都是调用了描述器对象，那么这些对象都是各自类的实例，它们的类是如何定义的呢？python中这些类的定义是用底层的C语言实现的，为了理解其工作原理，这里展示一个用python语言实现classmethod装饰器的方法，（来源），即构建能产生类方法对应描述器对象的类。

class myclassmethod(object):
    def __init__(self, method):
        self.method = method
    def __get__(self, instance, cls):
        return lambda *args, **kw: self.method(cls, *args, **kw)
    
class Myclass:
    x = 3
    @myclassmethod
    def method(cls, a):
        print(cls.x+a)
        
m = Myclass()
Myclass.method(a=2)

下面我们分析一下上述代码

我们看到使用@myclassmethod装饰器达到的效果和使用@classmethod装饰器没有什么区别
首先定义了myclassmethod类，里面使用了__get__方法，所以它的实例会是一个描述器对象
将myclassmethod当做装饰器作用于method函数，根据装饰器的知识，相当于这样设置method=myclassmethod(method)
调用Myclass.method()时调用了改变后了的method方法，即myclassmethod(method)(a)
myclassmethod(method)这是myclassmethod类的一个实例，即一个描述器，此处访问于是调用__get__方法，返回一个匿名函数
__get__中其实是将owner(cls)部分传入method方法，因为methon在Myclass类中调用，这个owner也就是Myclass类。这一步其实是提前传入了method的第一个参数cls，后面的参数a由myclassmethod(method)(a)第二个括号调用
仔细分析上面的定义与调用过程，我们会发现，我们常常说的类方法第一个参数要是cls，其实是不对的，第一个参数是任意都可以，它只是占第一个位置，用于接收类实例引用类属性，随便换成任意变量都可以，用cls只是约定俗成的。比如下面的代码正常运行

class Myclass:
    x = 3
    @classmethod
    def method(b, a):
        print(b.x+a)
        
m = Myclass()
Myclass.method(a=2) # 5

下面看一下staticmethod类的等价python定义

class mystaticmethod:
    def __init__(self, callable):
        self.f = callable
    def __get__(self, obj, type=None):
        return self.f
    
class Myclass:
    x = 3
    @mystaticmethod
    def method(a, b):
        print(a + b)
        
m = Myclass()
m.method(a=2, b=3)

注：从源码角度来理解静态方法和类方法

静态方法相当于不自动传入实例对象作为方法的第一个参数，类方法相当于将默认传入的第一个参数由实例改为类
使用@classmethod后无论类调用还是实例调用，都会自动转入类作为第一个参数，不用手动传入就可以调用类属性，而没有@classmethod的需要手动传入类
既不用@classmethod也不用@staticmethod则类调用时不会自动传入参数，实例调用时自动传入实例作为第一个参数
所以说加@classmethod是为了更方便调用类属性，加@staticmethod是为了防止自动传入的实例的干扰
除此之外要说明一点：当属性和方法重名时，调用会自动访问属性，是因为这些方法调用的描述器都是非资料描述器。而当我们使用@property装饰器后，自动调用的就是新定义的get set方法，是因为@property装饰器是资料描述器

property装饰器的原理

到这里我们可以讲一讲开头提出的问题了，即@property装饰器是如何使用描述器实现的，调用机制是怎样的，如何通过描述器达到精简多次使用@property装饰器的问题。

首先要明确，property有两种调用形式，一种是用装饰器，一种是用类似函数的形式，下面会用引言中的例子分别说明两种形式的调用机制。

下面贴出property的等价python定义

class Property(object):
    "Emulate PyProperty_Type() in Objects/descrobject.c"

    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        if doc is None and fget is not None:
            doc = fget.__doc__
        self.__doc__ = doc

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise AttributeError("unreadable attribute")
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError("can't delete attribute")
        self.fdel(obj)

    def getter(self, fget):
        return type(self)(fget, self.fset, self.fdel, self.__doc__)

    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel, self.__doc__)

    def deleter(self, fdel):
        return type(self)(self.fget, self.fset, fdel, self.__doc__)

从上面的定义中我们可以看出，定义时分为两个部分，一个是__get__等方法的定义，另一部分是getter等方法的定义，同时注意到这个类要传入fget等三个函数作为属性。getter等方法的定义是为了让它可以完美地使用装饰器形式，我们先不看这一部分，先看看不是使用第一种即不使用装饰器的形式的调用机制。

# 类似函数的形式
class A:
    def __init__(self, name, score):
        self.name = name # 普通属性
        self.score = score
        
    def getscore(self):
        return self._score
    
    def setscore(self, value):
        print('setting score here')
        if isinstance(value, int):
            self._score = value
        else:
            print('please input an int')
            
    score = property(getscore, setscore)
        
a = A('Bob',90)
a.name # 'Bob'
a.score # 90
a.score = 'bob' # please input an int

分析上述调用score的过程

初始化时即开始访问score，发现有两个选项，一个是属性，另一个是property(getscore, setscore)对象，因为后者中定义了__get__与__set__方法，因此是一个资料描述器，具有比属性更高的优先级，所以这里就访问了描述器
因为初始化时是对属性进行设置，所以自动调用了描述器的__set__方法
__set__中对fset属性进行检查，这里即传入的setscore，不是None，所以调用了fset即setscore方法，这就实现了设置属性时使用自定义函数进行检查的目的
__get__也是一样，查询score时，调用__get__方法，触发了getscore方法

下面是另一种使用property的方法

# 装饰器形式，即引言中的形式
class A:
    def __init__(self, name, score):
        self.name = name # 普通属性
        self.score = score
        
    @property
    def score(self):
        print('getting score here')
        return self._score
    
    @score.setter
    def score(self, value):
        print('setting score here')
        if isinstance(value, int):
            self._score = value
        else:
            print('please input an int')
        
a = A('Bob',90)
# a.name # 'Bob'
# a.score # 90
# a.score = 'bob' # please input an int

下面进行分析

在第一种使用方法中，是将函数作为传入property中，所以可以想到是否可以用装饰器来封装
get部分很简单，访问score时，加上装饰器变成访问property(score)这个描述器，这个score也作为fget参数传入__get__中指定调用时的操作
而set部分就不行了，于是有了setter等方法的定义
使用了property和setter装饰器的两个方法的命名都还是score，一般同名的方法后面的会覆盖前面的，所以调用时调用的是后面的setter装饰器处理过的score，是以如果两个装饰器定义的位置调换，将无法进行属性赋值操作。
而调用setter装饰器的score时，面临一个问题，装饰器score.setter是什么呢？是score的setter方法，而score是什么呢，不是下面定义的这个score，因为那个score只相当于参数传入。自动向其他位置寻找有没有现成的score，发现了一个，是property修饰过的score，这是个描述器，根据property的定义，里面确实有一个setter方法，返回的是property类传入fset后的结果，还是一个描述器，这个描述器传入了fget和fset，这就是最新的score了，以后实例只要调用或修改score，使用的都是这个描述器
如果还有del则装饰器中的score找到的是setter处理过的score，最新的score就会是三个函数都传入的score
对最新的score的调用及赋值删除都跟前面一样了

property的原理就讲到这里，从它的定义我们可以知道它其实就是将我们设置的检查等函数传入get set等方法中，让我们可以自由对属性进行操作。它是一个框架，让我们可以方便传入其他操作，当很多对象都要进行相同操作的话，重复就是难免的。如果想要避免重复，只有自己写一个类似property的框架，这个框架不是传入我们希望的操作了，而是就把这些操作放在框架里面，这个框架因为只能实现一种操作而不具有普适性，但是却能大大减少当前问题代码重复问题

下面使用描述器定义了Checkint类之后，会发现A类简洁了非常多

class Checkint:
    
    def __init__(self, name):
        self.name = name
        
    def __get__(self, instance, owner):
        if instance is None:
            return self
        else:
            return instance.__dict__[self.name]
        
    def __set__(self, instance, value):
        if isinstance(value, int):
            instance.__dict__[self.name] = value
        else:
            print('please input an integer')

# 类似函数的形式
class A:
    score = Checkint('score')
    age = Checkint('age')
    
    def __init__(self, name, score, age):
        self.name = name # 普通属性
        self.score = score
        self.age = age
        
a = A('Bob', 90, 30)
a.name # 'Bob'
a.score # 90
# a.score = 'bob' # please input an int
# a.age='a' # please input an integer

描述器的应用

因为我本人也刚刚学描述器不久，对它的应用还不是非常了解，下面只列举我现在能想到的它有什么用，以后如果想到其他的再补充

首先是上文提到的，它是实例方法、静态方法、类方法、property的实现原理

当访问属性、赋值属性、删除属性，出现冗余操作，或者苦思无法找到答案时，可以求助于描述器

具体使用1：缓存。比如调用一个类的方法要计算比较长的时间，这个结果还会被其他方法反复使用，我们不想每次使用和这个相关的函数都要把这个方法重新运行一遍，于是可以设计出第一次计算后将结果缓存下来，以后调用都使用存下来的结果。只要使用描述器在__get__方法中，在判断语句下，obj.__dict__[self.name] = value。这样每次再调用这个方法都会从这个字典中取得值，而不是重新运行这个方法。

python3.6以后字典有序的原理

Wed, 31 Aug 2022 23:03:57 +0800

在Python 3.5（含）以前，字典是不能保证顺序的，键值对A先插入字典，键值对B后插入字典，但是当你打印字典的Keys列表时，你会发现B可能在A的前面。

但是从Python 3.6开始，字典是变成有顺序的了。你先插入键值对A，后插入键值对B，那么当你打印Keys列表的时候，你就会发现B在A的后面。

不仅如此，从Python 3.6开始，下面的三种遍历操作，效率要高于Python 3.5之前：

for key in 字典
for value in 字典.values()
for key, value in 字典.items()

从Python 3.6开始，字典占用内存空间的大小，视字典里面键值对的个数，只有原来的30%~95%。

Python 3.6到底对字典做了什么优化呢？为了说明这个问题，我们需要先来说一说，在Python 3.5（含）之前，字典的底层原理。

当我们初始化一个空字典的时候，CPython的底层会初始化一个二维数组，这个数组有8行，3列，如下面的示意图所示：

my_dict = {}
'''
此时的内存示意图
[[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---]]
'''

现在，我们往字典里面添加一个数据：

my_dict['name'] = 'kingname'
'''
此时的内存示意图
[[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[1278649844881305901, 指向name的指针, 指向kingname的指针],
[---, ---, ---],
[---, ---, ---]]
'''

假设在某一个运行时里面，hash(‘name’)的值为1278649844881305901。现在我们要把这个数对8取余数：

>>> 1278649844881305901 % 8
5

余数为5，那么就把它放在刚刚初始化的二维数组中，下标为5的这一行。由于name和kingname是两个字符串，所以底层C语言会使用两个字符串变量存放这两个值，然后得到他们对应的指针。于是，我们这个二维数组下标为5的这一行，第一个值为name的hash值，第二个值为name这个字符串所在的内存的地址（指针就是内存地址），第三个值为kingname这个字符串所在的内存的地址。

现在，我们再来插入两个键值对：

my_dict['age'] = 26
my_dict['salary'] = 999999
'''
此时的内存示意图
[[-4234469173262486640, 指向salary的指针, 指向999999的指针],
[1545085610920597121, 执行age的指针, 指向26的指针],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[1278649844881305901, 指向name的指针, 指向kingname的指针],
[---, ---, ---],
[---, ---, ---]]
'''

那么字典怎么读取数据呢？首先假设我们要读取age对应的值。

此时，Python先计算在当前运行时下面，age对应的Hash值是多少

>>> hash('age')
1545085610920597121

然后对8取余数

当你要循环遍历字典的Key的时候，Python底层会遍历这个二维数组，如果当前行有数据，那么就返回Key指针对应的内存里面的值。如果当前行没有数据，那么就跳过。所以总是会遍历整个二位数组的每一行。

每一行有三列，每一列占用8byte的内存空间，所以每一行会占用24byte的内存空间。

由于Hash值取余数以后，余数可大可小，所以字典的Key并不是按照插入的顺序存放的。

在Python 3.6以后，字典的底层数据结构发生了变化，现在当你初始化一个空的字典以后，它在底层是这样的：

my_dict = {}
'''
此时的内存示意图
indices = [None, None, None, None, None, None, None, None]
entries = []
'''

当你初始化一个字典以后，Python单独生成了一个长度为8的一维数组。然后又生成了一个空的二维数组。

现在，我们往字典里面添加一个键值对：

my_dict['name'] = 'kingname'
'''
此时的内存示意图
indices = [None, 0, None, None, None, None, None, None]
entries = [[-5954193068542476671, 指向name的指针, 执行kingname的指针]]
'''

为什么内存会变成这个样子呢？我们来一步一步地看：

在当前运行时，name这个字符串的hash值为-5954193068542476671，这个值对8取余数是1：

所以，我们把indices这个一维数组里面，下标为1的位置修改为0。

这里的0是什么意思呢？0是二位数组entries的索引。现在entries里面只有一行，就是我们刚刚添加的这个键值对的三个数据：name的hash值、指向name的指针和指向kinganme的指针。所以indices里面填写的数字0，就是刚刚我们插入的这个键值对的数据在二位数组里面的行索引。

新的这种方式，当我要插入新的数据的时候，始终只是往entries的后面添加数据，这样就能保证插入的顺序。当我们要遍历字典的Keys和Values的时候，直接遍历entries即可，里面每一行都是有用的数据，不存在跳过的情况，减少了遍历的个数。

老的方式，当二维数组有8行的时候，即使有效数据只有3行，但它占用的内存空间还是 8 24 = 192 byte。但使用新的方式，如果只有三行有效数据，那么entries也就只有3行，占用的空间为3 24 =72 byte，而indices由于只是一个一维的数组，只占用8 byte，所以一共占用 80 byte。内存占用只有原来的41%。

————————————————

原文链接：https://blog.csdn.net/no_found/article/details/114502305

彻底搞懂编码 GBK 和 UTF8

Sat, 30 Jul 2022 19:13:54 +0800

原文地址：https://www.cnblogs.com/batsing/p/charset.html

首先来看一下常用的编码有哪些。其中ANSI在中国大陆即为GBK（以前是GB2312），最常用的是 GBK 和 UTF8无BOM 编码格式。后面三个都是有BOM头的文本格式，UCS-2即为人们常说的Unicode编码，又分为大端、小端。

所谓BOM头（Byte Order Mark）就是文本文件中开始的几个并不表示任何字符的字节，用二进制编辑器（如bz.exe）就能看到了。

UTF8的BOM头为 0xEF 0xBB 0xBF

Unicode大端模式为 0xFE 0xFF

Unicode小端模式为 0xFF 0xFE

何为GBK，何为GB2312，与区位码有何渊源？

区位码是早些年(1980)中国制定的一个编码标准，如果有玩过小霸王学习机的话，应该会记得有个叫做“区位”的输入法（没记错的话是按F4选择）。就是打四个数字然后就出来汉字了，什么原理呢。请看下面的区位码表，每一个字符都有对应一个编号。其中前两位为“区”，后两位为“位”，中文汉字的编号区号是从16开始的，位号从1开始。前面的区号有一些符号、数字、字母、注音符号（台）、制表符、日文等等。

而GB2312编码就是基于区位码的，用双字节编码表示中文和中文符号。一般编码方式是：0xA0+区号，0xA0+位号。如下表中的 “安”，区位号是1618（十进制），那么“安”字的GB2312编码就是 0xA0+16 0xA0+18 也就是 0xB0 0xB2 。根据区位码表，GB2312的汉字编码范围是0xB0A1~0xF7FE

区位码表http://www.xuebuyuan.com/879025.html

可能大家注意到了，区位码里有英文和数字，按道理说是不是也应该是双字节的呢。而一般情况下，我们见到的英文和数字是单字节的，以ASCII编码，也就是说现代的GBK编码是兼容ASCII编码的。比如一个数字2，对应的二进制是0x32，而不是 0xA3 0xB2。那么问题来了，0xA3 0xB2 又对应到什么呢？还是２（笑）。注意看了，这里的２跟2是不是有点不太一样？！确实是不一样的。这里的双字节２是全角的二，ASCII的2是半角的二，一般输入法里的切换全角半角就是这里不同。

如果留意过早些年的手机（功能机），会发现人名中常见的“燊”字是打不出来的。为什么呢？因为早期的区位码表里面并没有这些字，也就是说早期的GB2312也是没有这些字的。到后来的GBK（1995）才补充了大量的汉字进去，当然现在的安卓苹果应该都是GBK字库了。再看看这些补充的汉字的字节码燊 0x9F 0xF6 。和前面说到的GB2312不同，有的字的编码比 0xA0 还小，难道新补充的区位号还能是负的？？其实不然，这次的补充只补充了计算机编码表，并没有补充区位码表。也就是说区位码表并没有更新，用区位码打字法还是打不出这些字，而网上的反向区位码表查询也只是按照GBK的编码计算，并不代表字与区位号完全对应。时代的发展，区位码表早已经是进入博物馆的东西了。

Big5是与GB2312同时期的一种台湾地区繁体字的编码格式。后来GBK编码的制定，把Big5用的繁体字也包含进来（但编码不兼容），还增加了一些其它的中文字符。细心的朋友可能还会发现，台湾香港用的繁体字（如KTV里的字幕）跟大陆用的繁体字还有点笔画上的不一样，其实这跟编码无关，是字体的不同，大陆一般用的是宋体楷体黑体，港澳台常用的是明体。GBK总体编码范围为0x8140~0xFEFE，首字节在 0x81~0xFE 之间，尾字节在 0x40~0xFE 之间，剔除 xx7F 一条线。详细编码表可以参考这个链接。微软Windows安排给GBK的code page（代码页）是CP936，所以有时候看到编码格式是CP936，其实就是GBK的意思。2000年和2005年，国家又先后两次发布了GB18030编码标准，兼容GBK，新增四字节的编码，但比较少见。

同一个编码文件里，怎么区分ASCII和中文编码呢？从ASCII表我们知道标准ASCII只有128个字符，0~127即0x00~0x7F（0111 1111）。所以区分的方法就是，高字节的最高位为0则为ASCII，为1则为中文。

UTF8编码与 Unicode编码

GBK是中国标准，只在中国使用，而各国又推出各自的编码标准，互不兼容，非常不利于全球化发展。于是后来国际组织发行了一个全球统一编码表，把全球各国文字都统一在一个编码标准里，名为Unicode。很多人都很疑惑，到底UTF8与Unicode两者有什么关系？如果要类比的话，UTF8相当于GB2312，Unicode相当于区位码表，不同的是它们之间的编号范围和转换公式。那什么是原始的Unicode编码呢？如果你用过PHP的话，json_encode函数默认会把中文编码成为Unicode，比如“首发于博客园”就会转码成“\u9996\u53d1\u4e8e\u535a\u5ba2\u56ed”。可以看到每个字都变成了 \uXXXX 的形式，这个就是文字的对应Unicode编码，\u表示Unicode的意思。现行的Unicode编码标准里，绝大多数程序语言只支持双字节。英文字母、标点也收纳在Unicode编码中。

因为英文字符也全部使用双字节，存储成本和流量会大大地增加，所以Unicode编码大多数情况并没有被原始地使用，而是被转换编码成UTF8。下表就是其转换公式：

第一种：Unicode从 0x0000 到 0x007F 范围的，是不是有点熟悉？对，其实就是标准ASCII码里面的内容，所以直接去掉前面那个字节 0x00，使用其第二个字节（与ASCII码相同）作为其编码，即为单字节UTF8。

第二种：Unicode从 0x0080 到 0x07FF 范围的，转换成双字节UTF8。

第三种：Unicode从 0x8000 到 0xFFFF 范围的，转换成三字节UTF8，一般中文都是在这个范围里。

第四种：超过双字节的Unicode目前还没有广泛支持，仅见emoji表情在此范围。

例如“博”字的Unicode编码是\u535a。0x535A在0x0800~0xFFFF之间，所以用3字节模板 1110yyyy 10yyyyxx 10xxxxxx。将535A写成二进制是：0101 0011 0101 1010，高八位分别代替y，低八位分别代替x，得到 11100101 10001101 10011010，也就是 \0xE5\0x8D\0x9A ，这就是博字的UTF8编码。

前面提到，GBK的编码里英文字符有全角和半角之分，全角为GBK的标准编码过的双字节２，半角为ASCII的单字节2。那现在UTF8是全部用一个公式，理论上只有半角的2的，怎么支持全角的２呢？哈哈，结果是Unicode为中国特色的全角英文字符也单独分配了编码，简单粗暴。比如全角的２的Unicode编码是 \uFF12，转换到UTF8就是 0xEFBC92。

文章开头有说到 UCS-2，其实UCS-2就是原始的双字节Unicode编码，用二进制编辑器打开UCS-2大端模式的文本文件，从左往右看，看到的就是每个字符的Unicode编码了。至于什么是大端小端，就是字节的存放顺序不同，这一般是嵌入式编程的范畴。

如何区分一个文本是无BOM的UTF8还是GBK

前面说到的几种编码，其中有的是有BOM头的，可以直接根据BOM头区分出其编码。有两个是没有BOM头的，UTF8和GBK，那么两者怎么区分呢？答案是，只能按大量的编码分析来区分。一些常用的IDE，PHP的mb_系列函数，python的chardet库及其它语言衍生版如jchardet，jschardet 等。

那么这些库是怎么区分这些编码的呢？那就是词库，你会看到库的源码里有大量的数组，其实就是对应一个编码里的常见词组编码组合。同样的文件字节流在一个词组库里的匹配程度越高，就越有可能是该编码，判断的准确率就越大。而文件中的中文越少越零散，判断的准确率就越低。

关于ASCII

文中多次提及ASCII编码，其实这应该是每个程序员都非常熟悉、认真了解的东西。对于嵌入式开发的人来说，应该能随时在字符与ASCII码中转换，就像十六进制与二进制之间的转换一样。标准ASCII是128个，范围是0x00~0x7F (0000 0000~0111 0000) ，最高位为0。也有一个扩展ASCII码规则，把最高位也用上了，变成256个，但是这个扩展标准争议很大，没有得到推广，应该以后不会得到推广。因为无论是GBK还是UTF8，如果ASCII字符编码最高位能为1都会造成混乱无法解析。

以GBK为例，如果ASCII的字符最高位也能是1，那么是应该截取一个解析为ASCII呢？还是截取两个解析为中文字符？这根本无法判断。UTF8也是同理，遇到 0xxx 开头则截取一个（即为标准ASCII），遇到 110x 开头则截取两个，遇到 1110 开头则截取三个，如果ASCII包含1开头的，则无法确定何时截取多少个。

在哪里还能一睹扩展ASCII的真容呢？其实很简单，只要把网页的meta改成ASCII就行了 <meta charset="ASCII" /> 。又或者浏览器的编码选择“西方”，即可见到与平常所见不同的乱码。

诗歌处女作《今天我看见》三首

Fri, 27 May 2022 21:22:40 +0800

沐沐 7岁 2022.5

（其一）

明天我会看见

两个月亮

它们都是旧的

我把其中一个摘下来

做个纪念

我回了家

突然

我发现是一个鸡蛋

（其二）

第二次

我看见了两个太阳

突然

它们降下了好几度

变成了——

一片雪花

我把它们摘下来

放在手心里

一会儿

它们就融化了

（其三）

昨天

我什么都没有看见

今天

就不一样了

我今天看见了两个星星

我本来觉得没有什么奇怪的

我再看了一下

我发现

他们一个是聪明的

一个是不聪明的

我是他们的老师

那我就喜欢聪明的星星

我也喜欢不聪明的星星

今天我看见两个月亮，一个新的，一个旧的。我很相信新月，但我猜他是旧的。

——奥拉夫·赫格《今天我看见》

诗画十二生肖

Sat, 23 Jan 2021 16:20:06 +0800

子鼠
双眼露贼光，偷食昼夜忙。
官仓遭啃尽，个个狠如狼。

丑牛
世代拓荒忙，千家谷满仓。
而今谁候问，独自品寒霜。

寅虎
声啸山林镇，头冠帝者魂。
死生皆霸气，谁敢不称臣。

卯兔
原野寻踪迹，蟾宫伴女神。
三窟难觅影，急煞守株人。

辰龙
传承千百载，从古奉为神。
魂系中国梦，龙腾惠子孙。

巳蛇
乔扮可成龙，身居庙殿中。
一朝皮褪去，原本是条虫。

午马
血洒沙场路，尸身遍野横。
功成欢庆日。能有几骑生？

未羊
性善千家爱，皮毛暖众身。
心灵存孝悌，跪乳报亲恩。

申猴
徒生伶俐貌，不辨四和三。
纵有通天志，难逃五指关。

酉鸡
头戴王侯帽，身披彩凤衣。
为驱黑暗夜，日日唤晨曦。

戌狗
威猛镇一方，看家狩猎忙。
不嫌贫与富，忠义远名扬。

亥猪
不问人间事，因图肚子圆。
临刀魂出窍。飞月会婵娟。

十二月十日大雾送儿之幼儿园

Thu, 10 Dec 2020 20:51:19 +0800

十二月十日大雾送儿之幼儿园

沐·现代

空闻人语声，四望不见影。

出楼入仙境，路断方堪行。

最后一句“路断方堪行”源自沐沐，小家伙自出生还从未亲身经历过如此大雾（或者以前太小的时候都不记得了），所以也非常好奇，他看到前面都是雾蒙蒙的，路也渐渐的看不见了，所以就好奇的问我，“路都没有了，我们怎么去幼儿园？”

名字里的美是中国人才懂得的浪漫

Mon, 23 Nov 2020 21:51:28 +0800

中国人的浪漫是刻在骨子里的，从一系列高科技技术的命名可窥见一二：月球车叫玉兔、探月工程叫嫦娥、载人航天飞船叫神舟、载人空间站叫天宫、中继通信卫星叫鹊桥、南极科考站叫昆仑。

载人深海潜水器叫蛟龙、全球卫星定位系统叫北斗、全球低轨卫星星座通信系统叫鸿雁、太阳监测卫星计划叫夸父、量子科学实验卫星叫墨子、暗物质探测器叫悟空……

我们正在一步步实现当初古人写下的梦想，而一年十二个月，四季皆是风景，农历十二个月份的别称，亦是诗情画意，美妙不可言传。

每读一遍这些文字，心中对这种自古传承下的浪漫气息更多几分体会，也越来越骄傲自己是中国人！

杰智 × BLOG

许家印被抓要玩完

2023初雪：清晨的雪景，唤醒的心情

做学问的境界

Python入门之面向对象编程(四)Python描述器详解

python3.6以后字典有序的原理

彻底搞懂编码 GBK 和 UTF8

诗歌处女作《今天我看见》三首

诗画十二生肖

十二月十日大雾送儿之幼儿园

名字里的美 是中国人才懂得的浪漫

名字里的美是中国人才懂得的浪漫