Python学习——内置函数与变量

本节主要讲述python的内置函数、变量以及常用内置模块的函数。

abs：求数值的绝对值

返回一个数的绝对值。参数可以是普通的整数，长整数或者浮点数。如果参数是个复数，返回它的模

>>> abs(-2)
2

divmod：返回两个数值的商和余数，以元组形式返回

>>> divmod(5,2)
(2, 1)
>> divmod(5.5,2)
(2.0, 1.5)

max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

>>> max(1,2,3) # 传入3个参数 取3个中较大者
3
>>> max('1234') # 传入1个可迭代对象，取其最大元素值
'4'
>>> max(-1,0) # 数值默认去数值较大者
0
>>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
-1

min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

>>> min(1,2,3) # 传入3个参数 取3个中较小者
1
>>> min('1234') # 传入1个可迭代对象，取其最小元素值
'1'
>>> min(-1,-2) # 数值默认去数值较小者
-2
>>> min(-1,-2,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者
-1

pow：返回两个数值的幂运算值或其与指定整数的模值

pow(x,y) 等价于 x**y
pow(x,y,z) 等价于 x**y%z

>>> pow(2,3)
>>> 2**3

round：对浮点数进行四舍五入求值

第一个参数是一个浮点数，第二个参数是保留的小数位数，可选，如果不写的话默认保留到整数
round函数有个坑，比较好的解释请参见：http://www.runoob.com/w3cnote/python-round-func-note.html

>>> round(1.1314926,1)
1.1
>>> round(1.1314926,5)
1.13149

近似计算我们还有其他的选择：
使用math模块中的一些函数，比如math.ceiling（天花板除法）。
python自带整除，python2中是/，3中是//，还有div函数。
字符串格式化可以做截断使用，例如 “%.2f” % value（保留两位小数并变成字符串如果还想用浮点数请披上float()的衣）。
当然，对浮点数精度要求如果很高的话，用decimal模块。

sum：对元素类型是数值的可迭代对象中的每个元素求和

>>> sum((1,2,3,4))
10
# 元素类型必须是数值型
>>> sum((1.5,2.5,3.5,4.5))
12.0
>>> sum((1,2,3,4),-10)
0

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

>>> bool() #未传入参数
False
>>> bool(0) #数值0、空序列等值为False
False
>>> bool(1)
True

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

默认语法：class int(x, base=10)

>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8

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

默认语法：class float([x])

>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0

str：函数将对象转化为适于人阅读的形式。

默认语法：class str(object=”)

>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>> str(123)
'123'

bytearray：根据传入的参数创建一个新的字节数组，这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

默认语法：class bytearray([source[, encoding[, errors]]])
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray('runoob', 'utf-8')
bytearray(b'runoob')
>>> bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

bytes：根据传入的参数创建一个新的不可变字节数组

>>> bytes('中文','utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'

memoryview：根据传入的参数创建一个新的内存查看对象

默认语法：memoryview(obj)
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
返回元组列表

>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'

ord：返回Unicode字符对应的整数

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99

chr：返回整数所对应的Unicode字符

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a

bin：将整数转换成2进制字符串

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

>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'

oct：将整数转化成8进制数字符串

oct() 函数将一个整数转换成8进制字符串。

>>>oct(10)
'012'
>>> oct(20)
'024'
>>> oct(15)
'017'

hex：将整数转换成16进制字符串

hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。

>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'> 

tuple：根据传入的参数创建一个新的元组

默认语法：tuple( seq )，seq – 要转换为元组的序列

>>>tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple 
(1, 3)
>>> tuple((1,2,3,4))    #元组会返回元组自身 
(1, 2, 3, 4)

list：根据传入的参数创建一个新的列表

>>>list() # 不传入参数，创建空列表
[] 
>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
['a', 'b', 'c', 'd']

dict：根据传入的参数创建一个新的字典

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

set：根据传入的参数创建一个新的集合

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

>>>set() # 不传入参数，创建空集合
set()
>>> a = set(range(10)) # 传入可迭代对象，创建集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])

frozenset：根据传入的参数创建一个新的不可变集合

class frozenset([iterable])
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合

enumerate：根据可迭代对象创建枚举对象

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
enumerate(sequence, [start=0])

>>>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')]
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print(i, element)
... 
0 one
1 two
2 three

range：根据传入的参数创建一个新的range对象

range(start, stop[, step])
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
range() 函数可创建一个整数列表，一般用在 for 循环中。

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

iter：根据传入的参数创建一个新的可迭代对象

iter(object[, sentinel])
object – 支持迭代的集合对象。
sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的next()方法时，都会调用 object。
iter() 函数用来生成迭代器。

>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3
class counter: 
    def __init__(self, _start, _end):
        self.start = _start
        self.end = _end
    def get_next(self):
       s = self.start
        if(self.start < self.end):
            self.start += 1
        else:
            raise StopIteration
        return s
c = counter(1, 5)
iterator = iter(c.get_next, 3)
print(type(iterator))
for i in iterator:
    print(i)
>>> <class 'callable_iterator'>
>>> 1
>>> 2

slice：根据传入的参数创建一个新的切片对象

class slice(stop)
class slice(start, stop[, step])
start – 起始位置
stop – 结束位置
step – 间距
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]

super：根据传入的参数创建一个新的子类和父类关系的代理对象

super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
super(type[, object-or-type])
type – 类。
object-or-type – 类，一般是 self
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx

#定义父类A
>>> class A(object):
    def __init__(self):
        print('A.__init__')
#定义子类B，继承A
>>> class B(A):
    def __init__(self):
        print('B.__init__')
        super().__init__()
#super调用父类方法
>>> b = B()
B.__init__
A.__init__

filter：使用指定方法过滤可迭代对象的元素

filter()接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

>>> a = list(range(1,10)) #定义序列
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> def if_odd(x): #定义奇数判断函数
    return x%2==1
>>> list(filter(if_odd,a)) #筛选序列中的奇数
[1, 3, 5, 7, 9]

map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

>>> a = map(ord,'abcd')
>>> a
<map object at 0x03994E50>
>>> list(a)
[97, 98, 99, 100]

reduce：对参数序列中元素进行累积，生成新的可迭代对象

reduce(function, iterable[, initializer])
function – 函数，有两个参数
iterable – 可迭代对象
initializer – 可选，初始参数
reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做计算

>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15

next：返回可迭代对象中的下一个元素值

next(iterator[, default])
iterator – 可迭代对象
default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常

>>> a = iter('abcd')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    next(a)
StopIteration
#传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常
>>> next(a,'e')
'e'
>>> next(a,'e')
'e'

reversed：反转序列生成新的可迭代对象

>>> a = reversed(range(10)) # 传入range对象
>>> a # 类型变成迭代器
<range_iterator object at 0x035634E8>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

sorted：对可迭代对象进行排序，返回一个新的列表

sorted(iterable[, cmp[, key[, reverse]]])
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']
>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']
>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)] 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

