Thursday, March 6, 2014

【写作】Writing 2012

  2012-12-24 20:56   

https://www.51zanmei.net/home-space-uid-17-do-blog-id-7802.html

2012-12-2 16:16
HOW TO WRITE

A. Topic

1. You have a subject (a person or thing), 

2. then make a topic (a phrase or sentence; 
2.a. phrase :: subject-preposition-area, area-preposition-subject; 
2.b. sentence :: subject-verb(-target), (target-)verb-subject

3. choose a theme among :: what, why, or how
3.a. what :: definition, elements, perspectives
3.b. why :: cause, motive, purpose
3.c. how :: process, development, 

B. Outline

1. Three sections :: introduction (main idea), body (supporting points), conclusion

2. Introduction :: draw attention, limit/clarify the topic, thematic question or topic statement (thesis, summary)
2.a. Attention :: significance, motive, or intention of this writing; connect to audience or great thing/person/event
2.b. Range of topic :: reader's understanding, writer's ability, time restrictions; help readers to expect, writer to focus
2.c. Make a question or statement :: bad statement discourages readers, good statement makes easy to develop writing

3. Body :: supporting points, explanation on process, examples of application, recall the topic with an impact
3.a. Fixed style :: The first sentence of each paragraph is a point statement, then anything, and the last recalls the topic
3.b. Two principles in developing :: related (through interaction), responding (to the topic or the topical keyword)
3.c. Beautify :: change voices, or express feelings; such as funny, sad, difficult, amazing, and so on
3.d. Impact in recall :: support impacts topic (or, topic impacts support), topic impacts society or person with supporting point

4. Conclusion :: summarize or briefly restate supporting points, main idea (petition, judgement)
4.a. Remind of your reasoning in brief
4.b. Remind of the main idea
4.c. Make personal attitude to topic :: favor or not, personal impact, public petition

C. Preparation

1. Read a lot :: compare different writing styles, grab all kinds of different information
2. Practice :: build up your own style, avoid mistake in grammar and spelling, find the way to clarify ideas
3. Remember :: life cannot live without writing; a good writing makes peace and unity as well as legacy
 

2012-12-2 16:29
A. paragraph

- the first sentence :  the supporting point statement
- the last sentence :  the recall, to relate point to topic, to admire the current point

B. related, responding of paragraph requirements

- related :  (in developing a paragraph) to group a list of items, to interact between items

- responding : (at the last stence) to recall the supporting point (from the first sentence of paragraph) or the topic

C. description and example

- description :  brief, principle, items
- example :  details, application, interaction
 

2012-12-2 16:55
D. introduction and conclusion

- introduction :  importance of the topic, problem-impact
- conclusion :  response to the topic, petition-resolve-action

- main idea (thesis) :  what-why-how of a subject-action; items (components), factors (external), steps (phases); 
- supporting points :  details, how; answer, example; define, explain, highlight, recall (to relate point to subject); 

- topic of subject :  subject, restricted subject, under conditions; subject, phrase, sentence; 
- - main ideas :  restricted direction of development; what, why, or how; list regarding the topic
- - supporting points :  
- introduction :  we HAVE TO talk about this topic, why; 
- body : 
- conclusion :  we HAVE TO take actions about this topic, what;

 
2012-12-2 17:15
- introduction :  impacted environment of topic
- body :  interaction of topic and its environment through sub-areas
- conclusion : responding actions of environment or us (me)



Posted by at No comments:

【写作】写小说 (1)

  2012-12-24 20:55   

https://www.51zanmei.net/home-space-uid-17-do-blog-id-7803.html

2012-12-2 17:17
2012-11-20 22:37
戏剧，小说

- 错误，错失
- 主题，模式-重复，渐进
- 布局，伏笔。发展，转折。角色
- 影射，刻画，洞见，挑战
- 影射= 现实
- 刻画= 人物，意境，感情。文字，语气，组合，对比。
- 挑战= 逆境，极限，叛逆
 

2012-12-2 17:18
2012-11-29 11:45
写小说

-- 类别
- 悲壮=以卵击石，悲情=忍痛放弃，神秘=隐身贵人，恐怖=隐身杀手，残忍=血腥欺小。
- 玄幻=魔法族群，奇幻=魔法世界，魔幻=魔法异人，科幻=未来科技。
- 黑色幽默=恐惧下的幽默。新小说=口语写实。荒诞戏=绝望而废话。意识流=脑海变换。
- 浪漫主义=传奇或逃避。现实主义=典型人物。自然主义=琐碎细节。

- 优美= 意义，配合，吸引。生动= 动作，互动，带动。想像= 不凡，组合，功效。
- 伏笔= 后门，隐藏。
- 大纲，段落，章节。

- 微型=一时，短篇=一人，中篇=一地，长篇=一世。
- 新奇，易懂。启发，奇想。
- 知识=涉略。经验=体会。
 

2012-12-2 17:18
2012-11-30 11:42
写小说

- 场景
- - 场地，穿着（定位，心情）。（事）对立难化，神秘难解。
- - 对话，动作。（地）远近变化，（人）语气定位。
- - 角度（氛围），伏笔（特意，无意）。

- 人物
- - （主角）平行对差，相对对抗。
- - （配角）丑角-贵人，催化-阻力。

- 剧情
- - （人）牵挂= 受害，补偿。美丽= 脱俗，衬托。
- - （事）爽快= 强大，克刚。悲情= 天残，挣扎。
- - （结）对立= 必争，冒犯。神秘= 反常，隐藏。
- - 主轴= 口头禅，心法。主观，洞见。
- - 发展= 对立，高潮，尾语。
- - 高潮= 奇解-意外，真相。变化。
- - 复杂= 多层，多面。重叠。
- - 变化= 情字不变，大小神化。
- - 加长= 细节-发觉，阻碍-多重。

- 篇幅
- - 微型= 意外-第三者，改变-换轨。。 抗拒，秘诀。
- - 短篇= 挑战，多挫-主动。。 师傅，追星-追逐。
- - 中篇= 流转-被动，成长-显露。。 寻宝-过关，收集-拼图。
- - 长篇= 机制-微观，架构-宏观。。 历练，动员。
 

2012-12-2 17:18
2012-11-30 12:39
写小说

- 以假乱真，真真假假。借托，哄抬。
- 心法无敌，传功练功。智慧。
- 解决问题，发掘真相。冒险。
- 淘气-可爱，霸道-冲劲，善良-爱惜，伤痕。

- 系统，隔离，供需-授受。？？
- 配乐，旁白。

- 改变故事= 增减-改变，人物-性格，细节；顺序-因果，原因-结局。
- 多重故事= 置换衔接，平行汇集-柔和交叉。
 

2012-12-2 17:28
- 冲突，动作。智慧，鉴赏。文笔，叙述。
- 单纯化（去支，特写）、夸大（强者更强）、假借（转移，恶人之善转移到善人）；烘托（假专家，名人）。
 

2012-12-3 18:33
- 临摹，改写，整合-注入，创新-风格-写己。

- 事件。情感，起因，遗憾。
- 对差，冲突。扩大，增减-转移（不实，小说的本质）
- 环境，人物。突发，勉强-错误（扣住，小说的手段）

- 名言。现实，制敌。关键时刻，巧解。
- 平凡中，不平凡。迂腐，追逐。冲撞，真相。
- 丑角。愚笨，洞见。口头禅，习惯动作。
 

2012-12-9 00:13
- 角度：看戏-第三人称。游戏-第一人称。
- 事端：环境（小人钻营、小人求生），个性（伤痛-迷恋、霸气-恶习）。
- 人物：习性、小动作。特征。工作-穿着、家庭-贫富、亲友-才智。

- 情节A：冲突、再冲突、加剧。斗气、斗智、挣扎。阴谋家、被利用、贵人-高人。
- 情节B：宝物、追逐、威力（本身、保镖）。意外、真相、假相。失去-失踪、失误、真理。
- 情节C：迷恋、失恋、报复。愚笨、执法、残忍。喜乐、恐惧（极端）、冷静（周密）。

- 看戏：男主曲线，女主曲线，男女交叉线。对手曲线，关卡线（人事时地物）。
- - 看错人，出车祸，刚离开，掉瀑布，丢钻石。
- 游戏：助力曲线，阻力曲线，助阻交叉线。暗线（阴谋，道理）。
 

2012-12-9 03:54
- 读者？-- 惊奇，爽快，学习。选边-强悍，同情-受欺压，乐观-淘气。
- 高潮？-- 猪羊变色-一夕变天，王见王-见真情，大会战-总决战。





Posted by at No comments:

【写作】写小说 -- 网文

  2012-12-24 20:52   

https://www.51zanmei.net/home-space-uid-17-do-blog-id-7817.html

2012-12-9 00:19
伏笔= 动作，能力。
关键= 物件。
蒙太奇= 不相干，却可以做对比或衔接。
紧张= 剧中人不知，时间有限，定意走偏。
角色= 主角、对手、必须同在的外力。

五官-五感，解释。具体，指明。
兴奋，意外。
悬疑，蒙在鼓里，

核心事件，作者观点。。
人物冲突，关键物体，特殊能力。。
紧张情节，剪接对比。

* 思想要物体化，物体要人物化。
 

2012-12-9 00:20
- 临摹，改写，整合-注入，创新-风格-写己。

- 事件。情感，起因，遗憾。
- 对差，冲突。扩大，增减-转移（不实，小说的本质）
- 环境，人物。突发，勉强-错误（扣住，小说的手段）

- 名言。现实，制敌。关键时刻，巧解。
- 平凡中，不平凡。迂腐，追逐。冲撞，真相。
- 丑角。愚笨，洞见。口头禅，习惯动作。
 

2012-12-9 00:20
- 发展，转折，高潮。
- 主线，辅线，事件线，感情线。
- 外貌，性格，背景，技能。
- 相遇，冲突，解决。

- 人性。旋律。
- 人物= 表情，动作，对白，思想。欲望，缺点，习性。
- 桥段= 竞争，突出-常胜，隐藏-常败。
- 伏笔= 延迟暗器，定时炸弹，触发炸弹。
- 节奏= 高低，快慢，多寡。悬疑= 无解，错解，半解。
- 创意= 观察市场，趋势，逆向。
 

2012-12-9 00:21
- 结局= 死亡，不再回。循环，徒劳。团圆，揭谜。巧解，梦境。
- 幻想，虚构，独白。
- 时间顺序，因果关系。为什么。
- 动作，表达情绪，制造事端。

- 人与事的亲热。有深远的意味。
- 道理之中（合常理），意料之外（说圆）。读者观点，读者心思。
- 原创，意外，构思。立异，常识广博，根底。
- 错字，标点符号，逻辑过错。

- 凤头（精华），猪肚（灌水），麒麟尾（完善）。构思支撑，拖戏支撑，结束才干。
- 每天更新六千字，一周四万二。周六周日三四章（凤头）。周一周二，每天两章（猪肚）。周三周四周五，三章左右，这是麒麟尾。
- 推到这个人物前，必先安排另一个。
- 进入支线情节之前，必须把一切未结束的伏笔都理顺。出支线情节的时分，必须立刻处理几个伏笔，
 

2012-12-9 00:22
- 搔到了读者的痒处，捉住了读者的心思，让读者骑虎难下，为了晓得你的故工作节开展。
- 无逻辑过错，阶段（段落）不超越400个字，没有括号弥补性文字，没有作者语，作者旁白，
- 读者群喜好特色，很少人喜好抑郁情节、重口味，宣泄、泄恨。
- 让读者厌烦的人物，感触和领会主角的生计，主角的生长和奇遇艳遇，推倒读者喜欢女主角。
- 书要稳，三千一天跑不了，书要好，六千一天不能少，书要红，一万一天都嫌少。
- 坚持一万，留五千做存稿，这叫做三分力气，只出两分，留一分应万变。
- 人物多，该杀就杀。糖葫芦串。你想让主角有什么才能，主角就有什么才能。

- 主角们没互动，角色过多，命名难读，交待冗长，视角常变（我他互变），能力没崭露，碎碎念装可爱，自恋外貌，非重要的环境，重复描写。

- 做人的原则与精神，社会现象与人文精神，决不放弃永不妥协的精神。
- 时代背景，历史背景，能力系统，相关知识。
- 采用均等多势力开局，隐藏祸患。进而激发，引导中局。渐入稳定，功成完本。
- 血缘，师徒，敌对，嫉妒，爱慕。
- 矛盾的不断转变与升级，就造成了质变，在这个质变下人物的承受极限被打破了，人物之间的关系被迫转变了。
- 放入人物关系转变和人物能力、目标，性格上的转变的描述。
 

2012-12-9 00:22
- 书名，点出主题和风格，人物，动词，纠结。
- 简介，主题，亮点。
- 章节名，

- 大胆幻想，创造新传统，
- 情节，性格发展，关系变化。契机（伤痕-武器），死党（对立-挣扎）。
- 悬疑，为什么极端、异常（反应、速度）。
- 第三人称被称为“万能角度”，绘声绘色地、多角度多层次地推进，收到极佳的效果。
- 第一人称容易拉近读者与故事的心理距离，很难讲一个复杂的过程，特别是难于揭示他人的内心世界。
- 设置环境，营造氛围。
- 欲贬先褒，欲褒先贬。是是非非。
- 生动，血肉情感。

- 地形，命名，历史。物种，合理。
- 磨难，雕琢，紧张关头。具体化（细节），戏剧化（激动，意外）。
- （高潮= 会战，决战，扫荡。？）
 

2012-12-9 00:23
- 顶尖学校，贵族学校。富男，贫女（杂草），骄女。
- 财阀，皇宫，黑帮，演艺圈。家庭乱伦，男女变身。脑残-小题大做，稚气-装萌。八婆。

- 主人公无法把握，（但是有信念）。主人公的观点和感觉。主人公有根本的变化。不可调和的愿望和目的。定时炸弹。

- 必然-偶然，合理-意外，连结物，散形法，一明一暗，欲扬先抑，欲抑先扬，一叶报春。
 

2012-12-9 00:23
- 累积题材，反复思索，萃取重点。时代精神，典型特征。由此及彼，由表及里。
- 巧遇贵人，中机关。
- 紧张，欢乐，打斗，床戏，成功。生活真谛。

- 颠覆，创新。生活，精神，意象。岔路，选择，结果。
- 明线-暗线，散开-收合。突破，加压。遭遇，哲学-定律，思想-回应。
- 洞察，敏锐。生活，生活。动作，情绪，反应。
- 喻像= 以他物喻此物。物体化。
- 「组合式」-异类，「联合式」-同类，「结合式」-动作。

- 观察，思考，采访，提问。笔记。
- 背景，人物，大纲，内容。时间，空间，主轴，逻辑。
- 情节= 发现，急转，受难，冲突，危机。
- 人物特质，读者兴趣，语言误导。景观。
- 思路= 场面，认识，细节，人物，情绪，情节，题材，情境，心理。

- 表层做真，话语、人物、场景要新要活起来。
- 中层可以理解为人生味，有学人气息或艺术水准的人生味。
- 底层回到生命感悟上来，你要表达什么。
 

2012-12-9 00:23
- 作者对作品全身心的投人和深刻理解。耐心，勇气。




Posted by at No comments:

【写作】写诗

  2012-12-24 20:51    

https://www.51zanmei.net/home-space-uid-17-do-blog-id-7818.html

2012-12-9 00:17
* 诗：
- 四言：22, 21兮; xyxz, xxyz, yzxx; 
- 五言：23; 2-21, 2-12
- 七言：43, 22-3; 22-12, 22-21

* 词 B
- 诗 23, 43。词 32, 34; 
- 诗 4, 5, 7。词 (2), 3, 5, 6, 7;; 4 4, 4 4 4, 4 3, 3 4;
- 双字：22, 222; (121), 1-23; 

* 词 A
- 单字头：3+, 1+;;  1-2, 1-22, 1-222;  
- 双字头：2+, 22+;
- 三字尾：+3, +12, +21;  1-21(?), 12-3

- 对(3 3; 4 4)；三(3 3 3; 4 4 4; 7 7 7)；
- - 前叠(5 5 4; 4 4 6)；后叠(5 4 4)；
- 增(3 4; 3 5)；减(6 5; 5 4)；
- - 二增(3 4)，三增(3 4 5)；二减，三减；
- - 增一(3 4)，增二(3 5)；减一，减二；
- - 凸(2 5 4)；凹(5 3 6)；
- - 平凸(3 4 3)，斜凸(3 5 4)；平凹，斜凹
- 九字：4 5, 5 4; 3 6, 6 3;

- 双字句做结：..., xxyy; ..., xxyyxx;

 
2012-12-9 00:18
诗歌：
- 是歌、对唱，是颂赞、颂咏，是眷恋。有音符、旋律。
- 停顿，重复。精华，有回韵。向我诉，对他冲。

散文：
- 是描述，是寄情，是对话。有动作。
- 接续，回应。完整，有关联。互动。

 
2012-12-9 00:18
诗词= 格律，平仄、押韵、对偶。四言、五言、七言，为主。
歌赋= 跳脱字数，灵活变换，以六字为主。xxyy，xyyxyy。
新诗= 跳脱平仄、押韵，写实、写情为主。口语化。

诗歌= 颂赞。有节、有顿。提称、侧写。两、三句，十字左右。
散文= 记述。有始、有终。发展、转折。五、六句，三十字左右。

新新诗= 
- 对仗（xyy xyy），短句重复（xyy xyy xyy），反对仗（xyy yyx），
- 增减（x xyy; xxy xx; 西式），插入-破格（xyy z xyy），虚字，
- 节奏= 句型单偶，字数长短，平仄声调。
- 押韵= 字首（t- 他托），字尾（-u 有漏）。

 
2012-12-9 04:18
史诗？-- 半散文，句句完整，相关、不相连。去 连接词，有头无尾。
 

2012-12-9 10:49
- 一件物体，两三句话，片段动作，联想诉情。
- 物件，序列-平行。像我，像人。一个动作，一份叹息。
- 对唱，重叠。进程（一阶阶，一步步，远近大小）。断，顿；提稱，雕琢。
- 断句，对句，叠句（型同，字同），串句（尾接头）。
- 演变，转变。


=========================


2013-2-7 00:57
写物-物体，写景-图片，写意境-感受。
写内心-思维，写电影-动画，写乐曲。




Posted by at No comments:

Python note 32

  2012-12-24 20:19   


===========================




Tom 2012-12-24 20:26
$$ Class Oriented

    def __init__(self): pass
        # main() part, to use classObjName.var; this is more convenience
        # in __inti__, have to use self.var; this is more clas-oriented
    # def __new__(cls):  pass     # for inheritance of multi-generation, multi-parent
    # def __call__(self):  pass   # for mainCObj()
    # def __init__(self):  pass   # for post-instantiation of object

Tom 2012-12-24 20:27
$$ Loading Chinese py file

    # from prs2ndu8 import *
        # prs2ndu8.py saved in utf-8
        # succeed, but require : str.decode("utf8")
        # add coding: utf-8 ;  succeed in IMPORT;  no need of decode()
    # from prs2ndu import *
        # prs2ndu.py saved in Unicode; fail in IMPORT
    # from prs2ndub import *
        # prs2ndu.py saved in Unicode big endian; fail in IMPORT
    # from prs2ndasc import *
        # prs2ndasc.py saved in ascii/ANSI endian; fail in IMPORT
        # add coding: cp936/gbk ;  fail in IMPORT
        # add coding: utf-8 ;  succeed in IMPORT

Tom 2012-12-24 20:27
$$ List

    pop([id]); remove(value);
    append(value); extend(list); insert(id, value);
    index(value); count(value); reverse(); sort();
    del list[:]/all; del [pos:stop]

    tuple
    a = (1,2), (3,4)  >>> a == ((1,2), (3,4))
    a = 1,  >>> a == (1,)
    a,b = (1,2)  >>> a==1;  b==2
    a,b = 1,2  >>> a==1;  b==2
    (a,b) = (1,2)  >>> a==1;  b==2

    list("abc")  >>> ["a","b","c"]
    tuple("abc")  >>> ("a","b","c")

Tom 2012-12-24 20:29
""" Functions to use files.

    f.open ("path/filename","type")
        The first argument is a string containing the filename.
        The second argument is another string containing a few characters
        describing the way in which the file will be used.

        mode can be 'r' when the file will only be read,
        'w' for only writing (an existing file with the same name will be erased),
        and 'a' opens the file for appending;
        any data written to the file is automatically added to the end.
        'r+' opens the file for both reading and writing. The mode argument is optional;
        'r' will be assumed if it’s omitted.

        On Windows, 'b' appended to the mode opens the file in binary mode,
        so there are also modes like 'rb', 'wb', and 'r+b'.

    f.read()
        # 'This is the entire file.\n'
    f.readline()
        # read one line at a time; 
        # then 'Second line of the file\n'

    f.readlines (intByte)
        the same as read(), but parse into lines; 
        If given an optional parameter intByte, it reads that many bytes from the file and enough more to complete a line,
    f.xreadlines()
        # the same as readlines() to read the entire file,
        # readlines() returns a list, xreadlines returns a iterator

    for line in f
         the best way to read a line;
         range() returns an iterator object; 
         iterator, a generator-like tuple, one same space for all elements, next() required
    """

Tom 2012-12-24 20:33
$$ A. List Comprehesion

    x=[]; temp2=[x.extend(list(db2[y][3:9])) for y in range(len(db2))]
    [db2[x][y] for x in range(len(db2)) for y in range(3,9) ]
        # two ways, To get all numbers into one-level list

    x=[db2[y][3] for y into range(len(db2))]
        # To get all 3rd numbers in one-level list    

    for x,y,z in ((1,2,3),(4,5,6)): print x,y,z
    for x,(y,z) in [(1,(2,3)),(4,(5,6))]: print x,y,z;
        # multiple variables in FOR statement

    print "%6.4f" % (1.0*st.count(st[0])/len(st))
        # calculate the percentage of a number
    map(lambda x: 1.0*st.count(x)/len(st), [db2[0][y] for y in range(3,9)])
        # list of percentage for a row of numbers

Tom 2012-12-24 20:33
$$ B. Iteraables

    iter(SEQUENCE)
        # sequence: list, tuple, string;
        # generate an iterator object, (S[0], S[1], ...)
    enumerate(LIST)
        # generate an iterator object, ((0, L[0]), (1, L[1]), ...)

    ITERABLES, must work with IT.next() to get next element; 
        if sequence changed before next(), then iter() changed as well;

    reduce(f(x,y), [1, 2, 3, 4])    # f(f(f(1,2),3),4)
    reduce(f(x,y), [1, 2, 3, 4], 9)    # f(f(f(f(9,1),2),3),4)
    map(f(x), [1, 2, 3, 4, 5])    # [f(1), f(2), f(3)]; map(func,iterable)
    zip("1,2,3"£¬¡±a", "b")    # ("1a", "2b"); zip(iterable, ...)

Tom 2012-12-24 20:33
$$ C. String Formatting

    str(OBJ/NUM/STRING/SEQUENCE)    # return a string
    repr(x)    # return a string for interpretation
               # replaced into repr MODULE
               # Python3 rename to reprlib MODULE
    STRING.rjust()
    STRING.center()
    STRING.ljust()
    STRING.zfill(NUM)    # fill zero

    STRING.format(value1, value2,...)    # work with {}
    'The value of PI is approximately {}.'.format(math.pi)
    '{0} and {1}'.format('spam', 'eggs')    # with ordered values
    'This {food} is {adjective}.'.format(\
    food='spam', adjective='absolutely horrible')    # with named values
    'The story of {0}, {1}, and {other}.'.\
    format('Bill', 'Manfred', other='Georg')   # with mixed
    'PI is {!r}.'.format(math.pi)    # apply repr()
    'PI is {!s}.'.format(math.pi)    # apply str()
    'PI is {0:.3f}.'.format(math.pi)    # convert to float with 3 decimals
    'PI is {0:10d}.'.format(math.pi)    # convert to integer with 10 digits long

    table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
    print ('Jack: {0[Jack]:d}; Sjoerd: \
    {0[Sjoerd]:d}; Dcab: {0[Dcab]:d}'.format(table))    # with DICTIONARY
    coord = (3, 5)
    print 'X: {0[0]};  Y: {0[1]}'.format(coord)    # with LIST

    '{:<30}'.format('left aligned')   # with length of 30 characters
    '{:>30}'.format('right aligned')
    '{:^30}'.format('centered')
    '{:*^30}'.format('centered')  # use '*' as a fill char

    '{:+f}; {:+f}'.format(3.14, -3.14)  # show PLUS and MINUS
    '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
    '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the MINUS -- same as '{:f}; {:f}'

    >>> '{:,}'.format(1234567890)    # add thousand separator
    >>> 'Correct answers: {:.2%}'.format(19.5/22)    # percentage
    >>> import datetime
    >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
    >>> '{:%Y-%m-%d %H:%M:%S}'.format(d)    # with date MODULE

    for align, text in zip('<^>', ['left', 'center', 'right']):\
    '{0:{fillx}{alignx}16}'.format(text, fillx=align, alignx=align)    # nested
    >>> octets = [192, 168, 0, 1]
    >>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)    # convert to octets
    'C0A80001'

    >>> from string import Template
    >>> s = Template('$who likes $what')
    >>> s.substitute(who='tim', what='kung pao')
    'tim likes kung pao'

Tom 2012-12-24 20:34
$$ E. Input and Output

    s = raw_input('--> ')
    print s

    >>> f.write('This is a test\n')

    >>> f.read()    # read the whole file
    >>> f.readline()    # read one line
    >>> f.readlines()    # read the whole file, and split into lines
    ['This is the first line of the file.\n', 'Second line of the file\n']

    >>> f = open('/tmp/workfile', 'w')
    >>> print f
    <open file '/tmp/workfile', mode 'w' at 80a0960>

Tom 2012-12-24 20:34
$$ F. File Functions

    FILE.open (FILEname, FILEtype)
        # file name can include PATH
        # file type: "w", "r", "a"/append, "+r"/both
    FILE.close()
    FILE.name    # file name
    FILE.fileno   # integer file id in OS
    FILE.next()    # next line
    FILE.tell ()    # current position, in byte order
    FILE.seek (OFFset, /FROM/)    # from: 0/begin of file, 1/current, 0/eof of file
    FILE.read (/NUMbytes/)
    FILE.readline (/NUMbytes/)
    FILE.readlines (/NUMbytes/)
    FILE.write £¨STRING)
    FILE.writelines (SEQUENCE)

