源：pypypypy

www.cnblogs.com/pypypy/p/12011506.html

內置函數就是python給你提供的, 拿來直接用的函數，比如print.，input等。截止到python版本3.6.2 python一共提供了68個內置函數。

#68個內置函數# abs dict help min setattr# all dir hex next slice # any divmod id object sorted # ascii enumerate input oct staticmethod # bin eval int open str # bool exec isinstance ord sum # bytearray ?lter issubclass pow super # bytes ?oat iter print tuple # callable format len property type # chr frozenset list range vars # classmethod getattr locals repr zip # compile globals map reversed __import__ # complex hasattr max round # delattr hash memoryview set

和數字相關

1. 數據類型

• bool : 布爾型(True,False)

• int : 整型(整數)

• float : 浮點型(小數)

• complex : 復數

2. 進制轉換

• bin 將給的參數轉換成二進制

• otc 將給的參數轉換成八進制

• hex 將給的參數轉換成十六進制

print(bin(10)) # 二進制:0b1010print(hex(10)) # 十六進制:0xaprint(oct(10)) # 八進制:0o12

3. 數學運算

• abs 返回絕對值

• divmode 返回商和余數

• round 四舍五入

• pow(a, b) 求a的b次冪, 如果有三個參數. 則求完次冪后對第三個數取余

• sum 求和

• min 求最小值

• max 求最大值

print(abs(-2)) # 絕對值:2print(divmod(20,3)) # 求商和余數:(6,2)print(round(4.50)) # 五舍六入:4print(round(4.51)) #5print(pow(10,2,3)) # 如果給了第三個參數. 表示最后取余:1print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55print(min(5,3,9,12,7,2)) #求最小值:2print(max(7,3,15,9,4,13)) #求最大值:15

和數據結構相關

1. 序列

（1）列表和元組

• list 將一個可迭代對象轉換成列表

• tuple 將一個可迭代對象轉換成元組

print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)

（2）相關內置函數

• reversed 將一個序列翻轉, 返回翻轉序列的迭代器

• slice 列表的切片

lst = "你好啊"it = reversed(lst) # 不會改變原列表. 返回一個迭代器, 設計上的一個規則print(list(it)) #['啊', '好', '你']lst = [1, 2, 3, 4, 5, 6, 7]print(lst[1:3:1]) #[2,3]s = slice(1, 3, 1) # 切片用的print(lst[s]) #[2,3]

（3）字符串

• str 將數據轉化成字符串

print(str(123)+'456') #123456 format 與具體數據相關, 用于計算各種小數, 精算等.

s = "hello world!"print(format(s, "^20")) #劇中print(format(s, "<20")) #左對齊print(format(s, ">20")) #右對齊# hello world! # hello world! # hello world!print(format(3, 'b' )) # 二進制:11print(format(97, 'c' )) # 轉換成unicode字符:aprint(format(11, 'd' )) # ?進制:11print(format(11, 'o' )) # 八進制:13 print(format(11, 'x' )) # 十六進制(?寫字母):bprint(format(11, 'X' )) # 十六進制(大寫字母):Bprint(format(11, 'n' )) # 和d?樣:11print(format(11)) # 和d?樣:11print(format(123456789, 'e' )) # 科學計數法. 默認保留6位小數:1.234568e+08print(format(123456789, '0.2e' )) # 科學計數法. 保留2位小數(小寫):1.23e+08print(format(123456789, '0.2E' )) # 科學計數法. 保留2位小數(大寫):1.23E+08print(format(1.23456789, 'f' )) # 小數點計數法. 保留6位小數:1.234568print(format(1.23456789, '0.2f' )) # 小數點計數法. 保留2位小數:1.23print(format(1.23456789, '0.10f')) # 小數點計數法. 保留10位小數:1.2345678900print(format(1.23456789e+3, 'F')) # 小數點計數法. 很大的時候輸出INF:1234.567890

• bytes 把字符串轉化成bytes類型

