python内垃圾函数,python 内部函数

享学课堂浅谈Python序列内建函数都有哪些

1、Python类型操作符和内建函数总结

表4.5列出了所有操作符和内建函数，其中操作符顺序是按优先级从高到低排列的。同一种灰度的操作符拥有同样的优先级。注意在operator模块中有这些（和绝大多数Python)操作符相应的同功能的函数可供使用。

表4.5 标准类型操作符和内建函数

操作符/函数

描 述

结 果a

字符串表示

``

对象的字符串表示

str

内建函数

cmp(obj1, obj2)

比较两个对象

int

repr(obj)

对象的字符串表示

str

str(obj)

对象的字符串表示

str

type(obj)

检测对象的类型

type

值比较

小于

bool

大于

bool

=

小于或等于

bool

=

大于或等于

bool

==

等于

bool

!=

不等于

bool

不等于

bool

对象比较

is

是

bool

is not

不是

bool

布尔操作符

not

逻辑反

bool

and

逻辑与

bool

or

逻辑或

bool

2、Python数值类型操作符和内建函数

一、工厂函数

数值工厂函数总结类（工厂函数） 操作

bool(obj) b 返回obj对象的布尔值，也就是 obj.__nonzero__()方法的返回值。

int(obj, base=10) 　 返回一个字符串或数值对象的整数表 示， 类似string.atoi();

从Python 1.6起， 引入了可选的进制参数。

long(obj, base=10) 返回一个字符或数据对象的长整数表 示，类似string.atol(),

从Python1.6起， 引入了可选的进制参数 float(obj) ，

返回一个字符串或数据对象的浮点数 表示，类似string.atof()。

complex(str) or返回一个字符串的复数表示，或 者根据给定的实数，

complex(real, imag=0.0) 　（及一个可选 的虚数部分）生成一个复数对象。

二、内建函数

1、分类

Python 有五个运算内建函数用于数值运算：

abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)

其中abs()返回给定参数的绝对值。如果参数是一个复数， 那么就返回math.sqrt(num.real2 + num.imag2).

coerce()是一个数据类型转换函数，不过它的行为更像一个运算符.数coerce（）为程序员提供了不依赖Python 解释器，而是自定义两个数值类型转换的方法。对一种新创建的数值类型来说， 这个特性非常有用.函数coerce()仅返回一个包含类型转换完毕的两个数值元素的元组.

divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组.对整数来说，它的返回值就是地板除和取余操作的结果.对浮点数来说，返回的商部分是math.floor(num1/num2)，对复数来说，商部分是ath.floor((num1/num2).real).

pow()它和双星号 （**）运算符都可以进行指数运算.不过二者的区别并不仅仅在于一个是运算符，一个是内建函数.在Python 1.5 之前，并没有 ** 运算符,内建函数pow()还接受第三个可选的参数，一个余数参数.如果有这个参数的， pow() 先进行指数运算，然后将运算结果和第三个参数进行取余运算.这个特性主要用于密码运算，并且比 pow(x,y) % z 性能更好， 这是因为这个函数的实现类似于C 函数pow(x,y,z).

round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数.如果不提供小数位参数， 它返回与第一个参数最接近的整数（但仍然是浮点类型）.第二个参数告诉round 函数将结果精确到小数点后指定位数.

2、函数int()/round()/math.floor()它们之间的不同之处：

函数 int()直接截去小数部分.（返回值为整数）

函数 floor()　得到最接近原数但小于原数的整数.（返回值为浮点数）

函数 round() 得到最接近原数的整数.（返回值为浮点数）

3、进制转换函数:

返回字符串表示的8 进制和16 进制整数,它们分别是内建函数：

oct()和 hex(). oct(255)='0377'/hex(255)='0xff'

函数chr()接受一个单字节整数值(0到255)，返回一个字符串(ASCII)，其值为对应的字符.chr(97)='a'

函数ord()则相反，它接受一个字符(ASCII 或 Unicode)，返回其对应的整数值.ord('A')=65

3、Python字符串函数

(一)标准类型操作符和标准内建函数

