Python 内置函数简单介绍

Python 内置函数

Python提供了68个内置函数,根据是否常用,分成三部分:

了解 all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()
重点 abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()
后期 classmethod() delattr() getattr() hasattr() issubclass() isinstance() object() property() setattr() staticmethod() super()
  1. 了解部分

    • eval():剥去字符串的外衣,运算里面的代码。不建议使用

      ​ 特别是网络传输的str,input输入的时候,sql注入等等绝对不能使用eval()。因为被转换的字符串容易被修改利用,而导致eval()直接运行里面的内容。

      s1='1+2'
      print(eval(s1))
      >>>3
      

      和eval()相似的另一个函数exec()用于代码流(多行代码),也不建议使用,高危。

    • hash():获取一个对象的哈希值,可哈希对象为不可变对象。

    • help():打印获取这个对象的使用方法。

    • callable():判断某个对象是否可调用。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。

    • bin():将十进制转换成二进制并返回。★★

      oct():将十进制转化成八进制字符串并返回。★★

      hex():将十进制转化成十六进制字符串并返回。★★

      print(bin(10),type(bin(10)))  # 0b1010 <class 'str'>
      print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
      print(hex(10),type(hex(10)))  # 0xa <class 'str'>
      
    • divmod():计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)

      round():保留浮点数的小数位数,默认保留整数。

      pow():求xy次幂。(三个参数为xy的结果对z取余)

      print(divmod(7,2))  	# (3, 1)
      print(round(7/3,2))  	# 2.33
      print(round(7/3))  		# 2
      print(round(3.32567,3))  # 3.326
      print(pow(2,3))  		# 两个参数为2**3次幂
      print(pow(2,3,3))  		# 三个参数为2**3次幂,对3取余。
      
    • bytes():用于不同编码之间的转化。

      s = '你好'						
      bs = s.encode('utf-8')
      print(bs)						# b'\xe4\xbd\xa0\xe5\xa5\xbd'
      s1 = bs.decode('utf-8')
      print(s1)						# 你好
      bs = bytes(s,encoding='utf-8')
      print(bs)						# b'\xe4\xbd\xa0\xe5\xa5\xbd'
      b = '你好'.encode('gbk')
      b1 = b.decode('gbk')
      print(b1.encode('utf-8'))		# b'\xe4\xbd\xa0\xe5\xa5\xbd'
      
    • ord:输入字符找该字符编码的位置,可查Ascii码或Unicode

      chr:输入位置数字找出其对应的字符

      # ord 输入字符找该字符编码的位置
      print(ord('a'))		# 97
      print(ord('中'))		# 20013
      
      # chr 输入位置数字找出其对应的字符
      print(chr(97))		# a
      print(chr(20013))	# 中
      
    • repr():返回一个对象的string形式(原形毕露)★★★ 面向对象经常用到

      print(repr('{"name":"alex"}'))		# '{"name":"alex"}'
      print('{"name":"alex"}')			# {"name":"alex"}
      

      在格式化输出中,%r 也有repr()函数的功能:

      s1 = '中国人'
      msg = '我是%r' % s1
      print(msg) 				# 我是'中国人'
      
    • all():可迭代对象中,全都是True才是True

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

      print(all([1,2,True,0]))		# False
      print(any([1,'',0]))			# True
      
  2. 重点掌握

    • int():函数用于将一个字符串或数字转换为整型,可以用于取整。

      float:函数用于将整数和字符串转换成浮点数。

      complex:函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。

    • print():屏幕输出函数

      *格式:print(self, args, sep=' ', end='\n', file=None)

      *args:位置参数,不限内容。

      sep=' ':输出多个元素的间隔默认为一个空格。

      print('a',3,5,11,'kv',sep='|')		# a|3|5|11|kv
      

      end='\n':一次调用最后的结尾默认为一个换行符

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

      list1=list('amwkvi')
      print(list1)			# ['a', 'm', 'w', 'k', 'v', 'i']
      

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

      dict():通过相应的方式创建字典

      dict1 = dict([('one', 1), ('two', 2),('three', 3)])
      dict2 = dict(one=1, two=2, three=3)
      dict3 = dict({'one': 1, 'two': 2, 'three': 3})
      dict4 = {'one': 1, 'two': 2, 'three': 3}
      dict5 = dict.fromkeys('abc',[1,2,3])
      
    • abs():返回一个数值的绝对值。 ★★★

      sum():求和,求可迭代对象(数值型)的和。 ★★★

      l1 = [i for i in range(10)]
      print(sum(l1))			# 45
      print(sum(l1,100))		# 设置初始值100,就是在100的基础上进行做sum,结果为:145
      

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

      l1=list('amwkvi')
      print(l1)				# ['a', 'm', 'w', 'k', 'v', 'i']
      l2=list(reversed(l1))	# l2变量得到的是一个翻转的迭代器,所以需要用list函数进行转化
      print(l2)				# ['i', 'v', 'k', 'w', 'm', 'a']
      
    • zip():拉链方法,将几个可迭代对象按照顺序组成一个生成器,生成器内容长短取决于这几个对象中最短的那个。 ★★★

      l1 = [1, 2, 3, 4, 5]
      tu1 = ('a', 'b', 'c')			# tu1最短,以该对象为准,一一对应产生一个生成器
      s1 = 'kill'
      obj = zip(l1, tu1, s1)
      # for i in obj:
      #     print(i)
      print(list(obj))				# [(1, 'a', 'k'), (2, 'b', 'i'), (3, 'c', 'l')]
      >>>(1, 'a', 'k')
      (2, 'b', 'i')
      (3, 'c', 'l')
      
    • min():求最小值。 ★★★★★

      格式:min(*args, key=None)

      例一:输出l1列表中绝对值最小值,后面的key将每个元素进行了取绝对值处理。

      l1 = [1, 2, 3, 4, 5, -9, 19, -16]
      print(min(l1,key=abs))				# 1
      

      例二:求出值最小的键值对

      dic = {'a': 3, 'b': 2, 'c': 1}
      # print(min(dic))	 	# min默认会按照字典的键去比较大小,所以得出是a。
      # def dic_value(k):		# 手动建立一个函数,输入键,返回值
      #     return dic[k]
      # print(min(dic,key=dic_value))	# 输出的是值最小的键
      
      print(dic[min(dic,key=lambda k:dic[k])]) # 写成一行代码,使用匿名函数,传入键,返回值,min函数通过lambda对每个值进行比较大小。
      

      例三:求列表中年龄最小那人的姓名

      l2 = [('太白', 18), ('alex', 73), ('wusir', 35), ('口天吴', 41)]
      print(min(l2, key=lambda k: k[1])[0])		# 太白
      # k变量中每次传入的是列表中的每个元组,返回值为元组中的第二项,然后交给min函数进行比较。
      # min的比较结果是一个元组,最后再取元组中的第一个元素,即人的名字。
      

      max():求最大值。 ★★★★★

      格式:max(*args, key=None)

      凡是可以加key的函数:它会自动将可迭代对旬中的每个元素按照顺序传入key对应的函数中,以返回值进行比较大小。

    • sorted():排序函数,该函数对可迭代对象进行排序并返回一个新列表。默认从低到高进行排序,加上reverse=True参数可以进行逆序。

      格式:sorted(*args, **kwargs)
      l2 = [('太白', 18), ('alex', 73), ('wusir', 35), ('口天吴', 41)]
      # 默认按照列表中每个元素的第一个内容进行排序。
      print(sorted(l2))  # [('alex', 73), ('wusir', 35), ('口天吴', 41), ('太白', 18)]
      # 加上key之后,使用匿名函数指定按照第二个内容进行排序。
      print(sorted(l2, key=lambda x: x[1]))  
      # [('太白', 18), ('wusir', 35), ('口天吴', 41), ('alex', 73)]
      print(sorted(l2,key=lambda x:x[1],reverse=True))
      # 加上reverse=True之后,将逆序排序。
      # [('alex', 73), ('口天吴', 41), ('wusir', 35), ('太白', 18)]
      
    • filter():过滤、筛选,类似于列表推导式的筛选模式。该函数和列表推导器的区别是:返回值为一个迭代器。

      举例:列表推导式和 filter() 演示

      list1 = [2, 4, 11, 9, 5, 8]
      # 列表推导式实现输出大于6的内容:[11, 9, 8]
      print([i for i in list1 if i > 6])		# 返回的是个列表
      # 使用filter()函数实现该功能:[11, 9, 8]
      print(list(filter(lambda x: x > 6, list1)))	# 返回的是个迭代器,需要用list进行转换。
      
    • map()函数:类似于列表推导式的循环(遍历)模式。它和列表推导式的区别也是:返回值为一个迭代器。

      举例:列表推导式和 map() 演示,需要程序生产出一个有规律的列表:[1, 4, 9, 16 ,25]

      # 使用列表推导式生成列表:[1, 4, 9, 16 ,25]
      print([i * i for i in range(1, 6)])
      # 使用map函数进行生成列表:[1, 4, 9, 16 ,25]
      obj = map(lambda i: i * i, range(1, 6))
      # obj 为迭代器,想要得到列表需要用list方法实现
      print(list(obj))
      
    • reduce()函数:该函数不属于内置函数,需要外部导入。

      作用:

      第一步:先把列表中的前俩个元素取出,按function规则计算出一个值'a',然后临时保存着;

      第二步:将这个临时保存的值'a'和列表中第三个元素传入至function进行计算,再求出一个新的值'b';

      第三步:又将这个新的值'b'覆盖掉'a',读取列表中第四个元素传入至function进行计算。以此类推。(个人理解类似 “i++”)

      格式:reduce(function, sequence, initial=None)

      在Python2.x版本中recude是直接 import就可以的,Python3.x版本中需要从functools这个包中导入。

      举例:

      from functools import reduce
      list1 = [3, 5, 8, 2, 9, 7]
      
      # 方法一:使用自定义函数实现将列表中所有元素进行相加
      def func1(a, b):
          return a + b
      print(reduce(func1, list1))		# 34
      
      # 方法二:使用lambda实现将列表中所有数字变成一个整数
      print(reduce(lambda a, b: a * 10 + b, list1))		# 358297
      
posted @ 2020-09-28 17:11  amwkvi  阅读(103)  评论(0编辑  收藏  举报