all：all(iterable)

函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、FALSE 外都算 TRUE。
注意：空元组、空列表返回值为True，这里要特别注意。

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any：any(iterable)

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

id：返回对象的唯一标识符

id() 函数用于获取对象的内存地址。

>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608

hash：获取对象的哈希值

>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378

type：返回对象的类型，或者根据传入的参数创建一个新的类型

class type(name, bases, dict)
name – 类的名称。
bases – 基类的元组。
dict – 字典，类内定义的命名空间变量。
type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
一个参数返回对象类型, 三个参数，返回新的类型对象。

# 一个参数实例
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1          
>>> type( x ) == int    # 判断类型是否相等
True
# 三个参数
>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
>>> X
<class '__main__.X'>
class A:
    pass
class B(A):
    pass
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

len：返回对象的长度

len() 方法返回对象（字符、列表、元组等）长度或项目个数。

>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5

vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

vars() 函数返回对象object的属性和属性值的字典对象。
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

>>> class A(object):
    pass
>>> a.__dict__
{}
>>> vars(a)
{}
>>> a.name = 'Kim'
>>> a.__dict__
{'name': 'Kim'}
>>> vars(a)
{'name': 'Kim'}

isinstance：判断对象是否是类或者类型元组中任意类元素的实例

isinstance(object, classinfo)
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类

issubclass(class, classinfo)
class – 类。
classinfo – 类。
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。如果 class 是 classinfo 的子类返回 True，否则返回 False。

>>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True

hasattr：检查对象是否含有属性

hasattr(object, name)
object – 对象。
name – 字符串，属性名。
hasattr() 函数用于判断对象是否包含对应的属性。