bs = bytes("今天吃飯了嗎", encoding="utf-8")print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97' bytearray 返回一個新字節數組. 這個數字的元素是可變的, 并且每個元素的值得范圍是[0,256)ret = bytearray("alex" ,encoding ='utf-8')print(ret[0]) #97print(ret) #bytearray(b'alex')ret[0] = 65 #把65的位置A賦值給ret[0]print(str(ret)) #bytearray(b'Alex')

• ord 輸入字符找帶字符編碼的位置

• chr 輸入位置數字找出對應的字符

• ascii 是ascii碼中的返回該值 不是就返回u

print(ord('a')) # 字母a在編碼表中的碼位:97print(ord('中')) # '中'字在編碼表中的位置:20013print(chr(65)) # 已知碼位,求字符是什么:Aprint(chr(19999)) #丟for i in range(65536): #打印出0到65535的字符 print(chr(i), end=" ")print(ascii("@")) #'@'

• repr 返回一個對象的string形式

s = "今天\n吃了%s頓\t飯" % 3print(s)#今天# 吃了3頓 飯print(repr(s)) # 原樣輸出,過濾掉轉義字符 \n \t \r 不管百分號%#'今天\n吃了3頓\t飯'

2. 數據集合

• 字典：dict 創建一個字典

• 集合：set 創建一個集合

frozenset 創建一個凍結的集合，凍結的集合不能進行添加和刪除操作。

3. 相關內置函數

• len 返回一個對象中的元素的個數

• sorted 對可迭代對象進行排序操作 (lamda)

語法：sorted(Iterable, key=函數(排序規則), reverse=False)

• Iterable: 可迭代對象

• key: 排序規則(排序函數), 在sorted內部會將可迭代對象中的每一個元素傳遞給這個函數的參數. 根據函數運算的結果進行排序

• reverse: 是否是倒敘. True: 倒敘, False: 正序

lst = [5,7,6,12,1,13,9,18,5]lst.sort # sort是list里面的一個方法print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]ll = sorted(lst) # 內置函數. 返回給你一個新列表 新列表是被排序的print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]l2 = sorted(lst,reverse=True) #倒序print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]

#根據字符串長度給列表排序lst = ['one', 'two', 'three', 'four', 'five', 'six']def f(s): return len(s)l1 = sorted(lst, key=f, )print(l1) #['one', 'two', 'six', 'four', 'five', 'three']

• enumerate 獲取集合的枚舉對象

lst = ['one','two','three','four','five']for index, el in enumerate(lst,1): # 把索引和元素一起獲取,索引默認從0開始. 可以更改 print(index) print(el)# 1# one# 2# two# 3# three# 4# four# 5# five

• all 可迭代對象中全部是True, 結果才是True

• any 可迭代對象中有一個是True, 結果就是True

print(all([1,'hello',True,9])) #Trueprint(any([0,0,0,False,1,'good'])) #True

• zip 函數用于將可迭代的對象作為參數, 將對象中對應的元素打包成一個元組, 然后返回由這些元組組成的列表. 如果各個迭代器的元素個數不一致, 則返回列表長度與最短的對象相同

lst1 = [1, 2, 3, 4, 5, 6]lst2 = ['醉鄉民謠', '驢得水', '放牛班的春天', '美麗人生', '辯護人', '被嫌棄的松子的一生']lst3 = ['美國', '中國', '法國', '意大利', '韓國', '日本']print(zip(lst1, lst1, lst3)) #<zip object at 0x00000256CA6C7A88>for el in zip(lst1, lst2, lst3): print(el)# (1, '醉鄉民謠', '美國')# (2, '驢得水', '中國')# (3, '放牛班的春天', '法國')# (4, '美麗人生', '意大利')# (5, '辯護人', '韓國')# (6, '被嫌棄的松子的一生', '日本')

• fiter 過濾 (lamda)

語法：fiter(function. Iterable)

function: 用來篩選的函數. 在?lter中會自動的把iterable中的元素傳遞給function. 然后根據function返回的True或者False來判斷是否保留留此項數據 , Iterable: 可迭代對象

