首页 > 其他 > 详细

六、内置函数

时间:2019-05-25 11:34:56      阅读:135      评论:0      收藏:0      [点我收藏+]

一、了解部分

内置函数(大部分了解)

  • eval :剥去字符串的外衣,运算里面的代码,有返回值


    s1 = ‘1 + 3‘
    print(s1)         # 1+3
    print(eval(s1))   # 4

    s = ‘{"name": "alex"}‘
    print(s,type(s))              #{"name": "alex"} <class ‘str‘>
    #print(dict(s))   # 不行
    print(eval(s),type(eval(s)))  #{‘name‘: ‘alex‘} <class ‘dict‘>
    • 网络传输str input 输入的时候,sql注入等等绝不能使用eval

  • exec 与eval几乎一样,代码流


    msg = """
    for i in range(10):
      print(i)
    """
    print(msg)
    #结果就是注释里面内容
    exec(msg)
    #可计算内部,0~9循环输出
  • hash:获取一个对象的哈希值


    print(hash(‘fsjkdafsda‘))
    # -2847953170711602116
    ?
  • help:打印、获取一个方法的说明


    print(help(list))
    print(help(str.split))
  • callable:函数用于检查一个对象是否是可调用的


    name = ‘alex‘
    def func():
       pass
    print(callable(name))  # False
    print(callable(func))  # True
  • 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‘>

  