>>> class Student:
    def __init__(self,name):
        self.name = name        
>>> s = Student('Aim')
>>> hasattr(s,'name') #a含有name属性
True
>>> hasattr(s,'age') #a不含有age属性
False

getattr：获取对象的属性值

getattr(object, name[, default])
object – 对象。
name – 字符串，对象属性。
default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
getattr() 函数用于返回一个对象属性值。

>>> class Student:
    def __init__(self,name):
        self.name = name
>>> getattr(s,'name') #存在属性name
'Aim'
>>> getattr(s,'age',6) #不存在属性age，但提供了默认值，返回默认值
>>> getattr(s,'age') #不存在属性age，未提供默认值，调用报错
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    getattr(s,'age')
AttributeError: 'Stduent' object has no attribute 'age'

setattr：设置对象的属性值

setattr(object, name, value)
object – 对象。
name – 字符串，对象属性。
value – 属性值。
setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在。

>>> class Student:
    def __init__(self,name):
        self.name = name        
>>> a = Student('Kim')
>>> a.name
'Kim'
>>> setattr(a,'name','Bob')
>>> a.name
'Bob'

delattr：删除对象的属性

delattr(object, name)
object – 对象。
name – 必须是对象的属性。
delattr(x, ‘foobar’) 相等于 del x.foobar。

#定义类A
>>> class A:
    def __init__(self,name):
        self.name = name
    def sayHello(self):
        print('hello',self.name)
#测试属性和方法
>>> a.name
'小麦'
>>> a.sayHello()
hello 小麦
#删除属性
>>> delattr(a,'name')
>>> a.name
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    a.name
AttributeError: 'A' object has no attribute 'name'

callable：检测对象是否可被调用

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

>>> class B: #定义类B
    def __call__(self):
        print('instances are callable now.')        
>>> callable(B) #类B是可调用对象
True
>>> b = B() #调用类B
>>> callable(b) #实例b是可调用对象
True
>>> b() #调用实例b成功
instances are callable now.

globals：返回当前作用域内的全局变量和其值组成的字典

globals() 函数会以字典类型返回当前位置的全部全局变量。

>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

locals：返回当前作用域内的局部变量和其值组成的字典

locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

>>> def f():
    print('before define a ')
    print(locals()) #作用域内无变量
    a = 1
    print('after define a')
    print(locals()) #作用域内有一个a变量，值为1   
>>> f
<function f at 0x03D40588>
>>> f()
before define a 
{} 
after define a
{'a': 1}

print：向标准输出对象打印输出

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file – 要写入的文件对象。
print() 方法用于打印输出，最常见的一个函数。
print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

>>> print("www","runoob","com",sep=".")  # 设置间隔符
www.runoob.com
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?

input：读取用户输入值

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。
raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）
注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意：python3 里 input() 默认接收到的是 str 类型。

>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<type 'int'>               # 整型
>>> a = input("input:")    
input:"runoob"           # 正确，字符串表达式
>>> type(a)
<type 'str'>             # 字符串
>>> a = input("input:")
input:runoob               # 报错，不是表达式
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'runoob' is not defined
<type 'str'>

>>>a = raw_input("input:")
input:123
>>> type(a)
<type 'str'>              # 字符串
>>> a = raw_input("input:")
input:runoob
>>> type(a)
<type 'str'>              # 字符串

eval：执行动态表达式求值

eval(expression[, globals[, locals]])
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
eval() 函数用来执行一个字符串表达式，并返回表达式的值。

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值

compile() 函数将一个字符串编译为字节代码。
compile(source, filename, mode[, flags[, dont_inherit]])
source – 字符串或者AST（Abstract Syntax Trees）对象。。
filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志

>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17

exec：执行动态语句块

>>> exec('a=1+2') #执行语句
>>> a
3

repr：返回一个对象的字符串表现形式(给解释器)

repr() 函数将对象转化为供解释器读取的形式。
repr(object)

>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

property：标示属性的装饰器

property() 函数的作用是在新式类中返回属性值。
class property([fget[, fset[, fdel[, doc]]]])
fget – 获取属性值的函数
fset – 设置属性值的函数
fdel – 删除属性值函数
doc – 属性描述信息

