本文綱要

Python 作為一門高級編程語言，為我們提供了許多方便易用的內置函數，節省了不少開發應用的時間。目前，Python 3.7 共有 69 個內置函數，一些是我們耳熟能詳的函數，另一些卻不是很常見，這里主要介紹一些新手必備函數及其用法。

為了便于說明，我把這些內置函數粗略地分為六大類：

輸入輸出	print() open() ?input()
迭代相關	enumerate() ?zip()
序列屬性	sum() ?max() ?min() ?len()
操作序列	sorted() ?reversed() ?range()
對象屬性	dir() ?id() ?isinstance() ?type()
映射類型	eval() ?map() ?slice()

輸入輸出

print 函數將對象輸出至控制臺

print(*objects, sep=' ', end='\n', file=
sys.stdout, flush=False)

*objects 為可變參數，可以接受任意多個對象。sep 參數表示輸出對象之

間的分隔符，默認為空格。

>>> print('Python', '高效編程')
Python 高效編程

分隔符為'*':

>>> print('Python', '高效編程', sep = '*')
Python*高效編程

格式化輸出字符串的三種方式：

name =?'Python高效編程'
fmt1 = f'公眾號：{name}'
fmt2 = '公眾號：{}'.format(name)
fmt3 = '公眾號：%s' %name
print(fmt1)
print(fmt2)
print(fmt3)
# 公眾號：Python高效編程

open 函數打開文件并返回文件對象

open(file, mode='r', buffering=-1,
encoding=None, errors=None, newline=None, closefd=True, opener=None)

file 為文件地址，mode 為打開文件的模式，默認為 'r'，表示讀取文件，常用的還有：'w' 表示寫入文件、'b' 表示以二進制形式打開。

常用上下文管理器 with 打開文件，f.read( ) 讀取全部內容，f.readline() 讀取一行內容。

with open('test.txt', 'r') as f:
? ?text1 = f.read()

with open('test.txt', 'r') as f:
? ?text2 = ''
? ?line = f.readline()
? ?while line:
? ? ? ?text2 += line
? ? ? ?line = f.readline()

assert text1 == text2
print(text1)

###############
輸出內容：
Python 高效編程
Python 高效編程
Python 高效編程
Python 高效編程
###############

有時候，我們讀取文件還會遇到亂碼問題，可以指定編碼格式：

當文件中有中文的時候，使用 'utf-8' 編碼會導致異常：UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb8 in position 7: invalid start byte

with open('test.txt', 'r',
? ? ? ?encoding='utf-8') as f:
? ?text1 = f.read()

這時候，我們可以嘗試 'gb2312' 或者 'gbk' 編碼來打開含有中文字符的文件。這時，便可以成功打開文件。

with open('test.txt', 'r',
? ? ? ?encoding='gb2312') as f:
? ?text1 = f.read()
with open('test.txt', 'w',
? ? ? ?encoding='gbk') as f:f.write('Python高效編程')

input 函數獲取控制臺輸入

input([prompt])

input 可接受字符串為參數，提示用戶輸入。? ?

>>> s = input('請輸入公眾號名稱：')
請輸入公眾號名稱：Python高效編程
>>> s
'Python高效編程'迭代相關

enumerate 函數返回元素的序號與對應值

enumerate(iterable, start=0)iterable 參數表示可迭代對象，start 參數是元素序號的起點，默認為 0。enumerate 函數的等價形式如下：def?enumerate(sequence, start=0):
?n = start
?for elem in sequence:
? ? ?yield n, elem
? ? ?n += 1
seq =?['P',?'y',?'t',?'h',?'o',?'n']for i, elem in enumerate(seq):
? ?print(i, elem)

zip 函數用于同時迭代多個對象

zip(*iterables)

*iterable 可以接受任意多個可迭代對象

a = ["**", '**', '**']
b = ['微信公眾號', '關注', 'Python高效編程']
c = a
print('#'*20)
for i, j, k in zip(a, b, c):
? ?print(i, j, k)
print('#'*20)

####################
** 微信公眾號 **
** 關注 **
** Python高效編程 **
####################序列屬性

序列最大值：max

序列最小值：min

序列的和：? ?sum

序列長度：? ?len

基本用法：向這四個函數中傳入序列，可以得到對應屬性。

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
print(max(seq))
# 88
print(min(seq))
# 21
print(sum(seq))
# 545
print(len(seq))
# 10

作為內置函數，可以直接傳入生成器(不需要括號)作為參數：

import random
random.seed(21)
num = max(random.randint(0, 100) for i in range(10))
print(num)
# 88

可傳入 key 參數，作為比較大小的依據，相當于把序列中每一個元素 item 先傳入函數 key 中，將函數返回的數值作為判斷對象大小的依據。