def func(i): # 判斷奇數 return i % 2 == 1 lst = [1,2,3,4,5,6,7,8,9]l1 = filter(func, lst) #l1是迭代器print(l1) #<filter object at 0x000001CE3CA98AC8>print(list(l1)) #[1, 3, 5, 7, 9]

• map 會根據提供的函數對指定序列列做映射(lamda)

語法 : map(function, iterable)

可以對可迭代對象中的每一個元素進行映射. 分別去執行 function

def f(i): return ilst = [1,2,3,4,5,6,7,]it = map(f, lst) # 把可迭代對象中的每一個元素傳遞給前面的函數進行處理. 處理的結果會返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]

和作用域相關

• locals 返回當前作用域中的名字

• globals 返回全局作用域中的名字

def func: a = 10 print(locals) # 當前作用域中的內容 print(globals) # 全局作用域中的內容 print("今天內容很多")func# {'a': 10}# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': # <_frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080>, # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' # (built-in)>, '__file__': 'D:/pycharm/練習/week03/new14.py', '__cached__': None,# 'func': <function func at 0x0000026F8D6B97B8>}# 今天內容很多

和迭代器/生成器相關

• range 生成數據

• next 迭代器向下執行一次, 內部實際使?用了__ next__?方法返回迭代器的下一個項目

• iter 獲取迭代器, 內部實際使用的是__ iter__?方法來獲取迭代器

for i in range(15,-1,-5): print(i)# 15# 10# 5# 0lst = [1,2,3,4,5]it = iter(lst) # __iter__獲得迭代器print(it.__next__) #1print(next(it)) #2 __next__ print(next(it)) #3print(next(it)) #4

字符串類型代碼的執行

• eval 執行字符串類型的代碼. 并返回最終結果

• exec 執行字符串類型的代碼

• compile 將字符串類型的代碼編碼. 代碼對象能夠通過exec語句來執行或者eval進行求值

s1 = input("請輸入a+b:") #輸入:8+9print(eval(s1)) # 17 可以動態的執行代碼. 代碼必須有返回值s2 = "for i in range(5): print(i)"a = exec(s2) # exec 執行代碼不返回任何內容# 0# 1# 2# 3# 4print(a) #None# 動態執行代碼exec("""def func: print(" 我是周杰倫")""" )func #我是周杰倫

code1 = "for i in range(3): print(i)"com = compile(code1, "", mode="exec") # compile并不會執行你的代碼.只是編譯exec(com) # 執行編譯的結果# 0# 1# 2code2 = "5+6+7"com2 = compile(code2, "", mode="eval")print(eval(com2)) # 18code3 = "name = input('請輸入你的名字:')" #輸入:hellocom3 = compile(code3, "", mode="single")exec(com3)print(name) #hello

輸入輸出

• print : 打印輸出

• input : 獲取用戶輸出的內容

print("hello", "world", sep="*", end="@") # sep:打印出的內容用什么連接,end:以什么為結尾#hello*world@

內存相關

hash : 獲取到對象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時間 比較耗費內存

s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #報錯,列表是不可哈希的 id : 獲取到對象的內存地址s = 'alex'print(id(s)) #2278345368944

文件操作相關

• open : 用于打開一個文件, 創建一個文件句柄

f = open('file',mode='r',encoding='utf-8')f.readf.close

模塊相關

• __ import__ : 用于動態加載類和函數

# 讓用戶輸入一個要導入的模塊import osname = input("請輸入你要導入的模塊:")__import__(name) # 可以動態導入模塊

幫 助

• help : 函數用于查看函數或模塊用途的詳細說明

print(help(str)) #查看字符串的用途

調用相關

• callable : 用于檢查一個對象是否是可調用的. 如果返回True, object有可能調用失敗, 但如果返回False. 那調用絕對不會成功

a = 10print(callable(a)) #False 變量a不能被調用#def f: print("hello") print(callable(f)) # True 函數是可以被調用的

查看內置屬性