1)、标准类型操作符

,,=,=,==,!=,对象值得比较

注：做比较时字符串是按ASCII值的大小来比较的

is 对象身份比较

and,or,not 布尔类型

2）标准内建函数

type(obj)

cmp(obj1,obj2)

str(obj)和repr(obj) 或反引号运算符(``) 可以方便的以字符串的方式获取对象的

内容、类型、数值属性等信息。str()函数得到的字符串可读性好， 而repr()函数得到的字符

串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的

isinstance(obj,type) 判断对象的类型

(二)序列操作

1、序列操作

字符串属于序列对象，可以使用所有序列的操作和函数

切片 [] [:] [::]

简单总结：

*索引（S[i])获取特定偏移的元素。

——第一个元素偏移为0

——（S[0])获取第一个元素。

——负偏移索引意味着从最后或右边反向进行计数

——（S[-2])获取倒数第二个元素（就像S[len(s)-2]一样

*分片[S[i:j]提取对应的部分作为一个序列

——右边界不包含在内

——分片的边界默认为0和序列的长度，如果没有给出的话S[:]

——（S[1:3])获取了从偏移为1，直到但不包括偏移为3的元素

——（S[1:])获取从偏移为1到末尾之间的元素

——（S[:3])获取从偏移为0直到但不包括偏移为3的元素

——（S[:-1])获取从偏移为0直到但不包括最后一个元素之间的元素

——（S[:])获取从偏移为0到末尾之间的元素,这有效地实现了顶层S拷贝

拷贝了一个相同值，但是是不同内存区域的对象。对象字符串这样不可变的对象不是很有用，但是对于可以实地修改的对象来说很有用。

比如列表。

扩展分片：第三个限制值 【步进】

完整形式：X[I:J:K]:这标识索引X对象的元素，从偏移为I直到J-1，每隔K元素索引一次。第三个限制值，K，默认为1

实例

Python Code

1

2

3

4

5

S='abcdefghijk'

S[1:10]

'bcdefghij'

S[1:10:2]

'bdfhj

也可以使用负数作为步进。

分片表达式

Python Code

1

2

"hello"[::-1]

'olleh'

通过负数步进，两个边界的意义实际上进行了反转。

3、成员操作符 in ，not in

返回布尔值True 或False

可以使用string模块来判断输入字符的合法性，可见成品中的idcheck.py

4、字符串连接

+ 连接字符串 ‘name’+' '+'jin'

字符串格式化 '%s %s' % ('name','jin')

join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])

5、删除清空字符串

del aString

aString=''

(三)、序列函数

序列类型函数

len(str) 返回字串的长度

enumerate(iter):接受一个可迭代对象作为参数，返回一个enumerate

max(str)/min(str):max()和min()函数对其他的序列类型可能更有用,但对于string类型它们能很好地运行,返回最大或者最小的字符(按照ASCII 码值排列),

zip([it0, it1,... itN]) 返回一个列表，其第一个元素是it0,it1,...这些元素的第一个元素组成的一个元组，第二个...,类推.

reversed(seq)c 接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)

sorted(iter,func=None,key=None,reverse=False) 接受一个可迭代对象作为参数，返回一个有序的列表;可选参数func,key 和reverse 的含义跟list.sort()内建函数的参数含义一样.

注意：

sorted等需要在原处修改的函数无法用在字符串对象，但可以产生新的对象

sum处理的对象是数字，不能用在字符串

sorted(s)

['a', 'e', 'e', 'g', 'g', 'g', 'o']

(四)只适合于字符串类型的函数

1)raw_input()函数

内建的raw_input()函数使用给定字符串提示用户输入并将这个输入返回，下面是一个使

用raw_input()的例子:

user_input = raw_input("Enter your name: ")

prin user_input

2)str() and unicode()

str()和unicode()函数都是工厂函数，就是说产生所对应的类型的对象.它们接受一个任

意类型的对象，然后创建该对象的可打印的或者Unicode 的字符串表示. 它们和basestring 都

可以作为参数传给isinstance()函数来判断一个对象的类型

