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

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

创新互联公司是一家成都网站设计、成都做网站、外贸网站建设，提供网页设计，网站设计，网站制作，建网站，按需搭建网站，网站开发公司，从2013年创立是互联行业建设者，服务者。以提升客户品牌价值为核心业务，全程参与项目的网站策划设计制作，前端开发，后台程序制作以及后期项目运营并提出专业建议和思路。

表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内部的字符串存储

python基础数据结构：序列、映射、集合

参考资料：

Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。

一、序列（列表、元组和字符串）

序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。

1、列表

列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

（1）、创建

通过下面的方式即可创建一个列表：

输出：

['hello', 'world']

[1, 2, 3]

可以看到，这中创建方式非常类似于javascript中的数组。

（2）、list函数

通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效：

输出：

['h', 'e', 'l', 'l', 'o']

2、元组

元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。

（1） 、创建

输出：

(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)

从上面我们可以分析得出：

a、逗号分隔一些值，元组自动创建完成；

b、元组大部分时候是通过圆括号括起来的；

c、空元组可以用没有包含内容的圆括号来表示；

d、只含一个值的元组，必须加个逗号（,）；

（2）、tuple函数

tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组。如果参数就算元组，那么该参数就会原样返回：

输出：

(1, 2, 3)

('j', 'e', 'f', 'f')

(1, 2, 3)

Traceback (most recent call last):

File "F:\Python\test.py", line 7, in

t4=tuple(123)

TypeError: 'int' object is not iterable

3、字符串

（1）创建

输出：

Hello world

H

H

e

l

l

o

w

o

r

l

d

（2）、格式化

format（）：

print(‘{0} was {1} years old when he wrote this book’. format(name,age) )

print(‘{} was {} years old when he wrote this book’. format(name,age) )

print(‘{name} was {age} years old when he wrote this book’. format(name=’Lily’,age=’22’) )

#对于浮点数“0.333”保留小数点后三位

print(‘{0 : .3f}’.format(1.0/3) )

结果：0.333

#使用下划线填充文本，并保持文字处于中间位置

#使用^定义‘_____hello_____’字符串长度为11

print(‘{0 : ^_11}’.format(‘hello’) )

结果：_____hello_____

% :

格式化操作符的右操作数可以是任何东西，如果是元组或者映射类型（如字典），那么字符串格式化将会有所不同。

输出：

Hello,world

Hello,World

注意：如果需要转换的元组作为转换表达式的一部分存在，那么必须将它用圆括号括起来：

输出：

Traceback (most recent call last):

File "F:\Python\test.py", line 2, in

str1='%s,%s' % 'Hello','world'

TypeError: not enough arguments for format string

如果需要输出%这个特殊字符，毫无疑问，我们会想到转义，但是Python中正确的处理方式如下：

输出：100%

对数字进行格式化处理，通常需要控制输出的宽度和精度：

输出：

3.14

3.141593

3.14

字符串格式化还包含很多其他丰富的转换类型，可参考官方文档。

4、通用序列操作（方法）

从列表、元组以及字符串可以“抽象”出序列的一些公共通用方法（不是你想像中的CRUD），这些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员。除此之外，还有计算序列长度、最大最小元素等内置函数。

（1）索引

输出

H

2

345

索引从0（从左向右）开始，所有序列可通过这种方式进行索引。神奇的是，索引可以从最后一个位置（从右向左）开始，编号是-1：

输出：

o

3

123

（2）分片

分片操作用来访问一定范围内的元素。分片通过冒号相隔的两个索引来实现：

输出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[1, 2, 3, 4]

[6, 7, 8, 9]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[7, 8]

[7, 8, 9]

不同的步长，有不同的输出：

输出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 2, 4, 6, 8]

[0, 3, 6, 9]

[]

（3）序列相加

输出：

Hello world

[1, 2, 3, 2, 3, 4]

Traceback (most recent call last):

File "F:\Python\test.py", line 7, in

print str1+num1

TypeError: cannot concatenate 'str' and 'list' objects

（4）乘法

输出：

[None, None, None, None, None, None, None, None, None, None]

HelloHello

