Python学习——内置函数与变量 / 四六文摘

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

abs：求数值的绝对值
divmod：返回两个数值的商和余数，以元组形式返回
max：返回可迭代对象中的元素中的最大值或者所有参数的最大值
min：返回可迭代对象中的元素中的最小值或者所有参数的最小值
pow：返回两个数值的幂运算值或其与指定整数的模值
round：对浮点数进行四舍五入求值
sum：对元素类型是数值的可迭代对象中的每个元素求和
bool：函数用于将给定参数转换为布尔类型，如果没有参数，返回 False
int：函数用于将一个字符串或数字转换为整型
float：函数用于将整数和字符串转换成浮点数。
str：函数将对象转化为适于人阅读的形式。
bytearray：根据传入的参数创建一个新的字节数组，这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
bytes：根据传入的参数创建一个新的不可变字节数组
memoryview：根据传入的参数创建一个新的内存查看对象
ord：返回Unicode字符对应的整数
chr：返回整数所对应的Unicode字符
bin：将整数转换成2进制字符串
oct：将整数转化成8进制数字符串
hex：将整数转换成16进制字符串
tuple：根据传入的参数创建一个新的元组
list：根据传入的参数创建一个新的列表
dict：根据传入的参数创建一个新的字典
set：根据传入的参数创建一个新的集合
frozenset：根据传入的参数创建一个新的不可变集合
enumerate：根据可迭代对象创建枚举对象
range：根据传入的参数创建一个新的range对象
iter：根据传入的参数创建一个新的可迭代对象
slice：根据传入的参数创建一个新的切片对象
super：根据传入的参数创建一个新的子类和父类关系的代理对象
filter：使用指定方法过滤可迭代对象的元素
map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
reduce：对参数序列中元素进行累积，生成新的可迭代对象
next：返回可迭代对象中的下一个元素值
reversed：反转序列生成新的可迭代对象
sorted：对可迭代对象进行排序，返回一个新的列表
zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
all：all(iterable)
any：any(iterable)
id：返回对象的唯一标识符
hash：获取对象的哈希值
type：返回对象的类型，或者根据传入的参数创建一个新的类型
len：返回对象的长度
vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
isinstance：判断对象是否是类或者类型元组中任意类元素的实例
issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类
hasattr：检查对象是否含有属性
getattr：获取对象的属性值
setattr：设置对象的属性值
delattr：删除对象的属性
callable：检测对象是否可被调用
globals：返回当前作用域内的全局变量和其值组成的字典
locals：返回当前作用域内的局部变量和其值组成的字典
print：向标准输出对象打印输出
input：读取用户输入值
eval：执行动态表达式求值
compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值
exec：执行动态语句块
repr：返回一个对象的字符串表现形式(给解释器)
property：标示属性的装饰器
classmethod：标示方法为类方法的装饰器
staticmethod：标示方法为静态方法的装饰器
vars()查看内置全局变量
_doc_ ：获取文件的注释
_file_ 【重点】获取当前文件的路径
_package_ ：获取导入文件的路径多层目录以点分割，注意：对当前文件返回None
_cached_ ：获取导入文件的缓存路径
_name_ 获取导入文件的路径加文件名称路径以点分割，获取当前文件返回_main_

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、空序列等值为FalseFalse>>> bool(1)True

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

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

>>>int() # 不传入参数时，得到结果00>>> 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))>>> afrozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})>>> b = frozenset('runoob') >>> bfrozenset(['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 one1 two2 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)[]

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

>>>lst = [1, 2, 3]>>> for i in iter(lst):... print(i)... 123class 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 sc = 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个元素的切片>>> mysliceslice(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+515>>> 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: passclass B(A): passisinstance(A(), A) # returns Truetype(A()) == A # returns Trueisinstance(B(), A) # returns Truetype(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))    # 是元组中的一个返回 TrueTrue

`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.nameTraceback (most recent call last): File '<pyshell#47>', line 1, in <module> a.nameAttributeError: '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.

1
2
3
4
5
6
7
8
9
10

1
2
3
4
5
6
7
8
9
10

`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}

1
2
3
4
5
6
7
8
9
10
11
12
13

1
2
3
4
5
6
7
8
9
10
11
12
13

`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'>              # 字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

`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)0123456789>>> str = '3 * 4 + 5'>>> a = compile(str,'','eval')>>> eval(a)17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

`exec：执行动态语句块`

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

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.nameAttributeError: 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'>类实例对象调用类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

`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参数enWelcome!>>> 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 osa = __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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

print(__package__) #注意：对当前文件返回Nonefrom 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，这一节就写到这吧，还有一些关于文件操作的函数没写出来，文件操作需要另写一篇，才能加深理解，而且现在文件操作用的还不是很熟悉，等用熟悉了在写吧。

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

abs：求数值的绝对值

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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