3)chr(), unichr(), and ord()

chr()函数用一个范围在range(256)内的(就是0 到255)整数做参数,返回一个对应的字符.unichr()跟它一样，只不过返回的是Unicode 字符

ord()函数是chr()函数(对于8 位的ASCII 字符串)或unichr()函数(对于Unicode 对象)

的配对函数,它以一个字符(长度为1 的字符串)作为参数,返回对应的ASCII 数值，或者Unicode

数值，如果所给的Unicode 字符超出了你的Python 定义范围,则会引发一个TypeError 的异常

(五)、只适用于字符串的操作符

1、格式化操作符 %

字符串格式化符号

格式化字符 转换方式

%c 转换成字符(ASCII 码值，或者长度为一的字符串)

%ra 优先用repr()函数进行字符串转换

%s 优先用str()函数进行字符串转换

%d / %i 转成有符号十进制数

%ub 转成无符号十进制数

%ob 转成无符号八进制数

%xb/%Xb (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大

小写)

%e/%E 转成科学计数法(e/E 控制输出e/E)

%f/%F 转成浮点数(小数部分自然截断)

%g/%G %e 和%f/%E 和%F 的简写

%% 输出%

格式化操作符辅助指令

符号 作用

* 定义宽度或者小数点精度

- 用做左对齐

+ 在正数前面显示加号( + )

sp 在正数前面显示空格

# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于

用的是'x'还是'X')

0 显示的数字前面填充‘0’而不是默认的空格

% '%%'输出一个单一的'%'

(var) 映射变量(字典参数)

m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

2、字符串模板: 更简单的替代品

由于新式的字符串Template 对象的引进使得string 模块又重新活了过来，Template 对象

有两个方法,substitute()和safe_substitute().前者更为严谨,在key 缺少的情况下它会报一

个KeyError 的异常出来，而后者在缺少key 时，直接原封不动的把字符串显示出

3、原始字符串操作符( r/R )

字符串抑制转义r'带特殊符号的字串'

myfile=open(r'C:\new\text.data','w')

4、Unicode 字符串操作符( u/U )

u'abc' U+0061 U+0062 U+0063

u'\u1234' U+1234

u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012

(六)字符串对象的方法：

1、删减

T2.lstrip() 移除字符串前面字符（默认空格），返回字符串

T2.rstrip() 移除字符串后面字符（默认空格），返回字符串

T2.strip() 移除字符串前后面空格，返回字符串 默认空格，可以其他字符 S.strip('"')

2、切割

partition(sep),

rpartition(sep),

splitlines([keepends]),#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符

split([sep [,maxsplit]]),#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符

rsplit([sep[,maxsplit]]) #从右到左切割

备注：

partition()函数族是2.5版本新增的方法。它接受一个字符串参数，并返回一个3个元素的 tuple 对象。

如果sep没出现在母串中，返回值是 (sep, ‘’, ‘’)；

否则，返回值的第一个元素是 sep 左端的部分，第二个元素是 sep 自身，第三个元素是 sep 右端的部分。

S.partition(';')

('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')

参数 maxsplit 是分切的次数，即最大的分切次数，所以返回值最多有 maxsplit+1 个元素。

s.split() 和 s.split(‘ ‘)的返回值不尽相同

' hello world!'.split()

['hello', 'world!']

' hello world!'.split(' ')

['', '', 'hello', '', '', 'world!']

S.split('\n',3)

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']

超过最大切割个数后面的全部为一个元素

按行切割

S

'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'

S.splitlines()

['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']

产生差异的原因在于当忽略 sep 参数或sep参数为 None 时与明确给 sep 赋予字符串值时 split() 采用两种不同的算法。

对于前者，split() 先去除字符串两端的空白符，然后以任意长度的空白符串作为界定符分切字符串

即连续的空白符串被当作单一的空白符看待；

对于后者则认为两个连续的 sep 之间存在一个空字符串。因此对于空字符串（或空白符串），它们的返回值也是不同的：

''.split()

[]

''.split(' ')

['']

3、变形