[1, 2, 1, 2]

Traceback (most recent call last):

File "F:\Python\test.py", line 5, in

print str1*num1

TypeError: can't multiply sequence by non-int of type 'list'

（5）成员资格

in运算符会用来检查一个对象是否为某个序列（或者其他类型）的成员（即元素）：

输出：

False

True

True

（6）长度、最大最小值

通过内建函数len、max和min可以返回序列中所包含元素的数量、最大和最小元素。

输出：

5

o

H

5

123

1

二、映射（字典）

映射中的每个元素都有一个名字，如你所知，这个名字专业的名称叫键。字典（也叫散列表）是Python中唯一内建的映射类型。

1、键类型

字典的键可以是数字、字符串或者是元组，键必须唯一。在Python中，数字、字符串和元组都被设计成不可变类型，而常见的列表以及集合（set）都是可变的，所以列表和集合不能作为字典的键。键可以为任何不可变类型，这正是Python中的字典最强大的地方。

输出：

{1: 1}

Traceback (most recent call last):

File "F:\Python\test.py", line 6, in

d[list1]="Hello world."

TypeError: unhashable type: 'list'

2、自动添加

即使键在字典中并不存在，也可以为它分配一个值，这样字典就会建立新的项。

3、成员资格

表达式item in d（d为字典）查找的是键（containskey），而不是值（containsvalue）。

三、集合

集合（Set）在Python 2.3引入，通常使用较新版Python可直接创建，如下所示：

strs=set(['jeff','wong','cnblogs'])

nums=set(range(10))

看上去，集合就是由序列（或者其他可迭代的对象）构建的。集合的几个重要特点和方法如下：

1、副本是被忽略的

集合主要用于检查成员资格，因此副本是被忽略的，如下示例所示,输出的集合内容是一样的。

输出如下：

set([0, 1, 2, 3, 4, 5])

set([0, 1, 2, 3, 4, 5])

2、集合元素的顺序是随意的

这一点和字典非常像，可以简单理解集合为没有value的字典。

输出如下：

set(['wong', 'cnblogs', 'jeff'])

3、集合常用方法

a、并集union

输出：

set([1, 2, 3])

set([2, 3, 4])

set([1, 2, 3, 4])

union操作返回两个集合的并集，不改变原有集合。使用按位与（OR）运算符“|”可以得到一样的结果：

输出和上面union操作一模一样的结果。

其他常见操作包括（交集）,=,=,-,copy()等等，这里不再列举。

输出如下：

set([1, 2, 3])

set([2, 3, 4])

set([2, 3])

True

set([1, 2, 3])

False

b、add和remove

和序列添加和移除的方法非常类似，可参考官方文档：

输出：

set([1])

set([1, 2])

set([1])

set([1])

False

Traceback (most recent call last):

File "F:\Python\test.py", line 9, in

set1.remove(29) #移除不存在的项

KeyError: 29

4、frozenset

集合是可变的，所以不能用做字典的键。集合本身只能包含不可变值，所以也就不能包含其他集合：

输出如下：

Traceback (most recent call last):

File "F:\Python\test.py", line 3, in

set1.add(set2)

TypeError: unhashable type: 'set'

可以使用frozenset类型用于代表不可变（可散列）的集合：

输出：

set([1, frozenset([2])])

Python中字典的内建函数用法是什么？

点击上方 "Python人工智能技术" 关注，星标或者置顶

22点24分准时推送，第一时间送达

后台回复“大礼包”，送你特别福利

编辑：乐乐 | 来自：pypypypy

上一篇：

正文

大家好，我是Pythn人工智能技术。

内置函数就是Python给你提供的，拿来直接用的函数，比如print.，input等。

截止到python版本3.6.2 ，python一共提供了68个内置函数，具体如下

abs() dict() help() min() setattr()

all() dir() hex() next() slice()

any() divmod() id() object() sorted()

ascii() enumerate() input() oct() staticmethod()

bin() eval() int() open() str()

bool() exec() isinstance() ord() sum()

bytearray() filter() issubclass() pow() super()

bytes() float() iter() print() tuple()

callable() format() len() property() type()