• dir : 查看對象的內置屬性, 訪問的是對象中的__dir__方法

print(dir(tuple)) #查看元組的方法

部函數也稱私有函數，顧名思義，內部函數就是在函數內部定義的函數。函數和字符串值、數值等基本數據類型的值在本質上是一樣，函數也是數據。所以我們可以在函數內部定義一個函數作為函數的值使用。

function outFn(outValue){
function innerFn(innerValue){
return  fnValue*2;
}
  return "結果是"+innerFn(outValue);
}
let result=outFn(2);
console.log(result);//結果是6

當然我們可以使用函數表達式改寫上面的函數：

lel outFn=function(outValue){
   let innerFn=function(innerValue){
     return innerValue*2;
   }
   return “””
   }

當我們調用全局函數outFn()時，內部函數innerFn()也會在內部被調用。由于innerFn()函數是outFn()的內部函數，因此innerFn()函數在outFn()函數外部是不可見的，所以innerFn()函數是outFn()的私有函數。如果我們在外部調用innerFn()函數將會報錯：

let result=innerFn(2);
console.log(result);//Uncaught ReferenceError: innerFn is not defined

使用私有函數有以下幾點好處：

1.有助于確保全局名稱空間的純凈性；

2.有助于我們選擇暴露哪函數，保留哪些函數外部不可見不會被其他函數利用。

日分享最新，最流行的軟件開發知識與最新行業趨勢，希望大家能夠一鍵三連，多多支持，跪求關注，點贊，留言。

函數是 JavaScript 最重要的方面之一。本文將通過示例探索 9 個常用的 JavaScript 函數。

函數是 JavaScript 最重要的方面之一。如果沒有 JavaScript 函數，它將非常有限。javascript 中的函數用于執行特定的操作或任務。

它們可以寫入代碼中，也可以使用 Function 構造函數創建。

Java 中的 Javascript 函數或方法可以接受參數和返回值。參數是在調用函數時傳遞給函數的值。返回值是函數執行后返回的值。

函數可以定義在其他函數內部，稱為嵌套函數。嵌套函數可以訪問外部函數的變量和參數。

這允許一些有趣且強大的編程技術。

作為一種編程語言，JavaScript 具有許多使其獨特且重要的特性。這些功能之一是功能。

Javascript 函數對于 Angular 等其他框架也很重要。Angular 是一個 JavaScript 框架，用于在 JavaScript、HTML 和 TypeScript 中構建 Web 應用程序和應用程序。

Angular 被全世界數百萬的開發人員使用。它是用于構建單頁應用程序的最流行的框架之一。

本文將通過示例探索 9 個常用的 JavaScript 函數。

1. JavaScript 過濾器

JavaScript 中的 filter 函數用于根據特定條件從數組中過濾掉元素。換句話說，過濾器函數將返回一個新數組，其中僅包含滿足條件的那些元素。

例如，如果我們有一個數字數組并且我們只想獲得偶數，我們可以使用帶有檢查偶數條件的過濾器函數。

類似地，如果我們有一個對象數組并且只想獲取具有某個屬性值的對象，我們可以使用帶有檢查該屬性值的條件的過濾器函數。過濾器功能還有許多其他用途。

JavaScript 過濾器示例：

// Array Filter function let numbers = [15, 2, 50, 55, 90, 5, 4, 9, 10]; console.log(numbers.filter(number => number % 2 == 1)); // Filtering odd numbers => result is [15, 55, 5, 9]

2. Javascript foreach

Javascript foreach 循環是在 JavaScript 中迭代數組的便捷工具。它允許您為數組中的每個元素執行一組特定的代碼，而無需編寫 for 循環。我們將看看 foreach 循環是如何工作的，以及如何在代碼中使用它。

我們將討論我們可以在 JavaScript 中使用 foreach 執行哪些類型的操作。JavaScript Foreach 是一種循環結構，可用于多種編程語言，包括 JavaScript。

foreach 的主要目的是允許程序員迭代數據集合，例如數組或列表。