Tom 2012-12-24 20:34
$$ G. String Functions

    STRING.strip(/'CHARstringTOdelet'/)
        # delete chars from beginning and ending until non desired
        # deafult is to delete whitespace
    STRING.lstrip(/'CHARstringTOdelet'/)    # delete from beginning
    STRING.rstrip(/'CHARstringTOdelet'/)    # delete from ending

    STRING.split (/DELIMETERstring/,/ISaddLINEfeed/)    # return a list
    STRING.splitlines (/ISappendLINEfeed/)
    STIRNGconnector.join (SEQUENCE)

    from string import maketrans   
    intab = "aeiou"
    outtab = "12345"
    trantab = maketrans(intab, outtab)    # a>>1, e>>2,...
    str = "this is string example....wow!!!";
    print str.translate(trantab, /CHARstringTOdelete/);

Tom 2012-12-24 20:34
$$ H. Regular Expression

    >>> import re
    >>> m = re.search('(?<=abc)def', 'abcdef')    # (?<=xx)yy if yy preceded by xx
    >>> m.group(0)
    'def'

    >>> m = re.search('(?<=-)\w+', 'spam-egg')
    >>> m.group(0)
    'egg'

    prog = re.compile(pattern)    # compile to re object
    result = prog.match(string)

    result = re.match(pattern, string)

    re.I, re.IGNORECASE; re.M, re.MULTILINE;
    re.compile(pattern, flags=0)
    re.search(pattern, string, flags=0)
    re.match(pattern, string, flags=0)
    re.split(pattern, string, maxsplit=0, flags=0)
    str=re.sub(pattern, repl, string, count=0, flags=0)    # replace
    tuple=re.subn(pattern, repl, string, count=0, flags=0)    # (str3, numREPL)

    >>> re.split('\W+', 'Words, words, words.')
    ['Words', 'words', 'words', '']
    >>> re.split('(\W+)', 'Words, words, words.')
    ['Words', ', ', 'words', ', ', 'words', '.', '']
    >>> re.split('\W+', 'Words, words, words.', 1)
    ['Words', 'words, words.']
    >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
    ['0', '3', '9']

    search(string[, pos[, endpos]])
    match(string[, pos[, endpos]])
    split(string, maxsplit=0)
    findall(string[, pos[, endpos]])
    finditer(string[, pos[, endpos]])
    sub(repl, string, count=0)
    subn(repl, string, count=0)

    >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
    >>> m.group(0)       # The entire match
    'Isaac Newton'
    >>> m.group(1)       # The first parenthesized subgroup.
    'Isaac'
    >>> m.group(2)       # The second parenthesized subgroup.
    'Newton'
    >>> m.group(1, 2)    # Multiple arguments give us a tuple.
    ('Isaac', 'Newton')

    >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
    >>> m.group('first_name')
    'Malcolm'
    >>> m.group('last_name')
    'Reynolds'
    >>> m.group(1)
    'Malcolm'
    >>> m.group(2)
    'Reynolds'

    >>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
    >>> m.group(1)                        # Returns only the last match.
    'c3'

    >>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
    >>> m.groups()
    ('24', '1632')