lower(),#全部小写

upper(),#全部小写

capitalize(),#首字母大写

swapcase(),#大小写交换

title()#每个单词第一个大写,其他小写

备注

因为title() 函数并不去除字符串两端的空白符也不会把连续的空白符替换为一个空格，

所以建议使用string 模块中的capwords(s)函数，它能够去除两端的空白符，再将连续的空白符用一个空格代替。

Python Code

1

2

3

4

' hello world!'.title()

' Hello World!'

string.capwords(' hello world!')

'Hello World!'

4、连接

join(seq)

join() 函数的高效率（相对于循环相加而言），使它成为最值得关注的字符串方法之一。

它的功用是将可迭代的字符串序列连接成一条长字符串，如：

conf = {'host':'127.0.0.1',

... 'db':'spam',

... 'user':'sa',

... 'passwd':'eggs'}

';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())

'passswd=eggs;db=spam;user=sa;host=127.0.0.1'

S=''.join(T) #使用空字符串分割把字符列表转换为字符串

5、查找

count( sub[, start[, end]]),#计算substr在S中出现的次数

find( sub[, start[, end]]),#返回S中出现sub的第一个字母的标号，如果S中没有sub则返回-1。start和end作用就相当于在S[start:end]中搜索

index( substr[, start[, end]]),#与find()相同，只是在S中没有substr时，会返回一个运行时错误

rfind( sub[, start[,end]]),#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号

rindex( sub[, start[, end]])

T2.find('ie') 字符串方法调用：搜索

find()----找到的第一个符合字符的index

rfind()-----找到最后一个符合的字符的index

备注：

find()函数族找不到时返回-1，index()函数族则抛出ValueError异常。

另，也可以用 in 和 not in 操作符来判断字符串中是否存在某个模板

6、替换

replace(old, new[,count]),#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换

translate(table[,deletechars]) #使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉

备注：

replace()函数的 count 参数用以指定最大替换次数

translate() 的参数 table 可以由 string.maketrans(frm, to) 生成

translate() 对 unicode 对象的支持并不完备，建议不要使用

7、判定

isalnum(),#是否全是字母和数字，并至少有一个字符

isalpha(),是否全是字母，并至少有一个字符

isdigit(),是否全是数字，并至少有一个字符 ，如果是全数字返回True,否则返回False

islower(),#S中的字母是否全是小写

isupper(),#S中的字母是否是大写

isspace(),#是否全是空白字符，并至少有一个字符

istitle(),S是否是首字母大写的

startswith(prefix[, start[, end]]), #是否以prefix开头

endswith(suffix[,start[, end]]),#以suffix结尾

备注：

这些函数都比较简单，顾名知义。需要注意的是*with()函数族可以接受可选的 start, end 参数，善加利用，可以优化性能。

另，自 Py2.5 版本起，*with() 函数族的 prefix 参数可以接受 tuple 类型的实参，当实参中的某人元素能够匹配，即返回 True。

8、填充

字符串在输出时的对齐：

center(width[, fillchar]), 字符串中间对齐

ljust(width[, fillchar]), 字符串左对齐，不足部分用fillchar填充，默认的为空格

rjust(width[, fillchar]), 字符串右对齐，不足部分用fillchar填充，默认的为空格

zfill(width), 把字符串变成width长，并在右对齐，不足部分用0补足

expandtabs([tabsize])把字符串中的制表符（tab）转换为适当数量的空格。

fillchar 参数指定了用以填充的字符，默认为空格

zfill的z为zero的缩写,顾名思义,是以字符0进行填充，用于数值输出

expandtabs()的tabsize 参数默认为8。它的功能是把字符串中的制表符（tab）转换为适当数量的空格。

9、编码

encode([encoding[,errors]]),

decode([encoding[,errors]])

这是一对互逆操作的方法，用以编码和解码字符串。因为str是平台相关的，它使用的内码依赖于操作系统环境，

而unicode是平台无关的，是Python内部的字符串存储

相关问答

Q1: python、什么是内建函数

python内建函数总结

1. abs(x)