chr() frozenset() list() range() vars()

classmethod() getattr() locals() repr() zip()

compile() globals() map() reversed() __import__()

complex() hasattr() max() round()

delattr() hash() memoryview() set()

本文将这68个内置函数综合整理为12大类，正在学习Python基础的读者一定不要错过，建议收藏学习！

和数字相关 1. 数据类型

bool : 布尔型(True,False)

int : 整型(整数)

float : 浮点型(小数)

complex : 复数

2. 进制转换

bin() 将给的参数转换成二进制

otc() 将给的参数转换成八进制

hex() 将给的参数转换成十六进制

print(bin(10)) # 二进制:0b1010

print(hex(10)) # 十六进制:0xa

print(oct(10)) # 八进制:0o12

3. 数学运算

abs() 返回绝对值

divmode() 返回商和余数

round() 四舍五入

pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余

sum() 求和

min() 求最小值

max() 求最大值

print(abs(-2)) # 绝对值:2

print(divmod(20,3)) # 求商和余数:(6,2)

print(round(4.50)) # 五舍六入:4

print(round(4.51)) #5

print(pow(10,2,3)) # 如果给了第三个参数. 表示最后取余:1

print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55

print(min(5,3,9,12,7,2)) #求最小值:2

print(max(7,3,15,9,4,13)) #求最大值:15

和数据结构相关 1. 序列

（1）列表和元组

list() 将一个可迭代对象转换成列表

tuple() 将一个可迭代对象转换成元组

print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]

print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)

（2）相关内置函数

reversed() 将一个序列翻转, 返回翻转序列的迭代器

slice() 列表的切片

lst = "你好啊"

it = reversed(lst) # 不会改变原列表. 返回一个迭代器, 设计上的一个规则

print(list(it)) #['啊', '好', '你']

lst = [1, 2, 3, 4, 5, 6, 7]

print(lst[1:3:1]) #[2,3]

s = slice(1, 3, 1) # 切片用的

print(lst[s]) #[2,3]

（3）字符串

str() 将数据转化成字符串

print(str(123)+'456') #123456

format() 与具体数据相关, 用于计算各种小数, 精算等.

s = "hello world!"

print(format(s, "^20")) #剧中

print(format(s, "20")) #左对齐

print(format(s, "20")) #右对齐

# hello world!

# hello world!

# hello world!

print(format(3, 'b' )) # 二进制:11

print(format(97, 'c' )) # 转换成unicode字符:a

print(format(11, 'd' )) # ⼗进制:11

print(format(11, 'o' )) # 八进制:13

print(format(11, 'x' )) # 十六进制(⼩写字母):b

print(format(11, 'X' )) # 十六进制(大写字母):B

print(format(11, 'n' )) # 和d⼀样:11

print(format(11)) # 和d⼀样:11

print(format(123456789, 'e' )) # 科学计数法. 默认保留6位小数:1.234568e+08

print(format(123456789, '0.2e' )) # 科学计数法. 保留2位小数(小写):1.23e+08

print(format(123456789, '0.2E' )) # 科学计数法. 保留2位小数(大写):1.23E+08

print(format(1.23456789, 'f' )) # 小数点计数法. 保留6位小数:1.234568

print(format(1.23456789, '0.2f' )) # 小数点计数法. 保留2位小数:1.23

print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900

print(format(1.23456789e+3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890

bytes() 把字符串转化成bytes类型

bs = bytes("今天吃饭了吗", encoding="utf-8")

print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'

bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)

ret = bytearray("alex" ,encoding ='utf-8')

print(ret[0]) #97

print(ret) #bytearray(b'alex')

ret[0] = 65 #把65的位置A赋值给ret[0]

print(str(ret)) #bytearray(b'Alex')

ord() 输入字符找带字符编码的位置

chr() 输入位置数字找出对应的字符

ascii() 是ascii码中的返回该值 不是就返回u

print(ord('a')) # 字母a在编码表中的码位:97

print(ord('中')) # '中'字在编码表中的位置:20013

print(chr(65)) # 已知码位,求字符是什么:A

print(chr(19999)) #丢

for i in range(65536): #打印出0到65535的字符

print(chr(i), end=" ")

print(ascii("@")) #'@'

repr() 返回一个对象的string形式

s = "今天\n吃了%s顿\t饭" % 3

print(s)#今天# 吃了3顿 饭

print(repr(s)) # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%

#'今天\n吃了3顿\t饭'

2. 数据集合

字典：dict 创建一个字典

集合：set 创建一个集合

frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

3. 相关内置函数

len() 返回一个对象中的元素的个数

sorted() 对可迭代对象进行排序操作 (lamda)

语法：sorted(Iterable, key=函数(排序规则), reverse=False)

Iterable: 可迭代对象

key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序

reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [5,7,6,12,1,13,9,18,5]

lst.sort() # sort是list里面的一个方法

print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]

