-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathatom.xml
More file actions
1136 lines (951 loc) · 104 KB
/
atom.xml
File metadata and controls
1136 lines (951 loc) · 104 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>python ning's blog</title>
<link href="/atom.xml" rel="self"/>
<link href="http://python-ning.github.io/"/>
<updated>2016-08-18T01:31:26.000Z</updated>
<id>http://python-ning.github.io/</id>
<author>
<name>python-ning</name>
</author>
<generator uri="http://hexo.io/">Hexo</generator>
<entry>
<title>mysql 命令大全</title>
<link href="http://python-ning.github.io/2016/08/17/mysql_commonly_used_commands/"/>
<id>http://python-ning.github.io/2016/08/17/mysql_commonly_used_commands/</id>
<published>2016-08-16T16:00:00.000Z</published>
<updated>2016-08-18T01:31:26.000Z</updated>
<content type="html"><p>1.登录数据库</p>
<pre><code>mysql -u root -p
</code></pre><p>2.创建数据库</p>
<pre><code>CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name [[DEFAULT] CHARACTER SET [=] charset_name]
</code></pre><p>3.查看当前服务器下的数据库列表</p>
<pre><code>SHOW {DATABASES|SCHEMAS}
</code></pre><p>4.查看指定数据库的定义</p>
<pre><code>SHOW CREATE {DATABASE|SCHEMA} db_name
</code></pre><p>5.修改指定数据库的编码方式</p>
<pre><code>ALTER {DATABASE|SCHEMA} db_name [DEFAULT] CHARACTER SET [=] charset_name
</code></pre><p>6.打开指定数据库</p>
<pre><code>USE db_name
</code></pre><p>7.删除指定数据库</p>
<pre><code>DROP {DATABASE|SCHEMA} [IF EXISTS] db_name
</code></pre><p>8.得到当前打开的数据库名称</p>
<pre><code>SELECT DATABASE()|SCHEMA();
</code></pre><p>9.查看上一步操作产生的警告信息</p>
<pre><code>SHOW WARNINGS;
</code></pre><p>10.创建数据表</p>
<pre><code>CREATE TABLE [IF NOT EXISTS] tbl_name(字段名称 字段类型 [完整性约束条件]...)ENGINE=引擎名称 CHARSET=&apos;编码方式&apos;;
create table student(id INT(11) PRIMARY KEY, name VARCHAR(25), age INT(11))
完整性约束条件:
PRIMARY KEY主键
AUTO_INCREMENT自增长
FOREIGN KEY外键
NOT NULL非空
UNIQUE KEY唯一
DEFAULT默认值
</code></pre><p>11.查看数据库下的数据表</p>
<pre><code>SHOW TABLES
</code></pre><p>12.查看指定表的表结构</p>
<pre><code>DESC tbl_name
DESCRIBE tbl_name
SHOW COLUMNS FROM tbl_name
</code></pre><p>13.删除数据表</p>
<pre><code>DROP TABLE [IF EXISTS] tbl_name[,tbl_name...]
</code></pre><p>14.修改表名</p>
<pre><code>ALTER TABLE tbl_name RENAME [TO|AS] new_name
RENAME TABLE tbl_name TO new_name
</code></pre><p>15.添加字段</p>
<pre><code>ALTER TABLE tbl_name ADD 字段名称 字段类型 [完整性约束条件] [FIRST|AFTER 字段名称]
</code></pre><p>16.删除字段</p>
<pre><code>ALTER TABLE tbl_name DROP 字段名称
</code></pre><p>17.修改字段</p>
<pre><code>ALTER TABLE tbl_name MODIFY 字段名称 字段类型 [完整性约束条件] [FIRST|AFTER 字段名称]
</code></pre><p>18.修改字段名称</p>
<pre><code>ALTER TABLE tbl_name CHANGE 旧字段名称 新字段名称 字段类型 [完整性约束条件] [FIRST|AFTER 字段名称]
</code></pre><p>19.添加默认值</p>
<pre><code>ALTER TABLE tbl_name ALTER 字段名称 SET DEFAULT 默认值
</code></pre><p>20.删除默认值</p>
<pre><code>ALTER TABLE tbl_name ALTER 字段名称 DROP DEFAULT
</code></pre><p>21.添加主键</p>
<pre><code>ALTER TABLE tbl_name ADD [CONSTRAINT [symbol]] PRIMARY KEY[index_type] (字段名称,...)
</code></pre><p>22.删除主键</p>
<pre><code>ALTER TABLE tbl_name DROP PRIMARY KEY
</code></pre><p>23.添加唯一</p>
<pre><code>ALTER TABLE tbl_name ADD [CONSTRAINT [symbol]] UNIQUE [INDEX|KEY] [索引名称](字段名称,...)
</code></pre><p>24.删除唯一</p>
<pre><code>ALTER TABLE tbl_name DROP {INDEX|KEY} index_name
</code></pre><p>25.修改表的存储引擎</p>
<pre><code>ALTER TABLE tbl_name ENGINE=存储引擎名称
</code></pre><p>26.设置自增长的值</p>
<pre><code>ALTER TABLE tbl_name AUTO_INCREMNET=值
</code></pre><p>27.插入数据</p>
<pre><code>不指定具体的字段名
INSERT [INTO] tbl_name VALUES|VALUE(值...)
列出指定字段
INSERT [INTO] tbl_name(字段名称1,...) VALUES|VALUE(值1,...)
同时插入多条记录
INSERT [INTO] tbl_name[(字段名称...)] VALUES(值...),(值...)...
通过SET形式插入记录
INSERT [INTO] tbl_name SET 字段名称=值,...
将查询结果插入到表中
INSERT [INTO] tbl_name[(字段名称,...)] SELECT 字段名称 FROM tbl_name [WHERE 条件]
</code></pre><p>28.更新(修改)数据</p>
<pre><code>UPDATE tbl_name SET 字段名称=值,... [WHERE 条件][ORDER BY 字段名称][LIMIT 限制条数]
</code></pre><p>29.删除数据</p>
<pre><code>DELETE FROM tbl_name [WHERE 条件][ORDER BY 字段名称][LIMIT 限制条数]
</code></pre><p>30.彻底清空数据表</p>
<pre><code>TRUNCATE [TABLE] tbl_name
</code></pre><p>31.查询记录</p>
<pre><code>SELECT select_expr [, select_expr ...]
[
FROM table_references
[WHERE 条件]
[GROUP BY {col_name | position} [ASC | DESC], ... 分组]
[HAVING 条件 对分组结果进行二次筛选]
[ORDER BY {col_name | position} [ASC | DESC], ...排序]
[LIMIT 限制显示条数]
]
查询表达式:
每一个表达式表示想要的一列,必须至少有一列,多个列之间以逗号分隔
*表示所有列,tbl_name.*可以表示命名表的所有列
查询表达式可以使用[AS]alias_name为其赋予别名
4.GROUP BY查询结果分组:
COUNT()
MAX()
MIN()
AVG()
SUM()
WHERE 条件
</code></pre><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/3.WHERE%20%E6%9D%A1%E4%BB%B6.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>32.内连接查询</p>
<pre><code>JOIN|CROSS JOIN INNER JOIN
通过ON 连接条件
显示两个表中符合连接条件的记录
</code></pre><p>33.外连接查询</p>
<pre><code>左外连接 显示左表的全部记录及右表符合连接条件的记录
LEFT [OUTER] JOIN
右外连接 显示右表的全部记录以及左表符合条件的记录
RIGHT [OUTER] JOIN
</code></pre><p>34.联合查询</p>
<pre><code>UNION
UNION ALL
UNION和UNION ALL 区别是UNION去掉相同记录,UNION ALL 是简单的合并到一起。
</code></pre><p>35.子查询</p>
<pre><code>将查询结果写入到数据表
INSERT [INTO] tbl_name [(col_name,...)]SELECT ...
创建数据表同时将查询结果写入到数据表
CREATE TABLE [IF NOT EXISTS] tbl_name[(create_definition,...)]select_statement
</code></pre><p>36.删除索引</p>
<pre><code>DROP INDEX 索引名称 ON tbl_name
</code></pre><p>37.创建索引</p>
<pre><code>创建表的时候创建索引
CREATE TABLE tbl_name(字段名称 字段类型 [完整性约束条件],…,[UNIQUE|FULLTEXT|SPATIAL] INDEX|KEY [索引名称](字段名称[(长度)] [ASC|DESC]));
在已经存在的表上创建索引
ALTER TABLE tbl_name ADD [UNIQUE|FULLTEXT|SPATIAL] INDEX 索引名称(字段名称[(长度)] [ASC|DESC]);
</code></pre><p>38.mysql中的函数(数学函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_1.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>39.mysql中的函数(字符串函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_2_1.png" class="img-shadow" style="display: block;margin: auto"><br><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_2_2.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>40.mysql中的函数(日期时间函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_3_1.png" class="img-shadow" style="display: block;margin: auto"><br><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_3_2.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>41.mysql中的函数(条件判断函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_4.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>42.mysql中的函数(系统信息函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_5.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>43.mysql中的函数(加密函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_6.png" class="img-shadow" style="display: block;margin: auto"></p>
<p>44.mysql中的函数(其他常用函数)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/mysql_xmind_7.png" class="img-shadow" style="display: block;margin: auto"></p>
</content>
<summary type="html">
<p>1.登录数据库</p>
<pre><code>mysql -u root -p
</code></pre><p>2.创建数据库</p>
<pre><code>CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name [[DEFAU
</summary>
<category term="mysql" scheme="http://python-ning.github.io/categories/mysql/"/>
<category term="mysql" scheme="http://python-ning.github.io/tags/mysql/"/>
</entry>
<entry>
<title>redis的安装与配置</title>
<link href="http://python-ning.github.io/2016/07/28/redis_install_config/"/>
<id>http://python-ning.github.io/2016/07/28/redis_install_config/</id>
<published>2016-07-27T16:00:00.000Z</published>
<updated>2016-07-28T22:13:23.000Z</updated>
<content type="html"><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/jianyan.jpg" class="img-shadow" style="display: block;margin: auto"></p>
<p>有时间了,就看了看 redis,大概说一下 redis 的安装和配置,以及配置的各个参数的含义</p>
<h3 id="安装"><a href="#安装" class="headerlink" title="安装"></a>安装</h3><p>redis 官网</p>
<pre><code>http://redis.io/
</code></pre><p>1.进入<a href="http://redis.io/download" target="_blank" rel="external">http://redis.io/download</a> 下载页,下面有命令,wget 下载下来,或者直接下载压缩文件<br>2.解压压缩文件,打开解压后的文件夹,运行<code style="color:red">make</code>,可再运行 <code style="color:red">make test</code> 测试是否安装正确</p>
<pre><code>$ wget http://download.redis.io/releases/redis-3.2.1.tar.gz
$ tar xzf redis-3.2.1.tar.gz
$ cd redis-3.2.1
$ make
$ make test
</code></pre><p>3.启动服务端</p>
<pre><code>$ src/redis-server
</code></pre><p>4.启动客户端</p>
<pre><code>$ src/redis-cli
</code></pre><p>5.终端出现以下形式,说明已经进入 redis</p>
<pre><code>127.0.0.1:6379&gt;
</code></pre><h3 id="配置"><a href="#配置" class="headerlink" title="配置"></a>配置</h3><p>获取配置文件信息</p>
<pre><code>CONFIG GET *
</code></pre><p>如果你要改配置文件,可以直接去修改 redis.cnf,或者在终端里直接一条一条修改,比如下面是修改 redis 权限</p>
<pre><code>CONFIG SET requirepass password
</code></pre><h3 id="配置参数含义"><a href="#配置参数含义" class="headerlink" title="配置参数含义"></a>配置参数含义</h3><p>1.Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程</p>
<pre><code>daemonize no
</code></pre><p>2.当Redis以守护进程方式运行时,Redis默认会把pid写入/var/run/redis.pid文件,可以通过pidfile指定</p>
<pre><code>pidfile /var/run/redis.pid
</code></pre><p>3.指定Redis监听端口,默认端口为6379,作者在自己的一篇博文中解释了为什么选用6379作为默认端口,因为6379在手机按键上MERZ对应的号码,而MERZ取自意大利歌女Alessia Merz的名字</p>
<pre><code>port 6379
</code></pre><p>4.绑定的主机地址</p>
<pre><code>bind 127.0.0.1
</code></pre><p>5.当客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能</p>
<pre><code>timeout 300
</code></pre><p>6.指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为verbose</p>
<pre><code>loglevel verbose
</code></pre><p>7.日志记录方式,默认为标准输出,如果配置Redis为守护进程方式运行,而这里又配置为日志记录方式为标准输出,则日志将会发送给/dev/null</p>
<pre><code>logfile stdout
</code></pre><p>8.设置数据库的数量,默认数据库为0,可以使用SELECT <dbid>命令在连接上指定数据库id</dbid></p>
<pre><code>databases 16
</code></pre><p>9.指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合</p>
<pre><code>save &lt;seconds&gt; &lt;changes&gt;
Redis默认配置文件中提供了三个条件:
save 900 1
save 300 10
save 60 10000
分别表示900秒(15分钟)内有1个更改,300秒(5分钟)内有10个更改以及60秒内有10000个更改。
</code></pre><p>10.指定存储至本地数据库时是否压缩数据,默认为yes,Redis采用LZF压缩,如果为了节省CPU时间,可以关闭该选项,但会导致数据库文件变的巨大</p>
<pre><code>rdbcompression yes
</code></pre><p>11.指定本地数据库文件名,默认值为dump.rdb</p>
<pre><code>dbfilename dump.rdb
</code></pre><p>12.指定本地数据库存放目录</p>
<pre><code>dir ./
</code></pre><p>13.设置当本机为slav服务时,设置master服务的IP地址及端口,在Redis启动时,它会自动从master进行数据同步</p>
<pre><code>slaveof &lt;masterip&gt; &lt;masterport&gt;
</code></pre><p>14.当master服务设置了密码保护时,slav服务连接master的密码</p>
<pre><code>masterauth &lt;master-password&gt;
</code></pre><p>15.设置Redis连接密码,如果配置了连接密码,客户端在连接Redis时需要通过AUTH <code>password</code> 命令提供密码,默认关闭</p>
<pre><code>requirepass foobared
</code></pre><p>16.设置同一时间最大客户端连接数,默认无限制,Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数,如果设置 maxclients 0,表示不作限制。当客户端连接数到达限制时,Redis会关闭新的连接并向客户端返回max number of clients reached错误信息</p>
<pre><code>maxclients 128
</code></pre><p>17.指定Redis最大内存限制,Redis在启动时会把数据加载到内存中,达到最大内存后,Redis会先尝试清除已到期或即将到期的Key,当此方法处理 后,仍然到达最大内存设置,将无法再进行写入操作,但仍然可以进行读取操作。Redis新的vm机制,会把Key存放内存,Value会存放在swap区</p>
<pre><code>maxmemory &lt;bytes&gt;
</code></pre><p>18.指定是否在每次更新操作后进行日志记录,Redis在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为no</p>
<pre><code>appendonly no
</code></pre><p>19.指定更新日志文件名,默认为appendonly.aof</p>
<pre><code>appendfilename appendonly.aof
</code></pre><p>20.指定更新日志条件,共有3个可选值:</p>
<pre><code>no:表示等操作系统进行数据缓存同步到磁盘(快)
always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全)
everysec:表示每秒同步一次(折衷,默认值)
appendfsync everysec
</code></pre><p>21.指定是否启用虚拟内存机制,默认值为no,简单的介绍一下,VM机制将数据分页存放,由Redis将访问量较少的页即冷数据swap到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)</p>
<pre><code>vm-enabled no
</code></pre><p>22.虚拟内存文件路径,默认值为/tmp/redis.swap,不可多个Redis实例共享</p>
<pre><code>vm-swap-file /tmp/redis.swap
</code></pre><p>23.将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0</p>
<pre><code>vm-max-memory 0
</code></pre><p>24.Redis swap文件分成了很多的page,一个对象可以保存在多个page上面,但一个page上不能被多个对象共享,vm-page-size是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page大小最好设置为32或者64bytes;如果存储很大大对象,则可以使用更大的page,如果不 确定,就使用默认值</p>
<pre><code>vm-page-size 32
</code></pre><p>25.设置swap文件中的page数量,由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的,,在磁盘上每8个pages将消耗1byte的内存。</p>
<pre><code>vm-pages 134217728
</code></pre><p>26.设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4</p>
<pre><code>vm-max-threads 4
</code></pre><p>27.设置在向客户端应答时,是否把较小的包合并为一个包发送,默认为开启</p>
<pre><code>glueoutputbuf yes
</code></pre><p>28.指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法</p>
<pre><code>hash-max-zipmap-entries 64
hash-max-zipmap-value 512
</code></pre><p>29.指定是否激活重置哈希,默认为开启(后面在介绍Redis的哈希算法时具体介绍)</p>
<pre><code>activerehashing yes
</code></pre><p>30.指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件</p>
<pre><code>include /path/to/local.conf
</code></pre></content>
<summary type="html">
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/jianyan.jpg" class="img-shadow" style="display: block;margin: auto"></p>
<p>有时间了,就看了看 red
</summary>
<category term="redis" scheme="http://python-ning.github.io/categories/redis/"/>
<category term="redis" scheme="http://python-ning.github.io/tags/redis/"/>
</entry>
<entry>
<title>jira的安装配置以及接口调用</title>
<link href="http://python-ning.github.io/2016/07/16/jira_python_api/"/>
<id>http://python-ning.github.io/2016/07/16/jira_python_api/</id>
<published>2016-07-15T16:00:00.000Z</published>
<updated>2016-07-16T21:09:56.000Z</updated>
<content type="html"><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/55e736d12f2eb9388e9d2280d4628535e4dd6fcb.jpg" class="img-shadow" style="display: block;margin: auto"></p>
<p>最近应用户的需求,使用了一下 jira这个软件,用户要用 jira 作为工作流使用来调用私有云的云资源</p>
<h3 id="jira-介绍"><a href="#jira-介绍" class="headerlink" title="jira 介绍"></a>jira 介绍</h3><p>JIRA是Atlassian公司出品的项目与事务跟踪工具,被广泛应用于缺陷跟踪、客户服务、需求收集、流程审批、任务跟踪、项目跟踪和敏捷管理等工作领域。<br>JIRA中配置灵活、功能全面、部署简单、扩展丰富,其超过150项特性得到了全球115个国家超过19,000家客户的认可。</p>
<h3 id="jira-安装与配置"><a href="#jira-安装与配置" class="headerlink" title="jira 安装与配置"></a>jira 安装与配置</h3><h2 id="jira官网地址"><a href="#jira官网地址" class="headerlink" title="jira官网地址"></a>jira官网地址</h2><pre><code>https://www.atlassian.com/software/jira
</code></pre><h2 id="jira帐号注册地址"><a href="#jira帐号注册地址" class="headerlink" title="jira帐号注册地址:"></a>jira帐号注册地址:</h2><pre><code>https://id.atlassian.com/signup
</code></pre><h2 id="jira激活地址"><a href="#jira激活地址" class="headerlink" title="jira激活地址:"></a>jira激活地址:</h2><pre><code>https://id.atlassian.com/login?application=mac&amp;continue=https://my.atlassian.com
</code></pre><p>1.首先输入 jira 的官网地址,点击 Try it free进入试用界面<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira1.png" class="img-shadow" style="display: block;margin: auto"><br>2.节点点击Try it free<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira1.png" class="img-shadow" style="display: block;margin: auto"><br>3.注册 jira 的帐号,填写相关选项,确定<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira3.png" class="img-shadow" style="display: block;margin: auto"><br>4.然后你会进入下面这个页面<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira4.png" class="img-shadow" style="display: block;margin: auto"><br>5.你的邮箱会收到下面这个邮件,点击验证你的邮箱<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira5.png" class="img-shadow" style="display: block;margin: auto"><br>6.验证完后就开始系统配置你的 jira 了,如下图<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira6.png" class="img-shadow" style="display: block;margin: auto"><br>7.等页面变成一下就说明配置完了<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira7.png" class="img-shadow" style="display: block;margin: auto"><br>8.然后进入jira 激活地址,登录(你的邮箱是帐号)到如下页面,点击红框里的按钮<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira8.png" class="img-shadow" style="display: block;margin: auto"><br>9.进入以下网址,填写表单,(server id 是你 jira 安装到的主机上在设置里查到的),然后确定<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira9.png" class="img-shadow" style="display: block;margin: auto"><br>10.你就进入了下面的页面,拿到这个License Key,当你安装 jira 访问的时候他会提示你输入这个 key<br><img src="http://7xojjc.com1.z0.glb.clouddn.com/jira10.png" class="img-shadow" style="display: block;margin: auto"></p>
<h3 id="jira-一些功能"><a href="#jira-一些功能" class="headerlink" title="jira 一些功能"></a>jira 一些功能</h3><p>jira 主要是做工作流,他可以设置工作流方案,自定义字段,很方便好用</p>
<h3 id="jira-私有云接口-flask"><a href="#jira-私有云接口-flask" class="headerlink" title="jira+私有云接口+flask"></a>jira+私有云接口+flask</h3><p>jira 有一个 webhooks 的东东,是发http 请求的,我通过触发某个按钮,带上操作云资源需要的参数(自定义字段),在 webhooks 指定接受请求的连接,这里是用 python 的 flask 框架来接收 jira 发送的请求,是带有 json 数据的一个post 请求,flask 通过接受到的参数,去做处理,调取私有云系统的 api 从而实现通过 jira 对私有云系统的部分操作。</p>
</content>
<summary type="html">
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/55e736d12f2eb9388e9d2280d4628535e4dd6fcb.jpg" class="img-shadow" style="display: block;ma
</summary>
<category term="jira" scheme="http://python-ning.github.io/categories/jira/"/>
<category term="flask" scheme="http://python-ning.github.io/tags/flask/"/>
</entry>
<entry>
<title>我的项目经验</title>
<link href="http://python-ning.github.io/2016/06/28/ning.chen/"/>
<id>http://python-ning.github.io/2016/06/28/ning.chen/</id>
<published>2016-06-27T16:00:00.000Z</published>
<updated>2016-06-29T20:46:17.000Z</updated>
<content type="html"><h3 id="私有云项目"><a href="#私有云项目" class="headerlink" title="私有云项目"></a>私有云项目</h3><p>客户有(北京王府井集团,国家电网,神州数码)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus1.png" class="img-shadow" style="display: block;margin: auto"><br><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus2.png" class="img-shadow" style="display: block;margin: auto"><br><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus3.png" class="img-shadow" style="display: block;margin: auto"><br><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus4.png" class="img-shadow" style="display: block;margin: auto"></p>
<h3 id="相关代码"><a href="#相关代码" class="headerlink" title="相关代码"></a>相关代码</h3><h2 id="前端页部分代码"><a href="#前端页部分代码" class="headerlink" title="前端页部分代码"></a>前端页部分代码</h2><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus5.png" class="img-shadow" style="display: block;margin: auto"></p>
<h2 id="后端部分代码"><a href="#后端部分代码" class="headerlink" title="后端部分代码"></a>后端部分代码</h2><pre><code>from django.contrib.auth.decorators import login_required
from django.shortcuts import render_to_response
from django.forms.models import model_to_dict, save_instance
from django.http import HttpResponse
from db.models import *
from db.apis import *
from db.joblistener import send_welcome_email_to_internal, send_welcome_email
from sysadmin.views import *
from sysadmin.forms import *
from django.template.context import RequestContext
from django.utils.translation import ugettext as _
from sysadmin.templatetags.tags import *
from nexus.util import encrypt_password
@login_required
@permit_require(&apos;cloudserver_r&apos;)
@db_cached_view
@active_navs(&apos;cloud_server&apos;, &apos;cloud_server&apos;)
def index(request):
customer_list = User.objects.order_by(&apos;customer_name&apos;)
physical_server = PhysicalServer.objects.filter(
hyperviser__in=[&quot;kvm&quot;]).order_by(&apos;host_name&apos;)
image_list = Image.objects.filter(status=&quot;Ready&quot;).order_by(&apos;name&apos;)
data_center = DataCenter.objects.order_by(&apos;name&apos;)
cluster_list = Cluster.objects.order_by(&apos;name&apos;)
data = {
&apos;customer_list&apos;: customer_list,
&apos;physical_server&apos;: physical_server,
&apos;image_list&apos;: image_list,
&apos;data_center_list&apos;: data_center,
&apos;cluster_list&apos;: cluster_list,
&apos;cpu_modes&apos;: CPU_MODES,
}
return render(request, &apos;sysadmin/cloud_server/cloud_server_list.html&apos;, data)
@login_required
@permit_require(&apos;cloudserver_r&apos;)
@db_cached_view
def cloudservers_json(request):
def query_fields(key_word):
query = (Q(name__contains=key_word) |
Q(host_name__contains=key_word) |
Q(image__name__contains=key_word) |
Q(physical_server__host_name__contains=key_word) |
Q(user__customer_name__contains=key_word) |
Q(status__contains=key_word))
return query
def order_callback(qobj, column):
sortable = {0: &quot;name&quot;,
1: &quot;host_name&quot;,
2: &quot;user__customer_name&quot;,
5: &quot;status&quot;,
6: &quot;image__name&quot;,
11: &quot;created_at&quot;
}
order = sortable[0]
if column in sortable:
order = sortable[column]
return qobj.order_by(order)
data = generate_query_data(VirtualServer, request,
create_and_search_callback(query_fields),
order_callback, generate_vserver_list)
return response_200(json.dumps(data))
def generate_vserver_list(vservers):
ret = []
for vserver in vservers:
if vserver.bandwidth &gt;= 0:
bandwidth_str = vserver.bandwidth
else:
bandwidth_str = &quot;&amp;nbsp;&quot;
if vserver.physical_server:
pserver_str = &quot;&lt;a href=\&quot;/admin/server/show/%s\&quot;&gt;%s&lt;/a&gt;&quot; % (
vserver.physical_server.id, vserver.physical_server.host_name)
else:
pserver_str = &quot;&quot;
user_content = &quot;&quot;
if vserver.user:
user_content = &quot;&lt;a href=\&quot;/admin/customer/show/%s\&quot;&gt;%s&lt;/a&gt;&quot; % (
vserver.user.id, vserver.user.customer_name)
ret.append([
&quot;&lt;a data-id=\&quot;%s\&quot; href=\&quot;/admin/cloudserver/show/%s\&quot;&gt;%s&lt;/a&gt;&quot; % (
vserver.id, vserver.id, vserver.name),
vserver.host_name,
user_content,
vserver.ip_address_str(),
pserver_str,
&quot;&lt;div style=\&quot;color: %s\&quot;&gt;%s&lt;/div&gt;&quot; % (
vstatus_color(vserver.status), _(vserver.status)),
vserver.image.name,
vserver.cpu,
vserver.memory,
vserver.disk,
bandwidth_str,
format_time(vserver.created_at)
])
return ret
@login_required
@permit_require(&apos;cloudserver_w&apos;)
@log_action(action=&quot;Create Cloud Server&quot;, method=&quot;POST&quot;)
def create(request):
form = VirtualServerForm(request.POST)
form.fields[&apos;network_type_name&apos;].choices = get_network_type_names()
if form.is_valid():
vserver = create_virtual_server_from_form(request, form)
id = vserver.id
return render_json({&apos;url&apos;: reverse(&apos;cloudserver_show&apos;, kwargs={&apos;id&apos;: id})})
return render_form_error(form)
</code></pre><h3 id="公有云项目"><a href="#公有云项目" class="headerlink" title="公有云项目"></a>公有云项目</h3><p>(公司主营,公有云管理平台,让客户对所有云计算资源以及存储进行一键化操作)</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus6.png" class="img-shadow" style="display: block;margin: auto"><br><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus7.png" class="img-shadow" style="display: block;margin: auto"></p>
<h3 id="相关代码-1"><a href="#相关代码-1" class="headerlink" title="相关代码"></a>相关代码</h3><h2 id="前端页面部分代码"><a href="#前端页面部分代码" class="headerlink" title="前端页面部分代码"></a>前端页面部分代码</h2><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus9.png" class="img-shadow" style="display: block;margin: auto"></p>
<h2 id="后端部分代码-1"><a href="#后端部分代码-1" class="headerlink" title="后端部分代码"></a>后端部分代码</h2><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus10.png" class="img-shadow" style="display: block;margin: auto"></p>
<h3 id="官网接口文档编写与测试"><a href="#官网接口文档编写与测试" class="headerlink" title="官网接口文档编写与测试"></a>官网接口文档编写与测试</h3><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus8.png" class="img-shadow" style="display: block;margin: auto"></p>
<h3 id="对象存储-object-storage-相关技术"><a href="#对象存储-object-storage-相关技术" class="headerlink" title="对象存储(object_storage)相关技术"></a>对象存储(object_storage)相关技术</h3><p>客户(当当网、民族证券)</p>
<h2 id="对象存储-object-storage"><a href="#对象存储-object-storage" class="headerlink" title="对象存储(object_storage)"></a>对象存储(object_storage)</h2><p>Python相关代码</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/nexus11.png" class="img-shadow" style="display: block;margin: auto"></p>
</content>
<summary type="html">
<h3 id="私有云项目"><a href="#私有云项目" class="headerlink" title="私有云项目"></a>私有云项目</h3><p>客户有(北京王府井集团,国家电网,神州数码)</p>
<p><img src="http://7xojjc.com1
</summary>
<category term="求职" scheme="http://python-ning.github.io/categories/%E6%B1%82%E8%81%8C/"/>
<category term="求职" scheme="http://python-ning.github.io/tags/%E6%B1%82%E8%81%8C/"/>
</entry>
<entry>
<title>python面试题精选</title>
<link href="http://python-ning.github.io/2016/06/27/python_interview_questions/"/>
<id>http://python-ning.github.io/2016/06/27/python_interview_questions/</id>
<published>2016-06-26T16:00:00.000Z</published>
<updated>2016-08-04T06:46:56.000Z</updated>
<content type="html"><p><img src="http://7xojjc.com1.z0.glb.clouddn.com/293387-106.jpg" class="img-shadow" style="display: block;margin: auto"><br>小癖好~爱做面试题,感觉每次做份面试题总能在其中复习了很多基础知识和一些算法~</p>
<h3 id="用规定的Python方法,在一行中对给定的任意整数数列,按照如下规则排序:"><a href="#用规定的Python方法,在一行中对给定的任意整数数列,按照如下规则排序:" class="headerlink" title="用规定的Python方法,在一行中对给定的任意整数数列,按照如下规则排序:"></a>用规定的Python方法,在一行中对给定的任意整数数列,按照如下规则排序:</h3><p>a) 非负数在前,负数在后;<br>b) 非负数部分按照从小到大排序;<br>c) 负数部分按从大到小排序。<br>如: 数列 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]<br>希望排序后为[0,2,4,8,8,9,-2,-4,-4,-5,-20]</p>
<p>解答:</p>
<pre><code>&gt;&gt;&gt; foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
&gt;&gt;&gt; sorted(foo, key=lambda x: (x&gt;=0 and -abs(1/float(x+1)) or abs(x)))
[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]
&gt;&gt;&gt;
</code></pre><h3 id="给出用递归的方式求斐波那契数列的第n项的方法:"><a href="#给出用递归的方式求斐波那契数列的第n项的方法:" class="headerlink" title="给出用递归的方式求斐波那契数列的第n项的方法:"></a>给出用递归的方式求斐波那契数列的第n项的方法:</h3><p>(斐波那契数列指的是这样一个数列0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,…)<br>特别指出:第0项是0,第1项是第一个1。这个数列从第2项开始,每一项都等于前两项之和。</p>
<p>解答:</p>
<pre><code># test.py
def fib(n):
if n &lt;= 1:
return n
else:
return(fib(n - 1) + fib(n - 2))
if __name__ == &apos;__main__&apos;:
n = 10
print fib(n)
</code></pre><h3 id="求大于正整数n的最小质数"><a href="#求大于正整数n的最小质数" class="headerlink" title="求大于正整数n的最小质数"></a>求大于正整数n的最小质数</h3><pre><code>import math
def func_get_prime(n):
return filter(lambda x: not [x % i for i in range(2, int(math.sqrt(x)) + 1) if x % i == 0], range(2, n + 1))
if __name__ == &apos;__main__&apos;:
print min(func_get_prime(100))
</code></pre><h3 id="在不声明新变量的情况下,让变量a和变量b的值互换?"><a href="#在不声明新变量的情况下,让变量a和变量b的值互换?" class="headerlink" title="在不声明新变量的情况下,让变量a和变量b的值互换?"></a>在不声明新变量的情况下,让变量a和变量b的值互换?</h3><p>解答:</p>
<pre><code>&gt;&gt;&gt; a = 1
&gt;&gt;&gt; b = 9
&gt;&gt;&gt; a = a + b
&gt;&gt;&gt; b = a - b
&gt;&gt;&gt; a = a - b
&gt;&gt;&gt; a
9
&gt;&gt;&gt; b
1
&gt;&gt;&gt;
</code></pre><h3 id="Python是如何进行内存管理的?"><a href="#Python是如何进行内存管理的?" class="headerlink" title="Python是如何进行内存管理的?"></a>Python是如何进行内存管理的?</h3><p>解答:从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制<br><strong>一、对象的引用计数机制</strong><br>python内部使用引用计数,来保持追踪内存中的对象,所有对象都有引用计数。<br>引用计数增加的情况:<br>1,一个对象分配一个新名称<br>2,将其放入一个容器中(如列表、元组或字典)<br>引用计数减少的情况:<br>1,使用del语句对对象别名显示的销毁<br>2,引用超出作用域或被重新赋值<br>sys.getrefcount( )函数可以获得对象的当前引用计数<br>多数情况下,引用计数比你猜测得要大得多。对于不可变数据(如数字和字符串),解释器会在程序的不同部分共享内存,以便节约内存。<br><strong>二、垃圾回收</strong><br>1,当一个对象的引用计数归零时,它将被垃圾收集机制处理掉。<br>2,当两个对象a和b相互引用时,del语句可以减少a和b的引用计数,并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用,因此引用计数不会归零,对象也不会销毁。(从而导致内存泄露)。为解决这一问题,解释器会定期执行一个循环检测器,搜索不可访问对象的循环并删除它们。<br><strong>三、内存池机制</strong><br>Python提供了对内存的垃圾收集机制,但是它将不用的内存放到内存池而不是返回给操作系统。<br>1,Pymalloc机制。为了加速Python的执行效率,Python引入了一个内存池机制,用于管理对小块内存的申请和释放。<br>2,Python中所有小于256个字节的对象都使用pymalloc实现的分配器,而大的对象则使用系统的malloc。<br>3,对于Python对象,如整数,浮点数和List,都有其独立的私有内存池,对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数,用于缓存这些整数的内存就不能再分配给浮点数。</p>
<h3 id="什么是lambda函数?它有什么好处"><a href="#什么是lambda函数?它有什么好处" class="headerlink" title="什么是lambda函数?它有什么好处?"></a>什么是lambda函数?它有什么好处?</h3><p>解答:</p>
<p>lambda 表达式,通常是在需要一个函数,但是又不想费神去命名一个函数的场合下使用,也就是指匿名函数<br>lambda函数:首要用途是指短小的回调函数</p>
<pre><code>lambda [arguments]:expression
&gt;&gt;&gt; a=lambda x,y:x+y
&gt;&gt;&gt; a(3,11)
</code></pre><h3 id="现在有一个文件url-txt,每一行都是一个网站名(例如:map-baidu-com)请用Python读取这个文件并且使用正则表达式匹配简单的以“www-”,以“-com”或者”-edu”或者”-gov”作结尾的web域名,然后输出到另一个文件中"><a href="#现在有一个文件url-txt,每一行都是一个网站名(例如:map-baidu-com)请用Python读取这个文件并且使用正则表达式匹配简单的以“www-”,以“-com”或者”-edu”或者”-gov”作结尾的web域名,然后输出到另一个文件中" class="headerlink" title="现在有一个文件url.txt,每一行都是一个网站名(例如:map.baidu.com)请用Python读取这个文件并且使用正则表达式匹配简单的以“www.”,以“.com”或者”.edu”或者”.gov”作结尾的web域名,然后输出到另一个文件中"></a>现在有一个文件url.txt,每一行都是一个网站名(例如:map.baidu.com)请用Python读取这个文件并且使用正则表达式匹配简单的以“www.”,以“.com”或者”.edu”或者”.gov”作结尾的web域名,然后输出到另一个文件中</h3><p>解答:<br> coding:utf-8<br> import re<br> sch = re.compile(r”^www.*[com,edu,gov]$”)<br> listt = []<br> with open(‘C:\Users\test\Desktop\test.txt’, ‘r’) as f:<br> file_list = f.readlines()<br> for i in file_list:<br> listt.append(sch.match(i).group())</p>
<pre><code>with open(&apos;C:\Users\test\Desktop\\chen.txt&apos;, &apos;a&apos;) as f:
for i in listt:
f.write(i + &apos;\n&apos;)
</code></pre><h3 id="写一个装饰器,计算这个函数运行了多长时间?"><a href="#写一个装饰器,计算这个函数运行了多长时间?" class="headerlink" title="写一个装饰器,计算这个函数运行了多长时间?"></a>写一个装饰器,计算这个函数运行了多长时间?</h3><p>1.复杂</p>
<pre><code>import time
from functools import wraps
import random
def fn_timer(function):
@wraps(function)
def function_timer(*args, **kwargs):
t0 = time.time()
result = function(*args, **kwargs)
t1 = time.time()
print (&quot;Total time running %s: %s seconds&quot; %(function.func_name, str(t1-t0)))
return result
return function_timer
@fn_timer
def random_sort(n):
return sorted([random.random() for i in range(n)])
if __name__ == &quot;__main__&quot;:
random_sort(2000000)
</code></pre><p>2.简单</p>
<pre><code># coding:utf8
import time
# clock()方法返回当前的处理器时间,以秒表示Unix上一个浮点数。
# 精度取决于具有相同名称的C函数,但在任何情况下,
# 这是使用于基准Python或定时的算法函数。
def suan(fn):
def wrapper():
start = time.clock()
print start
fn()
end = time.clock()
print end
return end - start
return wrapper
@suan
def func():
return range(100000)
print func()
</code></pre><h3 id="django查询取出数据库”User表”中字段”name”为”chen”和”ning”的数据?"><a href="#django查询取出数据库”User表”中字段”name”为”chen”和”ning”的数据?" class="headerlink" title="django查询取出数据库”User表”中字段”name”为”chen”和”ning”的数据?"></a>django查询取出数据库”User表”中字段”name”为”chen”和”ning”的数据?</h3><pre><code># django查询方法
query = Author.objects.filter(first_name__in=[&quot;chen&quot;, &quot;ning&quot;])
# Q查询
query = Author.objects.filter(Q(first_name__contains=&quot;chen&quot;) | Q(first_name__contains=&quot;ning&quot;))
query = Author.objects.filter(Q(first_name=&quot;chen&quot;) | Q(first_name=&quot;ning&quot;))
</code></pre><h3 id="考面向对象的一道题"><a href="#考面向对象的一道题" class="headerlink" title="考面向对象的一道题"></a>考面向对象的一道题</h3><pre><code>#coding:utf-8
class Parent(object):
x = 1
def __init__(self, v):
self.x = v
class Child(Parent):
def __init__(self, v, m):
# 调用父类的__init__,填上空缺的
self.y = m
p = Parent(2)
print p.x, Parent.x
c = Child(2,3)
print c.x, Parent.x, Child.x
Parent.x = 3
print Parent.x , Child.x
</code></pre></content>
<summary type="html">
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/293387-106.jpg" class="img-shadow" style="display: block;margin: auto"><br>小癖好~爱做面试题,感觉每次
</summary>
<category term="python" scheme="http://python-ning.github.io/categories/python/"/>
<category term="面试题" scheme="http://python-ning.github.io/tags/%E9%9D%A2%E8%AF%95%E9%A2%98/"/>
</entry>
<entry>
<title>mac安装mysql</title>
<link href="http://python-ning.github.io/2016/05/14/mysql_mac_install_question/"/>
<id>http://python-ning.github.io/2016/05/14/mysql_mac_install_question/</id>
<published>2016-05-13T16:00:00.000Z</published>
<updated>2016-06-27T22:43:49.000Z</updated>
<content type="html"><p>mac下安装mysql,遇到了一个小波折,折磨了我一天,解决了,也借此机会总结一下。</p>
<p><code style="color: red">注意</code> mac上一定要安装xcode,哪怕你不是ios开发工程师也是要安装的,因为在苹果上开发大多数操作都要依赖xcode</p>
<p>mysql 在mac上安装有两种方式:</p>
<h3 id="1-Homebrew安装mysql"><a href="#1-Homebrew安装mysql" class="headerlink" title="1.Homebrew安装mysql"></a>1.Homebrew安装mysql</h3><p>Homebrew类似ubuntu系统的apt-get包管理,命令也基本一样。</p>
<h2 id="安装Homebrew"><a href="#安装Homebrew" class="headerlink" title="安装Homebrew"></a>安装Homebrew</h2><pre><code>ruby -e &quot;$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)&quot;
</code></pre><h2 id="Homebrew基本命令"><a href="#Homebrew基本命令" class="headerlink" title="Homebrew基本命令"></a>Homebrew基本命令</h2><pre><code>$ brew
Example usage:
brew [info | home | options ] [FORMULA...]
brew install FORMULA... // 安装包
brew uninstall FORMULA... // 卸载包
brew search [foo] // 搜索包
brew list [FORMULA...] // 显示已经安装的软件列表
brew update // 更新brew
brew upgrade [FORMULA...] // 更新包,不跟包名就是更新所有包
brew pin/unpin [FORMULA...]
Troubleshooting:
brew doctor
brew install -vd FORMULA
brew [--env | --config]
Brewing:
brew create [URL [--no-fetch]]
brew edit [FORMULA...]
open https://github.com/Homebrew/homebrew/wiki/Formula-Cookbook
Further help:
man brew
brew home
</code></pre><h2 id="安装mysql"><a href="#安装mysql" class="headerlink" title="安装mysql"></a>安装mysql</h2><pre><code>sudo brew install mysql
</code></pre><h2 id="mysql启动,重启,关闭服务"><a href="#mysql启动,重启,关闭服务" class="headerlink" title="mysql启动,重启,关闭服务"></a>mysql启动,重启,关闭服务</h2><pre><code>sudo brew services start mysql
sudo brew services restart mysql
sudo brew services stop mysql
</code></pre><h2 id="常遇问题1"><a href="#常遇问题1" class="headerlink" title="常遇问题1"></a>常遇问题1</h2><p>当mysql安装好,启动了服务后,我们<code style="color: red">mysql -u root -p</code>(mysql默认密码为空)时,可能会出现以下报错</p>
<pre><code>Error: Can&apos;t connect to local MySQL server through socket &apos;/tmp/mysql.sock&apos; (111)
</code></pre><h2 id="解决办法1"><a href="#解决办法1" class="headerlink" title="解决办法1"></a>解决办法1</h2><p>1.查找电脑上所有的mysql都在哪里</p>
<pre><code>sudo find / -name mysql
</code></pre><p>2.找出mysql安装的目录,给权限</p>
<pre><code>chown -R mysql:mysql xxx你的mysql目录xxx
</code></pre><p>实在不知道,你就把所有搜出来的mysql目录文件都给权限,前提是你自己的测试开发环境,可别在服务器上这么搞。</p>
<h3 id="2-dmg包双击安装"><a href="#2-dmg包双击安装" class="headerlink" title="2.dmg包双击安装"></a>2.dmg包双击安装</h3><p>在mysql官网选downloads,选Community(社区版的意思),点这个<code style="color: red">MySQL Community Server (GPL)</code></p>
<p>下载那个dmg后缀名的包下载下来点点点,下一步就好了,安装好以后他会给你个初始登陆密码记录下来,然后他会在你的设置里多一个mysql的图标,点击进入后可以开启关闭mysql服务</p>
<p>基本就安装好了,也可能会有1遇到的问题,按上述方法改就好了。</p>
<p>ps:贴图太麻烦,还有好多事要做,我要速度学成为大牛。</p>
</content>
<summary type="html">
<p>mac下安装mysql,遇到了一个小波折,折磨了我一天,解决了,也借此机会总结一下。</p>
<p><code style="color: red">注意</code> mac上一定要安装xcode,哪怕你不是ios开发工程师也是要安装的,因为在苹果上开发大多数操作都要依赖
</summary>
<category term="mysql" scheme="http://python-ning.github.io/categories/mysql/"/>
<category term="mysql" scheme="http://python-ning.github.io/tags/mysql/"/>
</entry>
<entry>
<title>读改善python程序的91个建议总结</title>
<link href="http://python-ning.github.io/2016/04/18/reading_comprehension_python_1/"/>
<id>http://python-ning.github.io/2016/04/18/reading_comprehension_python_1/</id>
<published>2016-04-17T16:00:00.000Z</published>
<updated>2016-06-27T23:04:51.000Z</updated>
<content type="html"><h3 id="建议一-字符串格式化,让可读性高一些"><a href="#建议一-字符串格式化,让可读性高一些" class="headerlink" title="建议一 字符串格式化,让可读性高一些"></a>建议一 字符串格式化,让可读性高一些</h3><pre><code>print &apos;Hello %S&apos; %(&apos;Chen&apos;,)
==&gt; print &apos;Hello %(name)s!&apos; %{&apos;name&apos;: &apos;Chen&apos;}
value = {&apos;greet&apos;: &apos;Hello world&apos;, &apos;language&apos;: &apos;Python&apos;}
print &apos;%(greet)s from %(language)s.&apos; % value
==&gt; print &apos;{greet} from {language}&apos;.format(greet = &apos;Hello world&apos;, language = Python&apos;&apos;)
</code></pre><h3 id="建议二-命名规则"><a href="#建议二-命名规则" class="headerlink" title="建议二 命名规则"></a>建议二 命名规则</h3><p>1.避免只用大小写来区分不同的对象<br>2.避免使用容易引起混淆的名称比如(0o混淆,l1混淆)<br>3.不要害怕过长的变量名。</p>
<p>安装pep8</p>
<pre><code>pip install -U pep8
</code></pre><p>检测代码</p>
<pre><code>pep8 --first optparse.py
</code></pre><p>显示详细不符合pep8的代码</p>
<pre><code>pep8 --show-source --show-pep8 test.py
</code></pre><h3 id="建议六-编写函数的4个原则"><a href="#建议六-编写函数的4个原则" class="headerlink" title="建议六 编写函数的4个原则"></a>建议六 编写函数的4个原则</h3><p>1.函数设计要尽量短小,嵌套层次不宜过深,if elif while for 等循环判断的,最好能控制在3层以内。<br>2.函数声明应该做到合理、简单、易于使用,参数个数不宜过多,。<br>3.函数参数设计应该考虑向下兼容,比如一个函数,多加了一个参数,来记录功能的日志,要加一个默认参数,便于兼容。<br>4.一个函数只干一件事,尽量保证函数语句粒度的一致性,<br>python中函数设计的好习惯好包括:不要再函数中定义可变对象作为默认值,使用异常替换返回错误,保证通过单元测试等。</p>
<h3 id="建议七-将常量集中到一个文件"><a href="#建议七-将常量集中到一个文件" class="headerlink" title="建议七 将常量集中到一个文件"></a>建议七 将常量集中到一个文件</h3><p>通过命名风格来提醒使用者该变量代表的意义为常量,如常量名所有字母大写,用下划线连接各个单词,如MAX_OVERFLOW. 然而这种方式并没有实现真正的常量,其对应的值仍然可以改变,这只是一种约定俗成的风格。</p>
<p>通过自定义的类实现常量功能。这要求符合”命名全部为大写”和”值一旦绑定便不可再修改”这两个条件。下面是一种较为常见的解决方法,他通过对常量对应的值进行修改时或者命名不符合规范时抛出异常来满足以上变量的两个条件。</p>
<pre><code>class _const:
class ConstError(TypeError): pass
class ConstCaseerror(ConstError): pass
def __setattr__(self,name, value):
if self.__dict__.has_key(name):
raise self.ConstError, &quot;Can&apos;t change const.%s&quot; % name
if not name.isupper():
raise self.ConstError, &quot;const name &apos;%s&apos; is not all uppercase&quot; % name
self.__dict__[name] = value
import sys
sys.modules[__name__] = _const()
</code></pre><p>如果上面的代码对应的模块名为const,使用的时候只需要import const,便可以直接定义常量了, 如以下代码:</p>
<pre><code>import const
const.COMPANY = &quot;IBM&quot;
</code></pre><h3 id="利用assert语句来发现问题"><a href="#利用assert语句来发现问题" class="headerlink" title="利用assert语句来发现问题"></a>利用assert语句来发现问题</h3><p>断言在很多语言中都存在,在python中的语法是:</p>
<pre><code>assert expression1 [&quot;,&quot; expression2]
</code></pre><p>其中计算expression1的值会返回True或者False, 当值为False的时候会引发AssertionError,而expression2是可选的,常用来传递具体的异常信息。</p>
<p>python -O test.py 便可以禁用断言</p>
<p>1.不要滥用,这是使用断言最基本的原则。<br>2.如果python本身的异常能够处理就不要再使用断言。<br>3.不要使用断言来检查用户的输入<br>4.在函数调用后,当需要确认返回值是否合理时可以使用断言<br>5.当条件是业务逻辑继续下去的先决条件时可以使用断言</p>
<h3 id="建议九-数据交换值的时候不推荐使用中间变量"><a href="#建议九-数据交换值的时候不推荐使用中间变量" class="headerlink" title="建议九 数据交换值的时候不推荐使用中间变量"></a>建议九 数据交换值的时候不推荐使用中间变量</h3><p> c = a<br> a = b<br> b = c</p>
<p> ==&gt; a,b = b,a</p>
<p>运行两者效率不一样:</p>
<pre><code>In [1]: from timeit import Timer
In [2]: Timer(&apos;c = x;x=y;y=c&apos;,&apos;x = 2; y=3&apos;)
Out[2]: &lt;timeit.Timer instance at 0x7f58a8273830&gt;
In [3]: Timer(&apos;c = x;x=y;y=c&apos;,&apos;x = 2; y=3&apos;).timeit()
Out[3]: 0.03874492645263672
In [4]: Timer(&apos;x,y = y,x&apos;, &apos;x=2;y=3&apos;).timeit()
Out[4]: 0.03464508056640625
In [5]:
</code></pre><h3 id="建议十-充分利用-Lazy-evaluation的特性"><a href="#建议十-充分利用-Lazy-evaluation的特性" class="headerlink" title="建议十 充分利用 Lazy evaluation的特性"></a>建议十 充分利用 Lazy evaluation的特性</h3><p>1.避免不必要的计算,带来性能上的提升,比如 if x and y ,在x为false的情况下y表达式的值不再计算,二对于if x or y, 当x的值为true的时候将直接返回,不再计算y的值。所以当我们循环一个比较大的数据,先从可能性比较高的一方去循环他,从而节省了时间,提高了效率</p>
<ol>
<li><p>节省空间,使得无限循环的数据结构成为可能。python中最典型的使用延迟计算的例子就是生成器表达式了,它仅在每次需要计算的时候通过yield产生所需要的元素。</p>
<p> def fib():</p>
<pre><code>a, b = 0, 1
while True:
yield a
a, b = b, a + b
</code></pre><blockquote>
<blockquote>
<blockquote>
<p>from itertools import islice<br>print list(islice(fib(), 5))<br> [0, 1, 1, 2, 3]</p>
</blockquote>
</blockquote>
</blockquote>
</li>
</ol>
<h3 id="建议12-不推荐使用type"><a href="#建议12-不推荐使用type" class="headerlink" title="建议12 不推荐使用type()"></a>建议12 不推荐使用type()</h3><p>基于内建类型扩展的用户自定义类型,type()函数并不能准确返回结果。<br>这时候用 isinstance(object, classinfo)</p>
<pre><code>isinstance(2, int)
</code></pre><h3 id="建议13-当涉及触发运算的时候尽量先将操作数转换为浮点类型再做运算"><a href="#建议13-当涉及触发运算的时候尽量先将操作数转换为浮点类型再做运算" class="headerlink" title="建议13 当涉及触发运算的时候尽量先将操作数转换为浮点类型再做运算"></a>建议13 当涉及触发运算的时候尽量先将操作数转换为浮点类型再做运算</h3><h3 id="建议14-eval-不安全"><a href="#建议14-eval-不安全" class="headerlink" title="建议14 eval()不安全"></a>建议14 eval()不安全</h3><pre><code>__import__(&quot;os&quot;).system(&quot;dir&quot;)
</code></pre><p>你的当前目录下的所有文件都出来了</p>
<h3 id="建议15-is-和-“-”"><a href="#建议15-is-和-“-”" class="headerlink" title="建议15 is 和 “==”"></a>建议15 is 和 “==”</h3><p>is的作用是用来检查对象的标识符是否一致的,也就是比较两个对象在内存中是否拥有同一块内存空间,它并不适合用来判断两个字符串是否相等;而”==”才是用来检验两个对象的值是否相等的,它实际调用内部<strong>eq</strong>()方法。</p>
<h3 id="建议17-考虑兼容性,尽可能使用Unicode"><a href="#建议17-考虑兼容性,尽可能使用Unicode" class="headerlink" title="建议17 考虑兼容性,尽可能使用Unicode"></a>建议17 考虑兼容性,尽可能使用Unicode</h3><p>Python内建的字符串有两种类型:str和Unicode,它们拥有共同的祖先basestring。其中Unicode是Python2.0中引入的一种新的数据类型,所有的Unicode字符串都是Unicode类型的实例。创建一个Unicode字符相对简单。</p>
<p>因此要解决乱码问题可以使用Unicode作为中间介质来完成转换。首先需要对读入的字符用UTF-8进行解码,然后再用GBK进行编码。修改后的结果如下:</p>
<pre><code>filehandle = open(&quot;test.txt&quot;,&apos;r&apos;)
print (filehandle.read().decode(&quot;utf-8&quot;)).encode(&quot;gbk&quot;)
filehandle.close()
</code></pre><p>关于BOM:<br>Unicode存储有字节序的问题,例如“汉”字的Unicode编码是0X6C49,如果将6C写在前面,则为big endian,将49写在前面则成为little endian。UTF-16以两个字节为编码单元,在字符的传送过程中,为了标明字节的顺序,Unicode规范中推荐使用BOM(Byte Order Mark):即在 UCS编码中用一个叫做ZERO WIDTH NO-BREAK SPACE的字符,它的编码是FEFF(该编码在UCS中不存在对应的字符),UCS规范建议在传输字节流前,先传输字符ZERO WIDTH NO-BREAK SPACE。这样如果接收者收到FEFF,就表明这个字节流是Big-Endian的;如果收到FFFE,就表明这个字节流是Little-Endian的。 UTF-8使用字节来编码,一般不需要BOM来表明字节顺序,但可以用BOM来表明编码方式。字符ZERO WIDTH NO-BREAK SPACE的UTF-8编码是EF BB BF。所以如果接收者收到以EF BB BF开头的字节流,就知道这是UTF-8编码了。</p>
<p>示例二分析:Python中默认的编码是ASCII编码(这点可以通过sys.getdefaultencoding()来验证),所以unicodetest.py文件是以ASCII形式保存的,s是包含中文字符的普通字符串。当调用print方法输出的时候会隐式地进行从ASCII到系统默认编码(Windows上为CP936)的转换,中文字符并不是ASCII字符,而此时源文件中又未指定其他编码方式,Python解释器并不知道如何正确处理这种情况,便会抛出异常:SyntaxError: Non-ASCII character ‘\xd6’ in file unicodetest.py on line 1。因此,要避免这种错误需要在源文件中进行编码声明,声明可用正则表达式<br>“coding[:=]\s*([-\w.]+)”表示。一般来说进行源文件编码声明有以下3种方式:</p>
<p>第一种声明方式:</p>
<pre><code># coding=&lt;encoding name&gt;
</code></pre><p>第二种声明方式:</p>
<pre><code>#!/usr/bin/python
# -*- coding: &lt;encoding name&gt; -*-
</code></pre><p>第三种声明方式:</p>
<pre><code>#!/usr/bin/python
# vim: set fileencoding=&lt;encoding name&gt; :
</code></pre><h3 id="建议18:构建合理的包层次来管理module"><a href="#建议18:构建合理的包层次来管理module" class="headerlink" title="建议18:构建合理的包层次来管理module"></a>建议18:构建合理的包层次来管理module</h3><p>什么是包呢?简单说包即是目录,但与普通目录不同,它除了包含常规的Python文件(也就是模块)以外,还包含一个<strong>init</strong>.py文件,同时它允许嵌套。包结构如下:<br> Package/ <strong>init</strong>.py<br> Module1.py<br> Module2.py<br> Subpackage/ <strong>init</strong>.py<br> Module1.py<br> Module2.py</p>
<p>以下是一个可供参考的Python项目结构:</p>
<pre><code>ProjectName/
|---README
|----LICENSE
|----setup.py
|-----requirements.txt
|------sample/
| |----__init__.py
| |----core.py
| |----helpers.py
|------docs/
| |------conf.py
| |------index.rst
|------bin/
|------package/
| |-----__init__.py
| |-----subpackage/
| |------........
|------tests/
| |------test_basic.py
| |------test_advanced.py
</code></pre><h3 id="建议19:有节制地使用from…import语句"><a href="#建议19:有节制地使用from…import语句" class="headerlink" title="建议19:有节制地使用from…import语句"></a>建议19:有节制地使用from…import语句</h3><p>在使用import的时候注意以下几点:<br>·一般情况下尽量优先使用import a形式,如访问B时需要使用a.B的形式。<br>·有节制地使用from a import B形式,可以直接访问B。<br>·尽量避免使用from a import *,因为这会污染命名空间,并且无法清晰地表示导入了哪些对象</p>
<p>为什么在使用import的时候要注意以上几点呢?在回答这个问题之前先来简单了解一下Python的import机制。Python在初始化运行环境的时候会预先加载一批内建模块到内存中,这些模块相关的信息被存放在sys.modules中。读者导入sys模块后在Python解释器中输入sys.modules.items()便可显示所有预加载模块的相关信息。当加载一个模块的时候,解释器实际上要完成以下动作:<br>1)在sys.modules中进行搜索看看该模块是否已经存在,如果存在,则将其导入到当前局部命名空间,加载结束。<br>2)如果在sys.modules中找不到对应模块的名称,则为需要导入的模块创建一个字典对象,并将该对象信息插入sys.modules中。<br>3)加载前确认是否需要对模块对应的文件进行编译,如果需要则先进行编译。<br>4)执行动态加载,在当前模块的命名空间中执行编译后的字节码,并将其中所有的对象放入模块对应的字典中。</p>
<h3 id="建议20:优先使用absolute-import来导入模块"><a href="#建议20:优先使用absolute-import来导入模块" class="headerlink" title="建议20:优先使用absolute import来导入模块"></a>建议20:优先使用absolute import来导入模块</h3><p>假设有如下文件结构,其中app/sub1/string.py中定义了一个lower()方法,那么当在mod1.py中import string之后再使用string.lower()方法时,到底引用的是sub1/string.py中的lower()方法,还是Python标准库中string里面的lower()方法呢?</p>
<pre><code>app/
__init__.py
sub1/
__init__.py
mod1.py
string.py
sub2/
__init__.py
mod2.py
</code></pre><p>从程序的输出会发现,它引用的是app/sub1/string.py中的lower()方法。显然解释器默认先从当前目录下搜索对应的模块,当搜到string.py的时候便停止搜索进行动态加载。那么,如果要使用Python自带的string模块中的方法,该怎么实现呢?这就涉及absolute import和relative import相关的话题了。<br>在Python2.4以前默认为隐式的relative import,局部范围的模块将覆盖同名的全局范围的模块。如果要使用标注库中同名的模块,你不得不去深入考察sys.modules一番,显然这并不是一种非常友好的做法。Python2.5中后虽然默认的仍然是relative import,但它为absolute import提供了一种新的机制,在模块中使用from <strong>future</strong> import absolute_import 语句进行说明后再进行导入。同时它还通过点号提供了一种显式进行relative import的方法,“.”表示当前目录,“..”表示当前目录的上一层目录。例如想在mod1.py中导入string.py,可以使用from . import string,其中mod1所在的包层次结构为app.sub1.mod1,“.”表示app.sub1;如果想导入sub2/mo2.py可以使用from ..sub2 import mod2,“..”代表的是app。<br>但事情是不是就此结束了呢?远不止,使用显式relative import之后再运行程序一不小心你就有可能遇到这种错误“ValueError: Attempted relative import in non-package”。这是什么原因呢?这个问题产生的原因在于relative import使用模块的<strong>name</strong>属性来决定当前模块在包层次结构中的位置,如果当前的模块名称中不包含任何包的信息,那么它将默认为模块在包的顶层位置,而不管模块在文件系统中的实际位置。而在relative import的情形下,<strong>name</strong>会随着文件加载方式的不同而发生改变,上例中如在目录app/sub1/下运行Python mod1.py,会发现模块的<strong>name</strong>为<strong>main</strong>,但如果在目录app/sub1/下运行Python-m mod1.py,会发现<strong>name</strong>变为mod1。其中-m的作用是使得一个模块像脚本一样运行。而无论以何种方式加载,当在包的内部运行脚本的时候,包相关的结构信息都会丢失,默认当前脚本所在的位置为模块在包中的顶层位置,因此便会抛出异常。如果确实需要将模块当作脚本一样运行,解决方法之一是在包的顶层目录中加入参数-m运行该脚本,上例中如果要运行脚本mod1.py可以在app所在的目录的位置输入Python -m app.sub1.mod1。另一个解决这个问题的方法是利用Python2.6在模块中引入的<strong>package</strong>属性,设置<strong>package</strong>之后,解释器会根据<strong>package</strong>和<strong>name</strong>的值来确定包的层次结构。上面的例子中如果将mod1.py修改为以下形式便不会出现在包结构内运行模块对应的脚本时出错的情况了。</p>
<pre><code>if __name__ == &quot;__main__&quot; and __package__ is None:
import sys
import os.path
sys.path[0] = os.path.abspath(&quot;./../../&quot;)
print sys.path[0]
import app.sub1
__package__ = str(&apos;app.sub1&apos;)
from . import string
</code></pre><h3 id="建议26:-深入理解None,正确判断对象是否为空"><a href="#建议26:-深入理解None,正确判断对象是否为空" class="headerlink" title="建议26: 深入理解None,正确判断对象是否为空"></a>建议26: 深入理解None,正确判断对象是否为空</h3><pre><code>if xxx is not None:
Do something
else:
Not do something
上边会走到else
</code></pre><p>只有None == None是True, 其他像0,[], (),’’等都是False</p>
<p>大多是情况下用</p>
<pre><code>if(XXX):
do or not do
</code></pre><h3 id="建议27-连接字符串用join比”-”好"><a href="#建议27-连接字符串用join比”-”好" class="headerlink" title="建议27 连接字符串用join比”+”好"></a>建议27 连接字符串用join比”+”好</h3><p>效率要高</p>
<h3 id="建议28-format"><a href="#建议28-format" class="headerlink" title="建议28 .format"></a>建议28 .format</h3><pre><code>In [15]: &apos;adasd asd as asd {0} id {1}&apos;.format(&apos;ning&apos;,&apos;chen&apos;)
Out[15]: &apos;adasd asd as asd ning id chen&apos;
</code></pre><h3 id="建议31-重点-记住函数传参既不是传值也不是传引用"><a href="#建议31-重点-记住函数传参既不是传值也不是传引用" class="headerlink" title="建议31 重点 记住函数传参既不是传值也不是传引用"></a>建议31 重点 记住函数传参既不是传值也不是传引用</h3><p>python中的函数参数既不是传值也不是传引用,也不是可变对象传引用,不可变对象传值,正确的叫法应该是传对象(call by object)或者说传对象的引用(call-by-object-reference)。函数参数在传递的过程中将整个对象传入,对可变对象的修改在函数外部以及内部都可见,调用者和被调用者之间共享这个对象,二对于不可变对象,由于并不能真正被修改,因此,修改往往是通过生成一个新对象然后复制来实现。</p>
<h3 id="建议36-掌握字符串的基本用法"><a href="#建议36-掌握字符串的基本用法" class="headerlink" title="建议36 掌握字符串的基本用法"></a>建议36 掌握字符串的基本用法</h3><p>basestring 包括str 和 unicode</p>
<p>字符串方法:</p>
<pre><code>isalnum()
isalpha()
isdigit()
islower()
isupper()
isspace()
istitle()
startswith()
endwith()
</code></pre><h3 id="建议14-eval-不安全-1"><a href="#建议14-eval-不安全-1" class="headerlink" title="建议14 eval()不安全"></a>建议14 eval()不安全</h3></content>
<summary type="html">
<h3 id="建议一-字符串格式化,让可读性高一些"><a href="#建议一-字符串格式化,让可读性高一些" class="headerlink" title="建议一 字符串格式化,让可读性高一些"></a>建议一 字符串格式化,让可读性高一些</h3><pre><cod
</summary>
<category term="python" scheme="http://python-ning.github.io/categories/python/"/>
<category term="总结" scheme="http://python-ning.github.io/tags/%E6%80%BB%E7%BB%93/"/>
</entry>
<entry>
<title>django(八)五步教你实现使用Nginx+uWSGI+Django方法部署Django程序(上)</title>
<link href="http://python-ning.github.io/2016/04/14/python_django_uwsgi/"/>
<id>http://python-ning.github.io/2016/04/14/python_django_uwsgi/</id>
<published>2016-04-13T16:00:00.000Z</published>
<updated>2016-04-14T17:49:14.000Z</updated>
<content type="html"><p>Django的部署可以有很多方式,采用nginx+uwsgi的方式是其中比较常见的一种方式。</p>
<p>在这种方式中,我们的通常做法是,将nginx作为服务器最前端,它将接收WEB的所有请求,统一管理请求。nginx把所有静态请求自己来处理(这是NGINX的强项)。然后,NGINX将所有非静态请求通过uwsgi传递给Django,由Django来进行处理,从而完成一次WEB请求。</p>
<p>可见,uwsgi的作用就类似一个桥接器。起到桥梁的作用。不使用nginx,只使用uwsgi+django也是可以实现WEB服务的。uwsgi也可以直接处理WEB请求。</p>
<p>为了完成上述的方式部署,我将分成两篇文章来分别进行阐述。</p>
<pre><code>第一步先解决uwsgi与django的桥接。解决在没有nginx的情况下,如何使用uwsgi+DJANGO来实现一个简单的WEB服务器。
第二步解决uwsgi与Nginx的桥接。通过nginx与uwsgi的桥接,打通nginx与django的连通,从而比较完美的实现django的部署。
</code></pre><p>本文将分成五步来详细阐述uwsgi+django的部署方式。nginx+uwsgi+django的部署将在下一篇 文章中阐述。</p>
<p>环境介绍</p>
<pre><code>Ubuntu 12.04.1 LTS
django 1.4.2
</code></pre><h3 id="安装uwsgi"><a href="#安装uwsgi" class="headerlink" title="安装uwsgi"></a>安装uwsgi</h3><p>1.安装pip</p>
<p>可以参考这篇文章:<a href="http://www.jsxubar.info/install-pip.html" target="_blank" rel="external">http://www.jsxubar.info/install-pip.html</a></p>
<p>2.安装uwsgi</p>
<p>$ export LDFLAGS=”-Xlinker –no-as-needed”<br>$ pip install uwsgi</p>
<h3 id="测试uwsgi"><a href="#测试uwsgi" class="headerlink" title="测试uwsgi"></a>测试uwsgi</h3><p>在你的机器上写一个test.py</p>
<pre><code># test.py
def application(env, start_response):
start_response(&apos;200 OK&apos;, [(&apos;Content-Type&apos;,&apos;text/html&apos;)])
return &quot;Hello World&quot;
</code></pre><p>然后执行shell命令:</p>
<pre><code>uwsgi --http :8001 --wsgi-file test.py
</code></pre><p>访问网页:</p>
<pre><code>http://127.0.0.1:8001/
</code></pre><p>看在网页上是否有Hello World</p>
<h3 id="配置django"><a href="#配置django" class="headerlink" title="配置django"></a>配置django</h3><pre><code>NOTE:
请保证你的django项目是正常使用的。可以使用
python manage.py runserver 0.0.0.0:8002
来测试一下你的django项目是否能正常跑起来。
请保证你的django程序已经关闭。
</code></pre><p>编写django_wsgi.py文件,将其放在与文件manage.py同一个目录下。</p>
<pre><code>注意: 编写文件时需要注意语句os.environ.setdefault。比如,如果你的项目为mysite,则你的语句应该是 os.environ.setdefault(&quot;DJANGO_SETTINGS_MODULE&quot;, &quot;mysite.settings&quot;)
#!/usr/bin/env python
# coding: utf-8
import os
import sys
# 将系统的编码设置为UTF8
reload(sys)
sys.setdefaultencoding(&apos;utf8&apos;)
os.environ.setdefault(&quot;DJANGO_SETTINGS_MODULE&quot;, &quot;mysite.settings&quot;)
from django.core.handlers.wsgi import WSGIHandler
application = WSGIHandler()
</code></pre><p>连接django和uwsgi,实现简单的WEB服务器。</p>
<p>我们假设你的Django项目的地址是/root/home/www/django_blog,</p>
<p>然后,就可以执行以下命令:</p>
<p>uwsgi –http :8000 –chdir /root/home/www/django_blog –module django_wsgi</p>
<p>这样,你就可以在浏览器中访问你的Django程序了。所有的请求都是经过uwsgi传递给Django程序的。</p>
<p>转载于<a href="http://www.django-china.cn/topic/101/" target="_blank" rel="external">django中国社区</a></p>
</content>
<summary type="html">
<p>Django的部署可以有很多方式,采用nginx+uwsgi的方式是其中比较常见的一种方式。</p>
<p>在这种方式中,我们的通常做法是,将nginx作为服务器最前端,它将接收WEB的所有请求,统一管理请求。nginx把所有静态请求自己来处理(这是NGINX的强项)。然后
</summary>
<category term="python" scheme="http://python-ning.github.io/categories/python/"/>
<category term="django" scheme="http://python-ning.github.io/tags/django/"/>
</entry>
<entry>
<title>https工作原理</title>
<link href="http://python-ning.github.io/2016/04/13/good_article_collect_https/"/>
<id>http://python-ning.github.io/2016/04/13/good_article_collect_https/</id>
<published>2016-04-12T16:00:00.000Z</published>
<updated>2016-04-13T18:43:12.000Z</updated>
<content type="html"><p>HTTPS其实是有两部分组成:HTTP + SSL/TLS,也就是在HTTP上又加了一层处理加密信息的模块。服务端和客户端的信息传输都会通过TLS进行加密,所以传输的数据都是加密后的数据</p>
<p><img src="http://7xojjc.com1.z0.glb.clouddn.com/https.png" class="img-shadow" style="display: block;margin: auto"></p>
<h3 id="客户端发起HTTPS请求"><a href="#客户端发起HTTPS请求" class="headerlink" title="客户端发起HTTPS请求"></a>客户端发起HTTPS请求</h3><p>这个没什么好说的,就是用户在浏览器里输入一个https网址,然后连接到server的443端口。</p>
<h3 id="服务端的配置"><a href="#服务端的配置" class="headerlink" title="服务端的配置"></a>服务端的配置</h3><p>采用HTTPS协议的服务器必须要有一套数字证书,如果没有请联系易维信客服购买全球信任的SSL证书,而使用受信任的CA签发的证书则不会弹出提示页面(GeoTrust,Symantec都是知名的CA机构)。这套证书其实就是一对公钥和私钥。如果对公钥和私钥不太理解,可以想象成一把钥匙和一个锁头,只是全世界只有你一个人有这把钥匙,你可以把锁头给别人,别人可以用这个锁把重要的东西锁起来,然后发给你,因为只有你一个人有这把钥匙,所以只有你才能看到被这把锁锁起来的东西。</p>
<h3 id="传送证书"><a href="#传送证书" class="headerlink" title="传送证书"></a>传送证书</h3><p>这个证书其实就是公钥,只是包含了很多信息,如证书的颁发机构,过期时间等等。</p>
<h3 id="客户端解析证书"><a href="#客户端解析证书" class="headerlink" title="客户端解析证书"></a>客户端解析证书</h3><p>这部分工作是有客户端的TLS来完成的,首先会验证公钥是否有效,比如颁发机构,过期时间等等,如果发现异常,则会弹出一个警告框,提示证书存在问题。如果证书没有问题,那么就生成一个随即值。然后用证书对该随机值进行加密。就好像上面说的,把随机值用锁头锁起来,这样除非有钥匙,不然看不到被锁住的内容。</p>
<h3 id="传送加密信息"><a href="#传送加密信息" class="headerlink" title="传送加密信息"></a>传送加密信息</h3><p>这部分传送的是用证书加密后的随机值,目的就是让服务端得到这个随机值,以后客户端和服务端的通信就可以通过这个随机值来进行加密解密了。</p>
<h3 id="服务段解密信息"><a href="#服务段解密信息" class="headerlink" title="服务段解密信息"></a>服务段解密信息</h3><p>服务端用私钥解密后,得到了客户端传过来的随机值(私钥),然后把内容通过该值进行对称加密。所谓对称加密就是,将信息和私钥通过某种算法混合在一起,这样除非知道私钥,不然无法获取内容,而正好客户端和服务端都知道这个私钥,所以只要加密算法够彪悍,私钥够复杂,数据就够安全。</p>
<h3 id="传输加密后的信息"><a href="#传输加密后的信息" class="headerlink" title="传输加密后的信息"></a>传输加密后的信息</h3><p>这部分信息是服务段用私钥加密后的信息,可以在客户端被还原</p>
<h3 id="客户端解密信息"><a href="#客户端解密信息" class="headerlink" title="客户端解密信息"></a>客户端解密信息</h3><p>客户端用之前生成的私钥解密服务段传过来的信息,于是获取了解密后的内容。整个过程第三方即使监听到了数据,也束手无策。</p>
</content>