描述:返回数字的绝对值,不改变数据类型和数据精度
语法:abs( x )
参数:x -- 数值表达式
返回值:x(数字)的绝对值
描述:all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False。元素除了是 0、空、None、False 外都算 True
语法:all(iterable)
参数:iterable -- 元组或列表
返回值:如果iterable的所有元素不为0、''、False或者iterable为空,all(iterable)返回True,否则返回False;注意:空元组、空列表返回值为True。
描述:any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。也就是可迭代参数中的元素有一个为True则返回True,否则返回False。元素除了是 0、空、None、FALSE 外都算 TRUE
语法:any(iterable)
参数:iterable -- 元组或列表
返回值:如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true
描述:basestring() 方法是 str 和 unicode 的超类(父类),也是抽象类,因此不能被调用和实例化,但可以被用来判断一个对象是否为 str 或者 unicode 的实例,isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
语法:basestring()
参数:无
返回值:无
描述:bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
语法:bin(x)
参数:x -- int 或者 long int 数字
返回值:字符串
描述:bool() 函数用于将给定参数转换为布尔类型,如果没有参数,返回 False。bool 是 int 的子类。转换原则是 0、空、None、FALSE 是Flase,其他的是True。
空列表,空集合,空元组,空字典都是False,否则是True。
语法:class bool([x])
参数:x -- 要进行转换的参数。
返回值:返回 Ture 或 False。
描述:bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256(一个字节存储的内容大小)。
语法:class bytearray([source[, encoding[, errors]]])
参数:
返回值:返回 Ture 或 False。
描述:callable() 函数用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
魔术方法:
__call__使实例能够像函数一样被调用(可调用对象),同时不影响实例本身的生命周期,可以用来改变实例的内部成员的值(改变类实例的状态)。 x() 与 x.__call__() 等同。
__init__ 函数的意义等同于类的构造器(同理,__del__等同于类的析构函数)
语法:callable(object)
参数:object -- 对象
返回值:可调用返回 True,否则返回 False。
描述:chr() 用一个范围在 range(256)内的(就是0~255)整数作参数(ASCII码对应的数值),返回一个对应的字符。
语法:chr(i)
参数:i -- 可以是10进制也可以是16进制(0x或0X)的形式的数字。
返回值:返回值是当前整数对应的 ASCII 字符。
描述:classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数(需要传入类本身作为参数,否则访问出错),可以来调用类的属性,类的方法,实例化对象等。将普通方法转为类方法,作用同装饰器@classmethod。在类中调用,将实例方法转为类方法。
语法:classmethod(function)
参数:function -- 类中实例方法。
返回值:返回普通函数(实例方法)的类方法。
描述:cmp(x,y) 函数用于比较2个对象,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
数字:数字大小。
字符串:每个字符的ASCII码的大小。
语法:cmp(x, y)
参数:
返回值:如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
描述:compile() 函数将一个字符串编译为字节代码。然后使用exec, eval, single函数执行。
语法:compile(source, filename, mode[, flags[, dont_inherit]])
参数:
返回值:返回表达式执行结果。
描述:complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。字符串必须是“j”,不能是i。
z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,b称为虚部,i称为虚数单位。当z的虚部等于零时,常称z为实数;当z的虚部不等于零时,实部等于零时,常称z为纯虚数。
语法:class complex([real[, imag]])
参数:
返回值:返回一个复数。即使虚部为0(实数),格式也是虚数。
描述:delattr 函数用于删除类实例对象的属性。再次访问会出错。
delattr(x, 'foobar') 相等于 del x.foobar。
语法:delattr(object, name)
参数:
返回值:无。
访问报错:
Traceback (most recent call last):
File "test.py", line 22, in
print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'
描述:dict() 函数用于创建一个字典。
语法:
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数:
返回值:返回一个字典。
>>>dict() # 创建空字典
{}
>>> dict({'three': 3, 'four': 4}) # 传一个字典
>>> 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}
描述:dir() 函数不带参数时,返回当前范围(当前模块)内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息
语法:dir([object])
参数:object -- 对象、变量、类型
返回值:返回模块的属性列表
>>>dir() # 获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ]) # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
描述:python divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。
在 python 2.3 版本之前不允许处理复数。
语法:divmod(a, b)
参数:
返回值:包含商和余数的元组。
描述:enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
Python 2.3. 以上版本可用,2.6 添加 start 参数。
语法:enumerate(sequence, [start=0])
参数:
返回值:返回 enumerate(枚举) 对象。
描述:eval() 函数用来执行一个字符串表达式,并返回表达式的值。
语法:eval(expression[, globals[, locals]])
参数:
返回值:返回表达式计算结果。
描述:execfile() 函数可以用来执行一个文件。
语法:execfile(filename[, globals[, locals]])
参数:
返回值:返回文件内内容的执行结果。
python3 删去了 execfile(),代替方法如下:
with open('test1.py','r') as f:
exec(f.read())
描述:file() 函数用于创建一个 file 对象,它有一个别名叫 open(),更形象一些,它们是内置函数。参数是以字符串的形式传递的。
file是类,open才是内置函数。
语法:file(name[, mode[, buffering]])
参数:
返回值:文件对象。
描述:filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判别,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
注意: Pyhton2.7 返回列表,Python3.x 返回迭代器对象。 filter 类对象。filter 类实现了 __iter__ 和 __next__ 方法, 可以看成是一个迭代器, 有惰性运算的特性, 相对 Python2.x 提升了性能, 可以节约内存。
语法:filter(function, iterable)
参数:
返回值:返回列表。
判断整数:math.sqrt(x) % 1 == 0
描述:float() 函数用于将整数和字符串转换成浮点数。(类)
语法:class float([x])
参数:x -- 整数或字符串
返回值:返回浮点数。
描述:Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数,位置可以不按顺序。
语法:str.format(参数)
参数:需要格式化的参数(字符串,整数,浮点数)。
返回值:格式化后的字符串。
>>>"{} {}".format("hello", "world") # 不设置指定位置,按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
# 设置参数
print("网站名:{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名:{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
# 传入对象
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
格式化数字:
数字 | 格式 | 输出 | 描述 |
---|---|---|---|
3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
-1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
2.71828 | {:.0f} | 3 | 不带小数 |
5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
0.25 | {:.2%} | 25.00% | 百分比格式 |
1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
13 | {:10d} | 13 | 右对齐 (默认, 宽度为10) |
13 | {:<10d} | 13 | 左对齐 (宽度为10) |
13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
11 | |
|
进制 |
^, <, > 分别是居中、左对齐、右对齐,后面带宽度, : 号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。
+ 表示在正数前显示 +,负数前显示 -; (空格)表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外我们可以使用大括号 {} 来转义大括号,如下实例:
print ("{} 对应的位置是 {{0}}".format("runoob"))
描述:frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
语法:class frozenset([iterable]) 类
参数:iterable -- 可迭代的对象,比如列表、字典、元组等等。
返回值:返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合。
返回不可变集合。
描述:getattr() 函数用于返回一个对象属性值。
语法:getattr(object, name[, default])
参数:
返回值:返回对象属性值。
描述:globals() 函数会以字典类型返回当前位置的全部全局变量。
语法:globals()
参数:无。
返回值:返回一个全局变量的字典,除了内置变量,还包括所有导入的变量。
{'__builtins__': , '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
Python里只有2种作用域:全局作用域和局部作用域。全局作用域是指当前代码所在模块的作用域,局部作用域是指当前函数或方法所在的作用域。局部作用域里的代码可以读外部作用域(包括全局作用域)里的变量,但不能更改它。如果想更改它,这里就要使用global关键字了。
具体来看分以下几种情况:
1. 当你直接在局部域读取全局变量,可以直接使用。
2. 当你直接在局部域修改全局变量分两种情况:但是我们一定无法直接修改全局变量。
(1)比如a+=1的情况,是必须要首先声明变量才能执行。所以会报错,未声明该变量。
(2)比如a=1的情况,则系统认为你声明a局部变量,所以不会报错。但并不是修改全局变量。
3. 要想在局部域修改全局变量,可以使用global关键字首先声明该变量,然后修改。
4. 如果提前在局部域声明了该全局变量的同名变量,则覆盖全局变量(包括读取和修改)。
在Python 2.x中,闭包只能读外部函数的变量,而不能改写它。为了解决这个问题,Python 3.x引入了nonlocal关键字,在闭包内用nonlocal声明变量,就可以让解释器在外层函数中查找变量名。
注意:关键字nonlocal:是python3.X中出现的,所以在python2.x中无法直接使用.
描述:hasattr() 函数用于判断对象是否包含对应的属性。
语法:hasattr(object, name)
参数:
返回值:如果对象有该属性返回 True,否则返回 False。
描述:hash() 用于获取取一个对象(字符串或者数值等)的哈希值。
语法:hash(object)
参数:
返回值:返回对象的哈希值。hash 值都是固定长度的。
可以应用于数字、字符串和对象,不能直接应用于 list、set、dictionary。
在 hash() 对对象使用时,所得的结果不仅和对象的内容有关,还和对象的 id(),也就是内存地址有关。
描述:help() 函数用于查看函数或模块用途的详细说明。
语法:help([object])
参数:
返回值:返回对象帮助信息。
可以直接传入字符串,比如'sys','print'。
还可以直接传入类实例对象,返回该实例对象对应类的帮助信息,直接传入类实例对象的属性,返回该实例对象对应类属性的帮助信息。
描述:hex() 函数用于将10进制整数转换成16进制,以字符串形式表示。
语法:hex(x)
参数:
返回值:返回16进制数,以字符串形式表示。
描述:id() 函数用于获取对象的内存地址。
语法:id([object])
参数:
返回值:返回对象的内存地址。
描述:
Python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。
Python2.x 中 input() 相等于 eval(raw_input(prompt)) ,用来获取控制台的输入。raw_input() 将所有输入作为字符串看待,返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性,它返回所输入的数字的类型( int, float )。
注意:Python2 input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意:python3 里 input() 默认接收到的是 str 类型,不要求是合法python表达式。
语法:input([prompt])
参数:
返回值:返回输入内容。
描述:int() 函数用于将一个字符串或数字转换为整型。对于浮点数向下取整。
语法:class int(x, base=10)
参数:
返回值:返回整型数据。不传入参数时,得到结果0。
描述:isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法:isinstance(object, classinfo)
参数:
返回值:如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False。
type(A()) == A
type()函数返回对象类型,但不考虑父类(继承)关系。
基本类型包括:int,float,bool,complex,str(字符串),list,dict(字典),set,tuple。
除了基本类型就是类(系统类或自定义)。
描述:issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
语法:issubclass(class, classinfo)
参数:
返回值:如果 class 是 classinfo 的子类返回 True,否则返回 False。
两个类之间的比较。
描述:iter() 函数用来生成迭代器。
语法:iter(object[, sentinel])
参数:
返回值:迭代器对象。
描述:len() 方法返回对象(字符、列表、元组、字典、集合等)长度或项目个数。
语法:len( s )
参数:
返回值:返回对象长度。
描述:list() 方法用于将元组转换为列表。(元组和列表相同包括索引和访问,除了不能修改。而集合和字典都无法使用索引进行访问)
注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。
语法:list( tup )
参数:
返回值:返回列表。
描述:locals() 函数会以字典类型返回当前位置(当前模块或下层局部域,比如类内,函数内等)的全部局部变量。
语法:locals()
参数:
返回值:返回字典类型的局部变量。
函数的话包括函数的形参及所有定义的其他变量。
描述:long() 函数将数字或字符串转换为一个长整型。
语法:class long(x, base=10)
参数:
返回值:返回长整型数。输出带有L结尾。
描述:map() 会根据提供的函数对指定序列做映射(处理)。
第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
语法:map(function, iterable, ...)
参数:
返回值:
Python 2.x 返回列表。
Python 3.x 返回迭代器。
# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
描述:max() 方法返回给定参数的最大值,参数可以为序列。
语法:max( x, y, z, .... )
参数:
返回值:返回给定参数的最大值。
1 . 列表数字
直接比较大小即可。
2. 字符串
>>> a='1,2,3,4'
>>> type(a) #类型为字符串
>>> max(a) #max 返回了最大值
'4'
3. 列表里面是元组构成元素
按照元素里面元组的第一个元素的排列顺序,输出最大值(如果第一个元素相同,则比较第二个元素,输出最大值)据推理是按ascii码进行排序的,类似于字符串的比较。
4. 比较字典
比较字典里面的最大值,会输出最大的键值。因为键值不重复,所以不会出现元组重复的情况。(注:字典中如果键重复,后一个会覆盖前一个)
描述:memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。
语法:memoryview(obj)
参数:
返回值:返回元组列表。
Python2
>>>v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
>>> v[1:4].tobytes()
'bce'
Python3
>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
>>> print(v[1:4].tobytes())
b'bce'
描述:min() 方法返回给定参数的最小值,参数可以为序列。
语法:min( x, y, z, .... )
参数:
返回值:返回给定参数的最小值。
可变参数:多个数值或数值表达式,输出这几个参数的最小值
多个序列,以序列的形式输出,将单个序列的最小值组成一个序列。
描述:next() 返回迭代器的下一个项目。
语法:next(iterator[, default])
参数:
返回值:返回迭代器的元素。
描述:返回一个新的无特征对象,object是所有类的基类,有所有Python类实例的通用方法,该函数不接受任何参数。
注意:object没有__dict__方法,所以你不能给某个object类的实例分配任意属性。
其他类可直接设置属性:
#定义一个类A
>>> class A:
pass
>>> a = A()
>>> a.name = 'kim' # 能设置属性
语法:o = object()
参数:无。
返回值:返回一个object的实例对象。
>>> dir(object)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
python的__slots__设计是为了节省内存,也可以用于构造安全的类、如果一个类使用了__slots__那么它的属性就不再自由了。
slots__设置非自由属性
class person(object):
__slots__=('Name','Age')
def __init__(self,name,age):
self.Name=name #注意,__init__的执行在__slots__之后;所以就算在__init__方法里也是不能执行self.ID=007的。
self.Age=age
if__name__=='__main__':
p=person('jiangle',100)
p.ID=7 #这里会报错,由于我们使用了__slots__来声明属性,所以属性再也不是自由的了。
__new__ and __init__
新式类都有一个__new__的静态方法,它的原型是object.__new__(cls[, ...])
cls是一个类对象,当调用C(*args, **kargs)来创建一个类C的实例时,python的内部调用是 :
所以调用一个实例c = C(2),实际执行的代码为:
c = C.__new__(C, 2)
if isinstance(c, C):
C.__init__(c, 23)#__init__第一个参数要为实例对象
object.__new__()创建的是一个新的,没有经过初始化的实例。当重写__new__方法时,可以不用使用装饰符@staticmethod指明它是静态函数,解释器会自动判断这个方法为静态方法。如果需要重新绑定C.__new__方法时,只要在类外面执行C.__new__ = staticmethod(yourfunc)就可以了。
此外,如果(新式)类中没有重写__new__()方法,即在定义新式类时没有重新定义__new__()时,Python默认是调用该类的直接父类的__new__()方法来构造该类的实例,如果该类的父类也没有重写__new__(),那么将一直按此规矩追溯至object的__new__()方法,因为object是所有新式类的基类。
__repr__ and __str__
print(someobj)会调用someobj.str(), 如果str没有定义,则会调用someobj.repr().
描述:oct() 函数将一个整数转换成8进制字符串。
语法:oct(x)
参数:
返回值:返回8进制字符串。
以0开头。
描述:open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
语法:open(name[, mode[, buffering]])
参数:
name : 一个包含了你要访问的文件名称的字符串值(文件路径)。
mode : mode 决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读(r)。
buffering : 如果 buffering 的值被设为 0,就不会有缓存。如果 buffering 的值取 1,访问文件时会缓存行。如果将 buffering 的值设为大于 1 的整数,表明了这就是的缓存区的缓冲大小。如果取负值,缓存区的缓冲大小则为系统默认。
返回值:返回file对象。
模式 | 描述 |
---|---|
r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
w | 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
w+ | 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
a | 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
ab | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
a+ | 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。 |
ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。 |
+多一个功能。
file.read([size]):size 未指定则返回整个文件,如果文件大小 >2 倍内存则有问题,f.read()读到文件尾时返回""(空字串)。
file.readline():返回一行。
file.readlines([size]) :返回包含size行的列表, size 未指定则返回全部行。
for line in f: print line :通过迭代器访问。
f.write("hello\n"):如果要写入字符串以外的数据,先将他转换为字符串。
f.tell():返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
f.seek(偏移量,[起始位置]):用来移动文件指针。
f.close() 关闭文件
描述:ord() 函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数,它以一个字符(长度为1的字符串)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值,如果所给的 Unicode 字符超出了你的 Python 定义范围,则会引发一个 TypeError 的异常。
语法:ord(c)
参数:c -- 字符(长度为1的字符串)
返回值:对应的十进制整数
描述:pow() 方法返回 x^y(x的y次方) 的值。
语法:
math 模块 pow() 方法的语法:
math.pow( x, y )
内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方,如果z存在,则再对结果进行取模,其结果等效于pow(x,y) %z
pow(x,y) 等价于 x**y:
pow(x,y,z) 等价于 x**y%z:
注意:pow() 通过内置的方法直接调用,math 模块会把参数转换为 float,内置方法不修改参数类型:py2和py3相同。
math.pow(11.2,3.2)
Out[39]: 2277.7060352240815
math.pow(100, 2)
Out[40]: 10000.0
pow(11.2,3.2)
Out[42]: 2277.7060352240815
pow(100, 2)
Out[43]: 10000
pow(x,y,z) 当 z 这个参数不存在时 x,y 不限制是否为 float 类型, 而当使用第三个参数的时候要保证前两个参数只能为整数。
>>> pow(11.2,3.2)
2277.7060352240815
>>> pow(11.2,3.2,2) # 结果报错
Traceback (most recent call last):
File "", line 1, in
TypeError: pow() 3rd argument not allowed unless all arguments are integers
参数:
返回值:返回 x^y(x的y次方) 的值。
描述:print() 方法用于打印输出,最常见的一个函数。
print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。
语法:print(*objects, sep=' ', end='\n', file=sys.stdout)
参数:
返回值:无。
>>> print(a,b)
1 runoob
# py2会输出元组
描述:property() 函数的作用是在新式类中返回属性值。
语法:class property([fget[, fset[, fdel[, doc]]]])
参数:
返回值:返回新式类属性。
# 定义一个可控属性值 x
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter , del c.x 触发 deleter。
如果给定 doc 参数,其将成为这个属性值的 docstring,否则 property 函数就会复制 fget 函数的 docstring(如果有的话)。
将 property 函数用作装饰器可以很方便的创建只读属性:
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
property 的 getter,setter 和 deleter 方法同样可以用作装饰器:
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
这个代码和第一个例子完全相同,但要注意这些额外函数的名字和 property 下的一样,例如这里的 x。
描述:python range() 函数可创建一个整数列表,一般用在 for 循环中。
语法:range(start, stop[, step])
参数:
返回值:Python2整数列表,Python3是range对象。
Python3.x 中 range() 函数返回的结果是一个整数序列的对象(不是迭代器),而不是列表。
class 'range',可以利用list()函数强转为列表。
注意负数和0作为参数。
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
描述:python raw_input() 用来获取控制台的输入。raw_input() 将所有输入作为字符串看待,返回字符串类型。
注意:input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意:python3 里 input() 默认接收到的是 str 类型。
语法:raw_input([prompt])
参数:
返回值:字符串。
Python3.x 中 raw_input( ) 和 input( ) 进行了整合,去除了 raw_input( ),仅保留了 input( ) 函数,其接收任意任性输入,将所有输入默认为字符串处理,并返回字符串类型。
描述:reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合(列表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。
语法:reduce(function, iterable[, initializer])
参数:
返回值:返回函数计算结果。
在 Python3 中,reduce() 函数已经被从全局名字空间里移除了,它现在被放置在 functools 模块里,如果想要使用它,则需要通过引入 functools 模块来调用 reduce() 函数:
描述:reload() 用于重新载入之前载入的模块。
语法:reload(module)
参数:
返回值:返回模块对象。
Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件,但是,必须导入 imp包才能使用。
需要先import来加载需要的模块,这时候再去reload。
描述:repr() 函数将对象转化为供解释器读取的形式。
语法:repr(object)
参数:
返回值:返回一个对象的 string 格式。
函数str() 用于将值转化为适于人阅读的形式,而repr() 转化为供解释器读取的形式,主要指可以用eval()函数重新将文本转为对象。当然并不是所有repr()返回的字符串都能够用 eval()内建函数得到原来的对象。
会显示类型的特点,比如字符串会输出引号。
但大多数情况下,str,repr和"输出相同。print调用__str__。在python解释器里直接敲对象后回车,调用的是__repr__.
对应 __repr__功能。意思是当需要显示一个对象在屏幕上时,将这个对象的属性或者是方法整理成一个可以打印输出的格式。
描述:reverse() 函数用于反向列表中元素。
语法:list.reverse()
参数:无。
返回值:返回值是一个None,也就是该方法没有返回值,但是会对列表的元素进行反向排序。直接操纵所调用的列表。
是python中列表的一个内置方法(也就是说,在字典,字符串或者元组中,是没有这个内置方法的),用于列表中数据的反转。
描述:python自带的一个方法,准确说,应该是一个类。可以操纵列表,元组,字符串等序列和迭代器。不在原始迭代器或序列中操作,返回被操作之后的迭代器。
语法:list = reversed(iter)
参数:iter是列表,元组,字符串等序列,或迭代器。 要转换的序列,可以是 tuple, string, list 或 range。
返回值:反转之后的迭代器。
反转迭代器的序列值,返回反向迭代器。需要通过遍历,或者List,或者next()等方法,获取作用后的值。
描述:round() 方法返回浮点数x的四舍五入值。
语法:round( x [, n] )
参数:
返回值:返回浮点数x的四舍五入值。
描述:set() 函数创建一个无序不重复元素集(集合),可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
语法:class set([iterable])
参数:
返回值:返回新的集合对象。
& 交集,| 并集,- 差集。
描述:setattr() 函数对应函数 getattr(),用于设置属性值,该属性不一定是存在的。
语法:setattr(object, name, value)
参数:
返回值:无。
如果属性不存在会创建一个新的对象属性,并对属性赋值。
描述:slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。
语法:
class slice(stop)
class slice(start, stop[, step])
参数:
返回值:返回一个切片对象。
>>> 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]
描述:sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别:
sort 是应用在 list 上的方法(List类的函数,其他对象无法使用),sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作(对当前调用列表进行排序),无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
语法:
sorted(iterable[, cmp[, key[, reverse]]])
参数:
返回值:返回重新排序的列表。
>>> 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)]
注意:key 和 reverse 比一个等价的 cmp 函数处理速度要快。这是因为对于每个列表元素,cmp 都会被调用多次,而 key和 reverse 只被调用一次
描述:str() 函数将对象转化为适于人阅读的形式。
对应于__str__函数。
语法:class str(object='')
参数:
返回值:返回一个对象的str字符串格式。
描述:sum() 方法对序列进行求和计算。
语法:sum(iterable[, start])
参数:
返回值:返回计算结果。
描述:super() 函数是用于调用父类(超类)的一个方法。在子类内部调用父类的方法。
super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO,method resolution order)、重复调用(钻石继承)等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。在python中,每个类都有一个mro的类方法。可以直接调用查看调用顺序。可以看到mro方法返回的是一个祖先类的列表。每个祖先都在其中出现一次,这也是super在父类中查找成员的顺序。 通过mro,python巧妙地将多继承的图结构,转变为list的顺序结构。super在继承体系中向上的查找过程,变成了在mro中向右的线性查找过程,任何类都只会被处理一次。
1. 查找顺序问题。从Leaf的mro顺序可以看出,如果Leaf类通过super来访问父类成员,那么Medium1的成员会在Medium2之前被首先访问到。如果Medium1和Medium2都没有找到,最后再到Base中查找。
2. 钻石继承的多次初始化问题。在mro的list中,Base类只出现了一次。事实上任何类都只会在mro list中出现一次。这就确保了super向上调用的过程中,任何祖先类的方法都只会被执行一次。
钻石继承指继承多个类时,同时初始化多个父类。而这多个父类有同一个父类。导致该父类的父类被初始化了多次。直接调用父类.__init__就会遇到钻石继承,而如果调用super函数,则会自动处理该问题。
单继承的Java和Ruby肯定不会到钻石继承问题。
语法:super(type[, object-or-type])
参数:
返回值:无。
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x) # Python 3
super(B, self).add(x) # Python 2
b = B()
b.add(2) # 3
Python支持多继承。继承时如果是类变量(不需要实例化即可访问)可以直接继承。但如果子类不重写构造器__init__方法,才会调用父类的构造器__init__方法 ,获得父类的实例变量。否则需要主动调用父类的__init__方法来获取父类的实例变量:super(FooChild,self).__init__()。
对于多继承按照继承顺序继承,首先继承第一个类的变量。
直接继承优先于间接继承的内容。
描述:元组 tuple() 函数将列表转换为元组。
语法:tuple( seq )
参数:
返回值:返回元组。
参数如果是字典则转换字典的键。
比如遍历字典,一个元素等于遍历key()。itmes()则返回元组(键, 值)对。
元组的元素不能修改(所以可以作为字典的键)。元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
描述:type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法:
type(object)
type(name, bases, dict)
参数:
返回值:一个参数返回对象类型, 三个参数,返回新的类型对象(等同于直接创建一个类)。
>>> type({0:'zero'})
>>> x = 1
>>> type( x ) == int # 判断类型是否相等
True
# 三个参数
>>> class X(object):
... a = 1
...
# 上下作用相同
>>> X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X
>>> X
描述:unichr() 函数 和 chr()函数功能基本一样, 只不过是返回 unicode 的字符。
语法:unichr(i)
参数:
返回值:返回 unicode 的字符。字符前面加u左下标。
描述:unicode是一种字符表示方法,定义了一系列字符的映射表示。不过在逻辑上unicode是没有编码的格式。进行I/O输出的时候一定要做encode("utf-8")这样类似的操作。每个字符都与唯一的数字关联,称为code point。
一种不用字节的形式来表示文本;就是说是变长的。每种语言的每一个字符都有唯一的数字来表示。支持所有主流的语言;可以表示超过100万的符号。
字符表示的是文本中的单个符号。更重要的是,一个字符不是一个字节。而且,一个字符有许多表示方法,不同的表示方法会使用不同的字节数。字符编码是在理想的字符和实际的字节表示方法之间的映射。这种映射无需面面俱到,即在某种编码中也许无法表示一些特定的字符。如果这些特定的字符用不到,那么这种编码方式还是可以用的。同时也无须为每个字符使用相同的内存空间,譬如某些字符使用单字节编码,而其他字符需要多个字节。
在Python的类型层次中,有3种不同的字符串类型:“unicode”,表示Unicode字符串(文本字符串)。“str”,表示字节字符串(二进制数据)。“basestring”,表示前两种字符串类型的父类。
字符串a使用decode就会得到unicode类型,a为unicode类型的时候a.encode就会得到str类型了。
语法:unicode(str)
参数:
返回值:返回 unicode 的字符。字符前面加u左下标。encode之后变成原始字符串。
UTF-8是变长编码方法:就是变量的多字节表示,前128个字符就和ascii一样。(其他的1字节表示不了,需要更多字节,一个字符可能需要1-4个字节)
描述:vars() 函数返回对象object的属性和属性值的字典对象。
语法:vars([object])
参数:
返回值:返回对象object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()(当前模块,包括内置变量)。
>>>print(vars())
{'__builtins__': , '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
... a = 1
...
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}
描述:xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组或列表,而是一个生成器。
语法:
xrange(stop)
xrange(start, stop[, step])
参数:
返回值:返回生成器。节省内存,惰性结构。可以利用list转换为列表。
迭代器和生成器:
迭代器:访问集合元素的一种方式。字符串,列表或元组对象都可用于创建迭代器。可以记住遍历的对象的上一次位置;从集合的第一个元素开始访问,直到所有的元素被访问结束。
即:只能往前不会后退。使用next()函数进行访问。
内建函数 iter()可以从 可迭代对象中获得迭代器(collections.Iterator)。迭代器可利用iter直接生成。包括:listiterator,tupleiterator,setiterator,dictionary-keyiterator等。
可迭代对象:list tuple dict str set collections.Iterable
序列(字符串,元组和列表)
一个可迭代的对象必须是定义了__iter__()方法的对象,而一个迭代器必须是定义了__iter__()方法和__next()__方法的对象。
iter([1,2,3,4])
Out[23]:
iter((1,2,3,4))
Out[24]:
1)__iter__()
该方法返回的是当前对象的迭代器类的实例。因为可迭代对象与迭代器都要实现这个方法,因此有以下两种写法。
写法一:用于可迭代对象类的写法,返回该可迭代对象的迭代器类(专门用于迭代可迭代对象的一个类)的实例。
写法二:用于迭代器类的写法,直接返回self(即自己本身),表示自身即是自己的迭代器。
2)next()
返回迭代的每一步,实现该方法时注意要最后超出边界要抛出StopIteration异常,以停止for循环。
一个实现了iter方法的对象时可迭代的,一个实现next方法的对象是迭代器,可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。
生成器(generator):通过 yield 语句快速生成迭代器,省略了复杂的 _iter__()&__next__()方式。在Python中,这种一边循环一边计算的机制,称为生成器:generator。是迭代器的一种,使用yield返回值函数,每次调用yield会暂停,而可以使用next()函数和send()函数恢复生成器。生成器看起来像是一个函数,但是表现得却像是迭代器。
生成器是能够返回一个迭代器的函数,其最大的作用是将输入对象返回为一个迭代器。Python中使用了迭代的概念,是因为当需要循环遍历一个较大的对象时,传统的内存载入方式会消耗大量的内存,不如需要时读取一个元素的方式更为经济快捷。
简单的说就是在函数的执行过程中,yield语句会把你需要的值返回给调用生成器的地方,然后退出函数,下一次调用生成器函数的时候又从上次中断的地方开始执行,而生成器内的所有变量参数都会被保存下来供下一次使用。创建迭代器的简单而强大的工具。只是在需要返回数据的时候使用yield语句。
生成器在迭代的过程中可以改变当前迭代值,而修改普通迭代器的当前迭代值往往会发生异常,影响程序的执行。
惰性。
如何创建生成器:
第一种方法很简单,把一个列表生成式的[]中括号改为()小括号,就创建一个generator。
#列表生成式
lis = [x*x for x in range(10)]
print(lis)
#生成器
generator_ex = (x*x for x in range(10))
print(generator_ex)
(1)通过next()函数获得generator的下一个返回值。
(2)使用for循环,因为generator也是可迭代对象,抛出StopIteration的错误,结束for循环。
一类是集合数据类型,如list,tuple,dict,set,str等
一类是generator,包括生成器和带yield的generator function
这些可以直接作用于for 循环的对象统称为可迭代对象:Iterable
from
collections
import
Iterable
第二种方法是通过yield关键字主动生成一个复杂的生成器。
def fib(max):
n,a,b =0,0,1
while n < max:
yield b
a,b =b,a+b
n = n+1
return 'done'
for i in fib(6):
print(i)
但是用for循环调用generator时,发现拿不到generator的return语句的返回值,如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中。
while True:
try:
x = next(g)
print('generator: ',x)
except StopIteration as e:
print("生成器返回值:",e.value)
break
生成器和迭代器的区别:
1、语法方面来讲:
生成器是用函数中yield语句来创建的。迭代器的创建首先跟函数无关,可以用iter([1,2])来创建。
2、使用方面来讲:
由于生成器是使用函数的方式创建的,所以生成器里面的所有过程都会被执行,但请注意生成器里面的过程只有在被next()调用或者for循环调用时,里面的过程才会被执行,如同上面的例子只是单纯调用add这个对象时,add里面的过程没有被执行哦
迭代器同样可以被for和next调用但是由于没有其他过程,在被调用时只会返回值,不会有其他动作
描述:zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同:在 Python 3.x 中为了减少内存,zip() 返回的是一个对象(节约了内存)。如需展示列表,需手动 list() 转换。
语法:zip([iterable, ...])
参数:
返回值:返回元组列表。
描述:__import__() 函数用于动态加载类和函数 。如果一个模块经常变化就可以使用 __import__() 来动态载入。
语法:__import__(name[, globals[, locals[, fromlist[, level]]]])
参数:
返回值:返回元组列表。
描述:python staticmethod 返回函数的静态方法。该方法不强制要求传递参数(类方法),如下声明一个静态方法(修饰器):
类可以不用实例化就可以调用该方法 C.f(),当然也可以实例化后调用 C().f()。
class C(object):
@staticmethod
def f(arg1, arg2, ...):
...
语法:staticmethod(function)
参数:
返回值:返回元组列表。
描述:用于当函数参数已经存在于一个元组或字典中时,间接地调用函数。类似于反射调用的函数。
语法:apply(func [, args [, kwargs ]])
参数:args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args,任何参数都不会被传递,kwargs是一个包含关键字参数的字典。
返回值:apply()的返回值就是func()的返回值,apply()的元素参数是有序的,元素的顺序必须和func()形式参数的顺序一致。
1、假设是执行没有带参数的方法
def say():
print 'say in'
apply(say)
输出的结果是'say in'
2、函数只带元组的参数。
def say(a, b):
print a, b
apply(say,("hello", "老王python"))
输出的结果是hello,老王python
3、函数带关键字参数。
def say(a=1,b=2):
print a,b
def haha(**kw):
#say(kw)
apply(say,(),kw)
print haha(a='a',b='b')
输出的结果是:a,b
描述:创建一个新的缓冲对象,该对象引用(指向)给定的对象。缓冲区将从对象的开始(或在指定的偏移量)引用目标对象的切片。该切片将扩展到目标对象的末端(或具有指定大小)。
语法:buffer(object [, offset[, size]])
参数:
返回值:返回一个新的缓冲对象
描述:返回由两个数值参数组成的元组,使用与算术运算符相同的规则转换为常见类型。如果coerce不可用,那么触发TypeError。
语法:coerce(x, y) -> (x1, y1)
参数:数值
返回值:元组
描述:手动将目标字符串驻留到字符串池子里。
语法:intern(str)
参数:字符串
返回值:字符串
字符串驻留机制:值同样的字符串对象仅仅会保存一份,是共用的,这也决定了字符串必须是不可变对象。
其实我们想一想,就和数值类型一样,同样的数值仅仅要保存一份即可了,不是必须用不同对象来区分。
>>> a = 'opq'
>>> b = 'o' + 'pq'
>>> id(a)
66832910
>>> id(b)
66832910
intern机制的优点是,在创建新的字符串对象时,会先在缓存池里面找是否有已经存在的值相同的对象(标识符,即只包含数字、字母、下划线的字符),如果有,则直接拿过来用(引用),避免频繁的创建和销毁内存,提升效率。
缺点是在拼接字符串时,或者在改动字符串时会极大的影响性能(多次重新创建对象)。原因是字符串在Python当中是不可变对象,所以对字符串的改动不是inplace(原地)操作,需要新开辟内存地址,新建对象。这也是为什么拼接字符串的时候不建议用‘+’而是用join()。join()是先计算出全部字符串的长度,然后再一一拷贝,仅仅创建一次对象(类似于字符串拼接中java要用stringbuffer和stringbuilder,而不是string)。
>>> a = 'hello world'
>>> b = 'hello world'
>>> id(a)
66834385
>>> id(b)
66439216
由于字符串里面含有空格,导致不会触发intern机制。
可是为什么会这么做呢?既然Python的内置函数intern()能显式的对随意字符串进行intern,说明不是实现难度的问题。
答案在源代码StringObject.h中的注释能够找到:intern机制仅仅对那些看起来像是Python标识符的字符串对象才会触发。
>>> 'op' + 'q' is 'opq'
>>> True
>>> c = 'op'
>>> d = 'opq'
>>> c + 'q' is 'opq'
>>> False
前半部分是在运行时进行拼接,没有自动调用intern机制
若是intern(a+“n”) is b 则是返回false。
>>> intern(c + 'q') is 'opq'
>>> False
在第一个例子中,‘op’ + ‘q’是在compile-time(编译时)求值的,被替换成了’opq’,而在第二个例子中,c + ‘q’是在run-time(运行时)拼接的,导致没有被主动intern。因为c是变量。
>>> s1 = "hell"
>>> s2 = "hello"
>>> s1 + "o" is s2
False
>>> "hell" + "o" is s2
True
>>>
# 说明shell和IDE在这方面没有差异
s1 = "hell"
s2 = "hello"
print(s1 + "o" is s2) # False
print("hell" + "o" is s2) # True
#因为"hell" + "o"在编译时已经变成了"hello",而s1+"o"因为s1是一个变量,他们会在运行时进行拼接,所以没有被intern
apply()、buffer()、coerce()、intern()---这些是过期的内置函数(3.0开始移除了),少用。具体内容参考:https://docs.python.org/zh-cn/3.7/library/functions.html