abs()函数返回数字（可为普通型、长整型或浮点型）的绝对值。如果给出复数，返回值就是该复数的模。例如：

print abs(-2,4)

2.4

print abs(4+2j)

4.472135955

2. apply(function,args[,keywords])

apply()函数将args参数应用到function上。function参数必须是可调用对象（函数、方法或其他可调用对象）。args参数必须以

序列形式给出。列表在应用之前被转换为元组。function对象在被调用时，将args列表的内容分别作为独立的参数看待。例如：

apply(add,(1,3,4))

等价于

add(1,3,4)

在以列表或元组定义了一列参数，且需要将此列表参数分别作为个个独立参数使用的情况下，必须使用apply()函数。在要把变长参数列应用到已函数上时，apply()函数非常有用。

可选项keywords参数应是个字典，字典的关键字是字符串。这些字符串在apply()函数的参数列末尾处给出，它们将被用作关键字参数。

3. buffer(object[,offset[,size]])

如果object对象支持缓存调用接口buffer()函数就为object对象创建一个新缓存。这样的对象包括字符串、数组和缓存。该新缓存通过使用从

offset参数值开始知道该对象末尾的存储片段或从offset参数值开始直到size参数给出的尺寸为长度的存储片段来引用object对象。如果没

给出任何选项参数，缓存区域就覆盖整个序列，最终得到的缓存对象是object对象数据的只读拷贝。

缓存对象用于给某个对象类型创建一个更友好的接口。比如，字符串对象类型通用缓存对象而变得可用，允许逐个字节地访问字符串中的信息。

4. callable(object)

callable()函数在object对象是可调用对象的情况下，返回真(true)；否则假(false)，可调用对象包括函数、方法、代码对象、类（在调用时返回新的实例）和已经定义‘调用’方法的类实例

5. chr(i)

chr()函数返回与ASCII码i相匹配的一个单一字符串，如下例所示：

print chr(72)+chr(101)+chr(108)+chr(111)

hello

chr()函数是ord()函数的反函数，其中ord()函数将字符串转换回ASCII整数码，参数i的取值应在0~255范围内。如果参数i的取值在此范围之外，将引发ValueError异常。

6. cmp(x,y)

cmp()函数比较x和y这两个对象，且根据比较结果返回一个整数。如果xy，则返回正数。请注意，此函数特别用来比较数值大小，而不是任何引用关系，因而有下面的结果：

a=99

b=int('99')

cmp(a,b)

7. coerce(x,y)

coerce()函数返回一个元组，该元组由两个数值型参数组成。此函数将两个数值型参数转换为同一类型数字，其转换规则与算术转换规则一样。一下是两个例子：

a=1

b=1.2

coerce(a,b)

(1.0,1.2)

a=1+2j

b=4.3e10

coerce(a,b)

((1+2j),(43000000000+0j))

8 compile(string,filename,kind)

compile()函数将string编译为代码对象，编译生成的代码对象接下来被exec语句执行，接着能利用eval()函数对其进行求值。

filename参数应是代码从其中读出的文件名。如果内部生成文件名，filename参数值应是相应的标识符。kind参数指定string参数中所含代码的类别。

举例如下：

a=compile(‘print “Hello World”’,’’,’single’)

exec(a)

Hello World

eval(a)

Hello World

9. complex(real,[image])

Complex()函数返回一个复数，其实部为real参数值。如果给出image参数的值，则虚部就为image；如果默认image参数，则虚部为0j。

10. delattr(object,name)

delattr()函数在object对象许可时，删除object对象的name属性，此函数等价于如下语句：

del object.attr

而delattr()函数允许利用编程方法定义来定义object和name参数，并不是在代码中显示指定。

Q2: python3--内置函数

python的常用内置函数

1.abs() 函数返回数字的绝对值

abs(-40)=40

2. dict() 函数用于创建一个字典

dict()

{}      #创建一个空字典类似于u={},字典的存取方式一般为key-value

例如u = {"username":"tom",  "age":18}

3. help() 函数用于查看函数或模块用途的详细说明

help('math')查看math模块的用处

