# 02-python 基礎語法知識-03-內置函數

02-python 基礎語法知識-03-內置函數

概述

上一節 中 ,有寫到 python的基礎語法函數,今天 我們繼續來看下 python中有哪些內置函數呢?

所謂內置函數,就是當我們安裝了python 的環境後,python解釋器 已經幫助我們 創建很多的函數,這些函數功能,一般都是比較常用的,所以 叫做 內置函數 .

內置函數 其實還有很多 ,我儘量把它都說明白 ,有很多的函數可能現在用不到 ,之後隨着你學習python的深入 你就能 發現 很多是可以用到的.

官方的內置函數 有下面那麼多, 我看了一下 有 69個 .

內置函數

Python 解釋器內置了很多函數和類型，您可以在任何時候使用它們。以下按字母表順序列出它們。

		內置函數
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	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()

14 *5 =70 -1 ==69

看似 很多 其實 只要分類一下 ,就沒有多少.

簡單分類一下

• 進制轉換函數
• 函數式編程函數
• 真值檢測
• any vs all 函數
• 數值類型轉換
• 數學公式

進制轉換的函數

有時候 我們 需要進行進制轉換的時候,可以使用 以下 三個函數 進制函數 進行轉換 .

常用的一些轉換

bin() 十進制 轉二進制

hex() 十進制 轉十六進制

oct() 十進制 轉八進制

#十進制轉二進制
bin(x)

#十進制轉十六進制
hex()

#十進制轉八進制
oct()

>>> num =16
>>> oct(num)
'0o20'
>>> bin(num)
'0b10000'
>>> hex(num)
'0x10'

用法 比較簡單 直接 傳入一個數字,就可以了.

比如 16 對應的二進制數字, 10000, 但是 解釋 返回的是 0b10000 這裏 0b 就是代表 二進制的意思

同理 0x 代表16進制 , 0o 代表八進制

注意 這裏用進制轉換函數後 ,返回的類型 str ,即字符串類型 ,此時就不是數字類型了.

函數式編程

• map

• filter

• zip

函數式編程 是一個比較大的概念,這裏 我只是簡單說一下 這幾個函數

map

map(function, iterable, …)¶

如果 你想對一個 序列 或者可迭代對象 進行批量操作,就可以使用這個函數來處理

舉例 :

1. 比如 我想對一個序列中的每一個數字 進行 +1的操作

if __name__ == '__main__':
    m = map(lambda x: x + 1, [1, 2, 3, 4])

    for i in m:
        print(i)

這裏的意思 就是 list 中每一個數字 ,使用前面的函數 調用一下,返回一個 map 對象, 然後這個對象 可以迭代.

通過迭代就可以取值了.

結果如下:

2
3
4
5	

2. 我想對一組序列 實現 乘*2 這樣的操作,

   相信你 已經知道怎麼做了

   if __name__ == '__main__':
       m = map(lambda x: x*2, [1, 2, 3, 4])
   
       for i in m:
           print(i)
           
   

3. 我想 對一組數 取 絕對值 的操作

   if __name__ == '__main__':
       m = map(lambda x: abs(x), [1, -2, -3, 4])
   
       for i in m:
           print(i)
   

是不是很簡單,這個就是map 的作用,如果想對一組數據進行批量的相同 的操作,就可以考慮使用map 來實現這功能,

當然 你可以不使用map 也可以實現,直接 for 循環然後調用函數 也是可以的, 但是一般情況,內置的函數 效率會相對高一些.

filter

filter(function, iterable)¶

filter 看意思就是過濾的意思, 當你想從一組數據裏面 過濾一部分數據的時候可以使用.

用法和map 類似, 也是 傳入一個函數,傳入一個可迭代對象 .

如果函數 返回一個 True 則這個對象 將會被留下來,

如果函數返回False,則這個對象 將會過濾掉.

舉例1

如果 從一個可迭代對象 獲取 是偶數的值 ,就可以 使用 filter 來 實現.

def is_even(x) -> bool:
    """
     x是偶數
    :param x:
    :return:
    """
    return x % 2 == 0