ll = sorted(lst) # 内置函数. 返回给你一个新列表 新列表是被排序的

print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]

l2 = sorted(lst,reverse=True) #倒序

print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]

#根据字符串长度给列表排序

lst = ['one', 'two', 'three', 'four', 'five', 'six']

def f(s):

return len(s)

l1 = sorted(lst, key=f, )

print(l1) #['one', 'two', 'six', 'four', 'five', 'three']

enumerate() 获取集合的枚举对象

lst = ['one','two','three','four','five']

for index, el in enumerate(lst,1): # 把索引和元素一起获取,索引默认从0开始. 可以更改

print(index)

print(el)

# 1

# one

# 2

# two

# 3

# three

# 4

# four

# 5

# five

all() 可迭代对象中全部是True, 结果才是True

any() 可迭代对象中有一个是True, 结果就是True

print(all([1,'hello',True,9])) #True

print(any([0,0,0,False,1,'good'])) #True

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

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

lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']

lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']

print(zip(lst1, lst1, lst3)) #

for el in zip(lst1, lst2, lst3):

print(el)

# (1, '醉乡民谣', '美国')

# (2, '驴得水', '中国')

# (3, '放牛班的春天', '法国')

# (4, '美丽人生', '意大利')

# (5, '辩护人', '韩国')

# (6, '被嫌弃的松子的一生', '日本')

fiter() 过滤 (lamda)

语法：fiter(function. Iterable)

function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

搜索公众号顶级架构师后台回复“面试”，送你一份惊喜礼包。

def func(i): # 判断奇数

return i % 2 == 1

lst = [1,2,3,4,5,6,7,8,9]

l1 = filter(func, lst) #l1是迭代器

print(l1) #

print(list(l1)) #[1, 3, 5, 7, 9]

map() 会根据提供的函数对指定序列列做映射(lamda)

语法 : map(function, iterable)

可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

def f(i): return i

lst = [1,2,3,4,5,6,7,]

it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]

和作用域相关

locals() 返回当前作用域中的名字

globals() 返回全局作用域中的名字

def func():

a = 10

print(locals()) # 当前作用域中的内容

print(globals()) # 全局作用域中的内容

print("今天内容很多")

func()

# {'a': 10}

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':

# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,

# '__spec__': None, '__annotations__': {}, '__builtins__':

# (built-in), '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,

# 'func': }

# 今天内容很多

和迭代器生成器相关

range() 生成数据

next() 迭代器向下执行一次, 内部实际使⽤用了__ next__()⽅方法返回迭代器的下一个项目

iter() 获取迭代器, 内部实际使用的是__ iter__()⽅方法来获取迭代器

for i in range(15,-1,-5):

print(i)

# 15

# 10

# 5

# 0

lst = [1,2,3,4,5]

it = iter(lst) # __iter__()获得迭代器

print(it.__next__()) #1

print(next(it)) #2 __next__()

print(next(it)) #3

print(next(it)) #4

字符串类型代码的执行

eval() 执行字符串类型的代码. 并返回最终结果

exec() 执行字符串类型的代码

compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值

s1 = input("请输入a+b:") #输入:8+9

print(eval(s1)) # 17 可以动态的执行代码. 代码必须有返回值

s2 = "for i in range(5): print(i)"

a = exec(s2) # exec 执行代码不返回任何内容

# 0

# 1

# 2

# 3