要使用 JavaScript foreach，首先需要一個數組。這可以使用 Array() 構造函數或簡單地將逗號分隔的值列表分配給變量來創建：

一旦你有了你的數組，你就可以使用 JavaScript foreach 循環開始迭代它。foreach 循環的語法如下：

JavaScript foreach 示例：

<p id="items"></p> <script> let text = ""; const fruits = ["Apple", "Orange", "Cherry", "Banana"]; fruits.forEach(myFunction); document.getElementById("items").innerHTML = text; function myFunction(item, index) { index =index + 1 text += index + ": " + item + ""; } </script>

3. JavaScript 地圖

JavaScript map 函數是 JavaScript 中的一個內置方法，它允許您處理數組中的每個元素。

JavaScript 中的 map() 方法根據函數轉換數組中的元素。該函數在數組的每個元素上執行，元素作為參數傳遞。

JavaScript map() 方法返回一個包含轉換后元素的新數組。

如果您有一個數字數組并且想要將它們加倍，您可以使用 map() 方法和一個將每個數字乘以 2 的函數。

在這種情況下，原始數組不會被修改。相反，使用雙倍值創建一個新數組：

var newArr = arr.map(num => num * 2);

讓我們看另一個 JavaScript 地圖函數的例子。

const users = [ {firstname : "Abhishek", lastname: "kumar"}, {firstname : "jay", lastname: "sharma"}, {firstname : "rupal", lastname: "sharma"} ]; users.map(getFullName); function getFullName(item) { return [item.firstname,item.lastname].join(", ");} // Output: Abhishek kumar, jay sharma, rupal sharma,

4. JavaScript 連接

JavaScript 字符串連接是將兩個或多個字符串連接在一起的過程。在 JavaScript 中連接字符串的最常見方法是使用 + 運算符。但是，還有其他方法可以做到這一點。

在 JavaScript 中連接字符串的一種方法是使用 += 運算符。該運算符將運算符右側的字符串添加到運算符左側的字符串中。例如：

str1 += str2; // 現在 str1 等于“Hello World”

在 JavaScript 中連接字符串的另一種方法是使用 .concat() 方法。

js concat 方法用于將兩個或多個字符串合并在一起。如果您想用多個較小的字符串構建單個字符串，這很有用。

JavaScript Concat() 方法不會更改現有字符串，而是返回一個包含合并字符串文本的新字符串。

JavaScript 連接示例：

const arr1 = ["Abhishek", "rupal"]; const arr2 = ["divya", "rahul", "harsh"]; const allUsers = arr1.concat(arr2); // Output: Abhishek, rupal, divya, rahul, harsh const arr1 = ["Abhishek", "rupal"]; const arr2 = ["divya", "rahul", "harsh"]; const arr3 = ["kamal", "rohit"]; const allUsers = arr1.concat(arr2, arr3); // Output: Abhishek, rupal, divya, rahul, harsh, kamal, rohit

5. JavaScript 查找

使用數組時，find 函數可能是一個有用的工具。此函數將返回數組中滿足給定條件的第一個元素。

如果我們有一個數字數組并且我們想找到第一個大于 5 的數字，我們可以使用 find 函數。JavaScript find 函數將回調作為其第一個參數。

此回調傳遞三個參數：正在處理的當前元素、該元素的索引和數組本身。

如果元素滿足條件，回調應該返回 true，否則返回 false。在我們的示例中，如果當前元素大于 5，我們將返回 true。

JavaScript 查找功能不僅限于數字。它也可以用于字符串。

JavaScript 查找函數示例：

const marks = [30, 70, 98, 77]; console.log(marks.find(checkMarks)); function checkMarks(mark) { return mark > 90; } // 98

JavaScript find 函數的另一個例子：

const fruits = [ { name: "apple", count: 10 }, { name: "banana", count: 18 }, { name: "mango", count: 3 } ]; const findMango = fruits.find(fruit =>fruit.name === "mango"); // { name: "mango", count: 3}

6. JavaScript 查找索引