if __name__ == '__main__':

    f = filter(is_even, range(10))
    for i in f:
        print(i, end=' ')
    print('\n')

過濾奇數 ,只要改變 function 的過濾條件就可以 了.

def is_even(x) -> bool:
    """
    是偶數
    :param x:
    :return:
    """
    return x % 2 == 0


def is_odd(x) -> bool:
    """
    是奇數
    :param x:
    :return:
    """
    return x % 2 == 1


if __name__ == '__main__':
    f = filter(is_even, range(10))

    evens = [i for i in f]
    print(evens)
    f2 = filter(is_odd, range(10))
    l = [i for i in f2]
    print(l)

zip

zip(*iterables)

創建一個聚合了來自每個可迭代對象中的元素的迭代器。

假設 我有兩組 數據

一組 是姓名, 一組是排名 ,我想把兩組數據關聯起來,這個時候 可以考慮 使用zip

zip 會分別從每組中去一個元素, 然後組成一個元祖 ,按順序拿值

if __name__ == '__main__':
    names = ['laoda', 'laoer', 'weilaosan', 'frank']
    rank = [1, 2, 3, 4]
    m = zip(names, rank)

    print(list(m))
	

結果如下:

[('laoda', 1), ('laoer', 2), ('weilaosan', 3), ('frank', 4)]

我們可以把它組成字典, 還記得 字典的創建方法嗎, 有一種是可以通過這種結果來創建

>>> names = ['laoda', 'laoer', 'weilaosan', 'frank']
... rank = [1, 2, 3, 4]
>>> m = zip(names, rank)
... 
>>> dict(m)
{'laoda': 1, 'laoer': 2, 'weilaosan': 3, 'frank': 4}

>>> # 注意這裏
>>> dict(m)
{}

我們發現 第一次 我成功創建了字典, 而當我 在使用dict 構造一個字典的時候 ,發現 返回了一個空字典?

這裏 你可能會有疑惑, 其實 這就是 迭代器的特點. 每次 迭代 返回一個元素,當迭代完成的時候,迭代器 中已經沒有 數據了. 下一次 在迭代的時候 ,也就沒有數據了.所以返回是空字典. 可能有點難理解, 之後 我有時間 在詳細 解釋一下 這個問題吧, 現在 先留在這裏吧.

如果 zip 中有三個 可迭代對象呢?

還是一樣的, 還是從每一個對象拿出來一個,然後組成一個元祖. 組成的元素 就是 一個元祖來自三個 迭代對象.

if __name__ == '__main__':
    names = ['laoda', 'laoer', 'weilaosan', 'frank']
    rank = [1, 2, 3, 4]
    heights = ['165cm', '170cm', '175cm', '165cm']
    m = zip(names, rank, heights)

    for item in m:
        print(item)   

結果如下:

('laoda', 1, '165cm')
('laoer', 2, '170cm')
('weilaosan', 3, '175cm')
('frank', 4, '165cm')

你可能 會有疑惑 ,如果可迭代對象的長度 不一樣呢? zip 會報錯嗎 ?

答案是不會,

而是以最短的迭代對象 爲主,如果沒有元素 就停止 組成元祖, 即最後結果是 最短的那個可迭代對象的長度 .

舉個例子

names 長度 是5 , rank 長度是4

經過zip 操作後, 返回 長度是4 ,並且 'laowu' 被丟掉了.

>>> names = ['laoda', 'laoer', 'weilaosan', 'frank', 'laowu']
... rank = [1, 2, 3, 4]
... 
>>> 
>>> m = zip(names,rank)
>>> list(m)
[('laoda', 1), ('laoer', 2), ('weilaosan', 3), ('frank', 4)]

rank 的長度是4 , names 長度是3,同樣 是丟掉了rank 最後一個元素.

>>> names = ['laoda', 'laoer', 'weilaosan']
... rank = [1, 2, 3, 4]
>>> 
>>> m = zip(names,rank)
>>> list(m)
[('laoda', 1), ('laoer', 2), ('weilaosan', 3)]

有的時候 我們 可能 想保存 最大的那個長度的數據,如果沒有對應的值,可以給一個默認值來填充?