>>> class C:
    def __init__(self):
        self._name = ''
    @property
    def name(self):
        """i'm the 'name' property."""
        return self._name
    @name.setter
    def name(self,value):
        if value is None:
            raise RuntimeError('name can not be None')
        else:
            self._name = value            
>>> c = C()
>>> c.name # 访问属性
''
>>> c.name = None # 设置属性时进行验证
Traceback (most recent call last):
  File "<pyshell#84>", line 1, in <module>
    c.name = None
  File "<pyshell#81>", line 11, in name
    raise RuntimeError('name can not be None')
RuntimeError: name can not be None
>>> c.name = 'Kim' # 设置属性
>>> c.name # 访问属性
'Kim'
>>> del c.name # 删除属性，不提供deleter则不能删除
Traceback (most recent call last):
  File "<pyshell#87>", line 1, in <module>
    del c.name
AttributeError: can't delete attribute
>>> c.name
'Kim'

classmethod：标示方法为类方法的装饰器

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

>>> class C:
    @classmethod
    def f(cls,arg1):
        print(cls)
        print(arg1)


>>> C.f('类对象调用类方法')
<class '__main__.C'>
类对象调用类方法

>>> c = C()
>>> c.f('类实例对象调用类方法')
<class '__main__.C'>
类实例对象调用类方法

staticmethod：标示方法为静态方法的装饰器

返回函数的静态方法。

# 使用装饰器定义静态方法
>>> class Student(object):
    def __init__(self,name):
        self.name = name
    @staticmethod
    def sayHello(lang):
        print(lang)
        if lang == 'en':
            print('Welcome!')
        else:
            print('你好！')           
>>> Student.sayHello('en') #类调用,'en'传给了lang参数
en
Welcome!
>>> b = Student('Kim')
>>> b.sayHello('zh')  #类实例对象调用,'zh'传给了lang参数
zh
你好

好了，写了三天了，内置函数就先写这么多，以上三个函数，需要在面向对象的详细理解并说明。
以下就说一下内置全局变量

vars()查看内置全局变量

以字典方式返回内置全局变量

print(vars())
#输出
# {'__builtins__': <module 'builtins' (built-in)>, '__spec__': None, '__package__': None, '__doc__': None, '__name__': '__main__', '__cached__': None, '__file__': 'H:/py/index.py', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000000AC32C66A58>}

_doc_ ：获取文件的注释

"""
这里是文件的注释
"""
print(__doc__)  #__doc__    ：获取文件的注释
#输出
# 这里是文件的注释

_file_ 【重点】获取当前文件的路径

_file_ ，一般配合os模块的os.path.dirname()，os.path.basename() ，os.path.join() 模块函数来使用

import os
a = __file__    # __file__全局变量获取当前文件路径
print(a) 
b = os.path.dirname(a) #获取文件当前目录：注意：os.path.dirname()叠加一次向上找一次 如下
print(b) 
b2 = os.path.dirname(b) #获取文件当前目录的上级目录，注意：os.path.dirname()叠加一次向上找一次
print(b2) 
c = os.path.basename(a) #获取文件名称
print(c)
#输出
# H:/py/lib/ska/mk.py
# H:/py/lib/ska
# H:/py/lib
# mk.py

_package_ ：获取导入文件的路径多层目录以点分割，注意：对当前文件返回None

print(__package__)  #注意：对当前文件返回None
from lib.ska import mk  #导入mk模块文件
print(mk.__package__) #__package__ ：获取导入文件的路径，多层目录以点分割，注意：对当前文件返回None
#输出
# None
# lib.ska
# lib.ska

_cached_ ：获取导入文件的缓存路径

from lib.ska import mk  #导入mk模块文件
print(mk.__cached__) #__cached__ ：获取导入文件的缓存路径
#输出
# H:\py\lib\ska\__pycache__\mk.cpython-35.pyc

_name_ 获取导入文件的路径加文件名称路径以点分割，获取当前文件返回_main_

print(__name__) #注意:获取当前文件返回__main__
from lib.ska import mk  #导入mk模块文件
print(mk.__name__)  #获取导入文件的路径加文件名称，路径以点分割
#输出
# __main__
# lib.ska.mk

ok，这一节就写到这吧，还有一些关于文件操作的函数没写出来，文件操作需要另写一篇，才能加深理解，而且现在文件操作用的还不是很熟悉，等用熟悉了在写吧。