Tom 2012-12-24 20:35
$$ J. Regular Expression in JavaScript

    * Javascript

    # \.X    \b boudary, \B non boundary;
    #       \w [A-Za-z0-9_], \W non letter;  \d digit [0-9], \D non digit;
    #       \s whitespace, \S non whitespace;
    #       \. ., \" ", \$, \^;       
    #       \n line feed, \r c return; \t h-tab, \v v-tab; \f form feed;
    #       \cX eg. \cM control-M; \0 NULL;
    #       \.xHH, \uHHHH hex code; 
          
    pos    ^ beginning, ^a;  $ ending, z$
    num    a* 0 or more 'a's;  a+ 1 or more 'a's;  a? 0 or 1 'a';  
    .      one of any digit or char
    (xx)    match xx and store to groups
    (?=x)    match but not store
    x(?=y)    match aslo if followed by y
    x(?!y)    match also if not followed by y

    x|y    x or y
    {n}    a{2} 2 a's, aa;  a{1,3} a, aa, aaa;
    [x]    [xyz] x or y or z;  [^xyz] no x or y or z;    [abcd] == [a-d]
    [\b]    backspace

    exec()    re=/d(b)/g; list=re.exec(str);;  list=/d(b)/g.exec(str);
            # list, list.index, list.input, list[0] /macthed substr
            # list[1], list[2]... stored 1, 2...
            # re.lastIndex, re.source /re string;
            # re.ignoreCase, re.global / all-repeat, re.multiline; 
    test()    re.test(subSTR)
    match()    list=str.match(regEXP); 
    search()    int=str.search(regEXP); 
    replace()    str3=str2.replace(/(\w+)\s(\w+)/, "$2, $1")    # with (xx)'s
                 # str3=str2.replace(substr,newsub, flgs)
    split()    list=str.split(separator, /numlist/)

