天天看點
傳回

02-python 基礎文法知識-03-内置函數02-python 基礎文法知識-03-内置函數

02-python 基礎文法知識-03-内置函數

文章目錄

  • 02-python 基礎文法知識-03-内置函數
    • 概述
    • 内置函數
      • 進制轉換的函數
      • 函數式程式設計
        • map
        • filter
        • zip
      • 真值檢測
      • any vs. all 的函數
      • slice
      • enumerate
      • help
      • 建立容器的基礎工廠類
      • 數值類型轉換
        • complex
        • float
        • int
        • ascii 函數
      • 數學公式相關
      • 排序 sorted
      • 面向對象程式設計相關的類
        • object
        • classmethod
        • staticmethod
        • property
        • hasattr
        • getattr
        • delattr
        • callable()
      • 雜項
      • chr 函數
      • ord 函數
      • id
      • open
      • bytes
      • eval
      • len
    • 總結
    • 參考文檔

概述

上一節 中 ,有寫到 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

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

    相信你 已經知道怎麼做了

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

    for i in m:
        print(i)
  2. 我想 對一組數 取 絕對值 的操作 
    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))

結果如下:

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

>>> 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

和我一起學習Python3 基礎 Python 内置函數
上一篇: 讀書筆記之《Java8實戰》
下一篇: list — 把數組中的值賦給一些變量list

繼續閱讀