【Python】常见内置函数用途(一)

Python的内置函数有77种，列举比较常用的内置函数！

1. open（）：用于文件操作

语法：

开放（“名”，“型号”，“缓冲”）

参数说明：名称：文件的路径，model：打开文件的模式，buffering：0，不会有寄存; 1，访问文件会寄存行，> 1，表明寄存区的大小; <0，缓存区大小为系统默认

模式：

r：只读，rb：二进制只读，r +：读写，rb +：二进制读写，w：写入（存在覆盖文件，不存在创建），wb：二进制写入（同上）

w +：读写（同上），wb +：二进制读写（同上），a：文件追加（存在继续写入不覆盖源文件内容，不存在创建），ab：二进制追加（同上），a +：读写同上），AB +：二进制读写（同上）

举例：打开（ “d：data.txt中”， 'A'）

扩展：

file = open（xxxxxxxxxxx）

对象方法：file.read（size）：size：可写可不写不写不写不写返写对应大小

file.readline（）返回一行，file.readlines（size）返回全部行同上

file.write（）文件写入file.tell（）返回指针位置file.seek（）移动指针file.close（）关闭文件

2. int（）：讲一个字符串或者数字转换为整型

语法：int（x，base = 10）

参数说明：x：字符串或者数字，基本进制默认为十进制  

举例：int（）------->返回0; int（“123”）-----------> 123; int（“a”）会报错

3. ord（）：返回一个字符的ASCII码值

语法：ord（x）

参数说明：x为一个字符

举例：ord（“a”）-----> 97

4. str（）

语法str（object）：转化为字符串

参数说明：object：任意类型

举例：str（123）--->“123”; str（{1,2,3,4}） - >“{1,2,3,4}”

5. eval（）：用于执行一个字符串表达式，并返回表达式的值

语法：EVAL（源，全局=无，当地人=无）

参数说明：源：表达式，必须为字符串;全局：必须只能是字典类型;当地人：可以是任何映射对象

举例：eval（“1 + 2”）-------------> 3

6. isinstance() :判断对象是否是已知类型，类似于type()，返回结果 True /False

语法: isinstance(object,classinfo)

参数说明：object:实例对象可以是任意类型，classinfo:可以是直接或间接类名，基本类型或有他们组成的元祖

举例 : isinstance([1,2,3],list) -------->True

扩展：与type()的区别：isinstance：子类是一种父类类型，考虑继承，而type()反之

7.  pow()  返回 一个数的次方

语法 ：pow(x,y,z)（内置）  :返回整型， math.pow(x,y)：返回float类型

参数说明: x:一个数，y：一个数的次方，z：取模

举例：pow(2,3,2) -------->8%2----->0

8. sum()：迭代求和计算

语法 :sum(iterable)

参数说明：iterable：可迭代对象，如列表

举例：sum([1,2,3,4]) ----------->10

9.print():输出

语法：print(*object，sep=" "，end=“\n”,file=sys.stdout)

参数说明: *object :输出多个对象，用逗号分隔，sep：用来分隔多个对象，默认空格 ，end：以说明结尾，默认换行符 ，file：要写入的文件对象，sys.stdout为系统输出

举例：print(1,2,3,4,sep=',',end='##',file="data.txt") -------->将会在data.txt文件中写入  1,2,3,4,##

10. super() ：子类调用父类方法

举例;super().方法名

11.tuple()：将列表转化为元祖

语法：tuple(seq)

参数说明：seq：列表，元祖，字典 

举例： tuple([1,2,3])---------->（1,2,3）；tuple({"a":1,"b":2}) ------>(a,b)  针对字典 会返回由字典的key组成的元祖

12. len()：返回对象长度

语法 ：len(x)

参数说明：x ：对象

举例：len("123")--------->3 ;len({1,2,3,4}) ----------->4;len({1:2，2:3})-----------2

13.float():用于整数和字符串转化为浮点型

语法：float(X)

参数说明： x：整数或字符串

举例：float（"123"）----->123.0 ; float(123)-------->123.0

14. range():创建一个整数列表，一般常用于for循环

语法：range(start，stop，step)

参数说明：start：计数开始 默认为0，stop：计数介绍，不包括stop，step：步长

举例：range(5)------->0,1,2,3,4   ; range(1,10)--------->0,1,2,3,4,5,6,7,8,9; range(1,10,2)---------->0,2,4,6,8

15.format():字符串格式化

语法 “xx{}xxx{}xx”.format("123","456") “xx{name}xxx{age}xx”.format(name="123",age="456")

举例： “我叫{}，今年{}岁".format("哈哈","12")--------->“我叫哈哈，今年12岁"

16.reduce():对参数序列中元素进行累积

语法：reduce(func,iterable)

参数说明：func：方法有两个参数，iterable：可迭代对象

举例：functools.reduce(lambda  x,y:x+y,[1,2,3,4,5])------->15

17.chr() ：范围0-255整数所对应的ASCII码值

语法 chr(r)

参数说明：r：0-255整数

举例：chr(97)------------>a

   18.frozenset() ：返回一个冻结的集合，不可变

语法 ：forzenset(iterable)

参数说明：iterable：可迭代对象

举例：forzenset(range(10)) ----------->firzenset([0,1,2,3,4,5,6,7,8,9]) 不可变集合

19 .map() :根据提供的函数对指定序列做映射

语法：map(function，iterable)

参数说明：function：方法，iterable：可迭代对象

举例 map(lambda x ,y:x+y,[1,3,5,7,9],[2,4,6,8,10])------->[3,7,11,15,19]

20:repr() :将对象转化为供解释器读取的形式

语法 repr(object)

参数说明：object  对象

举例：repr({1,2,3,4})----------->"{1,2,3,4}"

21.reverse() :对列表进行反向排序

语法：list.reverse()

参数说明：list：列表

举例：[1,2,3,4,5].reverse()------------->[5,4,3,2,1]

22. 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相反，可理解为解压，返回二维矩阵式----> [（1，2，3），（4，5，6）]

23 .dict（）：创建一个字典

语法：dict（** kwarg）
 字典（mapping，** kwarg）

 字典（可迭代，** kwarg）

参数说明：** kwargs - 关键字; mapping - 元素的容器。; iterable - 可迭代对象。

举例：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}

24.round():返回浮点数的四舍五入值

语法 ：round(x,n)

举例: round(12.4563,1)----> 12.5 ;round(12.4563,2)----> 12.46;round(12.4563,3)----> 12.456

25.sorted():可迭代的对象排序

语法：sorted(iterable[, cmp[, key[, reverse]]])

参数说明：iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

举例：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)]

26.oct()：整数转为8进制字符串

举例 oct(123)---->"0o173"

27. filter()：用于过滤序列，过滤不符合条件的元素，返回由符合条件元素组成的新列表

语法：filter(func，iterable)

参数说明：func：判断函数，iterable ：可迭代对象

举例：list(filter((lambda x ：x>0),range(-5,5))) ----------------->[0,1,2,3,4]

28:iter():用来生成迭代器对象

语法：iter(object，sentinel)

参数说明：object ：可迭代对象 ，sentinel：如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

举例：for i in iter([1,2,3])

29: set() ：创建一个不重复元素集，可进行关系测试，删除重复数据，可以计算交并差集。

语法 ：set（iterable）

参数说明：iterable ：可迭代对象

举例：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' ]）