内置函数

查看内置模块和常量

from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"

sorted(dir(__builtins__))

['ArithmeticError',
 'AssertionError',
 'AttributeError',
 'BaseException',
 'BlockingIOError',
 'BrokenPipeError',
 'BufferError',
 'BytesWarning',
 'ChildProcessError',
 'ConnectionAbortedError',
 'ConnectionError',
 'ConnectionRefusedError',
 'ConnectionResetError',
 'DeprecationWarning',
 'EOFError',
 'Ellipsis',
 'EnvironmentError',
 'Exception',
 'False',
 'FileExistsError',
 'FileNotFoundError',
 'FloatingPointError',
 'FutureWarning',
 'GeneratorExit',
 'IOError',
 'ImportError',
 'ImportWarning',
 'IndentationError',
 'IndexError',
 'InterruptedError',
 'IsADirectoryError',
 'KeyError',
 'KeyboardInterrupt',
 'LookupError',
 'MemoryError',
 'ModuleNotFoundError',
 'NameError',
 'None',
 'NotADirectoryError',
 'NotImplemented',
 'NotImplementedError',
 'OSError',
 'OverflowError',
 'PendingDeprecationWarning',
 'PermissionError',
 'ProcessLookupError',
 'RecursionError',
 'ReferenceError',
 'ResourceWarning',
 'RuntimeError',
 'RuntimeWarning',
 'StopAsyncIteration',
 'StopIteration',
 'SyntaxError',
 'SyntaxWarning',
 'SystemError',
 'SystemExit',
 'TabError',
 'TimeoutError',
 'True',
 'TypeError',
 'UnboundLocalError',
 'UnicodeDecodeError',
 'UnicodeEncodeError',
 'UnicodeError',
 'UnicodeTranslateError',
 'UnicodeWarning',
 'UserWarning',
 'ValueError',
 'Warning',
 'WindowsError',
 'ZeroDivisionError',
 '__IPYTHON__',
 '__build_class__',
 '__debug__',
 '__doc__',
 '__import__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'abs',
 'all',
 'any',
 'ascii',
 'bin',
 'bool',
 'breakpoint',
 'bytearray',
 'bytes',
 'callable',
 'chr',
 'classmethod',
 'compile',
 'complex',
 'copyright',
 'credits',
 'delattr',
 'dict',
 'dir',
 'display',
 'divmod',
 'enumerate',
 'eval',
 'exec',
 'filter',
 'float',
 'format',
 'frozenset',
 'get_ipython',
 'getattr',
 'globals',
 'hasattr',
 'hash',
 'help',
 'hex',
 'id',
 'input',
 'int',
 'isinstance',
 'issubclass',
 'iter',
 'len',
 'license',
 'list',
 'locals',
 'map',
 'max',
 'memoryview',
 'min',
 'next',
 'object',
 'oct',
 'open',
 'ord',
 'pow',
 'print',
 'property',
 'range',
 'repr',
 'reversed',
 'round',
 'set',
 'setattr',
 'slice',
 'sorted',
 'staticmethod',
 'str',
 'sum',
 'super',
 'tuple',
 'type',
 'vars',
 'zip']

import builtins
sorted(dir(builtins))

['ArithmeticError',
 'AssertionError',
 'AttributeError',
 'BaseException',
 'BlockingIOError',
 'BrokenPipeError',
 'BufferError',
 'BytesWarning',
 'ChildProcessError',
 'ConnectionAbortedError',
 'ConnectionError',
 'ConnectionRefusedError',
 'ConnectionResetError',
 'DeprecationWarning',
 'EOFError',
 'Ellipsis',
 'EnvironmentError',
 'Exception',
 'False',
 'FileExistsError',
 'FileNotFoundError',
 'FloatingPointError',
 'FutureWarning',
 'GeneratorExit',
 'IOError',
 'ImportError',
 'ImportWarning',
 'IndentationError',
 'IndexError',
 'InterruptedError',
 'IsADirectoryError',
 'KeyError',
 'KeyboardInterrupt',
 'LookupError',
 'MemoryError',
 'ModuleNotFoundError',
 'NameError',
 'None',
 'NotADirectoryError',
 'NotImplemented',
 'NotImplementedError',
 'OSError',
 'OverflowError',
 'PendingDeprecationWarning',
 'PermissionError',
 'ProcessLookupError',
 'RecursionError',
 'ReferenceError',
 'ResourceWarning',
 'RuntimeError',
 'RuntimeWarning',
 'StopAsyncIteration',
 'StopIteration',
 'SyntaxError',
 'SyntaxWarning',
 'SystemError',
 'SystemExit',
 'TabError',
 'TimeoutError',
 'True',
 'TypeError',
 'UnboundLocalError',
 'UnicodeDecodeError',
 'UnicodeEncodeError',
 'UnicodeError',
 'UnicodeTranslateError',
 'UnicodeWarning',
 'UserWarning',
 'ValueError',
 'Warning',
 'WindowsError',
 'ZeroDivisionError',
 '__IPYTHON__',
 '__build_class__',
 '__debug__',
 '__doc__',
 '__import__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'abs',
 'all',
 'any',
 'ascii',
 'bin',
 'bool',
 'breakpoint',
 'bytearray',
 'bytes',
 'callable',
 'chr',
 'classmethod',
 'compile',
 'complex',
 'copyright',
 'credits',
 'delattr',
 'dict',
 'dir',
 'display',
 'divmod',
 'enumerate',
 'eval',
 'exec',
 'filter',
 'float',
 'format',
 'frozenset',
 'get_ipython',
 'getattr',
 'globals',
 'hasattr',
 'hash',
 'help',
 'hex',
 'id',
 'input',
 'int',
 'isinstance',
 'issubclass',
 'iter',
 'len',
 'license',
 'list',
 'locals',
 'map',
 'max',
 'memoryview',
 'min',
 'next',
 'object',
 'oct',
 'open',
 'ord',
 'pow',
 'print',
 'property',
 'range',
 'repr',
 'reversed',
 'round',
 'set',
 'setattr',
 'slice',
 'sorted',
 'staticmethod',
 'str',
 'sum',
 'super',
 'tuple',
 'type',
 'vars',
 'zip']