Tom 2012-12-24 20:35
$$ Dictionary
        
        # Unlike sequences, which are indexed by a range of numbers,
        # dictionaries are indexed by keys, which can be any immutable type;
        # # strings and numbers can always be keys.
        # Tuples can be used as keys if they contain only strings, numbers, or tuples;
        # # if a tuple contains any mutable object either directly or indirectly,
        # it cannot be used as a key.

        dict = {}    # empty
        dict[KEY] = VALUE    # add an item
        del dict[KEY]    # delete an item
        dict.items()
        dict.keys()
        dict.values()
        dict.get(KEY, RETURNvalueIFfail)    # get a value
        for key in dict:    # extract keys only
        for key, value in dict.items():
        KEY in dict    # same as:  KEY in dict.keys()
        VALUE in dict.values()
        dict [KEY].append(VALUE)
        dict(LIST)
        dict(sorted(DICT.items(),key lambda x=x[1])    # sorted by value
        dict(sorted(DICT.items()))    # sorted by key

        >>> tel = {'jack': 4098, 'sape': 4139}
        >>> tel['guido'] = 4127
        >>> tel
        {'sape': 4139, 'guido': 4127, 'jack': 4098}

        >>> tel['jack']
        4098
        >>> del tel['sape']
        >>> tel['irv'] = 4127
        >>> tel
        {'guido': 4127, 'irv': 4127, 'jack': 4098}
        >>> tel.keys()
        ['guido', 'irv', 'jack']

        >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
        {'sape': 4139, 'jack': 4098, 'guido': 4127}
        >>> dict(sape=4139, guido=4127, jack=4098)
        {'sape': 4139, 'jack': 4098, 'guido': 4127}

        >>> for i, v in enumerate(['tic', 'tac', 'toe']):
        # (i, v) -- ((0,'tic'), (1,'tac'), (2,'toe'))

        >>> questions = ['name', 'quest', 'favorite color']
        >>> answers = ['lancelot', 'the holy grail', 'blue']
        >>> for q, a in zip(questions, answers):
        # (q, a) -- (('name', 'lancelot'), ('quest', 'the holy grail'), ('favorite color', 'blue'))

Tom 2012-12-24 20:35
$$ Command string

        EXEC statement, exec COMMANDstring may return a value
        EVAL function, eval (EXPRESSIONstring) must return a value
        COMPILE function, compile (COMMANDstring, "", EXECfunc)
        compile(source, filename, mode[, flags[, dont_inherit]])
        EXPR function,
            returns a COMMANDstring for eval(expr(object))
            works with __repr__ in class

            # exec STATEMENTstring
            # eval EXPstring
            # map (FUNC, ARG2list, ARG3list)


            # __repr__ returns a string to execute
            # __str__ works in PRINT statement

            # inside class, only methods, def func(self, [args])
            # inside method, call by self.property and self.method

        a += b - c :: a = a + (b - c)
        [x /if switch(x) else xx/ for x in items /if filter(x)/]

Tom 2012-12-24 20:35
$$ Overview Chinese Code History

    Chinese code : Unicode ,gb2312 , cp936 ,GBK£¬GB18030
    936 Code Page (ANSI/OEM - Simplified Chinese GBK)

    # FILE HEADER of text file
    FF FE - Unicode
    FE FF - Unicode big endian
    EF BB BF - UTF-8

    UTF-8 fits to ISO-8859-1
    Chinese in 3 bytes
    GB2312, GBK, GB18020 in 2 bytes - DBCS
    AABB Chinese -- AA BB big endian, BB AA little endian

    GB2313 - CP20936
    GBK - CP936
    GB18030 supports more characters
    BIG5 - CP950

    # HISTORY
    1980 GB2312 - simplified Chinese - 7445 characters
    1983 Big5 - tranditional Chinese - 13060
    1995 GBK1.0 - 21886 characters
    2000 GB18030 - 27484 characters
    2003 Big55-2003
    2002 ISO 10646 - Unicode CNS 14649 - CJK - 20902
    2008 CNS 11643

    Unicode - UCS
    ISO - ISO 10646
    Unicode.org - Unicode
    Unicode 2.0 - ISO 10646-1
    Unicode 4.1.0
    ISO 10646-3:2003

    UTF-8, UTF-7, UTF-16, (UTF-32)
    GB18030 ~~ CP54936, but some GB18030 in 4 bytes

    UCS-2  - 2^16
    UCS-4  - 2^31
    BMP - plane0 of group0 of UCS4


Tom 2012-12-24 20:36
$$ Tip : Global variable through dummy class

    class dummy():

        # PURPOSE : to create an object to carry values among classes or functions
        
        # REASON : in class/function, cannot reach global simple variables (number, string)
        # USAGE : x=dummy(); x.a=2; del x.a; # add/remove a properties
        pass

    p = dummy()
        # global passing channel


Posted by at No comments:
Subscribe to: Posts (Atom)