其實 是有辦法的, 不過這裏 我先不介紹了,之後 查一查資料 ,或者搜索 相信你會有收穫的.(zip_longest)

好了 zip 的用法就基本 說完了, 這個函數方便 把幾組數據關聯起來.

真值檢測

bool() 還記得 之前我們學習的 真值檢測嗎? 當時我說 如果你不確定 這個值 是否是真值怎麼辦?

就可以 使用這個函數 可以檢測 這個表達式是否爲真值

02-python 基礎語法知識-01流程控制 -真值檢測

這個函數 返回一個布爾值 True or False

如果你不確定這個 元素,或者對象 是否爲真值,就可以調用這個函數來判斷了.

注意 python3.7 中 : x 只能是位置參數

>>> bool("hello")
True

>>> bool("Love is the most beautiful things.")
True

>>> bool(0)
False
>>> bool(1)
True
>>> bool("believe In love")
True

你看看 計算機 都 '相信愛情', 所以 我們沒有理由不相信. 愛情會來的,麪包也會有的.

any vs. all 的函數

any 只要一組序列中有真值,則返回真,否則返回假.

all 一組序列中所有的都爲真值,則返回真, 否則 返回假 .

>>> any([1,2,3,4])
True
>>> any([1,2,3,4,False])
True
>>> any([1,2,3,4,False])
True
>>> all([1,2,3,4,False])
False

#注意這裏,對一個空list操作返回 True 
>>> all([])
True

slice

slice 是切片,可以返回一個切片, 然後可以給切片 起個名字 .

還記得 list 中可以使用切片嗎?

>>> number = [1, 3, 4, 5, 7]
... 
>>> 
>>> number[1:3]
[3, 4]

這裏 1:3 其實就是說 就是一個切片.

看下面的例子,這裏 如果我想獲取中間的元素, 不要 第一個 和最後一個元素,

就可以使用切片來完成. 有時候 可以使用切片,給要截取的數據一個更好的名稱,方便 我們以後查看自己代碼的時候,當初 爲啥要截取那個一段. 這個是時候 就可以通過切片來給要截取的那一段進行命名。

>>> number = [1, 3, 4, 5, 7]
... 
... mid = slice(1, 4, 1)
>>> 
>>> 
>>> print(number[mid])
... 
... print(number[1:4])
[3, 4, 5]
[3, 4, 5]
>>> 

enumerate

有時候 在我們 迭代 可迭代對象的時候,可以定義一個計算器,代表第幾個元素.

enumerate 會返回兩個值,一個是這個值的索引一個是這個值本身

>>> number = [1, 3, 4, 5, 7]
>>> for  i ,n in enumerate(number):
...     print(i,n)
...     
0 1
1 3
2 4
3 5
4 7

enumerate(iterable, start=0)¶

有一個參數 start 代表你想一個索引從多少開始,默認 start =0 ,即 0,1,2,…

如果start =2 , 則索引就是 2,3,4 …

看下面的例子

>>> number = [1, 3, 4, 5, 7]
>>> for  i ,n in enumerate(number,start=2):
...     print(i,n)
...     
2 1
3 3
4 4
5 5
6 7

help

這個函數 幾乎看名字 也能知道是什麼意思了? 如果你不清楚某個東西如何使用,可以調用help 來查看它的用法.

>>> number
[1, 3, 4, 5, 7]
>>> help(number)
Help on list object:

class list(object)
 |  list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 ....

幾乎 你可以往 help 放入 任何東西,

>>> help(1)
Help on int object:

class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 |  
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 ...

如果你對某個用法記不清楚了,可以通過 help 去查看 文檔

比如查看 字典的有哪些方法

>>> help(dict)
Help on class dict in module builtins:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:

迭代器 切片

https://python3-cookbook.readthedocs.io/zh_CN/latest/c04/p07_taking_slice_of_iterator.html

創建容器的基礎工廠類

這裏應該是叫 類 ,而不是函數,但是 它們都是可調用的.

list() set() tuple() dict() str() 這些用於構造容器的空對象

l = list()
l = set()
l = tuple()
l = str()
l = dict()

這些空對象,就可以 通過這些類 構造一個沒有內容的空對象.

