text
stringlengths 101
418k
|
|---|
春秋战国史 春秋时期和战国时期，是中国的战乱时期。从公元前770年至公元前221年，共600年左右，是中国时间最长的战乱时期之一。其中大国有许多，小国也数不胜数。这是也是百家争鸣时代，所以文学作品也是多得数不清。公元前221年，秦王嬴政灭其他的楚，齐，魏，韩，赵，燕六个大国，自称秦始皇。秦二世元年，灭卫，真正统一天下，可好景不长，陈胜吴广起义，群雄四起，秦国被汉朝取代。 |
文言/入門 爲了更有系統性的進行文言的學習，本文講述了文言最基礎的內容，以及如何有效利用本教科書和其他教材進行學習。 學習其他任何一種現代的一般語言時，往往從問候開始，然而，文言作爲一種書面語言，較少使用作爲口語的問候，不過並不是說文言中不會出現或者不能表達相關意思：事實上，古文獻中常常記述先人的口語，因此如果您有興趣，可以參考上古口語一章。 儘管文言是基於上古口語的一種文體，但不代表文言就是固定死的語言，其實，隨着時代的變遷，文言文中也會帶有作者自身時代的特色。文言作爲已經使用了兩千年以上的書面語言，必然會有大量的變化，因而有時候同樣的含義會有許多種方式來表達，這往往有時會加劇初學者的恐懼感，不過如果從一個歷時的角度，即語言發展的視點來看的話，並不是那麼困難的事情。某種意義上，文言和記述現代口語的白話文，是有繼承關係的。也就是說，文言並不是和白話乖離甚遠的語言，相反地，文言不但與白話有不同的地方，也有大量一致的、沒有發生變化的地方。另外，有時我們說話或寫白話的時候，常常會通過成語等習慣表達而帶上文言的色彩。因此學習文言，其實遠遠不如學習外語困難。 緊接着，下一個階段則是對基礎詞彙的學習。詞彙是語言的基本組成單位之一，可以劃分爲表達實際含義的實詞和僅有語法功能的虛詞，兩者皆可根據具體功能進一步劃分，這裏略下不表。和古代漢語以單音節詞爲主所不同，現代漢語的詞彙（特別是實詞）大量雙音節化，以雙音節詞（即兩個字的詞）爲主，試比較：文言中稱「狐狸」曰「狐」，「老鼠」曰「鼠」，「老師」曰「師」，「學習」曰「學」，「複習」曰「習」，「其他」曰「他」，「幫助」曰「助」，「而且」曰「而」等等。不過，文言中也有雙音節詞，例如「君子」「先生」等，而白話中也有單音節詞，例如「說」「寫」「做」等。而且，這並不意味着文言中的節律是奇數的，相反其實從上古時期漢語就已經偏好偶數音節，甚至出現了僅用於調整節律的「韻律助詞」文言的虛詞，作爲實現語法功能的工具，是十分常用的，然而和現代漢語有比較明顯的差異，例如文言謂「的」曰「之」「者」，「啊」曰「矣」「也」「哉」，「嗎」曰「乎」等等。 一個文言的詞，一般都有不止一個含義，這是因爲詞會從本來的含義（稱爲本意）被用作大量其他的含義（稱爲引申意），這是世界語言中普遍的現象。有時跨越品詞和虛實的界限，而從這個詞的引申角度看，會簡單很多，比如「以」這一詞，原本是「使用」這一動詞，其中一類虛化爲表示「通過某種方式」的方式介詞，例如「儒以文亂法，俠以武犯禁」（《韓非子·五蠹》）和表示「利用某種工具」的工具介詞，例如「昌以牦悬虱於牗」（《列子·汤问》），再進一步虛化爲表示「把」的受事介詞，例如「投我以木瓜，報之以瓊琚」（《詩·衛風·木瓜》）；另外一類引申爲表示「憑藉」「依靠」的動詞，例如「富國以農，距敵恃卒」（《韓非子·五蠹》），這類動詞再虛化爲表示「由於某種原因」的介詞，例如「扶蘇以數諫故，上使外將兵」（《史記·陳涉世家》），這類介詞進一步虛化成表示「因爲」的連詞，例如「晉侯秦伯圍鄭，以其無禮於晉，且貳於楚也」（《左傳·僖公三十年》）等等。 文言作爲漢語的一種，是以漢字作爲主要文字的書面語言，因此了解漢字對文言的學習十分有幫助。首先，是古今字這一現象，語言先於文字，先有語言中的一個詞，再依靠文字寫下，因此當文字不夠用時，人們首先會假借同音的字來表示這個詞，這就是假借字，然後後人爲了辯意清晰，通過一些方式（主要是形聲字）創造了一個新的字，例如「喜悅」的「悅」字，原本是不存在的，人們想寫下這個詞的時候，用的是音近的「說」字，然而這個字是言字旁，與表示喜悅心情的含義不太符合，因此人們通過替換形旁的方式創造了另外的一個字「悅」來表示這個含義，並且逐漸取代了原本的「說」字，這最終導致了有多個字表示同一個詞；還有一類例如「然」字，本來表示燃燒的含義，後來「然」字被借去表示這樣的意思的代詞「然」，而「然」字原本的意思則通過添加形旁「火」的方式創造了「燃」這個字來表示：這些就是古今字的現象。 接下來，是對於基礎語法的學習，請參考章句文法。其實文言和白話的語法差異並不大，值得注意的區別有以下幾點： 文言的介賓結構狀語不僅僅能出現在謂語前，也可以出現在謂語後，具體出現的位置取決於介詞的種類等。 《鄭伯克段于鄢》：「鄭武公娶于申」（「于」總是在謂語後） 《荀子·勸學》：「青， 取之於藍而青於藍。」（「於」總是在謂語後） 《荀子·勸學篇》：「君子博學而日參省乎己」（「乎」總是在謂語後） 《韓非子·五蠹》：「儒以文亂法，俠以武犯禁。」（「以」往往在謂語前，但是有時在謂語後） 倒裝比現代漢語更常見。 《論語·公冶長》：「君子哉若人！」（正過來就是「若人君子哉！」） 《論語·學而》：「貧而無諂，富而無驕，何如？」（疑問句中，介詞可以在疑問詞之後） 文言的一個連詞往往有許多功能，特別是「而」字，具體做什麼功能，要看前後語境。 因爲您所閱讀的是中文維基教科書，所以我們假設您已經至少對現代漢語有一定的了解。 一個漢字一般代表一個音節，所以單音節詞往往就是一個字的詞，而雙音節則是兩個字的詞。 不過，根據對古漢語語音的研究，其實很多虛詞可能僅僅形式變了，而發音卻保留了古音，例如根據白一平-沙加爾（2014）年的擬音，「之」字古音和現在所用的「的」字是接近的。 |
俄语/常用词汇 须知：这是俄语词汇表，对于某些职业的词汇只标出阳性词汇形式。 А а 而 август 八月 автобус 公共汽车 адрес 地址 английский 英语 апрель 四月 Б бабушка 祖母，外祖母 банана 香蕉 баскетбол 篮球（运动） бассейн 游泳池 бегать (несов.) 跑，奔跑 бежать (несов.) 跑，奔跑 без 没有，无 белый 白色的 библиотека 图书馆 благодарить, поблагодарить 感谢 болезнь 疾病 болеть (несов.) 患病 болеть (несов.) 疼痛 больница 医院 больной прил, сущ. 有病的; 病人 большой 大的 бояться (несов.) 害怕 брат 兄弟，哥哥，弟弟 брать, взять 拿 брюки 裤子 бумага 纸 бывать (несов.) 常在，常到 быстрый 快的 наречие - быстро быть (несов.) 在；是 В в 在……里面；到……里面 ваш 你们的；您的 вдруг 突然 ведь 要知道 ведро 桶 великий 伟大的 вернуться сов. 回来，返回 весёлый 快乐的，愉快的 наречие - весело весна 春天，春季 весной 在春天，在春季 ветер 风 вечер 晚上 вечером 在晚上，傍晚时 взрослый 成年的 видеть, увидеть 看见，看到 вилка 餐叉 включать, включить 接通，开（ 开关） вкусный 美味的 вместе 共同，一起 внимание 注意 внук 孙子 вода 水 воздух 空气，大气 возраст 年龄，年纪 вокзал 火车站 вокруг 在……周围 волейбол 排球（运动） взволноваться 激动 вон (远处 )那里 вопрос 问题 воскресенье 星期天 восток 东，东方 вот 这就是 впервые 初次，第一次 врач 医生，大夫 время 时，时间；时代；季节 всегда 从来；总是 всё 一切（东西） вскоре 很快（就） вставать, встать 站起来； 起床 всюду 到处 вторник 星期二 входить, войти 走入； 进入；参加；成为 вчера 昨天 вчерашний 昨天的 вы 你们；您 выигрывать, выиграть 赢得 выключать, выключить 关闭， 关(开关) высокий<高的 высоко выставка 展览会 выходить, выйти 走出；走到 Г газета 报纸 где 在哪里 география 地理 герой 英雄 героиня глаз 眼睛 говорить, сказать 说；谈 ；议论；说明 год 年；时代，年代；岁数 голова 头（部），脑袋 голос 声音；嗓子 гора 山；一大堆 город 城市 городской 城市的 гость 客人 гостья (女) готовить, приготовить 准备 градус (天气、数学)度 гриб 蘑菇 грипп 流行性感 冒 грязный 肮脏的；不道德的 наречие - грязно губа 嘴唇 гулять, погулять 散步 Д да 是，是的 давать, дать 给，供给，提 供 давно 很久以前 даже 甚至 дарить, подарить 赠送，送 给 дверь 门，门口 двор 院子 девочка 女孩 девушка 少女，姑娘 дедушка 祖父，外祖父 дежурный (прил., сущ.) 值日的；值日生 декабрь 十二月 делать, сделать 做 дело 事情 день 天；节日，纪念日 деньги (мн.) 钱，货币 деревня 村庄，农村 дерево 树 дети (мн.) 孩子们；儿童们 детство 儿童时代，童 年 диван 长沙发 директор 校长，院长；经理 длинный 长的 длинно для 为了 днём 白天 до 到，直到 дождь 雨 доктор 医生，大夫；博士（ 学位） дом 房子；住所；家 дома 在家里 домашний 家庭的；家常的； 家里的人 домой 回家 дорога 路，道路；旅程 дорогой 贵的；亲爱的 наречие - дорого доска 板；榜 дочь 女儿 древний 古代的；古老的 друг 朋友 подруга (女) друг друга 互相 другой 别的，另一个的 дружба 友爱；友谊 дружить (несов.) 交友，相好 думать, подумать 想，思考 ；以为 дядя 叔叔；伯伯；舅舅 Е его 他的 её 她的 ездить (несов.) （乘车，马等）前往 если 如果 есть, поесть и съесть 吃 есть 有；是 ехать (несов.) 乘，坐，骑；行驶 ещё 又，再；还 ёлка 枞树 Ж жаль 可惜；可怜 жаркий 热的；热情的 ждать (несов.) 等候；期望 же （用于加强前 面一个词或疑问词的语气） желание 心愿；希望 желать, пожелать 希望；祝愿 женщина 妇女 живой 活的 жизнь 生命；生活 жить (несов.) 生活；居住 журнал 杂志 З за 在……后边,在……外面 ； 到……后边，到……外面 забывать, забыть 忘记 зависеть (несов.) 依靠；决定于 завод 工厂 завтра 明天 завтрак 早饭 задание 任务 задача 任务；习题 закричать (сов.) 喊叫起来 закрывать, закрыть 关上，合上 зал 厅 замечать,заметить 发现 заниматься, заняться 从事 занятие 占领；从事；课 запад 西，西方 записка 字条；便函 заплакать (сов.) 哭起来 запоминать, запомнить 记 住 засмеяться сов. 笑起来 заходить, зайти 顺便到 защищать, защитить 保卫， 捍卫，保护 звонить, позвонить 打钟； 打电话 звонок 铃；铃声 звукозапись 录音 здесь 在这里 здоровый 健康的 здоровье 健康，身体状况 здравствуй(-те) 你（您， 你们）好 зелёный 绿色的 зима 冬天 ，冬季 зимой 在冬天，在冬季 знакомиться, познакомиться 与……相识 знакомый [прил\сущ] 熟悉的，认识的；熟人 знать (несов.) 知道，了解 значить (несов.) 意思是，意味着 зонтик 伞 зуб 牙，齿 И и 和 игра 玩耍，游戏；比赛 играть, сыграть 玩 идти (несов.) 去，到；走 из 从……里面 известный 有名的 извинять,извинить 原谅 изменять, изменить 变更，改 变 изучать, изучить 研究，学习 или 或者 иметь (несов.) 有，具有 имя 名字 иначе 按另外一种方式；否则 инженер 工程师 иногда 有时候 иностранный 外国的 институт 学院；研究所 интересный 有趣的， 有意思的 интересоваться (несов.) 感兴趣 искать (несов.) 寻找 искусство 艺术 история 历史；往事 их 他们的 июль 七月 июнь 六月 К к 向，朝，往 каждый 每，每个 казаться 觉得好像 как 怎样 какой 怎样的 камень 石头 каникулы 假期 капитан 大尉 карандаш 铅笔 карта 地图 картина 画，图画 кататься 滚动；（乘车、 船等）游玩 квартира 住宅 кино (нескл.) 电影，电影院 кинотеатр 电影院 китаец 中国人 Китай 中国 китайский 中国的 класс 年级；班 класть, положить （平）放， 放到 клуб 俱乐部 книга 书 когда 什么时候 комната 房间 композитор 作曲家 компьютер 电脑，计算机 комсомолец 共青团员 конец 端；尽头 конечно 当然 конфеты 糖果 концерт 音乐会 кончать, кончить 结束；停 止 кончаться, кончиться 结束 ；停止 копейка 戈比 коридор 走廊 короткий 短的 космонавт 宇航员 кофе 咖啡 кошка 家猫 красивый 美丽的 красный 红色的 крестьянин 农民 кричать (несов.) 叫喊 кровать 床 кроме 除……外 круглый 圆的 кружок 小组 кто 谁 куда 去哪里 купаться，выкупаться 洗澡 кухня 厨房 Л лаборатория 实验室 лагерь 夏令营 ладно 好吧 лампа 灯 левый 左面的 лёгкий 轻的 лежать (несов.) 躺 лес 森林 летать (несов.) 飞，会飞 лететь, полететь 飞，飞行 лето 夏天 летом （在）夏天 лётчик 飞行员 лифт 电梯 лицо 脸，面孔 лишь 仅仅，只 лоб 额 ловить, поймать 捕 лодка 船 ложиться, лечь 躺下；睡下 ложка 勺子，匙子 лошадь 马 луна 月亮 лыжи 滑雪板 любимый 喜爱的 любить (несов.) 爱；喜欢 любой 任何的 люди 人们 М магазин 商店 магнитофон 磁带录音机 май 五月 маленький 小的 малый 小的，小量的 мальчик 男孩 мама 妈妈 март 三月 математик 数学家 математика 数学 мать 母亲 машина 机器；汽车 медленный 慢的 между 在……之间 место 地方 месяц 月；月份 метр 米,公尺 метро 地铁 мечта 幻想；理想，愿望 мечтать 幻想；向往 мешать 打扰；妨碍 мимо 从旁边（而过） минута 分；一会儿 младший 年纪较小的 многие мн. 许多人 много 许多 многое 许多东西 можно 可以 мой 我的 молодёжь 青年 молодец 好样的 молодой 年轻的 молоко 牛奶 молчать (несов.) 沉默 море 海 Москва 莫斯科 московский 莫斯科的 мост 桥 мочь, смочь 能，能够 мужчина 男人 музей 博物馆 музыка 音乐 музыкант 音乐家 мы 我们 мыть, вымыть / помыть 洗 мясо 肉 мяч 球 Н на 在……上面；到……上面 наверное 大概 над 在……上方 надо 应该 назад 向后，往后；在……前 называть, назвать 起名叫 ……，称为…… называться, назваться 称为， 叫做…… наизусть 背熟，记熟 накануне 前夜 наконец 最终 налево 往左 направо 往右 например 比如 настоящий 在的；真的 находить, найти 找到；发现 находиться 位于 начало 开始 начинать, начать 开始 начинаться, начаться 开始 наш 我们的 не 不 небо 天，天空 небольшой 不大的；不多的 недавно 不久前 недалеко 不远 неделя 星期 нельзя 不可以，不得，不能 необходимо 必须 необходимый 必要的，必须的 несколько 几个 нести,понести 拿，提，抱 нет 不；不是 никак (не) 怎么也（不） никто (не) 谁也（不） ничего 还好，还可以 но 但，但是 новый 新的 нога 腿；脚 нос 鼻子 носить (несов.) 携带；背；抱 ночь 夜，夜里 ночью （在）夜里 ноябрь 十一月 нравиться, понравиться 喜欢，中意 нужный 需要的，必要的 нужно 需要 О о 关于 оба (обе) 两个；俩 обед 午饭 обедать, пообедать 吃 (午)饭 объяснять, объяснить 解释，说明 обычно 通常，平常 обязательный 必须的 овощи 蔬菜 одевать, одеть 给……穿（衣服），给……穿上 одеваться, одеться 穿(衣服)，穿上 одежда 衣服，服装 однажды 有一次，一回 озеро 湖 оканчивать ,окончить 做完；毕业 окно 窗户 около 附近，靠近 октябрь 十月 олимпи 奥林匹克 он 他 она 她 они 他们 оно 它 опаздывать, опоздать 迟到 опасный 危险的 опять 又，再，再一次 осень 秋天 осенью （在）秋天 осматривать, осмотреть 细看；（医生）检查 оставаться, остаться 留下，留在某处 останавливаться, остановитьс я 停止，停 остановка （电车、公共汽车）车站 от 自，从，由；离 отвечать, ответить 回答；复信 р радость 快乐，喜悦 раз （一）次，（一）回 раздеваться, раздеться 脱衣服 район 地区 рано 早 раньше 原先，从前 рассказывать, рассказать 讲，说 ребёнок， ребята и дети 婴儿，小孩 редкий 稀的，稀少的 река 河，江 ресторан 饭店 решать, решить 决定；解决 рисунок 图画 Родина 祖国 родители 父母 родной 亲的 ；故乡的 рождение 诞生 роза 玫瑰花 роман （长篇）小说 Россия 俄罗斯 рот 口，嘴 рубашка 衬衫 рубль 卢布 рука 手；臂 руководить (несов.) 领导 русский (прил，сущ.) 俄罗斯的；俄罗斯人 ручка 钢笔 рыба 鱼 рынок 市场 рядом 并排；在旁边 С с 由， 自，从 сад 园子，花园 садиться, сесть 坐，坐到……上 сам 自己，本人 самолёт 飞机 самый 最；正是 сахар 糖 свежий 新鲜的 светлый 明亮的 свидание 会晤 cвободный 自由的 свой 自己的 сдавать ,сдать 交出；考试通过 себя 自己 север 北，北方 сегодня 今天 сейчас 现在 сколько 多少，若干 секунда （一）秒；（一）刹那 село 乡村 сельский 农村的；乡村的 семья 家庭 сентябрь 九月 сердце 心脏 серьёзный 严肃的；郑重的 сестра 姐；妹 сидеть (несов.) 坐；闲坐着 сильный 有气力的；强大的 синий 蓝色的 скоро 快；即将到来 слабый 弱的；不健康的 следующий 下一个的；后继的 словарь 词典 слово （单）词；话语 сложный 复杂的 случаться, случиться 发生 слушать,прослушать и послушать 听 слышать, услышать 听见；听清 смелый 勇敢的 смеяться (несов.) 笑 смотреть, посмотреть 看；观看 сначала 起初，（一）开始，首先 снег 雪 снова 再次；重新 собака 狗 собирать, собрать 收集 собираться, собраться 准备好；集合 совсем 完全 согласный 表示 同意的 соглашаться, согласиться 同意 сожаление 遗憾；怜悯 солёный 咸的 солнце 太阳 соль 盐 соревнование 竞赛；（体育）比赛 сосед 邻居 спасибо 谢谢 спать (несов.) 睡觉 спешить, поспешить 急于 спокойный 平静的 спорт 体育运动 спрашивать, спросить 问 сразу 立刻，马上 среда 星期三 средний 中间的 ставить, поставить (竖)放 стадион 体育场 становиться, стать 成为 станция 车站 старательно 努力地 стараться, постараться 努力，勤奋 старший 年长的 старый 年老的 стена 墙 стихотворение 一首诗 стоить (несов.) 价钱是，值 стол 桌子 столица 首都 столовая 食堂 стоять 站着 cтрана 国家 страница 页 странный 奇怪的 страшный 可怕的 строгий 严厉的 строить, построить 建设 студент 学生 стул 椅子 стыдно 羞愧 суббота 星期六 сумка 书包 суп 汤，汤菜 счастливый 幸福的 счастье 幸福 считать, сосчитать и посчитать 数数 сын 儿子 сюда 到这里来 Т так 这样，如此，那样 также 同样地，也是 такой 这样的 там 在那里 танцевать (несов.) 跳舞 твой 你的 театр 戏剧 текст 正文 телевизор 电视机 телепередача 电视节目；电视播送 телефон 电话 тёмный 暗的 температура 温度 теперь 现在 тёплый 温暖的 тетрадь 练习本 тётя 姑母；姨母；伯母；舅母 тихий 小声的 то 就，那么，于是 тогда 那时候 то есть 也就是 тоже 也，也是 товарищ 同学；同事 только 仅仅，只不过 тот 那，那个 точно 确切地 трамвай 有轨电车 троллейбус 无轨电车 трудный 难的 туда 到那里 тут 在这里 ты 你 тяжёлый 重的 У у 在旁 边 убегать, убежать 跑开 уважать (несов.) 尊敬 удивительный 奇怪的 удивляться, удивиться 惊奇 удовольствие 愉快，高兴 уезжать, уехать （乘车、马等）到……去 уже 已经 ужин 晚饭 узнавать, узнать 认 出 улица 街道 улыбаться, улыбнуться 微笑 улыбка微笑 уметь (несов.) 会 умный 聪明的 университет （综合）大学 урок课 успевать, успеть 来得及 успех 成绩 уставать, устать 疲劳 утро早晨 утром （在）早晨 ухаживать (несов.)照料 уходить, уйти 离开，离走 участвовать (несов.) 参 加 учебник教科书 учебный 教学的；学习的 ученик学生 учёный学者 учитель 教师 учить, выучить教；学； 背诵 учиться, выучиться и научиться 学 习 Ф фабрика 工厂 фамилия 姓 февраль 二月 физик 物理学家 физика物理 физкультура 体育 фильм 电影片 фото照相；照片 фотографировать 拍照，摄影 фотография 照片 фрукты水果 футбол足球（运动） Х хватать, хватить 足够 химия 化学 хлеб面包 ходить (несов.) 走，去 хозяин主人 холодильник 冰箱 холодный 冷的 хороший 好的 хотеть (несов.)想，要 хотеться (несов.)想，要 хотя虽然，虽说 художник 艺术家 Ц цвет颜色 цветной 彩色的，有色的 цветок花 целовать, поцеловать 吻 целый 整的，完整的 цена价格 центр 中心 центральный 中心的 Ч чай 茶 час 小时 частый经常的，时常的 часы мн 手表 чей 谁的 человек 人 через 经过 чёрный黑色的 честный 诚实的 четверг 星期四 число 数 чистый清洁的 читальня 阅览室 читать, прочитать, прочесть разг. 读 член 成员 что 什么 чтобы 为了，为的是 чувствовать (несов.) 觉得 чужой 别人的，人家的 чуть一点儿，稍微 Ш шапка 帽子 шахматы （国际）象棋 шея 脖子 широкий 宽的 шкаф 柜子 школа 学校 школьник 中学生 шофёр （汽车）司机 шуметь (несов.) 响 Щ щека 面颊 щётка 刷子 щи菜汤 Э экзамен 考试 этаж 楼层 это 这 этот 这个 Ю юг 南,南方 юноша 少年人；青年人 Я я 我 яблоко苹果 являться, явиться 是；出现 язык 语言 январь一月 ясный 晴朗的 |
世界语/信息/世界語簡史 世界語(Esperanto)，舊譯萬國新語，旨在成為世界通用語。波蘭猶太人眼科醫生柴門霍夫在對其進行了十年的創作工作後於1887年出版《第一本書》，創立了這個語言的基礎，他創造這門語言是為了促進各國人民友好相處。 |
藥物化學/抗癌藥/Bcr-Abl 激酶抑制劑 第一個 TKI（酪氨酸激酶抑制劑） 在正常細胞中，Bcr（breakpoint cluster region）和 Abl 基因位於不同的染色體上，編碼出不同的蛋白質，但在慢性骨髓性白血病（CML）中，染色體 9 和 22 上的基因互相交換，交換後的染色體我們稱為費城染色體（Philadelphia chromosome），原本位於不同染色體的 Bcr 和 Abl 基因，現在融為一塊，融為一塊的這段基因編碼出致癌蛋白 Bcr-Abl，也稱為 Abelson 酪氨酸激酶，最後導致薄血球計數升高 AbI domain 點突變，尤其是氨基酸序列第 315 號從 Thr 換成Ile（T315I 突變） BCR-ABL 基因表現量上升 P-gp 基因表現量上升 有機陽離子轉運酶-1 蛋白質基因 能抵抗 T315I 突變 Bosutinib Dasatinib Imatinib Nilotinib Omacetaxine Mepesuccinate Ponatinib Radotinib |
春秋战国史/前言 1.这本书虽然不是专业人员编写的，但参考有很多。从传言到网络，从古书到教科书，内容很杂，要编写是极不容易的。史籍浩如烟海，想综合起来是非常难的。史实和谣言，是要分清楚的。这本书可能也有很多讹误，希望大家指正。 2.现在的书，大多是编年体的，我这本书，是仿照二十四史写的（即"纪传体“）这样可以从多方面来叙述，分类可以使书本更明确，更简洁。这本书的方式和二十四史相同，但做了一些改进。 3.这本书的引用大多数是古文，编写的时候是换行写的，引文是黑体字，中间的注释是斜体字，请读者分清。 4.参考引用的书，基本上都标明作者和书名篇章。作者不明确的书，一律不标。 5.参考的书，……表示词句有删节，…………表示自然段有删节。 |
溫嶺話 溫嶺話是吳方言台州片南台小片的方言。 一 ih 二 ni 三 sae 四 sy 五 ng 六 loh 七 chih 八 peh 九 ciou 十 zhih 何物 ka-m 「我弗識（sheh ）到底（dau-di ）講（gong ）何物。／我不知道你到底在說什麼。」 |
俄语/基础语法 '"俄语语法基本简要概述"' 俄语中的词分为10类： 有词形变化： 名词：комната（房间） 形容词：большой（大的） 数词：один（一），первый（第一） 代词：он（他），это（这个） 动词：слушать（听） 无词形变化： 副词：хорошо（好） 前置词：на（在...上） 连接词：и（和） 语气词：да（是） 感叹词：ах（哎呀） 名词有性、数、格的变化。数有单、复两个数，性分阳、阴、中三性，复数不分性。主格（1格）、宾格（4格）、与格（3格）、属格（2格）、工具格（5格）和方位格（6格，前置格），各有变格规则。 详见 俄语/名词 3以后的基数词无性、数范畴， 但有格的变化。 序数词1-10： первый，второй，третий， четвёртый，пятый，шестой，седьмой，восьмой，девятый，десятый 序数词有性、数、格的变化，同硬变化形容词，但 третий 的变化特殊。 详见 俄语/数词 形容词分性质形容词和关系形容词。性质形容词分长尾和短尾形式及原级、比较级和最高级 3个等级。详见 俄语/形容词 动词有式、时、人称、体等范畴。式分陈述式、命令式、条件式。时分现在时、过去时、将来时。单数过去时动词形式分阳、 阴、 中三性。体分完成体和未完成体。完成体表示已经完成或将要完成的动作；未完成体表示持续的动作。两种体各有不同的不定式。动词通过词尾变化可构成副动词、形动词形式。 详见 俄语/动词 详见 俄语/代词 句子语序非常灵活，被强调的成分往往出现在句首。 |
藥物化學/抗癌藥/Epothilones/Ixabepilone 從Sorangium cellulosum 發酵而來 來自Epothilone B，為了增加水溶性與 P-gp 帶來的問題，將酯基改成醯胺 以 cremophor EL 為其劑型，故可能會有過敏反應，所以治療前的預防行為是必須的 |
文言/口語 儘管文言是一種書面語言，然而作爲文言準繩的上古文獻中，時常出現口語表達，因此，在本課程中也對上古口語作簡要的介紹。 「無恙？」表示「你好嗎？」 「然」「然也」表示「是這樣的」，「不然」「非也」則表示「不是這樣的」。 「善」表示「好的」。 「諾」。 「拜德」表示「謝謝」 「吾之過也」表示「是我的錯」 维基學院中的相關論述或教學： Subject:華製新漢語及中文固有語/上古語考輯 |
现代标准汉语/文字 文字（英语：script）是人类用来记录传播语言的书写系统（英语：writing system）。文字是语言的视觉形式，让语言能够突破时间和空间的限制，更广泛地传播。此外，语言用文字记录下来，能够更好地推敲、琢磨。因此，一般来说，用文字记录的语言——书面语——比口语更有条理，更加严密细致。文字对语言的发展有促进作用。 文字或者书写系统并不是语言的组成部分，但是学习语言时，了解其使用的的书面形式是必要的。本章我们学习一下汉字的基本知。 汉字（hani）是为记录汉语而发明的文字，汉语也一般用汉字来记录。本书也采用汉字来记录汉语。 汉字有如下特点。 世界上的文字多数是表音文字。表音文字用符号直接表示语音。有些文字用符号表示音节，是音节文字；如韩语使用的谚文，「언」表示/ʌn/这个音节。有些文字用符号表示音素，是音素文字；如拉丁语使用的拉丁字母，「D」表示/d/这个音素。文字形式通过语音这个中介来表达意义。譬如英文「tiger」，它表示语音/ˈtaɪɡə/，而语音/ˈtaɪɡə/表示「老虎」這個意义——那麼，「tiger」通過語音間接表示「老虎」這個意义。 汉字不一样。漢字並不記錄語音，而直接表示語義，因此，漢字是表意文字。漢語中大部分詞語都能分解到一個個音節——它們是是语言中最小的有意义的成分，稱作语素。而漢字就直接記錄這些語素。因此漢字是語素文字。 雖然一個漢字一般表示一個音節，但是漢字並不是音節文字，因為一個音節可能有多個字來記錄。而韓語使用的諺文，一個音節只對應一個字。 漢字記錄語素，因而漢字的數量很多。公元二世紀初的字書《說文解字》已經收錄了近一萬字，十八世紀的《康熙字典》收錄四萬七千餘字。截至2023年，Unicode已經收錄「中日韩统一表意文字」（英语：CJK Unified Ideographs）計97,680字。 然而，漢語中常用字並沒有那麼多，只有四千字左右。 汉字音、义二维，与语义的联系有特定性，与语音的联系不具特定性。 漢字的笔画总是分布在一个方块里，不论笔画的多少。 https://www.termonline.cn/word/120214/1#s1 北大本p.145 黄廖本p.137 中文维基百科：汉字 中國大陸《通用规范汉字表》（2013）收8105字，其中常用字3500；臺灣《常用国字标准字体表》（1982）計4808字；香港《常用字字形表》（1986）在2012年重排本中收4762字。 |
俄语/日常对话 俄语对话 酒店对话 1. ――Простите, как мне попасть （пройти） в номер 914? ――А вы проживаете в гостинице? Тогда надо показать гостевую карточку. ――Нет, не проживаю. Здесь остановился мой коллега. Он тоже приехал на конгресс. ――Ах, вот как. Прошу вас： на 9-ом （девятом） этаже останавливаются третий и пятый лифты. ――Лифт справа? Вижу, спасибо. ――На этаже спросите у дежурной. Она вас проводит. ――Там я сам разберусь. Всё в порядке! ――请问，到914房间怎么走？ ――您是住在这个旅馆的吗？那么，先要出示住宿证。 ――不，我不住这儿。我的同事住这儿，他也是来开会的。 ――啊，是这样的。您请乘第3号或第5号电梯到9层。 ――电梯是在右边吗？看见了，谢谢。 ――到了第九层问值班员？她会带您去的。 ――到那儿我自己就能找到，没问题。 2. ――Простите, вы мне не поможете? ――Пожалуйста, в чём дело? ――Просто не знаю, как быть. Моя подруга приехала из Киева и остановилась в вашей гостинице, а номер забыла сообщить. ――Конечно, я помогу вам. Как фамилия и имя вашей подруги? ――Алексеева... Алексеева Ольга Дмитриевина. ――Так, посмотрим в регистрационной книге. Алексеева Анна... Это не то，а вот — Алексеева Ольга Дмитриевна - номер 914. ――Спасибо большое, вы мне так помогли! Номер 914. Где же это? ――Подождите, подождите, вы не туда пошли. Лифт прямо и налево. ――Спасибо большое. ――对不起，您能帮帮我的忙吗？ ――别客气，什么事？ ――我简直不知道该怎么办，我的女朋友从基辅来，住在你们旅馆，可她忘了告诉我房间号码了。 ――当然，我来帮您。您女朋友的姓名？ ――阿列克谢耶娃……奥丽加?德米特里耶芙娜?阿列克谢耶娃。 ――我查一查登记簿。阿列克谢耶娃，安娜……这不是，啊，在这儿，阿列克谢耶娃?奥丽加?德米特里耶芙娜，914房间。 ――太谢谢您了，多亏您帮忙！914房间，在什么地方？ ――等一等，等一等！不是往那儿走！一直往前，电梯就在左边。 ――多谢了。 3. ――Девушка, вы кого-то ищете? ――Здравствуйте, я никак не пойму, где находится номер 914 （девятьсот четырнадцать）? ――Девятьсот четырнадцатый номер на девятом этаже. ――А где мне лучше подняться? ――Пройдите к лифту, это там, направо. ――Большое спасибо. ――Если не найдёте, спросите у горничной. ――姑娘，您是在找人吧？ ――您好！我怎么也搞不清，914房间在哪儿？ ――914房间在九层。 ――我从哪儿上去好呢？ ――您乘电梯，在那儿，右边。 ――多谢您。 ――要是找不到，问一下服务员。 4. ――Внимание! Сейчас я вам прочитаю список номеров, а вы сразу говорите мне, кто где хочет жить. Номер 517 （пятьсот семнадцать）, двухместный. ――Можно нам? ――Пожалуйста. Записываю. Сейфулла Диалло с супругой. Вы будете жить в пятьсот семнадцатом номере. Дальше - номер 127 （сто двадцать семь）, одноместный. ――Предлагаю оставить этот номер профессору Кейго. Ему будет удобнее на первом этаже. ――Совершенно верно. Хорошее предложение. ――Нет возражений? Профессор, ваш номер127. ――请注意！现在我给你们念一下房间号码，请你们马上告诉我，哪位想住哪间。517号，双人房间。 ――我们俩住可以吗？ ――请吧，我登记上，谢伊富拉?季阿洛夫夫妇。你们住517房间。下一间是127号，单人房间。 ――我建议这间房给克伊托教授，他住一层方便些。 ――完全正确。这意见很好！ ――没有不同意见吧？教授，您的房间是127号。 搞笑对话 1. ――Почему вы не женитесь? — спросил юноша старого холостяка. ――Видишь ли, — отвечал тот, — когда я был молод, то решил не жениться до сих пор, пока не встречу идеальной женщины. Прошло много лет, и я встретил такую женщину. Но оказалось, что она ищет идеального мужчину. ――您怎么不结婚呀？－年轻小伙儿问老光棍儿。 ――你看，老光棍回答说，我年轻时候决定不遇到理想的女人就不结婚。 很多年过去了，我遇到了这样的女人。可结果她竟在寻觅理想的男人。 2. ――Выходи за меня замуж! ――Хорошо. ――Тишина... ――Почему ты больше ничего не говоришь, дорогой? ――Я и так сказал лишнее... ――嫁给我吧！ ――好的。 ――片寂静...... ――你为什么不再说些什么了，亲爱的？ ――我已经说走嘴了,说了自己不该说的话了...... 3. ――Убеждённый холостяк говорит приятелю: ――Женщины хуже гангстеров. ――Это почему? ――Потому что гангстеры требуют кошелёк или жизнь, а женщины и то и другое. ――一个铁杆儿光棍对朋友说： ――－女人比强盗更甚。 ――－为什么？ ――－因为强盗要么要钱包，要么要你的命，可女人两者都要。 |
藥物化學/抗癌藥/Estramustine 結構上，歸屬 Aziridine 類的藥物，但因其有抑制微管的作用，故分類於有絲分裂抑制劑 主要與MAP-4 結合，促進微管去聚合，次要為與 DNA 交聯反應 βm 微管表現量上升 |
文言/助詞 助詞是最虛的一類詞，特別是結構助詞僅有分隔和標識的作用。文言的助詞主要有結構助詞、時態助詞、語氣助詞和韻律助詞等。 結構助詞有「之」「所」等。 「N1之N2」，相當於「N1的N2」 《石鐘山記》：「窾坎鏜鞳者，魏莊子之歌鐘也」 《左傳·襄公十四年》：「余弟死而子來．是而子殺余之弟也。」 《蘭亭集序》：「暮春之初，會于會稽山陰之蘭亭」 《莊子·養生主》：「今臣之刀十九年矣。」 《說苑·貴德》：「此乃秦之所以亡天下也」（這就是秦失去天下的原因） 「N主語之P」，取消句子獨立性，相當於「N主語P這件事」 《左傳·僖公二十二年》：「天之棄商久矣。」 《禮記·禮運》：「大道之行也，天下為公」 「所V」，使動詞性短語名詞化，相當於「V這件事」「做V這件事的人或事物」 《說苑·貴德》：「此乃秦之所以亡天下也」（這就是秦失去天下的原因，「所以」相當於「所憑藉」「憑藉的東西」，也就是說「原因」） 即表示動作時間狀態的助詞。 完成體助詞有「矣」等，表達動作已經完成，相當於「了」。 《史記·五帝本紀》：「女謀事至而言可績，三年矣。」（直譯：你做事到位、說話可成事，已經三年了；意譯：你這三年做事做得到位，說話可以成事。） 《鄭伯克段于鄢》：「可矣！」（可以了！） 《論語·爲政》：「溫故而知新，可以爲師矣。」（溫習舊知而悟出新知，那麼就可以做老師了） 《項脊軒志》：「庭有枇杷樹，吾妻死之年所手植也；今已亭亭如蓋矣。」（庭院裏有枇杷樹，是我妻子死的那一年親手種植的；現在已經亭亭如蓋了。） 表示肯定語氣的助詞有「也」等。見判斷句。 「S也」 《史記·陳涉世家》：「陳勝者，陽城人也」（陳勝是陽城人） 《岳陽樓記》：「此則岳陽樓之大觀也」（這就是岳陽樓壯觀的景象） 《詩品》：「使味之者無極，聞之者動心，是詩之至也。」 表示感嘆語氣的助詞主要有「哉」、「夫」、「矣」和「乎」等。 「S夫」 《莊子·在宥》：「悲夫，有土者之不知也！」 《莊子·在宥》：「不明於道者，悲夫！」 《蘭亭集序》：「後之視今，亦由今之視昔，悲夫！」（後人看今人也就像是今人看前人，可悲啊！） 《報任少卿書》：「悲夫！悲夫！事未易一二為俗人言也。」 《寒花葬誌》：「事我而不卒，命也夫！」 「S矣」 《論語·學而》：「其爲人也孝弟，而好犯上者，鮮矣。」（……是很少的！） 韻律助詞是一類較特殊的助詞，其作用是補齊韻律，湊齊偶數音節，使詩文更加整齊，往往在辭、詩等文體中常見，而散文少見，有「其」「之」等。 「X奇數音節之」 《曹劌論戰》：「公將鼓之」（鼓：動詞，擊鼓） 《資治通鑑·漢紀五十七》：「頃之，煙炎張天，人馬燒溺死者甚眾。」（頃：一會兒） |
藥物化學/抗癌藥/Via Alkaloids 來自長春花（ Catharanthus roseus） 由兩個聚環片段組成，分別是 catharanthine（或稱 velbanamine）與 vindoline，這兩個是必要結構 三個藥物在結構上的不同分別是 C6' 和 9' （在catharanthine）之間的碳數、C4' 的取代基（olefin 和 三級醇），以及 N1上的取代基（甲基和甲醛） C18'和 C2'的立體化學被認爲在藥物活性上是重要的 抑制微管聚合 三個上市的此類藥物中，Vincristine 與微管結合能力最強，Vinblastine 結合能力最弱；但 Vinblastine 的清除速率是最慢，因此有較長的末端生物半衰期，而其他兩種藥，因為太脂溶性，而容易被組織排除 p53 基因突變，導致 MAP4 調節微管聚合 P-gp Vincristine Vinblastine Vinorelbine |
春秋战国史/卷一 秦本纪第一 秦国的祖先，史记上说： 秦之先，帝颛顼之苗裔孙曰女脩。女脩织，玄鸟陨卵，女脩吞之，生子大业。大业取少典之子，曰女华。女华生大费，与禹平水土。已成，帝锡玄圭。禹受曰：“非予能成，亦大费为辅。”帝舜曰：“咨尔费，赞禹功，其赐尔皁游。尔後嗣将大出。”乃妻之姚姓之玉女。大费拜受，佐舜调驯鸟兽，鸟兽多驯服，是为柏翳。舜赐姓嬴氏。 《史记正义》据《修女传》，大业即皋陶，伯翳即益。 大费生子二人：一曰大廉，实鸟俗氏；二曰若木，实费氏。其玄孙曰费昌，子孙或在中国，或在夷狄。费昌当夏桀之时，去夏归商，为汤御，以败桀於鸣条。大廉玄孙曰孟戏、中衍，鸟身人言。帝太戊闻而卜之使御，吉，遂致使御而妻之。自太戊以下，中衍之後，遂世有功，以佐殷国，故嬴姓多显，遂为诸侯。 ……缪王以赵城封造父，造父族由此为赵氏。自蜚廉生季胜已下五世至造父，别居赵。造父，柏翳的后代之一，是赵国的祖先。赵衰其後也。恶来革者，蜚廉子也，蚤死。有非子 也是柏翳的后代之一。居犬丘，好马及畜，善养息之。犬丘人言之周孝王，孝王召使主马于汧渭之间，马大蕃息。孝王欲以为大骆適嗣。申侯之女为大骆妻，生子成为適。申侯乃言孝王曰：“昔我先郦山之女，为戎胥轩妻，生中潏，以亲故归周，保西垂，西垂以其故和睦。今我复与大骆妻，生適子成。申骆重婚，西戎皆服，所以为王。王其图之。”於是孝王曰：“昔伯翳为舜主畜，畜多息，故有土，赐姓嬴。今其後世亦为朕息马，朕其分土为附庸。”邑之秦，使复续嬴氏祀，号曰秦嬴。亦不废申侯之女子为骆適者，以和西戎。 |
高中化学竞赛/范德华力、氢键 我们在《化学选修3》课本中已经对极性分子和非极性分子已有一定的了解，并且知道 双原子的单质分子都是非极性分子，例如H2{\displaystyle {\ce {H2}}}，O2{\displaystyle {\ce {O2}}}等； 双原子的化合物分子都是极性分子，如CO{\displaystyle {\ce {CO}}}，HCl{\displaystyle {\ce {HCl}}}等。 类似于上述的规律。现在我们要对分子的极性进行进一步的学习。 对于任何一个分子，我们总能找到它的正电荷中心和负电荷中心（也有教材写作正电荷重心和负电荷重心）。如果正电荷中心和负电荷中心重合，那么这个分子就是非极性分子；如果不重合，那么就是极性分子。 正电荷中心和负电荷中心所带的电量一定是相同的，因为一个分子整体上显电中性。 在极性分子中，正电荷中心和负电荷中心之间的距离称为偶极长，用符号d{\displaystyle d}表示。正电荷中心或负电荷中心所带的电量我们常用q{\displaystyle q}表示。那么我们可以定义一个度量极性大小的物理量——偶极矩μ=q⋅d{\displaystyle \mu =q\cdot d}。偶极矩的单位常用德拜 维基百科中的相关条目： 德拜 （D{\displaystyle {\mbox{D}}}）表示，1 D=3.33564×10−30 C⋅m{\displaystyle 1\ {\mbox{D}}=3.33564\times 10^{-30}\ {\mbox{C}}\cdot {\mbox{m}}}。当然，偶极矩在非极性分子中也是适用的，只是d=0{\displaystyle d=0}进而μ=0{\displaystyle \mu =0}而已。 偶极矩是一个矢量，具有大小和方向。与物理相反，化学中的偶极矩的方向是从正电荷到负电荷。 实验测得一些分子的偶极矩如下表： 在上文中所提到的偶极矩是分子自始至终存在的，我们把它称为固有偶极或永久偶极。 在外电场的作用下，（极性或非极性）分子也可能产生一个偶极矩，成为一个具有一定偶极的极性分子。我们将这样的偶极称为诱导偶极。其偶极矩称为诱导偶极矩，用符号Δμ{\displaystyle \Delta \mu }表示。 即使没有外加电场，由于分子中的原子核以及核外电子在不停的运动，也会产生一个瞬间的正电荷中心与负电荷中心不重合的情况，称为瞬间偶极，其偶极矩被称为瞬间偶极矩。分子越大，越容易变形，瞬间偶极矩越大。 取向力是极性分子因固有偶极而产生的静电引力。右图是水分子之间的取向力示意图。通过物理知识（两个点电荷之间的静电引力F=kQqr2{\displaystyle F=k{\frac {Qq}{r^{2}}}}）我们可以猜测：取向力的大小与分子的偶极矩和距离有关。事实上，取向力与下面这三个因素相关：取向力与分子的偶极矩的平方成正比，与热力学温度成反比，与分子间距的七次方成反比。 在极性分子的固有偶极诱导下，临近它的分子（无论是极性分子还是非极性分子）会产生诱导偶极，分子间的诱导偶极与固有偶极之间的电性引力称为诱导力。诱导力与极性分子的偶极矩的平方成正比，与被诱导分子的变形性（常用物理量“极化率”来表示，符号为α{\displaystyle \alpha }）成正比，与分子间距的七次方成反比。但与取向力不同的是，诱导力与温度无关。 色散力是由于瞬间偶极而产生的相互作用力。色散力没有方向，因为分子的瞬时偶极矩的矢量方向时刻在变动之中，瞬时偶极矩的大小也始终在变动之中。量子力学的计算表明，分子的变形性越大，色散力越大。同样的，色散力与分子间距的七次方成反比，此外还与相互作用的分子的电离势有关。 范德华力是取向力、诱导力、色散力的总称。一般来说，色散力占范德华力中的极大部分，但水分子和氨分子是特例，它们的分子间作用力以取向力为主，详见下方的表格。范德华力不像共价键，没有方向性和饱和性，也不受微粒之间的方向与个数的限制。它是分子（或原子）之间永恒存在的一种作用力，比化学键的作用力小一至二个数量级。 |
國中數學/國中數學七年級上冊/1-4 指數記法與科學記號 在數學中，我們把一個數字 n {\displaystyle n} ，連乘 a {\displaystyle a} 次時，可以簡記為 n a {\displaystyle {\color {Orange}{n^{a}}}} ，讀做「 n {\displaystyle n} 的 a {\displaystyle a} 次方」。這種運算方式也被稱為冪運算。 在這個例子中，我們稱 n {\displaystyle n} 為這個指數的「底數」， a {\displaystyle a} 為這個指數的「指數」。 當一個指數律，其指數為1時，通常會省略不記。例如： 5 1 {\displaystyle {\color {Orange}{5^{1}}}} 會記為 5 {\displaystyle {\color {Orange}{5}}} 。 當一個指數律，底數為0時，例如 0 1 {\displaystyle 0^{1}} 、 0 2 {\displaystyle 0^{2}} 、 0 3 {\displaystyle 0^{3}} 等， 0 n {\displaystyle {\color {Orange}{0^{n}}}} ( n ≠ 0 ) {\displaystyle (n\neq 0)} 的值都會是 0 {\displaystyle {\color {Orange}{0}}} 。 當一個指數律，底數為1時，例如 1 1 {\displaystyle 1^{1}} 、 1 2 {\displaystyle 1^{2}} 、 1 3 {\displaystyle 1^{3}} 等， 1 n {\displaystyle {\color {Orange}{1^{n}}}} 的值都會是 1 {\displaystyle {\color {Orange}{1}}} 。 當一個指數律，指數為0時，例如 1 0 {\displaystyle 1^{0}} 、 2 0 {\displaystyle 2^{0}} 、 3 0 {\displaystyle 3^{0}} 等， n 0 {\displaystyle {\color {Orange}{n^{0}}}} 的值都會是 1 {\displaystyle {\color {Orange}{1}}} 。 7 × 7 × 7 × 7 × 7 × 7 {\displaystyle 7\times 7\times 7\times 7\times 7\times 7} 的指數記法為： ( − 3 ) × ( − 3 ) × ( − 3 ) × ( − 3 ) {\displaystyle (-3)\times (-3)\times (-3)\times (-3)} 的指數記法為： 0 0 {\displaystyle 0^{0}} 的值為： 1 1000 {\displaystyle 1^{1000}} 的值為： 承 隨堂練習1 ，我們知道如何簡記冗長的乘法表達式，接著要來運算它。 ( − 3 ) 4 {\displaystyle (-3)^{4}} 的值即為 ( − 3 ) × ( − 3 ) × ( − 3 ) × ( − 3 ) {\displaystyle (-3)\times (-3)\times (-3)\times (-3)} ，也就是 81 {\displaystyle 81} 。 − 3 4 {\displaystyle -3^{4}} 的值即為 3 × 3 × 3 × 3 {\displaystyle 3\times 3\times 3\times 3} ，也就是 − 81 {\displaystyle -81} ，請務必記得觀察負號的位置。 在四則運算時，我們將指數視為一個括號「 ( ) {\displaystyle ()} 」，應該先算。 例如， 500 {\displaystyle 500} ÷ ( − 5 ) 2 {\displaystyle (-5)^{2}} 應該先算 ( − 5 ) 2 {\displaystyle (-5)^{2}} ，再將 500 {\displaystyle 500} ÷ 25 {\displaystyle 25} ，其值為 20 {\displaystyle 20} 。 切記，指數運算完畢後再遵循「先乘除後加減」的規定。 如果 a {\displaystyle a} 是正數且 a > 1 {\displaystyle a>1} ， n {\displaystyle n} 越大， a n {\displaystyle a^{n}} 值會越大； 如果 b {\displaystyle b} 是正數且 b < 1 {\displaystyle b<1} ， n {\displaystyle n} 越大， b n {\displaystyle b^{n}} 值會越小。 一張紙摺疊32次後，可以到達月球。 假設你原來的能力為1，每天進步百分之一，一平年之後你的能力會是37.8。( ( 1.01 ) 365 ≈ 37.8 {\displaystyle (1.01)^{365}\approx 37.8} ) 假設你原來的能力為1，每天退步百分之一，一平年之後你的能力會剩下0.03。( ( 0.99 ) 365 ≈ 0.03 {\displaystyle (0.99)^{365}\approx 0.03} ) ( − 2 ) 4 {\displaystyle (-2)^{4}} 的值為： − 2 3 {\displaystyle -2^{3}} 的值為： 64 {\displaystyle 64} ÷ ( − 2 ) 2 {\displaystyle (-2)^{2}} 的值為： 令 a = ( 1.5 ) 100 {\displaystyle a=(1.5)^{100}} ， a = ( 1.5 ) 101 {\displaystyle a=(1.5)^{101}} ， a = ( 1.5 ) 102 {\displaystyle a=(1.5)^{102}} ，試比較 a {\displaystyle a} 、 b {\displaystyle b} 、 c {\displaystyle c} 的大小。 令 d = ( 0.5 ) 100 {\displaystyle d=(0.5)^{100}} ， e = ( 0.5 ) 101 {\displaystyle e=(0.5)^{101}} ， f = ( 0.5 ) 102 {\displaystyle f=(0.5)^{102}} ，試比較 d {\displaystyle d} 、 e {\displaystyle e} 、 f {\displaystyle f} 的大小。 當我們在表示一個極大的數或極小的數時，我們通常會使用科學記號來表示它。像 22 , 000 , 000 {\displaystyle 22,000,000} 或是 0.0000035 {\displaystyle 0.0000035} 這種數就非常適合用科學記號來表示。 在科學記號中，我們會使用到10的次方來表示。我們知道 10 1 {\displaystyle 10^{1}} 就是 10 {\displaystyle 10} 、 10 2 {\displaystyle 10^{2}} 就是 100 {\displaystyle 100} 、 10 3 {\displaystyle 10^{3}} 就是 1000 {\displaystyle 1000} …… 那麼小數應該如何表示呢？ 透過觀察上面的表格。其實不難發現，每當位值變為 10 {\displaystyle 10} 倍時， 10 {\displaystyle 10} 的次方會增加 1 {\displaystyle 1} ；每當位值變為 1 10 {\displaystyle {\frac {1}{10}}} 倍時， 10 {\displaystyle 10} 的次方會減少 1 {\displaystyle 1} 。因為 1 {\displaystyle 1} 是 10 {\displaystyle 10} 的 0.1 {\displaystyle 0.1} 倍，我們規定 1 = 10 0 {\displaystyle 1=10^{0}} 。同理也可以應用在 0.1 = 10 − 1 {\displaystyle 0.1=10^{-1}} 、 0.01 = 10 − 2 {\displaystyle 0.01=10^{-2}} ，以此類推。 事實上，如果 m {\displaystyle {\color {Orange}{m}}} 是正整數，則 ( 0.1 ) m = 10 − m {\displaystyle {\color {Orange}{(0.1)^{m}=10^{-m}}}} 。 補充：科學上也常常使用底數為 10 {\displaystyle 10} 的指數記法來表示長度單位。例：一奈米= 10 − 9 m {\displaystyle 10^{-9}m} 。 以 a × 10 m {\displaystyle a\times 10^{m}} 來表示，其中 1 ≤ a < 10 {\displaystyle 1\leq a<10} 。 訣竅：例如 1000000 {\displaystyle 1000000} ， 1 {\displaystyle 1} 後面有 6 {\displaystyle 6} 個零，那麼此數必是 10 {\displaystyle 10} 的 6 {\displaystyle 6} 次方。 例如 0.000001 {\displaystyle 0.000001} ， 1 {\displaystyle 1} 在小數點第 6 {\displaystyle 6} 位，那麼此數必是 10 {\displaystyle 10} 的 − 6 {\displaystyle -6} 次方。 [範例一] 140000 {\displaystyle 140000} 以科學記號表示： = 1.4 × 100000 {\displaystyle =1.4\times 100000} = 1.4 × 10 5 {\displaystyle =1.4\times 10^{5}} [範例二] 0.00000037 {\displaystyle 0.00000037} 以科學記號表示： = 3.7 × 0.0000001 {\displaystyle =3.7\times 0.0000001} = 3.7 × ( 0.1 ) 7 {\displaystyle =3.7\times (0.1)^{7}} = 3.7 × 10 − 7 {\displaystyle =3.7\times 10^{-7}} 1. 判斷下列何者是正確的科學記號：(複選題) (A) 16.25 × 10 7 {\displaystyle 16.25\times 10^{7}} (B) 4.25 × 10 − 1 {\displaystyle 4.25\times 10^{-1}} (C) 7.6 × 8 − 5 {\displaystyle 7.6\times 8^{-5}} (D) 8.5 × 10 3 {\displaystyle 8.5\times 10^{3}} (E) 24.25 × ( − 5 ) 7 {\displaystyle 24.25\times (-5)^{7}} (F) 5.84 × 10 − 8 {\displaystyle 5.84\times 10^{-8}} 2. 請將數字轉換為正確的科學記號： (1) 48000 {\displaystyle 48000} (2) 1890000 {\displaystyle 1890000} (3) 0.000007 {\displaystyle 0.000007} |
藥物化學/抗癌藥/Taxans/Cabazitaxel 7號與10號碳皆變成甲醚取代，使其對 P-gp 的親和力下降 劑型是用 Tween 80，過敏反應較少，即便如此，仍要在治療前服用抗組織胺或是皮質類固醇 |
数学/求和表 q ≠ 1 {\displaystyle q\neq 1} 时，若 a i = a 0 q i {\displaystyle a_{i}=a_{0}q^{i}} ，则 ∑ i = 0 n a i = a 0 1 − q n + 1 1 − q . {\displaystyle \sum _{i=0}^{n}a_{i}=a_{0}{\frac {1-q^{n+1}}{1-q}}.} | q | < 1 {\displaystyle |q|<1} 时，若 a i = a 0 q i {\displaystyle a_{i}=a_{0}q^{i}} ，则 ∑ i = 0 ∞ a i = a 0 1 − q . {\displaystyle \sum _{i=0}^{\infty }a_{i}={\frac {a_{0}}{1-q}}.} ∑ n = 1 ∞ 1 n 2 = π 2 6 {\displaystyle \sum _{n=1}^{\infty }{\frac {1}{n^{2}}}={\frac {\pi ^{2}}{6}}} ∑ n = 1 ∞ 1 n 4 = π 4 90 {\displaystyle \sum _{n=1}^{\infty }{\frac {1}{n^{4}}}={\frac {\pi ^{4}}{90}}} |
日语/文法/“学校语法”与“日语教学语法”用语对照 過去的中國大陸與台灣，因為當時日本語言學界以古典日語為基礎來研究現代日語的觀點仍佔有絕對的優勢，所以教學上大多採用以日本國學為基礎的義務教育體系文法──学校（がっこ ）文法（ぶんぽう ）；但近年來日本語言學界環境丕變，以普通語言學為基礎，重視當下的語言狀態而不是源流的學派已佔有一席之地（事實上認證日語檢定的日本語教育学会就是這個學派的大本營）。為了方便學生上手和實用，現在大多採用了以此為基礎的教育（きょういく ）文法（ぶんぽう ）。以下是兩者的主要術語的對照表： |
Drupal7初學者指南/安裝模塊和主題 在正式使用Drupal前，有必要简单说明一下怎样安装模块和主题。模块在Drupal十分重要，因为Drupal主体只是一个能发布文字内容的架构，如需更多功能就需要安装模块。至于主题就不用详细说明了。 而且Drupal本身默认似乎没有缓存功能，推荐各位安装一个叫boost的模块以加入缓存功能并提高运行速度。顺便也可以学学怎么装模块了。 先去Drupal官方网站，搜索boost，然后缩小范围至Modules。会找到一个叫boost的模块。下载解压后里面有一个叫boost的目录，将整个目录（包括目录本身）复制至sites\all\modules下。 然后再进入你的网站，这时候你会见到一个基本的网站架构。先不管这个，以刚才安装注册的管理员名字登录，上方会出现一个黑边的菜单，选模块（Module）菜单，出现模块设置菜单，往下拉会找到PERFORMANCE AND SCALABILITY的分类下有个boost，在前面打勾，到最下方保存设置。 如果没有出现错误，现在boost插件启动了。 同样地，将下载回来的主题放在\sites\all\themes下，再到管理员菜单上选外观即可切换主题。新下载的主题因为没有启用所以都放在下面。点击主题下面的启用即可，然后可以在上面设置为默认主题。值得注意的是，目前很多主题都是以另一主题为基础开发的，比如一个名为Zen的主题就经常被用作为基本主题。如需要其它主题支援，该主题的下载页或压缩包内的说明文件都有说明，请在安装前留意。 |
藥物化學/抗癌藥/Taxans/Paclitaxel 目前歷史上，賣得最好的抗癌藥 會增加 thymidine phosphorylase 的基因表現量，因此可以共服 capecitabine（thymidine phosphorylase為此藥的活化酵素） 50%的酒精＋50%的polyoxyethylated oil (cremophor EL)，因此會有過敏的風險 |
基础数学/自然数 你会数数吗？也许你会不屑地说：“我早就会了！”那么你最大能数到多少呢？你会做加法、减法、乘法和除法吗？你知道分配律是什么吗？如果还不是特别清楚的话，就来读一读这一章的内容吧。 让我们还是回到数数的问题上来。什么是数数呢？我们先看一个例子：小明有一篮苹果，小红也有一篮苹果，可是谁的更多一些呢？我们就需要比一比。一个办法是小明和小红每次各吃一个苹果，看谁的先吃完，谁的就少一些，另一个人的就多一些。当然更聪明一点儿的办法是把苹果同时从篮子里取出来，每次各取一个，谁的苹果先取尽，谁的就少些，这样就不用把苹果都吃完了。那么如果两个人都在家里，只能通过电话联系呢？那也好办，他们可以每拿出一个苹果就在电话里说一句“苹果”，这样就能保证两个人每次同时各拿出一个苹果了。但如果电话也不通，只能写信呢？那也好办，我们可以让小明每取出一个苹果，就在信纸上画一个苹果，等取完了苹果，信纸上的苹果就和小明篮子里的苹果一样多了。当然了，要把一个苹果画得像并不是那么容易的事，不过只要小红明白他想画的是苹果也就可以了，不需要画得那么像，甚至小明可以简单的把每个苹果画成一个方块，像这样 口口口口 只要小红知道每个方块代表一个苹果就可以了。如果小明不能直接给小红写信，他们都只能给小刚写信呢？那也没关系，他们可以都把苹果画成方块或者别的什么，把信寄给小刚，像这样 小明：口口口口 小红：口口口口口口 小刚只要比一比他们谁画的方框更多就行了。这里有两件事是重要的，第一，方框和苹果长得像不像都没关系，只要每个方框代表一个苹果就可以；第二，只要比较小明和小红画的方框，看谁的多一些，就可以知道谁的苹果更多一些。所以我们不但可以用方框表示苹果，还可以用来表示橘子，葡萄，铅笔，汽车，随便什么能数的东西都可以。当然我们也可以不用方框，比如小红用横线来表示苹果，于是小刚收到的信会是下面的样子 小明：口口口口 小红：一一一一一一 我们看到口口口口口口和一一一一一一代表的含义其实是一样的，只是符号不同，如果大家用的符号都不一样，就不大方便，一个简单的办法是大家约定都用相同的符号，比如方框，这样不管是谁都认得了。可以说这些方框就是我们这一章的主角————自然数。不过如果两人要比较的不是苹果，而是瓜子，这样的画法就太麻烦了，所以我们还要用更简单的符号来代替这些方框。 我们先不急着去数瓜子吧，先来看看最小的几个自然数。当然它们无非就是口、口口、口口口……，不过像前面说的，我们要用更简单一些的符号来代替它们。实际上不同国家有不同的符号，我们下面列出中国、罗马、印度的符号如下 这就是最小的几个自然数，为了书写方便，我们以后都采用印度使用的符号（每个数字最多用两笔就能写完），它们被称为阿拉伯数字，这也是国际上通用的做法。当然，书写的方便是有代价的，那就是我们需要记住这些数字的顺序，也就是每个数字的下一个是什么，如果画方框就可以避免这个麻烦，所以我们的新符号似乎并不比方框更好，不过请相信我，一旦你熟悉了它们，你将会发现它们比方框好用得多，下面我们就先和这9个数字来交个朋友吧。 我们在这一小节里先学习书写这9个数字。 有一首儿歌可以帮助我们记住它们怎样书写： 1像铅笔细又长， 2像小鸭水上漂， 3像耳朵听声音， 4像小旗随风摇， 5像衣钩挂衣帽， 6像豆芽咧嘴笑， 7像镰刀割青草， 8像麻花拧一道， 9像勺子能盛饭， 0像鸡蛋做切糕。 关于最后一个数字0，我们前面没有提到过，将在下一节介绍它。 要学会这些数字需要花一番功夫才行，下面我们再看看数字的其它形式 读出以下数字。 9 8 7 6 5 4 3 2 1 0 我们已经认识了9以下的数字，这样我们数数的时候不是 口->口口->口口口->口口口口 而是 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 当然我们也完全可以用别的符号，比如汉字，只要你记得住它们的顺序就可以了，不过为了后面的方便，我们主要使用上面的1、2、3、4、5、6、7、8和9。 记住了顺序其实就是给出一个数，能够知道它的下一个是什么，比如我们数到3，再数下去就是4。所以每数一个数，我们就从这个数出发得到了另一个数，也就是它的下一个。这种从已知的数得到未知的数的过程称为运算。我们只考虑那些每次得到一个新的数字的运算。 像我们前面说的从一个数数到它的下一个数，就是一种运算，更准确的说，是一种一元运算。 这一节我们将讨论一种二元运算，也就是一种从两个已知的数得到一个未知的数的过程。 如果你觉得自己被这些定义搞糊涂了，那么别着急，我们可以先往下看，等学完这一节，你就清楚它们在说什么了。 还是让我们先来看一个例子吧。假设爸爸买了一篮苹果，妈妈也买了一篮苹果。 你数一数爸爸的苹果，发现有3个；你又数了数妈妈买的苹果，发现有2个。如果你不关心是爸爸买的还是妈妈买的，那么你可以重新数一遍，数完爸爸的3个苹果之后别停下来，接着数妈妈的2个，这样你就数到了5，一共有5个苹果。也就是数到3之后再数2个数就数到了5，我们把它写成 3 + 2 = 5 {\displaystyle 3+2=5} 这里" + {\displaystyle +} "叫作加号，读作“加”；" = {\displaystyle =} "叫作等号，读作“等于”。 为了说得更明白一些，我们可以回忆一下我们的方块数字，爸爸有口口口个苹果，妈妈有口口个苹果，把口口口和口口放在一起就是口口口口口，我们把它写成 口口口 + {\displaystyle +} 口口 = {\displaystyle =} 口口口口口 我们为了写起来容易，把口口口写成3，把口口写成2，把口口口口口写成5，也就是用阿拉伯数字来写，就是上面的样子了。我们再来看一个例子吧，小刚有3支铅笔，小红有2支铅笔，他们一共有多少支铅笔？ 小刚有3支铅笔，小红有2支，放在一起数就是数到3时，再数2个数，就是5，所以一共有5个，即 3 + 2 = 5 {\displaystyle 3+2=5} 比较这两个例子我们看到，不论是铅笔还是苹果，3个和2个放到一起，都是5个。所以不管数什么我们都可以写成 3 + 2 = 5 {\displaystyle 3+2=5} ，它的含义是数数数到3之后再数2个数得到5，也就是3个东西和2个东西放在一起一共有5个东西。这里的东西可是苹果，可以是铅笔，可以随便是什么。 这种把两个数放在一起得到一个新的数的过程就叫作加法。 我们来看一个例子 这里我们再讨论一点数数与加法的关系。一个数加几就是再它后面再数几个数，所以学会了加法，我们可以数数数得更快些，比如我们熟悉了2+2=4，4+2=6，6+2=8，那么我们在数数的时候就可以“两个两个的数”，这样数起来就是2,4,6,8，假设有8支铅笔，用4次就可以数完了。当然，你也可以三个三个的数。而数数就是一个一个的数，也就是每次加上1。实际上我们在数数时就学会了"+1"，它是最特殊的加法，然后我们又通过数数，也就是一个数加一，学会了两个数相加的加法。 计算： 1 + 2 = {\displaystyle 1+2=} 3 + 5 = {\displaystyle 3+5=} 4 + 2 = {\displaystyle 4+2=} 5 + 4 = {\displaystyle 5+4=} 3 + 6 = {\displaystyle 3+6=} 7 + 2 = {\displaystyle 7+2=} 6 + 2 = {\displaystyle 6+2=} 7 + 1 = {\displaystyle 7+1=} 5 + 3 = {\displaystyle 5+3=} 答案： 3 {\displaystyle 3} 8 {\displaystyle 8} 6 {\displaystyle 6} 9 {\displaystyle 9} 9 {\displaystyle 9} 9 {\displaystyle 9} 8 {\displaystyle 8} 8 {\displaystyle 8} 8 {\displaystyle 8} 前面我们已经学习了9以下的数，那么数数数到9之后接着数下去是多少呢？如果用我们的方框数字，就是在9个方框后面再添一个方框，这样当我们数很大的数的时候就会写得很长很长，如果每个数字都用一个符号来代表（就像阿拉伯数字中的1-9），那样虽然不会便得很长，但是每增加一个数字就要多认识一个，这也不方便。怎样做才好呢？我们这一节就来学习。 如果能重复使用数字就方便得多，所以9的下一个数我们还用1来表示，为了和真正的1区分，我们在1后面添一个新的符号0，就写成10，读作“十”。0表示个位上没有数。它的下一个数字写作11，读作“十一”。11的后面是12,13,14...19。为了明确，我们列一个表 这种由两个数字组成的数叫做两位数，右面的叫作个位，左面的叫作十位。我们可以这样理解：十位上的1代表10，个位上的数字是几就是十位上的10后面再数几个数，也就是10加几。例如13就是10+3, 16就是10+6。 数到19，我们个位上的数字已经把上一小节学的9个数字都用完了，如果再数一个数呢，个位上的数字就要变成10，没法用一位数写出来了，这时，我们实际上有了2个10，十位上的1代表10，个位上也有一个10，那么我们就在十位上写2，代表这两个10，个位上写0，就可以了，这就是19后面的数字，也就是19+1，写作20，读作“二十”。 古代的人最初是没有0的，他们只是把个位空出来，但是这样10就不容易和1区分（10写作1 ），所以后来才发明了0，用来占位，虽然写了一个0，但是这个写出来的数字却代表个位上什么都没有，这就是0的含义。有的教科书也把0作为一个自然数，你可以在数数前先数一个0，然后再从1开始数，不过多数人还是愿意省下这个力气，所以在这本书里不把0看作自然数。事实上0是不是自然数并不重要，只要我们数相同的东西得到同样的结果就可以了。关于0的更多内容，我们将在“整数”那一节作更详细的介绍。 前面我们学习了20以内的加法，我们做加法的方法就是数数。加法还有一些很重要的规律，掌握了这些规律可以让我们算得更快，我们这一节就来介绍一条规律——加法的交换律。下一小节介绍加法的结合律。 我们先来再来看看苹果的例子。要知道爸爸和妈妈一共买了多少个苹果，就是把他们的苹果放到一起，然后数数有多少个，可以先数爸爸的，也可以先数妈妈的。 重要的是 这是数学里常常用到的规律，我们以后还会遇见它。对于上面数苹果的例子，就可以得到 3 + 2 = 2 + 3 {\displaystyle 3+2=2+3} 。这里等号表示它两边的计算结果相同。如果是4+5呢？那就相当于在问把4个方框和5个方框放在一起是几个，你也可以先数4个方框再数5个方框，也可以先数5个方框再数4个方框，也就是 4 + 5 = 5 + 4 {\displaystyle 4+5=5+4} 。对于其它的数字相加也一样，所以我们有下面的规律，叫作加法的交换律 举一些例子来写： 2 + 6 = 6 + 2 {\displaystyle 2+6=6+2} 3 + 8 = 8 + 3 {\displaystyle 3+8=8+3} 9 + 4 = 4 + 9 {\displaystyle 9+4=4+9} 5 + 5 = 5 + 5 {\displaystyle 5+5=5+5} 7 + 9 = 9 + 7 {\displaystyle 7+9=9+7} …… 为了表示所有这些等式，我们用两个字母A和B来代替等式里的数字，写作 这里A和B可以是任何数字，左边的A和右边的A要相同，左边的B也要和右边的B相同，A和B既可以相同也可以不同。这种用字母表示数的方法更简单直观，我们今后将尽量使用这种方法说明运算的规律。 前面我们讨论了两个数相加的运算，这一节我们将讨论3个数相加的规律——加法的结合律。我们先介绍复合运算的顺序和括号，再介绍加法的结合律。 假设小刚有3支铅笔，小红有2支铅笔，小亮有1支铅笔，他们一共有多少铅笔呢？我们可以这样计算，先把小刚和小红的铅笔放到一起，比如放在老师手里，有3+2=5支铅笔，再考虑老师和小亮一共有多少铅笔，就是5+1=6支铅笔，所以小刚、小红和小亮一共有6支铅笔。这里我们计算了两次： 3 + 2 = 5 {\displaystyle 3+2=5} 5 + 1 = 6 {\displaystyle 5+1=6} 为了书写简单一点儿，我们把这个计算过程写在一起，写成下面的样子 ( 3 + 2 ) + 1 = 5 + 1 = 6 {\displaystyle (3+2)+1=5+1=6} 其中(和)叫做小括号，括号总是成对出现的，放在括号里面的部分作为一个整体去参与其它的运算，所以括号里的部分要先计算。例如上面的例子中括号里面的3+2要先计算出结果5再去和后面的1相加。 应用我们前面讲到的规律，把三份东西放到一起去数总可以先数其中两个，所得的总数不变。下面我们再用方框数字举一个例子，来形象的说明这个道理 用阿拉伯数字写出来就是(5+4)+7=5+(4+7)，其它数字的加法也是类似的，因此有 跟加法的交换律一样，这个用字母表示的式子的意义是：把每个字母都换成一个数字，并且相同的字母换成相同的数字，不同的字母既可以换成相同的数字，也可以换成不同的数字，那么等式总是成立的。 例如，把A换成5，B换成4，C换成7，就是我们前面所写的式子。又如把A换成3, B换成4， C换成9，那么上面的式子就表示 ( 3 + 4 ) + 9 = 3 + ( 4 + 9 ) {\displaystyle (3+4)+9=3+(4+9)} 。 可以验证一下这个等式： 左边 = ( 3 + 4 ) + 9 = 7 + 9 = 16 {\displaystyle =(3+4)+9=7+9=16} ，右边 = 3 + ( 4 + 9 ) = 3 + 13 = 16 {\displaystyle =3+(4+9)=3+13=16} ，可见左右两边确实是相等的。 有时候应用加法的交换律和结合律可以让我们的计算更简便，我们来看一个例子： 已知小刚有A个苹果，小红有B个苹果，我们就可以算出他们一共有A+B个苹果。反过来，如果小刚有C个苹果，分给小红D个苹果，小刚还剩多少苹果呢？这时就需要减法。我们这一小节就来学习减法，并讨论它和加法的关系。 我们还是来看一个具体的例子吧。假设你有7个苹果，送给朋友3个，你自己还剩几个呢？我们至少有两种办法可以算出你还剩几个苹果。下面我们分别来讨论。 第一种方法。回忆我们做加法的办法，我们可以先练习倒着数数，像这样10, 9, 8, 7, 6, 5, 4, 3, 2, 1。我们从7开始，每拿走一个苹果就倒着数一个数，这样，拿走3个苹果，我们就数6, 5, 4，所以还剩4个苹果。 第二种方法。我们可以这样想，如果朋友把那3个苹果拿回来，你自己就又有7个苹果了，所以我们把你自己剩下的苹果和你送给朋友的3个苹果加起来就是你原来的7个苹果，因此我们只要知道3+?=7就可以了。于是我们可以从3开始数数，4, 5，6，7，数到7时数了4个数，所以你还剩4个苹果。 我们把这种从一个数里拿走一部分，求剩下多数的运算叫做减法。 从上面的第二种方法我们还可以知道，减法也是已知一个加数与和，求另一个加数的运算，因此我们说减法是加法的逆运算。 我们来看一道例题 也可以这样做 对于20以内的加减法的结果，我们需要熟记，以后要经常用到它们。 前面我们认识了20以下的数，并学习了20以下的数的加减法，这些是以后学习的基础。那么比20更大的数呢？这一节我们将认识100以下的数，并讨论它们的加减法，下一节我们将介绍一位数的乘法。现在让我们向比20更大的数进军吧。 这一小节，我们先来认识100以下的数。 前面我们学习了20以下的数。（更准确的说我们介绍了20以下的阿拉伯数字的写法，其实如果用我们最初的方框数字，这些都很容易，只要在一个数的后面添一个方框就是它的下一个数了。不过我们的阿拉伯数字要简洁得多，这一点的优势后面会看得更清楚。）那么20的下一个是什么呢，类似于10的下一个数记作11，我们把20的下一个数记作21，读作“二十一”，接下去是22, 23, 24, 25..., 29, 30, 31, 32, ...读作“二十二”， “二十三”， “二十四”， “二十五”……“二十九”，“三十”，“三十一”，“三十二”……十位上的数字是几就读几十，个位上的数字是几就读几，0不读。 看一看这些符号和我们的方框数字的关系可能会有助于理解。 阿拉伯数字的十位对应方框数字有多少个整行（每行10个方框），即代表有几个10，个位代表除去整行还剩下多少，这样我们就可以一直数下去，直到99，99就是9个10零9个，再加1呢，就是10个10，所以在十位写10，个位上没有，写0，即100，读作“一百”。 前面我们学习了20以内的数的加减法，又认识了100以内的数，那么100以内的数的加减法你会做吗？当然你也可以照样用我们原来的办法，通过数数来计算，不过如果计算33+62这样的加法，数起数来就不大方便了，实际上我们有更好的办法，这一小节就来学习100以内的加减法。 我们的方框数字做加法是最方便的，因为只要把两个数的方框放在一起就可以了，我们就先来看一个例子： 20 + 30 = ? {\displaystyle 20+30=?} 用我们的方框数字可以这样计算： 要知道和是多少，就要数一数最右边有多少个方框。每行有10个，被加数有2行，加数有3行，所以一共是2+3=5行，所以和是5个10即50。 类似的我们还可以算出30+40=70, 20+60=80, 等等。 那么不是整十的数怎样算呢，我们再来看一个例子： 25 + 31 = ? {\displaystyle 25+31=?} 用我们的方框数字可以这样计算： 先数整行，被加数有两个整行，加数有三个整行，加起来有2+3=5个整行，是50。再数剩下的部分，被加数的个位是5，加数是1，所以剩下的是5+1=6。把两者放在一起就是最后的结果56。 我们实际上利用了前面学过的加法的交换律和结合律来帮忙。明显的写出来就是 从上面的例子我们可以总结出两位数的加法法则 为了书写明确，我们可以在计算时列竖式书写，例如： 36 + 11 = {\displaystyle 36+11=} ？ 答案： 47 {\displaystyle 47} 66 − 11 = {\displaystyle 66-11=} ？ 80 − 73 = {\displaystyle 80-73=} ？ 答案： 55 {\displaystyle 55} 7 {\displaystyle 7} 前面我们学习了100以内的数的加法与减法两种运算，下面我们将学习两种新的运算——乘法与除法，这一小节我们先学习一位数和一位数的乘法，并以此为例子，介绍乘法的运算规律，最后介绍除法。对于更大数字之间的乘法和除法我们留待认识多位数之后介绍。 什么是乘法呢？乘法就是求几个相同加数的和的运算。 这样说起来可能太抽象了，我们还是从具体的例子说起吧。下面的图里一共有多少条鱼呢? 你当然可以用数数的办法，把结果数出来，你会发现有15条鱼。如果你观察一下，还会发现，每一行都有5条鱼，所以一共有5+5+5=15条鱼，用这种办法只要数出一行有多少条鱼（5条），在数出有多少行（3行），然后把这3个5加起来就行了。如果有8行呢，那就是5+5+5+5+5+5+5+5，实际生活中，我们经常会遇到这样的情况，为了方便，我们不把加法写的这样长，而发明一种新的符号来代表相同的意思，我们把8个5相加写成 5 × 8 {\displaystyle 5\times 8} ， × {\displaystyle \times } 叫做乘号，上面的式子读作"五乘以八“。 和加法一样我们先学习一位数和一位数的乘法。 既然乘法就是求几个相同加数的和，我们可以像前面的例子那样，通过加法计算乘法，计算的结果列成一个乘法表，如下所示。 如果你仔细观察一下，就会发现，这张表右上方的部分是空的，那是因为乘法也跟加法一样有交换律和结合律，只要记住了表上的乘法就可以轻松的把空出来的部分补齐。关于乘法的交换律和结合律我们留到下一小节在讨论。就像一位数跟一位数的加法一样，一位数跟一位数的乘法是以后计算的基础，因此我们需要熟记这些乘法的结果，为了便于记忆，我们可以背诵下面的乘法口诀歌，歌诀的意思跟上面的乘法口诀表是对应的。 关于乘号。 现在过去的乘号有不同的写法，有的不写，有的用一个字母代替，有的写成一个圆点，我们这里介绍的乘号是英国数学家奧特雷德发明的。因为乘法跟加法有密切的关系，他把加号“＋”旋转了45度，变成 × {\displaystyle \times } 作为乘号，并流传开来。 在计算机的键盘上，通常没有 × {\displaystyle \times } ，绝大多数计算机语言使用"*"作为乘号，例如用5*8表示 5 × 8 {\displaystyle 5\times 8} 。 和加法的交换律与结合律类似，乘法也有交换律跟结合律，这一节我们就来学习它们。 前面我们用不同的方法数同样的一堆物品而得到了加法的交换律与结合律，这一小节我们还要用类似的方法来得到乘法的交换律与结合律。 我们在引入乘法时举了一个数鱼的例子，事实上，我们不但可以按行数，还可以按列来数，不管怎样数，如下图所示得到的都是鱼的总数，所以 第一种方法，每行有5条，共3行，所以一共有 5 × 3 {\displaystyle 5\times 3} 条鱼 第二种方法，每列有3条，共5列，所以一共有 3 × 5 {\displaystyle 3\times 5} 条鱼 或者用我们的方框数字写出来就是 所以我们可以得到 5 × 3 = 3 × 5 {\displaystyle 5\times 3=3\times 5} 从上面的例子我们可以总结出、 类似的我们还可以得到乘法的结合律，例如考虑 ( 5 × 3 ) × 4 {\displaystyle (5\times 3)\times 4} ，用方框数字可以写成下面的样子 我们如果先数表格的每一格，每行有5个方框，共有3行，所以有 5 × 3 {\displaystyle 5\times 3} 个方框，一共有这样的4格，所以一共有 ( 5 × 3 ) × 4 {\displaystyle (5\times 3)\times 4} 个方框。 我们还可以先数整个表格一共有多少行，因为每一格有3行，共4格，所以一共有 3 × 4 {\displaystyle 3\times 4} 12行，每行有5个方框，所以一共 5 × ( 3 × 4 ) {\displaystyle 5\times (3\times 4)} 个方框。 根据我们前面反复使用的规律，不管怎样数，方框的数目都是一样多，所以 ( 5 × 3 ) × 4 = 5 × ( 3 × 4 ) {\displaystyle (5\times 3)\times 4=5\times (3\times 4)} 。 上面的方法跟具体是每行有5个方框还是6个还是7个……都没有关系，跟每个方格里有3行还是4行还是5行……也没有关系，跟整个表格有4格还是5格还是6格……也没有关系，所以我们可以总结出下面的规律 适当的应用乘法的交换律和结合律有时会给我们的计算带来方便，例如 乘法表示几个相同的数相加，那么几个相同的数相乘呢，我们也可以用一种新的符号来表示，例如: 3 × 3 × 3 × 3 = 3 4 {\displaystyle 3\times 3\times 3\times 3=3^{4}} 前面我们学习了加法的交换律与结合律、乘法的交换律与结合律，那么加法和乘法之间有没有什么规律呢？的确有，这一小节我们就来学习加法和乘法之间的规律——乘法对加法的分配律。 我们还是看一个数数的例子，这里画的是鱼，当然，和前面的例子一样，换成别的什么或者我们的方框数字，都是类似的。 图里一共有多少条鱼呢？我们可以有两种不同的数法，一种是先数每一行有 5 + 2 {\displaystyle 5+2} 条鱼，再数一共有 3 {\displaystyle 3} 行，所以，共有 ( 5 + 2 ) × 3 {\displaystyle (5+2)\times 3} 条鱼。 我们还可以换一种方法，先数左边，有 5 × 3 {\displaystyle 5\times 3} 条鱼，再数右边，有 2 × 3 {\displaystyle 2\times 3} 条鱼，所以一共有 5 × 3 + 2 × 3 {\displaystyle 5\times 3+2\times 3} 条鱼。 用不同的数法，鱼的总数不变，所以 ( 5 + 2 ) × 3 = 5 × 3 + 2 × 3 {\displaystyle (5+2)\times 3=5\times 3+2\times 3} ，换成其它的数字也是类似的，因此我们有 根据加法的交换律和乘法的交换律，我们还可以得到乘法分配律的另一种形式 除法不可能都除尽，余下来的叫“余数”。 这次我们学到了一个新的词语：余数 但是，余数是什么呢？ 虽然说起来感觉十分深奥，但是我们用例子来表现一下什么是余数： 这里有 36 {\displaystyle 36} 条鱼，我们要把它们分给 5 {\displaystyle 5} 个人，怎么分呢？我们就用到了除法，我们用 36 / 5 = 7 {\displaystyle 36/5=7} ，得到个与它 36 {\displaystyle 36} 相近的一个数 5 × 7 = 35 {\displaystyle 5\times 7=35} ,但是我们还剩了一条鱼，即没法分给5个人，也不能把它分开，只好把那条鱼作为余下来的一条，也就是余数 1 {\displaystyle 1} ，所以，我们就得到了答案： 36 / 5 = 7 ⋯ 1 {\displaystyle 36/5=7\cdots 1} ，亦可以以減法的方式解題，連續用5去減36七次，得 36 − 5 − 5 − 5 − 5 − 5 − 5 − 5 = 1 {\displaystyle 36-5-5-5-5-5-5-5=1} ，即得餘數1。 请解答以下几道题： 13 ÷ 11 = {\displaystyle 13\div 11=} 7 ÷ 3 = {\displaystyle 7\div 3=} 7 ÷ 11 = {\displaystyle 7\div 11=} 16 ÷ 13 = {\displaystyle 16\div 13=} 66 ÷ 5 = {\displaystyle 66\div 5=} 97 ÷ 99 = {\displaystyle 97\div 99=} 答案：（取整數） 1 {\displaystyle 1} 2 {\displaystyle 2} 0 {\displaystyle 0} 1 {\displaystyle 1} 13 {\displaystyle 13} 0 {\displaystyle 0} 前面我们识了100以内的数，并学习了加、减、乘、除，四种运算。这一小节我们将介绍更大的数，以及它们的运算。 这一小节我们来学习100以上的数的读法和写法。 我们先来回忆一下两位数的写法。我们数数数到9以后，接下来的数字不再发明新的符号，就用一个两位数10来表示，然后每数一个数就在个位上增加1，即11, 12, 13, 14, 15, 16, 17, 18, 19，可以这样理解11就是10+1，12就是10+2，13就是10+3……，19就是10+9，再继续数就要遇到10+10即 10 × 2 {\displaystyle 10\times 2} ，我们在十位上写2表示2个10，即 20 = 10 × 2 {\displaystyle 20=10\times 2} 。数到99以后，我们再数下去个位上变成10，所以在十位增加1，个位写0，9＋1＝10，所以十位上写10，也就是说变成了一个3位数，100。基本的规则是，每当某一位上的9还需要加1时，就把它改成0，并在比它更高的一位上加1，这叫做“逢十进一”。一个多位数从右向左依次叫做个位、十位、百位、千位、万位……跟书写类似，我们不想为每一位都起个新名字，接下来叫做十万位、百万位、千万位。千万位之后是亿位，接下来是十亿位、百亿位、千亿位、万忆位、十万亿位、百万亿位、千万亿位。 1、讀法原則 按照四位分級的原則，我國的讀數法則是： ⑴四位以內的數，按照數位順序，從高位讀起。 ⑵四位以上的數，先從右向左四位分級，然後從最高級起，依次讀億級、萬級、個級。讀出各級里的數和它們的級名。億級里的數，按照個級的數的讀法來讀，再在後面加上一個「億」字；萬級里的數，按照個級的數的讀法來讀，再在後面加上一個「萬」字。 ⑶每級末尾不管有幾個「0」，都不讀；其他數位上有一個「0」或幾個「0」，都只讀一個零。 2、要點 ⑴讀數的時候，從高位開始，一級一級地讀。讀億級、萬級時，按個級的讀法讀，只要在後面加讀一個「億」或「萬」字。 ⑵數中間有1個0，或連續有幾個0，只讀一個零。 如： ⑴2的27次方等於134217728，其讀法為“一億三千四百二十一萬七千七百二十八”。 ⑵多位數加減算讀法，如： 70238＋70074＝140312， 其讀法為“七萬零兩百三十八加七萬零七十四等於十四萬零三百一十二”。 ⑶小數點以後的位數只讀數字，如： 634.608，其讀法為“六百三十四點六零八”。 实际上我们很少会用到万以上的数字，当数字很大时，使用科学计数法会方便得多，例如100000写成 1 × 10 5 {\displaystyle 1\times 10^{5}} ，40000000写成 4 × 10 7 {\displaystyle 4\times 10^{7}} 。这里只是个非常粗略的描述，具体怎样使用科学计数法，要在学习了小数之后才能详细介绍。 中国古代没有竖式，各种运算是用算筹帮助完成的，例如 38 × 76 = 2888 {\displaystyle 38\times 76=2888} 是如下图那样计算的 这个名称可能有一点儿古怪，那是因为印度的数字是经由阿拉伯传播开去的，这种名不副实的现象在数学里还有很多，所以也有稱作印度·阿拉伯数字。 |
文言/背景 维基百科中的相关条目： 文言 文言是中國傳統上使用的書面語言，與此相對應的口頭上使用的語言稱為白話。在白話文運動之前，文言文是中國書面文章、記載、傳記、文學的主要形式，現存的文獻絕大多數均使用文言。現在，文言作為一種簡潔精煉、含蓄磅礡、具有特殊的文學性、藝術性的文體，仍深受喜愛。 由文言所寫作的文章，稱文言文。 文言文的語法、詞彙等，脫胎於上古漢語。 中國、日本等地，現在仍在中等教育中實行文言文教育。 |
速打粤语拼音输入法 速打粤语拼音输入法，是一款运行于微软Windows平台的中文拼音输入法软件，使用粤语拼音。 速打粤语拼音输入法是绿色软件，不需要安装，下载后解压缩文件，点击输入法便可以打字，可以放在U盘或其它便携设备上随身携带。 实际上不是真正的输入法，它并不在语言栏裡。 速打粤语拼音输入法使用全拼的方法打字，键盘为标准的26键，打字时需按顺序输入所打字词的粤语拼音。 打字举例： 唔该（mgoi） 点解（dimgai） 呢度（nidou） 系咪（heimei） 唔系（mhei） 难打字的笔画输入法：难打字可以使用笔画：d（点）、w（横）、s（竖）、p（撇）、n（捺）、z（折）输入，其中d（点）=n（捺），引导键为Q。 打字举例： 冇（wpsz） 翻页键：翻页键为逗号（，）句号（。），减号（-）等于号（=），向上翻页键（Page Up）向下翻页键（Page Down），默认为逗号（，）句号（。）。 笔画输入法：笔画输入法使用d（点）、w（横）、s（竖）、p（撇）、n（捺）、z（折），其中d（点）=n（捺），引导键为Q。 输入法的打开关闭键：Ctrl + Space。 中文英文输入法状态切换：左Ctrl。 大小写切换键：Caps Lock。 繁体字转换： 繁体字转换的方法一：直接点击输入法状态栏的“简”字，当“简”字变为“繁”字时便可以打繁体字。 繁体字转换的方法二：进入输入法属性编辑器，勾选简体字/繁体字转换选项，按确定。 皮肤：进入输入法属性编辑器，在皮肤选项选择皮肤及设置双行（横排）或多行（竖排）。 候选词个数：进入输入法属性编辑器，在候选词个数选项设置候选词个数。 速打粤语拼音输入法官方网站 |
Drupal7初學者指南/安裝Drupal7 安装Drupal7之前，先要下载Drupal7的主体。你可以去Drupal的官方网站下载，这里不再强调。 需要注意的是，Drupal7目前还没有（起码到本文的目前）自动下载语言包的功能。如果你打算使用英文以外的语言，你需要在Drupal网站下载对应语言的PO文件。这里以中文7.4的翻译为例，下载drupal-7.4.zh-hans.po文件。 将压缩包下载后，将文件放在网站根目录的适当位置。如果要作为全站的主程序那就放在根目录吧。然后将drupal-7.4.zh-hans.po文件放在Drupal7根目录的profiles\standard\translations下。 在安装前，先去一下Phpmyadin。在Mysql那边创建一个数据库，作为Drupal的数据库。在首页的新建数据库上填写数据库名字，这里先默认为“Drupal”吧。旁边选择“utf8_bin”以选择UTF8作为数据库的编码。 访问Drupal7所在的根目录（不一定是你网站的根目录），就开始进入安装了。 这里有两个选项，标准（standard）和最小（Minimal）。最小只打开部分模块。我们先选标准。 下一步是选择语言。如果你有下载语言包，这里除了英文还有其它语言选择，选择完毕就会自动转到选择的语言版本继续安装。 第三步是选择数据库，MySQL, MariaDB, or equivalent就是说选MySQL, MariaDB或等效的数据库。如果没有出现这个选项，请检查PHP服务器PDO相关的选项是否打开。另一个选项是SQLite。如果选SQLite则默认即可。如果是选MySQL，在Database name打入先前创建的数据库名字（先前创建的数据库默认为Drupal），及数据库用户名和密码。以前篇的wamp为例，用户名为root，密码为空。 这时如果没什么问题，安装就开始了。注意，安装主体结束后会顺便导入语言文件。如果你的服务器设置超时过短，有可能在导入文件时出错。别管它，删除语言文件再来一次。语言文件可以在安装完成后导入。 安装设置结束后，就轮到设置站点的基本信息了。Site name填写网站名称，Site e-mail address填网站的电邮地址。SITE MAINTENANCE ACCOUNT段落则是设置管理员用户名等。这个用户名日后用作管理员登录。下方则是国家，时区等选项。最后是是否检查更新和是否接收电邮提醒，酌情选择吧。 当你看到“Congratulations, you installed Drupal!”时，安装完成了 注意：安装完成后，程序会在sites\default目录下生成settings.php（不是default.settings.php）。程序用此文件存储基本设置，以及判定安装完成。也就是说，只要删除settings.php，即可再次安装Drupal。当然，需要删除或更换数据库。 |
藥物化學/抗癌藥/DNA 聚合酶/DNA 鏈延長抑制劑 抑制 DNA 聚合酶和 DNA 鏈的延長 降低代謝酵素（deoxycytidine kinase enzyme）的表現量 轉運蛋白（尤其是hENT1/SLC29A1）將藥物排出細胞外 Cytarabine Gemcitabine Fludarabine Cladribine Clofarabine |
Introducing Julia/Working with dates and times Functions for working with dates and times are provided in the standard package Dates. To use any of the time and date functions, you must do one of the following: using Dates import Dates If you use import Dates functions, you’ll need to prefix every function with an explicit Dates., e.g. Dates.dayofweek(dt), as shown in this chapter. However, if you add the line using Dates to your code, this brings all exported Dates functions into Main, and they can be used without the Dates. prefix. This diagram shows the relationship between the various types used to store Times, Dates, and DateTimes. There are three main datatypes available: A Dates.Time object represents a precise moment of time in a day. It doesn't say anything about the day of the week, or the year, though. It's accurate to a nanosecond. A Dates.Date object represents just a date: no time zones, no daylight saving issues, etc... It's accurate to, well, a day. A Dates.DateTime object is a combination of a date and a time of day, and so it specifies an exact moment in time. It's accurate to a millisecond or so. Use one of these constructors to make the type of object you want: julia> rightnow = Dates.Time(Dates.now()) # a Dates.Time object 16:51:56.374 julia> birthday = Dates.Date(1997,3,15) # a Dates.Date object 1997-03-15 julia> armistice = Dates.DateTime(1918,11,11,11,11,11) # a Dates.DateTime object 1918-11-11T11:11:11 The Dates.today() function returns a Date object for the current date: julia> datetoday = Dates.today() 2014-09-02 The Dates.now() function returns a DateTime object for the current instant in time: julia> datetimenow = Dates.now() 2014-09-02T08:20:07.437 (We used Dates.now() earlier to define rightnow, then converted it to a Dates.Time using Dates.Time().) Sometimes you want UTC (the reference time for the world, without local adjustments for daylight savings): julia> Dates.now(Dates.UTC) 2014-09-02T08:27:54.14 To create an object from a formatted string, use the DateTime() function in Dates, and supply a suitable format string that matches the formatting: julia> Dates.DateTime("20140529 120000", "yyyymmdd HHMMSS") 2014-05-29T12:00:00 julia> Dates.DateTime("18/05/2009 16:12", "dd/mm/yyyy HH:MM") 2009-05-18T16:12:00 julia> vacation = Dates.DateTime("2014-09-02T08:20:07") # defaults to expecting ISO8601 format 2014-09-02T08:20:07 See Date Formatting below for more examples. Once you have a date/time or date object, you can extract information from it with the following functions. For both date and datetime objects, you can obtain the year, month, day, and so on: julia> Dates.year(birthday) 1997 julia> Dates.year(datetoday) 2014 julia> Dates.month(birthday) 3 julia> Dates.month(datetoday) 9 julia> Dates.day(birthday) 15 julia> Dates.day(datetoday) 2 and, for date/time objects: julia> Dates.minute(now()) 37 julia> Dates.hour(now()) 16 julia> Dates.second(now()) 8 julia> Dates.minute(rightnow) 37 julia> Dates.hour(rightnow) 16 julia> Dates.second(rightnow) 8 There's also a bunch of other useful ones: julia> Dates.dayofweek(birthday) 6 julia> Dates.dayname(birthday) "Saturday" julia> Dates.yearmonth(now()) (2014,9) julia> Dates.yearmonthday(birthday) (1997,3,15) julia> Dates.isleapyear(birthday) false julia> Dates.daysofweekinmonth(datetoday) 5 julia> Dates.monthname(birthday) "March" julia> Dates.monthday(now()) (9,2) julia> Dates.dayofweekofmonth(birthday) 3 Two of those functions are very similarly named: the Dates.daysofweekinmonth() (days of week in month) function tells you how many days there are in the month with the same day name as the specified day — there are five Tuesdays in the current month (at the time of writing). The last function, dayofweekofmonth(birthday) (day of week of month), tells us that the 15th of March, 1997, was the third Saturday of the month. You can also find days relative to a date, such as the first day of the week containing that day, using the adjusting functions, described below. You can do arithmetic on dates and date/time objects. Subtracting two dates or datetimes to find the difference is the most obvious one: julia> datetoday - birthday 6380 days julia> datetimenow - armistice 3023472252000 milliseconds which you can convert to Dates.Days or Dates.Milliseconds or some other unit: julia> Dates.Period(datetoday - birthday) 7357 days julia> Dates.canonicalize(Dates.CompoundPeriod(datetimenow - armistice)) 5138 weeks, 5 days, 5 hours, 46 minutes, 1 second, 541 milliseconds julia> convert(Dates.Day, Dates.Period(Dates.today() - Dates.Date(2016, 1, 1))) 491 days julia> convert(Dates.Millisecond, Dates.Period(Dates.today() - Dates.Date(2016, 1, 1))) 42422400000 milliseconds To add and subtract periods of time to date and date/time objects, use the Dates. constructor functions to specify the period. For example, Dates.Year(20) defines a period of 20 years, and Dates.Month(6) defines a period of 6 months. So, to add 20 years and 6 months to the birthday date: julia> birthday + Dates.Year(20) + Dates.Month(6) 2017-09-15 Here's 6 months ago from now: julia> Dates.now() - Dates.Month(6) 2014-03-02T16:43:08 and similarly for months, weeks: julia> Dates.now() - Dates.Year(2) - Dates.Month(6) 2012-03-02T16:44:03 and similarly for weeks and hours. Here's the date and time for two weeks and 12 hours from now: julia> Dates.now() + Dates.Week(2) + Dates.Hour(12) 2015-09-18T20:49:16 and there are julia> daystoxmas = Dates.Date.(Dates.year(Dates.now()), 12, 25) - Dates.today() 148 days or 148 (shopping) days till Christmas (at the time this was written). To retrieve the value as a number, use the function Dates.value(): julia> Dates.value(daystoxmas) 148 This works with different types of date/time objects too: julia> lastchristmas = Dates.now() - Dates.DateTime(2017, 12, 25, 0, 0, 0) 25464746504 milliseconds julia> Dates.value(lastchristmas) 25464746504 You can make iterable range objects that define a range of dates: julia> d = Dates.Date(1980,1,1):Dates.Month(3):Dates.Date(2019,1,1) 1980-01-01:3 months:2019-01-01 This iterator yields the first day of every third month. To find out which of these fall on weekdays, you can provide an anonymous function to filter() that tests the day name against the given day names: julia> weekdays = filter(dy -> Dates.dayname(dy) != "Saturday" && Dates.dayname(dy) != "Sunday" , d) 104-element Array{Date,1}: 1980-01-01 1980-04-01 1980-07-01 ⋮ 2014-07-01 2014-10-01 2016-04-01 2016-07-01 2018-01-01 2018-10-01 2019-01-01 Similarly, here's a range of times 3 hours apart from now, for a year hence: julia> d = collect(Dates.DateTime(Dates.now()):Dates.Hour(3):Dates.DateTime(Dates.now() + Dates.Year(1))) 2929-element Array{DateTime,1}: 2015-09-04T08:30:59 2015-09-04T11:30:59 2015-09-04T14:30:59 ⋮ 2016-09-03T20:30:59 2016-09-03T23:30:59 2016-09-04T02:30:59 2016-09-04T05:30:59 2016-09-04T08:30:59 If you have to pay a bill every 30 days, starting on the 1st of January 2018, the following code shows how the due date creeps forward every month: julia> foreach(d -> println(Dates.format(d, "d u yyyy")), Dates.Date("2018-01-01"):Dates.Day(30):Dates.Date("2019-01-01")) 1 Jan 2018 31 Jan 2018 2 Mar 2018 1 Apr 2018 1 May 2018 31 May 2018 30 Jun 2018 30 Jul 2018 29 Aug 2018 28 Sep 2018 28 Oct 2018 27 Nov 2018 27 Dec 2018 To specify date formats, you use date formatting codes in a formatting string. Each character refers to a date/time element: y Year digit eg yyyy => 2015, yy => 15 m Month digit eg m => 3 or 03 u Month name eg Jan U Month name eg January e Day of week eg Tue E Day of week eg Tuesday d Day eg 3 or 03 H Hour digit eg HH => 00 M Minute digit eg MM => 00 S Second digit eg S => 00 s Millisecond digit eg .000 You can use these formatting strings with functions such as DateTime() and Dates.format(). For example, you create a DateTime object from a string by identifying the different elements in the incoming string: julia> Dates.Date("Fri, 15 Jun 2018", "e, d u y") 2018-06-15 julia> Dates.DateTime("Fri, 15 Jun 2018 11:43:14", "e, d u y H:M:S") 2018-06-15T11:43:14 Other characters are used literally. In the second example, the formatting characters matched up as follows: Fri, 15 Jun 2018 11:43:14 e , d u y H: M: S You can supply a format string to Dates.format to format a date object. In the formatting string, you repeat the characters to control how years and days, for example, are output: julia> timenow = Dates.now() 2015-07-28T11:43:14 julia> Dates.format(timenow, "e, dd u yyyy HH:MM:SS") "Tue, 28 Jul 2015 11:43:14" When you're creating a formatted date, you can double some of the components of the format string to produce a leading zero for single digit date elements: julia> anothertime = Dates.DateTime("Tue, 8 Jul 2015 2:3:7", "e, d u y H:M:S") 2015-07-08T02:03:07 julia> Dates.format(anothertime, "e: dd u yy, HH.MM.SS") # with leading zeros "Wed: 08 Jul 15, 02.03.07" julia> Dates.format(anothertime, "e: d u yy, H.M.S") "Wed: 8 Jul 15, 2.3.7" To convert a date string from one format to another, you can use DateTime() and a format string to convert the string to a DateTime object, then DateFormat() to output the object in a different format: julia> formatted_date = "Tue, 28 Jul 2015 11:43:14" "Tue, 28 Jul 2015 11:43:14" julia> temp = Dates.DateTime(formatted_date, "e, dd u yyyy HH:MM:SS") 2015-07-28T11:43:14 julia> Dates.format(temp, "dd, U, yyyy HH:MM, e") "28, July, 2015 11:43, Tue" If you're doing a lot of date formatting (you can apply date functions to an array of strings), it's a good idea to pre-define a DateFormat object and then use that for bulk conversions (this is quicker): julia> dformat = Dates.DateFormat("y-m-d"); julia> Dates.Date.([ # broadcast "2010-01-01", "2011-03-23", "2012-11-3", "2013-4-13", "2014-9-20", "2015-3-1" ], dformat) 6-element Array{Date,1}: 2010-01-01 2011-03-23 2012-11-03 2013-04-13 2014-09-20 2015-03-01 There are some built-in formats that you can use. For example, there's Dates.ISODateTimeFormat to give you the ISO8601 format: julia> Dates.DateTime.([ "2010-01-01", "2011-03-23", "2012-11-3", "2013-4-13", "2014-9-20", "2015-3-1" ], Dates.ISODateTimeFormat) 6-element Array{DateTime,1}: 2010-01-01T00:00:00 2011-03-23T00:00:00 2012-11-03T00:00:00 2013-04-13T00:00:00 2014-09-20T00:00:00 2015-03-01T00:00:00</syntaxhighlight> and here's good old RFC1123: julia> Dates.format(Dates.now(), Dates.RFC1123Format) "Sat, 30 Jul 2016 16:36:09" Sometimes you want to find a date nearest to another - for example, the first day of that week, or the last day of the month that contains that date. You can do this with the functions like Dates.firstdayofweek() and Dates.lastdayofmonth(). So, if we're currently in the middle of the week: julia> Dates.dayname(now()) "Wednesday" the first day of the week is returned by this: julia> Dates.firstdayofweek(now()) 2014-09-01T00:00:00 which you could also write using the function chain operator: julia> Dates.now() |> Dates.firstdayofweek |> Dates.dayname "Monday" A more general solution is provided by the tofirst(), tolast(), tonext(), and toprev() methods. With tonext() and toprev(), you can provide a (possibly anonymous) function that returns true when a date has been correctly adjusted. For example, the function: d->Dates.dayofweek(d) == Dates.Tuesday returns true if the day d is a Tuesday. Use this with the tonext() method: julia> Dates.tonext(d->Dates.dayofweek(d) == Dates.Tuesday, birthday) 1997-03-18 # the first Tuesday after the birthday Or you can find the next Sunday following the birthday date: julia> Dates.tonext(d->Dates.dayname(d) == "Sunday", birthday) 1997-03-16 # the first Sunday after the birthday With tofirst() and tolast(), you can find the first Sunday, or Thursday, or whatever, of a month. Monday is 1, Tuesday 2, etc. julia> Dates.tofirst(birthday, 1) # the first Monday (1) of that month 1997-03-03 Supply the keyword argument of=Year to get the first matching weekday of the year. julia> Dates.tofirst(birthday, 1, of=Year) # the first Monday (1) of 1997 1997-01-06 You can use round(), floor(), and ceil(), usually used to round numbers up or down to the nearest preferred values, to adjust dates forward or backwards in time so that they have 'rounder' values. julia> Dates.now() 2016-09-12T17:55:11.378 julia> Dates.format(round(Dates.DateTime(Dates.now()), Dates.Minute(15)), Dates.RFC1123Format) "Mon, 12 Sep 2016 18:00:00" The ceil() adjusts dates or times forward in time: julia> ceil(birthday, Dates.Month) 1997-04-01 julia> ceil(birthday, Dates.Year) 1998-01-01 julia> ceil(birthday, Dates.Week) 1997-03-17 It's useful to be able to find all dates in a range of dates that satisfy some particular criteria. For example, you can work out the second Sunday in a month by using the Dates.dayofweekofmonth() and Dates.dayname() functions. For example, let's create a range of dates from the first of September 2014 until Christmas Day, 2014: julia> dr = Dates.Date(2014,9,1):Dates.Day(1):Dates.Date(2014,12,25) 2014-09-01:1 day:2014-12-25 Now an anonymous function similar to the ones we used in tonext() earlier finds a selection of those dates in that range that satisfy that function: julia> filter(d -> Dates.dayname(d) == "Sunday", dr) 16-element Array{Date,1}: 2014-09-07 2014-09-14 2014-09-21 2014-09-28 2014-10-05 2014-10-12 2014-10-19 2014-10-26 2014-11-02 2014-11-09 2014-11-16 2014-11-23 2014-11-30 2014-12-07 2014-12-14 2014-12-21 These are the dates of every Sunday between September 1st 2014 until Christmas Day, 2014. By combining criteria in the anonymous function, you can build up more complicated recurring events. Here's a list of all the Tuesdays in that period which are on days that are odd numbered and greater than 20: julia> filter(d->Dates.dayname(d) == "Tuesday" && isodd(Dates.day(d)) && Dates.day(d) > 20, dr) 4-element Array{Date,1}: 2014-09-23 2014-10-21 2014-11-25 2014-12-23 and here's every second Tuesday in 2016 between April and November: dr = Dates.Date(2015):Dates.Day(1):Dates.Date(2016); filter(dr) do x Dates.dayofweek(x) == Dates.Tue && Dates.April <= Dates.month(x) <= Dates.Nov && Dates.dayofweekofmonth(x) == 2 end 8-element Array{Base.Dates.Date,1}: 2015-04-14 2015-05-12 2015-06-09 2015-07-14 2015-08-11 2015-09-08 2015-10-13 2015-11-10 You sometimes have to deal with another type of timekeeping: Unix time. Unix time is a count of the number of seconds that have elapsed since the beginning of the year 1970 (the birth of Unix). In Julia the count is stored in a 64 bit integer, and we'll never see the end of Unix time. (The universe will have ended long before 64 bit Unix time reaches the maximum possible value, which will be in approximately 292 billion years from now, at 15:30:08 on Sunday, 4 December 292,277,026,596.) In Julia, the time() function, used without arguments, returns the Unix time value of the current second: julia> time() 1.414141581230945e9 The strftime() ("string format time") function, which lives in the Libc module, converts a number of seconds in Unix time to a more readable form: julia> Libc.strftime(86400 * 365.25 * 4) # 4 years worth of Unix seconds "Tue 1 Jan 00:00:00 1974" You can choose a different format by supplying a format string, with the different components of the date and time defined by '%' letter codes: julia> Libc.strftime("%A, %B %e at %T, %Y", 86400 * 365.25 * 4) "Tuesday, January 1 at 00:00:00, 1974" The strptime() function takes a format string and a date string, and returns a TmStruct expression. This can then be converted to a Unix time value by passing it to time(): julia> Libc.strptime("%A, %B %e at %T, %Y", "Tuesday, January 1 at 00:00:00, 1974") Base.Libc.TmStruct(0,0,0,1,0,74,2,0,0,0,0,0,0,0) julia> time(ans) 1.262304e8 julia> time(Libc.strptime("%Y-%m-%d","2014-10-1")) 1.4121216e9 The Dates module also offers a unix2datetime() function, which converts a Unix time value to a date/time object: julia> Dates.unix2datetime(time()) 2014-10-24T09:26:29.305 DateTimes are stored as milliseconds. You can access the field instant to see the actual value. julia> moment=Dates.now() 2017-02-01T12:45:46.326 julia> moment.instant Base.Dates.UTInstant{Base.Dates.Millisecond}(63621636346326 milliseconds) julia> Dates.value(moment) 63621636346326 If you use the more precise Dates.Time type, you can access nanoseconds. julia> moment = Dates.Time(Dates.now()) 17:38:44.33 julia> moment.instant 63524330000000 nanoseconds julia> Dates.value(moment) 63524330000000 The @elapsed macro returns the number of seconds an expression took to evaluate: function test(n) for i in 1:n x = sin(rand()) end end julia> @elapsed test(100000000) 1.309819509 The @time macro tells you how long an expression took to evaluate, and how memory was allocated. julia> @time test(100000000) 2.532941 seconds (4 allocations: 160 bytes) |
基础数学/质数与合数 你玩过积木吗？你可能有很多三角形，有很多正方形，有很多长方形，然后就可以拼出一辆汽车、一个房子或者其它的什么，而这些东西拆开来，也不过是三角形、正方形和长方形这三种。数字也有类似之处。如果我们只考虑加法，那么1就像是最简单的积木，所有其它的数都是由一些1拼起来（相加）的，加法就像只有正方形的积木。乘法要比加法复杂一些，有些数是其它的数相乘得到的，有些不是，我们在这一章就要讨论复杂的数是怎样由简单的数相乘得到的。 用积木搭汽车的时候，你可能先摆出一个车身，再摆出车轮，然后把他们组合到一起就成了一辆汽车，我们可以说车身和车轮都是汽车的一部分。在数字和乘法里也有类似的现象，这一小节我们就来学习它——约数与倍数。 如果 A {\displaystyle A} 除以 B {\displaystyle B} 所得的余数是 0 {\displaystyle 0} ，即 A = B × C {\displaystyle A=B\times C} ，我们就说 A {\displaystyle A} 是 B {\displaystyle B} 的倍数， B {\displaystyle B} 是 A {\displaystyle A} 的约数，我们也说 B {\displaystyle B} 能整除 A {\displaystyle A} ，记作 B | A {\displaystyle B|A} 。(当然因为乘法有交换律，我们同时也说A是C的倍数，C是A的约数。)例<： 6 = 2 × 3 {\displaystyle 6=2\times 3} ，我们说6是2的倍数，2是6的约数。又如 18 = 6 × 3 {\displaystyle 18=6\times 3} ，我们说18是6的倍数，6是18的约数。 一个数有很多倍数，也可能有很多约数。因为对于任何自然数 A {\displaystyle A} ，总有 A = A × 1 {\displaystyle A=A\times 1} ，所以 1 {\displaystyle 1} 和 A {\displaystyle A} 都是 A {\displaystyle A} 的约数。 又因为一个数 A {\displaystyle A} 的约数总是不会超过 A {\displaystyle A} ，所以要找出一个数 A {\displaystyle A} 的所有约数，只要考虑所有不超过 A {\displaystyle A} 的数 B {\displaystyle B} ，如果某个不超过 A {\displaystyle A} 的数 B {\displaystyle B} 能够整除 A {\displaystyle A} ，那么 B {\displaystyle B} 就是 A {\displaystyle A} 的约数，否则就不是。例如要找出7的所有约数，我们只要逐一考查1,2,3,4,5,6,7是不是7的约数。 1 × 7 = 7 {\displaystyle 1\times 7=7} ，所以1是7的约数。 7 / 2 = 3 ⋯ 1 {\displaystyle 7/2=3\cdots 1} ，所以2不是7的约数。类似的可以知道3,4,5,6都不是7的约数，显然7是7的约数，所以7只有两个约数，即1和7。那么7的最大约数是7，最小倍数也是7。 要得到一个数的倍数，我们就用另一个自然数乘它，例如5的倍数有 5 × 1 = 5 {\displaystyle 5\times 1=5} , 5 × 2 = 10 {\displaystyle 5\times 2=10} , 5 × 3 = 15 {\displaystyle 5\times 3=15} , 5 × 4 = 20 ⋯ {\displaystyle 5\times 4=20\cdots } 前面讨论的约数和倍数，如同讨论积木中的车身与车的关系，这一节我们要把那些最基本的正方形、三角形的积木，和它们拼出来的图案区分开，也就是说要考虑哪些数是由其它的数拼出来的（相乘得到的），哪些不是。 对于任何自然数 A {\displaystyle A} ，都有 A = 1 × A {\displaystyle A=1\times A} ，所以 1 {\displaystyle 1} 和 A {\displaystyle A} 都是 A {\displaystyle A} 的约数。我们希望把自然数分成两类，一类是由其它的数相乘得到的，另一类是不能由其它的数得到的。也就是说考虑一个数 A {\displaystyle A} ，除了 A = 1 × A = A × 1 {\displaystyle A=1\times A=A\times 1} 以外还能不能写成其它的两个数的乘积。用我们上一小节的语言来说就是一个数除了 1 {\displaystyle 1} 和 A {\displaystyle A} 以外还有没有其它的约数。因为 1 {\displaystyle 1} 是个特殊的数，它只有 1 {\displaystyle 1} 个约数，我们通常单独考虑它。 1 {\displaystyle 1} 既不是质数，也不是合数。下面我们来看一个例子： 当然在上面的例子中，不仅 2 {\displaystyle 2} 是42的约数，21也是。 42 {\displaystyle 42} 被分解成 2 {\displaystyle 2} 和 21 {\displaystyle 21} 的乘积。 2 {\displaystyle 2} 是质数，不能再分解， 21 {\displaystyle 21} 是还是个合数，我们可以把它也分解开，注意到 21 = 3 × 7 {\displaystyle 21=3\times 7} ，所以 42 = 2 × 3 × 7 {\displaystyle 42=2\times 3\times 7} ，现在 2 {\displaystyle 2} , 3 {\displaystyle 3} , 7 {\displaystyle 7} 都是质数，已经不能再分解了，这样我们就把一个合数 42 {\displaystyle 42} 分解为几个质数（ 2 {\displaystyle 2} , 3 {\displaystyle 3} , 7 {\displaystyle 7} ）的乘积，这个过程叫做分解质因数。 因为所有的合数都可以分解成质数的乘积，所以它们都是某个质数的倍数，要判断一个数 A {\displaystyle A} 是不是合数，只要检验每一个比 A {\displaystyle A} 小的质数 B {\displaystyle B} ，看 A {\displaystyle A} 是不是 B {\displaystyle B} 的倍数。如果 A {\displaystyle A} 是 B {\displaystyle B} 的倍数，那么 A {\displaystyle A} 是合数，如果所有小于 A {\displaystyle A} 的 B {\displaystyle B} 都不是 A {\displaystyle A} 的倍数，说明 A {\displaystyle A} 无法分解成比它小的质数的乘积，于是 A {\displaystyle A} 是质数。 就像积木拼出来的图形不论先拆哪一部分，最后拆完都是哪些基本的积木一样，合数的分解与过程无关，最后得到的质因数都是一样的。我们有下面的规律 为什么说 1 {\displaystyle 1} 既不是质数，也不是合数呢？ 如果我们说 1 {\displaystyle 1} 是一个质数，那么让我们来看这样一个例子： 所以，我们为了不破坏上面的规律，只好说 1 {\displaystyle 1} 既不是质数，又不是合数了。 前面讨论的都是某一个数的约数或倍数，这一小节我们要讨论两个数的共同约数和倍数。 我们来看2个例子 像上面的例子中那样计算两个数的最大公约数和最小公倍数需要列出两者所有的公约数和最小的几个公倍数，对于比较大的数字就不那么方便了。下面我们学习两种比较简便的方法，来计算两个数的最大公约数和最小公倍数。 1. 想想看为什么我们只定义最大公约数和最小公倍数，却没有定义两个数的“最小公约数”和“最大公倍数”呢？ 1.任意两自然数的所谓“最小公约数”皆为1；任意两自然数的公倍数皆为其最小公倍数之倍数，无最大自然数，故无所谓“最大公倍数”. |
藥物化學/抗癌藥/Taxans 來自太平洋紫杉的樹皮（Taxus brevifolia），現都來自於歐洲紅豆杉（Taxus baccata）的葉子，然後再經半合成製得 雙萜類 15個碳的三環系統（tricyclo[9.3.1.0]pentadecane），fused 一個 oxetane ring 13號碳上有一個酯化的 β-phenylisoserine 側鏈 市場上的此類藥物，結構上差異在 C13（苯醯胺和 t-butoxycarboxamido）、C10（二級醇、乙醯酯和甲醚）與 C7（二級醇和甲醚） 與正在延長（或說聚合）的 β-微管的疏水性結合位置結合，抑制微管去聚合 P-gp Paclitaxel Docetaxel Cabazitaxel |
Drupal7初學者指南/安裝伺服器 如果你已经购买并打算使用服务器空间，请无视本文。 Drupal7是PHP架构，可以使用mysql，sqllite或类似mysql的数据库。这边暂时先介绍大家常用的mysql，如打算使用其它版本的数据库，请自行研究。 通常，Drupal7需要以下几个程序的安装 Apathe服务器 Mysql数据库 PHP 当然你可以说，我是高手，我自己下载安装（windows）或编译（Linux），那没问题，不过你恐怕不是本教程的适合读者。 目前网上有很多预配置的环境，Linux系统也有RPM，APT包可以装，这些都不再详述。需要注意的是，Drupal7需要Apathe打开PDO支持和对应的PDO_mysql支持，记得修改PHP的配置文件进行设置。 当然，也有这方面的技术盲，所以我这边介绍的是Windows上安装已经预配置好的环境的方法。至于Linux方面怎么设置，请再参考其余教程。 这里我推荐一个预配置的服务器包程序：wampserver。你可以去www.wampserver.com下载或去Google找。这个环境有几个好处： 预配置服务器包都有的Apathe、Mysql、PHP、MysqlAdmin。 可以用菜单方便切换Apathe、Mysql、PHP的版本，对应版本可以在www.wampserver.com下载并在菜单上选择切换。 PDO等对应Drupal7的选项默认打开。 好了，我们去下载最新版本的wampserver，安装。记得选择对应版本（32/64位）下载。 下面基本上可以一路默认了，除了改改这个服务器的安装路径，以及改改你自己的邮箱。其余不懂的先不要改。 安装完毕，启动服务器的管理器程序，一般默认情况下服务器的Apathe、Mysql、PHP也会同时启动。服务器程序最小化到右下的托盘上，有个W的小图标，单击左键出来菜单可以进默认网站的根目录（你安装目录下的WWW目录），MysqlAdmin，以及启动/关闭/配置Apathe、Mysql、PHP的子菜单。记住，目前mysql的管理员用户名是root,密码为空。 咳，在前段写完后，我在网上得知原来还有一个专用于Drupal的服务器包版本叫Acquia Stack Installer（官方网站），这里可以下载到一个支持Drupal的服务器包。或者你不用再头疼怎么设置PHP.INI了。 |
藥物化學/抗癌藥/DNA 甲基轉移酶抑制劑 抑制 DNA 甲基轉移酶，使得染色體結構較寬鬆，促進轉譯，如轉譯 p53 或是 p21 基因，可引發細胞凋亡，使癌細胞死亡 此類藥物皆容易被水解，因此當藥物調劑完後須立刻服用 Azacitidine Decitabine Nelarabine |
DSE ICT/1A-a 資訊處理簡介 • 用作將手動流程自動化、減少人為錯誤，並提升效率。 • 數據會被儲存在電腦的儲存設備中，讓程式用以輸入或輸出。 • 硬件是指資訊系統中所使用的實體設備，它們有不同的功能。 • 軟件是指在資訊系統中運行的程式。 • 軟件可分為不同類型。 備註：部件包括系統功能、數據、流程、科技及從業員 • 資訊處理即是將原始數據轉換成有意義的資訊。 • 此過程包括七個階段：收集→組織→儲存→處理→分析→傳輸→演示 備註：處理資訊的過程包括數據收集、組織、分析、儲存、處理、傳輸及演示 • 數據是一組未經整理的事實，單獨來看通常沒有意義。 • 數據經處理後，配合前文後理而轉換為資訊。 • 文本包括各種類型的字符，如數字、字母、符號等。 • 數碼圖像是由數碼相機捕捉或使用圖像編輯軟件製作的圖像。 • 數碼音頻是可轉換為聲音的數據，而聲音則是模擬信號。 • 視頻即圖像和音效的組合。 • 微型電腦、互聯網和搜尋器正不斷完善。 • 人們可以以更實惠的價格購買電腦部件。 • 流動設備的運算能力隨著科技進步而提高。 • 軟件的互動式設計使人們可直接存取所需的資訊。 • 遠程通訊的進步提高了資訊的流動性和覆蓋面。 • 物聯網 • 大數據 • 人工智能 • 知識產權 • 數據私隱 • 可信度 • 提取和組織 |
筏釣 筏釣（raft fishing）是指利用漂浮在水体中央的筏子为平台进行作钓的捕鱼活动。 其實，筏釣並沒有特別的魚餌，所以在選擇魚餌時，主要都是針對目標魚而定。大海中的各種魚類，其實大多數不會揀飲擇食，為了繼續生存，衹要能吃的食物，都會全被吃掉。 南極蝦 最方便和最有效的萬能釣餌及誘餌南極蝦，分生及半生兩種。 全部經過醃制及防腐處理，兩種誘餌分別不大，半生是經過高溫處理，蝦身較紅和耐用，而且好釣，釣不完還可以放進冰箱內，隔幾天也可再用。 而生的南極蝦較腥臭，蝦身水份多，釣不完也很少留下再用。 鈎南極蝦可以按情況單雙鈎，兩隻鈎或多隻一起鈎也可 紅蟲 紅蟲又稱沙蟲，和青蟲一樣生長在砂泥裹。 因為它們的氣味較腥臭，能吸引更多魚。 紅蟲多脂肪，又合有大量蛋白質，再加上本地魚習慣食紅蟲，所以相比起其他魚餌，紅蟲更易釣到魚。 紅蟲分本地蟲和大陸蟲，大陸蟲是人工養殖，所以價格較便宜，色呈紅或粉紅，身軀肥胖，大條的話可達一呎以上。 本地天然蟲略帶深色，深得有點像啡色，而且蟲身有閃爍的發光。 大部份用紅蟲用作魚餌的人，都會剪開一節節使用，每口餌約姆指長。 青蟲 這種海蟲原曷生長在海底沙泥裹，但能買到的全是人工培養出來的。 如果外盜魚不多，兩両重就足夠釣八小時。 青虫一定要買活生生的。 在購買時常有木槺附身，用作吸水之用。 由於青蟲濕身很易腐爛，所以若想養活一段時間，就一定要有木槺，並放進雪櫃。 如果蟲太長，最多可分一半作兩口餌之用 蝦仁 方便、便宜是最大的好處，再加上不是所有人都會釣活蝦，釣蟲又嘔心。 如果想蝦仁更受魚歡迎的話，可加工醃南極蝦漿、誘餌粉、砂糖、鹽和酒等。 生蝦 一般魚餌舖出售的生蝦全是人工飼養的箕圍蝦，而野生捕捉的則稱為「電蝦」，因為牠們是用電被捉。 活蟹 蟹在筏釣用的餌可以是小蟹和分段用的重皮蟹。 其中一個鈎小蟹的方法是，除去最後的第二隻腳，然後用魚鈎從那裡進入，並剌穿背殼，露出鈎尖就可。 第二種「重皮蟹」魚餌可以是最重味，而且非常可靠，亦是釣石斑或紅鮋最佳魚餌，可惜衹有夏天及秋天才有售。 小魚釣餌 既用魚肉不如整條小魚鈎下。如用魚肉，可考慮黃魚、烏頭或秋刀魚。 麵包釣餌 麵包鈎法有兩式。首先是搓成圓粒狀，藏鈎在當中就可以。其次是散鈎，用手撕成條狀，對摺，魚鈎就藏在對摺位。另外也有人會先將麵包浸透水才上鈎。 市面的筏竿長度由1m至2.1m長，當中最普及的是1.8m長的竿，不但可以應用於近，又可以作遠投。 而1.m、1.3m和1.5m長的，主要針對船上使用，2.1m就比較適合岸上用。 筏竿也分為多種不同的調性，俗稱硬度。 最硬的竿稱⌈特硬竿⌋，近年較少見了。 第二種稱為⌈硬調⌋，屬於本調子竿，即針對鱲魚。 軟硬性分配為3:7之比，適合的魚絲約1-3號，約4-12磅釣絲，用來釣3斤或以下的魚。對於新入門的朋友是不錯的選擇。 最後是⌈中硬調⌋筏竿，即軟硬分配為之比，基本上整枝竿都有弧度，受力起來會彎到手柄，用上幼的魚絲也不易被拉斷，適用的魚絲約0.8-2.0號，約3-8磅釣線。 筏釣絞主要是小型的橫絞和單軸的鼓型絞。有人稱為⌈維京型⌋，全部收線速度比為1:3的比例，有力之餘又不失收線的速度 魚絞設在竿上，魚絲和導線環向天的，統稱⌈上釣手⌋。 小橫絞又可稱「上絞手⌋。 ⌈上絞手⌋依靠姆指去按線杯，與獵物博鬥時比較得心應手。 反過來，向下的就是⌈下手釣⌋。 維京型和一些⌈餅仔絞⌋較多人採用，可稱為⌈下手釣⌋。 制動多數利用食指控制，對於竿的平衡道遜於小橫絞，但就由於有大線杯，使魚絲不易上氣這點優勝過小橫絞。 為提高靈敏度，多以幼絲為主，如果沒有特別需要一定是直出在釣組上，除非是深場，否則不會有孻腳(子線)。 直出的魚絲，即是母線，可分為布線、碳線、合成線以及尼龍線。 當中布線是最耐磨，可惜柔軟布線很容易燒竿頭及傷竿 碳線多是採用磯釣的碳子線，耐磨不俗，可惜太硬，除非釣大魚，否則少用。 筏釣的魚絲多為合成，半碳半尼龍。最新有種線心是鋼線，線皮是尼龍的新品種。 最後是尼龍絲，又幼又好力，人稱壓縮絲。雖然柔軟度頗高，可惜耐磨度差，較易斷絲。 跟釣法上關係並不密切，用什麼鈎則視乎釣什麼魚而定。 這種從日本傳過來的釣法，選擇魚鈎大可由以「伊勢尼」型為主的磯釣鈎入手。 隨着目標魚的明確，便引伸出「黑毛鈎」和「鱲鈎」。鱲鈎向右歪，用意針對鱲魚的波子牙齒，一般香港用1-3號足以應付各種鱲魚。「黑毛鈎」鈎骨粗而短，有高拉力特性，一般用6-12號已足夠。 魚鈎分不同顏色，好像金、銀和黑色等，不同的顏色用來配合不同的魚餌。 鉛錘的作法在於使釣組能順利沉到某深水度或海底處。筏釣主要用1.夾鉛 和 2. 中通鉛 兩種 釣組上的鉛錘大小取決於流水的速度和釣埸的深淺，一般內灣魚排下，流水不會太急，衹用上B-3B的夾鉛就足夠，除非流水急，令魚絲入水角度超過45°，才需要加上重鉛。中通鉛的使用，多數是連6B的夾鉛也支持不下才用。 岸邊投出的釣法，建議用中通鉛，晤之下可以利用太空豆或擰圈，確保有一段的子線才到鈎，這種自由鉛釣組的好處是在於魚輕口食餌時，魚訉不會經過固定的鉛才傳到竿頭，也大大減少頂口的情況。 每支竿的竿尾都有個小圓扣，用途是連接失手繩，以防止失去釣竿。 靠看竿頭接收魚訉，有魚才拿起魚竿。 其實，在上餌或用雙手搓團子時，竿子有安全的位置承托亦有必要。 湯馬士‧筏釣入門必讀寶典‧鈞林製作室‧ISBN 978-988-19254-1-1 |
藥物化學/抗癌藥/Purine 拮抗劑：amidophosphoribosyl 轉移酶抑制劑/Thioguanine 由於此藥少被xanthine 氧化酶代謝，因此與 Allopurinol 共服時不像 Mecraptopurine 要非常謹慎 |
藥物化學/抗癌藥/Purine 拮抗劑：amidophosphoribosyl 轉移酶抑制劑/Mercaptopurine Allopurinol 會抑制 xanthine 氧化酶，而增加 6-thioinsinic acid 的量，延長藥效作用時間與抗癌活性，但 mecraptopurine 的服用劑量需減半 |
Drupal7初學者指南 欢迎，这是Drupal7初学者指南。本教程的目的在于帮助你学习怎样安装以及使用Drupal7，不会涉及任何有关PHP编写模块的内容。 安裝伺服器 安裝Drupal7 安裝模块和主题 基本概念 发布一篇内容 给上面的增加更多细节 加个选单 为首页增加一个区块 |
DSE ICT 資訊處理簡介 資據組織及控制 數據表示 數據操縱和分析 基本機器組織 系統軟件 建網及互聯基本知識 互聯網服務及應用 初級網頁創作 網上威脅及保安 問題建構和分析 算法設計 程式開發 程式測試及除錯 備註：公開考試中使用的編程語言是Python或C++。 科技創新 健康及道德議題 知識產權 關聯式數據庫概念 結構化查詢語言 數據庫設計方法 備註：公開考試中使用的編程語言是SQL。 網絡服務與實施 客戶機—伺服器通訊的基本概念 基本網絡實施 網絡編程與應用 網頁編寫及網上出版 網絡編程與應用 備註：公開考試中使用的編程語言是Javascript及PHP。 程式編寫 方案設計和實施 測試和除錯 程式編寫在現實生活的應用 備註：公開考試中使用的編程語言是Python或C++。 |
初中化学/元素符号 国际上统一采用元素的拉丁文名称的第一个字母（大写）来表示元素，如氢元素的符号为H，氧元素的符号为O；如果几种元素拉丁文名称的第一个字母相同，就附加一个小写字母来区别。例如用Cu表示铜元素，Cl表示氯元素，Ca表示钙元素。 书写元素符号时应注意，由两个字母表示的元素符号，第二个字母必须小写。 元素符号表示一种元素，还表示这种元素的一个原子，例如，元素符号“O”既表示氧元素，又表示氧元素的一个原子。 |
文言/介詞 维基百科中的相关条目： 介詞 介詞是引出名詞，並實現介引功能的虛詞。 主事介詞用于引出動作的執行者。 客事介詞用于引出動作的接受者。 境事介詞用于引出動作發生的環境，例如時間、地點等。 處所介詞用于引出動作發生、進行、到達的地點，有「於」「在」「自」等。 「V於N地點」「V于N地點」 《報任少卿書》：「身直為閨閤之臣，寧得自引深臧於巖穴邪？」 《三國志·魏書·董卓傳》：「於望垣硤北爲羌、胡數萬人所圍」 《史記·魏公子列傳》：「平原君使者冠蓋相屬於魏」 《鄭伯克段于鄢》：「鄭武公娶于申」（鄭武公從申國娶妻） 《蘭亭集序》：「暮春之初，會于會稽山陰之蘭亭，脩稧事也。」 「在N地點V」 《論語·述而》：「子在齊聞韶，三月不知肉味」 時間介詞用于引出動作發生、持續、結束的時間，有「於」「乎」「自」「由」「當」「至」「在」「方」「及」「即」等。 「V乎N時間」 《師說》：「生乎吾前」（在我之前出生） 對象介詞用于引出動作所涉及、服務的對象，有「乎」「爲」「於」「于」等。 「V乎N對象」相當于「VN對象」 《荀子·勸學篇》：「君子博學而日參省乎己」（君子廣泛地學習並且每日多次反省自己） 「V爲N對象」相當于「給N對象V」「爲N對象V」 《桃花源記》：「不足爲外人道也。」 《史記·項羽本紀》：「公為我獻之。」 「V於/于N對象」相當于「V於N對象」「爲N對象V」 《報任少卿書》：「少卿足下：曩者辱賜書，教以慎於接物，推賢進士為務。」 《左传·昭公二十六年》：「群臣不盡力于魯君者，非不能事君也」（群臣不願为鲁君尽力） 範圍介詞用于引出動作所涉及的範圍。 因事介詞用于引出動作的原因、目的等。 目的介詞用于引出動作的目的。 原因介詞用于引出動作的原因。 比事介詞用于引出比較的基準，有「於」等 「P於N比較基準」 《荀子·勸學》：「青， 取之於藍而青於藍。」（靛青是從蓼藍中提取出來的，但是它的顏色比蓼藍更藍） 《報任少卿書》：「人固有一死，死有重於泰山，或輕於鴻毛，用之所趨異也」（人必然會有一死，死有的比泰山還重，有的比鴻毛還輕，這是因爲他們所追求的不同） 《史記·魏公子列傳》：「當此之時，平原君不敢自比於人。」 |
倍长中线法 把一个三角形里的中线延长至原来的一半，构造全等三角形 在一个三角形里，有中线，要求证明和差关系，80%的情况要用倍长中线法，20%的情况用一般方法。 例1：如图（上），在△ABC中，AB=2AC，AD平分BC，AD⊥AC，求∠BAC的度数。 解：∠BAC=120°，理由如下： 延长DA,使DA=DE，连接BE。 因为D是中点 从而△ADC≌△BDE（SAS） 从而∠E=∠EAC=90°，BE=AC 因为AB=2AC 从而 1/2AB=BE 从而∠BAE=30°（在直角三角形中，如果有一个角等于30°，那么它所对的直角边等于斜边的一半） 从而∠BAC =∠BAE+∠EAC =30°+90° =120° 例2：如图（下），在△ABC中，AB=5a，AC=3a（a>0），求中线AD的取值范围。 解：延长AD至AE,交BC于D，使DE=AD。连接EC。 因为点D是中点 所以△ABD≌△CDE(SAS) 由题意：AC+EC>AE>AC-EC，AB=EC=5a，AC=3a。 所以AE的取值范围为：即8a>AE>2a 由题意：AE=2AD 所以4a>AD>a |
生物氧化的酶类 生物氧化酶类 按照各种氧化还原酶类催化反应的特点，氧化还原酶类包括需氧脱氢酶、不需氧脱氢酶和氧化酶等。 1.1需氧脱氢酶 此酶催化底物脱氢，并将脱掉的氢呈递给分子氧，生成过氧化氢（H2O2）。 此酶大多以黄素单核苷酸（FMN）和黄素腺嘌呤二核苷酸（FAD）为辅基，称为黄素酶类。通常需要某些金属离子，如Mo2+和Fe2+等作为辅因子。 属于需氧脱氢酶的有黄嘌呤氧化酶、L-氨基酸氧化酶、D-氨基酸氧化酶及醛氧化酶等。 此酶不被氰化物（CN-）和一氧化碳抑制。属于此酶类的有黄嘌呤氧化酶、L-氨基酸氧化酶、D-氨基酸氧化酶及醛氧化酶等。无氧条件下，某些色素，如甲烯蓝（MB），可代替氧接受氢而被还原。 1.2不需氧脱氢酶 此酶与需氧脱氢酶不同在于，脱下的氢并不直接与氧反应，而是通过呼吸链传递，最终结合成水。此酶类的辅酶包括NAD+、NADP+和FAD等。在脂肪酸的β氧化分解过程中主要由不需氧脱氢酶参与催化。在葡萄糖分解代谢的过程中有多种不需氧脱氢酶参与反应。 1.3氧化酶 主要的氧化酶是出于呼吸链末端的细胞色素氧化酶或细胞色素c氧化酶，又称为细胞色素aa3，可催化细胞色素c的氧化，将电子直接传递给氧，使氧激活并接受H+生成水。此酶会被氰化物（CN-）和一氧化碳抑制，需要Fe2+和Cu2+等金属离子。 需要注意的是，前面提及的黄嘌呤氧化酶、L-氨基酸氧化酶、D-氨基酸氧化酶及醛氧化酶，它们催化生成的氧化产物是过氧化氢，而不是水。因此虽冠以“氧化酶”称号，但并不是真正意义上的氧化酶。 1.4其他氧化酶 这里主要指的是，存在于细胞内的一些其他的氧化酶，大多数位于过氧化物酶体中，在动物机体解毒和防御中发挥重要的作用。 1.4.1过氧化氢酶和过氧化物酶 这两类酶主要存在于过氧化物酶体中，功能是清除过氧化氢，消除其对细胞的毒性。辅基为铁卟啉。在血液和乳中这两类酶都有较高的活性。 1.4.2加氧酶 包括加单氧酶和加双氧酶。加单氧酶又称为羟化酶，存在于内质网膜。可催化脂溶性物质和类固醇物质的氧化，使之转化为极性物质而通过体液代谢排出体外。反应需要有NADPH+H+和细胞色素P450参加。 加双氧酶催化底物分子双键与氧的加成反应。如β-胡萝卜素转变为维生素A的反应。 1.5超氧化物歧化酶（SOD） 是一类存在广泛且包含金属酶类。超氧化物歧化酶催化超氧离子（O2-）的反应是一种歧化反应。 SOD能促进超氧化物的歧化反应，通过生成过氧化物和氧分子而清除自由基，阻止自由基的连锁反应，对机体起到保护作用。 (SOD催化)O2-+O2-+2H+→O2+H2O2 |
藥物化學/抗癌藥/Anthracyclines and Anthracenediones/Valrubicin 14 號碳接上 valerate ester ，3’ 碳接上三氟乙醯胺，使脂溶性高且 3’ 碳取代基變為為非離子形式，使其能快速和廣泛地穿透進入癌細胞 機轉非TopIIα毒化劑，而是阻止核苷酸組裝入DNA和RNA |
藥物化學/抗癌藥/Anthracyclines and Anthracenediones/Epirubicin 與 Doxorubicin 不同處在 4’ 醇基的立體構型，變為 𝛃 form，使得心臟毒性比Doxorubicin低30% |
文言/連詞 维基百科中的相关条目： 連詞 連詞是用來連結詞語、詞組、短句、句子、段落等的詞，用於表示不同語句間的邏輯關係。連詞主要可以表達以下的關係：並列、選擇、承接、轉折、遞進、選擇、假設、讓步、目的、因果、伴隨等。 文言中的一個連詞往往同時承擔多個語義功能，實際的含義和翻譯主要由上下文決定，例如「而」字可以表達並列、轉折、順承等等很多關係。 「而」是比較有代表性的一個連詞，十分常用。一般「而」用於連接謂詞性成分（包括謂詞、謂詞詞組和含有謂詞的短句），構成「P而P」的結構。「而」作爲一個功能豐富的連詞，其具體所表達的關係由上下文決定。 「A而A」 《左傳·桓公元年》：「美而艷」 「V而V」 《戰國策·觸龍說趙太后》：「入而徐趨，至而致謝」 「N而N」 《荀子·勸學篇》：「蟹六跪而二螯」（蟹有六條腿和兩個鉗子） 「SP而SP」 《論語·泰伯》：「任重而道遠」 按連詞所表達的邏輯關係可將連詞分爲以下幾類： 並列連詞有「與」「及」「以」「且」「而」「暨」等，相當於「和」「及」「並」「並且」「而且」「又X又X」。 「N與N」 《太平御覽》：「周人有愛裘而好珍羞，欲為千金之裘而與狐謀其皮」 《報任少卿書》：「昔衛靈公與雍渠同載，孔子適陳」（曾經衛靈公和雍渠坐了同一輛車，孔子便去了陳國） 「N及N」 《鄭伯克段于鄢》：「生莊公、及共叔段」（武姜生下了莊公和共叔段） 「N而N」 《荀子·勸學篇》：「蟹六跪而二螯」 《左傳·桓公元年》：「美而艷」 《論語·泰伯》：「任重而道遠」 選擇連詞有「若」「如」「抑」 等，相當於「或」「或者」。 「若N1，若N2」「N1若N2」 「N1如N2」 《論語·先進》：「安見方六七十，如五六十，而非邦也者！」（怎麼六七十或者五六十里見方就算不上國家了？！） 「抑S」 承接連詞有「則」「而」「然則」等，表示前後兩項時間上相承而相關，相當於「那麼」「然後」「就」「便」等。 「P而P」 《論語·學而》：「學而時習之，不亦說乎」 《論語·學而》：「君子務本，本立而道生」 《論語·爲政》：「溫故而知新，可以爲師矣。」 「P以P」 《尚書·周書·金縢》：「天大雷電以風」 「然則S」 《岳陽樓記》：「然則何時而樂耶？」（那麼什麼時候歡樂呢？） 轉折連詞有「然」「而」「則」「然則」等，表示前後兩項相反，相當於「但是」。 「P而P」 《論語·爲政》：「學而不思則罔，思而不學則殆。」 《論語·學而》：「貧而無諂，富而無驕」 《荀子·勸學篇》：「目不能兩視而明，耳不能兩聽而聰。」 「然則S」 《岳陽樓記》：「然則北通……得無異乎？」（然而此地向北通往……難道都會一樣嗎？） 遞進連詞有「而」「以」等，表示後項在前項的基礎上更進一步，相當於「並」「而且」。 「P而P」 《荀子·勸學篇》：「君子博學而日參省乎己」 《戰國策·觸龍說趙太后》：「入而徐趨，至而致謝」 《孫子·謀攻》：「不戰而屈人之兵」 假設連詞有「若」「如」「苟」等，相當於「如果」。 「如S」 《論語·子路》：「如有政，雖不吾以，吾其與聞之！」（如果有政事，即使我不在朝，我總會聽說吧！） 「苟S」 《史記·陳涉世家》：「苟富貴，無相忘。」（如果我們之中有誰富貴了，不要互相忘記。） 讓步（縱予）連詞有「雖」「縱」等，相當於「即使」「雖然」。 「雖S」 《公羊傳·莊公四年》：「九世猶可以復讎乎？雖百世可也。」 《蘭亭集序》：「雖無絲竹管弦之盛，一觴一詠，亦足以暢敘幽情。」 《論語·子路》：「如有政，雖不吾以，吾其與聞之！」（如果有政事，即使我不在朝，我總會聽說吧！） 《捕蛇者說》：「悍吏之吾鄉，叫囂乎東西，隳突乎南北，譁然而駭者，雖雞狗不得寧焉。」 《捕蛇者說》：「今雖死乎此，比吾鄉鄰之則已後矣，又安敢毒耶？」 「雖然」（即使這樣） 「縱S」 目的連詞有「以」「爲」等，相當於「以」「來」。 「」 因果連詞有「故」「以」「爲」「由」「蓋」等，相當於「因爲」「所以」。 「S，蓋S」 《前出師表》：「然侍衞之臣不懈於內，忠志之士忘身於外者，蓋追先帝之殊遇，欲報之於陛下也。」（蓋：這是因爲） 伴隨連詞有「以」「而」等。 所謂「謂詞性」即可以做謂語的性質，比如形容詞、動詞和一部分名詞。 |
藥物化學/抗癌藥/Anthracyclines and Anthracenediones/Doxorubicin C13上有羥甲基取代：藥效持續時間長 高脂溶性 市面上以脂質體作為藥劑型式販賣，增加對癌細胞的選擇性，也可以保護藥物不被會產生心臟毒性的酵素催化，與不容易積聚在心臟中 |
截长补短法 在一个平面几何图形内，延长或截取某一条线段，使线段所在的三角形与平面内某一三角形成为全等三角形。 证明两条线段的和差，80%的情况都要用截长补短法，20%的情况用常规方法。 例1：如图1，正方形ABCD中，点E在CD上，点F在BC上，∠EAF=45。求证：EF=DE+BF。 解：延长CD到点G，使得DG=BF，连接AG。 从而可证得ADG≌ABF（SAS）。 从而可以得出∠GAD=∠FAB 因为∠GAD=∠FAB 所以∠GAF=90(等量代换) 因为∠GAF=90，∠EAF=45 所以∠GAE=∠EAF=45 从而△EAG≌△EAF（SAS） 所以EF=GE =GD+DE =BF+DE 例2：如图2，已知AD∥BC，AB=AD+BC，E是CD的中点，求∠AEB的度数。 解：向AE方向延长AE，交BC的延长线于F。 因为平行，所以∠1=∠F 从而△AED≌△CEF 从而AB =AD+BC =CF+BC =BF 因为等腰三角形三线合一，所以BE⊥AF，从而∠AEB=90 例3：如图，在△ABC中，∠B=2∠C，AD平分∠BAC。求证：AB+BD=AC。 证明：在AC上截取AE=AB，连接DE。 从而△ABD≌△AED（SAS） 从而BD=DE，∠B=∠3 因为∠B=2∠C 从而∠3=2∠C 而2∠C=∠4+∠C 所以∠C=∠4 已证明DE=CE，BD=CE 所以AB+BD=AC 例4：如图，AC平分∠DAB，∠ADC+∠B=180。求证：CD=CB。 在AB上找一点E，使AE=AD，连接CE。 因为AC平分∠DAB 从而△ACD≌△ACE(SAS) 所以∠ADC=∠AEC 因为∠AEC+∠B=180，∠CEB+∠AEC=180 所以∠B=∠CEB 所以CE=CB 从而CD=CB |
初中语文/七年级上册 观沧海/曹操 闻王昌龄左迁龙标遥有此寄/李白 次北固山下/王湾 天净沙·秋思/马致远 金色花/泰戈尔 荷叶·母亲/冰心 咏雪 陈太丘与友期行 本文作者逝世未满50年，作品尚未进入公有领域，请不要录入。 |
Introducing Julia/Plotting Julia 有许多不同的绘图包，应该会有一款适合您的需要，合您口味。本节是对其中一种绘图包 Plots.jl 的快速介绍，它非常有趣，因为它与许多其他绘图软件包进行了交互。在使用Julia进行绘图之前，请下载并安装一些绘图包 (请先在 REPL 中键入 ] 进入 pkg 模式) (v1.0) pkg> add Plots PyPlot GR UnicodePlots 第一个包，Plots，是一个高级绘图包，它为其他绘图包 (这里称为“后端”backend )提供一个统一的接口，而这些后端则充当生成图形的图形“引擎”。每个后端都是一个独立的绘图包，可以单独使用，但使用 Plots 的优点是，它提供给您一个更简单更一致的接口。 通过下面的代码，您可以开始在 Julia 会话中使用 Plots.jl 这个绘图包。 julia> using Plots 一般来说，您会需要将一个或者多个 序列 （即数值数组）绘制成图，或者也可以提供一个或多个函数来生成这些数值。 如果您想继续探究，这里使用的示例数据是一个简单的数值数组，表示当前年份中每天的 均时差 的值。(这些值曾用于调整机械时钟，以解释地球绕椭圆轨道摆动时的不稳定轨道。) julia> using Astro # you'll need to add this package with: add https://github.com/cormullion/Astro.jl julia> using Dates julia> days = Dates.datetime2julian.(Dates.DateTime(2018, 1, 1, 0, 0, 0):Dates.Day(1):Dates.DateTime(2018, 12, 31, 0, 0, 0)) julia> eq_values = map(equation_time, days) 我们现在有了一组 Float64 类型的数据，每个数据表示一年中每天的数值： 365-element Array{Float64,1}: -3.12598 -3.59633 -4.97289 -5.41857 -5.85688 ⋮ -1.08709 -1.57435 -2.05845 -2.53887 -3.01508 要对这一组数据绘图，只需要把它传入到 Plots 的 plot() 函数中。 julia> plot(eq_values) 这使用了第一个可用的绘图引擎。Plot 将该系列视为 y 值，添加了其他打印值，自动提供与您提供的 y 值相匹配的 x 值，然后为您打印所有内容。 如果你想要选择不同的绘图引擎，使用提供的几个函数 gr(), unicodeplots(), plotly() 以及其他的。例如，选择 Unicodeplots 绘图包（会使用 Unicode 字符绘图，这是在 REPL/终端 上的最佳选择）： julia> unicodeplots() julia> plot(eq_values) +------------------------------------------------------------+ 17 | ,--u | y1 | ./ "\ | | ./ \ | | ./ . | | / \. | | / \ | | .` ", | | ,` \ | | .r--\. / . | | /` \. / \ | |----------------nr-------fhr-----------v------------------v*| | .F \. ,` |.| |, / \, ,/ `| |l / "\. ,` | |". / \-ur/` | | \. /` | | l ,` | | \ ./ | | "\. ./` | -15 | '--" | +------------------------------------------------------------+ 0 370 GR 引擎/后端 也是一个很好的通用绘图软件包： julia> gr(); julia> plot(eq_values) Switch back to using PyPlot back-end: julia> pyplot() The Equation of Time graph can be approximately modeled by a function combining a couple of sine functions: julia> equation(d) = -7.65 * sind(d) + 9.87 * sind(2d + 206); It's easy to plot this function for every day of a year. Pass the function to plot(), and use a range to specify the start and end values: julia> plot(equation, 1:365) To combine the two plots, so as to compare the equation and the calculated series versions, Plots lets you add another plot to an existing one. The usual Julia convention of using "!" to modify the argument is available here (in an implicit way — you don't actually have to provide the current plot as an argument): the second plot function, plot!() modifies the previous plot: julia> plot(eq_values); julia> plot!(equation, 1:365) There is copious documentation for the Plots.jl package, and after studying it you'll be able to spend hours tweaking and customizing your plots to your heart's content. Here are a few examples. The ticks along the x-axis show the numbers from 1:365, derived automatically from the single series provided. It would be better to see the dates themselves. First, create the strings: julia> days = Dates.DateTime(2018, 1, 1, 0, 0, 0):Dates.Day(1):Dates.DateTime(2018, 12, 31, 0, 0, 0) julia> datestrings = Dates.format.(days, "u dd") The supplied value for the xticks option is a tuple consisting of two arrays/ranges: (xticks = (1:14:366, datestrings[1:14:366]) the first provides the numerical values, the second provides matching text labels for the ticks. Extra labels and legends are easily added, and you can access colors from the Colors.jl package. Here's a prettier version of the basic plot: julia> plot!( eq_values, label = "equation of time (calculated)", line=(:black, 0.5, 6, :solid), size=(800, 600), xticks = (1:14:366, datestrings[1:14:366]), yticks = -20:2.5:20, ylabel = "Minutes faster or slower than GMT", xlabel = "day in year", title = "The Equation of Time", xrotation = rad2deg(pi/3), fillrange = 0, fillalpha = 0.25, fillcolor = :lightgoldenrod, background_color = :ivory ) If you work in the REPL a lot, perhaps you want a quick and easy way to draw plots that use text rather than graphics for output? The UnicodePlots.jl package uses Unicode characters to draw various plots, avoiding the need to load various graphic libraries. It can produce: scatter plots line plots bar plots (horizontal) staircase plots histograms (horizontal) sparsity patterns density plots Download and add it to your Julia installation, if you haven't already done so: pkg> add UnicodePlots You have to do this just once. Now you load the module and import the functions: julia> using UnicodePlots Here is a quick example of a line plot: julia> myPlot = lineplot([1, 2, 3, 7], [1, 2, -5, 7], title="My Plot", border=:dotted) My Plot ⡤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⢤ 10 ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠔⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠊⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠀⠀⠀⠀⠔⠒⠊⠉⢣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠉⠉⠉⠉⠉⠉⠉⠉⠉⠫⡉⠉⠉⠉⠉⠉⢉⠝⠋⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁⢸ ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠱⡀⠀⢀⡠⠊⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠑⠔⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ -10 ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸ ⠓⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠚ 0 10 And here's a density plot: julia> myPlot = densityplot(collect(1:100), randn(100), border=:dotted) ⡤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⢤ 10 ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ░ ⢸ ⡇ ░░░ ░ ▒░ ▒░ ░ ░ ░ ░ ░ ░ ⢸ ⡇░░ ░▒░░▓▒▒ ▒░░ ▓░░ ░░░▒░ ░ ░ ▒ ░ ░▒░░⢸ ⡇▓▒█▓▓▒█▓▒▒▒█▒▓▒▓▒▓▒▓▓▒▓▒▓▓▓█▒▒█▓▒▓▓▓▓▒▒▒⢸ ⡇ ░ ░ ░░░ ░ ▒ ░ ░ ░░ ░ ⢸ ⡇ ░ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ ⡇ ⢸ -10 ⡇ ⢸ ⠓⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠚ 0 100 (Note that it needs the terminal environment for the displayed graphs to be 100% successful - when you copy and paste, some of the magic is lost.) allows you to create visualizations in a web browser window. VegaLite is a visualization grammar, a declarative format for creating and saving visualization designs. With VegaLite you can describe data visualizations in a JSON format, and generate interactive views using either HTML5 Canvas or SVG. You can produce: Area plots Bar plots/Histograms Line plots Scatter plots Pie/Donut charts Waterfall charts Wordclouds To use VegaLite, first add the package to your Julia installation. You have to do this just once: pkg> add VegaLite Here's how to create a stacked area plot. julia> using VegaLite julia> x = [0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9] julia> y = [28, 43, 81, 19, 52, 24, 87, 17, 68, 49, 55, 91, 53, 87, 48, 49, 66, 27, 16, 15] julia> g = [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1] julia> a = areaplot(x = x, y = y, group = g, stacked = true) A general feature of VegaLite is that you can modify a visualization after you've created it. So, let's change the color scheme using a function (notice the "!" to indicate that the arguments are modified): julia> colorscheme!(a, ("Reds", 3)) You can create pie (and donut) charts easily by supplying two arrays. The x array provides the labels, the y array provides the quantities: julia> fruit = ["peaches", "plums", "blueberries", "strawberries", "bananas"]; julia> bushels = [100, 32, 180, 46, 21]; julia> piechart(x = fruit, y = bushels, holesize = 125) |
中華民國命令註解/道路交通標誌標線號誌設置規則/第231條 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國78年)#第八節 時制設計之基本原則 第二百三十一條 號誌之燈號變換規定如左： 一、行車管制號誌之黃色燈號時間得依左表之規定： 二、行車管制號誌在黃色燈號結束後，應有一秒以上之全紅時間。直行交通之全紅時間宜依左表公式計算，使車輛能以正常速率，由近端停止線駛過遠端之行人穿越道或路段起點。 三、只有紅、綠兩色燈號之行車管制號誌，應以閃光綠燈取代黃色燈號，其時間長度爲五秒。如係作爲單向輪放管制，在改變遵循方向時，兩向均應顯示紅色燈號，其時間應足以淸除管制車道內之車輛。 四、行車管制號誌轉變爲閃光號誌時，幹道上號誌應由綠色燈號經過黃色燈號時段轉變爲閃光黃燈，支道上號誌應由紅燈轉變爲閃光紅燈；由閃光號誌轉變爲行車管制號誌時，應有三秒全紅時間，再循序轉換。 五、行人專用號誌在綠色「行走行人」燈號結束前，應有閃光運轉，其閃光時間應適足以使已進入道路之行人能以正常速率走完全程或到達可供行人避護之交通島。 六、行人觸動號誌經行人按鈕後，行車管制號誌應先循序變換爲紅燈，行人專用號誌始顯示綠燈。 七、車道管制號誌改變車道爲由對向車輛使用時，應於兩向同時顯示叉形紅燈，其時間應足以淸除管制車道內之車輛。在叉形紅燈顯示前，宜有五秒之箭頭綠燈閃光運轉，使駕駛人能採取因應措施。 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國83年4月)#第八節 時制設計之基本原則 第二百三十一條 號誌之燈號變換規定如左： 一、行車管制號誌之黃色燈號時間得依左表之規定： 二、行車管制號誌在黃色燈號結束後，應有一秒以上之全紅時間。直行交通之全紅時間宜依左表公式計算之。 三、只有紅、綠兩色燈號之行車管制號誌，應以閃光綠燈取代黃色燈號，其時間長度爲五秒。如係作爲單向輪放管制，在改變遵循方向時，兩向均應顯示紅色燈號，其時間應足以清除管制車道內之車輛。 四、行車管制號誌轉變爲閃光號誌時，幹道上號誌應由綠色燈號經過黃色燈號時段轉變爲閃光黃燈，支道上號誌應由紅燈轉變爲閃光紅燈；由閃光號誌轉變爲行車管制號誌時，應有三秒全紅時間，再循序轉換。 五、行人專用號誌在綠色「行走行人」燈號結束前，應有閃光運轉，其閃光時間應適足以使已進入道路之行人能以正常速率走完全程或到達可供行人避護之交通島。其計算公式如下： t=dw/v其中 t ：閃光綠燈時間。 dw：路口無供行人避讓之交通島時爲橫越路口寬；路口有供行人避讓之交通島時爲路邊緣石至供行人避讓交通島寬度較寬者。 v ：行走速率，一般使用一．○公尺／秒，學童眾多地點使用○．八公尺／秒，盲人音響號誌處使用○．五公尺／秒。 六、行人觸動號誌經行人按鈕後，行車管制號誌應先循序變換爲紅燈，行人專用號誌顯示綠燈。 七、車道管制號誌改變車道爲由對向車輛使用時，應於兩向同時顯示叉形紅燈，其時間應足以清除管制車道內之車輛。在叉形紅燈顯示前，宜有五秒之箭頭綠燈閃光運轉，使駕駛人能採取因應措施。 2007年11月1日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國96年)#第八節 時制設計之基本原則 第二百三十一條 號誌之燈號變換規定如下： 一、行車管制號誌之黃色燈號時間得依下表之規定： 二、行車管制號誌在黃色燈號結束後，應有一秒以上之全紅時間。直行交通之全紅時間，宜依下表公式計算之。 三、只有紅、綠兩色燈號之行車管制號誌，應以閃光綠燈取代黃色燈號，時間長度爲五秒；其作爲單向輪放管制者，在改變遵循方向時，兩向均應顯示紅色燈號，時間應足以清除管制車道內之車輛。 四、行車管制號誌轉變爲閃光號誌時，幹道上號誌應由綠色燈號經過黃色燈號時段轉變爲閃光黃燈，支道上號誌應由紅燈轉變爲閃光紅燈；由閃光號誌轉變爲行車管制號誌時，應有三秒全紅時間，再循序轉換。 五、行人專用號誌在綠色「行走行人」燈號結束前，應有閃光運轉，其閃光時間應適足以使已進入道路之行人能以正常速率走完全程或到達可供行人避護之交通島；其計算公式如下： t = dw／v ，其中 t：閃光綠燈時間。 dw：路口無供行人避讓之交通島時爲橫越路口寬；路口有供行人避讓之交通島時爲路邊緣石至供行人避讓交通島寬度較寬者。 v：行走速率，一般使用一公尺／秒，學童眾多地點使用零點八公尺／秒，盲人音響號誌處使用零點五公尺／秒。 六、行人觸動號誌經行人按鈕後，行車管制號誌應先循序變換爲紅燈，行人專用號誌始顯示綠燈。 七、車道管制號誌改變車道爲由對向車輛使用時，應於兩向同時顯示叉形紅燈，其時間應足以清除管制車道內之車輛。在叉形紅燈顯示前，宜有五秒之箭頭綠燈閃光運轉，使駕駛人能採取因應措施。 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國104年)#第八節 時制設計之基本原則 第二百三十一條 號誌之燈號變換規定如下： 一、行車管制號誌之黃色燈號時間得依下表之規定： 二、行車管制號誌在黃色燈號結束後，應有一秒以上之全紅時間。直行交通之全紅時間，宜依下表公式計算之。 三、只有紅、綠兩色燈號之行車管制號誌，應以閃光綠燈取代黃色燈號，時間長度為五秒；其作為單向輪放管制者，在改變遵循方向時，兩向均應顯示紅色燈號，時間應足以清除管制車道內之車輛。 四、行車管制號誌轉變為閃光號誌時，幹道上號誌應由綠色燈號經過黃色燈號時段轉變為閃光黃燈，支道上號誌應由紅燈轉變為閃光紅燈；由閃光號誌轉變為行車管制號誌時，應有三秒全紅時間，再循序轉換。 五、行人專用號誌在綠色「行走行人」燈號結束前，應有閃光運轉，其閃光時間應適足以使已進入道路之行人能以正常速率走完全程或到達可供行人避護之交通島；其計算公式如下： t=dw/v，其中 t：閃光綠燈時間。 dw：路口無供行人避讓之交通島時為橫越路口寬；路口有供行人避讓之交通島時為路邊緣石至供行人避讓交通島寬度較寬者。 v：行走速率，一般使用一公尺／秒，學童眾多地點使用零點八公尺／秒，盲人音響號誌處使用零點五公尺／秒。 六、行人觸動號誌經行人按鈕後，行車管制號誌應先循序變換為紅燈，行人專用號誌始顯示綠燈。 七、車道管制號誌改變車道為由對向車輛使用時，應於兩向同時顯示叉形紅燈，其時間應足以清除管制車道內之車輛。在叉形紅燈顯示前，宜有五秒之箭頭綠燈閃光運轉，使駕駛人能採取因應措施。 八、大眾捷運系統車輛行經之交叉路口，其大眾捷運系統號誌應與行車管制號誌連鎖，相關號誌之燈號即時制設計由大眾捷運系統工程建設機構或營運機構依系統特性協調主管機關辦理。 增加第八款。其他除爲改為外，未修正。 |
面積和體積 面積：物體的表面—平面圖形的大小。 體積：物質或物體所占空间的大小或占據一特定容積的物質的量。 長方形面積=長×寬 = l w {\displaystyle =lw} 正方形面積=邊長2 = x {\displaystyle =x} 2 {\displaystyle 2} 平行四邊形面積=底×高 三角形面積=平行四邊形面積÷2=底×高÷2 梯形面積=(上底+下底)×高÷2 圓形（正圓）面積=半徑×半徑×圓周率 長方体表面積=（長×寬+長×高+寬×高）×2 正方体表面積=正方形面積×6=邊長2×6 球體（正球）表面積=圓形（正圓）面積×4=4×圓周率×半徑2 長方體體積=長×寬×高 正方體體積=邊長3 柱體體積=底面積×高 錐體體積=柱體體積÷3=底面積×高÷3 圓柱（正圓）體積=圓形（正圓）底面積×高=圆周率×底半径2×高 圓锥=1/3×半徑2×圓周率×高 球體體積=4/3×圓周率×半徑3 |
中華民國命令註解/道路交通標誌標線號誌設置規則/第233條 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國78年)#第八節 時制設計之基本原則 第二百三十三條 號誌時制設計之基本規定如左： 一、行車管制號誌，其時制設計應考慮交岔路口車輛交通量、流向、車速、路況及行人穿越數等因素，並以使路口延滯、車輛停等次數、燃料消耗量及廢氣排放量等負效用爲最小；或使車輛通行有效綠帶寬最大爲指標，據以設計時制。 二、行車管制號誌之週期長度，以三○秒至一二○秒爲原則。 三、特種閃光號誌與行人穿越道號誌，及行車管制號誌與行人專用號誌之閃光操作等，其閃爍次數每分鐘爲五○至六○次，閃滅交替之時間應相等。 四、鐵路平交道號誌雙閃紅燈，其閃爍次數每分鐘爲四○至五○次。至少在火車駛抵平交道前二○秒即應開始顯示。 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國83年4月)#第八節 時制設計之基本原則 第二百三十三條 號誌時制設計之基本規定如左： 一、行車管制號誌，其時制設計應考慮交岔路口車輛交通量、流向、車速、路況及行人穿越數等因素，並以使路口延滯、車輛停等次數、燃料消耗量及廢氣排放量等負效用爲最小；或使車輛通行有效綠帶寬最大爲指標，據以設計時制。 二、行車管制號誌之週期長度，以三○秒至一○○秒爲原則。 三、特種閃光號誌與行人穿越道號誌，及行車管制號誌與行人專用號誌之閃光操作等，其閃爍次數每分鐘爲五○至六○次，閃滅交替之時間應相等。 四、鐵路平交道號誌雙閃紅燈，其閃爍次數每分鐘爲四○至五○次。至少在火車駛抵平交道前二○秒即應開始顯示。 第二款行車管制號誌之週期長度原則，30至120秒改成30至100秒。 |
文言/孟子 维基百科中的相关条目： 孟子 (書) 孟子曰：「天時不如地利，地利不如人和。三里之城，七里之郭，環而攻之而不勝；夫環而攻之，必有得天時者矣，然而不勝者，是天時不如地利也。城非不高也，池非不深也，兵革非不堅利也，米粟非不多也，委而去之，是地利不如人和也。故曰：域民不以封疆之界，固國不以山溪之險，威天下不以兵革之利。得道者多助，失道者寡助。寡助之至，親戚畔之；多助之至，天下順之。以天下之所順，攻親戚之所畔，故君子有不戰，戰必勝矣。」 |
中華民國命令註解/道路交通標誌標線號誌設置規則/第230條 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國78年)#第八節 時制設計之基本原則 第 二百三十 條 行車管制號誌之時相規定如左： 一、有左列情形之一者，可使用二時相： ㈠設置於三岔路口者。 ㈡設置於左轉車輛不多之四岔路口者。 ㈢設置於無行人專用時相之四岔路口者。 ㈣設置於設有行人專用號誌之非交岔路口者。 二、有左列情形之一者，可使用三時相或四時相： ㈠設置於五岔路口者。 ㈡設置於左轉車輛特多之四岔路口者，但該路口宜有左轉專用設施配合。 ㈢設置於行人特多須使用行人專用時相之交岔路口者者。 三、設置於道路錯綜、交通繁複之交岔路口者，視需要可使用五時相以上號誌，並得視交通情況將不必要之時相予以跳越。 行車管制號誌設置於左轉車輛較多，且兩向交通流量懸殊之交岔路口者，可使用綠燈早開或綠燈遲閉方式處理。 2007年11月1日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國96年)#第八節 時制設計之基本原則 第 二百三十 條 行車管制號誌之時相規定如下： 一、有下列情形之一者，可使用二時相： (一)設置於三岔路口者。 (二)設置於左轉車輛不多之四岔路口者。 (三)設置於無行人專用時相之四岔路口者。 (四)設置於設有行人專用號誌之非交岔路口者。 二、有下列情形之一者，可使用三時相或四時相： (一)設置於五岔路口者。 (二)設置於左轉車輛特多之四岔路口者，但該路口宜有左轉專用設施配合。 (三)設置於行人特多須使用行人專用時相之交岔路口者。 三、設置於道路錯綜、交通繁複之交岔路口者，視需要可使用五時相以上號誌，並得視交通情況將不必要之時相予以跳越。 行車管制號誌設置於左轉車輛較多，且兩向交通流量懸殊之交岔路口者，可使用綠燈早開或綠燈遲閉方式處理。 行車管制號誌使用左轉專用時相，除設有早開控制時相外，應配合佈設左彎待轉區線。左轉箭頭綠燈與對向號誌之圓形綠燈或直行箭頭綠燈不得於同一時相並亮。 |
中華民國命令註解/道路交通標誌標線號誌設置規則/第235條 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國78年)#第五章 附 則 第二百三十五條 本規則自發布日施行。 2006年7月1日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國95年6月)#第五章 附 則 第二百三十五條 本規則自發布日施行。 本規則修正條文施行日期，由交通部會同內政部定之。 2007年11月1日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國96年)#第五章 附 則 第二百三十五條 本規則自發布日施行。 本規則中華民國九十五年六月二十八日修正發布之條文，其施行日期，由交通部會同內政部定之。 本規則中華民國九十六年九月十七日修正發布之條文，自九十六年十一月一日施行。 2008年4月15日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國97年4月)#第五章 附 則 第二百三十五條 本規則自發布日施行。 本規則中華民國九十五年六月二十八日、九十七年四月十四日修正發布之條文，其施行日期，由交通部會同內政部定之。 本規則中華民國九十六年九月十七日修正發布之條文，自九十六年十一月一日施行。 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國106年)##第五章 附 則 第二百三十五條 本規則自發布日施行。 本規則中華民國九十五年六月二十八日、九十七年四月十四日修正發布之條文，其施行日期，由交通部會同內政部定之。 本規則中華民國九十六年九月十七日修正發布之條文，自九十六年十一月一日施行。 本規則中華民國一百零六年六月十四日修正發布之第五十五條之二條文，自一百 零七年一月一日施行。 |
文言/篇章 文言文的篇章，和其他語言的寫作類似的，有特定的結構。然而文言作爲一個千錘百鍊的文章語言，寫文言文時，有許多特殊的地方。 「起承轉合」是最基礎的文章結構，特別是議論文所必要的。一個好的文章，一定是有起有伏的，特別是文言寫作中，抑揚作爲文言相對於世界其他語言最典型特徵之一（參見抑揚法），自然要重視。 「起」即文章的起頭，如何引出想要寫的話題，就在「起」上。 「承」即承接上文的部分。「承」的部分不僅僅要承接上文，也要開啓下文。 「轉」即轉折之處。可以說是一個文章所能達到高度的點，若是其他部分都很好，唯獨「轉」處不夠味道，那麼整篇文章便不夠精彩。 「合」便是文章的結尾，點題昇華。 出自《前出師表》 臣亮言：先帝創業未半，而中道崩殂，今天下三分，益州疲敝，此誠危急存亡之秋也。然侍衞之臣不懈於內，忠志之士忘身於外者，蓋追先帝之殊遇，欲報之於陛下也。誠宜開張聖聽，以光先帝遺德，恢弘志士之氣，不宜妄自菲薄，引喻失義，以塞忠諫之路也。 宮中府中，俱爲一體，陟罰臧否，不宜異同。若有作姦犯科及爲忠善者，宜付有司，論其刑賞，以昭陛下平明之治，不宜偏私，使內外異法也。 侍中、侍郎郭攸之、費禕、董允等，此皆良實，志慮忠純，是以先帝簡拔以遺陛下。愚以爲宮中之事，事無大小，悉以咨之，然後施行，必能裨補闕漏，有所廣益。 將軍向寵，性行淑均，曉暢軍事，試用之於昔日，先帝稱之曰能，是以衆議舉寵爲督。愚以爲營中之事，事無大小，悉以咨之，必能使行陣和睦，優劣得所也。 親賢臣，遠小人，此先漢所以興隆也；親小人，遠賢臣，此後漢所以傾頹也。先帝在時，每與臣論此事，未嘗不歎息痛恨於桓、靈也。侍中、尚書、長史、參軍，此悉貞良死節之臣也，願陛下親之信之，則漢室之隆，可計日而待也。 臣本布衣，躬耕於南陽，苟全性命於亂世，不求聞達於諸侯。先帝不以臣卑鄙，猥自枉屈，三顧臣於草廬之中，諮臣以當世之事，由是感激，遂許先帝以驅馳。後值傾覆，受任於敗軍之際，奉命於危難之間，爾來二十有一年矣。 先帝知臣謹慎，故臨崩寄臣以大事也。受命以來，夙夜憂歎，恐託付不效，以傷先帝之明，故五月渡瀘，深入不毛。今南方已定，兵甲已足，當獎率三軍，北定中原，庶竭駑鈍，攘除姦凶，興復漢室，還于舊都。此臣所以報先帝，而忠陛下之職分也。至於斟酌損益，進盡忠言，則攸之、禕、允之任也。 願陛下託臣以討賊興復之效；不效，則治臣之罪，以告先帝之靈。若無興德之言，則責攸之、禕、允等之慢，以彰其咎。陛下亦宜自謀，以諮諏善道，察納雅言。深追先帝遺詔，臣不勝受恩感激。 今當遠離，臨表涕零，不知所言。 第一紅字部分即「起」，先講背景，提出論點。 第二黑字部分即「承」，先提原則，再舉實例，最後小結。 第三藍字部分即「轉」，先講舊事，引之點題。 第四紅字部分即「結」，總結論點，宣發感情。 |
中華民國命令註解/道路交通標誌標線號誌設置規則/第67-1條 2006年7月1日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國95年6月)#第三節 禁制標誌 第六十七條之一 行人及腳踏車專用標誌「遵22-1」，用以告示該段道路或騎樓以外之人行道專供行人及腳踏車通行，其他車輛不准進入，並以行人通行為爲優先。設於該路段或人行道起迄點顯明之處，中途得視需要增設之。其通行有其他規定者，應在附牌內說明之。 遵22-1 2008年4月15日施行 維基文库中相關的原始文獻： 道路交通標誌標線號誌設置規則 (民國97年4月)#第三節 禁制標誌 第六十七條之一 行人及自行車專用標誌「遵22-1」，用以告示該段道路或騎樓以外之人行道專供行人及自行車通行，其他車輛不准進入，並以行人通行為爲優先。設於該路段或人行道起迄點顯明之處，中途得視需要增設之。其通行有其他規定者，應在附牌內說明之。 遵22-1 腳踏車改稱自行車。 |
藥物化學/抗癌藥/Nitrogen mustard and Aziridine-mediated alkylation/Bendamustine 有一個類似purine取代，讓癌細胞以為那是它所要的營養物質 除了有此類藥物的交聯作用外，此藥另可以刺激p21與p53誘導之細胞凋亡，還有使細胞週期停留在S期 比其他DNA烷化劑低 |
Introducing Julia/Working with text files 从文本文件获取信息的标准方法是使用 open(), read() 和 close() 函数. 要从文件中读取文本，请首先获取文件的 handle： f = open("sherlock-holmes.txt") f 现在是 Julia 与磁盘上的文件的连接。完成文件处理后，应使用以下命令关闭连接： close(f) 通常，在 Julia 中处理文件的推荐方法是将任何文件处理函数包装在 do 代码块中： open("sherlock-holmes.txt") do file # do stuff with the open file end 当此代码块完成时，打开的文件将自动关闭。更多有关 do block 内容，见 Controlling the flow。 由于块中局部变量的范围，您可能希望保留一些已处理的信息： totaltime, totallines = open("sherlock-holmes.txt") do f linecounter = 0 timetaken = @elapsed for l in eachline(f) linecounter += 1 end (timetaken, linecounter) end julia> totaltime, totallines (0.004484679, 76803) 可以使用 read()一次性读取打开文件的全部内容： julia> s = read(f, String) 这会将文件的内容存储在 s 中： s = open("sherlock-holmes.txt") do file read(file, String) end 你可以使用 readlines() 来以数组的形式读取整个文件，并且每行都有一个元素，请执行以下操作： julia> f = open("sherlock-holmes.txt"); julia> lines = readlines(f) 76803-element Array{String,1}: "THE ADVENTURES OF SHERLOCK HOLMES by SIR ARTHUR CONAN DOYLE\r\n" "\r\n" " I. A Scandal in Bohemia\r\n" " II. The Red-headed League\r\n" ... "Holmes, rather to my disappointment, manifested no further\r\n" "interest in her when once she had ceased to be the centre of one\r\n" "of his problems, and she is now the head of a private school at\r\n" "Walsall, where I believe that she has met with considerable success.\r\n" julia> close(f) 现在，您可以对每行执行单步操作： counter = 1 for l in lines println("$counter $l") counter += 1 end 1 THE ADVENTURES OF SHERLOCK HOLMES by SIR ARTHUR CONAN DOYLE 2 3 I. A Scandal in Bohemia 4 II. The Red-headed League 5 III. A Case of Identity 6 IV. The Boscombe Valley Mystery ... 12638 interest in her when once she had ceased to be the centre of one 12639 of his problems, and she is now the head of a private school at 12640 Walsall, where I believe that she has met with considerable success. 有一种更好的方法可以做到这一点-参见下面的 enumerate() 。 您可能会发现 chomp() 函数很有用-它从字符串中删除后面的换行符。 The eachline() function turns a source into an iterator. This allows you to process a file a line at a time: open("sherlock-holmes.txt") do file for ln in eachline(file) println("$(length(ln)), $(ln)") end end 1, THE ADVENTURES OF SHERLOCK HOLMES by SIR ARTHUR CONAN DOYLE 2, 28, I. A Scandal in Bohemia 29, II. The Red-headed League 26, III. A Case of Identity 35, IV. The Boscombe Valley Mystery … 62, the island of Mauritius. As to Miss Violet Hunter, my friend 60, Holmes, rather to my disappointment, manifested no further 66, interest in her when once she had ceased to be the centre of one 65, of his problems, and she is now the head of a private school at 70, Walsall, where I believe that she has met with considerable success. 另一种方法是一直读到文件的末尾。您可能需要跟踪您所在的行： open("sherlock-holmes.txt") do f line = 1 while !eof(f) x = readline(f) println("$line $x") line += 1 end end 一种更好的方法是在可迭代对象上使用 enumerate() -您将额外得到一个的行号： open("sherlock-holmes.txt") do f for i in enumerate(eachline(f)) println(i[1], ": ", i[2]) end end 如果您有一个特定的函数要对文件调用，则可以使用以下语法： function shout(f::IOStream) return uppercase(read(f, String)) end julia> shoutversion = open(shout, "sherlock-holmes.txt"); julia> shoutversion[30237:30400] "ELEMENTARY PROBLEMS. LET HIM, ON MEETING A\nFELLOW-MORTAL, LEARN AT A GLANCE TO DISTINGUISH THE HISTORY OF THE\nMAN, AND THE TRADE OR PROFESSION TO WHICH HE BELONGS. " 这将打开该文件，对其运行 shout()函数，然后再次关闭该文件，并将处理后的内容分配给该变量。 You can use the DelimitedFiles.readdlm() function to read lines delimited with certain characters, such as data files, arrays stored as text files, and tables. If you use the DataFrames package, there's also a readtable() specifically designed to read data into a table. See also the package CSV.jl. These functions will be useful for working with filenames: cd(path) changes the current directory readdir(path) returns a lists of the contents of a named directory, or the current directory, abspath(path) adds the current directory's path to a filename to make an absolute pathname joinpath(str, str, ...) assembles a pathname from pieces isdir(path) tells you whether the path is a directory splitdir(path) - split a path into a tuple of the directory name and file name. splitdrive(path) - on Windows, split a path into the drive letter part and the path part. On Unix systems, the first component is always the empty string. splitext(path) - if the last component of a path contains a dot, split the path into everything before the dot and everything including and after the dot. Otherwise, return a tuple of the argument unmodified and the empty string. expanduser(path) - replace a tilde character at the start of a path with the current user's home directory. normpath(path) - normalize a path, removing "." and ".." entries. realpath(path) - canonicalize a path by expanding symbolic links and removing "." and ".." entries. homedir() - current user's home directory. dirname(path) - get the directory part of a path. basename(path)- get the file name part of a path. To work on a restricted selection of files in a directory, use filter() and an anonymous function to filter the file names and just keep the ones you want. (filter() is more of a fishing net or sieve, rather than a coffee filter, in that it catches what you want to keep.) for f in filter(x -> endswith(x, "jl"), readdir()) println(f) end Astro.jl calendar.jl constants.jl coordinates.jl ... pseudoscience.jl riseset.jl sidereal.jl sun.jl utils.jl vsop87d.jl If you want to match a group of files using a regular expression, then use occursin(). Let's look for files with ".jpg" or ".png" suffixes (remembering to escape the "."): for f in filter(x -> occursin(r"(?i)\.jpg|\.png", x), readdir()) println(f) end 034571172750.jpg 034571172750.png 51ZN2sCNfVL._SS400_.jpg 51bU7lucOJL._SL500_AA300_.jpg Voronoy.jpg kblue.png korange.png penrose.jpg r-home-id-r4.png wave.jpg To examine a file hierarchy, use walkdir(), which lets you work through a directory, and examine the files in each directory in turn. If you want information about a specific file, use stat("pathname"), and then use one of the fields to find out the information. Here's how to get all the information and the field names listed for a file "i": for n in fieldnames(typeof(stat("i"))) println(n, ": ", getfield(stat("i"),n)) end device: 16777219 inode: 2955324 mode: 16877 nlink: 943 uid: 502 gid: 20 rdev: 0 size: 32062 blksize: 4096 blocks: 0 mtime:1.409769933e9 ctime:1.409769933e9 You can access these fields via a 'stat' structure: julia> s = stat("Untitled1.ipynb") StatStruct(mode=100644, size=64424) julia> s.ctime 1.446649269e9 and you can also use some of them directly: julia> ctime("Untitled2.ipynb") 1.446649269e9 although not size: julia> s.size 64424 To work on specific files that meet conditions — all IPython files modified after a certain date, for example — you could use something like this: using Dates function output_file(path) println(stat(path).size, ": ", path) end for afile in filter!(f -> endswith(f, "ipynb") && (mtime(f) > Dates.datetime2unix(DateTime("2015-11-03T09:00"))), readdir()) output_file(realpath(afile)) end The cp(), mv(), rm(), and touch() functions have the same names and functions as their Unix shell counterparts. To convert filenames to pathnames, use abspath(). You can map this over a list of files in a directory: julia> map(abspath, readdir()) 67-element Array{String,1}: "/Users/me/.CFUserTextEncoding" "/Users/me/.DS_Store" "/Users/me/.Trash" "/Users/me/.Xauthority" "/Users/me/.ahbbighrc" "/Users/me/.apdisk" "/Users/me/.atom" ... To restrict the list to filenames that contain a particular substring, use an anonymous function inside filter() — something like this: julia> filter(x -> occursin("re", x), map(abspath, readdir())) 4-element Array{String,1}: "/Users/me/.DS_Store" "/Users/me/.gitignore" "/Users/me/.hgignore_global" "/Users/me/Pictures" ... To restrict the list to regular expression matches, try this: julia> filter(x -> occursin(r"recur.*\.jl", x), map(abspath, readdir())) 2-element Array{String,1}: "/Users/me/julia/recursive-directory-scan.jl" "/Users/me/julia/recursive-text.jl" To write to a text file, open it using the "w" flag and make sure that you have permission to create the file in the specified directory: open("/tmp/t.txt", "w") do f write(f, "A, B, C, D\n") end Here's how to write 20 lines of 4 random numbers between 1 and 10, separated by commas: function fourrandom() return rand(1:10,4) end open("/tmp/t.txt", "w") do f for i in 1:20 n1, n2, n3, n4 = fourrandom() write(f, "$n1, $n2, $n3, $n4 \n") end end A quicker alternative to this is to use the DelimitedFiles.writedlm() function, described next: using DelimitedFiles writedlm("/tmp/test.txt", rand(1:10, 20, 4), ", ") In the DelimitedFiles package are two convenient functions, writedlm() and readdlm(). These let you read/write an array or collection from/to a file. writedlm() writes the contents of an object to a text file, and readdlm() reads the data from a file into an array: julia> numbers = rand(5,5) 5x5 Array{Float64,2}: 0.913583 0.312291 0.0855798 0.0592331 0.371789 0.13747 0.422435 0.295057 0.736044 0.763928 0.360894 0.434373 0.870768 0.469624 0.268495 0.620462 0.456771 0.258094 0.646355 0.275826 0.497492 0.854383 0.171938 0.870345 0.783558 julia> writedlm("/tmp/test.txt", numbers) You can see the file using the shell (type a semicolon ";" to switch): <shell> cat "/tmp/test.txt" .9135833328830523 .3122905420350348 .08557977218948465 .0592330821115965 .3717889559226475 .13747015238054083 .42243494637594203 .29505701073304524 .7360443978397753 .7639280496847236 .36089432672073607 .43437288984307787 .870767989032692 .4696243851552686 .26849468736154325 .6204624598015906 .4567706404666232 .25809436255988105 .6463554854347682 .27582613759302377 .4974916625466639 .8543829989347014 .17193814498701587 .8703447748713236 .783557793485824 The elements are separated by tabs unless you specify another delimiter. Here, a colon is used to delimit the numbers: julia> writedlm("/tmp/test.txt", rand(1:6, 10, 10), ":") shell> cat "/tmp/test.txt" 3:3:3:2:3:2:6:2:3:5 3:1:2:1:5:6:6:1:3:6 5:2:3:1:4:4:4:3:4:1 3:2:1:3:3:1:1:1:5:6 4:2:4:4:4:2:3:5:1:6 6:6:4:1:6:6:3:4:5:4 2:1:3:1:4:1:5:4:6:6 4:4:6:4:6:6:1:4:2:3 1:4:4:1:1:1:5:6:5:6 2:4:4:3:6:6:1:1:5:5 To read in data from a text file, you can use readdlm(). julia> numbers = rand(5,5) 5x5 Array{Float64,2}: 0.862955 0.00827944 0.811526 0.854526 0.747977 0.661742 0.535057 0.186404 0.592903 0.758013 0.800939 0.949748 0.86552 0.113001 0.0849006 0.691113 0.0184901 0.170052 0.421047 0.374274 0.536154 0.48647 0.926233 0.683502 0.116988 julia> writedlm("/tmp/test.txt", numbers) julia> numbers = readdlm("/tmp/test.txt") 5x5 Array{Float64,2}: 0.862955 0.00827944 0.811526 0.854526 0.747977 0.661742 0.535057 0.186404 0.592903 0.758013 0.800939 0.949748 0.86552 0.113001 0.0849006 0.691113 0.0184901 0.170052 0.421047 0.374274 0.536154 0.48647 0.926233 0.683502 0.116988 There are also a number of Julia packages specifically designed for reading and writing data to files, including DataFrames.jl and CSV.jl. Look through the Julia package directory for these and more. |
三角形 不在同一直線上的三條線段首尾順次連接所組成的封閉圖形(小學-初中)；也叫三邊形。 對頂角相等，如圖一，∠2=∠4、∠6=∠8 同位角相等，∠α=∠β 內錯角相等，∠α=∠β 同側內角互補，如圖一，∠4+∠5=180°，∠3+∠6=180° 證明： ∵∠5+∠6=180°(平角)，∠4=∠6(內錯角) ∴∠4+∠5=180°。同理∠3+∠6=180° 三角形的兩鄰邊之和大於第三邊，三角形的兩鄰邊之差小於第三邊。 三角形三個內角之和等於180°。 三角形的外角等於與它不相鄰的兩個內角之和。 三角形的一個外角大於任何一個與它不相鄰的內角。 ∵△外角等於兩遠內角之和，全體大於部分，∴外角大於任一遠內角。 三角形的三外角之和是360°。 同底等高的兩個三角形面積相等。 ∵△面積=½底×高，∴同底等高的△面積皆相等。如圖 三角形的任意一條中線將這個三角形分為兩個面積相等的三角形。 定義：經過平移、旋轉或鏡射之後，能夠完全重合的兩個三角形。 性質： 對應角相等。 對應邊相等。 面積相等。 周長相等。 重合 角相等則角之兩邊重合。 線段等長，則對應之兩端點重合，線段也重合。 三角形共有三邊與三角，兩個三角形各有六個邊、角，取三組邊或角相等共得到八種情形，可歸納為六種情形(SSA和ASS等價，AAS和SAA等價)。其中四種情形全等： SAS RHS SSS ASA AAS 一種情形ASS，又包含： A為直角則兩三角形全等，稱為RHS A為鈍角則兩三角形全等，沒有特別的名稱 A為銳角則三角形有兩種不同的形狀，不會全等 一種情形AAA代表兩三角形相似。 相關圖庫 以下討論全等條件，並簡單證明之： 有兩邊及其夾角對應相等的兩個三角形全等。 已知△ΑΒΓ與△ΔΕΖ，∠Α=∠Δ、ΑΒ=ΔΕ、ΑΓ=ΔΖ 移動△ΔΕΖ使 Α點與Δ點重合，且∠Α與∠Δ兩邊重合(兩角相等使兩邊重合) 則Β點將與Ε點重合(線段等長兩端點重合) 同理Γ點將與Ζ點重合(線段等長兩端點重合) ∴兩△三頂點重合，兩△三邊重合，∴△ΑΒΓ≅△ΔΕΖ △ACB≅△BCA(SAS) 在兩個直角三角形中，斜邊及一直角邊對應相等，那麼這兩個三角形全等。 如圖依據畢氏定理：斜邊2−高2 = 另一高2 左、右兩個直角△，斜邊及一高對應相等，另一高亦會對應相等 兩個直角相等，依據SAS，左右兩個△全等。 三組對應邊分別相等的兩個三角形全等。 已知△ΑΒΓ與△ΔΕΖ，ΑΒ=ΔΕ、ΑΓ=ΔΖ、ΒΓ=ΕΖ 翻轉△ΑΒΓ並使ΒΓ與ΕΖ重合(兩線段相等)，且Α的位置移動到Η的位置。 △ΔΕΗ為等腰△(已知)，兩底角相等 △ΔΖΗ為等腰△(已知)，兩底角相等 ∠ΕΔΖ=∠ΕΗΖ，∴△ΕΔΖ≅△ΕΗΖ(SAS) 而△ΕΗΖ是△ΑΒΓ移動並鏡射而來的，∴△ΕΔΖ≅△ΒΑΓ 有兩角及其夾邊對應相等的兩個三角形全等。 已知△ΑΒΓ與△ΔΕΖ，∠Β=∠Ε、∠Γ=∠Ζ、ΒΓ=ΕΖ 假定△ΑΒΓ與△ΔΕΖ不全等，移動△ΔΕΖ使ΒΓ與ΕΖ重合(等長) ∵∠Β=∠Ε所以Δ必落在ΑΒ線上，Α點之外的另一點Η上。 連接ΗΓ，得到∠ΗΓΒ≠∠ΑΓΒ，與已知矛盾 △ΑΒΓ必須≅△ΔΕΖ，才不致於發生矛盾 有兩角及其一角的對邊對應相等的兩個三角形全等。 ∵△的三角相加必等於180°， ∴若是已確定兩個角之度數，第三角之度數也必確立。 此時三角形之相等部分為AASA，已知ASA滿足全等條件，故為AAS也為全等。 兩△全等 △只有兩種可能，並不全等。 定義：四邊形兩組對邊平行 性質： 兩組對邊平行且相等； 兩組對角大小相等； 相鄰的兩個角互補； 對角線互相平分； 對於平面上任何一點，都存在一條能將平行四邊形平分為兩個面積相等圖形、並穿過該點的線； 四邊邊長的平方和等於兩條對角線的平方和。 中點定理：三角形兩邊中點連線平行於第三邊，且等於第三邊長的一半。 截線定理：三角形過一邊中點對底邊作平行線，平分對邊。 定義 等邊三角形(正三角形)：三邊都相等的三角形。 等腰三角形：有兩邊相等的三角形。 直角三角形：有一個直角的三角形。 特殊直角三角形：對剖正方形，對剖正三角形 性質 等邊三角形的三邊相等，且三個角都為60°。 等腰三角形的「三線」（高、中線、角平分線）合一。 等腰三角形的兩個底角都相等。 直角三角形中，兩直角邊的平方和等於斜邊的平方。 在直角三角形中，如果有一個角為30°，那麼它所對的直角邊等於斜邊的一半。 直角三角形的兩個銳角互余。 在直角三角形中，斜邊上的中線等於斜邊的一半。 判定 直角三角形。 有一個角是直角的三角形是直角三角形。 兩銳角互余的三角形是直角三角形。 在一個三角形中，如果一邊上的中線等於這邊的一半，那麼這個三角形是直角三角形。 等腰三角形。 有兩邊相等的三角形是等腰三角形。 有兩個角相等的三角形是等腰三角形。 等邊三角形。 三條邊都相等的三角形是等邊三角形。 三個角都相等的三角形是等邊三角形。 有兩邊相等，且其中一角為60°的三角形是等邊三角形。 |
藥物化學/抗癌藥/Nitrogen mustard and Aziridine-mediated alkylation/Mechlorethamine 在美國與臺灣，因爲毒性太大已下市 在Nitrogen mustard類藥物中，唯一一個是脂肪鏈取代 見上一頁 如果不小心碰到皮膚，要立刻使用硫代硫酸鈉，並冰敷6-12小時 |
藥物化學/抗癌藥/Pyrimidine 拮抗劑：dTMP 合成抑制劑/Pralatrexate 三鍵炔基提高透過RFC1轉運入癌細胞內（12~14倍），以及FPGS-調節聚谷氨酸化（10倍） 降低RFC1基因表現量 共服葉酸和維他命 B12 以減少骨髓抑制和胃腸道（粘膜炎、口腔炎）副作用 |
食谱/摇疙瘩 摇疙瘩，是一种源自山东或北京的传统家常面食，原料为玉米面，亦可适量加些黄豆面。其特点為健康饮食，有玉米及豆香，口感滑爽。 具体做法如下： 用热水（摄氏80度左右）将玉米面及豆面混合，和匀后墩成方块； 将面块切成1cm左右的小方块儿，切时刀面多放些干玉米面以免粘刀； 切好的方块儿放入盆中，多撒些玉米面，然后水平方向摇盆，如面块粘连可再放玉米面，摇至面块儿不粘连为止； 以上就是摇好的“摇疙瘩”，可用煮面的汤料将其煮熟，按个人口味放入其他调料食用。 |
Introducing Julia/Strings and characters 字符串是由一个或多个字符组成的序列，通常用双引号括起来： "this is a string" 关于字符串，有两件重要的事情需要了解。 一个是，它们是不可变的。一旦它们被创建，你就不能改变它们。但是，从现有字符串的某些部分创建新字符串是很容易的。 第二点是，在使用两个特定字符时必须小心：双引号(")和美元符号($)。如果要在字符串中包含双引号字符，则必须在其前面加上反斜杠，否则字符串的其余部分将被解释为 Julia 代码，可能会产生有趣的结果。如果您想在字符串中包含一个美元符号($)，也应该以反斜杠开头，因为它用于字符串插值 string interpolation。 julia> demand = "You owe me \$50!" "You owe me \$50!" julia> println(demand) You owe me $50! julia> demandquote = "He said, \"You owe me \$50!\"" "He said, \"You owe me \$50!\"" 字符串也可以用三个双引号括起来。这很有用，因为您可以在字符串中使用普通的双引号，而不必在它们前面加反斜杠： julia> """this is "a" string""" "this is \"a\" string" 您还会遇到几种特殊类型的字符串，这些字符串由一个或多个字符组成，后面紧跟着开头的双引号： r" " 表示这是一个正则表达式 v" " 表示这是一个版本字符串 b" " 表示这是一个字节字面量 raw" " 表示这是一个 raw string 不允许插值 您通常希望在字符串中使用 Julia 表达式的结果。例如，假设您想说： "The value of x is n." 这 n 是 x 的当前值。任何 Julia 的表达式都可以插入到具有 $() 结构的字符串中： julia> x = 42 42 julia> "The value of x is $(x)." "The value of x is 42." 如果只是使用变量的名称，则不必使用括号： julia> "The value of x is $x." "The value of x is 42." 若要将 Julia 表达式的结果包含在字符串中，请先将表达式括在括号中，然后在其前面加上一个美元符号： julia> "The value of 2 + 2 is $(2 + 2)." "The value of 2 + 2 is 4." 若要从字符串中提取较小的字符串，请使用 getindex(s, range) 或 s[range] 语法。对于基本ASCII字符串，可以使用用于从数组中提取元素的相同技术： julia> s = String("a load of characters") "a load of characters" julia> s[1:end] "a load of characters" julia> s[3:6] "load" julia> s[3:end-6] "load of char" 您可以轻松地遍历字符串： for char in s print(char, "_") end a_ _l_o_a_d_ _o_f_ _c_h_a_r_a_c_t_e_r_s_ 注意，如果从字符串中提取单个元素，而不是长度为1的字符串(即具有相同的起始位置和结束位置)： julia> s[1:1] "a" julia> s[1] 'a' 第二个结果不是字符串，而是一个字符(在单引号内)。 并非所有字符串都是 ASCII。要访问 Unicode 字符串中的单个字符，不能总是使用简单索引，因为某些字符占用多个索引位置。不要仅仅因为一些 index 看起来会起作用就被愚弄了： julia> su = String("AéB𐅍CD") "AéB𐅍CD" julia> su[1] 'A' julia> su[2] 'é' julia> su[3] ERROR: UnicodeError: invalid character index in slow_utf8_next(::Array{UInt8,1}, ::UInt8, ::Int64) at ./strings/string.jl:67 in next at ./strings/string.jl:92 [inlined] in getindex(::String, ::Int64) at ./strings/basic.jl:70 使用 lastindex(str) 而不是 length(str) 来查找字符串的长度： julia> length(su) 6 julia> lastindex(su) 10 isascii() 函数用于测试字符串是 ASCII 还是包含 Unicode 字符： julia> isascii(su) false 在这个字符串中，“第二个”字符 (é) 有2个字节，“第四个”字符(𐅍)有4个字节。 对于处理这样的字符串，有一些有用的函数，包括 thisind(), nextind() 和 prevind(): for i in eachindex(su) println(thisind(su, i), " -> ", su[i]) end 1 -> A 2 -> é 4 -> B 5 -> 𐅍 9 -> C 10 -> D “第三个”字符 B 从字符串中的第四个元素开始。 此外，可以使用 eachindex 迭代器： for charindex in eachindex(su) @show su[charindex] end su[charindex] = 'A' su[charindex] = 'é' su[charindex] = 'B' su[charindex] = '𐅍' su[charindex] = 'C' su[charindex] = 'D' 您可以使用乘 (*) 运算符将字符串粘合在一起(通常称为串联的过程)： julia> "s" * "t" "st" 如果您使用过其他编程语言，您可能希望使用加法(+)运算符： julia> "s" + "t" LoadError: MethodError: `+` has no method matching +(::String, ::String) - 因此用 *. 如果你想把字符串‘乘’起来，你也可以把它们提升为一个幂： julia> "s" ^ 18 "ssssssssssssssssss" 你也可以用 string(): julia> string("s", "t") "st" 但是，如果您想在循环中进行大量连接，也许最好使用字符串缓冲区方法(见下文)。 若要拆分字符串，请使用 split()函数。给出这个简单的字符串： julia> s = "You know my methods, Watson." "You know my methods, Watson." 对 split() 函数的简单调用在空格处分割字符串，返回一个分为五段的数组： julia> split(s) 5-element Array{SubString{String},1}: "You" "know" "my" "methods," "Watson." 也可以指定要在以下位置拆分的 1个或多个字符的字符串： julia> split(s, "e") 2-element Array{SubString{String},1}: "You know my m" "thods, Watson." julia> split(s, " m")' 3-element Array{SubString{String},1}: "You know" "y" "ethods, Watson." 用于分割的字符串不会显示在最终结果中： julia> split(s, "hod") 2-element Array{SubString{String},1}: "You know my met" "s, Watson." 如果要将字符串拆分为单独的单字符串，请使用空字符串(“)，它将字符串拆分为两个字符： julia> split(s,"") 28-element Array{SubString{String},1}: "Y" "o" "u" " " "k" "n" "o" "w" " " "m" "y" " " "m" "e" "t" "h" "o" "d" "s" "," " " "W" "a" "t" "s" "o" "n" "." 也可以使用正则表达式来定义分割点来拆分字符串。使用特殊的正则表达式字符串结构 r" "。在其中，您可以使用具有特殊含义的正则表达式字符： julia> split(s, r"a|e|i|o|u") 8-element Array{SubString{String},1}: "Y" "" " kn" "w my m" "th" "ds, W" "ts" "n." 这里，r"a|e|i|o|u" 是一个正则表达式字符串，而且-如果您喜欢正则表达式的话-它与任何元音都匹配。因此，结果数组由每个元音处的字符串分割组成。注意结果中的空字符串-如果您不想要这些字符串，请在末尾添加一个 false 标志： julia> split(s, r"a|e|i|o|u", false) 7-element Array{SubString{String},1}: "Y" " kn" "w my m" "th" "ds, W" "ts" "n." 如果您想保留元音，而不是将它们用于拆分工作，则必须深入研究正则表达式文字字符串的世界。继续读下去。 可以使用 join() 连接以数组形式拆分字符串的元素： julia> join(split(s, r"a|e|i|o|u", false), "aiou") "Yaiou knaiouw my maiouthaiouds, Waioutsaioun." Julia中的许多函数允许您使用函数作为函数调用的一部分。匿名函数很有用，因为您可以进行具有内置智能选择的函数调用。例如，split() 允许您提供一个函数来代替分隔符字符。在下一个示例中，分隔符(奇怪地)指定为ASCII代码为8的倍数的任何大写字符： julia> split(join(Char.(65:90)), c -> Int(c) % 8 == 0) 4-element Array{SubString{String},1}: "ABCDEFG" "IJKLMNO" "QRSTUVW" "YZ" 在上面，我们从较大的字符串中提取较小的字符串： julia> s[1:1] "a" 但当我们从字符串中提取单个元素时： julia> s[1] 'a' 请注意单引号。在Julia中，这些字符用于标记字符对象，因此‘a’是字符对象，而“a”是长度为1的字符串。他们是不相等的。 您可以轻松地将字符对象转换为字符串： julia> string('s') * string('d') "sd" 或是 julia> string('s', 'd') "sd" 使用 \U 转义 输入32位 Unicode 字符很容易(大写表示32位)。小写转义序列 \u 可用于16位和8位字符： julia> ('\U1014d', '\u2640', '\u26') ('𐅍','♀','&') 对于字符串，\Uxxxxxxx和\uxxxx语法更为严格。 julia> "\U0001014d2\U000026402\u26402\U000000a52\u00a52\U000000352\u00352\x352" "𐅍2♀2♀2¥2¥2525252" 将整数转换为字符串也是 string() 函数的工作。关键字 base 用于指定转换的数字基数，可用于将十进制数字转换为二进制、八进制或十六进制字符串： julia> string(11, base=2) "1011" julia> string(11, base=8) "13" julia> string(11, base=16) "b" julia> string(11) "11" julia> a = BigInt(2)^200 1606938044258990275541962092341162602522202993782792835301376 julia> string(a) "1606938044258990275541962092341162602522202993782792835301376" julia> string(a, base=16) "1000000000000000000000000000000000000000000000000" 要将字符串转换为数字，请使用 parse()，如果希望字符串被解释为使用数字基数，则还可以指定数字基数(如二进制或十六进制)： julia> parse(Int, "100") 100 julia> parse(Int, "100", base=2) 4 julia> parse(Int, "100", base=16) 256 julia> parse(Float64, "100.32") 100.32 julia> parse(Complex{Float64}, "0 + 1im") 0.0 + 1.0im Int() 将字符转换为整数，Char()将整数转换为字符。 julia> Char(8253) '‽': Unicode U+203d (category Po: Punctuation, other) julia> Char(0x203d) # the Interrobang is Unicode U+203d in hexadecimal '‽': Unicode U+203d (category Po: Punctuation, other) julia> Int('‽') 8253 julia> string(Int('‽'), base=16) "203d" 要从单个字符串转换为代码号(如其 ASCII 或 UTF code number)，请尝试以下操作： julia> Int("S"[1]) 83 如果您深深依赖于 C风格的 printf() 函数，那么您能够使用 Julia 宏(通过在宏前面加上 @ 符号来调用它们)。宏在 Printf 包中提供，您需要先加载该程序包： julia> using Printf julia> @printf("pi = %0.20f", float(pi)) pi = 3.14159265358979311600 或者，也可以使用 sprintf() 宏创建另一个字符串，也可以在 Printf 包中找到： julia> @sprintf("pi = %0.20f", float(pi)) "pi = 3.14159265358979311600" 要将字符串读入数组，可以使用 IOBuffer() 函数。这在许多Julia函数(包括printf()中都是可用的。下面是一串数据(可能是从文件中读取的)： data="1 2 3 4 5 6 7 8 9 0 1 2" "1 2 3 4\n5 6 7 8\n9 0 1 2" 现在，您可以使用 readdlm()之类的函数“读取”这个字符串，即“使用分隔符读取(read with delimiters)”函数。这可以在DelimitedFiles包中找到。 julia> using DelimitedFiles julia> readdlm(IOBuffer(data)) 3x4 Array{Float64,2}: 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 0.0 1.0 2.0 您可以添加一个可选的类型限定： julia> readdlm(IOBuffer(data), Int) 3x4 Array{Int64,2}: 1 2 3 4 5 6 7 8 9 0 1 2 有时，您希望对字符串执行一些操作，以便使用数组做得更好。这里有一个例子。 julia> s = "/Users/me/Music/iTunes/iTunes Media/Mobile Applications"; 可以使用 collect() 将路径名字符串 分解 为字符对象数组，该方法将集合中的项或字符串分解为数组： julia> collect(s) 55-element Array{Char,1}: '/' 'U' 's' 'e' 'r' 's' '/' ... 类似地，您可以使用split()拆分字符串并计算结果： julia> split(s, "") 55-element Array{Char,1}: '/' 'U' 's' 'e' 'r' 's' '/' ... 要计算特定角色对象的出现次数，可以使用匿名函数： julia> count(c -> c == '/', collect(s)) 6 虽然在这里转换为数组是不必要和低效的。这里有一个更好的方法： julia> count(c -> c == '/', s) 6 如果您想知道字符串是否包含特定字符，请使用通用的 in()函数。 julia> s = "Elementary, my dear Watson"; julia> in('m', s) true 但是，接受两个字符串的 occursin() 函数更有用，因为您可以将子串与一个或多个字符一起使用。请注意，将搜索词放在第一位，然后是正在查找的字符串。occursin(needle, haystack)： julia> occursin("Wat", s) true julia> occursin("m", s) true julia> occursin("mi", s) false julia> occursin("me", s) true 您可以使用 findfirst(needle, haystack) 获取子字符串第一次出现的位置。第一个参数可以是单个字符、字符串或正则表达式： julia> s ="You know my methods, Watson."; julia> findfirst("meth", s) 13:16 julia> findfirst(r"[aeiou]", s) # first vowel 2 julia> findfirst(isequal('a'), s) # first occurrence of character 'a' 23 在每种情况下，结果都包含字符的索引(如果存在)。 replace()函数的作用是：返回一个新字符串，其中包含一个替换为其他字符的子字符串： julia> replace("Sherlock Holmes", "e" => "ee") "Sheerlock Holmees" You use the => operator to specify the pattern you're looking for, and its replacement. Usually the third argument is another string, as here. But you can also supply a function that processes the result: julia> replace("Sherlock Holmes", "e" => uppercase) "ShErlock HolmEs" where the function (here, the built-in uppercase() function) is applied to the matching substring. There's no replace! function, where the "!" indicates a function that changes its argument. That's because you can't change a string — they're immutable. Many functions in Julia allow you to supply functions as part of the function call, and you can make good use of anonymous functions for this. Here, for example, is how to use a function to provide random replacements in a replace() function. julia> t = "You can never foretell what any one man will do, but you can say with precision what an average number will be up to. Individuals vary, but percentages remain constant."; julia> replace(t, r"a|e|i|o|u" => (c) -> rand(Bool) ? "0" : "1") "Y00 c1n n0v0r f1r0t1ll wh1t 0ny 0n0 m0n w1ll d0, b0t y01 c1n s1y w0th pr1c1s10n wh0t 1n 1v0r0g0 n1mb0r w0ll b0 0p t1. Ind1v0d11ls v0ry, b0t p1rc0nt0g0s r0m01n c1nst0nt." julia> replace(t, r"a|e|i|o|u" => (c) -> rand(Bool) ? "0" : "1") "Y11 c0n...n1v0r f0r1t0ll wh1t 1ny 0n1 m0n w1ll d1, b1t y10 c1n s1y w1th pr0c1s01n wh0t 0n 0v1r0g0 n1mb1r w0ll b0 1p t1. Ind1v0d01ls v0ry, b1t p0rc1nt1g0s r0m01n c1nst0nt." You can use regular expressions to find matches for substrings. Some functions that accept a regular expression are: replace() changes occurrences of regular expressions match() returns the first match or nothing eachmatch() returns an iterator that lets you search through all matches split() splits a string at every match Use replace() to replace each consonant with an underscore: julia> replace("Elementary, my dear Watson!", r"[^aeiou]" => "_") "__e_e__a________ea___a__o__" and the following code replaces each vowel with the results of running a function on each match: julia> replace("Elementary, my dear Watson!", r"[aeiou]" => uppercase) "ElEmEntAry, my dEAr WAtsOn!" With replace() you can access the matches if you provide a special substitution string s"", where \1 refers to the first match, \2 to the second, and so on. With this regex operation, each lowercase letter preceded by a space is repeated three times: julia> replace("Elementary, my dear Watson!", r"(\s)([a-z])" => s"\1\2\2\2") "Elementary, mmmy dddear Watson!" For more regular expression fun, there are the -match- functions. Here I've loaded the complete text of "The Adventures of Sherlock Holmes" from a file into the string called text: julia> f = "/tmp/adventures-of-sherlock-holmes.txt" julia> text = read(f, String); To use the possibility of a match as a Boolean condition, suitable for use in an if statement for example, use occursin(). julia> occursin(r"Opium", text) false That's odd. We were expecting to find evidence of the great detective's peculiar pharmacological recreations. In fact, the word "opium" does appear in the text, but only in lower-case, hence this false result—regular expressions are case-sensitive. julia> occursin(r"(?i)Opium", text) true This is a case-insensitive search, set by the flag (?i)), and it returns true. You could check every line for the word using a simple loop: for l in split(text, "\n") occursin(r"opium", l) && println(l) end opium. The habit grew upon him, as I understand, from some he had, when the fit was on him, made use of an opium den in the brown opium smoke, and terraced with wooden berths, like the wrinkled, bent with age, an opium pipe dangling down from between very short time a decrepit figure had emerged from the opium den, opium-smoking to cocaine injections, and all the other little steps - for the house was none other than the opium den in which lives upon the second floor of the opium den, and who was learn to have been the lodger at the opium den, and to have been doing in the opium den, what happened to him when there, where is "Had he ever showed any signs of having taken opium?" room above the opium den when I looked out of my window and saw, For more useable output (in the REPL), add enumerate() and some highlighting: red = Base.text_colors[:red]; default = Base.text_colors[:default]; for (n, l) in enumerate(split(text, "\n")) occursin(r"opium", l) && println("$n $(replace(l, "opium" => "$(red)opium$(default)"))") end 5087 opium. The habit grew upon him, as I understand, from some 5140 he had, when the fit was on him, made use of an opium den in the 5173 brown opium smoke, and terraced with wooden berths, like the 5237 wrinkled, bent with age, an opium pipe dangling down from between 5273 very short time a decrepit figure had emerged from the opium den, 5280 opium-smoking to cocaine injections, and all the other little 5429 steps - for the house was none other than the opium den in which 5486 lives upon the second floor of the opium den, and who was 5510 learn to have been the lodger at the opium den, and to have been 5593 doing in the opium den, what happened to him when there, where is 5846 "Had he ever showed any signs of having taken opium?" 6129 room above the opium den when I looked out of my window and saw, There's an alternative syntax for adding regex modifiers, such as case-insensitive matches. Notice the "i" immediately following the regex string in the second example: julia> occursin(r"Opium", text) false julia> occursin(r"Opium"i, text) true With the eachmatch() function, you apply the regex to the string to produce an iterator. For example, to look for substrings in our text matching the letters "L", followed by some other characters, ending with "ed": julia> lmatch = eachmatch(r"L.*?ed", text) The result in lmatch is an iterable object containing all the matches, as RegexMatch objects: julia> collect(lmatch)[1:10] 10-element Array{RegexMatch,1}: RegexMatch("London, and proceed") RegexMatch("London is a pleasant thing indeed") RegexMatch("Looking for lodgings,\" I answered") RegexMatch("London he had received") RegexMatch("Lied") RegexMatch("Life,\" and it attempted") RegexMatch("Lauriston Gardens wore an ill-omened") RegexMatch("Let\" card had developed") RegexMatch("Lestrade, is here. I had relied") RegexMatch("Lestrade grabbed") We can step through the iterator and look at each match in turn. You can access a number of fields of a RegexMatch, to extract information about the match. These include captures, match, offset, offsets, and regex. For example, the match field contains the matched substring: for i in lmatch println(i.match) end London - quite so! Your Majesty, as I understand, became entangled Lodge. As it pulled Lord, Mr. Wilson, that I was a red League of the Red League was founded London when he was young, and he wanted LSON" in white letters, upon a corner house, announced League, and the copying of the 'Encyclopaed Leadenhall Street Post Office, to be left till called Let the whole incident be a sealed Lestrade, being rather puzzled Lestrade would have noted ... Lestrade," drawled Lestrade looked Lord St. Simon has not already arrived Lord St. Simon sank into a chair and passed Lord St. Simon had by no means relaxed Lordship. "I may be forced London. What could have happened London, and I had placed Other fields include captures, the captured substrings as an array of strings, offset, the offset into the string at which the whole match begins, and offsets, the offsets of the captured substrings. To get an array of matching strings, use something like this: julia> collect(m.match for m in eachmatch(r"L.*?ed", text)) 58-element Array{SubString{String},1}: "London - quite so! Your Majesty, as I understand, became entangled" "Lodge. As it pulled" "Lord, Mr. Wilson, that I was a red" "League of the Red" "League was founded" "London when he was young, and he wanted" "Leadenhall Street Post Office, to be left till called" "Let the whole incident be a sealed" "Lestrade, being rather puzzled" "Lestrade would have noted" "Lestrade looked" "Lestrade laughed" "Lestrade shrugged" "Lestrade called" ... "Lord St. Simon shrugged" "Lady St. Simon was decoyed" "Lestrade,\" drawled" "Lestrade looked" "Lord St. Simon has not already arrived" "Lord St. Simon sank into a chair and passed" "Lord St. Simon had by no means relaxed" "Lordship. \"I may be forced" "London. What could have happened" "London, and I had placed" The basic match() function looks for the first match for your regex. Use the match field to extract the information from the RegexMatch object: julia> match(r"She.*",text).match "Sherlock Holmes she is always THE woman. I have seldom heard\r" A more streamlined way of obtaining matching lines from a file is this: julia> f = "adventures of sherlock holmes.txt" julia> filter(s -> occursin(r"(?i)Opium", s), map(chomp, readlines(open(f)))) 12-element Array{SubString{String},1}: "opium. The habit grew upon him, as I understand, from some" "he had, when the fit was on him, made use of an opium den in the" "brown opium smoke, and terraced with wooden berths, like the" "wrinkled, bent with age, an opium pipe dangling down from between" "very short time a decrepit figure had emerged from the opium den," "opium-smoking to cocaine injections, and all the other little" "steps - for the house was none other than the opium den in which" "lives upon the second floor of the opium den, and who was" "learn to have been the lodger at the opium den, and to have been" "doing in the opium den, what happened to him when there, where is" "\"Had he ever showed any signs of having taken opium?\"" "room above the opium den when I looked out of my window and saw," Sometimes you want to make a regular expression from within your code. You can do this by making a Regex object. Here is one way you could count the number of vowels in the text: f = open("sherlock-holmes.txt") text = read(f, String) for vowel in "aeiou" r = Regex(string(vowel)) l = [m.match for m = eachmatch(r, thetext)] println("there are $(length(l)) letter \"$vowel\"s in the text.") end there are 219626 letter "a"s in the text. there are 337212 letter "e"s in the text. there are 167552 letter "i"s in the text. there are 212834 letter "o"s in the text. there are 82924 letter "u"s in the text. There are lots of functions for testing and changing strings: length(str) length of string sizeof(str) length/size startswith(strA, strB) does strA start with strB? endswith(strA, strB) does strA end with strB? occursin(strA, strB) does strA occur in strB? all(isletter, str) is str entirely letters? all(isnumeric, str) is str entirely number characters? isascii(str) is str ASCII? all(iscntrl, str) is str entirely control characters? all(isdigit, str) is str 0-9? all(ispunct, str) does str consist of punctuation? all(isspace, str) is str whitespace characters? all(isuppercase, str) is str uppercase? all(islowercase, str) is str entirely lowercase? all(isxdigit, str) is str entirely hexadecimal digits? uppercase(str) return a copy of str converted to uppercase lowercase(str) return a copy of str converted to lowercase titlecase(str) return copy of str with the first character of each word converted to uppercase uppercasefirst(str) return copy of str with first character converted to uppercase lowercasefirst(str) return copy of str with first character converted to lowercase chop(str) return a copy with the last character removed chomp(str) return a copy with the last character removed only if it's a newline To write to a string, you can use a Julia stream. The sprint() (String Print) function lets you use a function as the first argument, and uses the function and the rest of the arguments to send information to a stream, returning the result as a string. For example, consider the following function, f. The body of the function maps an anonymous 'print' function over the arguments, enclosing them with angle brackets. When used by sprint, the function f processes the remaining arguments and sends them to the stream. function f(io::IO, args...) map((a) -> print(io,"<",a, ">"), args) end f (generic function with 1 method) julia> sprint(f, "fred", "jim", "bill", "fred blogs") "<fred><jim><bill><fred blogs>" Functions like println() can take an IOBuffer or stream as their first argument. This lets you print to streams instead of printing to the standard output device: julia> iobuffer = IOBuffer() IOBuffer(data=Uint8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=Inf, ptr=1, mark=-1) julia> for i in 1:100 println(iobuffer, string(i)) end After this, the in-memory stream called iobuffer is full of numbers and newlines, even though nothing was printed on the terminal. To copy the contents of iobuffer from the stream to a string or array, you can use take!(): julia> String(take!(iobuffer)) "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14 ... \n98\n99\n100\n" |
高中语文/课改/选择性必修上册 标有“*”的是选读课文；“/”符号后的名字是作者。 中国人民站起来了/毛泽东 长征胜利万岁/杨成武 *大战中的插曲/聂荣臻 别了，“不列颠尼亚”/周婷 杨兴 *县委书记的榜样——焦裕禄/穆青 冯健 周原 在民族复兴的历史丰碑上——2020中国抗疫记/钟华论 《论语》十二章 大学之道/《礼记》 *人皆有不忍人之心/《孟子》 《老子》四章 *五石之瓠/《庄子》 *兼爱/《墨子》 大卫·科波菲尔（节选）/狄更斯 复活（节选）/列夫·托尔斯泰 *老人与海（节选）/海明威 *百年孤独（节选）/加西亚·马尔克斯 学习活动 一 发现潜藏的逻辑谬误 二 运用有效的推理形式 三 采用合理的论证方法 无衣/《诗经·秦风》 春江花月夜/张若虚 将进酒/李白 江城子·乙卯正月二十日夜记梦/苏轼 出于版权原因没有收入每单元引言，下同。 本文与上一行所示课文编入同一课中。 |
藥物化學/抗癌藥/Pyrimidine 拮抗劑：dTMP 合成抑制劑/Pemetrexed 降低FPGS活性 透過γ-谷氨酸水解酶加強水解聚谷氨酸化pemetrexed 胸嘧啶合成酶基因表現量上升 共服葉酸和維他命 B12 以減少骨髓抑制和胃腸道（粘膜炎、口腔炎）副作用 共服皮質類固醇，以降低藥物誘導皮疹 |
食譜/滿漢全席 备好白豆腐、青椒、红椒；盐、味精、色拉油、高汤、水菱粉等调料。 豆腐切碎成花状，加入辣椒 加调味料，蒸十分钟即可。 备好猪廋肉，生姜，大蒜；精盐；鸡精，红苕粉等食料。廋肉切小片，大蒜生姜切碎，加入红苕粉，加适量水搅匀；捏成汤圆大小一个个圆子。加调味料，水烧开煮15---20分钟，待圆子浮于汤面，片刻即可。 |
藥物化學/抗癌藥/Pyrimidine 拮抗劑：dTMP 合成抑制劑/Methotrexate 與 7,8-DHF 比較，C4變成 NH2取代，C7,8 變成雙鍵 抑制DHFR酵素、胸嘧啶合成酶和甘氨酸醯胺核糖核苷酸甲醯轉移酶 藥物結構尾端單谷氨酸部分會活化還原型葉酸攜帶體（RFC1)轉運至細胞內 增加DHFR酵素基因表現量 破壞RFC1 活化細胞排出 暫緩細胞內聚穀氨酸作用 如服用劑量太高，methotrexate 和其 7-羥基代謝物（水溶解度降低 3~5 倍）會沈澱在腎小管，造成 crystalluria；如這事不幸發生，立刻服用 5-formyltetrahydrofolate （leucovorin），leucovorin 也常用於服用高劑量治療後預防毒性發生用 |
Introducing Julia/Dictionaries and sets 到目前为止，介绍的许多函数都是在数组(和元组)上工作的。数组只是集合的一种类型，Julia 还有其他的集合类型。 简单的 查找表 是组织多种类型数据的有用方法：给定单个信息 (例如称为 键 的数字、字符串或符号)，对应的数据 值 是什么？为此，Julia提供了 Dictionary 对象，简称为 Dict。它是一个“关联集合”，因为它将键与值相关联。 可以使用以下语法创建简单字典： julia> dict = Dict("a" => 1, "b" => 2, "c" => 3) Dict{String,Int64} with 3 entries: "c" => 3 "b" => 2 "a" => 1 dict 现在是字典了。键是“a”、“b”和“c”，对应的值是1、2和3。操作符 => 称为 Pair 函数。在字典中，键总是唯一的 - 不能有两个同名的键。 如果预先知道键和值的类型，则可以(而且很可能应该) 在 Dict 关键字后用大括号指定它们： julia> dict = Dict{String,Integer}("a"=>1, "b" => 2) Dict{String,Integer} with 2 entries: "b" => 2 "a" => 1 还可以使用 推导 complementsions 语法创建词典: julia> dict = Dict(string(i) => sind(i) for i = 0:5:360) Dict{String,Float64} with 73 entries: "320" => -0.642788 "65" => 0.906308 "155" => 0.422618 ⋮ => ⋮ 使用以下语法创建类型化的空字典： julia> dict = Dict{String,Int64}() Dict{String,Int64} with 0 entries or you can omit the types, and get an untyped dictionary: julia> dict = Dict() Dict{Any,Any} with 0 entries It's sometimes useful to create dictionary entries using a for loop: files = ["a.txt", "b.txt", "c.txt"] fvars = Dict() for (n, f) in enumerate(files) fvars["x_$(n)"] = f end This is one way you could create a set of 'variables' stored in a dictionary: julia> fvars Dict{Any,Any} with 3 entries: "x_1" => "a.txt" "x_2" => "b.txt" "x_3" => "c.txt" To get a value, if you have the key: julia> dict = Dict("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5) julia> dict["a"] 1 if the keys are strings. Or, if the keys are symbols: julia> symdict = Dict(:x => 1, :y => 3, :z => 6) Dict{Symbol,Int64} with 3 entries: :z => 6 :x => 1 :y => 3 julia> symdict[:x] 1 Or if the keys are integers: julia> intdict = Dict(1 => "one", 2 => "two", 3 => "three") Dict{Int64,String} with 3 entries: 2 => "two" 3 => "three" 1 => "one" julia> intdict[2] "two" You can instead use the get() function, and provide a fail-safe default value if there's no value for that particular key: julia> dict = Dict("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5) julia> get(dict, "a", 0) 1 julia> get(dict, "Z", 0) 0 If you don't use a default value as a safety precaution like this, you'll get an error if there's no key: julia> get(dict, "Z") ERROR: MethodError: no method matching get(::Dict{String,Int64}, ::String) Closest candidates are: get(::Dict{K,V}, ::Any, ::Any) where {K, V} at dict.jl:508 get(::Base.EnvDict, ::AbstractString, ::Any) at env.jl:77 If you don't want get() to provide a default value, use a try...catch block: try dict["Z"] catch error if isa(error, KeyError) println("sorry, I couldn't find anything") end end sorry, I couldn't find anything To change a value assigned to an existing key (or assign a value to a hitherto unseen key): julia> dict["a"] = 10 10 Keys must be unique for a dictionary. There's always only one key called a in this dictionary, so when you assign a value to a key that already exists, you're not creating a new one, just modifying an existing one. To see if the dictionary contains a key, use haskey(): julia> haskey(dict, "Z") false To check for the existence of a key/value pair: julia> in(("b" => 2), dict) true To add a new key and value to a dictionary, use this: julia> dict["d"] = 4 4 You can delete a key from the dictionary, using delete!(): julia> delete!(dict, "d") Dict{String,Int64} with 4 entries: "c" => 3 "e" => 5 "b" => 2 "a" => 1 You'll notice that the dictionary doesn't seem to be sorted in any way — at least, the keys are in no particular order. This is due to the way they're stored, and you can't sort them in place. (But see Sorting, below.) To get all keys, use the keys() function: julia> dict = Dict("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5); julia> keys(dict) Base.KeySet for a Dict{String,Int64} with 5 entries. Keys: "c" "e" "b" "a" "d" The result is an iterator that has just one job: to iterate through a dictionary key by key: julia> collect(keys(dict)) 5-element Array{String,1}: "c" "e" "b" "a" "d" julia> [uppercase(key) for key in keys(dict)] 5-element Array{Any,1}: "C" "E" "B" "A" "D" This uses the list comprehension form ([ new-element for loop-variable in iterator ]) and each new element is collected into an array. An alternative would be: julia> map(uppercase, collect(keys(dict))) 5-element Array{String,1}: "C" "E" "B" "A" "D" To retrieve all the values, use the values() function: julia> values(dict) Base.ValueIterator for a Dict{String,Int64} with 5 entries. Values: 3 5 2 1 4 If you want to go through a dictionary and process each key/value, you can make use the fact that dictionaries themselves are iterable objects: julia> for kv in dict println(kv) end "c"=>3 "e"=>5 "b"=>2 "a"=>1 "d"=>4 where kv is a tuple containing each key/value pair in turn. Or you could do: julia> for k in keys(dict) println(k, " ==> ", dict[k]) end c ==> 3 e ==> 5 b ==> 2 a ==> 1 d ==> 4 Even better, you can use a key/value tuple to simplify the iteration even more: julia> for (key, value) in dict println(key, " ==> ", value) end c ==> 3 e ==> 5 b ==> 2 a ==> 1 d ==> 4 Here's another example: for tuple in Dict("1"=>"Hydrogen", "2"=>"Helium", "3"=>"Lithium") println("Element $(tuple[1]) is $(tuple[2])") end Element 1 is Hydrogen Element 2 is Helium Element 3 is Lithium (Notice the string interpolation operator, $. This allows you to use a variable's name in a string and get the variable's value when the string is printed. You can include any Julia expression in a string using $().) Because dictionaries don't store the keys in any particular order, you might want to output the dictionary to a sorted array to obtain the items in order: julia> dict = Dict("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6) Dict{String,Int64} with 6 entries: "f" => 6 "c" => 3 "e" => 5 "b" => 2 "a" => 1 "d" => 4 julia> for key in sort(collect(keys(dict))) println("$key => $(dict[key])") end a => 1 b => 2 c => 3 d => 4 e => 5 f => 6 If you really need to have a dictionary that remains sorted all the time, you can use the SortedDict data type from the DataStructures.jl package (after having installed it). julia> import DataStructures julia> dict = DataStructures.SortedDict("b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6) DataStructures.SortedDict{String,Int64,Base.Order.ForwardOrdering} with 5 entries: "b" => 2 "c" => 3 "d" => 4 "e" => 5 "f" => 6 julia> dict["a"] = 1 1 julia> dict DataStructures.SortedDict{String,Int64,Base.Order.ForwardOrdering} with 6 entries: "a" => 1 "b" => 2 "c" => 3 "d" => 4 "e" => 5 "f" => 6 A simple application of a dictionary is to count how many times each word appears in a piece of text. Each word is a key, and the value of the key is the number of times that word appears in the text. Let's count the words in the Sherlock Holmes stories. I've downloaded the text from the excellent Project Gutenberg and stored them in a file "sherlock-holmes-canon.txt". To create a list of words from the loaded text in canon, we'll split the text using a regular expression, and convert every word to lowercase. (There are probably faster methods.) julia> f = open("sherlock-holmes-canon.txt") julia> wordlist = String[] julia> for line in eachline(f) words = split(line, r"\W") map(w -> push!(wordlist, lowercase(w)), words) end julia> filter!(!isempty, wordlist) julia> close(f) wordlist is now an array of nearly 700,000 words: julia> wordlist[1:20] 20-element Array{String,1}: "THE" "COMPLETE" "SHERLOCK" "HOLMES" "Arthur" "Conan" "Doyle" "Table" "of" "contents" "A" "Study" "In" "Scarlet" "The" "Sign" "of" "the" "Four" "The" To store the words and the word counts, we'll create a dictionary: julia> wordcounts = Dict{String,Int64}() Dict{String,Int64} with 0 entries To build the dictionary, loop through the list of words, and use get() to look up the current tally, if any. If the word has already been seen, the count can be increased. If the word hasn't been seen before, the fall-back third argument of get() ensures that the absence doesn't cause an error, and 1 is stored instead. for word in wordlist wordcounts[word]=get(wordcounts, word, 0) + 1 end Now you can look up words in the wordcounts dictionary and find out how many times they appear: julia> wordcounts["watson"] 1040 julia> wordcounts["holmes"] 3057 julia> wordcounts["sherlock"] 415 julia> wordcounts["lestrade"] 244 Dictionaries aren't sorted, but you can use the collect() and keys() functions on the dictionary to collect the keys and then sort them. In a loop you can work through the dictionary in alphabetical order: for i in sort(collect(keys(wordcounts))) println("$i, $(wordcounts[i])") end 000, 5 1, 8 10, 7 100, 4 1000, 9 104, 1 109, 1 10s, 2 10th, 1 11, 9 1100, 1 117, 2 117th, 2 11th, 1 12, 2 120, 2 126b, 3 ⋮ zamba, 2 zeal, 5 zealand, 3 zealous, 3 zenith, 1 zeppelin, 1 zero, 2 zest, 3 zig, 1 zigzag, 3 zigzagged, 1 zinc, 3 zion, 2 zoo, 1 zoology, 2 zu, 1 zum, 2 â, 41 ã, 4 But how do you find out the most common words? One way is to use collect() to convert the dictionary to an array of tuples, and then to sort the array by looking at the last value of each tuple: julia> sort(collect(wordcounts), by = tuple -> last(tuple), rev=true) 19171-element Array{Pair{String,Int64},1}: ("the",36244) ("and",17593) ("i",17357) ("of",16779) ("to",16041) ("a",15848) ("that",11506) ⋮ ("enrage",1) ("smuggled",1) ("lounges",1) ("devotes",1) ("reverberated",1) ("munitions",1) ("graybeard",1) To see only the top 20 words: julia> sort(collect(wordcounts), by = tuple -> last(tuple), rev=true)[1:20] 20-element Array{Pair{String,Int64},1}: ("the",36244) ("and",17593) ("i",17357) ("of",16779) ("to",16041) ("a",15848) ("that",11506) ("it",11101) ("in",10766) ("he",10366) ("was",9844) ("you",9688) ("his",7836) ("is",6650) ("had",6057) ("have",5532) ("my",5293) ("with",5256) ("as",4755) ("for",4713) In a similar way, you can use the filter() function to find, for example, all words that start with "k" and occur less than four times: julia> filter(tuple -> startswith(first(tuple), "k") && last(tuple) < 4, collect(wordcounts)) 73-element Array{Pair{String,Int64},1}: ("keg",1) ("klux",2) ("knifing",1) ("keening",1) ("kansas",3) ⋮ ("kaiser",1) ("kidnap",2) ("keswick",1) ("kings",2) ("kratides",3) ("ken",2) ("kindliness",2) ("klan",2) ("keepsake",1) ("kindled",2) ("kit",2) ("kicking",1) ("kramm",2) ("knob",1) A dictionary can hold many different types of values. Here for example is a dictionary where the keys are strings and the values are arrays of arrays of points (assuming that the Point type has been defined already). For example, this could be used to store graphical shapes describing the letters of the alphabet (some of which have two or more loops): julia> p = Dict{String, Array{Array}}() Dict{String,Array{Array{T,N},N}} julia> p["a"] = Array[[Point(0,0), Point(1,1)], [Point(34, 23), Point(5,6)]] 2-element Array{Array{T,N},1}: [Point(0.0,0.0), Point(1.0,1.0)] [Point(34.0,23.0), Point(5.0,6.0)] julia> push!(p["a"], [Point(34.0,23.0), Point(5.0,6.0)]) 3-element Array{Array{T,N},1}: [Point(0.0,0.0), Point(1.0,1.0)] [Point(34.0,23.0), Point(5.0,6.0)] [Point(34.0,23.0), Point(5.0,6.0)] Or create a dictionary with some already-known values: julia> d = Dict("shape1" => Array [ [ Point(0,0), Point(-20,57)], [Point(34, -23), Point(-10,12) ] ]) Dict{String,Array{Array{T,N},1}} with 1 entry: "shape1" => Array [ [ Point(0.0,0.0), Point(-20.0,57.0)], [Point(34.0,-23.0), Point(-10.0,12.0) ] ] Add another array to the first one: julia> push!(d["shape1"], [Point(-124.0, 37.0), Point(25.0,32.0)]) 3-element Array{Array{T,N},1}: [Point(0.0,0.0), Point(-20.0,57.0)] [Point(34.0,-23.0), Point(-10.0,12.0)] [Point(-124.0,37.0), Point(25.0,32.0)] Set 是元素的集合，就像是一个没有重复元素的字典或数组。 Set 和其他类型的集合有两个不同之处： Set 中每个元素只能有一份 元素的顺序不重要 （而数组对同一个元素可以有多份，并且是有序的） 你可以通过使用 Set 构造函数创建一个空的集合： julia> colors = Set() Set{Any}({}) 和 Julia 的其他地方一样，你可以指定类型： julia> primes = Set{Int64}() Set(Int64)[] 可以一次操作创建和填充 Set： julia> colors = Set{String}(["red","green","blue","yellow"]) Set(String["yellow","blue","green","red"]) 或者你可以让 Julia “猜出类型”： julia> colors = Set(["red","green","blue","yellow"]) Set{String}({"yellow","blue","green","red"}) 相当一部分处理数组的函数也可以用于处理集合。例如，将元素添加到集合 类似于 将元素添加到数组。您可以使用 push!() ： julia> push!(colors, "black") Set{String}({"yellow","blue","green","black","red"}) But you can't use pushfirst!(), because that works only for things that have a concept of "first", like arrays. What happens if you try to add something to the set that's already there? Absolutely nothing. You don't get a copy added, because it's a set, not an array, and sets don't store repeated elements. To see if something is in the set, you can use in(): julia> in("green", colors) true There are some standard operations you can do with sets, namely find their union, intersection, and difference, with the functions, union(), intersect(), and setdiff(): julia> rainbow = Set(["red","orange","yellow","green","blue","indigo","violet"]) Set(String["indigo","yellow","orange","blue","violet","green","red"]) The union of two sets is the set of everything that is in one or the other sets. The result is another set – so you can't have two "yellow"s here, even though we've got a "yellow" in each set: julia> union(colors, rainbow) Set(String["indigo","yellow","orange","blue","violet","green","black","red"]) The intersection of two sets is the set that contains every element that belongs to both sets: julia> intersect(colors, rainbow) Set(String["yellow","blue","green","red"]) The difference between two sets is the set of elements that are in the first set, but not in the second. This time, the order in which you supply the sets matters. The setdiff() function finds the elements that are in the first set, colors, but not in the second set, rainbow: julia> setdiff(colors, rainbow) Set(String["black"]) 处理数组和集合的函数有时也适用于字典和其他集合。例如，某些 集合的操作可应用于词典，而不仅仅是 Set 和 数组： julia> d1 = Dict(1=>"a", 2 => "b") Dict{Int64,String} with 2 entries: 2 => "b" 1 => "a" julia> d2 = Dict(2 => "b", 3 =>"c", 4 => "d") Dict{Int64,String} with 3 entries: 4 => "d" 2 => "b" 3 => "c" julia> union(d1, d2) 4-element Array{Pair{Int64,String},1}: 2=>"b" 1=>"a" 4=>"d" 3=>"c" julia> intersect(d1, d2) 1-element Array{Pair{Int64,String},1}: 2=>"b" julia> setdiff(d1, d2) 1-element Array{Pair{Int64,String},1}: 1=>"a" 请注意，结果是以对数组的形式返回的，而不是以字典的形式返回的。 filter(), map() 和 collect() 等函数 (我们已经看到它们用于数组) 也适用于字典： julia> filter((k, v) -> k == 1, d1) Dict{Int64,String} with 1 entry: 1 => "a" 有一个 merge() 函数，它可以合并两个字典： julia> merge(d1, d2) Dict{Int64,String} with 4 entries: 4 => "d" 2 => "b" 3 => "c" 1 => "a" findmin()函数可以在字典中找到最小值，然后返回值及其键。 julia> d1 = Dict(:a => 1, :b => 2, :c => 0) Dict{Symbol,Int64} with 3 entries: :a => 1 :b => 2 :c => 0 julia> findmin(d1) (0, :c) |
测度论初步/格式指南 本指南是为維基書架>数学书架>测度论初步而编写的。 对格式的控制请参阅维基百科的Help:编辑页面。 本书使用了图片、声音等多媒体形式，您可以使用维基共享资源中的元素，例如Crystal_Clear中的图标。 模板可以统一全书的风格，也便于维护，关于模板的更多内容请参阅w:Help:模板入门。 本书使用的模板如下，您可以点击模板名称进入相应页面编辑。 |
藥物化學/抗癌藥/Pyrimidine 拮抗劑：dTMP 合成抑制劑/Capecitabine 第一步驟，形成活性代謝產物 第二步驟，接著與 Fluorouracil 第二步驟相同 在癌細胞中，被活化的藥物量比周圍正常組織高 3.5 倍，因此副作用的發生率較小（與 Fluorouracil 比起來） 會抑制 CYP2C9 |
WebQuest網路探究/網路探究在臺灣的導入與運用 台灣於近年來開始興起網路探究(WebQuest)的發展，本文檢視近三年內博碩士論文系統當中，針對網路探究進行應用的主題作背景回顧，期能對於文獻座落的分佈提供整理探索，以供後續研究者進行研究延伸及成效探討。 網路探究(WebQuest)係一種基於網路環境的探究活動，由學習者在適當的教學場域中，主動進行以任務為導向的學習行為(March, 2003)。因可透過網路平台而取得豐沛的學術資源，佐以各國互聯網(Internet)的蓬勃發展，逐漸成為教師在教學設計上，得以應用的良好輔助教學界面(Dodge, 2000)。在亞洲各國的發展，目前以中國香港的中文大學教育學院為首，起源於2004年5月，邀請了網路探究的創建人杜博禮教授前往香港進行座談交流，繼而開啟了網路探究等諸多研究的推展。 大陸方面，杜博禮教授近期曾於2010年8月造訪內地並舉行專題講演；台灣方面，最近則以2009年6月時，於台北所舉行的華人網路探究大賽(webquest competition)中，國立台北教育大學邀請杜博禮教授，針對網絡2.0 (Web 2.0)所進行的專題演講。 而「網路探究」一詞，在台灣開始逐漸的被廣泛使用於研究文獻中，約莫從2001年末開始（黃勝發，2002）。於資訊教學相關書籍中，出現專文介紹「網路探究」的獨立篇章，始於沈中偉所著作之「科技與學習」一書（梁雲霞，2008）。在2002年至2007年間，台灣的期刊論文與碩士論文，在主題的內容及取向，呈現不同的特性，前者多為分享教學經驗、介紹教學模式及方法，或是用以澄清教學理念；後者則多屬實證研究，多半應用於教學設計以及成效驗證（梁雲霞、鄭婷尹，2008）。其後，便較少以台灣本地對於網絡探究之使用面向的後續探討，因此將於往後章節，簡述台灣近三年來所進行關於網絡探究之研究型態。 「台灣博碩士論文系統」與「台灣期刊論文索引系統」，係由教育部官方所直轄的國家圖書館所建構，因此除了按照教育部的論文檢索規範(國家圖書館，2010)之外，所收錄的期刊暨論文的格式與內容較為嚴謹，且符合電子期刊聯合目錄(財團法人國家實驗研究院，2011)的制定模式，因此作為整理分析WebQuest的研究面向較為適宜；由於碩士論文均施以實證研究導向的研究方法，編目較詳細，故此處針對碩士論文進行整理歸納。檢索策略為以「WebQuest(網路探究)」進行「論文名稱」、「關鍵詞」暨「摘要」所統計加總之結果。 近年的研究者背景仍以一般生居多，僅五篇為在職專班生所著；而所有論文作者中，身負教職者多達19人以上，因此可推估由於研究便利取樣，使教學者多願意將WebQuest融入自身教學中進行施測。 包括國小基礎科目（國語文、社會、自然科）以及國中進階科目，另外也涵蓋到智育、群育及美育的部分，唯群育及德育，因為受限於評測結果不易呈現，使得這類型的研究闕如。另值得關注之處，乃是成人補救教育及企業教育訓練的學習模式，近年首度出現於碩士論文中，並有兩篇以成人教育為主的探討。非傳統學科的部分，亦新增了創造力教育等新興研究，讓多元能力的評核逐漸廣為教育者所接受（于文正、黃雲龍、林家君，2008）。 多達24篇的對象係以國中小學生為主，高中職僅1篇，並有2篇成人教育與1篇教師的施行驗證。而原住民的補救教學則是近年來首次出現，囿於教育落差及資訊化的程度不一，致使原住民區域的教學及資訊研究受到侷限（黃學仁，2006）。 共計準實驗研究14篇，行動研究12篇，2項個案研究與1篇調查研究。可推估在數量上仍以實際教學的施測為主，並有相當多元的研究方法併用其中，並有別與以往的單一實驗設計，近年的研究方法漸趨複合，以及越來越多的質化研究同時伴隨進行。 較多的教學實施時間約落在5到8周之間，過短的施行時間容易有系統性誤差，或是因為學生資訊素養的程度落差而造成偏誤，因此施測時間多半都足以充分施行，且為期六周以上的案例更普遍多於四年前。而越是高等或是進階的學科及專業領域，建議採取較長週期的施測時間（梁雲霞，2008）。 所有的論文均顯示出WebQuest對於教學上不等程度的助益，某些部分未達顯著的原因如下：施測時間不足、資訊素養的落差、網路涉入程度的高低。另外，某些學科及領域，或是較為基礎的層次以及較高的專業階段，WebQuest的介入雖有助益但未達顯著；且先備知識對於成效會有較大的影響，而學習者本身的動機與學習意願亦會導致成果的最終呈現。在國中小的學齡階段，雖普遍存在些許城鄉差距，但透過WebQuest的介入，其最終成效均是正面的（黃彰聖，2007）。 根據「科學教育白皮書」（教育部，2003）關於資訊時代的教育施行方針，台灣近年來銳意發展數位教學策略，其中教育部所轄之「Arts人文藝術網」便於2007年起，針對藝文領域的教學資源平台以及推廣的教案，收錄許多實例以供教師及學生參閱，且因應「中小學資訊教育白皮書」（教育部，2008）的建議規範，特建置雙語平台以響應國際化，並陸續舉辦教案設計及平台建立的競賽，對於優秀教學者暨參與學生給予鼓勵，目的便在於推廣以網路探究作為提升教學品質的促進方案。 近年來，台灣教育部於2007年中，發展了「中小學教師資訊科技素養自評表發展計畫」，用意為提升教師在「教材準備與資料蒐集」、「教材製作及硬體問題解決」、「規畫、教學與評量」等常態性教育較為弱勢的環節上進行補強，成效也逐步提升，但「數位教學資源」係屬長期環境養成，亟需教師於資訊領域的更多投入，在教育部的「致知網 Project Based Learning」中，遂與台灣微軟公司(Microsoft Taiwan Corp.)合作，共同進行數位化教學的品質推廣延伸計劃，用以深耕資訊素養對於教師及學生的學習行為涉入，最終目的即是追求教學品質的提升；也呼應了「國家發展重點計畫」中，建構數位化學習環境的目標，並落實於當中的「E世代人才培育計畫」，在在顯示了台灣追求數位化學習品質提升的信念。 在上述國家所投入的施行辦法中，唯欠缺對於中高等教育乃至於成人推廣教育的發展，於是在教育部「六大學習網共同平台learning.edu.tw」官方網站中，將網路學習計畫拓展至「歷史文化」、「自然生態」、「生命教育」、「人文藝術」、「科學教育」、「健康醫學」等六大領域，不再侷限於教育學習成效的深究，擴大了網路學習應用領域的範疇。 在台灣部分師資培育為導向的大學中，如台北市立教育大學及國立台北教育大學，於2007年亦開始針對在職教師與職前教師，針對 WebQuest 作教學設計進行實務研討，並舉辦座談邀請學者與具有豐富實務經驗的教師，倡議中高等教育的網路探究導入架構，期能將中小學已逐漸完備的發展模式，上行到欠缺實際執行的中高等教育環境中（劉成新，2007）。 誠如第二節檢索所得的資訊，現階段台灣的網路探究環境，於基礎教育的應用並不於匱乏，缺少的乃是中高等教育的施行，並驗證施行的效度。行政院國科會的「數位典藏國家型科技計畫」，已於2008年中轉型成「數位典藏與數位學習國家型科技計畫(Taiwan e-Learning & Digital Archives Program)」，當中提供了「數位學習品質服務中心」的收費認證服務，可惜迄今接受認證的單位跟研究機構，尚未出現以中高等教育環境為主的課程，由於中高等教育已經證實可透過 WebQuest 的導入來提升學習成效，期盼日後研究者，針對此一領域可多所著墨。 另外，台灣行政院勞委會官方所建置的「訓練品質評核系統(Taiwan TrainQuali System)」，亦少見成人職訓教育的 WebQuest 品質評核，冀望後續能有更多的研究延伸，以茲証明網路探究於成人學習的成效。 Dodge, B. (2000). Thinking Visually with WebQuest. http://edweb.sdsu.edu/webquest/TV Fred N. Kerlinger & Howard B. Lee. (2002). Foundations of Behavioral Reaserch, 4th. March, T. (2003). The Learning Power of WebQuests. Educationa Leadership, 61(4),. 黃勝發(2002)。找出教師使用資訊科技融入教學的因素。師說，167 期，17-19頁。 梁雲霞、劉尹婷，(2008)。「網路探究學習模式的導入與研究：台灣的觀察與分析」，網路探究的理念與設計，pp152-153。 財團法人國家實驗研究院科技策略研究與資訊中心服務推廣組。全國學術電子資訊資源共享聯盟 http://concert.stpi.narl.org.tw/ 國家圖書館研究組(2010)。「國家圖書館2010至2013中程發展策略目標」。 于文正、黃雲龍、林家君(2008)。WebQuest在創造力教育中的應用。師大學報：教育類, 3(2)，pp169-192。 黃學仁(2007)。資訊融入原住民五年級學生數學補救教學成效之研究。國立臺北教育大學數學教育研究所，未出版。台北市。 黃彰聖(2008)。城鄉差距對國小學童電腦網路的學習及其相關因素的影響--以桃園縣某兩國小為例。國立新竹教育大學人資處數學教育碩士班，未出版。新竹市。 行政院國家科學委員會(2003)。教育部科學教育白皮書。 教育部(2008)。中小學資訊教育白皮書。 劉成新(2007)。「WebQuest設計與應用調查分析」。課程、教材、教法。第27券第三期，pp67-71。 |
Introducing Julia/Metaprogramming 元编程是指编写 Julia 代码来处理和修改 Julia 代码。使用元编程工具，您可以编写 Julia 代码来修改源文件的其他部分，甚至可以控制修改后的代码是否运行以及何时运行。 在 Julia 中，原始源代码的执行分为两个阶段。(实际上，还有更多的阶段，但在这一点上，我们只关注这两个阶段。) 阶段1 是原始 Julia 代码被解析 - 转换为适合于求值的形式。您会对这个阶段比较熟悉，因为这时候所有语法错误都能被发现……这样做的结果是 抽象语法树 或 AST (Abstract Syntax Tree) ，该结构包含所有代码，但其格式比通常使用的人类友好语法更易于操作。 阶段2 是执行解析后的代码。通常，当您在 REPL 中键入代码并按 換行键 时，或者当您从命令行运行 Julia 文件时，您不会注意到这两个阶段，因为它们发生得太快了。但是，使用 Julia 的元编程工具，您可以在对代码解析之后，但在执行之前访问该代码。 这可以让你做一些你通常不能做的事情。例如，您可以将简单表达式转换为更复杂的表达式，或者在代码运行之前检查代码并对其进行更改，以使其运行得更快。使用这些元编程工具拦截和修改的任何代码最终都将以通常的方式执行，运行速度与普通Julia代码一样快。 您可能已经在Julia中使用了两个现有的元编程示例： - @time 巨集指令: julia> @time [sin(cos(i)) for i in 1:100000]; 0.102967 seconds (208.65 k allocations: 9.838 MiB) @time 巨集指令在代码的前面插入了 "秒表开始" 的命令在传入的表达式之前。当代码结束的时候，添加了一个“秒表结束” 的命令。然后进行计算，以报告所经过的时间和内存使用情况。 - @which 巨集指令 julia> @which 2 + 2 +(x::T, y::T) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8} in Base at int.jl:53 此巨集指令根本不允许计算表达式 2 + 2 。相反，它报告将对这些特定参数使用哪种方法。它还会告诉您包含方法定义的源文件和行号。 元编程的其他用途包括 通过编写生成较大代码块的短代码 来实现单调编码工作的自动化，以及能通过生成您可能不希望手工编写的更快的代码来提高“标准”代码的性能。 要使元编程成为可能，在解析阶段完成后，Julia 就需要一种方法来存储未计算但已解析的表达式。这就是 ':' (冒号) 前缀运算符： julia> x = 3 3 julia> :x :x 在 Julia 中, :x 表示一个未求值的符号或一个引用符号。 (如果您不熟悉编程中引用符号（Quoted Symbols）的用途，请想想在书写中如何使用引用来区分普通用途和特殊用途。例如，在句子中： 'Copper' contains six letters. 引号表明 “Copper” 这个词不是指金属，而是指这个单词本身。同样，在 :x 中，符号前面的冒号将使您和Julia将 'x' 视为未计算的符号，而不是值3。) 要引用整个表达式而不是单个符号，请用冒号开头，然后将 Julia 表达式括在括号中： julia> :(2 + 2) :(2 + 2) 还有一种形式的 :( ) 结构，使用 quote ... end 关键字来将表达式封闭起来并引用： quote 2 + 2 end 将返回 quote #= REPL[123]:2 =# 2 + 2 end 而下面这个表达式： expression = quote for i = 1:10 println(i) end end 返回的是： quote #= REPL[124]:2 =# for i = 1:10 #= REPL[124]:3 =# println(i) end end expression 对象的类型是 Expr: julia> typeof(expression) Expr 解析完成，并准备好做接下来的事情。 Julia 还有一个函数 eval() 用于计算未求值的表达式： julia> eval(:x) 3 julia> eval(:(2 + 2)) 4 julia> eval(expression) 1 2 3 4 5 6 7 8 9 10 使用这些工具，可以创建并存储任何表达式，而不对其求值： e = :( for i in 1:10 println(i) end ) 返回: :(for i = 1:10 # line 2: println(i) end) 然后再计算这个表达式： julia> eval(e) 1 2 3 4 5 6 7 8 9 10 更有用的是，可以在对表达式进行求值之前修改表达式的内容。 只要将 Julia 代码放在一个未计算的表达式中，而不是作为字符串中的一段文本，您就可以使用它来做一些事情。 下面是另外一段表达式 P = quote a = 2 b = 3 c = 4 d = 5 e = sum([a,b,c,d]) end 返回： quote #= REPL[125]:2 =# a = 2 #= REPL[125]:3 =# b = 3 #= REPL[125]:4 =# c = 4 #= REPL[125]:5 =# d = 5 #= REPL[125]:6 =# e = sum([a, b, c, d]) end 请注意添加到每行引用表达式的有帮助的行号。 （每行的标签都添加在上一行的末尾。） 我们可以用 fieldnames() 函数看看表达式里面是什么： julia> fieldnames(typeof(P)) (:head, :args, :typ) head字段为:block , args字段是一个数组，包含表达式(包括注释)。我们可以用这些简单的 Julia 技巧来检查这些。 例如，第二个子表达式是什么： julia> P.args[2] :(a = 2) 把它们打印出来 for (n, expr) in enumerate(P.args) println(n, ": ", expr) end 1: #= REPL[125]:2 =# 2: a = 2 3: #= REPL[125]:3 =# 4: b = 3 5: #= REPL[125]:4 =# 6: c = 4 7: #= REPL[125]:5 =# 8: d = 5 9: #= REPL[125]:6 =# 10: e = sum([a, b, c, d]) 如你所见，表达式 P 包含许多子表达式。我们可以非常容易地修改这个表达式；例如，我们可以将表达式的最后一行更改为使用 prod()而不是 sum() ，这样，当对P 求值时，它将返回乘积而不是变量的和。 julia> eval(P) 14 julia> P.args[end] = quote prod([a,b,c,d]) end quote #= REPL[133]:1 =# prod([a, b, c, d]) end julia> eval(P) 120 或者，您可以在表达式中直接指向 sum() 符号： julia> P.args[end].args[end].args[1] :sum julia> P.args[end].args[end].args[1] = :prod :prod julia> eval(P) 120 这种代码解析后的表示方式称为 AST (抽象语法树)。这是一个嵌套的层次结构，允许您和 Julia 轻松地处理和修改代码。 非常有用的 dump 函数使您可以轻松地可视化表达式的分层性质。例如，表达式：:(1 * sin(pi/2)) 表示如下： julia> dump(:(1 * sin(pi/2))) Expr head: Symbol call args: Array{Any}((3,)) 1: Symbol * 2: Int64 1 3: Expr head: Symbol call args: Array{Any}((2,)) 1: Symbol sin 2: Expr head: Symbol call args: Array{Any}((3,)) 1: Symbol / 2: Symbol pi 3: Int64 2 typ: Any typ: Any typ: Any 您可以看到 AST 完全由 Expr 和 原子符号(例如符号和数字) 组成。 在某种程度上，字符串和表达式是相似的——它们所包含的任何 Julia 代码通常都是未计算的，但是您可以使用插值来计算 引用表达式 中的一些代码。我们已经遇到了 字符串插值运算符，即美元符号($)。在字符串中使用它做插值时（可能会用括号将被插值的表达式括起来），这将计算被插值的 Julia 代码，然后将结果插入到字符串中： julia> "the sine of 1 is $(sin(1))" "the sine of 1 is 0.8414709848078965" 同样的，您也可以使用美元符号来将某段 Julia 代码的执行结果插入到表达式中（否则这段代码也会被引用，而不会被求值）： julia> quote s = $(sin(1) + cos(1)); end quote # none, line 1: s = 1.3817732906760363 end 尽管这是一个被引用（quoted）了的表达式，因此未被计算，但表达式中的 sin(1) + cos(1) 却是被执行了，它的值被插入到了表达式中，原始代码则被值替换了。这种操作称为“拼接”。 与字符串插值一样，只有当你想要插入一个表达式的值时候才需要使用圆括号，插入单个符号的值用 $ 就行。 现在你已经知道如何创建并处理未求值的 Julia 表达式了，你肯定会想知道该怎样去修改它们。宏—— macro 就是从一个未求值的表达式生成新表达式的途径之一。 当你的 Julia 程序运行时，它首先会解析宏，并对宏进行求值，然后将宏生成的代码当成普通的表达式来计算。 下面是一个简单的宏定义，它只是打印出传入表达式的内容，然后直接将该传入表达式返回给调用者（在这里，调用者就是 REPL）。宏定义的语法和函数定义的语法很相似： macro p(n) if typeof(n) == Expr println(n.args) end return n end 您可以通过在名称前添加 @ 前缀来运行宏。这个宏只需要一个参数，你直接提供未求值的 Julia 代码给它就行。也不必像调用函数那样，用括号将参数括起来。 先尝试一下用数值做参数： julia> @p 3 3 数字并不是表达式，因此宏的 if 条件结果是 false。这个宏会直接返回 n。但如果你传入一个表达式，宏里边的代码就能够在表达式被求值前，通过 .args 属性来审查或处理表达式的内容： julia> @p 3 + 4 - 5 * 6 / 7 % 8 Any[:-,:(3 + 4),:(((5 * 6) / 7) % 8)] 2.7142857142857144 在上面的例子中，if 条件结果为 true，输入的表达式的未求值形式就被打印了出来。因此你能看到表达式的 AST 结构——也就是 Julia 表达式被解析得到的结果，对它进一步求值，就得到表达式的值。 你也能发现解析操作会考虑到算术运算符的不同优先级。注意上层操作符和子表达式都被冒号（:）引用了起来。 Also notice that the macro p returned the argument, which was then evaluated, hence the 2.7142857142857144. But it doesn't have to — it could return a quoted expression instead. As an example, the built-in @time macro returns a quoted expression rather than using eval() to evaluate the expression inside the macro. The quoted expression returned by @time is evaluated in the calling context when the macro has done its work. Here's the definition: macro time(ex) quote local t0 = time() local val = $(esc(ex)) local t1 = time() println("elapsed time: ", t1-t0, " seconds") val end end Notice the $(esc(ex)) expression. This is the way that you 'escape' the code you want to time, which is in ex, so that it isn't evaluated in the macro, but left intact until the entire quoted expression is returned to the calling context and executed there. If this just said $ex, then the expression would be interpolated and evaluated immediately. If you want to pass a multi-line expression to a macro, use the begin ... end form: @p begin 2 + 2 - 3 end Any[:( # none, line 2:),:((2 + 2) - 3)] 1 (You can also call macros with parentheses similar to the way you do when calling functions, using the parentheses to enclose the arguments: julia> @p(2 + 3 + 4 - 5) Any[:-,:(2 + 3 + 4),5] 4 This would allow you to define macros that accepted more than one expression as arguments.) There's an eval() function, and an @eval macro. You might be wondering what's the difference between the two? julia> ex = :(2 + 2) :(2 + 2) julia> eval(ex) 4 julia> @eval ex :(2 + 2) The function version (eval()) expands the expression and evaluates it. The macro version doesn't expand the expression you supply to it automatically, but you can use the interpolation syntax to evaluate the expression and pass it to the macro. julia> @eval $(ex) 4 In other words: julia> @eval $(ex) == eval(ex) true Here's an example where you might want to create some variables using some automation. We'll create the first ten squares and ten cubes, first using eval(): for i in 1:10 symbolname = Symbol("var_squares_$(i)") eval(quote $symbolname = $(i^2) end) end which creates a load of variables named var_squares_n, such as: julia> var_squares_5 25 and then using @eval: for i in 1:10 symbolname = Symbol("var_cubes_$(i)") @eval $symbolname = $(i^3) end which similarly creates a load of variables named var_cubes_n, such as: julia> var_cubes_5 125 Once you feel confident, you might prefer to write like this: julia> [@eval $(Symbol("var_squares_$(i)")) = ($i^2) for i in 1:10] When you use macros, you have to keep an eye out for scoping issues. In the previous example, the $(esc(ex)) syntax was used to prevent the expression from being evaluated in the wrong context. Here's another contrived example to illustrate this point. macro f(x) quote s = 4 (s, $(esc(s))) end end This macro declares a variable s, and returns a quoted expression containing s and an escaped version of s. Now, outside the macro, declare a symbol s: julia> s = 0 Run the macro: julia> @f 2 (4,0) You can see that the macro returned different values for the symbol s: the first was the value inside the macro's context, 4, the second was an escaped version of s, that was evaluated in the calling context, where s has the value 0. In a sense, esc() has protected the value of s as it passes unharmed through the macro. For the more realistic @time example, it's important that the expression you want to time isn't modified in any way by the macro. To see what the macro expands to just before it's finally executed, use the macroexpand() function. It expects a quoted expression containing one or more macro calls, which are then expanded into proper Julia code for you so that you can see what the macro would do when called. julia> macroexpand(Main, quote @p 3 + 4 - 5 * 6 / 7 % 8 end) Any[:-,:(3 + 4),:(((5 * 6) / 7) % 8)] quote #= REPL[158]:1 =# (3 + 4) - ((5 * 6) / 7) % 8 end (The #none, line 1: is a filename and line number reference that's more useful when used inside a source file than when you're using the REPL.) Here's another example. This macro adds a dotimes construction to the language. macro dotimes(n, body) quote for i = 1:$(esc(n)) $(esc(body)) end end end This is used as follows: julia> @dotimes 3 println("hi there") hi there hi there hi there Or, less likely, like this: julia> @dotimes 3 begin for i in 4:6 println("i is $i") end end i is 4 i is 5 i is 6 i is 4 i is 5 i is 6 i is 4 i is 5 i is 6 If you use macroexpand() on this, you can see what happens to the symbol names: macroexpand(Main, # we're working in the Main module quote @dotimes 3 begin for i in 4:6 println("i is $i") end end end ) with the following output: quote #= REPL[160]:3 =# begin #= REPL[159]:3 =# for #101#i = 1:3 #= REPL[159]:4 =# begin #= REPL[160]:4 =# for i = 4:6 #= REPL[160]:5 =# println("i is $(i)") end end end end end The i local to the macro itself has been renamed to #101#i, so as not to clash with the original i in the code we passed to it. Here's how to define a macro that is more likely to be useful in your code. Julia doesn't have an until condition ... do some stuff ... end statement. Perhaps you'd like to type something like this: until x > 100 println(x) end You'll be able to write your code using the new until macro like this: until <condition> <block_of_stuff> end but, behind the scenes, the work will be done by actual code with the following structure: while true <block_of_stuff> if <condition> break end end This forms the body of the new macro, and it will be enclosed in a quote ... end block, like this, so that it executes when evaluated, but not before: quote while true <block_of_stuff> if <condition> break end end end So the nearly-finished macro code is like this: macro until(<condition>, <block_of_stuff>) quote while true <block_of_stuff> if <condition> break end end end end All that remains to be done is to work out how to pass in our code for the <block_of_stuff> and the <condition> parts of the macro. Recall that $(esc(...)) allows code to pass through 'escaped' (i.e. unevaluated). We'll protect the condition and block code from being evaluated before the macro code runs. The final macro definition is therefore: macro until(condition, block) quote while true $(esc(block)) if $(esc(condition)) break end end end end The new macro is used like this: julia> i = 0 0 julia> @until i == 10 begin global i += 1 println(i) end 1 2 3 4 5 6 7 8 9 10 or julia> x = 5 5 julia> @until x < 1 (println(x); global x -= 1) 5 4 3 2 1 If you want a more complete explanation of the compilation process than that provided here, visit the links shown in Further Reading, below. Julia performs multiple 'passes' to transform your code to native assembly code. As described above, the first pass parses the Julia code and builds the 'surface-syntax' AST, suitable for manipulation by macros. A second pass lowers this high-level AST into an intermediate representation, which is used by type inference and code generation. In this intermediate AST format all macros have been expanded and all control flow has been converted to explicit branches and sequences of statements. At this stage the Julia compiler attempts to determine the types of all variables so that the most suitable method of a generic function (which can have many methods) is selected. Julia ASTs · The Julia Language（英文） Julia 官方文档中关于 AST（抽象语法树）的部分 Julia Introspects（英文） Leah Hanson 2013 写的关于 Julia 内部表示的文章 |
MySQL/Pivot table “透视表”或“交叉报表”(crosstab report），是对源数据表的选定的列作为“列标签”（Column label），该列的值将作为透视表中的列名。从而实现“行转列”。源数据表的其他列可以在透视表中保留（这称为“列标签”Column labels，即透视表的每行在该列有不同取值），也可以用于汇总计算（这称为“汇总值”Summation values）。 MySQL不像SQL Server直接提供了pivot和unpivot关键字，所以需要自行创建。 可分为手工写SQL语句的静态实现或者写存储程序的动态实现。 CREATE TABLE product_sales ( product_name VARCHAR(100), store_location VARCHAR(50), num_sales INT ); INSERT INTO product_sales (product_name, store_location, num_sales) VALUES ('Chair', 'North', 55), ('Desk', 'Central', 120), ('Couch', 'Central', 78), ('Chair', 'South', 23), ('Chair', 'South', 10), ('Chair', 'North', 98), ('Desk', 'West', 61), ('Couch', 'North', 180), ('Chair', 'South', 14), ('Desk', 'North', 45), ('Chair', 'North', 87), ('Chair', 'Central', 34), ('Desk', 'South', 42), ('Couch', 'West', 58), ('Couch', 'Central', 27), ('Chair', 'South', 91), ('Chair', 'West', 82), ('Chair', 'North', 37), ('Desk', 'North', 68), ('Couch', 'Central', 54), ('Chair', 'South', 81), ('Desk', 'North', 25), ('Chair', 'North', 46), ('Chair', 'Central', 121), ('Desk', 'South', 85), ('Couch', 'North', 43), ('Desk', 'West', 10), ('Chair', 'North', 5), ('Chair', 'Central', 16), ('Desk', 'South', 9), ('Couch', 'West', 22), ('Couch', 'Central', 59), ('Chair', 'South', 76), ('Chair', 'West', 48), ('Chair', 'North', 19), ('Desk', 'North', 3), ('Couch', 'West', 63), ('Chair', 'South', 81), ('Desk', 'North', 85), ('Chair', 'North', 90), ('Chair', 'Central', 47), ('Desk', 'West', 63), ('Couch', 'North', 28); SELECT * FROM product_sales; #以下为静态实现： SELECT product_name, SUM(CASE WHEN store_location = 'North' THEN num_sales ELSE 0 END ) AS north, SUM(CASE WHEN store_location = 'Central' THEN num_sales ELSE 0 END ) AS central, SUM(CASE WHEN store_location = 'South' THEN num_sales ELSE 0 END ) AS south, SUM(CASE WHEN store_location = 'West' THEN num_sales ELSE 0 END ) AS west FROM product_sales GROUP BY product_name; #以下为动态实现： SET @sql = NULL; SELECT GROUP_CONCAT(DISTINCT CONCAT( 'SUM( CASE WHEN store_location = "', store_location, '" THEN num_sales ELSE 0 END) AS ', store_location) ) INTO @sql FROM product_sales; select @sql; SET @sql = CONCAT('SELECT product_name, ', @sql, ' FROM product_sales GROUP BY product_name'); SELECT @sql; PREPARE stmt FROM @sql; EXECUTE stmt; DEALLOCATE PREPARE stmt; ==不使用if或case的实现==不使用"if", "case", or "GROUP_CONCAT". Yes, there is use for this..."if" statements sometimes cause problems when used in combination. The simple secret, and it's also why they work in almost all databases, is the following functions: sign (x) returns -1,0, +1 for values x < 0, x = 0, x > 0 respectively abs( sign( x) ) returns 0 if x = 0 else, 1 if x > 0 or x < 0 1-abs( sign( x) ) complement of the above, since this returns 1 only if x = 0 Quick example: sign(-1) = -1, abs( sign(-1) ) = 1, 1-abs( sign(-1) ) = 0 Data for full example: CREATE TABLE exams ( pkey int(11) NOT NULL auto_increment, name varchar(15), exam int, score int, PRIMARY KEY (pkey) ); insert into exams (name,exam,score) values ('Bob',1,75); insert into exams (name,exam,score) values ('Bob',2,77); insert into exams (name,exam,score) values ('Bob',3,78); insert into exams (name,exam,score) values ('Bob',4,80); insert into exams (name,exam,score) values ('Sue',1,90); insert into exams (name,exam,score) values ('Sue',2,97); insert into exams (name,exam,score) values ('Sue',3,98); insert into exams (name,exam,score) values ('Sue',4,99); mysql> select * from exams; +------+------+------+-------+ | pkey | name | exam | score | +------+------+------+-------+ | 1 | Bob | 1 | 75 | | 2 | Bob | 2 | 77 | | 3 | Bob | 3 | 78 | | 4 | Bob | 4 | 80 | | 5 | Sue | 1 | 90 | | 6 | Sue | 2 | 97 | | 7 | Sue | 3 | 98 | | 8 | Sue | 4 | 99 | +------+------+------+-------+ 8 rows in set (0.00 sec) mysql> select name, sum(score*(1-abs(sign(exam-1)))) as exam1, sum(score*(1-abs(sign(exam-2)))) as exam2, sum(score*(1-abs(sign(exam-3)))) as exam3, sum(score*(1-abs(sign(exam-4)))) as exam4 from exams group by name; +------+-------+-------+-------+-------+ | name | exam1 | exam2 | exam3 | exam4 | +------+-------+-------+-------+-------+ | Bob | 75 | 77 | 78 | 80 | | Sue | 90 | 97 | 98 | 99 | +------+-------+-------+-------+-------+ 2 rows in set (0.00 sec) Note, the above pivot table was created with one select statement. Let's decompose to make the trick clearer, for the second exam: mysql> select name, score, exam, exam-2, sign(exam-2), abs(sign(exam-2)), 1-abs(sign(exam-2)), score*(1-abs(sign(exam-2))) as exam2 from exams; +------+-------+------+--------+--------------+-------------------+---------------------+-------+ | name | score | exam | exam-2 | sign(exam-2) | abs(sign(exam-2)) | 1-abs(sign(exam-2)) | exam2 | +------+-------+------+--------+--------------+-------------------+---------------------+-------+ | Bob | 75 | 1 | -1 | -1 | 1 | 0 | 0 | | Bob | 77 | 2 | 0 | 0 | 0 | 1 | 77 | | Bob | 78 | 3 | 1 | 1 | 1 | 0 | 0 | | Bob | 80 | 4 | 2 | 1 | 1 | 0 | 0 | | Sue | 90 | 1 | -1 | -1 | 1 | 0 | 0 | | Sue | 97 | 2 | 0 | 0 | 0 | 1 | 97 | | Sue | 98 | 3 | 1 | 1 | 1 | 0 | 0 | | Sue | 99 | 4 | 2 | 1 | 1 | 0 | 0 | +------+-------+------+--------+--------------+-------------------+---------------------+-------+ 8 rows in set (0.00 sec) You may think IF's would be clean but WATCH OUT! Look what the following gives (INCORRECT !!): mysql> select name, if(exam=1,score,null) as exam1, if(exam=2,score,null) as exam2, if(exam=3,score,null) as exam3, if(exam=4,score,null) as exam4 from exams group by name; +------+-------+-------+-------+-------+ | name | exam1 | exam2 | exam3 | exam4 | +------+-------+-------+-------+-------+ | Bob | 75 | NULL | NULL | NULL | | Sue | 90 | NULL | NULL | NULL | +------+-------+-------+-------+-------+ 2 rows in set (0.00 sec) Note: the following does work - is all the maths necessary after all? mysql> SELECT name, SUM(IF(exam=1,score,NULL)) AS exam1, SUM(IF(exam=2,score,NULL)) AS exam2, SUM(IF(exam=3,score,NULL)) AS exam3, SUM(IF(exam=4,score,0)) AS exam4 FROM exams GROUP BY name; +------+-------+-------+-------+-------+ | name | exam1 | exam2 | exam3 | exam4 | +------+-------+-------+-------+-------+ | Bob | 75 | 77 | 78 | 80 | | Sue | 90 | 97 | 98 | 99 | +------+-------+-------+-------+-------+ 2 rows in set (0.00 sec) mysql> select name, sum(score*(1-abs(sign(exam-1)))) as exam1, sum(score*(1-abs(sign(exam-2)))) as exam2, sum(score*(1-abs(sign(exam-3)))) as exam3, sum(score*(1-abs(sign(exam-4)))) as exam4, sum(score*(1-abs(sign(exam- 2)))) - sum(score*(1-abs(sign(exam- 1)))) as delta_1_2, sum(score*(1-abs(sign(exam- 3)))) - sum(score*(1-abs(sign(exam- 2)))) as delta_2_3, sum(score*(1-abs(sign(exam- 4)))) - sum(score*(1-abs(sign(exam- 3)))) as delta_3_4 from exams group by name; +------+-------+-------+-------+-------+-----------+-----------+-----------+ | name | exam1 | exam2 | exam3 | exam4 | delta_1_2 | delta_2_3 | delta_3_4 | +------+-------+-------+-------+-------+-----------+-----------+-----------+ | Bob | 75 | 77 | 78 | 80 | 2 | 1 | 2 | | Sue | 90 | 97 | 98 | 99 | 7 | 1 | 1 | +------+-------+-------+-------+-------+-----------+-----------+-----------+ 2 rows in set (0.00 sec) Above delta_1_2 shows the difference between the first and second exams, with the numbers being positive because both Bob and Sue improved their score with each exam. Calculating the deltas here shows it's possible to compare two rows, not columns which is easily done with the standard SQL statements but rows in the original table. mysql>select name, sum(score*(1-abs(sign(exam-1)))) as exam1, sum(score*(1-abs(sign(exam-2)))) as exam2, sum(score*(1-abs(sign(exam-3)))) as exam3, sum(score*(1-abs(sign(exam-4)))) as exam4, sum(score*(1-abs(sign(exam- 2)))) - sum(score*(1-abs(sign(exam- 1)))) as delta_1_2, sum(score*(1-abs(sign(exam- 3)))) - sum(score*(1-abs(sign(exam- 2)))) as delta_2_3, sum(score*(1-abs(sign(exam- 4)))) - sum(score*(1-abs(sign(exam- 3)))) as delta_3_4, sum(score*(1-abs(sign(exam- 2)))) - sum(score*(1-abs(sign(exam- 1)))) + sum(score*(1-abs(sign(exam- 3)))) - sum(score*(1-abs(sign(exam- 2)))) + sum(score*(1-abs(sign(exam- 4)))) - sum(score*(1-abs(sign(exam- 3)))) as TotalIncPoints from exams group by name; +------+-------+-------+-------+-------+-----------+-----------+-----------+----------------+ | name | exam1 | exam2 | exam3 | exam4 | delta_1_2 | delta_2_3 | delta_3_4 | TotalIncPoints | +------+-------+-------+-------+-------+-----------+-----------+-----------+----------------+ | Bob | 75 | 77 | 78 | 80 | 2 | 1 | 2 | 5 | | Sue | 90 | 97 | 98 | 99 | 7 | 1 | 1 | 9 | +------+-------+-------+-------+-------+-----------+-----------+-----------+----------------+ 2 rows in set (0.00 sec) TotalIncPoints shows the sum of the deltas. select name, sum(score*(1-abs(sign(exam-1)))) as exam1, sum(score*(1-abs(sign(exam-2)))) as exam2, sum(score*(1-abs(sign(exam-3)))) as exam3, sum(score*(1-abs(sign(exam-4)))) as exam4, sum(score*(1-abs(sign(exam- 2)))) - sum(score*(1-abs(sign(exam- 1)))) as delta_1_2, sum(score*(1-abs(sign(exam- 3)))) - sum(score*(1-abs(sign(exam- 2)))) as delta_2_3, sum(score*(1-abs(sign(exam- 4)))) - sum(score*(1-abs(sign(exam- 3)))) as delta_3_4, sum(score*(1-abs(sign(exam- 2)))) - sum(score*(1-abs(sign(exam- 1)))) + sum(score*(1-abs(sign(exam- 3)))) - sum(score*(1-abs(sign(exam- 2)))) + sum(score*(1-abs(sign(exam- 4)))) - sum(score*(1-abs(sign(exam- 3)))) as TotalIncPoints, (sum(score*(1-abs(sign(exam-1)))) + sum(score*(1-abs(sign(exam-2)))) + sum(score*(1-abs(sign(exam-3)))) + sum(score*(1-abs(sign(exam-4)))))/4 as AVG from exams group by name; +------+-------+-------+-------+-------+-----------+-----------+-----------+----------------+-------+ | name | exam1 | exam2 | exam3 | exam4 | delta_1_2 | delta_2_3 | delta_3_4 | TotalIncPoints | AVG | +------+-------+-------+-------+-------+-----------+-----------+-----------+----------------+-------+ | Bob | 75 | 77 | 78 | 80 | 2 | 1 | 2 | 5 | 77.50 | | Sue | 90 | 97 | 98 | 99 | 7 | 1 | 1 | 9 | 96.00 | +------+-------+-------+-------+-------+-----------+-----------+-----------+----------------+-------+ 2 rows in set (0.00 sec) It's possible to combine Total Increasing Point TotalIncPoints with AVG. In fact, it's possible to combine all of the example cuts of the data into one SQL statement, which provides additional options for displaying data on your page select name, sum(score*(1-abs(sign(exam-1)))) as exam1, sum(score*(1-abs(sign(exam-2)))) as exam2, sum(score*(1-abs(sign(exam-3)))) as exam3, sum(score*(1-abs(sign(exam-4)))) as exam4, (sum(score*(1-abs(sign(exam-1)))) + sum(score*(1-abs(sign(exam-2)))))/2 as AVG1_2, (sum(score*(1-abs(sign(exam-2)))) + sum(score*(1-abs(sign(exam-3)))))/2 as AVG2_3, (sum(score*(1-abs(sign(exam-3)))) + sum(score*(1-abs(sign(exam-4)))))/2 as AVG3_4, (sum(score*(1-abs(sign(exam-1)))) + sum(score*(1-abs(sign(exam-2)))) + sum(score*(1-abs(sign(exam-3)))) + sum(score*(1-abs(sign(exam-4)))))/4 as AVG from exams group by name; +------+-------+-------+-------+-------+--------+--------+--------+-------+ | name | exam1 | exam2 | exam3 | exam4 | AVG1_2 | AVG2_3 | AVG3_4 | AVG | +------+-------+-------+-------+-------+--------+--------+--------+-------+ | Bob | 75 | 77 | 78 | 80 | 76.00 | 77.50 | 79.00 | 77.50 | | Sue | 90 | 97 | 98 | 99 | 93.50 | 97.50 | 98.50 | 96.00 | +------+-------+-------+-------+-------+--------+--------+--------+-------+ 2 rows in set (0.00 sec) Exam scores are listing along with moving averages...again it's all with one select statement. Good article on "Cross tabulations" or de-normalizing data to show stats: http://dev.mysql.com/tech-resources/articles/wizard/print_version.html ADOdb (PHP) can generate pivot tables using PivotTableSQL(). For Perl, check DBIx-SQLCrosstab. |
藥物化學/抗癌藥/Pyrimidine 拮抗劑：dTMP 合成抑制劑/Fluorouracil 第一步驟，形成活性代謝產物 第二步驟，與目標作用 因為 C5 上具有強拉電子取代基，使得 C6 比 dUMP 更親電性，增加 Cys 195 攻擊 C6 的速率 配製成的溶液具有光敏感性 |
Blender 3D︰從入門到精通/网格（Mesh）与编辑模式（Edit Mode） 网格（Mesh）可以说是Blender中最重要，也是使用最频繁的对象类型之一了。虽说其他类型的对象（比方说像是文本（Text），NURBS patches，等等）也可以被用来对场景或复杂模型的某一部分进行建模，可是它们最终往往会被转化为网格对象，这是因为网格对象能够提供最多的细节控制。也正是因为如此，Blender为处理网格对象提供了比其他对象更多的功能，这既包括内置的功能，也包括可供安装的附加组件。 编辑模式（Edit Mode）是你可以编辑“活动”对象（Active Object）的模式。并非每个对象都有编辑模式（比方说摄像机（Camera）就没有），就算是有编辑模式的对象，在编辑模式下你可以进行的操作也不尽相同。本节主要讨论网格对象的编辑模式。 一个“网格”由许多“顶点（Vertex，复数形式为Vertices）”组成，每个顶点就是三维空间中的一个点。而两个顶点间可以连一条线段，被称作“边（Edge）”；若干条边如果连接成一个完整的环，就可以被填充成为一个“面（Face）”。正是“面”构成了我们所能看到的物体表面，顶点和边本质上来说是物体必要的几何框架。 显然，一个面至少要由三条边构成。在Blender 2.63之前的版本里，一个面只能由三条边或者四条边围成，或者说一个面不是三角形就是四边形。不过，Blender 2.63引入了全新的BMesh网格系统，所以这个限制已不复存在。现在，你可创建由五条边甚至更多边构成的面。不过，实际上来说，尤其是在创建的模型需要用于动画时，为了使一切功能都运行得很好，你会发觉还是让所有的面尽可能都是四边形为好。 Blender的对象模式（Object Mode）有一个“添加（Add）”菜单（按 SHIFT + A 调出它），里面就有一个“网格”子菜单，其中包括了全部的内置网格对象。你可以选择其中一个和你预想中的模型相似的来作为你建模的起点，然后在此基础上进行修改，这会比从零开始构建网格要容易一些。 我们首先新建一个Blender文档。如果你能看见操纵器（Manipulator）的话，先按( CTRL + SPACE )隐藏它。现在你应当处于对象模式（Object Mode）之中。 鼠标右键 单击那个默认存在的正方体来选中它，同时使它成为活动对象（Active Object）。 之前说过，可以使用模式選单（Mode Menu）来切换模式。不过在对象模式（Object Mode）和编辑模式（Edit mode）是非常频繁的操作，因此有一个快捷键 TAB 专门为这个操作预留。现在试试用这种新方法吧，你会发觉立方体的外观变成了右图那样，而且模式菜单也提示你进入了编辑模式。再按一次 TAB ，你会回到对象模式。好啦，为了方便一下的学习，再按一次 TAB 回到编辑模式。 现在我们来看一看这个立方体，感受一下网格对象的特点： 那些在角落上的点就是所谓的顶点（Vertex，复数形式Vertices）。 连接它们的线就是所谓的边（Edge）。 而那些由边围成的填充区域就是所谓的面（Face）。 在编辑模式中，3D视图（3D View）窗口的标题栏会发生变化以便你可以修改选择模式。你可以尝试依次左键单击那三个按钮，它们分别代表着顶点选择模式、边选择模式和面选择模式。注意你可以按住Shift键来同时启用多个选择模式。 在顶点选择模式中，右键单击一个顶点可以选中它。你也可以通过按住 Shift 键来同时选择多个顶点。如果按住 Shift 键后再次右键单击已经选择的顶点，那将会取消选择该顶点。在没有顶点被选择的情况下，按A键会选中所有顶点；如果已经有顶点被选择，按 A 键会先取消选择所有的顶点。 边选择模式和面选择模式的工作方式与顶点选择模式是相似的。 在三个控制选择模式的按钮右侧的是被叫做“仅选择可见元素（limit selection to visible）”的按钮，当它被激活时，网格对象是不透明的，因此那些在背面的顶点、边和面无法被选中。现在点一下这个按钮，网格对象就会变成透明的了，你可以“透过”正面去选择那些藏在后面的对象。 另外一个在3D视图中非常有用的显示模式是线框（Wireframe），你可以从视图着色方式（Viewport Shading）菜单中选择它或者按Z键开关它。在这个模式中，面是透明的，几乎看不到，而顶点和边就显得更为突出。 这里你可以看到各种显示模式的组合都是什么样的。第一行显示的是一个顶点被选中的情况；第二行显示的是一条边被选中的情况，第三行显示的是一个面被选中的情况。而第一列中，“仅选择可见元素”功能是激活的，第二列中该功能被关闭了，第三列中线框模式是启用的。 你可以通过 CTRL + TAB 来切换选择模式。 在出现的菜单中，你可以使用鼠标选择，或者通过键盘上的方向键和 ENTER 的方式切换到单顶点选择模式（single selection mode）。使用 SHIFT + ENTER 或者 SHIFT + LMB 这两个按键组合可以在保证原来被选择的内容不被影响的情况下，切换到新的选择模式，就像上面我们所提到的，通过Shift+左键单击的方式选择多个顶点一样。 通常情况下，和所有的呼出菜单一样，你可以通过数字键，如 1KEY 、 2KEY 或者 3KEY 从 CTRL + TAB 呼出的菜单中快速切换到第一个（选择点）、第二个（选择边）、第三个（选择面）选择模式。同时，和之前所提到的一样， SHIFT + 1KEY , SHIFT + 2KEY 和 SHIFT + 3KEY 可以分别切换到点、边和面的选择模式中。 你可以使用 SHIFT + RMB 來選擇多個物件,并且按下 CTRL + I 來進行反選擇,就像是在物件模式。 根據選擇模式的不同，會決定是多個點、多條線或多個面被選取。 被作用的部分(最後被選擇的)會變成白色, 而其他被選擇的部分(如果有的話)通常會是橘黃色。 就像上面提到的, A 就像在物体模式下一样，只不过不是应用到整个场景的所有物体,而是应用到正在编辑物体的所有子元素. H , SHIFT + H and ALT + H work in an analogous way to their behaviour in Object mode. Again, instead of applying to everything, they apply to all parts of the object being edited. Remembering What’s Hidden: If you switch out of Edit mode with some parts hidden, they will reappear, then disappear again when you re-enter Edit mode. So each object remembers what was hidden when you last edited it. 您可以在编辑模式下切换局部/全局视图，就像在对象模式下一样。然而，不是将视图缩放到一个或多个选定对象，而是将其缩放到正在编辑的对象。 B 和 C 就像在物体模式下一样起作用, 可以通过画一个方框或者在物体上勾画来多选对象。 在编辑模式下，还有一些其它选择方法。为了演示的目的，我们不使用缺省的立方体，而是新建一个。先使用 TAB 键返回对象模式，删除立方体，现在按 ( SHIFT + A ) 并添加一个 Grid 对象. 按 TAB 切换为编辑模式， 可以看到这是一个由9x9个面组成的网格，当然，也可以说这是一个由10x10个顶点组成的网格。开始的时候，他们都是被选定的，按 A 取消选择，然后按 C 键，在网格的靠近中间的地方随意移动一下鼠标来选择几个顶点（像刷油漆一样，你刷过的地方的顶点被选中了）， 接下来按 RMB 或者 ESC . 来结束刷式选择模式，接下来，就是见证奇迹的时刻， 试着按 CTRL + NUM+ (选择更多)， 看到了么，发生了什么？靠近原来被选择的顶点的外围一圈的顶点也被选择中！那么，试试 CTRL + NUM− (选择更少)， 你会发现处在已选中区域中那些边缘的顶点从已选状态切换为未选状态。 所有这些都可以在编辑模式下使用，因为它们处于对象模式，但不是“操纵中心点”按钮。 请注意，缩放顶点会缩放它们之间的距离; 顶点本身没有大小，所以它们不会变大或变小。 类似地，旋转顶点仅改变它们相对于枢轴点的方向，因为无特征点本身没有方向。 When trying to produce more natural, organic shapes, moving vertices one by one gets tedious. To produce smoother-looking shapes, you need a mode where, instead of a sharp distinction between selected vertices which are moved and unselected ones that remain where they are, there is a more gradual transition from one to the other, where unselected vertices close to the selection also get some movement. This is where proportional editing comes in. If you look in the “Mesh” menu, you will see two submenus, titled “Proportional Editing” and “Proportional Editing Falloff”. The former turns the mode on and off, the latter controls the choice of falloff function. There is also an icon for it in the header of the default 3D view next to the layer selection. Pressing O will switch between Enable and Disable. The “Proportional Editing” submenu has 3 options: “Disable”, “Enable” and “Connected”. Do you still have the Grid object you created in the “Select More, Select Less” section above? If not, add a fresh Grid object. Switch to Edit mode, and ensure that just a few vertices in the middle are selected. Enable proportional editing, and now use G to move the selected vertices. You should notice 2 things: unselected vertices near the selected ones also move, and there is a white circle enclosing all the vertices that undergo any movement. Try using the mouse wheel while moving the vertices, and you will see the white circle grow or shrink, and the region of influence of the proportionality grow or shrink correspondingly. Also try different falloff functions in the “Proportional Editing Falloff” submenu; some ensure that the mesh stays smooth and curvy, others give a more angular effect, and so on. The third option to “Disable” and “Enable” proportional editing is “Connected”. This one makes a difference in more complicated meshes, which might have folds or concavities in them. In this situation, “Enable” affects all vertices within a particular distance of the selected ones, while “Connected” only measures the distance via connected edges, rather than directly through space. This lets you move one part of the mesh without affecting another part which might be located nearby purely as a result of a fold. Of course, proportional editing works with scale S and rotate R operations as well. Now, let’s try deleting parts of a mesh. This is the menu that comes up when you press X or DEL when editing a mesh; we will concentrate for now on the first three items. 現在讓我們嘗試刪除網格的某些構成部分。當你在編輯一個網格物件時，按下 X 或 DEL 會看見如左圖的選單。我們現在專注於前三個選項。 First of all, go into face-select mode. Select just one face of the default cube, press the delete key, and select “Faces”. As shown in these screenshots, the selected face should disappear. 首先，使用 CTRL + TAB 進入面選擇模式( face-select mode )，從預設的立方體選擇一個面，按下 DEL 鍵並選擇面( Faces )。如擷圖所示，剛才選擇的面( face )已經消失了。 Use CTRL + Z to undo your previous deletion. Now go into edge-select mode. Select just one edge this time. Press delete again, this time select “Edges”. As the screenshots show, the selected edge disappears, but the faces bordering that edge also disappear. Faces cannot exist without their bordering edges! 使用 CTRL + Z 還原( undo )你剛才執行的刪除操作。現在進入線選擇模式( edge-select mode )。選擇一條線( edge )，並再次按下 DEL 鍵並選擇線( Edges )。如擷圖所示，剛才選擇的線( edge )已經消失了，然而，以該線條為邊界的面也跟著消失了──失去邊界的面便無法存在。 Use CTRL + Z to undo your previous deletion again. Go into vertex-select mode. Select just one vertex, make sure it’s the one closest to you so you get the best view of the effect. Press delete, and select “Vertices”. Not only does the selected vertex disappear, but also the edges connected to that vertex—edges cannot exist without their endpoint vertices. And since those edges disappeared, the faces that were depending on them to be their borders had to be deleted as well. 使用 CTRL + Z 還原( undo )你剛才執行的刪除操作。現在進入端點選擇模式( vertex-select mode )。選擇一個端點( vertex )──為了取得最好的觀察視野，請確保它是距離你最近的一個端點。按下 DEL 鍵並選擇端點( Vertices )。不只是選擇的端點( vertex )消失，與其相連的線( Edges )亦然──失去終點的線段便無法存在。同理，以消失的線( edge )作為邊界的面( face )也必然一起被刪除。 So, to recap: You can undo your last Edit-mode operation with CTRL + Z , and undo your undo with CTRL + SHIFT + Z , similarly to Object mode. However, Edit mode maintains its own undo stack, separate from the Object-mode one; to undo/redo an Edit-mode operation, you must be in Edit mode, not Object mode. 你可以使用 CTRL + Z 還原( undo )在「編輯模式」下最後的操作；此外，你可以透過 CTRL + SHIFT + Z 重作( redo )已被還原的動作──類似在「物件模式」中的操作；然而，「編輯模式」與「物件模式」均各自管理其還原紀錄堆疊。要還原( undo )或重作( redo )一個在「編輯模式」下的操作步驟，你必須在「編輯模式」中，而非「物件模式」。 Back to the default cube, and Edit mode. Ensure you are in vertex-select mode, with nothing selected. Left-click with the control key down ( CTRL + LMB ) somewhere near the cube. Do you see a little orangey-yellow dot appear where you clicked? You just added a new, unconnected vertex to the mesh. Undo your addition ( CTRL + Z ). Select an existing vertex with RMB . Now CTRL + LMB to add a new vertex again, and you will notice that it is connected to the previously-selected vertex by a newly-added edge as well. Since the newly-added vertex is now the selected vertex, doing CTRL + LMB again at another position, and so on repeatedly, lets you construct a whole chain of new edges in this way. But what good are edges and vertices without faces? To construct a face, you need a closed loop of edges. To close a loop of edges, select all the vertices in the chain, and press F ; this will add another edge joining the first and last vertex into a complete loop of edges, and at the same time it will fill in the loop with a new face. Alternatively, if you just wanted to close the loop without filling in the face, then select only the first and last vertex in the chain before pressing F ; since only two vertices are selected, this will not construct a new face, it will only add an edge joining those vertices. You can also extrude entire new sections of mesh with a single click in this way. Try selecting two adjacent corner vertices of the cube (i.e. ones joined by an edge). Now CTRL + LMB near to them, and you will see you’ve created two more vertices, joined to the previous two by a new face. CTRL + LMB again, and you can construct a whole sheet of new mesh in this way. Undo all your additions, and get back to the pristine cube. Now select all four vertices of a single face. CTRL + LMB near to your selection, and now you have added four new vertices (corresponding to the original four you selected), plus a new face connecting them, plus four new faces connecting them to the original four. (You may not notice it, but the original face formed from the original four vertices has been removed as well.) Another CTRL + LMB does the same thing again. So with just a few clicks, you started with a cube and ended up with something (see at right) that is starting to resemble—who knows? A square-cross-sectioned piece of somewhat wonky-looking pipe, perhaps? It is possible to remove vertices without leaving holes behind in the mesh, by merging two or more vertices into one. Select the vertices you want to merge, and press ALT + M ; a menu will popup with some options, including whether to position the resulting vertex in the middle of the ones being merged, or at the position of the first or last one you selected. The resulting vertex inherits all the edges that were connected to the vertices being merged, as well as the faces connected between those edges. Alternatively, sometimes an operation might create duplicate vertices in exactly the same positions, or very close together. You can merge these en masse by ensuring you have selected all possible candidate vertices (e.g. the whole mesh), bringing up the Vertex Specials menu ( W ) and selecting the “Remove Doubles” item. Look for a message to flash up briefly in the Info window, saying “Removed n vertices”; if n is 0, then nothing was done. But if you look in the lower left of the Toolshelf, you will see a “Remove Doubles” panel has appeared, with a “Merge Distance” slider that governs the maximum distance allowed between vertices that are merged; change this value as appropriate (either by clicking on the left- and right-arrows, or by clicking and typing in a new value and pressing ENTER ), and the Remove Doubles operation is immediately redone, and a new message will flash up indicating how many vertices were removed this time. Simply keep on adjusting the value until you are satisfied that you haven’t removed too many or too few vertices. |
藥物化學/抗癌藥/Anthracyclines and Anthracenediones/Mitoxantrone 正電胺基側基與DNA骨架帶有負電磷酸結合，與L-daunosamine上胺基的作用相同 |
WebQuest網路探究/運用網路探究在學習成效的研究分析 前面幾章介紹了WebQuest如何操作，此章將藉由整理已發表相關研究論文，探究學生實際運用WebQuest在學習上之成效。 根據台南科技大學資管系講師陳玉婷所撰寫「影響網路學習成效之相關研究—以南部某科技大學為例」之論文研究，學習成效泛指學習者經過一段時間學習後，所進行的某種形式上評量之表現（詹秉鈞，2002、謝孟穎，2003）。觀其內容所引用關於學習成效之文獻與作者自身之歸納，我們得知，學習成效可從兩大層面衡量。 (一)學習滿意度 學習滿意可做為學生參與學習活動動機和參與學習結果之指標，此指標代表學生在學習過程中的滿意程度，可能影響之因素包括學生個人、教師、課程與學習環境等。 (二)課程測驗成績 學習成效主要是以課後之測驗成績為衡量依據，藉以觀測學生在學習之後，對於課程內容之認知程度是否有所改變與增進。 網路探究目前被許多教師嘗試多方面施行於各個領域，觀察研究其成效，以下是觀察數篇論文後的整理，包括網路探究之學習施行於數學、英文、自然、社會、電腦資訊科技學習和藝術與人文等不同科目中的學習成效。 (一) 文章：《網路教學輔助教室學習實施模式對學習成效影響之研究─以高一數學為例》 在高雄師範大學資教所副教授孫培真與高雄師範大學資教所研究生黃建晃的研究中，將網路探究教學方法施行於高中數學領域的課程中，同時採用質量並行，質的方面為對兩班實驗組之高、中、低分群各選取一名學生晤談；量的方面為同時對三班進行「數學學期成就前後測」。 研究結果為針對整體學生而言，無論課前課後，採取網路教學搭配傳統教學之學習成效，均優於只採取傳統教學模式，尤其針對高中一年級高分群與中分群學生之數學學習成就是較有幫助的，咎其原因，根據學生晤談資料顯示，高分群學生能夠具有較佳之學習成效，乃因其回家後得以重複播放、學習，進而強化其學習效果；低分群學生則因為學習態度較為被動，即使教學模式改變，仍無法建構自己的學習興趣與概念，甚而被網路所誘惑。 亦即對低分組的學生而言，學習成效低落的因素在於缺乏對該科目之興趣，故難以配合網路探究學習之任務發展，而無法展現出網路探究之成效。 (一) 文章：《WebQuest教學策略對國小學生問題解決、英語學習成就及學習動機之影響》 成功大學李杏芳的研究中，針對就讀於一所資訊教育種子學校的三個班級96位小學六年級的學生，實施為期21週的WebQuest教學；欲探討WebQuest教學策略對於國小學生在問題解決、英語學習成就及學習動機之影響，並調查學生及教師對於WebQuest之觀點。 其研究結果發現：資訊科技、合作學習、時間管理和提供資源或不提供資源都會是影響WebQuest的成效。而WebQuest有助於學生在網路搜尋技巧、學習內容、英語學習、電腦技能及上台報告技巧的發展。 (一) 文章：《施行WebQuest教學模式對不同學習風格學生科學學習成效之影響》 在2009年屏東教育大學學報中，陳明慧幾位老師做了這份研究，在七年級學生身上，施行自然領域的網路探究教學，企圖了解網路探究在七年級不同學習風格學生的學習成效如何？且與傳統資訊融入教學學習成效做比較。對照組的學生則以一般較傳統的資訊融入上課方式，包含利用教學錄影帶、課堂教師以PowerPoint講解課程，學生回家簡報的製作，然後學生上台進行全班的報告。實驗組與對照組全班皆採異質小組分組，且其常規以及小組競賽各方面的規定皆相同。 結論：學生對於在自然課使用電腦搜尋資料完成任務，均呈現正向回應，並且認為收穫很多，也讓學生對學習自然更有興趣。而且，這些任務類型很多都是小組任務。即使是個人任務，也需要與小組進行互動。且個人得分會併入小組競賽，所以，每位學生都在時間內就將任務完成，並且呈現出作品。此與在課室中繳交作業的鬆散情形大為不同。因此，使學生在學習動機以及學習習慣的向度上有所成長。 學生普遍認為網路資料搜尋能力有增加，也認為解決問題的能力有增加。經由WebQuest教學後，他們更會搜尋資料，與提升問題解決的能力，同時也改變了他們的學習習慣。 (二) 文章：《具自律學習輔助機制的網路探究學習系統之研究》 由國立台灣師範大學工業科技教育系與國立暨南國際大學通識教育中心的蕭顯勝等老師，以小學六年級學生為實驗對象，讓學習者在課堂上進行網路探究學習，並利用本系統記錄課堂學習歷程。屬於自然與生活科技領域的教學，以環保肥皂課程教材進行為期五週之網路探究學習教學實驗。 本研究以高自律程度與低自律程度在一般的網路探究學習為主，探究任務的成績呈現顯著差異，顯示低自律程度學習者進行網路探究學習時不易完成任務的要求，透過本研究之具自律學習輔助機制，確實能輔助低自律程度學習者完成探究任務，使其探究任務的成績與高自律程度學習者間無顯著差異。但對於網路探究在自然領域上學習成效如何，並未特別嚴明。 (三) 文章：《美國網路探究課程對台灣學生學習科學之成效》 張欣怡老師於2009年中華民國第25 屆科學教育學術研討會發表此篇研究，其研究分別實行網路探究於國中「氫燃料汽車」課程與國小「溫度與熱」課程，及探討網路探究對於台灣學生自然領域之學習成效。 結果在這九個實驗班級中，接近八成（78%）使用TELS 課程明顯增進學生的測驗成績；而如前述，本研究之測驗係測量學生的課程目標概念與科學探究如實驗設計與解釋能力。因此，使用TELS 課程對七個班級的學生平均而言可以促進其科學概念的理解與培養科學探究的能力。即在自然領域中，網路探究的教學法，對於學生之科學概念與探究能力的發展有顯著助益。 (一) 文章：《WebQuest學習活動對國小六年級社會領域學生學習態度與學習成就之研究》 屏東教育大學張安臨在此研究中，以在屏東的兩班小六學生為研究對象，其中一班採傳統式教學法，另一班則利用作者自行設計之WebQuest教材實施學習活動，以此比對兩組同學，在學習態度與學業成就上的差異，並訪談學生對於WebQuest學習活動實際想法。 唯研究結果顯示：兩組學生在學業成就與學業態度上皆無明顯差異。 實驗組學生在使用網路探究學習後，大部分同學表示較喜歡傳統教學，認為傳統教學方式學習成效比WebQuest教學方式好。研究發現雖然班級學生資訊能力均能應付WebQuest教學法，且合作學習的方式對學生的學習是有幫助的，同學們也樂意用小組合作學習，但學生仍希望用傳統教學方式上課。 (一) 文章：《探究式網路學習對中學生學習之影響》 在民國九十四年期刊東海科學第七卷中，李宜靜等老師，在計算機概論的課程中，將網路探究施行於高中二年級的學生， 該研究顯示：探究式網路學習可以使得學生對計算機概論課程產生較多興趣，同時學生也對課程的重要性與效用持較肯定的態度。探究方式對學習任務價值的影響達到顯著水準。 (二) 文章：《影響網路學習成效之相關研究—以南部某科技大學為例》 台南科技大學資管系講師陳玉婷的研究，以南部某科技大學修習「電腦與資訊應用」課程的部份大一新生為樣本，施行網路探就的學習，將學習型態、學習動機、電腦先備素養等定義為自變項，學習成效為其依變項，再根據文獻分析、統計檢定、問卷調查等方法進行其間之相關性分析。 研究結果指出：學習型態、學習動機、電腦先備素養與學習成效的相關分析：三者自變項中彼此具有正相關。電腦先備素養的高低程度不同在學習成效上是具有顯著的差異，電腦先備素養程度較高者比程度較低者具較好的表現。學習型態、學習動機與電腦先備素養對於學習成效的影響力：参者變項當中，以「學習動機」對於學習成效最具影響力。 故，根據此研究結果，作者更進一步提出下列建議：(1) 教師在規畫教學時，能夠明確而有意義的闡述目標，讓學生能夠自發產生學習興趣。因為再好的學習方法皆應配合學生的學習興趣，才能發會最大的成效(2) 設計積極的合作學習環境，並對於學習結果給予建議或改善等具體回饋。(3) 建構一套學習輔導系統，更深入了解學生個人學習特質與背景，以提升其學習成效。 (一) 文章：《應用web quest在國民中學藝術與人文領域學生學習動機與成效之研究─以歌仔戲欣賞教學為例》 淡江大學教育科技學系研究生吳品萱同學，在其學位論文中，分別針對十個九年級班級學生，實行六週的網路探究課程，研究結果後，修正課程內容再對一個八年級學生，實行七週九節課程做出的研究。 發現：在學習動機方面，大多數學生對於WebQuest的學習方是有正向的看法，覺得此種學習方法創新有趣，且具有挑戰性，完成任務後能帶給他們成就感，故認為此種學習方式有句體的努力目標與方向，覺得很歡，而對學生學習動機之提升有顯著之幫助。 且研究也顯示，學生對於在自己動手所查詢的資料與小組合作中的學習內容，印象較深刻、不易忘記，另外WebQuest的學習方式也能有效提升學生原本認知程度較差、或較抽象之概念的學習成效；但對於學生原本認知度高，或具體的學習項目，學習成效並無明顯提升。 多數學生皆能認真的參與WebQuest任務式的合作學習，結束後也表現出高度願意再嘗試的意願，但也有少部分學生認為此種學習方是很麻煩，不願再使用。 課堂討論時間不足是學生在學習歷程中，遭遇到最大的困難，因為施行於九年級的課程中，該階段之學生課業壓力繁重，課餘時間有限，對於小組合作之協調有一定的困難度。 目前在各領域皆有使用WebQuest網路探究教學策略之研究，尤其以自然與生活科技領域和電腦資訊科技學習方面的研究最為豐富，在各領域共同的研究結果指出，學習動機仍是影響WebQuest教學策略之學習成效的最大因素，在數學領域、英文領域中，當學生對於科目興致缺缺，則設計完善的WebQuest任務也無法發揮其功效，在社會領域方面，可能研究對象為國小學生，年齡尚幼，缺乏對資訊、知識理解、綜合、判斷組織的高層次能力，故成效亦不佳，多數學生表示較喜歡傳統教學法。 在藝術與人文領域的研究，可發現學生的課業壓力也是影響WebQuest施行成效的關鍵，當學生課業繁忙，缺乏課餘時間討論、收集資料時，對於非考試科目之藝能科的學習興趣降低，WebQuest任務型的學習方式就是一種擾民的學習。但在八年級的學生眼中，用此種活潑、創新、生動的學習方式，可以帶給他們成就感、提升他們學習的意願，且對於原本認知程度較差的學生有提升學習成效的效果。對於抽效概念的學習也很有幫助。 故在實行WebQuest網路探究教學策略時，要考慮到學生的年紀、認知思考能力、時間，並盡可能提升學生對於該科目領域學習之動機，才能發會較優的學習成效。 （一）成大：蘇美菁 〈WebQuest教學策略對國小高年級學童高層是思考與學習動機之影響〉 1.研究對象與方法 作者以台南市東光國小六年級三個班級（兩班音樂班、一般普通班）進行實驗操弄，資料蒐集採量化與質化方式進行，將教學策略分成三項，分別為：傳統教學、WebQuest-未提供資源、WebQuest-有提供資源。 2.研究目標 測驗這些接受不同教學策略的學生，在「高層次思考」上（包括：批判思考能力和問題解決能力）的差異，以及「學習動機」上的差異。 3.實驗結果 (1)電腦背景狀況與網路技能結果 三組學生接觸電腦時間並無明顯差異，家中有電腦的比例、可上網的比例分佈、學生平均一週上網時數都很接近，亦無差異。而各組同學的電腦基本技能與網路能力亦無差異。 (2)高層次思考能力結果 在批判思考能力方面，三組間無顯著差異；另外在問題解決能力，WebQuest-有提供資源組之學生能力最高，次之為傳統教學組，最後則為WebQuest-未提供資源組學生。 (3)學習動機結果 三組學習動機並無顯著差異。 (4)訪談結果 （二）屏教大：張安臨 〈WebQuest學習活動對國小六年級社會領域學生學習態度與學習成就之研究〉 1.研究對象與方法 以屏東的兩班小六學生為研究對象，其中一班採傳統式教學法，另一班則利用作者自行設計之WebQuest教材實施學習活動。 2.研究目的 以此比對兩組同學，在學習態度與學業成就上的差異，並訪談學生對於WebQuest學習活動實際想法。 3.研究結果 兩組學生在學業成就與學業態度上皆無明顯差異。 訪談實驗組學生表示： 1. 較喜歡傳統教學 2. 認為傳統教學方式學習成效比WebQuest教學方式好 3. 學生資訊能力均能應付WebQuest教學法 4. 合作學習的方式對學生的學習是友邦 住的 5. 大部分學生喜歡小組合作學習 6. 學生希望用傳統教學方式上課 屏教大：陳明慧 楊子瑩 林凱胤 王國華 〈施行WebQuest教學模式對不同學習風格學生科學學習成效之影響〉 1.研究對象 七年級 領域：自然與生活科技教學(演化、生物與環境以及生物多樣性) 2.研究方法 對照組的學生則以一般較傳統的資訊融入上課方式，包含利用教學錄影帶、課堂教師以PowerPoint講解課程，學生回家簡報的製作，然後學生上台進行全班的報告。 實驗組與對照組全班皆採異質小組分組，且其常規以及小組競賽各方面的規定皆相同。 3.研究目標 (1)以WebQuest教學進行自然與生活科技教學，對七年級不同學習風格學生的學習成效如何？並與傳統資訊融入教學學習成效做比較。 (2)以WebQuest教學進行自然與生活科技教學，對七年級不同學習風格學生學習環境的態度包含電腦焦慮、學習動機、電腦喜好、學習習慣影響為何？並與傳統資訊融 入教學做比較。 4.研究結果 不同學習風格的學生之間成就測驗並無顯著差異。亦即表示施行WebQuest教學，均可讓各種不同學習風格的學生有所收穫，並無偏好任何一種學習風格的學生。由此可知WebQuest是一種可以廣為使用的教學模式，適用於所有的學生。 在第一單元不同學習風格學生經過教學後，調整過的成就測驗後測成績為調適者＞發散者＞收斂者＞同化者。在第二單元以及第三單元不同學習風格學生經過教學後，調整過的紙筆成就測驗後測成績為發散者＞收斂者＞調適者＞同化者。 （一）高師大：黃建晃 〈網路教學輔助教室學習實施模式對學習成效影響之研究─以高一數學為例〉 1.研究對象 以某入學分數在高雄市各公立學校中屬於中等程度之高中一年級學生作為研究樣本，隨機取樣二個班，使之成為實驗組，再選取另一班為對照組。 2.研究方法 以準實驗研究法為主，但同時採用質量並行，質的方面為對兩班實驗組之高、中、低分群各選取一名學生晤談；量的方面為同時對三班進行「數學學期成就前後測」。 3.研究目標 (1)探究「網路教學(E-learning)」的相關理論與研究。 (2)探究學生於課前預習時使用「網路教學」配合「傳統教學」與學生只接受「傳統教學」在高中數學學習成就上的差異。 (3)探究學生於課後複習時使用「網路教學」配合「傳統教學」與學生只接受「傳統教學」在高中數學學習成就上的差異。 (4)探究學生於課前預習時使用「網路教學」配合「傳統教學」與學生於課後複習時使用「網路教學」配合「傳統教學」在高中數學學習成就上的差異。 (5)探究學生於課前預習時使用「網路教學」與課後複習時使用「網路教學」的接受度與相關建議。 4.研究結果 (1) 接受課前預習使用「網路教學」配合「傳統教學」的學生之數學學習成就表現優於只接受「傳統教學」的學生，且已達到統計上的顯著差異。 (2) 接受課前預習使用「網路教學」配合「傳統教學」的學生之數學學習成就表現優於只接受「傳統教學」的學生，且已達到統計上的顯著差異。 (3) 接受課後複習使用「網路教學」配合「傳統教學」的學生之數學學習成就表現優於只接受「傳統教學」的學生，且已達到統計上的顯著差異。 (4) 接受課前預習使用「網路教學」配合「傳統講述教學」的學生之數學學習成就表現優於只接受「傳統講述教學」的學生，且已達到統計上的顯著差異。 (5) 接受課後複習使用「網路教學」配合「傳統講述教學」的學生之數學學習成就表現優於只接受「傳統講述教學」的學生，且已達到統計上的顯著差異。 （二）東海科學第七卷：李宜靜、朱延平、楊朝成 〈探究式網路學習對中學生學習之影響〉 1.研究對象 以高中二年級兩班學生共九十四人為樣本。在計算機概論課程上，以電腦新知為主軸進行主題探究活動。 2.研究方法 假設一：使用探究式網路學習較使用一般探究學習的學生有顯著較佳的自我效能。 假設二：使用探究式網路學習較使用一般探究學習的學生有顯著較佳的學習任務價值。 假設三：主動實驗者較被動觀察者有顯著較佳的自我效能。 假設四：主動實驗者較被動觀察者有顯著較佳的學習任務價值。 假設五：使用探究式網路學習時，主動實驗者較被動觀察者有顯著較佳的自我效能。 假設六：使用探究式網路學習時，主動實驗者較被動觀察者有顯著較佳的學習任務價值。 3.研究結果 實驗結果顯示：採用探究式網路學習的學生之自我效能及學習任務價值，皆顯著優於使用一般探究學習者；不同學習風格的學習者之自我效能及學習任務價值無顯著差異；而探究方式與學習風格之間也無顯著的交互作用；使用探究式網路學習時，主動觀察者較被動觀察者有顯著較佳的學習任務價值。 台南科大：陳玉婷 〈影響網路學習成效之相關研究—以南部某科技大學為例〉 1.研究對象 南部某科技大學修習「電腦與資訊應用」課程的部份大一新生為樣本。 2.研究方法 將學習型態、學習動機、電腦先備素養等定義為自變項，學習成效為其依變項，再根據文獻分析、統計檢定、問卷調查等方法進行其間之相關性分析。 3.研究目標 (1)瞭解學習型態、學習動機、電腦先備素養與學習成效是否有關連？ (2)探討不同的學習型態、學習動機強弱與電腦先備素養程度的高低，在學習成效上是否有顯著的差異表現？ (3)探討學習型態、學習動機與電腦先備素養對於學習成效是否有顯著的影響力？ 4.研究結果 （1）學習型態、學習動機、電腦先備素養與學習成效的相關分析：三者自變項中彼此具有正相關。 （2）不同的學習型態、學習動機強弱與電腦先備素養程度的高低與學習成效的關係。 a.學習型態與學習成效：不同學習型態者在學習成效上具顯著差異，主動參與者學習成效較好。 b.學習動機強弱與學習成效：學習動機愈強者在學習成效表現也愈好。 c.電腦先備素養程度與學習成效：電腦先備素養的高低程度不同在學習成效上是具有顯著的差異，電腦先備素養程度較高者比程度較低者具較好的表現。 （3）學習型態、學習動機與電腦先備素養對於學習成效的影響力：参者變項當中，以「學習動機」對於學習成效最具影響力。 彰師大：楊子瑩、王國華、余安順 〈科學教師試行資訊融入探究教學與學生成效之研究〉 1. 研究對象 共有四位教師參與研究，分別為錢老師、任老師、賈老師、溫老師。 2. 研究方法 質：課程觀察、錄影、晤談、心得及學生學習單。 量：學生學習前後測成績。 3. 研究目標 主要探討四位任教「國中自然與科技課程」的個案教師，修習暑期「資訊融入探究教學」專業成長課程後，回到任教學校，實施教學情形與學生學習成效。 4. 研究結果 (1)、科技的支援與合作討論增進學習的自主性與正向態度。 (2)、學生學習成就前後測的改變。 學習風格是指學生從事學習活動時，經由知覺、記憶、思惟等心理歷程，在外顯行為上表現出帶有認知、情意、生理性質的習慣性特徵 Kolb將四個學習階段分兩相互垂直的構面，一是學習者在接收新資訊時的偏好（Perception），包含具體經驗與抽象概念。具體經驗著重的是具體、有形的經驗；抽象概念著重的則是概念的解釋與符號的呈現。另一個垂直的構面則是指學習者如何處理新知識的方式（Processing），包含主動實驗和省思觀察。主動實驗的是對外在環境的操控，由實作的經驗來學習（learning by doing）；省思觀察則著重個人內在的反應，以看及聽來學習（learning by watching and listening）。 如此可區分四種學習風格：發散者（Diverger）、調適型（Accommodator）、收斂者（Converger）、及同化者（Assimilator）（Smith & Kolb, 1985）。 1.發散者(Diverger)是喜好省思觀察與具體經驗。以圖像或整體觀點來幫助學習，不喜歡同儕互動學習。 2.調適型（Accommodator）是喜好主動實驗與具體經驗。擅長於動手做事情、實現計畫、參與新事物。在理論與情境不相符的情況下，會放棄理論，相信直覺。需要同儕的互動學習。 3.收斂者（Converger）是喜好主動實驗與抽象思考。是實用主義者，善於找到理論的實際應用方式與難題解決方式，以親自實驗的方法獲得知識。且擅長於解決問題、做決策和將想法實際應用。 4.同化者（Assimilator）是喜好省思觀察與抽象概念，是思考者，善於歸納推理及建立理論架構的能力。能同化完全不同的發現，而提出一完整的解釋。 (一) 文章：《施行WebQuest教學模式對不同學習風格學生科學學習成效之影響》 在2009年屏東教育大學學報-教育類，第三十二期中，陳明慧等教師研究以WebQuest教學進行自然與生活科技教學，對七年級不同學習風格學生的學習成效如何，並與傳統資訊融入教學學習成效做比較。 其文獻探討中，羅列諸多相關研究，包括施賀建（2003）研究結果指出，學習風格對學習成效均達到顯著影響，且學習風格與學習方式存在交互效果；林鈺婷（2003）網路輔助教學應用於國小自然學習領域之研究研究中發現，不同學習風格之學生，其自然科學習態度在不同教學方法中沒有顯著差異，而不同學習風格之學生，其自然科學習態度在接受網路輔助教學法與一般教學法間有顯著差異。其中以收斂者以及調適者表現較佳，而且以收斂者表現大於調適者。龔僑立（2007）合作學習、電腦概念構圖與學習風格對自然科學習成效之研究結果顯示，不同學習風格的學童學習成就均無顯著差異。有就是對於WebQuest實行在不同學習風格的學習者身上的成效，正反兩極的研究結果皆有。 而在此篇研究中，與施建賀(2003)、林玉婷(2003)研究結果相似，即不同學習風格的學生之間成就測驗均呈現正向回應，但並無顯著差異。亦即表示施行WebQuest教學，均可讓各種不同學習風格的學生有所收穫，並無偏好任何一種學習風格的學生。由此可知WebQuest是一種可以廣為使用的教學模式，適用於所有的學生。 最初，在不同學習風格學生經過教學後，調整過的成就測驗後測成績為調適者＞發散者＞收斂者＞同化者。學習歷程中後段，不同學習風格學生經過教學後，調整過的紙筆成就測驗後測成績為發散者＞收斂者＞調適者＞同化者。 在最初的學習歷程對所有學習者都是一種新的改變，不論學習風格的特性而言，調適者較屬於隨遇而安型的學習者，而且調適者較喜愛同儕式的學習 其後的教學更開放，在習慣此種教學模式後，對學習風格為發散者的學生而言比較游刃有餘，是一個腦力激盪的機會。而加入設計實驗的動手實驗部分，對偏好主動實驗的收斂者和調適者而言表現也會提升。在紙筆測驗上，整體表現以同化者的表現較不凸顯。 學習風格為同化者學生使用WebQuest教學於動手實驗之開放教學，優於一般使用錄影帶以及PowerPoint教學。 資訊流通、科技日新月異的現代，新興教學方式對於未來教育現場以是不容小覷之趨勢，但於教育實務現場，網路探究之運用與傳統教學之抗衡一直是教學者與學習者所必須共同面對之問題，也是未來欲投入教學工作者必須做的準備。 故本組選擇「網路探究在學習成效的研究分析」為主題，蒐集網路探究在學習成效之分析相關論文文獻，希望藉由文獻資料之分析整理，觀察並同時思考網路融入教學對於學習者在學習成效是否具有正面幫助，與其可能產生之影響為何？ 我們總共蒐集10篇文獻，並將文獻內容分為學習領域、學習者階段、學習風格等三大層面做一分析比較，探討網路探究對於不同階段的學習者、不同學習領域的學習者、與不同學習風格的學習者之學習成效始否有所差異。 本組之論文研究學習者階段橫跨國小、國中、高中與大學，因此，我們便以各領域為應變項，探究學習者在不同學習階段是否會有學習成效之差異，進而得知運用網路探究學習，對於該領域之學習成效之可能結果。 1.自然與生活科技 (1) 「施行WebQuest教學模式對不同學習風格學生科學學習成效之影響」以七年級為研究對象，而其研究結果顯示學生對於WebQuest融入教學呈現正向回應。 (2)「具自律學習輔助機制的網路探究學習系統之研究」之研究對象為小學六年級學生，其研究結果顯示透過網路探究學習，學習者之成績達顯著差異。 (3)「美國網路探究課程對台灣學生學習科學之成效」分別以國小和國中之課程進行研究，顯示了網路探究課程對於多數學生之科學概念有助益。 (4)「科學教師試行資訊融入探究教學與學生成效之研究」亦以國中生為研究對象，研究結果顯示網路探究教學能夠增進學生學習態度與成績表現。 2. 電腦與資訊領域 (1) 「影響網路學習成效之相關研究—以南部某科技大學為例」以大一新生為研究對象，得到學習型態、學習動機、電腦先備素養與學習成效之相互關聯性。 (2) 「探究式網路學習對中學生學習之影響」以高中二年級為樣本，獲得探究式網路學習能夠引發學生興趣，增近期自我效能，與能夠適應學生知個別差異。 因此，我們可以粗略得知，在「自然與生活科技領域」以及「電腦與資訊領域」上，網路探究學習對於學習者會帶來學習態度的轉變或者前後測成績的差異，對於學習者之學習成效是具有正面助益的。 同樣的，本組網羅英語、社會、自然與科技等多元領域，欲探究在某一領域中，學習者學習階段的不同對於其學習成效是否會具有影響，以下，便做進一步之歸納。 1. 國小階段 (1) 從「WebQuest學習活動對國小六年級社會領域學生學習態度與學習成就之研究」之研究結果，我們發現，學生較偏愛傳統教學方式。 (2) 從「WebQuest教學策略對國小學生問題解決、英語學習成就及學習動機之影響」之研究結果，問題解決與英語學習成就有所提升，但於學習動機方面並無顯著差異。 (3) 從「美國網路探究課程對台灣學生學習科學之成效」之研究結果顯示，網路探究課程對於多數學生之科學概念有助益。 (4) 「具自律學習輔助機制的網路探究學習系統之研究」之研究結果顯示透過網路探究學習，學習者之成績達顯著差異。 2. 國中階段 (1) 「科學教師試行資訊融入探究教學與學生成效之研究」之研究結果顯示網路探究教學能夠增進學生學習態度與成績表現。 (2) 「美國網路探究課程對台灣學生學習科學之成效」，顯示了網路探究課程對於多數學生之科學概念有助益。 (3) 「施行WebQuest教學模式對不同學習風格學生科學學習成效之影響」之研究結果顯示學生對於WebQuest融入教學呈現正向回應。 3. 高中階段 (1) 「探究式網路學習對中學生學習之影響」獲得其研究結果為探究式網路學習能夠引發學生興趣，增近期自我效能，與能夠適應學生知個別差異。 (2) 「網路教學輔助教室學習實施模式對學習成效影響之研究─以高一數學為例」之研究結果顯示「網路教學」配合「傳統教學」之學生學習成就表現會達到統計上之顯著差異。 根據文獻資料，我們僅能就特定領域來做一歸納，如「科學」、「電腦科技」等相關領域，學習之學習成效較不因學習者階段之不同而有所差異，但若於「語文」、「社會」等相關領域，小學階段的學習者也許仍較適應傳統教學模式。 當然，我們僅能就本組所蒐集之文獻做一可能之歸納，較嚴謹的結果還是得經過更大量的資料蒐集與統計分析才得以呈現。 1. 「施行WebQuest教學模式對不同學習風格學生科學學習成效之影響」之研究顯示WebQuest之教學可以適用於個別學生的差異。 2. 「影響網路學習成效之相關研究—以南部某科技大學為例」指出學習型態、學習動機與電腦先備素養對於學習成效是有正相關的，尤其以學習動機最具影響力。 3. 「WebQuest教學策略對國小高年級學童高層是思考與學習動機之影響」研究結果顯示在電腦背景與網路技能、高層次思考能力、學習動機等三變項無顯著差異，唯在問題解決能力方面採用WebQuest教學策略之學生能力最高。 由以上論文研究統計，我們可以知道，WebQuest教學策略之採用在不同的變項分析當中，分別具有其不同的優點存在。 綜合論述，我們認為，WebQuest之教學策略具有不可否認之教學上之助益，惟教師是否採用，乃端視教學領域、學生學習方式、以及最重要的學生學習成效之改變等做一全面更加完善之評斷，期能截長補短，萃取WebQuest之以學習者學習角度出發之菁華，設計出兼具實用與學習效益之教學策略，以能達到提促進學生學習滿意度與學習成就表現之提升學習成效之目標。 1.蘇美菁，〈WebQuest教學策略對國小高年級學童高層是思考與學習動機之影響〉。 2.張安臨，〈WebQuest學習活動對國小六年級社會領域學生學習態度與學習成就之研究。 3.陳明慧、楊子瑩、林凱胤、王國華，〈施行WebQuest教學模式對不同學習風格學生科學學習成效之影響〉。 4.黃建晃，〈網路教學輔助教室學習實施模式對學習成效影響之研究─以高一數學為例〉。 5.李宜靜、朱延平、楊朝成，〈探究式網路學習對中學生學習之影響〉。 6.陳玉婷，〈影響網路學習成效之相關研究—以南部某科技大學為例〉。 7.楊子瑩、王國華、余安順，〈科學教師試行資訊融入探究教學與學生成效之研究〉。 8.蕭顯勝、洪琬諦、蔡忠潔，〈具自律學習輔助機制的網路探究學習系統之研究〉。 9.張欣怡，〈美國網路探究課程對台灣學生學習科學之成效〉。 10.吳品萱，〈應用 WebQuest 在國民中學藝術與人文領域學生學習動機與成效之研究：以歌仔戲欣賞教學為例〉。 |
Introducing Julia/Functions 函数是 Julia 代码的构建块(building blocks)，充当其他编程语言中的子例程、过程、块和类似的结构概念。 函数的工作是将一组值作为参数列表并返回值。如果参数包含可变的值(如数组)，则可以在函数中修改数组。按照惯例，感叹号(！)函数结尾处的名称表示该函数可以修改其参数。 定义函数有多种语法： 函数包含单个表达式 函数包含多个表达式 函数不需要名字 要定义一个简单的函数，您所需要做的就是在左边提供函数名和参数，在等于号的右边提供一个表达式。这些就像数学函数： julia> f(x) = x * x f (generic function with 1 method) julia> f(2) 4 julia> g(x, y) = sqrt(x^2 + y^2) g (generic function with 1 method) julia> g(3,4) 5.0 用多个表达式定义函数的语法如下： function functionname(arg1, arg2) expression expression expression ... expression end 下面是一个典型的函数，它调用另外两个函数，然后结束。 function breakfast() maketoast() brewcoffee() end breakfast (generic function with 1 method) 不管最后一个表达式 brewcoffee() 返回的值是什么, breakfast()函数返回值就是这个。 你可以使用 return 关键字来指定一个特定的值来返回。 julia> function paybills(bankbalance) if bankbalance < 0 return false else return true end end paybills (generic function with 1 method) julia> payBills(20) true julia> payBills(-10) false Some consider it good style to always use a return statement, even if it's not strictly necessary. Later we'll see how to make sure that the function doesn't go adrift if you call it with the wrong type of argument. To return more than one value from a function, use a tuple. function doublesix() return (6, 6) end doublesix (generic function with 1 method) julia> doublesix() (6, 6) Here you could write 6, 6 without parentheses. You can define functions with optional arguments, so that the function can use sensible defaults if specific values aren't supplied. You provide a default symbol and value in the argument list: function xyzpos(x, y, z=0) println("$x, $y, $z") end xyzpos (generic function with 2 methods) And when you call this function, if you don't provide a third value, the variable z defaults to 0 and uses that value inside the function. julia> xyzpos(1,2) 1, 2, 0 julia> xyzpos(1,2,3) 1, 2, 3 When you write a function with a long list of arguments like this: function f(p, q, r, s, t, u) ... end 早晚你会可能忘记他们的顺序。 sooner or later, you will forget the order in which you have to supply the arguments. For instance, it can be: f("42", -2.123, atan2, "obliquity", 42, 'x') or f(-2.123, 42, 'x', "42", "obliquity", atan2) You can avoid this problem by using keywords to label arguments. Use a semicolon after the function's unlabelled arguments, and follow it with one or more keyword=value pairs: function f(p, q ; r = 4, s = "hello") println("p is $p") println("q is $q") return "r => $r, s => $s" end f (generic function with 1 method) When called, this function expects two arguments, and also accepts a number and a string, labelled r and s. If you don't supply the keyword arguments, their default values are used: julia> f(1,2) p is 1 q is 2 "r => 4, s => hello" julia> f("a", "b", r=pi, s=22//7) p is a q is b "r => π = 3.1415926535897..., s => 22//7" If you supply a keyword argument, it can be anywhere in the argument list, not just at the end or in the matching place. julia> f(r=999, 1, 2) p is 1 q is 2 "r => 999, s => hello" julia> f(s="hello world", r=999, 1, 2) p is 1 q is 2 "r => 999, s => hello world" julia> When defining a function with keyword arguments, remember to insert a semicolon before the keyword/value pairs. Here's another example from the Julia manual. The rtol keyword can appear anywhere in the list of arguments or it can be omitted: julia> isapprox(3.0, 3.01, rtol=0.1) true julia> isapprox(rtol=0.1, 3.0, 3.01) true julia> isapprox(3.0, 3.00001) true A function definition can combine all the different kinds of arguments. Here's one with normal, optional, and keyword arguments: function f(a1, opta2=2; key="foo") println("normal argument: $a1") println("optional argument: $opta2") println("keyword argument: $key") end f (generic function with 2 methods) julia> f(1) normal argument: 1 optional argument: 2 keyword argument: foo julia> f(key=3, 1) normal argument: 1 optional argument: 2 keyword argument: 3 julia> f(key=3, 2, 1) normal argument: 2 optional argument: 1 keyword argument: 3 Functions can be defined so that they can accept any number of arguments: function fvar(args...) println("you supplied $(length(args)) arguments") for arg in args println(" argument ", arg) end end The three dots indicate the famous splat. Here it means 'any', including 'none'. You can call this function with any number of arguments: julia> fvar() you supplied 0 arguments julia> fvar(64) you supplied 1 arguments argument 64 julia> fvar(64,65) you supplied 2 arguments argument 64 argument 65 julia> fvar(64,65,66) you supplied 3 arguments argument 64 argument 65 argument 66 and so on. Here's another example. Suppose you define a function that accepts two arguments: function test(x, y) println("x $x y $y") end You can call this in the usual way: julia> test(12, 34) x 12 y 34 If you have the two numbers, but in a tuple, then how can you supply a single tuple of numbers to this two argument function? Again, the answer is to use the ellipsis (splat). julia> test((12, 34) ...) x 12 y 34 The use of the ellipsis or 'splat' is also referred to as 'splicing' the arguments: julia> test([3,4]...) x 3 y 4 You can also do this: julia> map(test, [3, 4]...) x 3 y 4 Any variable you define inside a function will be forgotten when the function finishes. function test(a,b,c) subtotal = a + b + c end julia> test(1,2,3) 6 julia> subtotal LoadError: UndefVarError: subtotal not defined If you want to keep values around across function calls, then you can think about using global variables. A function can't modify an existing variable passed to it as an argument, but it can change the contents of a container passed to it. For example, here is a function that changes its argument to 5: function set_to_5(x) x = 5 end julia> x = 3 3 julia> set_to_5(x) 5 julia> x 3 Although the x inside the function is changed, the x outside the function isn't. Variable names in functions are local to the function. But a function can modify the contents of a container, such as an array. This function uses the [:] syntax to access the contents of the container x, rather than change the value of the variable x: function fill_with_5(x) x[:] .= 5 end julia> x = collect(1:10); julia> fill_with_5(x) 5 julia> x 10-element Array{Int64,1}: 5 5 5 5 5 5 5 5 5 5 You can change elements of the array, but you can't change the variable so that it points to a different array. In other words, your function isn't allowed to change the binding of the argument. Sometimes you don't want to worry about thinking up a cool name for a function. Anonymous functions — functions with no name — can be used in a number of places in Julia, such as with map(), and in list comprehensions. The syntax uses ->, like this: x -> x^2 + 2x - 1 which defines a nameless function that takes a argument, calls it x, and returns x^2 + 2x - 1. For example, the first argument of the map() function is a function, and you can define an one-off function that exists just for one particular map() operation: julia> map(x -> x^2 + 2x - 1, [1,3,-1]) 3-element Array{Int64,1}: 2 14 -2 After the map() finishes, both the function and the argument x have disappeared: julia> x ERROR: x not defined If you want an anonymous function that accepts more than one argument, provide the arguments as a tuple: julia> map((x,y,z) -> x + y + z, [1,2,3], [4, 5, 6], [7, 8, 9]) 3-element Array{Int64,1}: 12 15 18 Notice that the results are 12, 15, 18, rather than 6, 15, and 24. The anonymous function takes the first value of each of the three arrays and adds them, followed by the second, then the third. In addition, anonymous functions can have zero arguments, if you use an 'empty' tuple(): julia> random = () -> rand(0:10) #3 (generic function with 1 method) julia> random() 3 julia> random() 1 如果已有一个函数和数组，你可以通过使用 map() 对数组中的每个元素来调用函数。这将会依次对每个元素进行调用并收集结果，返回一个数组。这个过程称之为 映射 (mapping): julia> a=1:10; julia> map(sin, a) 10-element Array{Float64,1}: 0.841471 0.909297 0.14112 -0.756802 -0.958924 -0.279415 0.656987 0.989358 0.412118 -0.544021 map() 返回一个新的数组，但调用 map!() 则会修改原始数组的内容。 通常，不必用 map() 来对数组的每个成员都调用 sin() 函数，因为很多函数本身就自动支持 "元素级别" 的操作, 两种版本的耗时是相当的（ 用 sin.() 可能还有优势，取决于数据规模）: julia> @time map(sin, 1:10000); 0.149156 seconds (568.96 k allocations: 29.084 MiB, 2.01% gc time) julia> @time sin.(1:10000); 0.074661 seconds (258.76 k allocations: 13.086 MiB, 5.86% gc time) map() 会收集结果然后返回一个数组，优势你只是想要 '映射' 操作但并不需要返回一个数组的结果。这样的话，用 foreach(): julia> foreach(println, 1:20) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 此时 ans 是 nothing (ans == nothing 返回 true). 你可以对不止一个数组进行 map() 操作. The function is applied to the first element of each of the arrays, then to the second, and so on. The arrays must be of the same length (unlike the zip() function, which is more tolerant). Here's an example which generates an array of imperial (non-metric) spanner/socket sizes. The second array is just a bunch of repeated 32s to match the integers from 5 to 24 in the first array. Julia simplifies the rationals for us: julia> map(//, 5:24, fill(32,20)) 20-element Array{Rational{Int64},1}: 5//32 3//16 7//32 1//4 9//32 5//16 11//32 3//8 13//32 7//16 15//32 1//2 17//32 9//16 19//32 5//8 21//32 11//16 23//32 3//4 (In reality, an imperial spanner set won't contain some of these strange sizes - I've never seen an old 17/32" spanner, but you can buy them online.) 除了 map()以外, it's possible to apply functions directly to arguments that are arrays. See the section on Broadcasting: dot syntax for vectorizing functions. The map() function collects the results of some function working on each and every element of an iterable object, such as an array of numbers. The reduce() function does a similar job, but after every element has been seen and processed by the function, only one is left. The function should take two arguments and return one. The array is reduced by continual application, so that just one is left. A simple example is the use of reduce() to sum the numbers in an iterable object (which works like the built-in function sum()): julia> reduce(+, 1:10) 55 Internally, this does something similar to this: ((((((((1 + 2) + 3) + 4) + 6) + 7) + 8) + 9) + 10) After each operation adding two numbers, a single number is carried over to the next iteration. This process reduces all the numbers to a single final result. A more useful example is when you want to apply a function to work on each consecutive pair in an iterable object. For example, here's a function that compares the length of two strings and returns the longer one: julia> l(a, b) = length(a) > length(b) ? a : b l (generic function with 1 method) This can be used to find the longest word in a sentence by working through the string, pair by pair: julia> reduce(l, split("This is a sentence containing some very long strings")) "containing" "This" lasts a few rounds, and is then beaten by "sentence", but finally "containing" takes the lead, and there are no other challengers after that. If you want to see the magic happen, redefine l like this: julia> l(a, b) = (println("comparing \"$a\" and \"$b\""); length(a) > length(b) ? a : b) l (generic function with 1 method) julia> reduce(l, split("This is a sentence containing some very long strings")) comparing "This" and "is" comparing "This" and "a" comparing "This" and "sentence" comparing "sentence" and "containing" comparing "containing" and "some" comparing "containing" and "very" comparing "containing" and "long" comparing "containing" and "strings" "containing" You can use an anonymous function to process an array pairwise. The trick is to make the function leave behind a value that will be used for the next iteration. This code takes an array such as [1, 2, 3, 4, 5, 6...] and returns [1 * 2, 2 * 3, 3 * 4, 4 * 5...], multiplying adjacent elements. store = Int[]; reduce((x,y) -> (push!(store, x * y); y), 1:10) julia> store 9-element Array{Int64,1}: 2 6 12 20 30 42 56 72 90 Julia also offers two related functions, foldl() and foldr(). These offer the same basic functionality as reduce(). The differences are concerned with the direction in which the traversal occurs. In the simple summation example above, our best guess at what happened inside the reduce() operation assumed that the first pair of elements were added first, followed by the second pair, and so on. However, it's also possible that reduce() started at the end and worked towards the front. If it's important, use foldl() for left to right, and foldr() for right to left. In many cases, the results are the same, but here's an example where you'll get different results depending on which version you'll use: julia> reduce(-, 1:10) -53 julia> foldl(-, 1:10) -53 julia> foldr(-, 1:10) -5 Julia offers other functions in this group: check out mapreduce(), mapfoldl(), and mapfoldr(). If you want to use reduce() and the fold-() functions for functions that take only one argument, use a dummy second argument: julia> reduce((x, y) -> sqrt(x), 1:4, init=256) 1.4142135623730951 which is equivalent to calling the sqrt() function four times: julia> sqrt(sqrt(sqrt(sqrt(256)))) 1.4142135623730951 You can treat Julia functions in the same way as any other Julia object, particularly when it comes to returning them as the result of other functions. For example, let's create a function-making function. Inside this function, a function called newfunction is created, and this will raise its argument (y) to the number that was originally passed in as the argument x. This new function is returned as the value of the create_exponent_function() function. function create_exponent_function(x) newfunction = function (y) return y^x end return newfunction end Now we can construct lots of exponent-making functions. First, let's build a squarer() function: julia> squarer = create_exponent_function(2) #8 (generic function with 1 method) and a cuber() function: julia> cuber = create_exponent_function(3) #9 (generic function with 1 method) While we're at it, let's do a "raise to the power of 4" function (called quader, although I'm starting to struggle with the Latin and Greek naming): julia> quader = create_exponent_function(4) #10 (generic function with 1 method) These are ordinary Julia functions: julia> squarer(4) 16 julia> cuber(5) 125 julia> quader(6) 1296 The definition of the create_exponent_function() above is perfectly valid Julia code, but it's not idiomatic. For one thing, the return value doesn't always need to be provided explicitly — the final evaluation is returned if return isn't used. Also, in this case, the full form of the function definition can be replaced with the shorter one-line version. This gives the concise version: function create_exponent_function(x) y -> y^x end which acts in the same way. make_counter = function() so_far = 0 function() so_far += 1 end end julia> a = make_counter(); julia> b = make_counter(); julia> a() 1 julia> a() 2 julia> a() 3 julia> a() 4 julia> b() 1 julia> b() 2 Here's another example of making functions. To make it easier to see what the code is doing, here is the make_counter() function written in a slightly different manner: function make_counter() so_far = 0 counter = function() so_far += 1 return so_far end return counter end julia> a = make_counter() #15 (generic function with 1 method) julia> a() 1 julia> a() 2 julia> a() 3 julia> for i in 1:10 a() end julia> a() 14 在 Julia 中函数可以互相组合。 函数组合是指将两个或多个函数应用于参数。你可以使用组合运算符 (∘) 来组合函数。（在 REPL 中使用\circ来打出运算符）。举个例子，sqrt() 和 + 函数组合在一起： julia> (sqrt ∘ +)(3, 5) 2.8284271247461903 先将数字相加，然后计算平方根。 下面这个例子复合了三个函数。 julia> map(first ∘ reverse ∘ uppercase, split("you can compose functions like this")) 6-element Array{Char,1}: 'U' 'N' 'E' 'S' 'E' 'S' 函数链（有时又称为“管道”或者说“用管道来将数据送到下一个函数”）是指将前一个函数的输出应用到后一个函数： julia> 1:10 |> sum |> sqrt 7.416198487095663 其中 sum() 的值 递给 sqrt() 函数。等价于： julia> (sqrt ∘ sum)(1:10) 7.416198487095663 管道能够给一个接受单参数的函数发送数据。如果函数需要多个参数，可以用匿名函数： julia> collect(1:9) |> n -> filter(isodd, n) 5-element Array{Int64,1}: 1 3 5 7 9 A function can have one or more different methods of doing a similar job. Each method usually concentrates on doing the job for a particular type. Here is a function to check a longitude when you type in a location: function check_longitude_1(loc) if -180 < loc < 180 println("longitude $loc is a valid longitude") else println("longitude $loc should be between -180 and 180 degrees") end end check_longitude_1 (generic function with 1 method) The message ("generic function with 1 method") you see if you define this in the REPL tells you that there is currently one way you can call the check_longitude_1() function. If you call this function and supply a number, it works fine. julia> check_longitude_1(-182) longitude -182 should be between -180 and 180 degrees julia> check_longitude_1(22) longitude 22 is a valid longitude But what happens when you type in a longitude in, say, the format seen on Google Maps: julia> check_longitude_1("1°24'54.6\"W") ERROR: MethodError: `isless` has no method matching isless(::Int64, ::UTF8String) The error tells us that the function has stopped because the concept of less than (<), which we are using inside our function, makes no sense if one argument is a string and the other a number. Strings are not less than or greater than integers because they are two different things, so the function fails at that point. Notice that the check_longitude_1() function did start executing, though. The argument loc could have been anything - a string, a floating point number, an integer, a symbol, or even an array. There are many ways for this function to fail. This is not the best way to write code! To fix this problem, we might be tempted to add code that tests the incoming value, so that strings are handled differently. But Julia proposes a better alternative: methods and multiple dispatch. In the case where the longitude is supplied as a numeric value, the loc argument is defined as 'being of type Real'. Let's start again, define a new function, and do it properly: function check_longitude(loc::Real) if -180 < loc < 180 println("longitude $loc is a valid longitude") else println("longitude $loc should be between -180 and 180 degrees") end end Now this check_longitude function doesn't even run if the value in loc isn't a real number. The problems of what to do when the value is a string is avoided. With a type Real, this particular method can be called with any argument provided that it is some kind of number. We can use the applicable() function to test this. applicable() lets you know whether you can apply a function to an argument — i.e. whether there is an available method for the function for arguments with that type: julia> applicable(check_longitude, -30) true julia> applicable(check_longitude, pi) true julia> applicable(check_longitude, 22/7) true julia> applicable(check_longitude, 22//7) true julia> applicable(check_longitude, "1°24'54.6\"W") false The false indicates that you can't pass a string value to the check_longitude() function because there is no method for this function that accepts a string: julia> check_longitude("1°24'54.6\"W") ERROR: MethodError: `check_longitude` has no method matching check_longitude(::UTF8String) Now the body of the function isn't even looked at — Julia doesn't know a method for calling check_longitude() function with a string argument. The obvious next step is to add another method for the check_longitude() function, only this time one that accepts a string argument. In this way, a function can be given a number of alternative methods: one for numeric arguments, one for string arguments, and so on. Julia selects and runs one of the available methods depending on the types of arguments you provide to a function. This is multiple dispatch. function check_longitude(loc::String) # not real code, obviously! if endswith(loc, "W") println("longitude $loc is West of Greenwich") else println("longitude $loc is East of Greenwich") end end check_longitude (generic function with 2 methods) Now the check_longitude() function has two methods. The code to run depends on the types of the arguments you provide to the function. And you can avoid testing the types of arguments at the start of this function, because Julia only dispatches the flow to the string-handling method if loc is a string. You can use the built-in methods() function to find out how many methods you have defined for a particular function. julia> methods(check_longitude) # 2 methods for generic function "check_longitude": check_longitude(loc::Real) at none:2 check_longitude(loc::String) at none:3 An instructive example is to see how many different methods the + function has: julia> methods(+) # 176 methods for generic function "+": [1] +(x::Bool, z::Complex{Bool}) in Base at complex.jl:276 [2] +(x::Bool, y::Bool) in Base at bool.jl:104 ... [174] +(J::LinearAlgebra.UniformScaling, B::BitArray{2}) in LinearAlgebra at /Users/osx/buildbot/slave/package_osx64/build/usr/share/julia/stdlib/v0.7/LinearAlgebra/src/uniformscaling.jl:90 [175] +(J::LinearAlgebra.UniformScaling, A::AbstractArray{T,2} where T) in LinearAlgebra at /Users/osx/buildbot/slave/package_osx64/build/usr/share/julia/stdlib/v0.7/LinearAlgebra/src/uniformscaling.jl:91 [176] +(a, b, c, xs...) in Base at operators.jl:466 This is a long list of every method currently defined for the + function; there are many different types of thing that you can add together, including arrays, matrices, and dates. If you design your own types, you might well want to write a function that adds two of them together. Julia chooses "the most specific method" to handle the types of arguments. In the case of check_longitude(), we have two specific methods, but we could define a more general method: function check_longitude(loc::Any) println("longitude $loc should be a string or a number") end check_longitude (generic function with 3 methods) This method of check_longitude() is called when the loc argument is neither a Real number or a String. It is the most general method, and won't be called at all if a more specific method is available. 在方法定义中可以用到类型信息。以此为例： julia>function test(a::T) where T <: Real println("$a is a $T") end test (generic function with 1 methods) julia> test(2.3) 2.3 is a Float64 julia> test(2) 2 is a Int64 julia> test(.02) 0.02 is a Float64 julia> test(pi) π = 3.1415926535897... is a Irrational{:π} julia> test(22//7) 22//7 is a Rational{Int64} julia> test(0xff) 255 is a UInt8 The test() method automatically extracts the type of the single argument a passed to it and stores it in the 'variable' T. For this function, the definition of T was where T is a subtype of Real, so the type of T must be a subtype of the Real type (it can be any real number, but not a complex number). 'T' can be used like any other variable — in this method it's just printed out using string interpolation. (It doesn't have to be T, but it nearly always is!) This mechanism is useful when you want to constrain the arguments of a particular method definition to be of a particular type. For example, the type of argument a must belong to the Real number supertype, so this test() method doesn't apply when a isn't a number, because then the type of the argument isn't a subtype of Real: julia> test("str") ERROR: MethodError: no method matching test(::ASCIIString) julia> test(1:3) ERROR: MethodError: no method matching test(::UnitRange{Int64}) Here's an example where you might want to write a method definition that applies to all one-dimensional integer arrays. It finds all the odd numbers in an array: function findodds(a::Array{T,1}) where T <: Integer filter(isodd, a) end findodds (generic function with 1 method) julia> findodds(collect(1:20)) 10-element Array{Int64,1}: 1 3 5 7 9 11 13 15 17 19 but can't be used for arrays of real numbers: julia> findodds([1, 2, 3, 4, 5, 6, 7, 8, 9, 10.0]) ERROR: MethodError: no method matching findodds(::Array{Float64,1}) Closest candidates are: findodds(::Array{T<:Integer,1}) where T<:Integer at REPL[13]:2 Note that, in this simple example, because you're not using the type information inside the method definition, you might be better off sticking to the simpler way of defining methods, by adding type information to the arguments: function findodds(a::Array{Int64,1}) findall(isodd, a) end But if you wanted to do things inside the method that depended on the types of the arguments, then the type parameters approach will be useful. |
藥物化學/抗癌藥/Purine 拮抗劑：amidophosphoribosyl 轉移酶抑制劑 速率限制酵素：amidophosphoribosyl transferase (又稱 phosphoribosylpyrophosphate amido transferase） 降低活化核苷酸轉運酶 缺少活化藥物的HGPRT酵素 Mercaptopurine Thioguanine |
藥物化學/抗癌藥/Pyrimidine 拮抗劑：dTMP 合成抑制劑 速率限制酵素：Thymidine 合成酶 Fluorouracil Floxuridine Capecitabine Methotrexate Pemetrexed Pralatrexate |
Introducing Julia/Controlling the flow 通常，Julia程序的每一行都是依次计算的。有多种方法可以控制和修改评估流程。它们与其他语言中使用的结构相对应： 三元 复合表达式 布尔转换表达式 if elseif else end - 条件求值 for end - 迭代求值 while end - 迭代条件求值 try catch error throw 异常处理 do 代码块 通常，如果某个条件为真，您会希望执行job A (或调用函数A)，如果不是，则希望执行 job B(函数B)。写流程控制最快的方法是使用三元运算符("?" 和 ":")： julia> x = 1 1 julia> x > 3 ? "yes" : "no" "no" julia> x = 5 5 julia> x > 3 ? "yes" : "no" "yes" 下面是另一个例子： julia> x = 0.3 0.3 julia> x < 0.5 ? sin(x) : cos(x) 0.29552020666133955 Julia 返回 sin(x) 的值， 因为 x 小于 0.5. cos(x) 根本没有被计算求值。 布尔运算符使您可以在条件为真时对表达式求值。可以使用 && 或 || 组合条件和表达式。&& 表示“和”，而 || 表示“或”。由于 Julia 逐个计算表达式，因此仅当前一个条件为 true 或 false 时，才能轻松安排对表达式求值。 下面的示例使用一个 Julia 函数，该函数根据数字是否为奇数返回 true或 false ：isodd(n)。 对于 &&，这两个部分都必须是 true ，所以我们可以这样写： julia> isodd(1000003) && @warn("That's odd!") WARNING: That's odd! julia> isodd(1000004) && @warn("That's odd!") false 如果第一个条件(数字为奇数)为真，则计算第二个表达式。如果第一个不为真，则不对表达式求值，只返回条件。 另一方面，使用 || 运算符： julia> isodd(1000003) || @warn("That's odd!") true julia> isodd(1000004) || @warn("That's odd!") WARNING: That's odd! 如果第一个条件为 true，则不需要对第二个表达式求值，因为我们已经有“或”所需的一个真值，并且它返回值true。如果第一个条件为false，则对第二个表达式求值，因为该表达式可能被证明为真。 这类求值也称为“短路求值”。 对于更一般和传统的条件执行方法，您可以使用 if, elseif 和 else。如果您习惯使用其他语言，请不要担心空格、大括号、缩进、括号、分号或诸如此类的东西，但请记住使用end完成条件的构造。 name = "Julia" if name == "Julia" println("I like Julia") elseif name == "Python" println("I like Python.") println("But I prefer Julia.") else println("I don't know what I like") end elseif 和 else 的这部分是可选的： name = "Julia" if name == "Julia" println("I like Julia") end 别忘了 end! "switch"和"case"语句呢？emmmm，你不需要学习这些语法，因为他们不存在！ 有一个 ifelse 函数。看起来是这样的： julia> s = ifelse(false, "hello", "goodbye") * " world" ifelse 是一个普通函数，它计算所有参数，并根据第一个参数的值返回第二个或第三个参数。使用条件 if 或 ? ... :，只对所选路由中的表达式求值。或者，也可以这样: julia> x = 10 10 julia> if x > 0 "positive" else "negative or zero" end "positive" julia> r = if x > 0 "positive" else "negative or zero" end "positive" julia> r "positive" 遍历一个列表或一组值或从起始值到终止值都是迭代的样例，而 for ... end 构造可以让您遍历许多不同类型的对象，包括范围、数组、集、字典和字符串。 下面是通过一系列值进行简单迭代的标准语法： julia> for i in 0:10:100 println(i) end 0 10 20 30 40 50 60 70 80 90 100 变量 i 依次获取数组中每个元素的值(它是从 Range 对象构建的)：这里以10为步长从0到100。 julia> for color in ["red", "green", "blue"] # an array print(color, " ") end red green blue julia> for letter in "julia" # a string print(letter, " ") end j u l i a julia> for element in (1, 2, 4, 8, 16, 32) # a tuple print(element, " ") end 1 2 4 8 16 32 julia> for i in Dict("A"=>1, "B"=>2) # a dictionary println(i) end "B"=>2 "A"=>1 julia> for i in Set(["a", "e", "a", "e", "i", "o", "i", "o", "u"]) println(i) end e o u a i 我们还没有见过集和字典，但是遍历它们是完全一样的。 可以遍历二维数组，从上到下逐步“向下”遍历第1列，然后遍历第2列，依此类推： julia> a = reshape(1:100, (10, 10)) 10x10 Array{Int64,2}: 1 11 21 31 41 51 61 71 81 91 2 12 22 32 42 52 62 72 82 92 3 13 23 33 43 53 63 73 83 93 4 14 24 34 44 54 64 74 84 94 5 15 25 35 45 55 65 75 85 95 6 16 26 36 46 56 66 76 86 96 7 17 27 37 47 57 67 77 87 97 8 18 28 38 48 58 68 78 88 98 9 19 29 39 49 59 69 79 89 99 10 20 30 40 50 60 70 80 90 100 julia> for n in a print(n, " ") end 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 您可以使用 = 代替 in. 当您在数组上迭代时，每次循环中都会检查数组，以防它发生更改。一个你应该避免犯的错误是使用 push! 使数组在循环中增长。仔细运行以下文本，当您看到足够多的内容时准备使用 Ctrl-C(否则您的计算机最终会崩溃)： julia> c = [1] 1-element Array{Int64,1}: 1 julia> for i in c push!(c, i) @show c sleep(1) end c = [1,1] c = [1,1,1] c = [1,1,1,1] ... 遍历每个项目的变量，即“循环变量”，仅存在于循环内部，并在循环结束后立即消失。 julia> for i in 1:10 @show i end i = 1 i = 2 i = 3 i = 4 i = 5 i = 6 i = 7 i = 8 i = 9 i = 10 julia> i ERROR: UndefVarError: i not defined 如果要记住循环之外的循环变量的值(例如，如果必须退出循环并需要知道所达到的值)，请使用 global 关键字定义一个比循环更持久的变量。 julia> for i in 1:10 global howfar if i % 4 == 0 howfar = i end end julia> howfar 8 在这里，howfar 在循环之前是不存在的，但是当循环结束时，它存活了下来，讲述了它的故事。如果 howfar 在循环开始之前已存在，则仅当在循环中使用全局时才能更改其值。 在REPL中工作与在函数中编写代码略有不同。在函数中，您可以这样写： function f() howfar = 0 for i in 1:10 if i % 4 == 0 howfar = i end end return howfar end @show f() 8 类似地，如果您在循环中声明一个新变量，则该变量在循环完成后将不复存在。在此示例中，k 是在以下位置创建的： julia> for i in 1:5 k = i^2 println("$(i) squared is $(k)") end 1 squared is 1 2 squared is 4 3 squared is 9 4 squared is 16 5 squared is 25 因此它在循环完成后不存在： julia> k ERROR: UndefVarError: k not defined 在循环的一个迭代中创建的变量在每次迭代结束时都会被忘记。在此循环中： for i in 1:10 z = i println("z is $z") end z is 1 z is 2 z is 3 z is 4 z is 5 z is 6 z is 7 z is 8 z is 9 z is 10 每次都会重新创建 z。如果希望变量从一个迭代持续到另一个迭代，它必须是全局的： julia> counter = 0 0 julia> for i in 1:10 global counter counter += i end julia> counter 55 要更详细地了解这一点，请考虑下面的代码。 for i in 1:10 if ! @isdefined z println("z isn't defined") end z = i println("z is $z") end 也许您只期望第一个循环产生“z未定义的错误”？事实上，即使 z 是在循环体中创建的，在下一次迭代开始时也没有定义它。 z isn't defined z is 1 z isn't defined z is 2 z isn't defined z is 3 z isn't defined z is 4 z isn't defined z is 5 z isn't defined z is 6 z isn't defined z is 7 z isn't defined z is 8 z isn't defined z is 9 z isn't defined z is 10 再说一遍，使用 global 关键字强制 z 在创建后在循环之外可用： for i in 1:10 global z if ! @isdefined z println("z isn't defined") else println("z was $z") end z = i println("z is $z") end z isn't defined z is 1 z was 1 z is 2 z was 2 ... z is 9 z was 9 z is 10 如果您在全局范围内工作，虽然 z 现在任何地方都可用，值为10。 although, if you're working in global scope, z is now available everywhere, with the value 10. 这种行为是因为我们在 REPL 工作。通常更好的做法是将代码放在函数中，在函数中不需要将从循环外部继承的变量标记为全局变量： function f() counter = 0 for i in 1:10 counter += i end return counter end julia> f() 55 有时，在特定的迭代中，您可能希望跳到下一个值。您可以使用 continue 跳过循环中的其余代码，并使用下一个值再次启动循环。 for i in 1:10 if i % 3 == 0 continue end println(i) # this and subsequent lines are # skipped if i is a multiple of 3 end 1 2 4 5 7 8 10 这一概念只是产生和收集项目的一种方式。在数学界，你会这样说： "设S是所有元素n的集合，其中n大于或等于1，小于或等于10。" 在Julia中，您可以这样写： julia> S = Set([n for n in 1:10]) Set([7,4,9,10,2,3,5,8,6,1]) [n for n in 1:10] 的结构被称为 数组推导 或 列表推导 ("comprehension"，意思是“得到一切”，而不是“理解”)。外面的方括号将通过 计算放置在 for 迭代之前的表达式 而生成的元素集合在一起。而不是end ，使用方括号完成。 julia> [i^2 for i in 1:10] 10-element Array{Int64,1}: 1 4 9 16 25 36 49 64 81 100 可以指定元素的类型： julia> Complex[i^2 for i in 1:10] 10-element Array{Complex,1}: 1.0+0.0im 4.0+0.0im 9.0+0.0im 16.0+0.0im 25.0+0.0im 36.0+0.0im 49.0+0.0im 64.0+0.0im 81.0+0.0im 100.0+0.0im 但是 Julia 可以计算出你所产生的结果的类型： julia> [(i, sqrt(i)) for i in 1:10] 10-element Array{Tuple{Int64,Float64},1}: (1,1.0) (2,1.41421) (3,1.73205) (4,2.0) (5,2.23607) (6,2.44949) (7,2.64575) (8,2.82843) (9,3.0) (10,3.16228) 下面是如何通过推导来生成字典： julia> Dict(string(Char(i + 64)) => i for i in 1:26) Dict{String,Int64} with 26 entries: "Z" => 26 "Q" => 17 "W" => 23 "T" => 20 "C" => 3 "P" => 16 "V" => 22 "L" => 12 "O" => 15 "B" => 2 "M" => 13 "N" => 14 "H" => 8 "A" => 1 "X" => 24 "D" => 4 "G" => 7 "E" => 5 "Y" => 25 "I" => 9 "J" => 10 "S" => 19 "U" => 21 "K" => 11 "R" => 18 "F" => 6 接下来，这里是一个理解中的两个迭代器，用逗号分隔，这使得生成表变得非常容易。在这里，我们将创建一个元组表格： julia> [(r,c) for r in 1:5, c in 1:2] 5×2 Array{Tuple{Int64,Int64},2}: (1,1) (1,2) (2,1) (2,2) (3,1) (3,2) (4,1) (4,2) (5,1) (5,2) r 经过五个循环，每个 c 的值对应一个循环。 嵌套循环 的工作方式正好相反。此处将遵守列主次顺序，如阵列中填充了纳秒时间值时所示： julia> [Int(time_ns()) for r in 1:5, c in 1:2] 5×2 Array{Int64,2}: 1223184391741562 1223184391742642 1223184391741885 1223184391742817 1223184391742067 1223184391743009 1223184391742256 1223184391743184 1223184391742443 1223184391743372 您还可以提供一个测试表达式来过滤产品。例如，生成 1 到 100 之间可被 7 整除的所有整数： julia> [x for x in 1:100 if x % 7 == 0] 14-element Array{Int64,1}: 7 14 21 28 35 42 49 56 63 70 77 84 91 98 与推导类似，生成器表达式可用于通过迭代变量来生成值，但与理解不同的是，这些值是按需生成的。 julia> sum(x^2 for x in 1:10) 385 julia> collect(x for x in 1:100 if x % 7 == 0) 14-element Array{Int64,1}: 7 14 21 28 35 42 49 56 63 70 77 84 91 98 通常，您希望逐个元素检查数组元素，同时跟踪每个元素的索引号。enumerate() 函数的作用是：生成一个索引号和每个索引号的值，从而为您提供一个可迭代版本的内容： julia> m = rand(0:9, 3, 3) 3×3 Array{Int64,2}: 6 5 3 4 0 7 1 7 4 julia> [i for i in enumerate(m)] 3×3 Array{Tuple{Int64,Int64},2}: (1, 6) (4, 5) (7, 3) (2, 4) (5, 0) (8, 7) (3, 1) (6, 7) (9, 4) 在循环的每次迭代中检查数组是否可能发生更改。 有时，您希望同时处理两个或更多个数组，先取每个数组的第一个元素，然后再取第二个，依此类推。使用名字挺好的 zip() 函数可以做到这一点： julia> for i in zip(0:10, 100:110, 200:210) println(i) end (0,100,200) (1,101,201) (2,102,202) (3,103,203) (4,104,204) (5,105,205) (6,106,206) (7,107,207) (8,108,208) (9,109,209) (10,110,210) 如果数组的大小不同，你会认为它们都会出错。如果第三个数组太大或太小怎么办？ julia> for i in zip(0:10, 100:110, 200:215) println(i) end (0,100,200) (1,101,201) (2,102,202) (3,103,203) (4,104,204) (5,105,205) (6,106,206) (7,107,207) (8,108,208) (9,109,209) (10,110,210) 但 Julia 没有被耍-任何一个数组中的任何一个供过于求或供过于求都会得到很好的处理。 julia> for i in zip(0:15, 100:110, 200:210) println(i) end (0,100,200) (1,101,201) (2,102,202) (3,103,203) (4,104,204) (5,105,205) (6,106,206) (7,107,207) (8,108,208) (9,109,209) (10,110,210) 但是，这在填充数组的情况下不起作用，在这种情况下，维度必须匹配： (v1.0) julia> [i for i in zip(0:4, 100:102, 200:202)] ERROR: DimensionMismatch("dimensions must match") Stacktrace: [1] promote_shape at ./indices.jl:129 [inlined] [2] axes(::Base.Iterators.Zip{UnitRange{Int64},Base.Iterators.Zip2{UnitRange{Int64},UnitRange{Int64}}}) at ./iterators.jl:371 [3] _array_for at ./array.jl:611 [inlined] [4] collect(::Base.Generator{Base.Iterators.Zip{UnitRange{Int64},Base.Iterators.Zip2{UnitRange{Int64},UnitRange{Int64}}},getfield(Main, Symbol("##5#6"))}) at ./array.jl:624 [5] top-level scope at none:0 (v1.0) julia> [i for i in zip(0:2, 100:102, 200:202)] 3-element Array{Tuple{Int64,Int64,Int64},1}: (0, 100, 200) (1, 101, 201) (2, 102, 202) 对于可以遍历的所有内容，“For Something in Something”结构都是一样的：数组、字典、字符串、集合、范围等等。在Julia中，这是一个普遍的原则：有许多方法可以创建“可迭代对象”，该对象被设计为作为迭代过程的一部分，一次提供一个元素。 我们已经遇到的最明显的例子是Range对象。当您在REPL中键入它时，它看起来并不多： julia> ro = 0:2:100 0:2:100 但是当你开始遍历它时，它会给出数字： julia> [i for i in ro] 51-element Array{Int64,1}: 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 ⋮ 74 76 78 80 82 84 86 88 90 92 94 96 98 100 如果需要数组中某个范围(或其他可迭代对象)中的数字，可以使用 collect()将其收集起来： julia> collect(0:25:100) 5-element Array{Int64,1}: 0 25 50 75 100 您不必收集可迭代对象的每个元素，只需对其进行迭代即可。当您有其他Julia函数创建的可迭代对象时，这一点特别有用。例如，permutations()创建一个可迭代对象，该对象包含数组的所有排列。当然，您可以使用collect()获取它们并创建一个新数组： julia> collect(permutations(1:4)) 24-element Array{Array{Int64,1},1}: [1,2,3,4] [1,2,4,3] … [4,3,2,1] 但是在任何大的东西上，都有成百上千的排列。这就是为什么迭代器对象不能同时从迭代中产生所有值的原因：内存和性能。Range 对象不会占用太多空间，即使遍历它可能需要很长时间，具体取决于范围有多大。如果您一次生成所有的数字，而不是仅在需要时才生成它们，那么它们都必须存储在某个地方，直到您需要使用它们… Julia为处理其他类型的数据提供了可迭代的对象。例如，在处理文件时，可以将打开的文件视为可迭代对象： filehandle = "/Users/me/.julia/logs/repl_history.jl" for line in eachline(filehandle) println(length(line), line) end 迭代数组时的常见模式是对 i 的每个值执行某些任务，其中 i 是每个元素的索引号，而不是元素： for i = 1:length(A) # do something with i or A[i] end 有一种更有效(即在某些情况下更快)执行此操作的方法： for i in eachindex(A) # do something with i or A[i] end 有一个名为 IterTools.jl 的 Julia 包，它提供了一些高级迭代器函数。 (v1.0) pkg> ] add IterTools julia> using IterTools 例如，partition()将迭代器中的对象分组到易于处理的块中： julia> collect(partition(1:10, 3, 1)) 8-element Array{Tuple{Int64,Int64,Int64},1}: (1, 2, 3) (2, 3, 4) (3, 4, 5) (4, 5, 6) (5, 6, 7) (6, 7, 8) (7, 8, 9) (8, 9, 10) chain() 一个接一个地处理所有迭代器： for i in chain(1:3, ['a', 'b', 'c']) @show i end i = 1 i = 2 i = 3 i = 'a' i = 'b' i = 'c' subsets() 处理对象的所有子集。可以指定大小： for i in subsets(collect(1:6), 3) @show i end i = [1,2,3] i = [1,2,4] i = [1,2,5] i = [1,2,6] i = [1,3,4] i = [1,3,5] i = [1,3,6] i = [1,4,5] i = [1,4,6] i = [1,5,6] i = [2,3,4] i = [2,3,5] i = [2,3,6] i = [2,4,5] i = [2,4,6] i = [2,5,6] i = [3,4,5] i = [3,4,6] i = [3,5,6] i = [4,5,6] 如果希望将一个循环嵌套在另一个循环中，则不必复制 for 和 end 关键字。只要用逗号： julia> for x in 1:10, y in 1:10 @show (x, y) end (x,y) = (1,1) (x,y) = (1,2) (x,y) = (1,3) (x,y) = (1,4) (x,y) = (1,5) (x,y) = (1,6) (x,y) = (1,7) (x,y) = (1,8) (x,y) = (1,9) (x,y) = (1,10) (x,y) = (2,1) (x,y) = (2,2) (x,y) = (2,3) (x,y) = (2,4) (x,y) = (2,5) (x,y) = (2,6) (x,y) = (2,7) (x,y) = (2,8) (x,y) = (2,9) (x,y) = (2,10) (x,y) = (3,1) (x,y) = (3,2) ... (x,y) = (9,9) (x,y) = (9,10) (x,y) = (10,1) (x,y) = (10,2) (x,y) = (10,3) (x,y) = (10,4) (x,y) = (10,5) (x,y) = (10,6) (x,y) = (10,7) (x,y) = (10,8) (x,y) = (10,9) (x,y) = (10,10) (十分有用的@show 宏打印出东西的名称及其值。) 较短和较长形式的嵌套循环之间的一个不同之处是 break： julia> for x in 1:10 for y in 1:10 @show (x, y) if y % 3 == 0 break end end end (x,y) = (1,1) (x,y) = (1,2) (x,y) = (1,3) (x,y) = (2,1) (x,y) = (2,2) (x,y) = (2,3) (x,y) = (3,1) (x,y) = (3,2) (x,y) = (3,3) (x,y) = (4,1) (x,y) = (4,2) (x,y) = (4,3) (x,y) = (5,1) (x,y) = (5,2) (x,y) = (5,3) (x,y) = (6,1) (x,y) = (6,2) (x,y) = (6,3) (x,y) = (7,1) (x,y) = (7,2) (x,y) = (7,3) (x,y) = (8,1) (x,y) = (8,2) (x,y) = (8,3) (x,y) = (9,1) (x,y) = (9,2) (x,y) = (9,3) (x,y) = (10,1) (x,y) = (10,2) (x,y) = (10,3) julia> for x in 1:10, y in 1:10 @show (x, y) if y % 3 == 0 break end end (x,y) = (1,1) (x,y) = (1,2) (x,y) = (1,3) 请注意，break以较短的形式出现在内部循环和外部循环中，而在较长的形式中仅出现在内部循环中。 对于Julia，内部循环应该关注行而不是列。这是由于数组如何存储在内存中。例如，在这个Julia数组中，单元格1、2、3和4彼此相邻存储在内存中(“列优先”格式)。因此，从1到2到3向下移动列比沿行移动要快，因为从列到列从1到5到9跳过需要额外的计算： +-----+-----+-----+--+ | 1 | 5 | 9 | | | | | +--------------------+ | 2 | 6 | 10 | | | | | +--------------------+ | 3 | 7 | 11 | | | | | +--------------------+ | 4 | 8 | 12 | | | | | +-----+-----+-----+--+ 下面的示例由简单的循环组成，但是行和列的迭代方式不同。“不好”的版本逐列查看第一行，然后向下移动到下一行，依此类推。 function laplacian_bad(lap_x::Array{Float64,2}, x::Array{Float64,2}) nr, nc = size(x) for ir = 2:nr-1, ic = 2:nc-1 # bad loop nesting order lap_x[ir, ic] = (x[ir+1, ic] + x[ir-1, ic] + x[ir, ic+1] + x[ir, ic-1]) - 4*x[ir, ic] end end 在“好的”版本中，两个循环被正确嵌套，以便内部循环按照数组的内存布局在行中向下移动： function laplacian_good(lap_x::Array{Float64,2}, x::Array{Float64,2}) nr,nc = size(x) for ic = 2:nc-1, ir = 2:nr-1 # good loop nesting order lap_x[ir,ic] = (x[ir+1,ic] + x[ir-1,ic] + x[ir,ic+1] + x[ir,ic-1]) - 4*x[ir,ic] end end 另一种提高速度的方法是使用宏@inbounds删除数组边界检查： function laplacian_good_nocheck(lap_x::Array{Float64,2}, x::Array{Float64,2}) nr,nc = size(x) for ic = 2:nc-1, ir = 2:nr-1 # good loop nesting order @inbounds begin lap_x[ir,ic] = # no array bounds checking (x[ir+1,ic] + x[ir-1,ic] + x[ir,ic+1] + x[ir,ic-1]) - 4*x[ir,ic] end end end 下面是测试函数： function main_test(nr, nc) field = zeros(nr, nc) for ic = 1:nc, ir = 1:nr if ir == 1 || ic == 1 || ir == nr || ic == nc field[ir,ic] = 1.0 end end lap_field = zeros(size(field)) t = @elapsed laplacian_bad(lap_field, field) println(rpad("laplacian_bad", 30), t) t = @elapsed laplacian_good(lap_field, field) println(rpad("laplacian_good", 30), t) t = @elapsed laplacian_good_nocheck(lap_field, field) println(rpad("laplacian_good no check", 30), t) end 结果表明，仅根据行/列扫描顺序就可以得到不同的性能差异。“不检查”的版本更快.。 julia> main_test(10000,10000) laplacian_bad 1.947936034 laplacian_good 0.190697149 laplacian_good no check 0.092164871 可以设计自己的可迭代对象。定义类型时，需要向 Julia 的 iterate()函数添加几个方法。那你就可以用类似于for .. end循环用于处理对象的组件，这些iterate()方法将在必要时自动调用。 下面的示例演示如何创建一个可迭代对象，该对象生成将大写字母与1到9之间的数字组合在一起的字符串序列。因此，我们的序列中的第一个项目是“A1”，然后是“A2”、“A3”，直到“A9”，然后是“B1”、“B2”，等等，最后是“Z9”。 首先，我们将定义一个名为 SN (StringNumber)的新类型： mutable struct SN str::String num::Int64 end 稍后，我们将使用如下内容创建此类型的可迭代对象： sn = SN("A", 1) 迭代器将生成到“Z9”的所有字符串。 现在，我们必须向 iterate()函数添加两个方法。这个函数已经存在于 Julia 中(这就是为什么您可以迭代所有的基本数据对象)，需要Base前缀：我们将向现有的iterate()函数添加一个新的用于处理这些特殊对象的方法。 第一个方法不接受参数(类型除外)，用于启动迭代过程。 function Base.iterate(sn::SN) str = sn.str num = sn.num if num == 9 nextnum = 1 nextstr = string(Char(Int(str[1])) + 1) else nextnum = num + 1 nextstr = str end return (sn, SN(nextstr, nextnum)) end 这将返回一个元组：我们计算过的迭代器的第一个值和未来的值(以防万一我们希望在“A1”以外的位置启动迭代器)。 iterate()的第二个方法接受两个参数：可迭代对象和当前状态。它再次返回包含两个值的元组，即下一项和下一状态。但是首先，如果没有更多的值可用，iterate()函数应该什么也不会返回。 function Base.iterate(sn::SN, state) # check if we've finished? if state.str == "[" # when Z changes to [ we're done return end # we haven't finished, so we'll use the incoming one immediately str = state.str num = state.num # and prepare the one after that, to be saved for later if num == 9 nextnum = 1 nextstr = string(Char(Int(str[1])) + 1) else nextnum = num + 1 nextstr = state.str end # return: the one to use next, the one after that return (SN(str, num), SN(nextstr, nextnum)) end 告诉迭代器什么时候完成很简单，因为一旦传入状态包含“[”我们已经完成了，因为“[”(91)的代码紧跟在“Z”(90)的代码之后。 通过添加这两个方法来处理 SN 类型，现在可以对它们进行迭代。为其他几个 Base 函数添加一些方法也很有用，例如show()和length()。length()方法计算出从 sn 开始还有多少 SN 字符串可用。 Base.show(io::IO, sn::SN) = print(io, string(sn.str, sn.num)) function Base.length(sn::SN) cn1 = Char(Int(Char(sn.str[1]) + 1)) cnz = Char(Int(Char('Z'))) (length(cn1:cnz) * 9) + (10 - sn.num) end 迭代器现在可以使用了： julia> sn = SN("A", 1) A1 julia> for i in sn @show i end i = A1 i = A2 i = A3 i = A4 i = A5 i = A6 i = A7 i = A8 ... i = Z6 i = Z7 i = Z8 i = Z9 julia> for sn in SN("K", 9) print(sn, " ") end K9 L1 L2 L3 L4 L5 L6 L7 L8 L9 M1 M2 M3 M4 M5 M6 M7 M8 M9 N1 N2 N3 N4 N5 N6 N7 N8 N9 O1 O2 O3 O4 O5 O6 O7 O8 O9 P1 P2 P3 P4 P5 P6 P7 P8 P9 Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 R1 R2 R3 R4 R5 R6 R7 R8 R9 S1 S2 S3 S4 S5 S6 S7 S8 S9 T1 T2 T3 T4 T5 T6 T7 T8 T9 U1 U2 U3 U4 U5 U6 U7 U8 U9 V1 V2 V3 V4 V5 V6 V7 V8 V9 W1 W2 W3 W4 W5 W6 W7 W8 W9 X1 X2 X3 X4 X5 X6 X7 X8 X9 Y1 Y2 Y3 Y4 Y5 Y6 Y7 Y8 Y9 Z1 Z2 Z3 Z4 Z5 Z6 Z7 Z8 Z9 julia> collect(SN("Q", 7)), (Any[Q7, Q8, Q9, R1, R2, R3, R4, R5, R6, R7 … Y9, Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, Z9],) 若要在条件为真时重复某些表达式，请使用while ... end构造。 julia> x = 0 0 julia> while x < 4 println(x) global x += 1 end 0 1 2 3 如果在函数外部工作，则需要 global 声明 x，然后才能更改其值。在函数内部，不需要global。 如果希望在语句之后(而不是在语句之前)测试条件，生成“do...until”的形式，请使用以下结构： while true println(x) x += 1 x >= 4 && break end 0 1 2 3 这里我们使用的是布尔转换表达式而不是if ... end语句。 使用Julia的宏，您可以创建自己的控制结构。请参见 Metaprogramming 元编程。 如果要编写检查错误并妥善处理这些错误的代码，请使用try ... catch结构。 使用catch短语，您可以处理代码中出现的问题，这可能会使程序继续运行，而不是陷入停顿。 在下一个示例中，我们的代码试图直接更改字符串的第一个字符(这是不允许的，因为Julia中的字符串不能就地修改)： julia> s = "string"; julia> try s[1] = "p" catch e println("caught an error: $e") println("but we can continue with execution...") end caught an error: MethodError(setindex!,("string","p",1)) but we can continue with execution... error()函数使用给定的消息引发错误异常。 最后，让我们看一看do代码块，这是另一种语法形式，就像列表推导一样，乍看起来有点倒退(也就是说，从末尾开始，从开头开始或许可以更好地理解它)。 还记得 前面的 find()示例吗？ julia> smallprimes = [1,2,3,5,7,11,13,17,19,23]; julia> findall(x -> isequal(13, x), smallprimes) 1-element Array{Int64,1}: 7 anonymous function 匿名函数 (x -> isequal(13, x)是find()的第一个参数，它对第二个参数进行操作。但是有了do代码块，你就可以把函数拿出来放在do之间…… julia> findall(smallprimes) do x isequal(x, 13) end 1-element Array{Int64,1}: 7 您只需丢掉箭头、更改顺序，将find()函数及其目标参数放在第一位，然后在 do之后添加匿名函数的参数和主体。 这样做的目的是在表单末尾的多行上编写一个较长的匿名函数，而不是将其作为第一个参数插入。 |
WebQuest網路探究/探究式學習 壹、探究式教學 探究式教學的意涵： 探究教學法和講述教學法是完全不同的教學法。學生是學習的主體，擁有充分的發表、討論、操作的機會，讓學生透過類似科學家做研究的經驗，體會與學習到科學 知識、科學態度與科學技能。(陳振威，2000) 探究教學有以下幾種特徵： 一、學生對自然事物與現象主動地去研究，經過探求自然的過程獲得科學上的知識。 二、為了研究自然而培養所需要的探求能力。 三、有效地形成認識自然基礎的科學概念。 四、培養探究未知自然的積極態度。 五、經由探究活動而學得的知識是科學概念而不是文字知識。 學生經由探究活動的過程，他/她在腦海中一步步建構他自己的概念體系。當愈多的活動被學生探究，學生的科學態度會積極，學生的科學方法層次愈高，則愈有信 心探討更多的活動。 探究式教學的原則： 探究教學並不是一個固定的模式，探究是主要精神，方式可以有許多種，諸如舒華布（Joseph, J. Schwab）的科學探究模式、Ausubel 的前導組體教學模式、 薩克曼（Richard Suchmann）的探究訓練模式等等，都是著名的以探究精神為要旨的教學模式。而可以探究主題更是俯拾皆是，尤其對學童而言，生活就是最好的主 題，從空氣、陽光、水到昆蟲、小動物都能探究出重要的科學概念。教師在教學與規劃時只要把握住幾項重要的原則，應該就不至於偏離探究的精神太遠了，以下為一些 參考原則： 一、探究的題材應生活化、趣味化、創意化： 對兒童來說生活中充滿了驚喜，那怕是一片葉子、一條毛毛蟲都可以是一個大問題。尤其，多數的兒童有著獨特的另有架構，若能在大自然的環境中主動探索，一方 面能拓展新視野，另一方面藉著親身的觀察、體驗，得到最有效的概念改變。 二、利用小組合作學習，營造熱絡的學習氣氛： 合作學習本身就是能促進學生有效學習的策略，經過老師適當的安排，例如異質性分組、合理的分工，並讓每個學生有機會擔任不同的角色，使學生意識到自己對團 體的重要與責任，加上適度的小組競爭更能創造學習氣氛，使學生熱於投入探究活動，體驗到學習的興趣與喜悅。 三、提供豐富多元的資源供學生使用： 教師應為學生提供豐富多元的資源，一方面給予學生不同的感官刺激，另一方面作為學生試煉自己身手的材料，並培養學生整合資訊的能力。 四、活動的背後是有組織的課程架構： 一個完整而成功的教學，是需要老師做長期的規劃，以階段性的目標為每個活動的中心，貫串起學生的完整能力與認知的學習。教師應先瞭解學生的先備知識與能 力，規劃單元目標，並為達到預期的教學目標做適當的教學設計或探究題目。 五、注重過程中創造性思考、態度、技能的評量： 所有的教學都應兼顧認知、技能與情意的學習，老師們需要從評量方式的改變做起，以多元、實作的方式，達到真實性的評量。 六、教師適當的導引，卻不過度的介入： 探究教學強調學生學習的自主性，畢竟學生才是學習的主體。當然老師不可放任學生盲目活動，甚至碰觸危險，但當學生遇到困難或瓶頸時，教師不必急於支援，因 為正如科學家的探究一樣，每一個困難都是一次的學習，教師只需要多一點的耐心和信心，以鼓勵代替解答，學生往往獲得的比老師想像的多更多。 七、支持每一個學習者並尊重個別差異： 不是只有好學生才有能力探究，教師應給每一位學習者參與的機會，並照顧與鼓勵較內向而少表現的學生，使他們也能感受到探究的喜悅，並建立自信心。 貳、探究式學習 探究式學習(WebQuest)的意義 WebQuest是1995年聖地牙哥州立大學的Bernie Dodge和Tom March教授所提出的一項新興教學技術，其核心概念即：整合學習策略與應用網路資源，規劃出探究 導向（inquiry-oriented activity）的教學活動。教師可由教學目標出發，有目的地規劃一系列的問題與任務，並透過事先整理好的相關資源網站，幫助學生在資料 搜尋、整合、分析、評鑑等解決問題的過程中學習成長。WebQuest可避免學習者在多元的全球資訊網中盲目瀏覽和接觸不適宜資源，同時又能激發學習者的主動性、探 究精神和創意思考。 在WebQuest學習當中，分為長期與短期兩種不同層次的學習。短期的WebQuest探究式學習主要目標是知識的獲取和整合，通成實施一至三節課的單元學習；長期的 WebQuest其學習目標則是擴展和提煉出新概念，通常以一周至一個月為實施長度。 探究式學習(WebQuest)，又稱為研究性學習、專題研習或疑難為本學習，是一種以學生為主的學習模式。在教師的輔助下，由學生策劃、執行及自我評估的學習方 法(梁淑貞、陳秀騰，2001年)。它是一種跨學科的學習技巧。學生透過研習一個特定的專題的同時，運用現有的知識和技巧來重新綜合，並透過進行一些特定的活動， 使學生能自主地建構知識，繼而學會這個新的題目，而達至學會學習的目的，並培養學生的自學精神。簡單來說就是一種以學生自主探究為主的學習方式。 探究式學習的特色 探究式學習主要是培養學生獨立思考與自主解決的能力，由學生的好奇心開始，見基於已有知識，透過探索、推敲、反思及驗證的互動過程，培養學生的供通能力。 以下是探究式學習的特色： 一、學生就自己感興趣的現象提出問題，並設計方法找出答案 二、學生蒐集數據，決定如何表達數據，並測試所得結果的可靠性 三、學生學習評鑑自己及同儕的工作 四、學生能就別人對他們的探究結論或不足之處所作的挑戰，作出回應 五、學生向別人匯報自己的探究，並樂意接受批評 探究式學習的組成要素及設計原則 一、WebQuest教學即善用網路資訊來增進教學目標，而其組成主要有六項要素： (一)Introduction：引發學習動機與情境引導的介紹。 即一個構建“知識鷹架”的導言，提供本次探究的背景資訊，且提供背景材料，喚起學生原有知識經驗，為新的學習作好準備的教學設計。 (二)Task：學習任務的描述。 安排一個可能完成並且是有趣的任務，這個解決問題的任務是WebQuest的核心部分。 (三)Process：探索過程的安排與指引。 即一個探究學習的過程描述，學生探究學習的每一步驟都有清晰的指導說明。 (四)Resources：網站連結或其他資源列表。 務必提供完成任務所必須的資訊資源，通常是將許多資源超連結在WebQuest文字中，作為問題探究的“定錨點”。資源包括網站資料、透過E-mail聯繫的專家、實 際的參考資料、在網路上的調查資料庫，也包括傳統印刷的書籍和文獻。 (五)Evaluation：描述達成任務的要求與評分方式。 這部份的評估系統是開放性的，用來對學生解決問題的結果而創作的作品進行評估。 (六)Conclusion：結論。 說明完成本次學習的意義，並可以提出新問題或補充連結，提供延伸加廣學習的機會。 二、至於如何才能設計出合適的WebQuest教學模式，在此有五項基本設計原則： (一)Find great sites：找出精彩的網站。 好的網站品質必須符合學習者的年齡、Webquest的主題、教師期望的學習活動。 (二)Orchestrate your learners and resources：有效組織學習者和學習資源。 意即，使每一台電腦被充分運用、每個人在每一個時刻都在做有意義的事，將電腦資源做整合，並且建立學習者間互信互賴的關係，透過閱讀不同的網頁、通過並行 的活動路線來劃分責任。 (三)Challenge your learners to think：要求學生思考。 網路並非學校圖書館延伸，給你的學習者一個任務，讓他思考根據資訊可以做些什麼？例如：設計旅遊行程、撰寫新聞…。 (四)Use the medium：選用媒體。 除了學習夥伴外，開設討論區，並提供特定網站資源來幫助學習。 (五)Scaffold high expectations：為高水準的學習期望提供鷹架。 教學者需具備三項能力，第一、接收鷹架：觀察指導、會晤技巧、線上術語、字典等；第二、轉換鷹架：提供比較和對照，研究物件中找尋共同點、集體討論、推理 和決策等；第三、輸出鷹架：寫作提示、多媒體素材等。 探究式學習的應用 一、探究式網路學習對中學生學習之影響 (一)研究目的 本實驗之目的在探討應用網路學習工具進行主題探究學習，對提昇學生自我效能及學習任務價值之助益，以及對不同學習風格者的影響。 (二)研究樣本與方法 以某綜合高中商業類學程二年級兩班學生共九十四位女同學為實驗對象，並依班級分為實驗組54人及控制組40人。由於這兩班都是商業類學程的學生，必修課程相 同，且以常態編班，本實驗課程計算機概論的任課老師也相同，所以選擇這兩班作為研究對象。學生在計算機概論課程上，以電腦新知為主軸進行主題探究活動。實驗組 使用「網路學習工具」所建構的應用模式進行探究學習，本研究將之稱為「探究式網路學習」，而控制組使用原來的探究方法稱為「一般探究學習」。 (三)研究結果 採用探究式網路學習的學生之自我效能及學習任務價值，皆顯著優於使用一般探究學習者；不同學習風格的學習者之自我效能及學習任務價值無顯著差異；而探究方 式與學習風格之間也無顯著的交互作用；使用探究式網路學習時，主動觀察者較被動觀察者有顯著較佳的學習任務價值。 (四)結論 根據實驗結果發現在探究式網路學習的環境中，確實可以增進學生的自我效能與學習任務價值，且學習者的學習風格對增進自我效能及學習任務價值無顯著影響，其 中在使用探究式網路學習時，主動觀察者會較被動觀察者有較佳的學習任務價值。由此可知，透過網路進行探究活動的確有助於自我效能與學習任務價值的提昇。網路學 習改變了傳統教室學習的時空限制，使訊息的溝通和處理更具彈性，同時在沒有老師臨場的督促指導下學習者可以依照自己的能力、興趣與目的進行學習，培養學生自主 學習的能力，由於自我操控性較高，學生的學習動機因而顯著提昇。 同時網路的互動性與趣味化也提高了學生的學習興趣，並使得學生能夠知覺計算機概論對個人的重要性及效用價值。 使用探究式網路學習時，主動實驗者的學習任務價值顯著高於被動觀察者，可能與主動觀察者偏好做中學，喜歡冒險、從實作中解決問題，面對新的學習情境調適較 快，趨向同儕互動學習有關。由於網路工具的操作以及網路學習環境具有豐富、多變、多樣及互動性高等特性，正符合主動觀察者的喜好，可能也因而提高了學習興趣與 動機。 故由實驗證明，本研究所建構的探究式網路學習模式確實是較佳的探究方式，透過應用網路學習工具本身具有的功能特色，使學習更為有效，同時也能適應不同學習 風格的個別差異。 由於主動實驗者在使用探究式網路學習時，會有較佳的表現，建議未來利用網路進行合作探究時可依學生的學習風格分配學生到一異質小組，利用組員間的個別差異 在彼此互相幫助下，觀察是否會形成互補，提高個人學習成效並達成整體的學習效果。藉以探討在彼此互動影響後產生的變化，瞭解在網路的探究模式下搭配何種分組能 發揮最好的效果。 二、利用WebQuest 教學活動提升創造思考能力 (一)目的 WebQuest 教學模式當中的探索過程，可讓學生多瀏覽各種資訊，而多看網路上的資訊將有助於學生提升對創造思考的敏覺力，此外，腦力激盪過程也是WebQuest 教學的過程之ㄧ，腦力激盪可逐漸擴大思考範圍，從別人的意見中引出種種聯想，對於同學提升變通力有所幫助，天馬行空不受限制地思考，也有助於學生思考的流暢 性。因此，此研究者認為WebQuest 教學模式可以提升學生創造思考的敏覺力、變通力與流暢力。 (二)研究方法 此研究以「我國科技發展政策」單元為題，設計為期五週的WebQuest 教學活動，並配合創造性的思考題目與角色扮演的學習方式來提升學生的學習興趣與培養學生 的創造思考能力。 (三)研究內容 （詳細教案請連結此網頁） 1.活動名稱：探討我國科技政策的發展 2.授課年級：高一生活科技課程 3.教學時數：5 小時 4.活動概述：主要是讓學生以WebQuest 的方式探索網路上的資源，進而瞭解到我國科技發展的目標與政策，培養同儕之間合作學習的觀念與態度，熟悉網路上資料 蒐集與整理的方式，並設計一個需要小組合作思考之創意學習題目，以及多元的學習單來促進同學的創造思考能力。 5.活動目標： 1)瞭解我國科技政策的目標。 2)瞭解我國科技政策的發展策略。 3)瞭解我國發展科技的優勢與劣勢。 4)使學生能認識並且使用網路上的資源來搜尋資料來解決問題。 5)使學生了解合作學習的觀念與創造思考的能力。 6.教案設計：包括情境介紹、學習任務、探索過程、網站資源、評鑑以及結論等六個步驟。 (四)結論： WebQuest 教學過程包含網路資料瀏覽探索與同學間腦力激盪等過程，有助於學生提升創造思考的敏覺力、變通力與流暢力。提升創意思考的教學方式有許多的種 類，每種方法都有它的優點與特色，以WebQuest 教學活動來提升學生的創造思考能力有以下幾項優勢： 1.促進合作學習。牛頓曾經說過：我可以比別人看的更高更遠是因為我站在他人的肩膀上，因此合作學習可以增進學生之眼界與智力。 2.促進主動學習。有較強內在學習動機的學生會展現出較高的創造力，而WebQuest 教學活動可以提升學生的學習動機。 3.藉由多媒體與網路的輔助，在問題解決的過程學生可以隨時搜尋最新且符合需求的資料，可以提升問題解決的能力。 此研究整理了利用WebQuest 實施教學以提昇創造思考能力之文獻，並提出一完整之WebQuest 教案供有興趣之教師參考使用，以期對學生創造思考能力的提升有所 助益。 參考資料 簡介探究式教學法，劉美芳，屏東縣德協國小 維基百科 探究式學習的評估 論文：探究式網路學習對中學生學習之影響 論文：利用WebQuest 教學活動提升創造思考能力 WebQuest與問題導向學習 WebQuest簡介(張原禎cyc@mail.tpc.edu.tw) WebQuest教學模式、介紹及應用實務 |
國中地理/七年級/上冊 • 位置的表達 ○ 絕對位置：利用座標系統來表示目標物。 § 地圖網格或經緯線。 § 教室第二列第三排。第二橫列、第三直排。 ○ 相對位置：利用目標物與某個明顯地標的方位關係，來表示目標物的所在。 § 例如：講桌的東南方。 • 位置與地圖 ○ 地圖 § 定義：地圖是將地表上各種現象依比例縮小，繪製在平面上的圖像。 § 地圖要素：圖名、比例尺、方向標、圖例。 □ 圖名：描述地圖的主要內容。 □ 比例尺：圖上距離與地表實際距離的長度比例。 ® 大比例尺：比例尺的比值較大，涵蓋範圍較小、較詳盡。 ® 小比例尺：比例尺的比值較小，涵蓋範圍較大，較簡略。 □ 方向標：標示方向的指標。無方向標則以地圖上方為北方。 □ 圖例：利用符號代表地形、地物。 ○ 位置的判讀 § 相對位置：利用方位關係，在地圖中描述目標物的位置。 § 絕對位置：利用網格座標來判斷目標物的位置。 • 經緯線座標系統：經由經線與緯線所構成的地表網格座標系統來表達絕對位置。 ○ 經線：又稱子午線。 § 定義：連接南北兩極的半圓弧線。 § 方向：南北向。 § 長度：赤道的一半。 § 度數：東西各180度。 □ 東半球：往東經度越高。 □ 西半球：往西經度越高。 § 0度經線：本初經線（本初子午線），通過格林威治天文臺，劃分東西半球。 § 180度經線：國際換日線。 § 計算時差： □ 地球由西往東轉，越往東時間越早。 □ 360度＝24小時，每15度相差1小時。 □ 中央經線：時區中央的經線稱為中央經線，往東西各7.5度的範圍為同一時區。格林威治天文臺為0度，東經7.5度至西經7.5度為同一個時區。 □ 由東向西計算經度差／360＊24。 □ 中央經線： ○ 緯線： § 定義：與赤道平行的圓圈。 § 赤道：與南北極距離相等的各點連線。為最長的緯線。 § 方向：東西向、相互平行。 § 長度：赤道為最長的緯線，緯度越高緯線越短，南北極爲一點。 § 度數：南北極各90度。 □ 北半球：往北緯度越高。 □ 南半球：往南緯度越高。 □ 0度緯度：赤道，為劃分南北半球的依據。 □ 北回歸線：北緯23.5度。 □ 北極圈：北緯66.5度。90-23.5=66.5。 □ 北極：北緯90度。 □ 南回歸線：南緯23.5度。 □ 南極圈：南緯66.5度。 □ 南極：南緯90度。 ○ 尋找另一端點 § 經度：東經－180度。 § 緯度：度數相同，分別在南北緯。 ○ 氣候與緯度 § 氣候帶：由於不同緯度太陽照射角度不同 □ 角度：陽光射線與地平面的夾角，地球是圓的，使得高緯度的地平面與陽光的夾角很小（斜射）。 □ 高緯度：太陽斜射地平面，單位面積獲得熱量低，溫度較低。 □ 低緯度：太陽直射地平面，單位面積獲得熱量高，溫度較高。 § 季節差異：因為地軸傾斜，太陽會輪流在南北半球直射，形成四季變化，且南北半球季節相反。 □ 3-9月：直射北半球。北回歸線為直射北半球的界線，夏至(6/21或6/22)那天北半球白天最長、晚上最短。 □ 10-2月：直射南半球。南回歸線為直射南半球的界線，冬至(12/21或12/22)那天南半球白天最長、晚上最短。 |
藥物化學/抗癌藥/Bleomycin 平面結構 立體結構 來自Streptomyces verticillus 主要以A2型作為藥物 藥物結構與藥物作用機制的關係 雙 thiazole 促進 bleomycin 產生具細胞毒性的自由基，使 DNA 被破壞 具有高電子密度的 雙醣、聚胺、imidazole 和 pyrimidine 基團，可以螯合細胞中的鐵離子 會受 bleomycin hydrase （一種 aminopeptidase）切除末端醯胺基生成羧酸基而去活化， 不過此酵素在癌細胞中量不多，因此可以對癌細胞反應，提高選擇性（例外，皮膚及肺臟也缺乏 bleomycin hydrase） G2期專一性 肺部纖維化，因為肺部缺少 bleomycin hydrase 將藥物去活化，因此需要服用銅錯合物藥劑，tetrathiomolybdate，抑制銅依賴發炎細胞激素的作用，降低 bleomycin 誘導之纖維化副作用 皮膚部分，有紅斑和肥大 注意：此藥不會抑制骨髓!!! |
初中物理/声波的产生与传播 声音的产生是因为物体发生振动 正在发声的物体一定在振动，正在振动的物体也一定在发声。 声音以声波传递。 气体，液体，固体都能传声（即声音的传播许要介质，真空中不能传声） 一般情况下固体传播速度>液体传播速度>气体传播速度，注意，是一般情况下，也有特殊情况，例如：相同温度下，水传播速度＞软木传播速度（声音的传播速度还和温度有关——温度越高，声速越快）。 |
Introducing Julia/Types 这一节是关于类型的，下一节是关于函数和方法的，理想情况下应该同时阅读这两个主题，因为这两个主题是紧密地联系在一起的。 数据元素有不同的形状和大小，称为类型。 考虑以下数值：浮点数、有理数和整数： 0.5 1//2 1 对我们人类来说，不假思索地将这些数字相加是很容易的，但计算机不能使用简单的加法程序将所有三个值相加，因为它们的类型是不同的。添加有理数的代码必须考虑分子和分母，而添加整数的代码则不必考虑分子和分母。计算机可能必须将这些值中的两个转换为与第三个值相同的类型(通常是将 整数 和 有理数 首先转换为浮点数)，然后将三个浮点数相加在一起。 这种转换类型的工作显然需要时间。因此，要编写真正快速的代码，您需要确保不会不断地将值从一种类型转换为另一种类型，从而浪费计算机的时间。当 Julia 编译您的源代码时(每次您第一次对函数求值时都会发生这种情况)，您提供的任何类型指示都允许编译器生成更高效的可执行代码。 转换类型的另一个问题是在某些情况下，您将丢失精度：将有理数转换为浮点数可能会丢失一些精度。 Julia 的设计师的官方说法是，类型是可选的。换句话说，如果您不想担心类型(如果您不介意代码的运行速度慢于它可能)，那么您可以忽略它们。但是您将在错误消息和文档中遇到它们，因此您最终将不得不处理它们… 折中的方法是编写 top-level 的代码，而不必担心类型，但是，如果您希望加快代码速度，请找出程序花费时间最多的瓶颈，并清理该区域中的类型。 关于Julia的类型系统有很多需要了解的地方，所以正式文档才是真正的去处。但这里有一个简短的概述。 在Julia中，类型是按层次结构组织的，具有树状结构。 在树的根中，我们有一个称为 Any 的特殊类型，所有其他类型都直接或间接地连接到它。非正式地说，我们可以说这种 Any 有孩子。它的孩子被称为 Any 的子类。单个孩子 超类 是 Any。(但是，请注意，类型之间的层次关系是 explicitly declared 显式声明的，而不是 implied by compatible structure 兼容的结构暗示的。) 通过查看 Number 类型，我们可以看到 Julia 类型层次结构的一个很好的示例。 类型 Number 是类型 Any 的一个直接子类。 查看 Number 的超类是谁，我们可以使用 supertype() 函数: julia> supertype(Number) Any 我们还能尝试找出 Number 的所有子类 (Number 的子辈，因此也就是, Any 的孙辈). 想要找到，我们可以用 subtypes() 函数： julia> subtypes(Number) 2-element Array{Union{DataType, UnionAll},1}: Complex Real 我们可以观察到，我们有两个 Number 的子类型：复数 Complex 和实数 Real。对于数学家来说，实数和复数都是数字。作为一般规则，Julia的类型层次结构反映了现实世界的层次结构。 作为另一个例子，如果 美洲豹 Jaguar 和 狮子 Lion 都是 Julia 的类型，很自然的他们的超类会是猫科动物 Feline ： julia> abstract type Feline end julia> mutable struct Jaguar <: Feline end julia> mutable struct Lion <: Feline end julia> subtypes(Feline) 2-element Array{Any,1}: Jaguar Lion Julia中的每个对象(非正式地说，这意味着在Julia中可以放入变量的所有内容)都有一个类型。但并非所有类型都可以有各自的对象(该类型的实例)。唯一可以有实例的是所谓的具体类型。这些类型不能有任何子类型。可以有子类型(例如Any, Number)的类型称为抽象类型。因此，我们不能拥有Number类型的对象，因为它是抽象类型。换句话说，只有类型树的叶子是具体的类型，并且可以实例化。 如果我们不能创建抽象类型的对象，为什么它们有用呢？有了它们，我们可以为它的任何子类型编写泛化的代码。例如，假设我们编写了一个期望类型为 Number 的变量的函数： #this function gets a number, and returns the same number plus one function plus_one(n::Number) return n + 1 end 在本例中，函数需要一个变量 n. n 的类型必须是 Number 的子类型(直接的或间接的) 。用 :: 语法表示(但是不要担心语法)。这是什么意思？无论n 的类型是Int (整数) 还是 Float64 (浮点数), 函数 plus_one() 都可以正常工作. 此外, plus_one() 不适用于任何不是 Number 的子类型 的类型 (例如文本字符串、数组)。 我们可以将具体类型分为两类：基元 primitive (或基本) 和 复杂(或复合)。基元类型用来构建代码块，通常硬编码到 Julia 的心脏中，而复合类型将许多其他类型组合在一起，以表示更高级别的数据结构。 您可能会看到以下基本类型： 基本整数和浮点数类型(有符号和无符号)： Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, Float16, Float32, and Float64 更高级的数字类型：BigFloat, BigInt 布尔和角色类型： Bool and Char 文本字符串类型： String 复合类型的一个简单示例是 Rational ，用于表示分数。它由两个部分组成，一个分子和一个分母，两个整数(类型为 Int )。 Julia 提供了两个用于导航类型层次结构的函数：subtypes() 和 supertype()。 julia> subtypes(Integer) 4-element Array{Union{DataType, UnionAll},1}: BigInt Bool Signed Unsigned julia> supertype(Float64) AbstractFloat sizeof() 函数告诉您此类型的项占用的字节数： julia> sizeof(BigFloat) 32 julia> sizeof(Char) 4 如果您想知道某个特定类型可以容纳的数字有多大，以下两个函数非常有用： julia> typemax(Int64) 9223372036854775807 julia> typemin(Int32) -2147483648 在基本Julia系统中有340多种类型。可以使用以下函数调查类型层次结构： function showtypetree(T, level=0) println("\t" ^ level, T) for t in subtypes(T) if t != Any showtypetree(t, level+1) end end end showtypetree(Number) 它会为不同的数字类型生成如下所示： julia> showtypetree(Number) Number Complex Real AbstractFloat BigFloat Float16 Float32 Float64 Integer BigInt Bool Signed Int128 Int16 Int32 Int64 Int8 Unsigned UInt128 UInt16 UInt32 UInt64 UInt8 Irrational Rational 例如，这显示了实数 Real的四个主要子类型：抽象浮点 AbstractFloat、整数 Integer、有理数 Rational 和无理数 Irrational。 我们已经看到，如果您不指定变量类型的话，Julia会尽最大努力计算出您在代码中放入的内容类型，： julia> collect(1:10) 10-element Array{Int64,1}: 1 2 3 4 5 6 7 8 9 10 julia> collect(1.0:10) 10-element Array{Float64,1}: 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 我们还看到，您可以为新的空数组指定类型： julia> fill!(Array{String}(undef, 3), "Julia") 3-element Array{String,1}: "Julia" "Julia" "Julia" 对于变量，可以指定其值必须具有的类型。由于技术原因，您不能在 top-level 中指定类型。在REPL中，您只能在定义的里面这样做。使用 :: 语法，表示“是这个类型”。所以： function f(x::Int64) 表示函数 f 有一个接受参数 x 的方法，该参数类型预期为 Int64。请参见函数 Functions。 下面的示例说明了变量类型的选择如何影响 Julia 代码的性能。您能找出这两个函数之间的唯一区别吗： function t1(n) s = 0 t = 1 for i in 1:n s += s/i t = div(t, i) end return t end function t2(n) s = 0.0 t = 1 for i in 1:n s += s/i t = div(t, i) end return t end 这两个定义几乎是相同的，除了每个定义开头的s的类型。在运行它们几次之后，计时结果是值得注意的： julia> @time t1(10000000) 0.658128 seconds (60.00 M allocations: 915.520 MiB, 25.01% gc time) julia> @time t2(10000000) 0.118332 seconds (4 allocations: 160 bytes) 原因是s开始时是一个整数(s=0表示Julia最初将s视为整数)，但是在循环中，它被分配用来保存s/i的结果，这是一个浮点值：必须将其从整数转换为浮点以进行匹配。因此该函数不是类型稳定的-Julia编译器无法对其内容进行假设，因此它不能生成纯整数代码或纯浮点代码。因此，它最终生成的代码并不像它所能产生的那样快。 t1() 的表现明显低于 t2(). 原因是 s 一开始是一个整数。(s = 0 表示 Julia 最初将 s 视为整数), 但是在循环中，它被分配用来保存s/i 的结果，这是一个浮点值：必须将其从整数转换为浮点以进行匹配。因此此该函数不是类型稳定的，Julia编译器无法对其内容进行假设，也就不能生成纯整数代码或纯浮点代码。因此，它最终生成的代码并不像它写的时候所能产生的那样快。 如果要比较这个小差异导致 Julia 编译器生成的额外编译代码的数量，请运行 @code_native t1(100) 和 @code_native t2(100) 命令。 在Julia中，程序员很容易就能创建新的类型，受益于 native 类型(由Julia的创建者创建的类型)所具有的相同的性能和语言方面的集成。 In Julia, it's very easy for the programmer to create new types, benefiting from the same performance and language-wise integration that the native types (those made by Julia's creators) have. 假设我们要创建一个抽象类型。为此，我们使用 Julia 的关键字 abstract，后跟要创建的类型的名称： abstract type MyAbstractType end 默认情况下，您创建的类型是 Any 的直接子类型： julia> supertype(MyAbstractType) Any 您可以使用 <: 运算符来更改它。例如，如果希望新的抽象类型是 Number 的子类型，则可以声明： abstract type MyAbstractType2 <: Number end 现在我们得到： julia> supertype(MyAbstractType2) Number 请注意，在同一Julia会话中(在不退出REPL或结束脚本的情况下)，不可能重新定义类型。这就是为什么我们必须创建一个名为 MyAbstractType2 的类型。 现在可以创建新的复合类型了。请使用 struct 或 mutable struct 关键字，它们的语法与声明超类的语法相同。新类型可以包含多个字段，对象在这些字段中存储值。作为示例，让我们定义一个具体的类型，它是 MyAbstractType 的子类型： mutable struct MyType <: MyAbstractType foo bar::Int end 我们刚刚创建了一个名为 MyType 的复合结构类型，它是 MyAbstractType 的一个子类型，有两个字段：foo 可以是任何类型，bar可以是 Int 类型。 如何创建 MyType 对象？默认情况下，Julia 会自动创建一个构造函数，该函数返回该类型的对象。该函数具有相同的类型名称，并且该函数的每个参数对应于每个字段。在此示例中，我们可以通过键入以下命令来创建新对象： julia> x = MyType("Hello World!", 10) MyType("Hello World!", 10) 这将创建一个 MyType 对象，并赋值 Hello World! 到 foo 字段和 10 到 bar 字段。我们可以使用点符号访问 x 的字段： julia> x.foo "Hello World!" julia> x.bar 10 此外，我们还可以轻松地更改可变结构的字段值： julia> x.foo = 3.0 3.0 julia> x.foo 3.0 注意，由于我们在创建类型定义时没有指定 foo 的类型，所以可以随时更改它的类型。 而不同指出在于，当我们尝试更改 x.bar 字段的类型(根据 MyType 的定义，我们将其指定为 Int )时： julia> x.bar = "Hello World!" LoadError: MethodError: Cannot `convert` an object of type String to an object of type Int64 This may have arisen from a call to the constructor Int64(...), since type constructors fall back to convert methods. 错误消息告诉我们 Julia 无法更改 x.bar 的类型。这确保了类型稳定的代码，并且可以在编程时提供更好的性能。作为性能提示，在定义类型时指定字段的类型通常是很好的做法。 缺省构造函数用于简单的情况，在这种情况下，您键入类似 typename(field1, field2) 之类的内容来生成该类型的新实例。但有时您希望在构造新实例时执行更多操作，例如检查传入的值。为此，您可以使用内部构造函数，即类型定义中的函数。下一节将展示一个实例。 下面是一个示例，说明如何创建一个可以处理老式英国货币的简单复合类型。在英国看到曙光并引入十进制货币之前，货币体系用了英镑、先令和便士，其中一英镑由20先令组成，一先令由12便士组成。这就是所谓的 £sd 或 LSD 系统(拉丁语的LiBRAE，Solidii，Denarii，因为该系统起源于罗马帝国)。 要定义合适的类型，开始一个新的复合类型声明： struct LSD 要包含以英镑、先令和便士为单位的价格，此新类型应包含三个字段：英镑、先令和便士： pounds::Int shillings::Int pence::Int 重要的任务是创建 构造函数。它与类型具有相同的名称，并接受三个值作为参数。在检查了几个无效值之后，特殊的 new() 函数将创建一个带有传入值的新对象。请记住，我们仍然在类型定义中：这是一个内部构造函数。 function LSD(a,b,c) if a < 0 || b < 0 || c < 0 error("no negative numbers") end if c > 12 || b > 20 error("too many pence or shillings") end new(a, b, c) end 现在我们完成类型的定义 end 下面是完整的类型定义： struct LSD pounds::Int shillings::Int pence::Int function LSD(a, b, c) if a < 0 || b < 0 error("no negative numbers") end if c > 12 || b > 20 error("too many pence or shillings") end new(a, b, c) end end 现在有可能创造出新的物品来储存老式的英国价格。使用其名称(调用构造函数)创建此类型的新对象： julia> price1 = LSD(5, 10, 6) LSD(5, 10, 6) julia> price2 = LSD(1, 6, 8) LSD(1, 6, 8) 而且，由于构造函数中添加了简单的检查，所以不能创建糟糕的价格： julia> price = LSD(1,0,13) ERROR: too many pence or shillings Stacktrace: [1] LSD(::Int64, ::Int64, ::Int64) 如果检查我们创建的某个价格“对象”的字段： julia> fieldnames(typeof(price1)) 3-element Array{Symbol,1}: :pounds :shillings :pence 您可以看到以下三个字段，它们存储这些值： julia> price1.pounds 5 julia> price1.shillings 10 julia> price1.pence 6 下一项任务是使此新类型的行为方式与其他 Julia 对象相同。例如，我们无法让两个价格相加： julia> price1 + price2 ERROR: MethodError: no method matching +(::LSD, ::LSD) Closest candidates are: +(::Any, ::Any, ::Any, ::Any...) at operators.jl:420 而且输出肯定可以得到改善： julia> price2 LSD(5, 10, 6) Julia已经有了加法函数(+)，其中包含为许多类型的对象定义的方法。下面的代码添加了另一个可以处理两个LSD对象的方法： function Base.:+(a::LSD, b::LSD) newpence = a.pence + b.pence newshillings = a.shillings + b.shillings newpounds = a.pounds + b.pounds subtotal = newpence + newshillings * 12 + newpounds * 240 (pounds, balance) = divrem(subtotal, 240) (shillings, pence) = divrem(balance, 12) LSD(pounds, shillings, pence) end 这个定义教 Julia 如何处理新的 LSD 对象，并向 + 函数添加一个新方法，这一个方法接受两个 LSD 对象，将它们相加，并生成一个新的 LSD 对象。 现在你可以将两个价格相加： julia> price1 + price2 LSD(6,17,2) 这的确是将 LSD(5,10,6) 和 LSD(1,6,8) 相加的结果 下一个要解决的问题是 LSD 对象的不吸引人的表示。我们通过添加新方法，以完全相同的方式修复了此问题，但这次是添加到 show() 函数中，该函数属于 Base 环境： function Base.show(io::IO, money::LSD) print(io, "£$(money.pounds).$(money.shillings)s.$(money.pence)d") end 在这里，io 是所有 show() 方法当前使用的输出通道。我们添加了一个简单的表达式，用适当的标点符号和分隔符显示字段值。 julia> println(price1 + price2) £6.17s.2d julia> show(price1 + price2 + LSD(0,19,11) + LSD(19,19,6)) £27.16s.7d 可以添加一个或多个别名，这些别名是特定类型的备用名称。由于 Price 是 LSD 的一种更好的表达方式，我们将创建一个有效的替代方案： julia> const Price=LSD LSD julia> show(Price(1, 19, 11)) £1.19s.11d 到目前为止，还不错，但这些 LSD 对象还没有完全开发出来。如果要执行减法、乘法和除法运算，则必须为这些函数定义用于处理LSD的其他方法。减法很简单，只要用先令和便士来摆弄就行了，所以我们暂时不谈这个问题，但是乘法呢？价格乘以数字涉及两种类型的对象，一种是 Price / LSD对象，另一种是--嗯，任何正实数都应该是可能的： function Base.:*(a::LSD, b::Real) if b < 0 error("Cannot multiply by a negative number") end totalpence = b * (a.pence + a.shillings * 12 + a.pounds * 240) (pounds, balance) = divrem(totalpence, 240) (shillings, pence) = divrem(balance, 12) LSD(pounds, shillings, pence) end 与我们添加到 Base 的 + 函数中的 + 方法一样，Base 的 * 函数的这种新的 * 方法专门定义为将价格乘以数字。第一次尝试的效果出乎意料的好： julia> price1 * 2 £11.1s.0d julia> price1 * 3 £16.11s.6d julia> price1 * 10 £55.5s.0d julia> price1 * 1.5 £8.5s.9d julia> price3 = Price(0,6,5) £0.6s.5d julia> price3 * 1//7 £0.0s.11d 然而，有些失败是可以预料到的。我们没有考虑到一分钱中真正过时的部分：半分钱和一分钱： julia> price1 * 0.25 ERROR: InexactError() Stacktrace: [1] convert(::Type{Int64}, ::Float64) at ./float.jl:675 [2] LSD(::Float64, ::Float64, ::Float64) at ./REPL[36]:40 [3] *(::LSD, ::Float64) at ./REPL[55]:10 (答案应该是 1.7欧元7又二分之一欧元。不幸的是，我们的 LSD 类型不允许一分钱的零碎。) 但还有一个更紧迫的问题。此时此刻，你必须先给出价格，然后再乘以乘数；反过来说，结果是失败的： julia> 2 * price1 ERROR: MethodError: no method matching *(::Int64, ::LSD) Closest candidates are: *(::Any, ::Any, ::Any, ::Any...) at operators.jl:420 *(::Number, ::Bool) at bool.jl:106 ... 这是因为，尽管Julia可以找到匹配的方法 (a::LSD, b::Number) ，但却找不到另一种方法：(a::Number, b::LSD)。但是添加它是非常容易的： function Base.:*(a::Number, b::LSD) b * a end 它向Base的 * 函数添加了另一个方法。 julia> price1 * 2 £11.1s.0d julia> 2 * price1 £11.1s.0d julia> for i in 1:10 println(price1 * i) end £5.10s.6d £11.1s.0d £16.11s.6d £22.2s.0d £27.12s.6d £33.3s.0d £38.13s.6d £44.4s.0d £49.14s.6d £55.5s.0d 现在的价格看起来就像一家19世纪的英国老店。真的！ 如果您想查看到目前为止已添加了多少个方法来处理这种旧的英磅类型，请使用 methodswith 函数： julia> methodswith(LSD) 4-element Array{Method,1}: *(a::LSD, b::Real) at In[20]:4 *(a::Number, b::LSD) at In[34]:2 +(a::LSD, b::LSD) at In[13]:2 show(io::IO, money::LSD) at In[15]:2 到目前为止只有四个……您还可以继续添加方法，使该类型更加有用。这将取决于您对自己或其他人使用它的设想。例如，您可能希望添加除法和模数方法，并对负货币值进行智能操作。 这种用于持有英国价格的复合类型被定义为不可变类型。创建价格对象后，不能更改这些对象的值： julia> price1.pence 6 julia> price1.pence=10 ERROR: type LSD is immutable 要基于现有价格创建新价格，您必须执行以下操作： julia> price2 = Price(price1.pounds, price1.shillings, 10) £5.10s.10d 对于这个特定的示例，这不是一个大问题，但是当您可能希望修改或更新某个类型中的字段的值，而不是创建一个具有正确值的新字段时，会出现许多应用场景。 对于这些情况，您需要创建一个可变结构 mutable struct。根据对类型的要求，在 struct 和 mutable struct 之间进行选择。 有关模块和从其他模块导入函数的更多信息，请参见 Modules and packages。 |
藥物化學/抗癌藥/Dactinomycin 由Streptomyces parvullus 發酵得到的主成分 兩個五胜肽內酯環與三環芳香化合物-actinocin（或說phenoxazinone）相連，因此結構平坦 具有光敏感性 與位於位於相同一條DNA鏈上的鳥嘌呤和胞嘧啶相連 抑制含有促進致癌的四重複G序列的寡核苷酸行聚合 Phenoxazinone中的p-benzoquinoneimine使得藥物分子容易被NADPH/CYP450還原酶摧化，產生自由基，破壞DNA，如下圖 |
WebQuest網路探究/「評核」模組的設計 WebQuest網路探究 - 「評核」模組的設計 評核的目的及特點 讓教師有效估價學生活動的努力程度 讓學生和教師自我評估他們的學習 提供回饋並調整相應的指導和評價 專注於測量的既定目標 使用評核的優點 使評估更加客觀一致 老師澄清其標準及具體條款 清楚表明對於學生所需進行的工作和期望 促進學生認識有關標準使用性能評估 提供有用的回饋意見及有效的說明 提供基準以用來衡量和記錄進度 由以上幾點，我們可得知評估的重要性。對於初次接觸ＷＥＢＱＵＥＳＴ的人來說，設計出好用的評估準則有些困難，Dr. Dodge在其網站中提供了一個相當方便的範本，協助老師設定。 根據上述的表格，老師先逐項列出希望學生學習的目標，接著再按照本次課程及學生進度，挑選出學生能夠達成的目標或績效， 接著再寫出個項目標評級的準則。以下列出幾個資料庫，讓老師們可以從中參考 http://questgarden.com/ http://www3.fed.cuhk.edu.hk/community/webquest/ http://webquest.org/index-create.php 參考網站: http://web.cjjh.tc.edu.tw/~sciedu95/wave/webquest/aboutwebquest.files/frame.htm http://translate.googleusercontent.com/translate_c?hl=zh-TW&langpair=en%7Czh-TW&rurl=translate.google.com.tw&u=http://webquest.sdsu.edu/rubrics/weblessons.htm&usg=ALkJrhgeuYF-L_mkLc7JnGtZ1nSMHmsouQ http://webquest.org/index-create.php http://www2.hkedcity.net/iclub_files/a/1/119/webpage/project_learning_03/feature/jun04/webquest/page2c.htm |
2019年集思廣憶賽事特刊/記憶故事3／政治／上頁 「一府．二鹿．三艋舺」描述清領時期，台灣島政經重心由南轉至中北部的開墾史，各朝代統治者為政治或殖民統治的教育宣導目的，台灣從南到北都有許多建築物，代表當時治理者對於這塊土地的用心。清治屯墾進而駐兵的『滬尾礮臺』；荷蘭統治時期，淡水留下不少如軍事目的『紅毛城』；還有當時商業目的茶葉外銷洋行「嘉士洋行」的英籍商人范嘉士所建倉庫的。日治時期用心殖民，除建立總督府（現總統府）、總督官邸（現台北賓館）及各式官房廳社，這些都已成為台灣歷史的一部份。 國民政府抵台後，在陽明山中山樓舉辦了數十年的國大會議，並在蔣中正總統逝世後，蓋了中正紀念堂。台灣近三十年的政治事件都與其場域及背後所代表的都有不可抹去的政治意義。 台灣博物館展現了台灣的過去、現在的歷史價值。每個時期來到台灣生活的人，都想擁有這美麗寶島，不論用甚麼方式在這寶島上生活，都為這塊土地點綴拼出最美的台灣政治文化。 |
分子生物学/細胞週期/Flow cytometry 儀器外貌 利用等張溶液，讓含有螢光標記的液體樣本越來越狹窄，直到寬度只有一個細胞大小，然後利用雷射激發檢品中的螢光物質，使其散發螢光並由感應器偵測螢光強度，或是偵測發散光的折射角度 圖下為應用於（正常細胞之）細胞週期實驗的數據 橫軸為螢光強度，縱軸為細胞數量，最高峰（左邊往右邊數的第一個波鋒）代表細胞在G1，此時的染色體數量為2n；下一個明顯的波鋒則代表細胞在G2和M期，此二期的染色體數量皆為4n；介在這兩明顯波峰之間代表著S期，染色體正在複製，因此染色體數量從2n到4n都有。由於細胞週期中，有約46%的時間在G1（為細胞週期四個階段中所站時間最長的時期），因此第一個波鋒的高度最高，因為大部分的細胞落在此時期 |
Julia for MATLAB Users Template:Under Construction Julia for MATLAB Users A Free Online Reference This Wikibook is a place to capture information that could be helpful for people interested in migrating code from MATLAB™ to Julia, and also those who are familiar with MATLAB and would like to learn Julia. It is meant to supplement existing resources, for instance the noteworthy differences from other languages page from the Julia manual. However this wiki intends to be more comprehensive, and to be structured in such a way as to make it easy for one to find answers to questions like: For a given MATLAB or MATLAB toolbox command/function/construct what are the closest Julia equivalents? For a given MATLAB toolbox, what Julia packages provide similar functionality? All of the content here is geared towards someone with a MATLAB background. In general this book assumes that the reader is well acquainted with the fundamentals of MATLAB and any aspects of that product that they are interested in seeing the Julia equivalent(s) for. This book is not intended to be a resource for learning MATLAB! In contrast, we do not assume any knowledge of Julia, but leave general purpose introductions to the language to other resources (see Related Resources below for some of these). The book contains distinct sections offering readers different ways to approach learning how to use Julia from the point of view of a MATLAB user. This part provides a guided tour of Julia intended to orient a typical MATLAB user to some of the most significant aspects of Julia, emphasizing what might be some of the more unexpected differences and also highlighting some of the areas where Julia has particular strengths relative to MATLAB. This part includes short tutorials that walk MATLAB users through some typical example scenarios, each demonstrating how some particular workflow or idiom from MATLAB would translate to Julia. The organization of this part of the book mirrors that of the MathWorks' on-line documentation; that is, the core MATLAB language features are together in the MATLAB section which when complete would map everything found in the core MATLAB documentation to Julia equivalents, while another section on the Control System Toolbox, for instance, would map functionality documented in its toolbox documentation page to Julia equivalents. The most recent MATLAB documentation (currently R2018a) is assumed unless otherwise specified. In general when equivalent Julia 1.0 (i.e. 0.7 without deprecation warnings) functionality exists this is what will be linked to, but in cases where this does not exist but an earlier version, e.g. 0.6, has the functionality the latter may be linked to. The learning section at Julia's official site. Julia documentation, a.k.a. the Julia manual. noteworthy differences from MATLAB Packages Julia package index Julia Observer Julia Discourse forums QuantEcon MATLAB - Python - Julia Cheatsheet Automatic MATLAB to Julia converter (limited in its usefulness, especially for functions in toolboxes) Package for calling MATLAB in Julia through MATLAB Engine: MATLAB.jl Rosetta Code Julia category and MATLAB category MatlabCompat.jl (appears to be unmaintained) Introducing Julia Wikibook Basic Comparison of Python, Julia, Matlab, IDL and Java (2018 Edition) Contributions are encouraged! See the WikiBooks Help:Contributing page. In particular here are some notes on contributions to this book. Of course, follow the Wikibooks Manual of Style. In addition, specific to this book the following style conventions apply. Command and function names in either language when written inline should be in code text format. In addition in the individual command/function name sections the MATLAB command/function names should link to an appropriate page in the MATLAB documentation and similarly for the Julia equivalent where it is first mentioned on that page. For example, see the entry for ans. In general the intent is to capture the information itself in this wiki, for the same reasons as this is encouraged on Stack Overflow: Provide context for links Links to external resources are encouraged, but please add context around the link so your fellow users will have some idea what it is and why it’s there. Always quote the most relevant part of an important link, in case the target site is unreachable or goes permanently offline. As such, it is assumed that the main Julia documentation isn't at risk of going offline, but the salient points from other sources should in general be included in this wiki so it is largely self-contained (and thus is itself suitable for offline use). Of course, attribution by means of links to sources of information is highly encouraged. Template:Subjects/0 Only the most recent MATLAB documentation is available on the MathWorks' website without a login; previous releases' documentation is accessible with but only with a login (though creating one appears not to require a MATLAB license). https://stackoverflow.com/help/how-to-answer |
初中物理/声波的特征 声波的特征有三种：音调、响度、音色。 物体振动的频率越高，音调越高。频率指物体每秒振动的次数，单位为赫兹（Hz) 人能发出声音的频率为85~1100Hz 人能接收到的声音频率为20~20000Hz（所以，20Hz以下的声音被称为次声波，20000Hz以上的声音被称为超声波，这两种声波人耳听不见） 物体振动的幅度越大，响度越大。响度的单位为分贝（dB) 人正常交谈声音为60分贝左右。 音色指声音的特色。音色由发声物体的结构，材质及发声方式等决定。 人能够在听歌时分辨出是谁在唱歌，就是因为歌手的音色各不相同。 |
Git 维基百科中的相关条目： Git git，是一个w:分散式版本控制软件，最初由w:林纳斯·托瓦兹（Linus Torvalds）創作，於2005年以w:GPL釋出。 git是用于Linux内核开发的版本控制工具。与w:CVS、w:Subversion一類的集中式版本控制工具不同，它采用了分布式版本库的作法，不需要服务器端软件，就可以運作版本控制，使得源代码的发布和交流极其方便。git的速度很快，这对于诸如Linux内核这样的大项目来说自然很重要。git最为出色的是它的合并追踪（merge tracing）能力。 主页面：git/git简明用法 git和其他w:版本控制系统（如CVS）有不少的差别，git本身关心檔案的整体性是否有改變，但多數的版本控制系统如CVS或w:Subversion系统則在乎檔案内容的差异。git拒绝保持每个文件的版本修订关系。因此查看一个文件的历史需要遍历各个history快照；git隐式处理文件更名，即同名文件默认为其前身，如果没有同名文件则在前一个版本中搜索具有类似内容的文件。 每个用户都可有全部开发历史的本地副本，changes从这种本地repository复制给其他开发者。这些changes作为新增的开发分支被导入，可以与本地开发分支合并。 分支是非常轻量级的，一个分支仅是对一个commit的引用。 git是用C语言开发的，以追求最高的性能。git自动完成垃圾回收，也可以用命令git gc --prune直接调用。 git存储每个新创建的object作为一个单独文件。为了压缩存储空间占用， packs操作把很多文件（启发式类似名字的文件往往具有类似内容）使用w:差分压缩入一个文件中（packfile），并创建一个对应的索引文件，指明object在packfile中的偏移值。新创建的对象仍然作为单独文件存在。repacks操作非常费时间，git会在空闲时间自动做此操作。也可用命令git gc来直接启动repack。packfile与索引文件都用SHA-1作为校验和并作为文件名。git fsck命令做校验和的完整性验证。 Git服务器典型listenTCP port 9418. 文件有三种状态：已提交（committed），已修改（modified）和已暂存（staged）。已提交表示该文件已经被安全地保存在本地数据库 中了；已修改表示修改了某个文件，但还没有提交保存；已暂存表示把已修改的文件放在下次提交时要保存的清单中。 理解Git的内部目录结构对于理解Git是如何工作的有重要作用。 . └── .git/ ├── HEAD ├── branches/ ├── config ├── description ├── hooks/ │ ├── applypatch-msg.sample │ ├── commit-msg.sample │ ├── post-update.sample │ ├── pre-applypatch.sample │ ├── pre-commit.sample │ ├── prepare-commit-msg.sample │ ├── pre-push.sample │ ├── pre-rebase.sample │ └── update.sample ├── info/ │ └── exclude ├── objects/ │ ├── info/ │ └── pack/ └── refs/ ├── heads/ └── tags/ objects：存放git對象 上一次提交的信息保存在这个文件中。可用文本编辑器处理。 最后一次的Git命令fectch的操作信息保存在这里。可用於下次Git命令merge。 指向當前被检出的代码（checked out code），也就是当前所在的工作分支。一般指向refs下的某文件。 也可以进入"detached HEAD"状态，这时你不在一个本地分支上，而是HEAD直接指向一个提交（commit）而不是一个分支。 当前git仓库的配置文檔，包含如果在本地仓库管理与存储数据，已知的远程仓库，本地用户信息，其他配置数据。 可用文本编辑器来编译此文档，或者用Git命令config。 供仓库浏览器工具使用，包含了当前项目（project）的描述。在非共享仓库中通常不改变。 是缓冲（staging）区域。包含了紧凑形式的已经被staged的文件改变信息供下一次commit使用。 用户的个人专用文件，针对仓库的个人副本。 如果此文件存在，仓库的每个远程或本地的分支，以及tags，除了在refs/heads与 refs/tags有对应的单个文件外，还在此文件中有对应的一行。适用于大型仓库。 改变当前分支的commit历史的操作在本文件中保存前一次HEAD的值，以允许从错误中恢复。 未见使用 存儲鉤子的文件夾。包含了git仓库特定事件发生时要运行的脚本。Git给出的脚本，使用扩展名.sample。 存儲日誌（reflogs）的文件夾。reflog用于记录那些不保存在提交历史中的事情，如rebases, fast-forward merges, resets等。每个分支有一个reflog。reflog不是仓库的公开部分，它严格特定于局部副本仓库，其信息保留有限时间（确省为两周）。可用於从错误中恢复。 所有的文件、目录列表、commits的存储之地。 未包装（unpacked）的对象存在其下的几个目录里，多个压缩后的对象的包装在一个包装目录里。自动运行的"git gc"会收集未包装的对象压缩后放入包装目录。 每个本地分支的head commit对应单个文件。另见info/refs 已经定义的每个远程仓库对应一个子目录。在子目录中，每个远程分支定义了一个tip commit。 Can contain one file defining the commit corresponding to each tag (but see info/refs above). 每个tag的commit对应单个文件。另见info/refs 如果需要Git命令svn提交到一个Subversion服务器. Git有两种数据结构：可变的索引（index或stage或cache)用于缓冲工作目录信息与下一次提交的版本信息；不变的、仅追加的对象数据库。 对象数据库包含5类对象： blob：二进制大对象包含了一个文件的全部内容。Blobs没有适当的文件名、时间戳、或其他元数据。一个blob的内部名字是它的内容的hash。 tree对象：等效于一棵目录树。包含全部包含的文件路径信息以及文件的模式（mode）、blob或tree对象的ID。tree对象是源树(source tree)的快照。用[[:w:默克树}}实现。由于并不包含目录自身的信息，所以git仓库不记录子目录创建或删除的信息，仅记录所包含的文件。 commit对象：指向一棵树表示了commit之后源树的状态。commit对象链接tree对象在一起而成为history。commit对象 包含顶层源目录的tree对象名字、一个时间戳、提交作者信息、log信息、0个或多个父commit对象的名字。 tag对象是一个名字指向到一个commit，也可以增加关于另外对象的元数据。它可用於数字签名，以保证特定版本的身份真实。 branch对象是一个名字指向到一个commit，对于当前检出的分支，在下一次commit时会自动修改branch对象指向最新的commit。 Blob, tree与commit对象用其内容的SHA-1 hash作为ID。对象放入它的hash值得前两个字符标识的目录中，其余hash字符作为这个对象的文件名。 Git数据库中不变引用的对象将会被垃圾回收清除。Git命令可以创建、移动、删除引用。"git show-ref"列出所有引用。某些引用类型： heads: 引用一个本地对象，是commit的指针。每个head可以指任意一个这样的指针。可以包含任意数量的heads。而"HEAD"（全部大写），仅仅指的是当前有效的head。默认情况下，在每个仓库下都有一个head，叫做master。 remotes: 引用远程repository中的一个对象 stash: 引用一个还没有committed的一个对象 meta: 例如一个bare repository中的一个配置, 用户权限; refs/meta/config命名空间等 tags: Git的提交作为图的节点，父子关系作为图的有向边，那么提交历史构成有向无环图（DAG）。 一个commit是可达的如果它被branch、tag、reflog条目指向，或是一个可达commit的父亲。一棵tree是可达的如果它被一个可达的commit指向。一个blob是可达的如果被一棵可达的tree指向。此外的commit/tree/blob对象都是不可达的，通常是aborted commits、删除掉的branches等的结果，白白占了存储空间。 不可达的对象可用git命令gc收回占用存储空间。这通常可自动被调用。 Git在内部有个指向当前版本的HEAD指针,表示当前的提交（commit）版本，上一个版本就是HEAD^，上上一个版本就是HEAD^^，往上100个版本可以写成HEAD~100。提交（commit）版本也可以用SHA1的hash值表示。 命令git init [repName] 在一个目录下创建指定名字的文件夹或文件夹已存在，并在文件夹中创建一个仓库(repository). 命令git clone git://github.com/schacon/simplegit.git 复制该项目的全部记录到本地；并复制该项目的master分支作为工作文件。 命令git add指出下次commit包含哪个文件。即把指定工作文件加入缓存 -A选项将增加工作目录所有的文件。-u选项仅处理缓冲中有的文件。 命令git reset [-q] [<tree-ish>] [--] <paths>… 命令git reset [commit-object] [--hard] [--soft] [filename]：从分支[commit-object]；如果用--soft选项，那么工作目录与缓存都不变；如果不用--soft选项，那么缓冲更改；如果用--hard选项，那么工作目录也更改。如果指定文件，则该文件更改。 命令git commit来创建一个commit object。新的commit object将会把当前的HEAD作为它的父亲。commit执行后，HEAD将会指向新的commit object 命令git commit -A自动提交工作文件夹内所有修改的文件（新建的文件不包含在内） 提交消息Tim Pope writes 第一行不应超出50字符。如需要进一步详细解释，第二行为空行，从第三行开始写，每行不超过72列。使用缩进（hanging indent）。 命令git status列出当前工作文件和HEAD比较，哪些文件发生了改变。文件有三种状态：新的没有被添加的文件（可用git add命令添加）、修改的但是没有被提交的文件、已经被提交的文件 命令git checkout -- <filename>：把工作区内的指定文件恢复回到最近一次git commit或git add时的状态。如果没有--，就变成了“切换到另一个分支”的命令。 命令git reset HEAD <filename>：把指定文件在暂存区的修改回退到工作区，并把指定文件在暂存区的内容恢复回到最近一次git commit时的状态。即把暂存区的修改撤销掉（unstage），重新放回工作区。 命令git revert <commit>：撤销指定的提交所做的改变，这些操作并作为一次新的提交。 git log [head1]..[head2]：列出head2和head1和head2的公共祖先之间的更改日志。 git reflog：记录了所有的操作历史 命令git mv 文件重命名。等效于git rm –cached orig; mv orig new; git add new 命令git rm <filename>：将文件从缓存区和工作目录删除。 如果要在工作目录中留着该文件，可以使用 git rm --cached 忽略特定文件，针对命令git status与git add -A (增加所有新文件或修改过的文件)。需要注意的是，用git add [filename]增加到缓冲中的文件或者已经提交的文件，是不能忽略的。为忽略某些文件，可把文件名（可带通配符）写入特定的两个文件之一： .git/info/exclude — 这是用户私有的，不是仓库公开的数据。 .gitignore — 由于这是在.git目录之外，它可以被当作普通文件上传到仓库。适合作为项目中所有用户共同遵守的忽略文件的定义。 config help git branch 查看仓库的所有分支 git branch [new-head-name] [reference-to-commit-object]给指定的对象起一个新的名字 git checkout -b [new-head-name] 创建一个分支并置为当前工作分支 git branch -d [head-name] 删除一个本地分支 git push remote_rep :remote_branch_name 删除一个远程分支 git branch -r git checkout [head-name]：设置head-name为当前的head，重写目录下面的所有文件，就可以在其上开始新的工作 git merge [head-name]：把head-name指定的commit对象合并到当前commit对象 git cherry-pick："复制"一个提交节点并在当前分支做一次完全一样的新提交。 git rebase [branch-name] 衍合是合并命令的另一种选择。在[branch-name]重演当前分支的历史，提交历史是线性的。 本质上，这是线性化的自动的 cherry-pick。 --abort删除一个commit。 mergetool git log --merge 用于合并冲突 git log --graph --oneline --decorate --all [branch_name] ^[exclude_branch_name] 显示一个分支的各个commit的信息 git diff --merge 3路diff stash git tag -a [mytag] [my-branch] 创建一个带注解的标签 git fetch [remote-alias] 更新/同步本地项目 git pull [remote-alias] 相当于fetch加上merge git push [remote-alias] [branch] 分享本地改动。必须是远端分支的fast-forwards才可以上传；否则需要在本地先merge再上传。 git push origin :remoteBranchNameToDelete 删除远程分支 git remote 管理远程仓库 git remote -v 查看远程仓库别名的实际链接地址 git remote add [alias] [url] 添加一个远端仓库 git remote rm [alias] 删除一个远端 git remote show origin submodule git show <commit>:<filename> 展示某个提交版本的某个文件的内容 命令git diff:列出当前工作目录与当前缓存之间的差别，产生的输出兼容于diff -u的输出。 git diff --cached，列出当前缓存与当前commit对象之间的差别 git diff HEAD，列出当前工作目录与当前commit对象之间的差别 git diff [head1]..[head2]：列出head1 和head2之间的区别 git diff [head1]...[head2](中间三个点)：列出head1和head2以及他们所有的祖先之间的区别。 git format-patch origin/master 创建origin与master之间的patch，产生的输出兼容于diff -u的输出。 git am： automatically apply it and save the commit git apply --stat P1.txt git apply --check P1.txt git am < P1.txt git merge-base [branchA] [branchB] 最近的共同祖先提交 shortlog describe bisect blame grep bisect blame grep am apply format-patch send-email request-pull svn fast-import clean gc fsck reflog filter-branch instaweb archive bundle daemon update-server-info cat-file commit-tree count-objects diff-index for-each-ref hash-object ls-files read-tree rev-list rev-parse show-ref symbolic-ref update-index update-ref verify-pack write-tree GitHub Desktop:可用于第三方Git仓库网站 Git for Windows w:TortoiseGit SourceTree GitEye git - Definition and pronunciation. Oxford Learner's Dictionaries. Gerrit Code Review – Project Configuration File Format Using GitHub for Windows with non-GitHub repositories git官方网站（英文） git快速入门（英文） git Man Page（英文） git用户手册（英文） git Community Book（英文） 使用git管理源代码 git# (gitSharp)（英文） GNU Interactive Tools git从入门到精通P 連猴子都能懂的Git入門指南（正体中文） |
WebQuest網路探究/網路探究的基本模組 WebQuest包括以下6個方面的內容模組： （1）情境介紹（Introduction）：一個構建“知識鷹架”的導言，提供本次探究的背景資訊。 （2）學習任務（Task）：一個可能完成的並且是有趣的任務。 （3）探索過程（Process）：一個探究學習的過程描述。即學生探究學習的步驟，每一步驟都有清晰的指導說明。 （4）網站資源（Resources）：完成任務所必須的資訊資源。通常，許多資源是超連結在WebQuest文字中，作為問題探究的“定錨點”。這些資源包括：網站資料、透過E-mail聯繫的專家、實際的參考資料、在網路上的調查資料庫，也包括傳統印刷的書籍和文獻。這些資源將引導學生不至於在 網路空間因盲目地漫遊而分心，甚至忽略了探究學習的主要目標。 （5）評鑑（Evaluation）：有兩種模式，第一種模式是對“指導”如何組織現有資訊的層次規準。可以是問題求解的“導航”，或是如何完成任務的指導框架，如時間進度、概念圖表、因果分析圖示等等。另一種模式是Webquest的設計者後來所用的“評鑑Evaluation”模組取代了“指導”模組 （指導也可包括在探索過程Process模組中），亦即：對探究學習效果與可行性的評價。網路探究學習是一種較高水準的學習，在布盧姆Bloom's教育目標分類（知識、理解、應用、分析、綜合、評鑑）中，處於最高的位置。WebQuest通常採用評鑑表來考察學生作品的不同方面（包括過程、 結果、態度、情感等）。評鑑人員可以是教師，也可以是家長和同學。另外，根據任務的差異，評鑑的作品可表現為書面作業、學生的作品、創作的網頁或其他內容。 （6）結論（Conclusion）：完成這次探究學習的結論。提示學生已經學到了什麼，並鼓勵他們發表這次探究的經驗如何擴展到其他領域、發現什麼新問題，以及有何感想等。 另外WebQuest分為兩種層次:短期與長期 （1）短期WebQuest探究學習指的是1～3節課的單元學習，其主要目標是知識的獲取和整合。某次學習結束後，學生能夠獲得大量有用的新資訊，並獲得探究體驗和感受。 （2）長期WebQuest探究學習的學習目標是擴展和提煉出新的概念，時間在一週到一個月之間。 無論是短期抑或是長期都適用於以上六方面的模組 參考資料: 1.http://www.wretch.cc/blog/miyaka0803/20795035 2.http://www.stnn.cc:82/gate/big5/blog.stnn.cc/avexazhong/Efp_Bl_1004916539.aspx 3.http://zh.wikiteamwork.wikia.com/wiki/WebQuest |
藥物化學/抗癌藥/Anthracyclines and Anthracenediones 來自Streptomyces 結構類似四環素 屬於配醣體，由胺基糖類（L-daunosamine）和非醣之四環骨架（anthroquinone，或稱anthracycline）組成 phenolic 基團使其具有光敏感性 主要為TopIIα 毒化劑： Daunosamine 與 DNA 小溝結合 3' 離子化胺基可與 DNA 的磷酸基團互相吸引，使之接近並與 guanine 的 2號碳上胺基形成共價鍵（因此缺少3' 離子化胺基或改變其構形成 𝛃 form，會降低藥物與 DNA 的結合能力） 含平面環，可平行嵌入DNA鹼基，生成複合物 為細胞週期非專一性藥物 產生自由基，造成心臟毒性（因為心肌組織沒有明顯足夠多的catalase與相關細胞保護酵素），次要機轉則為夠過NF-kB誘導細胞凋亡 也因為它的結構，會去螯合鐵離子，導致細胞中鐵離子可用濃度下降，下圖為此藥物螯合鐵離子情形，以及細胞如何應對可被利用鐵離子濃度下降的情況 服用藥物時要避免外滲，以免造成皮膚潰爛 活化P-gp和MDR轉運酶將藥物排出細胞外 改變癌細胞對於觸發細胞凋亡的反應 改變TopIIα的基因表現程度和活性 生化防禦anthracycline誘導氧化壓力 將藥物轉運到細胞外 可以服用Epigallocatechin 3-gallate（EGCG，在綠茶中找到）來抑制細胞將Doxorubicin排出細胞外 Doxorubicin Epirubicin Valrubicin Daunorubicin Idarubicin Mitoxantrone |
Introducing Julia/Migrating From Other Languages Julia 文档里的与其他语言的显著差异章节是值得一读的好材料。里面对比了 Julia 与 MATLAB、R、Python、C/C++ 等语言的显著差异。 维基教科书：为 MATLAB 用户准备的 Julia 教程 |
C++/資料輸入輸出 一門程式語言的第一個步驟就是，在控制台上顯示出文字，也就是純文字模式，儘管這很無聊，但是這可以讓程式設計師只注重於邏輯上。 C++語言的副檔名為「*.cpp」，可以使用任意一個純文字編輯軟體撰寫程式，例如Win下的「記事本 」；然而MSO的「Word」則不是好選擇，那是因為它可以設定字型大小、插入表格等等，這不是純文字的。在寫完程式後，需要將其進行編譯（Compile），所以也會需要編譯器（Compiler）。但我並不推薦這樣，大多數人也不會這樣，因為如果程式碼有錯，你很可能不會發現，直到編譯錯誤。 所以使用「整合開發環境（Integrated Development Environment，IDE）」會更好。 整合開發環境是協助程式設計師撰寫程式的工具，包含純文字編輯器等，通常含有「自動建構（Build automation）」與「除錯（Debug）」，甚至某些還含有編譯器。以下為推薦的IDE。 ※不按推薦程度排序！ 這是一款強大的IDE，支援許多程式語言及語言，且包含編譯器，有許多的使用者。不過雖過於強大，儘管有中文介面，對初學者可能還是不太好操作，因此較沒有那麼推薦。 維基百科 官網 推薦程度（僅供參考）：★★★☆☆ 如果只需要寫C++的話，可以不需要其他語言，可以使用VC++。 維基百科 官網 推薦程度（僅供參考）：★★★★☆ 適用於初學者，不過於簡單，也不過於複雜，儘管需要付費，但如果是學生或老師的話只要提供edu E-mail即可（例s1080101@csps.tp.edu.tw），也有其他優惠選項。該公司也有各種語言的IDE。 維基百科：暫時沒有 官網 推薦程度（僅供參考）：★★★★★ 臺灣許多大學課程皆是使用這套IDE，主要是因為輕便、有中文化界面。但是做為免費開源軟體，該公司已經倒閉，十多年無更新（被別的公司買下，可能有），有幾百甚至幾千個bug。 維基百科 載點 推薦程度（僅供參考）：☆☆☆☆☆ 有中文介面，但很少更新，其被發現bug非常多。 維基百科 官網 推薦程度（僅供參考）：☆☆☆☆☆ 可以參考維基百科，為何是用它來作為測試，不過這不是重點。 在C++中，你可以使用C的寫法，或是C++引進的「物件導向」概念。 #include <iostream> int main() { std::cout << "Hello World!" << std::endl; return 0; } ================================================================================ #include <cstdio> int main() { printf("Hello World!"); return 0; } ================================================================================ #include <stdio.h> int main() { printf("Hello World"); return 0; } 上面三段程式碼是一樣的，最底下是C的寫法，在C++中可以使用C的庫；中間是C++化的函式庫，可以看見前面加上了c、去掉了.h。最推薦的當然是第一個，因為他要輸出變數比較方便（先不解釋語法，待〈變數〉再論）。 在C++中，字串必須要用雙引號""框起，且絕對不能使用單引號''，因為那是代表字元。 endl則是End Line（結束此行）的縮寫，也就是可以用他換行，如果不想要換行，改成（也可以完全刪掉，但建議使用）flush。 |
園藝/造園/園藝技術 首页 > 維基書架 > 自然科學書架 > 園藝>造園>園藝技術 園藝是農業的一部分，在農業中園藝是最有趣味性，且最高尚、進步的事業，它可以陶治性情。 園藝一詞，字面上包括「園」和「藝」二字，園字由口、袁二字所組成。口字是垣籬、界限、範圍的意思，而袁字在說文中記載：「袁，袁衣之貌也」，而動物中只有人穿衣，所以園是人設圍籬保護的耕作地區。倉頡解字記載：「種樹曰園，種菜曰圃」，而辭源中解釋：「圃，園也」，因此在園中不只種果樹，也種蔬菜。 藝字，就是才能技術，並且有熟能生巧的意思，在農業來說即是栽植培養的技術。 一.蔬菜：係研究疏菜的栽培管理、處理及利用之科學，包括： (一) 蔬菜分類學： (二) 蔬菜栽培學： (三) 新鮮蔬菜栽培學： (四) 促成蔬菜栽培學： (五) 加工蔬菜栽培學： (六) 採種企業： 二.果樹：係研究果樹的栽培管理、處理及利用之科學，包括： (一) 果樹分類學： (二) 果樹栽培學： (三) 果樹運銷學： 三.觀賞植物：係研究觀賞植物的栽培管理、處理及利用之科學，包括： (一) 花卉栽培學： (二) 觀賞樹木學： 四.造園：係以人為的方法美化土地環境之之科學，包括： (一) 造園原理學： (二) 風景設計： (三) 建築設計學： (四) 植栽設計： (五) 造園描畫學： (六)造園管理學： 園藝起源早，並與人類歷史有密切的關係。 一.蔬果能增進國民的健康： (一) (二) 二.花卉可陶治性情： (一) (二) (三) 三.觀賞植物能美化環境及調節環境： (一) (二) 四.園藝能輔助教育： (一) (二) 五.園藝為可開發的資源： (一) (二) 一.蔬果的分類： (一) (二) (三) (四) (五) (六) 二.果樹的分類： (一) (二) (三) (四) 三.觀賞植物的分類： (一) (二) (三) (四) (五) (六) 一. 二. (一) (二) (三) 三. (一) (二) (三) (四) 一. 二. 三. 一. (一) 1. 2. 3. (二) 1. 2. 3. 4. 5. 6. 二. 1. 2. 3. 4. 5. 6. 7. 8. 9. 三. 1. 2. 3. 4. 5. 6. 四. (一) 1. 2. 3. 4. 5. (二) 1. 2. 3. 4. 维基百科中的相关条目： 園藝 |