内置函数（一）

内置函数：
作用域相关  ******
globals() :返回一个字典：包含全部的全局变量。
locals() ： 返回一个字典：包含的是当前作用域 所有的变量。

1 b = 2
2 def func1():
3     a = 1
4     print(locals())
5     print(globals())
6 func1()

字符串类型代码的执行 eval，exec，complie
eval函数
功能：将字符串str当成有效的表达式来求值并返回计算结果。

函数的作用：
计算指定表达式的值。也就是说它要执行的Python代码只能是单个运算表达式（注意eval不支持任意形式的赋值操作），而不能是复杂的代码逻辑，这一点和lambda表达式比较相似。

函数定义：
eval(expression, globals=None, locals=None)
参数说明：
expression：必选参数，可以是字符串，也可以是一个任意的code对象实例（可以通过compile函数创建）。如果它是一个字符串，它会被当作一个（使用globals和locals参数作为全局和本地命名空间的）Python表达式进行分析和解释。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
如果globals与locals都被忽略，那么它们将取eval()函数被调用环境下的全局命名空间和局部命名空间。
返回值：
如果expression是一个code对象，且创建该code对象时，compile函数的mode参数是'exec'，那么eval()函数的返回值是None；
否则，如果expression是一个输出语句，如print()，则eval()返回结果为None；
否则，expression表达式的结果就是eval()函数的返回值；
实例：

 1 x = 10
 2 def func():
 3     y = 20
 4     a = eval('x + y')
 5     print('a: ', a)
 6     b = eval('x + y', {'x': 1, 'y': 2})
 7     print('b: ', b)
 8     c = eval('x + y', {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
 9     print('c: ', c)
10     d = eval('print(x, y)')
11     print('d: ', d)
12 
13 func()

输出结果：

a:  30
b:  3
c:  4
10 20
d:  None
对输出结果的解释：

对于变量a，eval函数的globals和locals参数都被忽略了，因此变量x和变量y都取得的是eval函数被调用环境下的作用域中的变量值，即：x = 10, y = 20，a = x + y = 30
对于变量b，eval函数只提供了globals参数而忽略了locals参数，因此locals会取globals参数的值，即：x = 1, y = 2，b = x + y = 3
对于变量c，eval函数的globals参数和locals都被提供了，那么eval函数会先从全部作用域globals中找到变量x, 从局部作用域locals中找到变量y，即：x = 1, y = 3, c = x + y = 4
对于变量d，因为print()函数不是一个计算表达式，没有计算结果，因此返回值为None

可以把list,tuple,dict和string相互转化。
#################################################
字符串转换成列表

1 >>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
2 >>>type(a)
3 <type 'str'>
4 >>> b = eval(a)
5 >>> print b
6 [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
7 >>> type(b)
8 <type 'list'>

#################################################
字符串转换成字典

1 >>> a = "{1: 'a', 2: 'b'}"
2 >>> type(a)
3 <type 'str'>
4 >>> b = eval(a)
5 >>> print b
6 {1: 'a', 2: 'b'}
7 >>> type(b)
8 <type 'dict'>

#################################################
字符串转换成元组

1 >>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
2 >>> type(a)
3 <type 'str'>
4 >>> b = eval(a)
5 >>> print b
6 ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
7 >>> type(b)
8 <type 'tuple'>

2. exec函数
函数的作用：
动态执行Python代码。也就是说exec可以执行复杂的Python代码，而不像eval函数那么样只能计算一个表达式的值，没有返回值。

函数定义：
exec(object[, globals[, locals]])
参数说明：
object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，同eval函数
locals：可选参数，同eval函数
返回值：
exec函数的返回值永远为None.

需要说明的是在Python 2中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个execfile()函数。可以理解为Python 3把exec这个statement和execfile()函数的功能够整合到一个新的exec()函数中去了：

eval()函数与exec()函数的区别：
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。
实例1：
我们把实例1中的eval函数换成exec函数试试：

 1 x = 10
 2 
 3 def func():
 4     y = 20
 5     a = exec('x + y')
 6     print('a: ', a)
 7     b = exec('x + y', {'x': 1, 'y': 2})
 8     print('b: ', b)
 9     c = exec('x + y', {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
10     print('c: ', c)
11     d = exec('print(x, y)')
12     print('d: ', d)
　　　　fun（）

输出结果：

a:  None
b:  None
c:  None
10 20
d:  None
因为我们说过了，exec函数的返回值永远为None
实例2：

 1 x = 10
 2 expr = """
 3 z = 30
 4 sum = x + y + z
 5 print(sum)
 6 """
 7 
 8 
 9 def func():
10     y = 20
11     exec(expr)
12     exec(expr, {'x': 1, 'y': 2})
13     exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
14 
15 
16 func()

输出结果：

60
33
34
对输出结果的解释：

前两个输出跟上面解释的eval函数执行过程一样，不做过多解释。关于最后一个数字34，我们可以看出是：x = 1, y = 3
是没有疑问的。关于z为什么还是30而不是4，这其实也很简单，我们只需要在理一下代码执行过程就可以了，其执行过程相当于：

 1 x = 1
 2 y = 2
 3 
 4 
 5 def func():
 6     y = 3
 7     z = 4
 8 
 9     z = 30
10     sum = x + y + z
11     print(sum)
12 
13 
14 func()

compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。参数说明：　　　

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。
'''
流程语句使用exec

1 code1 = 'for i in range(0,10): print (i)'
2 compile1 = compile(code1,'','exec')
3 exec (compile1)

简单求值表达式用eval

1 code2 = '1 + 2 + 3 + 4'
2 compile2 = compile(code2,'','eval')
3 eval(compile2)

交互语句用single
 code3 = 'name = input("please input your name:")'
 compile3 = compile(code3,'','single')
 name #执行前name变量不存在
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"

.2.2 输入输出相关 input，print

　　input:函数接受一个标准输入数据，返回为 string 类型。

　　print:打印输出。
''' 源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """
'''

1 print(111,222,333,sep='*')  # 111*222*333
2 
3 print(111,end='')
4 print(222)  #两行的结果 111222
5 
6 f = open('log','w',encoding='utf-8')
7 print('写入文件',file=f,flush=True)

1.2.3内存相关 hash id

　　hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值

 1 print(hash(12322))
 2 print(hash('123'))
 3 print(hash('arg'))
 4 print(hash('alex'))
 5 print(hash(True))
 6 print(hash(False))
 7 print(hash((1,2,3)))
 8 
 9 '''
10 -2996001552409009098
11 -4637515981888139739
12 1
13 2528502973977326415
14 '''
15 print(hash([1,2,3]))      #不可以hash
16 print(hash({1:2,3:4}))

id:用于获取对象的内存地址。
注意：在全局变量下，每个变量的id地址不同，而{}，[]的id地址相同


1.2.3文件操作相关

　　open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

1.2.4模块相关__import__　

　　__import__：函数用于动态加载类和函数 。

1.2.5帮助

　　help：函数用于查看函数或模块用途的详细说明。

1.2.6调用相关

　　callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

1.2.7查看内置属性

　　dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
1.2.7查看内置属性  ***

　　dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
name = 'alex'
print(dir(name))

range：函数可创建一个整数对象，一般用在 for 循环中。
 python2x: range(3) ---> [0,1,2] 列表
           xrange(3) ---> 迭代器。
 python3x: range(3) ---> range(0,3) 可迭代对象

　　next：内部实际使用了__next__方法，返回迭代器的下一个项目。
　　iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。

1.4 .1
数字相关（14）

　　数据类型（4）：

　　　　bool ：用于将给定参数转换为布尔类型，如果没有参数，返回False。 ***

1 print(bool(1 < 2 and 3 > 4 or 5 < 6 and 9 > 2 or 3 > 1))
2 print(bool('fdsjkfl'))

　　int：函数用于将一个字符串或数字转换为整型。***

1 print(int('123'))
2 print(int(3.74)) # 取整 不是四舍五入
3 print(int('0101',base=2))  # 将2进制的 0100 转化成十进制。结果为 4

float：函数用于将整数和字符串转换成浮点数。 ***

1 print(type(3.14))

complex：函数用于创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。。

 进制转换（3）：

　　bin：将十进制转换成二进制并返回。

1 print(bin(100))  # 0b1100100

　　oct：将十进制转化成八进制字符串并返回。

1 print(oct(7))  # 0o7
2 print(oct(8))  # 0o10
3 print(oct(9))  # 0o10

hex：将十进制转化成十六进制字符串并返回。

1 print(hex(10)) # 0xa
2 print(hex(15)) # 0xf
3 print(hex(17)) # 0xf

数学运算（7）：

　　　　abs：函数返回数字的绝对值。 ****

1 print(abs(-100))

　　　　divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。 ****

1 print(divmod(12,7))  # (1, 5) (商，余数)

应用分页。
103 条数据，你每页显示12 条数据，你最终显示多少页。
print(divmod(103,12))
　　　　round：保留浮点数的小数位数，默认保留整数,四舍五入。  ***
print(round(3.141592653,4))

　　　　pow：求x**y次幂。（三个参数为x**y的结果对z取余） **
print(pow(2,5))
print(pow(2,5,12))
　　　　sum：对可迭代对象进行求和计算（可设置初始值）。 *****

1 sum(iterable,start_num)
2 print(sum([1,2,3,4,100,101]))
3 print(sum([1,2,3,4,100,101],100))
4 print(sum([int(i) for i in [1,'2',3,'4','100',101]]))

min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。 *****

1 print(min([1,-2,3,4,100,101]))
2 print(min([1,-2,3,4,100,101]))
3 print(min([1,-2,3,4,100,101],key=abs))
4 [('alex',1000),('太白',18),('wusir',500)]

求出年龄最小的那个元组

1 ls = [('alex',1000),('太白',18),('wusir',500)]
2 min1 = min([i[1] for i in ls])
3 for i in ls:
4     if i[1]==min1:
5         print(i)
6 def func(x):
7     return x[1]  # 1000  18  500
8 print(min([('alex',1000),('太白',18),('wusir',500)],key=func))

1,他会将iterable的每一个元素当做函数的参数传进去。
2，他会按照返回值去比较大小。
3,返回的是 遍历的元素 x.

1 dic = {'a':3,'b':2,'c':1}
2 def func1(x):
3     return dic[x]
4 print(min(dic,key=func1))
5 def func2(x):
6     return x[1]
7 print(min(dic.items(),key=func2))

max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。 *****
print(max([1,2,3,100]))

any()与all()
函数的区别:

　　
any是任意，而all是全部。

 1 any(...)
 2 
 3 any(iterable) -> bool
 4 
 5 Return
 6 True if bool(x) is True
 7 for any x in the iterable.
 8 
 9 If
10 the
11 iterable is empty,
12 return False.any(iterable)

说明：参数iterable：可迭代对象；

如果当iterable所有的值都是0、''
或False时，那么结果为False，如果所有元素中有一个值非0、''
或False，那么结果就为True


如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)




注意：空元组、空列表返回值为True，这里要特别注意。

转载于:https://www.cnblogs.com/qilin610/p/9519719.html