二、内置函数I

  • callable 判断一个对象是否是可被调用,True则可以,False不可调用 ***


    name = ‘alex‘
    def func():
       pass
    print(callable(name))  # False
    print(callable(func))  # True
  • int 整型,取整


    print(int())  # 0
    print(int(‘12‘))  # 12
    print(int(3.6))  # 3   取整
    print(int(‘0100‘,base=2))  # 将2进制的 0100 转化成十进制。结果为 4
  • float :函数用于将整数和字符串转换成浮点数。


    print(float(2))    # 2.0
    print(type(3.6))   # <class ‘float‘>
  • complex :函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。


    print(complex(1,2))   # (1+2j)
    print(complex(‘12‘))  # (12+0j)
  • divmod :计算除数与被除数的结果 **

    返回一个包含商和余数的元组(a // b, a % b)


    print(divmod(10,3))    # (3, 1)
  • round :保留浮点数的小数位数 **


    print(round(3.141592653, 2))  # 3.14
  • pow :求x**y次幂(三个参数为对x**y结果对z取余) **


    print(pow(2,3))   # 8
    print(pow(2,3,3)) # 2 就是2的3次方再对3取余
  • bytes :用于不同编码之间的转化 ***


    s1 = ‘太白‘
    b = s1.encode(‘utf-8‘)
    print(b)              # b‘\xe5\xa4\xaa\xe7\x99\xbd‘
    b = bytes(s1,encoding=‘utf-8‘)
    print(b)              # b‘\xe5\xa4\xaa\xe7\x99\xbd‘
  • ord :输入字符找该字符编码的位置 **

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

    ? 超出ASCII用Unicode


    print(ord(‘a‘))   # 97
    print(ord(‘中‘))  # 20013   Unicode
    ?
    print(chr(97))    # a
    print(chr(20013)) # 中   Unicode
  • repr :返回一个对象的string形式(原形毕露)***


    s1 = ‘太白‘
    print(s1)        # 太白
    print(repr(s1))  #‘太白‘
    ?
    msg = ‘我叫%s‘%(s1)   # 我叫太白
    msg = ‘我叫%r‘%(s1)   # 我叫‘太白‘
    print(msg)
  • all :可迭代对象中,全部是True才是True

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


    l1 = [1, 2, ‘太白‘, True, [1,2,3], ‘‘]
    print(all(l1))      # False
    ?
    l2 = [ 0, ‘太白‘, False, [], ‘‘,()]
    print(any(l2))      # True

 

三、内置函数II

    • print


      # print(self, *args, sep=‘ ‘, end=‘\n‘, file=None)
      print(1,2,3,4)          # 1 2 3 4
      print(1,2,3,4,sep=‘&‘)  # 1&2&3&4
      print(1,end=‘ ‘)        # 1 下次输出不换行,以空格分开
      print(2)

       

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

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


      l1 = [1,2,3,4]
      l2 = list()
      l2 = list(‘sadsaff‘)
      print(l2)    # [‘s‘, ‘a‘, ‘d‘, ‘s‘, ‘a‘, ‘f‘, ‘f‘]
      ?
      tu1 = tuple(‘abcd‘)
      print(tu1)   # (‘a‘, ‘b‘, ‘c‘, ‘d‘)

       

    • dict


      dic = dict([(1,‘one‘),(2,‘two‘),(3,‘three‘)])
      print(dic)     # {1: ‘one‘, 2: ‘two‘, 3: ‘three‘}
      ?
      #把列表转化字典
      l1 = [(1,‘one‘),(2,‘two‘),(3,‘three‘)]
      dic = dict(l1)
      print(dic)     # {1: ‘one‘, 2: ‘two‘, 3: ‘three‘}
      ?
      dic = dict(one=1,two=2)
      print(dic)     # {‘one‘: 1, ‘two‘: 2}

       

    • abs() 绝对值 ***


      print(abs(-7))    # 7

       

    最重要的内置函数(面试、工作都用得到)

    • sum() 求和

      可设置初始值

      要是int型


      l1 = [i for i in range(10)]
      print(sum(l1))     # 45
      print(sum(l1,100)) # 145 设置100为初始值
      ?
      s1 = ‘12345‘
      print(sum(s1))  # s1 是str,不是int,会报错

       

    • reversed 返回的是一个翻转的迭代器 ***


      l1 = [i for i in range(10)]
      l1.reverse() # 列表的方法
      print(l1)   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
      ?
      l1 = [i for i in range(10)]
      obj = reversed(l1)
      print(l1)         # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      print(list(obj))  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

       

    • zip() 拉链方法

      函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,

      然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回,


      l1 = [1,2,3,4,5]
      tu1 = (‘太白‘,‘b哥‘,‘德刚‘)
      s1 = ‘abcd‘
      obj = zip(l1,tu1,s1)
      #print(obj)   #<zip object at 0x000001177EA77A08>,就是个地址
      # 迭代对象取值:for next list
      ?
      # 第一种for迭代对象
      for i in obj:
         print(i)
      ?
      # 第二种list迭代对象
      print(list(obj))

       

    *************** 以下方法更重要

    • min max

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

      min默认会按照字典的键去比较大小


      l1 = [33, 2, 3, 54, 7, -1, -9]
      print(min(l1))    # -9
      ?
      ?
      # 以绝对值的方式去最小值
      l1 = [33, 2, 3, 54, 7, -1, -9]
      l2 = []
      func = lambda a:abs(a)
      for i in l1:
         l2.append(func(i))
      print(min(l2))    # 1
      ?
      l1 = [33, 2, 3, 54, 7, -1, -9]
      def abss(a):
      #     ‘‘‘
      #     第一次:a = 33 以绝对值取最小值 33
      #     第二次:a = 2 以绝对值取最小值 2
      #     第三次:a = 3 以绝对值取最小值 2
      #     ......
      #     第六次:a = -1   以绝对值取最小值 1
      #
      #     ‘‘‘
         return abs(a)
      print(min(l1,key=abss))  # -1
      ?
      print(min(l1,key=abs))  # -1
      # 凡是可以加key的:它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中,
      # 以返回值比较大小。
      ?
      ?
      # min默认会按照字典的键去比较大小。
      dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
      print(min(dic))       # a  
      # 求出值最小的键?
      dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
      def func(a):
         return dic[a]
      func = lambda a:dic[a]
      print(min(dic,key=func))
      ?
      dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
      print(min(dic,key=lambda a:dic[a]))

       

    • sorted 排序 (也可以加key)

      返回一个列表,默认从低到高


      l1 = [11,22,33,1,2,8,7,6,5]
      l2 = sorted(l1)
      print(l1)  # [11,22,33,1,2,8,7,6,5]
      print(l2)  # [1,2,5,6,7,8,11,22,33]
      ?
      l1 = [(‘大壮‘,76),(‘雪飞‘,70),(‘张程‘,98),(‘b哥‘,96)]
      print(sorted(l1,key= lambda x:x[1]))  # 返回的是一个列表
      # [(‘雪飞‘,70),(‘大壮‘,76),(‘b哥‘,96),(‘张程‘,98)]
      print(sorted(l1,key= lambda x:x[1],reverse = True))
      # 默认从低到高,加reverse是从高到低

       

    • filter 筛选,类似列表推导式的筛选模式


      l1 = [2,3,4,1,6,7,8]
      print([i for i in l1 if x > 3]) # [4,6,7,8]返回的是一个列表
      ret = filter(lambda x:x>3,l1)   # 返回的是一个迭代器
      print(ret) # 迭代器
      print(list(ret))  # [4,6,7,8]
    • map 映射函数,类似列表推导式的循环模式


      # map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function
      # 想要得到这样的列表 l1 = [1,4,9,16,25]
      print([i**2 for i in range(1,6)])
      ret = map(lambda x:x**2,range(1,6))
      print(ret)
      print(list(ret))
    • reduce 累加效果,第一次取两个值

      from functools import reduce


      # reduce
      from functools import reduce
      def func(x,y):
         ‘‘‘
        第一次:x y : 11 2     x + y =     记录: 13
        第二次:x = 13   y = 3   x + y =     记录: 16
        第三次 x = 16   y = 4 .......
        ‘‘‘
         return x + y
      ?
      l = reduce(func,[11,2,3,4])
      print(l)

 

四、闭包

闭包(多用于面试题:什么是闭包,闭包有什么作用)

整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢?就是从这个商品一出现开始,每天记录当天价格,然后计算他的平均值:平均值要考虑直至目前为止所有的价格。

比如大众推出了一款新车:小白轿车。

第一天价格为:100000元,平均收盘价:100000元

第二天价格为:110000元,平均收盘价:(100000 + 110000)/2 元

第三天价格为:120000元,平均收盘价:(100000 + 110000 + 120000)/3 元

 

封闭的东西:保证数据的安全


# 封闭的东西: 保证数据的安全。
?
# 方案一:
# l1 = [] # 全局变量 数据不安全
# li = []
# def make_averager(new_value):
#     l1.append(new_value)
#     total = sum(l1)
#     averager = total/len(l1)
#     return averager
# print(make_averager(100000))
# print(make_averager(110000))
# # 很多代码.....
# l1.append(666)
# print(make_averager(120000))
# print(make_averager(90000))
?
# 方案二: 数据安全,l1不能是全局变量。
# 每次执行的时候,l1列表都会重新赋值成[]
# li = []
# def make_averager(new_value):
#     l1 = []
#     l1.append(new_value)
#     total = sum(l1)
#     averager = total/len(l1)
#     return averager
# print(make_averager(100000))
# print(make_averager(110000))
# # 很多代码.....
# print(make_averager(120000))
# print(make_averager(90000))
?
# 方案三: 闭包
?
#
def make_averager():
   l1 = []
   def averager(new_value):
       l1.append(new_value)
       print(l1)
       total = sum(l1)
       return total/len(l1)
   return averager
?
# avg = make_averager() # averager
# print(avg(100000))
# print(avg(110000))
# print(avg(120000))
# print(avg(190000))
?
# def func():
#     return 666
#
# ret = func()
# print(globals())
  • 闭包: 多用于面试题: 什么是闭包? 闭包有什么作用。

    1. 闭包只能存在嵌套函数中

    2. 定义:内层函数对外层函数非全局变量的引用(使用),就会形成闭包。被引用的非全局变量也称作自由变量,这个自由变量会与内层函数产生一个绑定关系,自由变量不会在内存中消失

    3. 作用:保证数据的安全

  • 如何判断一个嵌套函数是不是闭包?


    # 1,闭包只能存在嵌套函数中。
    # 2, 内层函数对外层函数非全局变量的引用(使用),就会形成闭包。
    # 例一:
    # def wrapper():
    #     a = 1
    #     def inner():
    #         print(a)
    #     return inner
    # ret = wrapper()
    ?
    #
    # # 例二:
    # a = 2
    # def wrapper():
    #     def inner():
    #         print(a)
    #     return inner
    # ret = wrapper()
    ?
    ?
    # # 例三:
    #   也是闭包!
    # def wrapper(a,b):
    #     def inner():
    #         print(a)
    #         print(b)
    #     return inner
    # a = 2
    # b = 3
    # ret = wrapper(a,b)
    # print(ret.__code__.co_freevars) # (‘a‘, ‘b‘)
    # 如何代码判断闭包?
    ?
    def make_averager():
       l1 = []
       def averager(new_value):
           l1.append(new_value)
           print(l1)
           total = sum(l1)
           return total/len(l1)
       return averager
    ?
    avg = make_averager()  # averager
    print(avg.__code__.co_freevars)

     

 

六、内置函数

原文:https://www.cnblogs.com/yangzm/p/10921745.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!