def foo(x):
? ?return 1. / x
max(seq, key = foo)
# 21

對于我們自定義的類型，必須實現特殊方法，才能進行 len 等操作。

__len__ 代表：len 操作，__eq__ 代表：= 操作，__lt__ 代表 < 操作。

class foo:
? ?def __init__(self, num, seq):
? ? ? ?self.num = num
? ? ? ?self.seq = seq
? ? ? ?
? ?def __len__(self):
? ? ? ?return len(self.seq)
? ? ? ?
? ?def __eq__(self, other):
? ? ? ?return self.num == other.num
? ? ? ?
? ?def __lt__(self, other):
? ? ? ?return self.num < other.num

>>> f1 = foo(18, [1, 4, 6])
>>> f2 = foo(21, [1, 7, 9, 10])
>>> f1 < f2
True
>>> f1 > f2
False
>>> f1 == f2
False
>>> f3 = foo(18, [9, 9, 0, 7])
>>> f1 == f3
True
>>> len(f1)
3
>>> len(f2)
4操作序列

????range 函數生成序列

range(start, stop[, step])

• start 可選參數，默認為 0 ，表示序列起點

• stop 必選參數，表示序列終點，不包括終點

• step 可選參數，序列的步長，默認為 1

>>> range(6)
range(0, 6)
>>> list(range(6))
[0, 1, 2, 3, 4, 5]
>>> list(range(0, 6, 2))
[0, 2, 4]

range 函數生成的對象可以迭代，和列表很類似，_ 表示廢棄變量(為了避免污染變量環境)：

for _ in range(3):
?print('Python高效編程')

reversed 函數可以將序列逆置

reversed 可以將序列逆置，包括元組、字符串、列表。對于列表和字符串的逆置，使用 list[::-1] 或者slice()更加方便。

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
reversed(seq)
print(list(reversed(seq)))
# [65, 60, 27, 61, 36, 81, 53, 88, 53, 21]

字符串逆置：

>>> a = 'Python高效編程'
>>> a[::-1]
'程編效高nohtyP'
>>> ''.join(reversed('Python高效編程'))
'程編效高nohtyP'

sorted 函數可以對序列進行排序

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

sorted 不同于 list.sort 操作(原地排序)，返回一個新的有序序列，原序列保持不變。* 表示僅限關鍵字參數(keyword-only)，也就是說，key、reverse 參數只能通過關鍵字傳參，而不能通過位置傳參。reverve 參數表示逆置操作，key 與之前 len 中的 key 參數類似，是函數排序的依據。?

>>> sorted([9, 6, 2, 3, 6])
[2, 3, 6, 6, 9]對象屬性

dir 函數返回屬性列表

id ?函數返回對象地址

isinstance ?判斷對象的類型

type 返回對象的類型

class foo:pass
>>> dir(foo)
['__class__','__delattr__','__dict__','__dir__',
......'__str__','__subclasshook__','__weakref__']# 創建實例
>>> f = foo()
>>> type(foo)
__main__.foo
>>> isinstance(f, foo)
True
>>> id(f)
2135099584864

映射類型

eval 解除引號的束縛

map 應用函數于單個對象

slice 生成切片

eval 可以去除字符串的單引號，從而獲取引號內部內容。下面的演示展示了，如何使用 eval 函數獲取字符串中的字典：

>>> info = '{"name": "LiHua", "age": 12}'
>>> eval(info)
{'name': 'LiHua', 'age': 12}
>>> info_dict = eval(info)
>>> type(info_dict)
dict

map 將傳進來的函數應用于序列中的每一個元素，并返回迭代器。

map(function, iterable, ...)

舉例來說,map 就是對 seq 列表中的每一個元素 item 進行 int 操作(int(item))。匿名函數同理，就是對序列中的每一個元素進行加 2 的操作。

>>> seq = [1.5, 4.5, 9.1]
>>> list(map(int, seq))
[1, 4, 9]
>>> list(map(lambda x: x + 2, seq))
[3.5, 6.5, 11.1]

slice 函數為切片操作命名，使得切片操作更加清晰明了。

slice(start, stop[, step])

start 為起點，stop 為終點，step 為步長。使用該操作，使得截取有規律的文本內容變得很輕松。特別是長文本，使用 slice 函數更加清晰易懂。

>>> text = '微信公眾號 Python高效編程'
>>> name = slice(0, 6)
>>> text[name]
微信公眾號?
>>> content = slice(6, 16)
>>> text[content]
Python高效編程

這篇文章到此結束了，大家可以趁熱打鐵，多多練習。覺得不過癮的小伙伴，可以繼續學習我們公眾號中的python教程。

作者：flywind

來源：Python高效編程

---

總結

以上是生活随笔為你收集整理的class传参 python_Python 初学者必备的常用内置函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。