logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

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

 看见就非常 2020-10-30

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

abs：求数值的绝对值

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

>>> abs(-2)2
  • 1
  • 2
  • 1
  • 2

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

>>> divmod(5,2)(2, 1)>> divmod(5.5,2)(2.0, 1.5)
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

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

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

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

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

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

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

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

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

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

>>> round(1.1314926,1)1.1>>> round(1.1314926,5)1.13149
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

近似计算我们还有其他的选择：
使用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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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

>>> bool() #未传入参数False>>> bool(0) #数值0、空序列等值为FalseFalse>>> bool(1)True
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

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

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

>>>float(1)1.0>>> float(112)112.0>>> float(-123.6)-123.6>>> float('123')     # 字符串123.0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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

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

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'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

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

>>>ord('a')97>>> ord('b')98>>> ord('c')99
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

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

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

>>>bin(10)'0b1010'>>> bin(20)'0b10100'
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

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

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

>>>oct(10)'012'>>> oct(20)'024'>>> oct(15)'017'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

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

>>>hex(255)'0xff'>>> hex(-42)'-0x2a'>>> hex(1L)'0x1L'>>> hex(12)'0xc'>>> type(hex(12))<class 'str'>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

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

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}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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'])
  • 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

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'])   # 创建不可变集合
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

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]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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__
  • 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

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]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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

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

>>> a = map(ord,'abcd')>>> a<map object at 0x03994E50>>>> list(a)[97, 98, 99, 100]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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'
  • 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

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

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

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)]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

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)]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

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

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

>>>a = 'runoob'>>> id(a)4531887632>>> b = 1>>> id(b)140588731085608
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

hash：获取对象的哈希值

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

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

len：返回对象的长度

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

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

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

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

>>> class A(object): pass>>> a.__dict__{}>>> vars(a){}>>> a.name = 'Kim'>>> a.__dict__{'name': 'Kim'}>>> vars(a){'name': 'Kim'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

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}
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

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=?
  • 1
  • 2
  • 3
  • 4
  • 1
  • 2
  • 3
  • 4

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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
  • 1
  • 2
  • 3
  • 1
  • 2
  • 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'}'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

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你好
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

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

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>}
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

_doc_ ：获取文件的注释

'''这里是文件的注释'''print(__doc__) #__doc__ ：获取文件的注释#输出# 这里是文件的注释
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

_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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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

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

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

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

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

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 看见就非常 > 《待分类》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多