Python 内置函数

python内置了很多简单实用的内置函数,日常工作中会很常用到这些函数,通过这些内置函数能够提高代码得简洁性,节省工作量。

inside-function

查看更多详细:官方

abs

取绝对值

In [1]:
abs(-10)
Out[1]:
10

bool

求布尔值

In [2]:
bool(True)
bool(False)
bool(0)
bool(1)
bool(None)

s = ""
bool(s)

t = ()
bool(t)

l = []
bool(l)

d = {}
bool(d)
Out[2]:
True
Out[2]:
False
Out[2]:
False
Out[2]:
True
Out[2]:
False
Out[2]:
False
Out[2]:
False
Out[2]:
False
Out[2]:
False

False   None   0   ""   ()   []   {}

标准值 FalseNone,所有类型的数字 0(包括浮点型、长整型和其他类型)、 空序列 (比如空字符串、元组合列表)以及空的字典都为 假(False),其他得一切都为 真(True) 和特殊值 True

all

所有为真,结果为真

In [3]:
all([1, 2, 3, None])
Out[3]:
False

any

只要有真,结果就为真

In [4]:
any([1, 2, 3, None])
Out[4]:
True

进制转换

In [5]:
# bin() 转换2进制  0b
bin(10)

# oct() 转换8进制  0o
oct(10)

# hex() 转换16进制 0x
hex(10)
Out[5]:
'0b1010'
Out[5]:
'0o12'
Out[5]:
'0xa'

编码

In [6]:
# bytes() 字符串转换成字节
name = '梁先森'
b = bytes(name, encoding="utf-8")
print(b)
b'\xe6\xa2\x81\xe5\x85\x88\xe6\xa3\xae'
In [7]:
# str() 字节转换字符串
s1 = str(b, encoding="utf-8")
print(s1)
梁先森
In [8]:
# ASCII 转换
bm = ord('A')  # 输入字符返回ascii中对应位置
print(bm)

ch = chr(bm)  # 通过ascii中对应位置转换对应的的字符
print(ch)
65
A

pow

幂运算

In [9]:
2**10
pow(2, 10)
Out[9]:
1024
Out[9]:
1024

divmod

求商和余数

In [10]:
divmod(97, 10)
Out[10]:
(9, 7)

round

四舍五入

In [11]:
round(91.79)
Out[11]:
92

max,min,sum

求最大,最小,求和.

In [12]:
max([11,22,33])
min([11,22,33])
sum([11,22,33])
Out[12]:
33
Out[12]:
11
Out[12]:
66

len

获取一个序列长度,有多少元素

In [13]:
len('liang')
len((1, 2, 3,))
len([1, 'o', 3, 'p'])
len({"name": "Kevin", "age": 18, "job": "programmer"})  # 字典的长度即多少个key。
Out[13]:
5
Out[13]:
3
Out[13]:
4
Out[13]:
3

zip

拉链,交叉序列,不相同长度序列多出的会丢弃。

In [14]:
lt = [11, 22, 33]
ld = ['aa', 'bb', 'cc', 'dd']

zip(lt, ld)
print(list(zip(lt, ld)))
Out[14]:
<zip at 0x104303608>
[(11, 'aa'), (22, 'bb'), (33, 'cc')]

sorted

排序

In [15]:
sorted([3,2,1,4,5,6,9,])
Out[15]:
[1, 2, 3, 4, 5, 6, 9]

reversed

反转序列

In [16]:
l = [11, 22, 33, 44]
print(list(reversed(l)))  # 反转,和list的reverse方法一样
print(list(reversed("liang")))
l.reverse()
print(l)
[44, 33, 22, 11]
['g', 'n', 'a', 'i', 'l']
[44, 33, 22, 11]

help

看源码信息

In [17]:
help(list)
Help on class list in module builtins:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 |  
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

dir

快速查看类和对象都有哪些属性和方法

In [18]:
dir(list)
Out[18]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

isinstance

判断对象是否是某个类的实例

In [19]:
isinstance([], list)
Out[19]:
True

eval

执行表达式,并返回结果

In [20]:
eval("print(123)")
123

compile

编译字符串,将字符串编译成python代码交给 single,eval,exec,执行

In [21]:
r = compile("print(123)", "this is string", "exec")  # 参数: python字符串代码, 字符串说明,mode制定编译种类single,eval,exec
print(r)

#执行代码,接收代码和字符串都能执行,没有返回值
exec(r)  # exec() 执行编译后python的代码
<code object <module> at 0x1042e5540, file "this is string", line 1>
123

filter

对一个可迭代对象进行筛选

In [22]:
# 参数1, 函数
# 参数2, 一个可迭代对象(序列)
"""
filter() 内部实现感觉应该是这样:

result = []
for item in 参数2:
    r = 参数1(item)   # 执行结果 
    if r:            # 如果合法
        result.append(item)
        
return result       # 全部执行完了,吐出过了条件的序列
"""

# filter ,循环第二个参数,让每个循环元素执行函数,如果函数返回True,表示元素合法

def f1(num):
    if num > 5:
        return num
    
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

result = filter(f1, li)
result         # 可迭代对象
list(result)   # 变成list
Out[22]:
<filter at 0x104324630>
Out[22]:
[6, 7, 8, 9, 10]

map

迭代操作,遍历序列,对序列每个元素进行操作

In [23]:
def f2(num):
    return num + 100
    
list(map(f2, li)) # 对list中的每个元素 + 100
Out[23]:
[101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

这里你可能会感觉,map()filter() 感觉功能一样啊

In [24]:
"""
map() 内部实现感觉是这样:

for item in 参数2:
    return 参数1(item)   # 执行结果 
"""

# 一不一样试一下不就知道了
list(map(f1, li))
Out[24]:
[None, None, None, None, None, 6, 7, 8, 9, 10]

接下来看图理解:

filter-function

map-function