内置函数的补充

内置函数的补充

字符串相关

    • eval（）：执行字符串类型的代码，并返回最后结果。

    • exec（）：执行字符串类型的代码。流程语句。

        • 返回值为None。

    • print（）：

        • print（end = ）：末尾以什么元素结束。

        • print（sep =  ）　：print多个元素之间用什么元素连接。
        • print（file =  ）　：在哪个文件写入内容　　

    • hash（）

        • 数字的哈希值还是数字本身。
        • 字符串转化为哈希值，为一串可变数字。
        • bool值对应的哈希值分别为1/0.　

    • callable（）：判断一个对象是否可以被调用。一般判定对象是否为函数名。

        • callable（a）

    • dir（）：查阅对象的所有方法。

    • iter（）：

        • iter（a）

    • int（）

      • int（）= 0、int（3.14） = 3 ，int（“0100”base = 2）　

    • float（数字，小数点个数）　　

        • 默认保留一个小数

  • 机制转换　

        • *bin（）十进制转2进制并返回     格式：0bxxx

        • *oct（）将十进制转化为八进制并返回   格式：0oxxx

        • *hex（）将十进制转换成十六进制字符串并返回 。 格式：0xXXX

    • divmod（）：divmod（a，b）返回一个包含商与余数的元组

  • 数学运算

    • round（3.114，2）：保留浮点数的小数位数。默认保留整数

    • pow（x，y，z）：求x**y。（三个参数对第三个数z取余）　　

    • sum（[1,2,5,99,7],88）:对可迭代对象进行求和。

    • mix（）：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）

    • min（）：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最小值）

  • 数据结构

    • list（）：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素。

    • tuple（）：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素。　　

    • reversed（）：将一个列表翻转后，返回这个翻转列表的迭代器。　

    • slice（5）　：构建一个切片，对一定列表进行切割。

        • 　规则=（5）→list[规则]　

 

 1 li = ['a','b','c','d','e','f','g']
 2 l2 = ['a','b','c',1,2,3,4,54]
 3 ll = slice(5)
 4 print(li[ll])
 5 print(l2[ll])
 6 
 7 
 8 
 9 ['a', 'b', 'c', 'd', 'e']
10 ['a', 'b', 'c', 1, 2]
View Code

 

    • format（'test'，20<>^）：　　左对齐、右对齐、居中对齐。

    • byte（）：

        • ord（）：输入字符返回字符在unicode中asci码的编号、

        • chr（）：输入asci码返回在unicode 对应asci码的字符。

        • ascii（）：判断是不是asci码，如果是就返回原值，不是的话返回/u

 

    • %r 跟 repr（）

        • %r  原封不动的填入

        • repr（）类似于原形毕露。是什么就返回什么 ，包括字符串的引号“”。

 

    • 　枚举（贼鸡儿重要）

        • ennumerate（）：返回一个枚举对象。　此枚举对象是一个迭代器。　　　　　　　　

 

 

　　

 1 li = ['老男孩', 'alex', 'wusir', '嫂子', 'taibai']
 2 print(enumerate(li))
 3 for i in enumerate(li):
 4     print(i)
 5 for k,v in enumerate(li):
 6     print(k,v)
 7 for k,v in enumerate(li,3):   ##定义一个开头数字
 8     print(k,v)
 9 
10 
11 (0, '老男孩')
12 (1, 'alex')
13 (2, 'wusir')
14 (3, '嫂子')
15 (4, 'taibai')
16 0 老男孩
17 1 alex
18 2 wusir
19 3 嫂子
20 4 taibai
21 3 老男孩     ###序号可以定义从哪个数字开始。
22 4 alex
23 5 wusir
24 6 嫂子
25 7 taibai

 

    • all（）：可迭代对象中，全部为True方为True

    • ant（）：可迭代对象中，有一个为True即为True。

    • zip（）：　　

      • 拉链方法。形成元素的个数与最短的可迭代对象长度一样。

      • zip（）是一个迭代器。

 

　

 1 l1 = [1, 2, 3, 4]
 2 l2 = ['a', 'b', 'c', 5]
 3 l3 = ('*', '**', (1,2,3), 777)
 4 l4= ('0', '99', (1,2,3), 777)
 5 print('__iter__' in dir(zip(l1,l2,l3,l4)))
 6 print('__next__' in dir(zip(l1,l2,l3,l4)))
 7 for i in zip(l1,l2,l3,l4):
 8     print(i)
 9 
10 
11 True
12 True
13 (1, 'a', '*', '0')
14 (2, 'b', '**', '99')
15 (3, 'c', (1, 2, 3), (1, 2, 3))
16 (4, 5, 777, 777)
View Code

    • filter（）：过滤。。用一个函数过滤一个可迭代对象。类似于 [i for i in range(10) if i >3]

        • filter（函数，可迭代对象） 也是一个迭代器。　　

    • map（）：循环。　

        • map（函数，可迭代对象），也是一个迭代器。　

  • 匿名函数：为了解决那些功能很简单的需求而设计的一种函数。　　　　

        • calc = lambda  n：n**2　

          • calc为函数名；
          • n为匿名函数的变量
          • n**2为匿名函数的返回值　　

　　

 

　

　　　　　　　　　　　

posted on 2018-04-04 17:33  弃疾  阅读(146)  评论(0)    收藏  举报

导航