# 4

print(a) #None

# 动态执行代码

exec("""

def func():

print(" 我是周杰伦")

""" )

func() #我是周杰伦

code1 = "for i in range(3): print(i)"

com = compile(code1, "", mode="exec") # compile并不会执行你的代码.只是编译

exec(com) # 执行编译的结果

# 0

# 1

# 2

code2 = "5+6+7"

com2 = compile(code2, "", mode="eval")

print(eval(com2)) # 18

code3 = "name = input('请输入你的名字:')" #输入:hello

com3 = compile(code3, "", mode="single")

exec(com3)

print(name) #hello

输入输出

print() : 打印输出

input() : 获取用户输出的内容

print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾

#hello*world@

内存相关

hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存

s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #报错,列表是不可哈希的 id() : 获取到对象的内存地址s = 'alex'print(id(s)) #2278345368944

文件操作相关

open() : 用于打开一个文件, 创建一个文件句柄

f = open('file',mode='r',encoding='utf-8')

f.read()

f.close()

模块相关

__ import__() : 用于动态加载类和函数

# 让用户输入一个要导入的模块

import os

name = input("请输入你要导入的模块:")

__import__(name) # 可以动态导入模块

帮 助

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

print(help(str)) #查看字符串的用途

调用相关

callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

a = 10

print(callable(a)) #False 变量a不能被调用

def f():

print("hello")

print(callable(f)) # True 函数是可以被调用的

查看内置属性

dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法

print(dir(tuple)) #查看元组的方法

你还有什么想要补充的吗？

免责声明：本文内容来源于网络，文章版权归原作者所有，意在传播相关技术知识行业趋势，供大家学习交流，若涉及作品版权问题，请联系删除或授权事宜。

技术君个人微信

添加技术君个人微信即送一份惊喜大礼包

→ 技术资料共享

→ 技术交流社群

--END--

往日热文：

Python程序员深度学习的“四大名著”：

这四本书着实很不错！我们都知道现在机器学习、深度学习的资料太多了，面对海量资源，往往陷入到“无从下手”的困惑出境。而且并非所有的书籍都是优质资源，浪费大量的时间是得不偿失的。给大家推荐这几本好书并做简单介绍。

获得方式：

2.后台回复关键词：名著

Python 通用的序列操作

序列 （sequence）是Python最基本的一种数据结构。

序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。Python的序列索引支持负数，-1表示序列的最后一个元素，这是Python不同其他很多种语言不同的地方。

Python内置了多种序列，列表、元组、字符串是其中最常用的三种，本文为你描述各种序列的通用操作。

索引从0开始，索引号为0的元素为1，greeting的索引号为0的元素为'H'。

你可能注意到'Hello'和'H'都用单引号包围，这是Python不同于其他语言的另一个地方。Python并没有专门用于表示字符的数据类型，因此一个字符就是一个只包含一个元素的字符串。

Python的序列索引支持负数，-1表示倒数第一个元素。

切片 （slicing）操作用于访问序列特定 范围 内的元素。在一对方括号内使用两个索引，并用冒号隔开：

注意到，返回的序列并未包含愿序列的第6个元素7，就相当于数学集合中的 左闭右开区间 操作。

换言之，你提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。

保留冒号，省略第一个索引，表示从序列起始位置开始切片；省略第二个索引，表示切片到序列末尾，包含最后一个元素：

这个操作的效果是：在指定的区间内间隔取元素，语法格式为：

例如：

步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点。

可以使用加法运算（+运算符）拼接两个序列：

从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。

将序列与数x 相乘时，将重复这个序列x 次来创建一个新序列：

初始化一个长度为10的空列表：

成员资格检查判定一个元素是否存在于集合中，如存在返回True，否则返回False，实际上是一个布尔表达式。

语法：

例如：

内置函数 len 返回序列包含的元素个数，而 min 和 max 分别返回序列中最小和最大的元素。

Python通用的序列操作有：索引、切片、乘法、成员资格检查、长度、最小值和最大值。

当前标题：python内建序列函数 python序列类型的通用操作符和函数
网页路径：http://cqwzjz.cn/article/hieehs.html