from ipywidgets import widgets
import re
lst=[i for i in dir(__builtins__) if re.findall(r'[a-z]',i[0])]
func=widgets.Select(options=lst,value=lst[0],description='内置函数')
def help_func(func):
    help(eval(func))
w=widgets.interactive_output(help_func,{'func':func})
widgets.HBox([func,w])

HBox(children=(Select(description='内置函数', options=('abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', …

import pandas as pd
import numpy as np
df=pd.DataFrame([[1,3,6,4],[2,9,7,8],[4,3,6,3],[9,4,7,2]])
df

类型转换

bin,oct,hex

bin(10)
oct(10)
hex(10)

'0b1010'

'0o12'

'0xa'

import pandas as pd
pd.DataFrame([[bin(i) for i in range(17)],[oct(i) for i in range(17)],[hex(i) for i in range(17)]],index=['bin','oct','hex'],columns=list(range(17)))

可以看到在16进制中，10进制从10开始，被表示为a，然后依次类推

float与complex

将某些字符串形式的数字以及一些特殊的字符串转化为float或complex

float('3')#字符串
float(3)#整数
float('inf')#特殊字符串
type(float('inf'))

3.0

3.0

inf

float

complex('3')
complex(3)
complex('3j')
complex(3,5)

(3+0j)

(3+0j)

3j

(3+5j)

int

int(3.5)#取整
int('3')#转化类型
int('1111',2)#按照指定进制转化字符串

3

3

15

ord,chr与str

ord('a')#返回单个字符的unicode编码
ord('汪')#返回单个汉字的unicode编码

97

27754

##返回unicode编码对应的字符
chr(97)
chr(27754)

'a'

'汪'

## 将任意对象转化为字符串
str([1,2,4])
str(1)

'[1, 2, 4]'

'1'

list,tuple,dict,set

将任意类型转化为列表，元组，字典，集合

list('123')#列表
tuple('123')#元组
dict(name='wcl',age=22)#字典
set('123')#

['1', '2', '3']

('1', '2', '3')

{'name': 'wcl', 'age': 22}

{'1', '2', '3'}

eval

内置函数eval()用来计算字符串或字节串的值，在有些场合也可以用来实现类型转换的功能。

eval('3+5')#计算字符串
eval(b'3+5')#计算字节串
eval('3')#类型转换
eval('[1,2,3]')#还原列表等，通过list方法是无法把一个列表形式的字符串还原为字符串的

8

8

3

[1, 2, 3]

max,min,sum,sorted,round

注意max和min可以指定排序规则

max,min

help(max)

Help on built-in function max in module builtins:

max(...)
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value
    
    With a single iterable argument, return its biggest item. The
    default keyword-only argument specifies an object to return if
    the provided iterable is empty.
    With two or more arguments, return the largest argument.

max(['111','1111'],key=len)#指定根据长度进行排序，也可以根据
max(1,2,3)
max([1,2,4],[3,2,1])#先比较第一个，相同则比较下一个
max([1,2,4],[1,3,0])
max([],default=0)#迭代对象为空，则需要指定default默认返回值

'1111'

3

[3, 2, 1]

[1, 3, 0]

0

df
max(df)
df1=pd.DataFrame(np.zeros((7,6)))
max(df1)
min(df1)
##放入数据框则返回的是列索引column的最大索引

3

5

0

sum

help(sum)

Help on built-in function sum in module builtins:

sum(iterable, start=0, /)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.

##注意start只能以位置参数的形式给出，不能以关键字参数的形式给出
sum([1,2,3])
sum([1,2,3],1)#1+1+2+3
sum([])
sum([],3)

6

7

0

3

sum(df)#返回列索引之和

6

sorted

sorted([3,5,2,7,4],key=lambda x:x,reverse=False)#x代表每一个元素，根据每一个元素的某些特征来进行排序，默认reverse=False表示升序排序

[2, 3, 4, 5, 7]

sorted([[3,5,7],[2,4,3]],key=lambda x:x[1])#根据第二个元素排序

[[2, 4, 3], [3, 5, 7]]

sorted(['1111','111'],key=len)#根据长度排序

['111', '1111']

sorted(df,key=lambda x:sum(df[x]))#根据索引对应列的和进行索引的排序

[0, 3, 1, 2]

如果根据排序规则有两个值相同，则先出现的排在前面

round

确定小数的位数

import math
print(math.pi,round(math.pi,2))
round(math.pi),round(math.pi,None)#不设置精度或者为None,则返回整数
round(math.pi,-2)#复数，则为0.0
round(math.pi,-5)

3.141592653589793 3.14

(3, 3)

0.0

0.0

input和print

input('请输入值：将会生成字符串')

请输入值：将会生成字符串abc

'abc'

一般会结合字符串的方法使用

print('abcdefg',sep=',')
print(1,2,3,sep='\t')#输出多个值，使用逗号分隔
print(1,2,3,sep='1')
for i in range(10):
    print(i,end=' ')#输出一个值，结尾是换行还是空格等

abcdefg
1	2	3
11213
0 1 2 3 4 5 6 7 8 9 

reversed,map,zip,filter,enumerate

这些都具有惰性求值的特点，只能被用一次，需要通过next函数,__next__方法，或者转化为序列等形式来获得值

reversed

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']

>>> reversed(x)                    #返回reversed对象

>>> list(reversed(x))              #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']

>>> ''.join(reversed('Hello world.'))
                                   #返回翻转后的字符串
                                   #join()把多个字符串连接为一个长字符串
>>> y = reversed(x)
>>> len(y)                         #不支持内置函数len()

<list_reverseiterator at 0x1891ccb9d08>

['ba', 'b', 'd', 'bc', 'aaaa']

['ba', 'b', 'd', 'bc', 'aaaa']

'.dlrow olleH'

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-44-2ad083328ea7> in <module>
     10                                    #join()把多个字符串连接为一个长字符串
     11 y = reversed(x)
---> 12 len(y)                         #不支持内置函数len()

TypeError: object of type 'list_reverseiterator' has no len()

>>> reversed(reversed(x))        #reversed对象不支持reversed()函数

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-41-70fab16ac800> in <module>
----> 1 reversed(reversed(x))        #reversed对象不支持reversed()函数

TypeError: 'list_reverseiterator' object is not reversible

使用next函数可以一个一个输出值，

当判断是否在该迭代器中时，他会从前往后遍历，直到遍历到了该值，前面的值包括该值都会被消除掉，只剩下还没有被迭代到的对象

z=reversed([1,2,3])
next(z)
next(z)

3

2

z=reversed([1,2,3])
3 in z #迭代到3，还剩下1,2
list(z)
3 in z# 直到结束，也迭代不到3了，此时为空
list(z)
1 in z
list(z)

True

[2, 1]

False

[]

False

[]

##1直到最后才被迭代到
z=reversed([1,2,3])
1 in z 
list(z)

True

[]

map

对可迭代对象的每一个元素应用函数

map(function(arg1,arg2,...),iterable1,iterable2,...) 

• 迭代对象的数量应该和函数的参数的个数保持一致
• 迭代对象的长度可以不一致，由最短的决定

list(map(int,'123'))
list(map(lambda x,y:x+y,[1,2,3],[4,5,6]))
list(map(lambda x,y:x*y,[1,2,3],[4,5]))

[1, 2, 3]

[5, 7, 9]

[4, 10]

zip

将多个可迭代对象结合，按照每一列的形式组合。每一个元素是多个可迭代对象的相应位置的元素共同组成，如果长度不一，由短的决定

• 每一个元素的长度与可迭代对象的个数保持一致

a=[1,2,3,4]
b=[4,5,6]
c=list(zip(a,b))
c
list(map(list,zip(*c)))

[(1, 4), (2, 5), (3, 6)]

[[1, 2, 3], [4, 5, 6]]

for i in zip(a,b):
    print(i)
    break
for i,j in zip(a,b):
    print(i)
    break

(1, 4)
1

filter

根据函数过滤掉不满足条件的元素

filter(function or None, iterable) 

• 如果给了函数，这个函数对可迭代对象中的每个元素作用，结果为true的保留生成一个新的迭代器。
• 如果没有函数,即None，则保留原迭代对象中那些值为true的值。

list(filter(lambda x:x>3,range(5)))
list(filter(None,range(5)))

[4]

[1, 2, 3, 4]

enumerate

同时获取索引和值组成的元组，比如(0, seq[0]), (1, seq[1]), (2, seq[2]), …

list(enumerate(range(5)))
list(enumerate(range(5),2))

[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

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

reduce

对单个可迭代对象的没两个元素进行遍历式的函数应用

##from functools import reduce
reduce(lambda x,y:x+y, range(1, 10))
reduce(lambda x,y:x+y,range(1,10),5) #当有初始值5时，会将它放在最前面输出
reduce(lambda x,y:x+y ,[],5)         #当可迭代对象为空时，initial值会被当做默认值输出

45

50

5