a=[1,2,3,4]

help(a)查看列表list帮助信息

4.dir()获得当前模块的属性列表

dir(help)

['__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

5.min() 方法返回给定参数的最小值 /参数可以为序列

a=  min(10,20,30,40)

a

10

6. next() 返回迭代器的下一个项目

it = iter([1, 2, 3, 4, 5])

next(it)

1

next(it)

2

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

a=12

id(a)

1550569552

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

a=["tom","marry","leblan"]

list(enumerate(a))

[(0, 'tom'), (1, 'marry'), (2, 'leblan')]

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

oct(15)

'0o17'

oct(10)

'0o12'

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

bin(10)

'0b1010'

bin(15)

'0b1111'

11.eval() 函数用来执行一个字符串表达式，并返回表达式的值

eval('2+2')

4

12.int() 函数用于将一个字符串会数字转换为整型

int(3)

3

int(3.6)

3

int(3.9)

3

int(4.0)

4

13.open() 函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写

f=open('test.txt')

14.str() 函数将对象转化为适于人阅读的形式

str(3)

'3'

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

bool()

False

bool(1)

True

bool(10)

True

bool(10.0)

True

16.isinstance() 函数来判断一个对象是否是一个已知的类型

a=5

isinstance(a,int)

True

isinstance(a,str)

False

17. sum() 方法对系列进行求和计算

sum([1,2,3],5)

11

sum([1,2,3])

6

18. super() 函数用于调用下一个父类(超类)并返回该父类实例的方法。super 是用来解决多重继承问题的，直接用类名调用父类方法

class   User(object):

      def__init__(self):

class Persons(User):

            super(Persons,self).__init__()

19. float() 函数用于将整数和字符串转换成浮点数

float(1)

1.0

float(10)

10.0

20. iter() 函数用来生成迭代器

a=[1,2,3,4,5,6]

iter(a)

for i in iter(a):

...         print(i)

...

1

2

3

4

5

6

21.tuple 函数将列表转换为元组

a=[1,2,3,4,5,6]

tuple(a)

(1, 2, 3, 4, 5, 6)

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

s = "playbasketball"

len(s)

14

a=[1,2,3,4,5,6]

len(a)

6

23. property() 函数的作用是在新式类中返回属性值

class User(object):

     def __init__(self,name):

              self.name = name

    def get_name(self):

              return self.get_name

    @property

     def name(self):

             return self_name

24.type() 函数返回对象的类型

25.list() 方法用于将元组转换为列表

b=(1,2,3,4,5,6)

list(b)

[1, 2, 3, 4, 5, 6]

26.range() 函数可创建一个整数列表，一般用在 for 循环中

range(10)

range(0, 10)

range(10,20)

range(10, 20)

27. getattr() 函数用于返回一个对象属性值

class w(object):

...             s=5

...

a = w()

getattr(a,'s')

5

28. complex() 函数用于创建一个复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

complex(1,2)

(1+2j)

complex(1)

(1+0j)

complex("1")

(1+0j)

29.max() 方法返回给定参数的最大值，参数可以为序列

b=(1,2,3,4,5,6)

max(b)

6

30. round() 方法返回浮点数x的四舍五入值

round(10.56)

11

round(10.45)

10

round(10.45,1)

10.4

round(10.56,1)

10.6

round(10.565,2)

10.56

31. delattr 函数用于删除属性

class Num(object):

...    a=1

...    b=2

...    c=3.

.. print1 = Num()

print('a=',print1.a)

a= 1

print('b=',print1.b)

b= 2

print('c=',print1.c)

c= 3

delattr(Num,'b')

print('b=',print1.b)

Traceback (most recent call last):  File "", line 1, inAttributeError: 'Num' object has no attribute 'b'

32. hash() 用于获取取一个对象（字符串或者数值等）的哈希值

hash(2)

2

hash("tom")

-1675102375494872622

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

a= set("tom")

b = set("marrt")

a,b

({'t', 'm', 'o'}, {'m', 't', 'a', 'r'})

ab#交集

{'t', 'm'}

a|b#并集

{'t', 'm', 'r', 'o', 'a'}

a-b#差集

{'o'}

Q3: python 8个常用内置函数解说

8个超好用内置函数set（），eval（），sorted（），reversed（），map（），reduce（），filter（），enumerate（）

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候，set()函数就派上用场了。

用于创建一个集合，集合里的元素是无序且不重复的。集合对象创建后，还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器，输入字符串公式，直接产生结果。用eval()来做就很简单：eval(str_expression)作用是将字符串转换成表达式，并且执行。

3、sorted()在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ，它可以对任何可迭代对象进行排序，并返回列表。对列表升序操作：

对元组倒序操作：

使用参数：key，根据自定义规则，按字符串长度来排序：

根据自定义规则，对元组构成的列表进行排序：

4、reversed()如果需要对序列的元素进行反转操作，reversed()函数能帮到你。reversed()接受一个序列，将序列里的元素反转，并最终返回迭代器。

5、map()做文本处理的时候，假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数，对指定的序列做映射，最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列。举个例子，对列表里的每个数字作平方处理：

6、reduce()前面说到对列表里的每个数字作平方处理，用map()函数。那我想将列表里的每个元素相乘，该怎么做呢？这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果。再举个例子，将字母连接成字符串。

你可能已经注意到，reduce()函数在python3里已经不再是内置函数，而是迁移到了functools模块中。这里把reduce()函数拎出来讲，是因为它太重要了。

7、filter()一些数字组成的列表，要把其中偶数去掉，该怎么做呢？

filter()函数轻松完成了任务，它用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。filter()函数和map()、reduce()函数类似，都是将序列里的每个元素映射到函数，最终返回结果。我们再试试，如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景，同时打印出序列里每一个元素和它对应的顺序号，我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思，所以说enumerate()函数用于对序列里的元素进行顺序标注，返回(元素、索引)组成的迭代器。再举个例子说明，对字符串进行标注，返回每个字母和其索引。

Q4: python中的变量与垃圾回收

python中的变量和java中的变量本质是不一样的，python中的变量实质上是一个指针（指针的大小固定的）

is可以用来判断id是否相等

对于这种赋值，虽然所赋值是相同的，但是他们的id不同，即他们是不同的对象，a is b 即为false ,但是有个特例： a = 1 b = 1 时他们的id相同。其实这是python内部的优化机制，对于小整数和小的字符串来说，python在前边定义一个对象时，下次在遇到时会直接调用前边生成的对象，而不会去重新申请一个。

他们的对象内存地址不一样，但是，a和b里的值是相等的，这是由于a和b都为list,而list里有内置的魔法函数 eq 通过 eq 魔法函数可以判断里边两个的值是否相同，若相同则返回True

python中垃圾回收的算法回收的算法是采用引用计数，当程序中有一个变量引用该python对象时，python会自动保证该对象引用计数为1；当程序中有两个变量引用该python对象时，python会自动保证该对象计数器为2， 以此类推，当一个对象的引用计数器变为0 时，则说明程序中不再有变量对其进行引用，因此python就会回收该对象。

大多数情况，python的ARC都能准确，高效的回收系统中的每一个对象。但如果系统中出现循环引用时，比如a对象持有一个实例变量引用对象b，而b对象又持有一个实例变量引用对象a，此时 两个对象的计数器都为1， 而实际上python不再需要这两个对象，也没有程序在引用他们，系统回收他们时python的垃圾回收器就没有那儿快，要等到专门的循环垃圾回收器（Cyclic Garbage Collector）来检测并回收这种引用循环

当一个对象被垃圾回收式，python就会自动调用该对象的 del 方法

当没有注释掉x = im时， item对象被两个变量所引用，所以在执行完del im时并不会去回收item对象，所以先输出--------，当程序完全执行完成后，引用item的对象的变量被释放，然后系统便会执行 del 方法，回收item对象。

当 x = im被注释后，只有一个变量去引用item对象，所以在执行完后程序变回去调用 del 方法，回收item对象，然后在继续向下执行 输出-----