python ----内置函数

def abs(*args, **kwargs)
返回参数的绝对值。

a = -5
print(abs(a))      #打印结果：5

 

 

all(*args, **kwargs)
all() 函数用于判断给定的可迭代参数 iterable 中的全部元素是否都为 TRUE，若是是返回 True，不然返回 False。
元素除了是 0、空、FALSE 外都算 TRUE。
PS:注意：空元组、空列表返回值为True，这里要特别注意。

all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True

all(['a', 'b', '', 'd'])  # 列表list，存在一个为空的元素
False

all([0, 1，2, 3])  # 列表list，存在一个为0的元素
False

all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True

all(('a', 'b', '', 'd'))  # 元组tuple，存在一个为空的元素
False

all((0, 1, 2, 3))  # 元组tuple，存在一个为0的元素
False

all([])  # 空列表
True

all(())  # 空元组
True

 

any(*args, **kwargs)
any() 函数用于判断给定的可迭代参数 iterable 是否所有为 False，则返回 False，若是有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
若是都为空、0、false，则返回false，若是不都为空、0、false，则返回true。

any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True

any(['a', 'b', '', 'd'])  # 列表list，存在一个为空的元素
True

any([0, '', False])  # 列表list,元素全为0,'',false
False

any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True

any(('a', 'b', '', 'd'))  # 元组tuple，存在一个为空的元素
True

any((0, '', False))  # 元组tuple，元素全为0,'',false
False

any([])  # 空列表
False

any(())  # 空元组
False

 

python中any()和all()如何使用
本质上讲，any()实现了或(OR)运算，而all()实现了与(AND)运算。
更多:https://blog.csdn.net/cython22/article/details/78829288

ascii(*args, **kwargs)
ascii() 函数相似 repr() 函数, 返回一个表示对象的字符串, 可是对于字符串中的非 ASCII 字符则返回经过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串相似 Python2 版本中 repr() 函数的返回值。

ascii('runoob')
 "'runoob'"   #打印结果

 

bin(*args, **kwargs)
返回一个整数 int 或者长整数 long int 的二进制表示。

print(bin(13))   #打印结果：0b1101

 

bool(int)

Python 中布尔值使用常量 True 和 False 来表示。
一、在数值上下文环境中，True 被看成 1，False 被看成 0，例如：

print(True+3)   #输出结果：4
print(False+2)   #输出结果：2

 

二、其余类型值转换 bool 值时除了 ''、""、''''''、""""""、0、()、[]、{}、None、0.0、0L、0.0+0.0j、False 为 False 外，其余都为 True 例如：

print(bool(-2))    #输出结果：True

print(bool(''))     ##输出结果：False

 

bytearray(object)
返回一个新字节数组。这个数组里的元素是可变的，而且每一个元素的值范围: 0 <= x < 256。

a = [1,2,3]
print(bytearray(a))   #输出结果：bytearray(b'\x01\x02\x03')

bytes(object)
返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

a = [1,2,3]
print(bytes(a))   #输出结果：b'\x01\x02\x03'

 

callable(i_e_, some_kind_of_function)
用于检查一个对象是不是可调用的。若是返回True，object仍然可能调用失败；但若是返回False，调用对象ojbect绝对不会成功。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

callable(0)
False
callable("runoob")
False
def add(a, b):
    ...
    return a + b

callable(add)  # 函数返回 True
True


class A:  # 类
    ...

    def method(self):

        ...
    return 0

callable(A)  # 类返回 True
True
a = A()
callable(a)  # 没有实现 __call__, 返回 False
False


class B:
    ...

    def __call__(self):

        ...
    return 0



callable(B)
True
b = B()
callable(b)  # 实现 __call__, 返回 True
True

 

chr(*args, **kwargs)
用一个范围在 range（256）内的（就是0～255）整数做参数，返回一个对应的字符。
能够是10进制也能够是16进制的形式的数字。
返回值是当前整数对应的ascii字符。

print(chr(0x61))  #输出结果：a
print(chr(49))  #输出结果：1

 

classmethod(object)
修饰符对应的函数不须要实例化，不须要 self 参数，但第一个参数须要是表示自身类的 cls 参数，能够来调用类的属性，类的方法，实例化对象等。

class A(object):
    bar = 1

    def func1(self):
        print('foo')

    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()  # 调用 foo 方法


A.func2()  # 不须要实例化

输出结果：
func2
1
foo

 

compile(*args, **kwargs)
将一个字符串编译为字节代码。

str = "3 * 4 + 5"
a = compile(str,'','eval')
print(eval(a))     #输出结果：17

 

complex(object)
用于建立一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。若是第一个参数为字符串，则不须要指定第二个参数。。