數值類型轉換

float(x)

int(x,base)

complex .

ascii()

complex

這個有在 之前的數據類型有介紹過,翻看之前 講數據類型的文章。

float

float 接收一個字符串, 然後 返回一個float 類型的數字 ,如果 傳入的字符串 是不能轉的類型,會報錯 ValueError.

>>> float('344.232132')
344.232132
>>> float('   44.232132   ')
44.232132
>>> 
>>> float('+1.23')
1.23

>>> float('+1.23avc')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: could not convert string to float: '+1.23avc'

int

int 這個可以接收 x和base 默認 是十進制,base 就是轉成多少進制的數字 .

返回一個轉換好的數字

注意 x 要是 str 類型 ,base 要轉成 多少進制數,默認值 base =10

如果不能轉 ,會報錯, ValueError .

>>> int('10001',2)
17
>>> int('10001',10)
10001
>>> int('10001',10)
10001
>>> int('10001',10)
10001
>>> int('16',2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '16'

‘16’ 就不能 轉成 二進制,因爲二進制 要求 字符 只能有 01 這兩種字符. 所以這裏會報錯.

ascii 函數

​ 這個函數 和 repr() 這個函數有點類似 返回一個字符串的表示， 這個函數並不是 講一個字符 轉化爲一個 ascii 碼 ，如果你需要 講一個字符 轉化爲對應的ASCII 碼 可以使用 chr() 這個函數。

下面就是官方的解釋

就像函數 repr()，返回一個對象可打印的字符串，但是 repr() 返回的字符串中非 ASCII 編碼的字符，會使用 \x、\u 和 \U 來轉義。生成的字符串和 Python 2 的 repr() 返回的結果相似。

>>> ascii('frank')
"'frank'"
>>> ascii(b'frank')
"b'frank'"
>>> ascii(range(10))
'range(0, 10)'
>>> ascii([1,2,3])
'[1, 2, 3]'
>>> ascii({"name":"frank","age":18})
"{'name': 'frank', 'age': 18}"

數學公式相關

這裏涉及一些 數值 計算,數值轉換的一些 函數

pow(x,y) 求 x 的y 次方

max(),min(), sum() 求最大 ,最小 ,求和

round(number,ndigits) 類似 於 四捨五入吧

abs() 用來 取絕對值

divmod 獲取整除的值，和取餘的結果

>>> max(range(10))
9
>>> min(range(10))
0
>>> sum(range(10))
45

>>> pow(2,5)
32
>>> pow(2,3)
8
>>> pow(3,3)
27


>>> abs(10)
10
>>> abs(-10)
10
>>> abs(-1.5)
1.5
>>> abs(1.5)
1.5
>>> abs(0)
0

這裏比較簡單 就不說了. 只要記住 函數名稱 就可以了 .

round(number,ndigits) 類似於 四捨五入吧.

number 你要傳入的數字, ndigits 你要保留幾位有效數字

round官方文檔

>>> round(2.3456,2)
2.35
>>> round(2.3456,3)
2.346
>>> round(-2.3456,2)
-2.35


# 注意這裏
>>> round(2.675,2)
2.67

官網 給出 一個解釋 說 這是由於 小數 在計算機中表示 不精確導致的問題.

divmod(a, b)¶

它將兩個（非複數）數字作爲實參，並在執行整數除法時返回一對商和餘數。對於混合操作數類型，適用雙目算術運算符的規則。對於整數，結果和 (a // b, a % b) 一致

這個函數返回結果是一個元祖

>>> divmod(13,3)
(4, 1)

>>> divmod(15,2)
(7, 1)

排序 sorted

排序函數,可以對一個 可迭代對象進行排序

sorted(iterable, *, key=None, reverse=False)¶

排序函數,可以對一個 可迭代對象進行排序

key 指定帶有單個參數的函數，用於從 iterable 的每個元素中提取用於比較的鍵 (例如 key=str.lower)。 默認值爲 None (直接比較元素)。 key 很多的時候 使用 lamba 表達式來完成 的。

reverse 是一個bool 值， 默認是False 即升序排列。 reverse=True 則爲降序排序。

這個函數會返回一個 已經排好序的對象，不會對 iterable 參數任何影響。

還有 sorted 保證排序是穩定的。

給一個list 進行排序

>>> t
[5, 7, 2, 3, 9, 1, 8, 4, 0, 6]
>>> sorted(t)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> # t 的順序本身沒有改變
>>> t
[5, 7, 2, 3, 9, 1, 8, 4, 0, 6]

再看一個例子 對應元祖的某個位置進行排序

可以使用 lambda 表達式來構造一個匿名函數 來實現

可以藉助 operator模塊裏面的 itemgetter 也可以實現類似排序的功能。

from operator import itemgetter


if __name__ == '__main__':
    persons = [
        ('frank', 19, 56),
        ('laoda', 20, 86),
        ('weiliang', 22, 59),
        ('lile', 23, 79),

    ]

    sorted_p = sorted(persons, key=lambda e: e[2])
    print(sorted_p)

    # 也可以使用 itemgetter 這種方式排序
    sorted_p = sorted(persons, key=itemgetter(2))
    print(sorted_p)
    # [('frank', 19, 56), ('weiliang', 22, 59), ('lile', 23, 79), ('laoda', 20, 86)]
    pass

排序 是一個比較大的話題，有時間的話，我會寫一下 關於python的一些排序 list.sort() vs. sorted() 的一些區別等。這裏可以先了解一下 可以 指定key 來實現排序， reverse 來控制是升序還是降序排序。

面向對象編程相關的類

object

所有的類 都默認繼承 object 這個類， 這是所有python 類的基類。 當然我這句話 說的不夠嚴謹。 之後會在面向對象裏面的繼續講解。

classmethod

這個將一個函數變成一個類方法 ，如果你還不知道面向對象的知識，先知道有這個方法即可，有時間 我會繼續 寫一下 面向對象的知識。 這裏說一下基本用法

class Factory:
    
    @classmethod
    def f(cls, arg1, arg2):
        pass
    

只需要這樣寫就可以了，就可以將一個普通的函數 變成一個類方法了。

staticmethod

這個就是講一個函數 強行到放到一個類中，這個函數 和這個類 本身沒有什麼關係，放到類中 只是希望 在類中可以訪問這個函數，不希望 類的外面使用這個函數， 之後又時間 會在 面向對象編程的章節繼續詳解 這些方法的區別 .

下面add 方法 就是一個static method

class Factory:
    @classmethod
    def f(cls, arg1, arg2):
        pass
    
    @staticmethod
    def add(a:int,b:int)-> int:
        return a+b 

property

這個翻譯過來應該叫特性吧， 將以屬性變成一個特性。 這個一般 需要對屬性進行 控制的時候 會用到這個的。

python3中的特性property介紹

之前我寫的一篇文章 ，比較詳細的介紹了這個property 的用法。

hasattr

這個用來查看一個 對象中是否包含一個屬性 ，如果有返回True，否則返回False. 之後再面向對象編程裏面 會說一下這個方法。

getattr

這個用來獲取某個對象的這個屬性的值，之後再面向對象編程裏面 會說一下這個方法。

delattr

用來 刪除對象的 一些屬性，用的比較少。之後再面向對象編程裏面 會說一下這個方法。

delattr()

callable()

這個 函數 挺重要的 ， 這個可以判斷 一個對象是否爲可調用的， 如果是可調用的返回爲True，否則返回爲False。

舉個例子，一般函數是 可調用的。

看個例子

>>> 
... def say_hello():
...     print("hello frank")
...     

>>> callable(say_hello)
True

以這個例子爲例

定義了一個學生類

class Student:

    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def __str__(self):
        return '%s(name:%s,age:%s,score:%s)' % (self.__class__.__name__, self.name, self.age, self.score)

    __repr__ = __str__

>>> callable(Student)
True
>>> s = Student('frank',18,89)
>>> callable(s)
False

可以看到 Student 這個類 是可調用的， 但是s 卻是不可調用的。

你可能會好奇 爲啥呢？

其實沒有那麼複雜 ，判斷 是否可以調用 只要看這個對象 能否 執行 obj(*args,**kw)這個代碼，如果可以 就是可調用的，否則就不行。

關於這個話題 我之前 有寫過一個文章，看下這個文章 應該就可以理解了

python中什麼是 可調用的，什麼是不可調用的

雜項

chr 函數

chr(i)

返回 Unicode 碼位爲整數 i 的字符的字符串格式

實參的合法範圍是 0 到 1,114,111（16 進製表示是 0x10FFFF）。如果 i 超過這個範圍，會觸發 ValueError 異常。

>>> chr(97)
'a'
>>> chr(65)
'A'
>>> chr(127)
'\x7f'
>>> chr(12799)
'ㇿ'

ord 函數

ord© 是 chr 的逆函數, 這裏將 一個字符 轉換成一個整數

對錶示單個 Unicode 字符的字符串，返回代表它 Unicode 碼點的整數。例如 ord('a') 返回整數 97

>>> ord('c')
99
>>> ord('f')
102
>>> ord('r')
114
>>> ord('a')
97
>>> ord('n')
110
>>> ord('k')
107

id

id() 函數, 返回對象的“標識值”。該值是一個整數，在此對象的生命週期中保證是唯一且恆定的。 即兩個對象 不會有 相同的 id 值。

a = 10 
b = 20 

>>> id(a)
140733509497376
>>> id(b)
140733509497696

看這裏 就可以看出 id 值不相同，我們認爲 a,b 不是同一個對象。 所以以後如果要判斷 兩個對象是不是同一個對象 ，就可以看 id 值 是否一樣就可以了。

open

這個 一般用來打開文件的時候用到的。 我之前有寫過一個文章 。

03-python中的文件操作-01

bytes

這個之前 的文章 基礎類型有講過，只要記得 bytes 和str 如何轉換就可以了。

eval

eval 這個函數 比較強大，可以執行 代碼的字符串

就是說一段 本來 是代碼，現在變成了一個字符串 ，通過這個函數就可以執行這段代碼。

>>> eval('1 + 23')
24
>>> eval('1 + 520')
521
>>> eval(' 3* 5')
15

>>> eval('pow(2,4)')
16

>>> x =10
>>> eval('x +15')
25

​ 看到這個函數功能 挺強大的吧， 就是只要是一段代碼的字符串 ，就可以直接運行。 這樣感覺非常酷。 但是實際上最好不要使用這個函數，就是安全性的問題，因爲 你並不知道 字段字符串裏面會寫什麼操作，如果是一些比較複雜的操作，比如刪除一些操作系統核心的文件，或者惡意破壞的程序。 這樣 直接執行一段 代碼 是比較危險的行爲。

len

看到這個名稱 就知道用來求長度，大部分對象 都可以通過這個方法來獲取長度。

len() 中可以放 很多東西， 常用的一些容器類，list ,str ,dict ,set ,tuple 等這些都是可以求長度的，

就是對應容器 有多少個元素。

之後我們 學習 面向對象編程的時候，就可以自己定義 一個對象的長度啦。

>>> sentences
'I am Frank'
>>> 
>>> del  setences 
>>> sentences
'I am Frank'
>>> len(sentences)
10
>>> len(10)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: object of type 'int' has no len()
>>> len([1,2,3,4])
4
>>> len((1,2,3,4))
4
>>> d = {
...     "name": "frank",
... }
>>> d
{'name': 'frank'}
>>> person = {
...     "name": "frank",
...     "age": 18,
...     "hobby": "swimming",
...     "language": ["java", "php", "c", "goland"]
... }
>>> len(person)
4
>>> len(set([1,2,4,5,6]))
5

總結

​ 本文 主要寫 了一些 比較常用的一些內置方法， 還有一些 沒有講到，有時間 在繼續補充一下，很多的時候 我們 只用到 一部分，更多的時候，我們可以查看官方文檔，就知道如何使用了。 這裏 介紹 一下 比較常用的一些 內置函數。 加油，好好學習，天天向上。

參考文檔

python3.7 內置函數整理

python3.x常用內置函數

Python --內置函數（68個）講解

bulit funcitions

分享快樂,留住感動. 2020-05-24 23:02:48 --frank