使用數組時，有時您可能需要查找特定元素的索引。這可以使用 JavaScript findIndex() 方法來完成。

JavaScript findIndex 方法返回數組中滿足提供的測試函數的第一個元素的索引。否則，它返回 -1。

findindex JavascripS 方法類似于 JavaScript 的 find 函數，但它返回的是索引而不是值。

findIndex() 函數有兩個 參數，一個回調函數和一個可選對象，該對象可用作回調函數中的 this 關鍵字。

JavaScript findIndex 函數示例：

const marks = [30, 70, 98, 77]; console.log(marks.findIndex(checkMarks)); function checkMarks(mark) { return mark > 90; } // 2

JavaScript findIndex 函數的另一個例子：

const fruits = [ { name: "apple", count: 10 }, { name: "banana", count: 18 }, { name: "mango", count: 3 } ]; const findMango = fruits.findIndex(fruit =>fruit.name === "mango"); // 2

7. JavaScript 包括

Javascript includes() 一個內置函數，用于檢查一個字符串是否包含另一個字符串。如果找到指定的字符串，則返回 true。否則，它返回 false。

JavaScript包含函數區分大小寫，這意味著它將區分大小寫字母，這意味著它將“Java”和“java”視為兩個不同的字符串。

要檢查 js 字符串是否包含另一個字符串，只需將要檢查的字符串作為第一個參數傳入，將要檢查的字符串作為第二個參數傳入。

例如，讓我們檢查字符串“Hello World”是否包含單詞“world”。由于搜索區分大小寫，因此將返回 false。

const birds = ["Birds", "peacock", "Dove", "Sparrow"];console.log(birds.includes("Dove")); // true

8. JavaScript 拆分

JavaScript 拆分函數 JavaScript 是一個字符串函數，用于將字符串拆分為子字符串數組并返回新數組。

拆分（str，分隔符，限制）

原始字符串沒有被修改。split 函數的語法是：

str — 要拆分的字符串。

separator — 用作分隔符的字符。如果省略，則使用單個空格 (' ') 作為分隔符。

limit — 一個整數，指定要進行的拆分次數。如果省略，字符串將被拆分為一個沒有限制的子字符串數組。

分隔符是一個字符串，它定義了應該在哪里拆分字符串。限制是一個整數，指定最大拆分數。

如果沒有指定分隔符，字符串將被空白字符分割。如果未指定限制，則默認為 0，即沒有限制。

JavaScript split 函數的返回值是一個子字符串數組。如果字符串不能被拆分，它將返回一個空數組。

let text = "Hello this is akashminds";console.log(text.split(" "));// ["Hello", "this", "is", "akashminds"];let text = "Hello this is akashminds";console.log(text.split(" ", 3)); // ["akashminds"];

9. JavaScript 子字符串

JavaScript substr 函數用于提取字符串的一部分。它有兩個參數：開始位置和子字符串的長度。該函數返回一個新字符串，其中包含原始字符串的提取部分。

如果起始位置為負數，則從字符串的末尾開始計數。如果省略長度參數，JavaScript substr 會提取從字符串開始位置到結尾的所有字符。

JavaScript substr 函數可用于提取字符串的一部分或通過連接兩個子字符串來創建新字符串。它還可以用于找出給定字符串中是否存在某個字符或子字符串。

const test = "Hey!, this is Akashminds, have a nice day ahead.";console.log(test.substring(0, 30));// Hey!, this is Akashminds, have

作為用途最廣泛、用途最廣泛的編程語言之一，JavaScript 有著悠久的歷史和光明的未來。在本文中，我們通過示例探索了最常用的 9 個 JavaScript 函數。

在 JavaScript 中使用函數有很多優點。

首先，如果你有很多代碼需要重用，把它放在一個函數中可以很容易地在你需要的時候再次調用它。

其次，使用函數可以通過將代碼分解成更小的部分來幫助您提高代碼的可讀性。

這些是最常用的 9 個 JavaScript 函數以及示例。掌握這些功能將幫助你編寫更好的代碼，成為更精通的程序員。