complex(1, 2)
(1 + 2j)

complex(1)  # 数字
(1 + 0j)

complex("1")  # 当作字符串处理
(1 + 0j)

# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，不然会报错
complex("1+2j")
(1 + 2j)

 

delattr(x, y)
用于删除属性。
delattr(x, 'foobar') 相等于 del x.foobar。

class Coordinate:
    x = 10
    y = -5
    z = 0


point1 = Coordinate()

print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)

delattr(Coordinate, 'z')

print('--删除 z 属性后--')
print('x = ', point1.x)
print('y = ', point1.y)

# 触发错误
print('z = ', point1.z)

输出结果：

('x = ', 10)
('y = ', -5)
('z = ', 0)
--删除 z 属性后--
('x = ', 10)
('y = ', -5)
Traceback (most recent call last):
  File "test.py", line 22, in <module>
    print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'

 

class dict(object)

字典是另外一种可变容器模型，且可存储任意类型对象。
字典的每一个键值 key=>value 对用冒号 : 分割，每一个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }键通常是惟一的，若是重复最后的一个键值对会替换前面的，值不须要惟一。

dict = {'a': 1, 'b': 2, 'b': '3'};
dict['b']
'3'
dict
{'a': 1, 'b': '3'}

值能够取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此建立字典：

dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

把相应的键放入熟悉的方括弧，以下实例:

实例

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print
"dict['Name']: ", dict['Name'];
print
"dict['Age']: ", dict['Age'];

以上实例输出结果：

dict['Name']: Zara
dict['Age']: 7

 

若是用字典里没有的键访问数据，会输出错误以下：

实例

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print
"dict['Alice']: ", dict['Alice'];
以上实例输出结果：

dict['Alice']:
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

 

修改字典
向字典添加新内容的方法是增长新的键/值对，修改或删除已有键/值对以下实例:

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

dict['Age'] = 8;  # update existing entry
dict['School'] = "DPS School";  # Add new entry

print
"dict['Age']: ", dict['Age'];
print
"dict['School']: ", dict['School'];

 

以上实例输出结果：

dict['Age']:  8
dict['School']:  DPS School

 

删除字典元素
能删单一的元素也能清空字典，清空只需一项操做。

显示删除一个字典用del命令，以下实例：

实例

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

del dict['Name'];  # 删除键是'Name'的条目
dict.clear();  # 清空词典全部条目
del dict;  # 删除词典

print
"dict['Age']: ", dict['Age'];
print
"dict['School']: ", dict['School'];

 

但这会引起一个异常，由于用del后字典再也不存在：

dict['Age']:
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

注：del ()
方法后面也会讨论。


字典键的特性
字典值能够没有限制地取任何python对象，既能够是标准的对象，也能够是用户定义的，但键不行。

两个重要的点须要记住：

1）不容许同一个键出现两次。建立时若是同一个键被赋值两次，后一个值会被记住，以下实例：

实例

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};

print
"dict['Name']: ", dict['Name'];
以上实例输出结果：

dict['Name']: Manni

 

2）键必须不可变，因此能够用数字，字符串或元组充当，因此用列表就不行，以下实例：

实例

dict = {['Name']: 'Zara', 'Age': 7};

print
"dict['Name']: ", dict['Name'];
以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Zara', 'Age': 7};
TypeError: list objects are unhashable

 

 

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

print(dir())   #['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

 

 

def divmod(x, y)
把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(7,2))  #(3, 1)     商3，余1

print(divmod(8,2))  #(4, 0)     商4，余0

 

 

class enumerate(object)
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，通常用在 for 循环当中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

i = 0
seq = ['one', 'two', 'three']
for element in seq:
    print (i, seq[i])
    i +=1

输出结果：
0 one
1 two
2 three

 

def eval(*args, **kwargs)
用来执行一个字符串表达式，并返回表达式的值。

x = 7
print(eval('3 * x'))

print(eval('pow(2,2)'))

print(eval('2 + 2'))

n =81
print(eval("n + 4"))

输出结果：
21
4
4
85

 

 

def exec(*args, **kwargs)
执行储存在字符串或文件中的 Python 语句，相比于 eval，exec能够执行更复杂的 Python 代码。
返回值
exec 返回值永远为 None。

exec('print("Hello World")')
exec("print ('runoob.com')")

 

多行语句字符串
exec("""for i in range(5):
      print ("iter time: %d" % i)
   """)

 

输出结果：
Hello World
runoob.com
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4

 

 

class filter(object)
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，若是要转换为列表，能够使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每一个元素做为参数传递给函数进行判，而后返回 True 或 False，最后将返回 True 的元素放到新列表中。
返回一个迭代器对象

def is_odd(n):
    return n % 2 == 1


tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)