如果您想獲取一個字符串數(shù)組并將這些字符串連接成一個大字符串，則可以使用join方法。實例：# 將由'a', 'b', 'c'字符組成的數(shù)組合并成一個字符串a(chǎn)rr = ['a', 'b', 'c']arr.join# ---- 輸出結果 ----"abc"也可以通多傳遞參數(shù)指定字符分隔符。實例：arr = ['a', 'b', 'c']arr.join("-")# ---- 輸出結果 ----"a-b-c"
圖片是文檔中最長出現(xiàn)的媒體文件，是用來表達內(nèi)容的最好載體之一。一篇文章通?？梢栽黾宇^部的封面圖、尾部的簽名圖等。實例 4：做一個類似圖片預覽的效果。#### 拼圖九宮格![][img6]![][img5]![][img4]![][img3]![][img2]![][img1]![][img9]![][img8]![][img7][img1]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101433_eTTNZ.thumb.300_300_c.jpeg[img2]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101434_iWadw.thumb.300_300_c.jpeg[img3]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101434_Z3JVy.thumb.300_300_c.jpeg[img4]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101435_NiLkv.thumb.300_300_c.jpeg[img5]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101437_CxzYm.thumb.300_300_c.jpeg[img6]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101437_wdizF.thumb.300_300_c.jpeg[img7]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101438_J8vff.thumb.300_300_c.jpeg[img8]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101439_cVcLx.thumb.300_300_c.jpeg[img9]: https://c-ssl.duitang.com/uploads/item/202004/10/20200410101439_yhUv3.thumb.300_300_c.jpeg<style>img { width: 150px !important; height: 150px !important; border: 1px solid #EEE;}</style>渲染結果如下：圖片來源于網(wǎng)絡，版權歸原作者所有
let target = {a: 1, b: 1};let source1 = {b: 2, c: 2};let source2 = {c: 3};Object.assign(target, source1, source2);console.log(target); // {a: 1, b: 2, c: 3}如果后面的源對象上有相同的值，后面的源對象會覆蓋前面對象上的值，這一點需要注意。
在前面我們學習了很多種類的變量，每個變量都會有一種類型。但是如果我們需要定義一個變量，可以同時存儲不同的類型的變量，那會在很多場合下很方便的使用。比如我們常見的通信錄，里面會包含很多信息，比如姓名，電話號碼，郵箱地址等信息。這里面就會涉及到整數(shù)，字符串等等。如果每個人建立的時候都分別聲明一次其中的變量，那么工作量就會非常的大，也很容易出現(xiàn)錯誤。那么怎么解決這種情況呢？這就是今天我們要講解的內(nèi)容。
>>> import re>>> re.search('c$', 'abc')<_sre.SRE_Match object; span=(2, 3), match='c'>>>> re.search('c$', 'abcx')>>>在第 2 行，c$ 表示從字符串 ‘a(chǎn)bc’ 的尾部進行匹配在第 3 行，顯示匹配結果不為 None在第 4 行，c$ 表示從字符串 ‘xabc’ 的尾部進行匹配在第 5 行，顯示匹配結果為 None
函數(shù)的定義使用關鍵字fun，函數(shù)參數(shù)格式為: “參數(shù):類型”，函數(shù)返回值類型 fun(...): Int。這種聲明函數(shù)參數(shù)、函數(shù)返回值類型方式正好與 Java 是相反的。//Kotlin定義fun sum(a: Int, b: Int, c: Int): Int { return a + b + c}//Java定義public int sum(int a, int b, int c) { return a + b + c;}
我相信大家都知道經(jīng)典的多繼承問題，俗稱 “鉆石繼承問題”。我們用反證法，假設 Java/Kotlin 中支持類的多繼承，一起來看個例子，對于 A 類中有一個 invoke 方法，B,C 兩個類都去繼承 A 類，然后 D 類去分別去繼承 B，C 類。abstract class A { abstract fun invoke()}class B: A { override fun invoke() = println("B invoke")}class C: A { override fun invoke() = println("C invoke")}class D: B,C {//假設支持類的多繼承 override fun invoke() = println("C invoke")// B ? C}那么問題就來了 D 類應該是繼承 B 類 invoke 方法，還是 C 類 invoke 方法呢？所以這樣類的多繼承很容易帶來歧義。但是我們知道在開發(fā)過程中還是可能遇到多繼承的問題，我們一般常用的方法是采用接口多繼承方式來解決，因為我們知道在 Java 和 Kotlin 中是支持接口的多繼承的。
#include <stdio.h>int main(){ for (int i = 0; i < 10; i++) { printf("No. %d: Hello C Language!\n", i); } return 0;}運行結果：No. 0: Hello C Language!No. 1: Hello C Language!No. 2: Hello C Language!No. 3: Hello C Language!No. 4: Hello C Language!No. 5: Hello C Language!No. 6: Hello C Language!No. 7: Hello C Language!No. 8: Hello C Language!No. 9: Hello C Language!我們首先初始化一個用于循環(huán)控制的變量 i ，當然你看到的大多數(shù)編程書籍都會使用這個變量名，其實你可以使用任意你喜歡的變量名，這個變量名的作用域，也就是變量起作用的范圍僅僅是在這個循環(huán)語句以及包括在緊挨著的大括號內(nèi)，也就是我們經(jīng)常提到的循環(huán)體內(nèi)有效。在初始化用于控制循環(huán)的變量后，我們就要判斷一下這個變量的初始值是不是滿足循環(huán)條件，如果你的初始值不滿足循環(huán)條件，那么后面的循環(huán)一次也不會被執(zhí)行。這個和 do while 語句是完全不同的。如果滿足循環(huán)條件，那么后面大括號中的語句就會被執(zhí)行。這里我們執(zhí)行的語句是輸出一句話。在執(zhí)行完大括號中的內(nèi)容后，for 語句就會執(zhí)行前面圓括號中的最后一個部分，也就是根據(jù)寫入的語句改變循環(huán)控制變量的值。Tips：這里需要注意的是，控制循環(huán)變量的值不是在判斷條件后馬上改變，而是在執(zhí)行完循環(huán)體中的內(nèi)容后才發(fā)生改變。這點從上面實例程序中輸出的序號中可以清晰地看到。
os.chdir(path) 的功能切換當前工作目錄。該函數(shù)的使用示例：>>> import os>>> os.chdir('C:\\Windows')>>> os.getcwd()'C:\\Windows'
Set 實例上的數(shù)據(jù)可以使用 forEach 進行遍歷：var set = new Set(['a', 'b', 'c'])set.forEach((item) => { console.log(item)})// a// b// c雖然在 Set 數(shù)據(jù)結構中沒有索引的概念，但是 Set 提供了三個方法用于我們?nèi)ケ闅v Set 數(shù)據(jù)結構。方法名描述 values 得到 Set 實例中的值作為一個可以遍歷的對象 keys 得到 Set 實例中的鍵作為一個可以遍歷的對象，鍵和值相等 entries 得到 Set 實例中的鍵值作為一個可以遍歷的對象通過這三種方法得到的是一個可迭代對象（后面的迭代器小節(jié)會具體介紹），看如下實例：var set = new Set(['a', 'b', 'c'])set.keys(); // SetIterator {"a", "b", "c"}set.values(); // SetIterator {"a", "b", "c"}set.entries(); // SetIterator {"a" => "a", "b" => "b", "c" => "c"}for(var [key, value] of set.entries()) { console.log(key, value)}// a, a// b, b// c, c從上面的代碼中，使用這三個方法得到的數(shù)據(jù)可以被 for...of 進行遍歷。而且這三個方法得到的數(shù)據(jù)是一個可以迭代的對象，對象上的鍵和值是相等的，這也是為什么 Set 中的數(shù)據(jù)是唯一的原因。
os.path.isdir(path) 判斷文件是否為目錄文件，該函數(shù)的使用示例：>>> import os>>> os.path.isdir('C:\\Windows\\notepad.exe')False>>> os.path.isdir('C:\\Windows')True
和 C、C++ 等編程語言相比，Python 程序的運行性能很差，這是 Python 語言最主要的缺點。例如，編寫一個以數(shù)學計算為主的程序，完成相同功能的 Python 程序的運行性能只有 C 程序的千分之一左右。在實際的應用場景中，Python 的缺點并不會成為系統(tǒng)的瓶頸，原因如下：在應用領域中，程序運行時大部分時間進行的是 IO 處理，少部分時間進行數(shù)學計算。在 Web 后端開發(fā)中，Python 程序接受來自網(wǎng)絡的請求，處理請求時讀寫數(shù)據(jù)庫，最后將處理結果通過網(wǎng)絡返回，大量的時間花費在網(wǎng)絡 IO 和數(shù)據(jù)庫 IO 上，因此 Python 的數(shù)學運算性能對程序的整體影響不大。發(fā)揮 C 語言和 Python 語言兩者各自的優(yōu)勢，使用 C 語言完成對計算性能要求高的功能，使用 Python 語言封裝 C 語言實現(xiàn)的功能模塊。Python 的 NumPy (Numerical Python) 庫，是一個針對矩陣運算的數(shù)學函數(shù)庫，該庫由 Python 語言和 C 語言混合開發(fā)而成：底層的數(shù)學運算功能由 C 語言實現(xiàn)，面向用戶的接口使用 Python 語言實現(xiàn)。用戶使用 Python 語言調(diào)用底層的 C 語言模塊，從而兼顧了開發(fā)效率和運行效率。
使用split方法可以很容易地將字符串分割成字符數(shù)組：實例：string = "a b c d"string.split# ---- 輸出結果 ----["a", "b", "c", "d"]默認情況下，split將使用空格作為分隔符，但是您可以將參數(shù)傳遞給此方法以指定其他分隔符。實例：# 將逗號作為分隔符string = "a,b,c,d"string.split(",")# ---- 輸出結果 ----["a", "b", "c", "d"]
>>> x = {'a':'A', 'b':'B', 'c': 'C'}>>> del x['b']>>> x{'a':'A', 'c':'C'}在第 1 行，創(chuàng)建一個具有 3 個鍵值對的字典；在第 2 行，使用 del 語句從字典 x 中刪除鍵 ‘b’ 對應的鍵值對；在第 3 行，顯示刪除后的字典；在第 4 行，刪除一個鍵值對后，字典僅包含 2 個鍵值對。
interface Temperature { var temperature: Double}class CTemperature(override var temperature: Double) : Temperatureclass FTemperature(var cTemperature: CTemperature) : Temperature { override var temperature: Double get() = convertCelsiusToFahrenheit(cTemperature.temperature) set(temperatureInF) { cTemperature.temperature = convertFahrenheitToCelsius(temperatureInF) } private fun convertFToCelsius(f: Double): Double = (f - 32) * 5 / 9 private fun convertCToFahrenheit(c: Double): Double = (c * 9 / 5) + 32}fun main() { val cTemperature = CTemperature(0.0) val fTemperature = FTemperature(celsiusTemperature) cTemperature.temperature = 36.6 println("${cTemperature.temperature} C -> ${fTemperature.temperature} F") fTemperature.temperature = 100.0 println("${fTemperature.temperature} F -> ${cTemperature.temperature} C")}
os.sep 是 os 模塊的導出變量，定義了文件路徑名的分割符：在 linux 中，os.sep 等于 /在 windows 中，os.sep 等于 \os.sep 的用法如下：>>> import os>>> os.sep'\\'>>> 'C:\\Windows' + os.sep + 'Readme.txt''C:\\Windows\\Readme.txt'在第 4 行，使用 os.sep 將 ‘C:\Windows’ 和 ‘Readme.txt’ 連接形成一個新的路徑。
os.path.join(*args) 接受可變數(shù)量的參數(shù)，將所有的輸入?yún)?shù)使用路徑分隔符連接，形成一個新的路徑名。參數(shù) *args，args 是可變參數(shù)返回值，返回由輸入?yún)?shù)組成的新路徑該函數(shù)的使用示例：>>> import os>>> os.path.join('C:\\Windows', 'Readme.txt')'C:\\Windows\\Readme.txt'>>> os.path.join('C:\\Windows', 'System32', 'Kernel.dll')'C:\\Windows\\System32\\Kernel.dll'在第 2 行，將 2 個字符串連接形成一個路徑名在第 4 行，將 3 個字符串連接形成一個路徑名
在 Go 語言中判斷數(shù)組是否相等需要比較兩個部分。一個是數(shù)組的長度是否相等，另一個是數(shù)組中存放的值是否順序和大小完全相同。只要這兩個部分相等，則 Go 語言中的兩個數(shù)組就是相等的。Tips：Go 語言中只有類型相同的數(shù)組才可以互相比較，且數(shù)組沒有大小的比較，只能比較是否相等。代碼示例：package mainimport ( "fmt")func main() { var a [2]int var c = [2]int{1, 2} var d = [...]int{1, 2} fmt.Println("a == c ? ", a == c) fmt.Println("c == d ?", c == d)}第 11 行：比較數(shù)組 a 和數(shù)組 b 是否相等。兩個數(shù)組長度相同，是存儲的值不同，所以不相等；第 12 行：比較數(shù)組 c 和數(shù)組 d 是否相等。兩個數(shù)組長度相同，且存儲的值也相通，所以相等。執(zhí)行結果：
算術運算符顧名思義，其就是進行加減乘除數(shù)值運算，在 shell 中，bash 不支持原生的數(shù)學運算，需要利用第三方工具來如 let，expr 等來實現(xiàn)。運算符說明舉例+加法expr $a + $b 結果為 30。-減法expr $a - $b 結果為 -10。*乘法expr $a \* $b 結果為 200。/除法expr $b / $a 結果為 2。%取余expr $b % $a 結果為 0。=賦值a=$b 將把變量 b 的值賦給 a。==相等用于比較兩個數(shù)字，相同則返回 true。 [$a == $b] 返回 false。!=不相等用于比較兩個數(shù)字，不相同則返回 true。 [$a != $b] 返回 true。2.1.1 let可以利用 let 對數(shù)值進行運算，let C=$A+$B, 例如：[root@master ~]# A=1[root@master ~]# B=2[root@master ~]# let C=${A}+${B}[root@master ~]# echo $C3注意：let 運算后需要將其賦值給一個變量。2.1.2 expr可以利用 expr 對數(shù)組進行運算，C=$(expr $A+$B)，例如：[root@master ~]# C=`expr $A + $B`[root@master ~]# echo $C3注意 + 號兩邊需要有空格，不然會將其當作字符串連接2.1.3 []可以利用 [] 來對數(shù)值進行運算，C=[A+B]，例如：[root@master ~]# C=$[$A+$B][root@master ~]# echo $C32.1.4 (())利用 (()) 來對數(shù)值進行運算，C=$(($A+$B))，例如：[root@master ~]# C=$(($A+$B))[root@master ~]# echo $C3
在對象的解構中也可以使用剩余參數(shù)，對對象中沒有解構的剩余屬性做聚合操作，生成一個新的對象。var {a, c, ...rest} = {a: 1, b: 2, c: 3, d: 4}console.log(a); // 1console.log(c); // 3console.log(rest); // { b: 2, d: 4 }對象中的 b、d 沒有被解構，通過剩余參數(shù)語法把沒有解構的對象屬性聚合到一起形成新的對象。
圖片來源于網(wǎng)絡
返回結果是一個二維數(shù)組，數(shù)組中的每個元素是一個包含兩個元素的數(shù)組，第一個元素是屬性，第二個元素是屬性對應的值。var obj = {a: 1, b: 2, c: 3};console.log(Object.entries(obj))// [['a', 1], ['b', 3], ['c', 3]]如果傳入的參數(shù)是數(shù)字或布爾值時，則返回一個空數(shù)組Object.entries(50) // []Object.entries(false) // []對 values() 返回數(shù)組的順序，會按照屬性的數(shù)值大小，從小到大排序。var obj = {10: 'a', 1: 'b', 7: 'c'};console.log(Object.entries(obj))// [["1", "b"], ["7", "c"], ["10", "a"]]上面的代碼中，屬性名為數(shù)值的屬性，是按照數(shù)值大小，從小到大遍歷的，因此返回值是一個排序后的二維數(shù)組。values() 傳入的對象如果是一個字符串時，則會把字符拆成數(shù)組中的單個項，如下：console.log(Object.entries('abc'))// [["0", "a"], ["1", "b"], ["2", "c"]]
在 Go 語言中，使用 <- 符號來向通道中塞取數(shù)據(jù)。放在通道右邊 chan <-，就是塞數(shù)據(jù)，放在通道左邊 <- chan ，就是取數(shù)據(jù)。代碼示例：func main() { c := make(chan int, 1) c <- 10 //將10塞入通道中 i := <-c //將10從通道中取出，并賦值給變量i fmt.Println(i)}執(zhí)行結果：
numpy.ravel() 展平的數(shù)組元素，順序通常是"C風格"，返回的是數(shù)組視圖（view），修改會影響原始數(shù)組。該函數(shù)接收兩個參數(shù)：numpy.ravel(a, order='C')其中，order 可選：‘C’ – 按行，‘F’ – 按列，‘A’ – 原順序，‘K’ – 元素在內(nèi)存中的出現(xiàn)順序。案例arr_r = np.ravel(arr0, order='C')展開結果為：arr_rout: array([0, 1, 2, 3, 4, 5, 6, 7])通過切片賦值的方法，顯式地改變 arr_r 的值，查看 arr0 的變化：arr_r[0] = 100arr0out: array([[100, 1, 2, 3], [ 4, 5, 6, 7]])可以看到，雖然利用 ravel 方法對 arr0 進行了展開，但是對展開后的結果所做的修改，也會對應地出現(xiàn)在 arr0 上。
as 命令是用來重命名的，在使用 import 命令導入時可以使用 as 來更改變量名。// a.jslet a = 1;let b = 2;export { a, b,}// main.jsimport { a, b as y } from './a';console.log(a, y); // 1,2如果模塊中同時有 export default 導出和 export 導出時，在導入時可以使用 as 對默認導出進行重命名。// a.jslet a = 1;let b = 2;export { a, b,}export default let c = 3;// main.jsimport { a, b, default as c } from './a'// 等價于下面直接在外面進行使用import c, { a, b } from './a'默認導出的內(nèi)容也可以放在 export 導出的對象中，但是需要使用 as default 命令：// a.jslet a = 1;let b = 2;let c = 'imooc';export { a, b, c as default, // 相當于 export default 'imooc',給導出的對象增加一個default屬性}
Go 語言還能直接在返回值處聲明變量，這個變量的作用域是整個函數(shù)，并且會在 return 的時候直接返回。代碼示例：package mainimport "fmt"func SumAndProduct(a, b int) (c int, d int) { c = a + b //因為c和d函數(shù)返回值處已經(jīng)定義了，可以直接使用 d = a * b return //直接返回，c和d自動傳出去}func main() { sum, product := SumAndProduct(1, 2) //接收多返回值的函數(shù)時，也需要用逗號隔開變量 fmt.Println("a + b =", sum) fmt.Println("a * b =", product)}執(zhí)行結果：
ES6 允許按照一定模式，從數(shù)組和對象中提取值，并對變量進行賦值，這被稱為解構（下節(jié)我們會講到）。 比如如下代碼：let array = [1, 2, 3]let [a, b, c] = array;console.log(a); // 1console.log(b); // 2console.log(c); // 3再比如如下代碼：let obj = {a:1, b:2, c:3}let {a, b, c} = obj;console.log(a); // 1console.log(b); // 2console.log(c); // 3上面的兩個例子，就是數(shù)組和對象的解構賦值過程，在解構賦值時，可以使用剩余操作符。剩余操作符所操作的變量會匹配在解構賦值中所有其他變量未匹配到的屬性?？慈缦率纠簂et {a, b, ...others } = {a: 1, b: 2, c: 3, d: 4, e: 5}console.log(a); // 1console.log(b); // 2console.log(others); // {c: 3, d: 4, e: 5}上面的代碼中，a、b 會匹配對象中對應的值，...others 則會收集匹配余下的屬性值，并打包起來構造一個新的對象賦值給了 others。數(shù)組也可以通過剩余操作符，把剩余的元素打包成一個新的數(shù)組賦值給剩余屬性，代碼如下：let array = [1, 2, 3, 4, 5];let [a, b, ...others] = array;console.log(a); // 1console.log(b); // 2console.log(others); // [3,4,5]在函數(shù)傳參的時候也可以是和解構一起使用。如下所示。function fun(...[a, b, c]) { return a + b + c;}fun('1') // NaN (b 和 c 都是 undefined)fun(1, 2, 3) // 6fun(1, 2, 3, 4) // 6 多余的參數(shù)不會被獲取到上面的代碼中，a、b、c 會去解構傳入?yún)?shù)，加上有剩余語法的作用，對應的值從數(shù)組中的項解構出來，在函數(shù)內(nèi)部直接使用解構出來的參數(shù)即可。剩余語法看起來和展開語法完全相同，不同點在于，剩余參數(shù)用于解構數(shù)組和對象。
集合是一個無序、不重復的序列，集合中所有的元素放在 {} 中間，并用逗號分開，例如：{1, 2, 3}，一個包含 3 個整數(shù)的列表{‘a(chǎn)’, ‘b’, ‘c’}，一個包含 3 個字符串的列表集合提供的最基本的操作有：使用 in 關鍵字檢查元素是否在集合中>>> x = {'a', 'b', 'c'}>>> 'b' in xTrue>>> 'd' in xFalse在第 1 行，創(chuàng)建了一個包含 3 個字符串的集合。在第 2 行，檢測字符串 ‘b’ 是否在集合中；第 3 行顯示結果為 True。在第 4 行，檢測字符串 ‘d’ 是否在集合中；第 5 行顯示結果為 False。向集合中增加元素>>> x = {'a', 'b', 'c'}>>> x.add('d')>>> x{'a', 'b', 'c', 'd'}在第 1 行，創(chuàng)建了一個包含 3 個字符串的集合 x在第 2 行，向集合 x 增加一個元素 ‘d’在第 3 行，打印集合 x，結果表明集合中新增了一個元素從集合中刪除元素>>> x = {'a', 'b', 'c'}>>> x.remove('c')>>> x{'a', 'b'}在第 1 行，創(chuàng)建了一個包含 3 個字符串的集合 x在第 2 行，從集合 x 刪除一個元素 ‘c’在第 3 行，打印集合 x，結果表明集合中刪除了一個元素
同樣以表 course 和 teacher 內(nèi)連接為例：SELECT c.id AS course_id,c.*,t.* FROM course c INNER JOIN teacher t ON c.teacher_id=t.id;執(zhí)行結果如下圖：Tips：INNER JOIN 為內(nèi)連接，展示的是左右兩表都有對應的數(shù)據(jù)。
