从这方面看 确实 ucloud 更方便，

随意绑定IP到主机，到自建路由器。 能实现很多东西

不会， 但为什么不让用下划线？

我个人不喜欢表名和字段名有大写字母

LZ 别补充了， 越补充越烂

我最讨厌的就是这句： 只要你是优秀人才/大牛，工资上不封顶，就看你能不能谈下来。

骗三岁小孩呢？

如果没记错的话， pycharm 4 出来有三周了吧

刚好最近在学习postgresql，就来解答一下

LZ这样的 没有表结构， 怎么回答？

那我就来假设吧：


如果是经典的关系表：
那么你会有两个表， user 和 friends，

user 记录用户， friends 记录好友关系


mydb=# \d user
Table "public.user"
Column | Type | Modifiers
--------+---------+-----------
id | integer

mydb=# \d friends
Table "public.friends"
Column | Type | Modifiers
--------+---------+-----------
u1 | integer |
u2 | integer |

mydb=# select * from user ;
id
----
1
2
3
4
5
6
(6 rows)

mydb=# select * from friends ;
u1 | u2
----+----
1 | 3
1 | 6
(2 rows)


假设 user.id = 1 的是A用户， 他有两个好友，id为3,6

SQL：


mydb=# select id from user, (select array_agg(u2) as friend from friends where u1 = 1) as f where not (id = any(f.friend));
id
----
1
2
4
5
(4 rows)



如果是单向好友，那么完全可以不要friends表， 把好友用array类型存储起来


mydb=# \d s_user
Table "public.s_user"
Column | Type | Modifiers
---------+-----------+-----------
id | integer |
friends | integer[] |



mydb=# select * from s_user ;
id | friends
----+---------
2 |
3 |
4 |
5 |
6 |
1 | {3,6}
(6 rows)

mydb=# select u1.id from s_user u1, s_user u2 where u2.id = 1 and not (u1.id = any(u2.friends));
id
----
2
4
5
1
(4 rows)

LZ 典型伸手党啊，

不看文档
不google
给了提示 还是不懂！

datetime.deltatime

arrow.replace(hours+=8)

国庆期间 阿里云机器 不知为何重启了，
我那些服务偷懒没有配置 到开启启动， 然后用户反映上不去。
还好已经从外地归来，否则损失就大了。


有次给阿里云报工单，那个客服直接把我搞怒了，
让他们换客服，换个动技术了，然后才换了个能沟通的。。。

加密这种需求，就别自己实现了。

用erlang吧， 递归既符合我个人的思维，代码也好写

PIL 库保持的时候有个 质量选项， 默认不是最到， 你设置到100就OK， 肉眼对比过 和 ps 无差异

@lbp0200

http 代理也是我想添加的个功能，但自己事情比较多，一直没添加，
而且 有现成的 将 socks5 转换成 http 代理的程序，
比如我用的 privoxy 就很好用， 配置简单。


这个不用和 supervisord 配合， erlang 程序自己就有监督树，
不会整个crash掉的，

用了erlang 你会发现什么 redis, zeromq, rabbitmq, 都不用学了
自己要考虑的 缓存，多进程，同步，分布式，都帮你做好了。
你只要用就可以。

所以用erlang的方式来思考， 抛弃supervisord!

@lbp0200 是不是 key 长度的问题？

@damngood 我也是做手游的， 交流一下

我QQ 330912736

刚好我今早还想到 要自己做一个轮子，
因为 protobuffer 岁好，但是 在erlang中使用起来确实麻烦，
如果自己定义 消息的二进制结构，那么每个消息服务端和客户端都要自己去 pack/unpack，
比protobuf这种麻烦多了，

于是便有了这个想法：
用python写protocol定义， 然后生成对应语言的操作代码
生成的代码直接去 pack/unpack 二进制数据。

这样 protocol 定义写起来非常方便，而且自动生成各种语言的代码，
方便，省事，而且为了简单轻量：

可能有以下特性：

1. 不做错误检查， pack进去的数据由 人保证不写错， 否则在 serialize 的可能会报错
2. 生成的代码，没有压缩算法，一个 32位整数，哪怕你之填充了一个1, 那么也是老老实实的占用4个字节。
3. 保持简单，生成的二进制结构就是这么的stupid:

Binary:
[4 bytes length][ * body *]
Body:
[4 bytes protocol id][ * data *]
Data:
[1 byte date type sign number][ * value * ]...
[1 byte date type sign number][4 bytes string length][* string value *]...
[1 byte date type sign number][4 bytes repeated amount][* repeated value *]...
Repated Value:
[1 byte date type sign number][* value *]...




比如举个例子：
协议定义

class Weapon(EmbeddedProtocol):
----id = IntegerField(bytes=4)
----attack = FloatField()

@Spec(protocol_id=10) # 协议号
class Person(Protocol):
----id = IntegerField(bytes=8) # 64 bits integer
----gender = IntegerField(bytes=1) # 8 bits integer
----name = StringField()
----position = PointField()
----weapons = ListField(Weapon)


然后用python直接生产对应语言的 代码。
python例子（以及所有支持OOP的语言），生成后的代码使用起来类似这样：

p = Person()
p.id = 1
p.gender = 1
p.name = "My Name"
p.position = (23, 56)
p.weapons.extend([
----Weapon(id=11, attack=99),
----Weapon(id=12, attack=101),
])

binary = p.Serialize()


erlang 例子，生成后的代码使用类似这样：

P = person:new(),
P1 = person:set(P, id, 1),
P2 = person:set(P1, gender, 1),
%% 或者一次设置多个Field
P3 = P2#person(name=<<"My Name">>, position=[23, 56]),

W1 = weapon:new(#weapon(id=11, attack=99)),
W2 = weapon:new(#weapon(id=12, attack=101)),


P4 = person:append_to_field(P3, weapons, [W1, W2])

Binary = person:serialize(P4)

@damngood 一看就是做手游的吧， unity3d, golang server ?

我的用法是 一个单独的 git repo, 放 protobuf 定义

然后 server 和 client 的 仓库 都去添加那个 protobuf 的仓库为 submodule

当 protobuf修改 提交后 ， server 和 client 都 git submodule update 一下，
最后各自生产各自的代码就行