zoukankan      html  css  js  c++  java

  • python 小兵(10)内置函数

    内置函数(下午讲解)

    什么是内置函数?就是python帮我们提供的一个工具,拿过直接用就行,比如我们的print,input,type,id等等.截止到python3.6.2版本

    中一共提供了68个内置函数.他们就是python直接提供给我们的,有一些我们已经用过了.有一些还没有用过.还有一我们需要学完面向对象才能继续学习.今天我们认识一下python的内置函数

    作用域相关

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

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

    迭代器相关

    　　range() 生成数据

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

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

    字符串类型代码的执行

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

    1
    2
    3
    4
    5
    6
    7
    8
    print(eval('2+8'))
    结果:
    10
    ​
    n = 8
    print(eval('n + 10'))
    结果:
    18

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    exec('''
    for i in range(10):
        print(i)
    ''')
    ​
    # 我们按照python能够识别的语法写代码,这次写入的是字符串也可以执行
    ​
    ​
    exec('''
    ​
    def func():
        print("444")
    ​
    func()   
    ​
    ''')
    ​
    结果:
    444　　

    通过上边的测试发现,只要是exec就没有返回值,eval就是有返回值的　

    输入和输出相关

    　　input() 获取用户输入的内容

    　　print() 打印 输出

    print里的sep

    1
    2
    3
    4
    5
    6
    7
    8
    print('alex','wusir','baoyuan')
    print('alex','wusir','baoyuan',sep='|')
    ​
    # 结果:
    # alex wusir baoyuan
    # alex|wusir|baoyuan
    ​
    print默认sep是一个空格,咱们打印出来的是以空格分开的,我们修改了sep打印出来的就是以管道符分开的

    print里的end

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    print('alex')
    print('alex')
    print('alex')
    # 结果:
    # alex
    # alex
    # alex
    ​
    ​
    print('alex',end='')
    print('alex',end='')
    print('alex',end='')
    # 结果:
    # alexalexalex
    print 默认end是一个 ,打印出来的效果是有换行功能,咱们改成空字符串,打印出来的效果就是一行显示

    内存相关

    　　hash() 获取对象的哈希值(int.str,bool,tuple)

    1
    2
    3
    4
    print(hash((1,2,4)))
    print(hash('你好'))
    print(hash(111))
    print(hash(False))

    　　id() 获取到对象的内存地址

    1
    2
    3
    4
    name = 'alex'
    print(id(name))
    ​
    结果:2376700908072

    文件操作相关

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

    模块相关

    ​ import() 导入,引入

    1
    2
    3
    import time
    ​
    print(time.time())

    帮助

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    help(input)
    ​
    结果:
    Help on built-in function input in module builtins:
    ​
    input(prompt=None, /)
        Read a string from standard input.  The trailing newline is stripped.
         
        The prompt string, if given, is printed to standard output without a
        trailing newline before reading input.
         
        If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
        On *nix systems, readline is used if available.

    调用相关

    　　callable() 用于检查一个对象是否是可调用的,如果返回True,object有可能调用失败,要是返回False,那调用绝对就完犊子

    1
    2
    3
    4
    5
    6
    7
    8
    def func():
    ​
        pass
    ​
    name = 'meet'
    ​
    print(callable(func))  结果 True
    print(callable(name))  结果 Fasle

    查看内存属性

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

    1
    2
    3
    4
    5
    print(dir(input))
    ​
    # 结果:
    # ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
    基础数据类型相关

    数字相关:　　

    　　bool() 将给定的数据转换成bool值,如果不给值.返回False

    1
    2
    3
    print(bool())
    结果:
    False

    　　int() 将给定的数据转换成int值,如果不给值,返回0

    1
    2
    3
    print(int())
    结果:
    0

    　float() 将给定的数据转换成float值,也就上次小数

    1
    2
    3
    print(float())
    结果:
    0.0

    　　compilex() 创建一个复数,第一个参数为实部,第二个参数为虚部.或者第一个参数直接用字符串来描述复数

    1
    2
    3
    print(complex(120))
    结果:
    120+0j

    进制转换:

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

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

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

    数字运算:

    　　abs() 求绝对值

    1
    2
    3
    print(abs(-100))
    结果:
    100 　

    　　divmod() 返回商和余数

    1
    2
    3
    print(divmod(20,6))
    结果:
    (3, 2)
    		 
    第一个参数是商,第二参数是余数

    　　round() 四舍五入

    1
    2
    3
    4
    5
    6
    7
    print(round(3.56))
    结果:
    4
    print(round(3.56,1))
    结果:
    3.6
    后边的参数是指定小数点后边的数字进行四舍五入,咱们指定的数字要小于咱们小时候点后边的位数

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

    1
    2
    3
    4
    5
    6
    7
    print(pow(2,4))
    结果:
    16
    print(pow(2,4,3))
    结果:
    1
    三个参数 前来个参数是求2的3次幂,第三个参数是这个总和去除3然后获取的是余数

    　　sum() 求和

    1
    2
    3
    4
    5
    6
    7
    8
    print(sum([1,2,3,4,5]))
    结果:
    15   参数必须是可迭代对象
    　　min() 求最小值
     
    print(min([1,2,3,4,5]))
    结果:
    1    参数必须是可迭代对象

    　　max() 求最大值

    1
    2
    3
    print(max([1,2,3,4,5]))
    结果:
    5    参数必须是可迭代对象

    数据结构相关

    列表和元祖

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

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

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

    1
    2
    3
    print(list(reversed('你好啊')))
    结果:
    ['啊', '好', '你']

    字符串相关:

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

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

    字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 字符串
    # print(format('meet','<20'))   #左对齐
    # print(format('meet','>20'))   #右对齐
    # print(format('meet','^20'))   #居中
    ​
    结果:
    meet               
                    meet
            meet

    数值 自己练习

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #数值
    print(format(3,'b'))    # 二进制
    print(format(97,'c'))   # 转换成unicodezif
    print(format(11,'d'))   #十进制
    print(format(56))       #和d一样
    print(format(11,'n'))   #十进制
    print(format(11,'o'))   #八进制
    ​
    print(format(11,'x'))  # 十六进制(小写字母)
    print(format(11,'X'))  # 十六进制(大写字母)
    ​
    # 浮点数
    ​
    print(format(1234567890,'e'))  #科学计算法,默认使用6位
    print(format(123456789,'0.2e'))# 科学计算,保留2位小数(小写)
    print(format(123456789,'0.2E'))# 科学计算,保留2位小数(大写)
    print(format(1.23456789,'f')) #小数点计数法,保留6位小数
    print(format(1.23456789,'0.2f')) # 小数点计数法,保留2位数
    print(format(1.23456789,'0.10f')) # 小数点计数法,保留2位数
    print(format(1.23456789e+1000,'F')) # 小数点计数法

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    s = '你好武大'
    ​
    bs = s.encode('utf-8')
    print(bs)
    ​
    结果:b'xe4xbdxa0xe5xa5xbdxe6xadxa6xe5xa4xa7'
    ​
    s1 = bs.decode('utf-8')
    print(s1)
    ​
    结果: 你好武大
    ​
    bs = bytes(s,encoding='utf-8')
    print(bs)
    ​
    结果: b'xe4xbdxa0xe5xa5xbdxe6xadxa6xe5xa4xa7'
    把字符串编码成utf-8

    bytearray() 返回一个新字节数组,每个元素的值的范围是0~256对应的是ascii码表

    1
    2
    3
    4
    5
    6
    7
    ret = bytearray('meet',encoding='utf-8')
    print(ret)
    print(ret[0])
    ​
    结果:
    bytearray(b'meet')
    109

    memoryview() 查看bytes的内存地址

    1
    2
    3
    4
    5
    s = memoryview('麻花藤'.encode('utf-8'))
    print(s)
    ​
    # 结果:
    # <memory at 0x000001F332E0E288>

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    print(ord('a'))
    print(ord('中'))
    print(ord('国'))
    ​
    结果:
    97
    20013
    22269
    ​
    对应的是当前编码　

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

    1
    2
    3
    4
    5
    6
    print(chr(97))  # 找到对应位置的字符
    print(chr(20013))  # 找到对应位置的字符
    ​
    # 结果:
    a
    中

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

    1
    2
    3
    4
    5
    6
    print(ascii('a'))  判断字符串在不在ascii码表中
    print(ascii('中')) 
    ​
    结果:
    'a'
    'u4e2d'     如果不存在就返回u...

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    name = 'alex'
    print(repr(name))   #返回这个对象本质的表示形式
    ​
    结果:
    'alex'
    ​
    name = '我叫%r'
    print(name%'meet')   %r 用的就是repr
    结果:
    我叫'meet'

    数据集合

    　　dict() 创建一个字典

    1
    2
    3
    4
    d = dict(k='v',key1='v2')
    print(d)
    结果:
    {'k': 'v', 'key1': 'v2'}

    　　set() 创建一个集合

    1
    2
    3
    4
    s = set([1,2,4,5,6])
    print(s)
    结果:
    {1, 2, 4, 5, 6}

    其他相关

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

    　　enumerate() 获取枚举对象

    1
    2
    3
    4
    5
    lst = ['alex','wusir','taibai']
    ​
    for i,k in enumerate(lst):
        print('这是序号',i)
        print('这是元素',k)

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    lst = [1,2,3,4,True,0,False]
    lst1 = [1,2,3,4,True]
    print(all(lst))
    ​
    print(all(lst1))
    ​
    结果:
    False
    True

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    lst = [1,2,3,4,True,0,False]
    lst1 = [1,2,3,4,True]
    print(any(lst))
    ​
    print(any(lst1))
    ​
    结果:
    False
    True

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    lst1 = [1,2,3]
    lst2 = ['a','b','c','d']
    lst3 = (11,12,13,14,15)
    ​
    for i in zip(lst1,lst2,lst3):
        print(i)
    ​
    结果:
    (1, 'a', 11)
    (2, 'b', 12)
    (3, 'c', 13)　

    lambda

    匿名函数,为了解决一些简单的需求而设计的一句话函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    def func(n):
        return n**n
    print(func(4))
      
    f = lambda x: x**x
    print(f(4))
      
    结果:
    256
    256

    lambda表示的是匿名函数,不需要用def来声明,一句话就可以声明出一个函数

    语法:

    　　函数名 = lambda 参数:返回值

    注意:

    　　1.函数的参数可以有多个,多个参数之间用逗号隔开

    　　2.匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

    　　3.返回值和正常的函数一样,可以是任意数据类型,但是只能一个,不能返回多个.

    匿名函数并不是说一定没有名字,这里前面的变量就是一个函数名,说他是匿名原因是我们通过

    name查看的时候是没有名字的.统一都叫做lambda.在调用的时候没有什么特别之处

    像正常的函数调用既可

    sorted

    排序函数

    语法:sorted(iterable,key=None,reverse=False)

    iterable : 可迭代对象

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    lst = [1,3,2,5,4]
    lst2 = sorted(lst)
    print(lst)    #原列表不会改变
    print(lst2)   #返回的新列表是经过排序的
      
      
    lst3 = sorted(lst,reverse=True)
    print(lst3)   #倒叙
      
    结果:
    [1, 3, 2, 5, 4]
    [1, 2, 3, 4, 5]
    [5, 4, 3, 2, 1]

    字典使用sorted排序

    1
    2
    3
    4
    5
    dic = {1:'a',3:'c',2:'b'}
    print(sorted(dic))   # 字典排序返回的就是排序后的key
      
    结果:
    [1,2,3]

    和函数组合使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # 定义一个列表,然后根据一元素的长度排序
    lst = ['天龙八部','西游记','红楼梦','三国演义']
      
    # 计算字符串的长度
    def func(s):
        return len(s)
    print(sorted(lst,key=func))
      
    # 结果:
    # ['西游记', '红楼梦', '天龙八部', '三国演义']

    和lambda组合使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    lst = ['天龙八部','西游记','红楼梦','三国演义']
      
    print(sorted(lst,key=lambda s:len(s)))
      
    结果:
    ['西游记', '红楼梦', '天龙八部', '三国演义']
      
      
    lst = [{'id':1,'name':'alex','age':18},
        {'id':2,'name':'wusir','age':17},
        {'id':3,'name':'taibai','age':16},]
      
    # 按照年龄对学生信息进行排序
      
    print(sorted(lst,key=lambda e:e['age']))
      
    结果:
    [{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

    filter

    筛选过滤

    语法: filter(function,iterable)

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

    iterable:可迭代对象

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    lst = [{'id':1,'name':'alex','age':18},
            {'id':1,'name':'wusir','age':17},
            {'id':1,'name':'taibai','age':16},]
      
    ls = filter(lambda e:e['age'] > 16,lst)
      
    print(list(ls))
      
    结果:
    [{'id': 1, 'name': 'alex', 'age': 18},
     {'id': 1, 'name': 'wusir', 'age': 17}]

    map

    映射函数

    语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

    计算列表中每个元素的平方,返回新列表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    lst = [1,2,3,4,5]
     
    def func(s):
     
        return  s*s
     
    mp = map(func,lst)
     
    print(mp)
     
    print(list(mp))

    改写成lambda

    1
    2
    3
    lst = [1,2,3,4,5]
     
    print(list(map(lambda s:s*s,lst)))

    计算两个列表中相同位置的数据的和

    1
    2
    3
    4
    5
    6
    7
    8
    9
    lst1 = [1, 2, 3, 4, 5]
     
    lst2 = [2, 4, 6, 8, 10]
     
    print(list(map(lambda x, y: x+y, lst1, lst2)))
     
    结果:
     
    [3, 6, 9, 12, 15]

    reduce

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    from functools import reduce
    def func(x,y):
        return x + y
     
    # reduce 的使用方式:
    # reduce(函数名,可迭代对象)  # 这两个参数必须都要有,缺一个不行
     
    ret = reduce(func,[3,4,5,6,7])
    print(ret)  # 结果 25
    reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
    接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
    临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
     
    注意:我们放进去的可迭代对象没有更改
    以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
    普通函数版
    from functools import reduce
     
    def func(x,y):
     
        return x * 10 + y
        # 第一次的时候 x是1 y是2  x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
        # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
        # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
     
    l = reduce(func,[1,2,3,4])
    print(l)
     
     
    匿名函数版
    l = reduce(lambda x,y:x*10+y,[1,2,3,4])
    print(l)

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

    龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce

    最后lambda没删除是因为和一个人写信写了好多封,进行交流然后把lambda保住了.

    参考资料:

    https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac

    递归

    在函数中调用函数本身,就是递归

    1
    2
    3
    4
    5
    6
    7
    def func():
     
        print('我是谁')
     
        func()
     
    func()

    在python中递归的深度最大到998

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def func(n):
     
        print(n)
     
        n+=1
     
        func(n)
     
    func(1)

    官方文档表示最大递归深度是1000

    1
    2
    3
    but in 2.0 the maximum recursion depth can be read and modified using sys.getrecursionlimit()
     
    and sys.setrecursionlimit(). The default value is 1000

    递归的应用:

    　　我们可以使用递归来遍历各种树形结构,比如我们的文件夹系统.可以使用递归来遍历该文件夹中的所有文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    import os
     
    def read(filepath, n):
     
        files = os.listdir(filepath) # 获取到当前⽂件夹中的所有⽂件
     
        for fi in files: # 遍历⽂件夹中的⽂件, 这⾥获取的只是本层⽂件名
     
            fi_d = os.path.join(filepath,fi) # 加⼊⽂件夹 获取到⽂件夹+⽂件
     
            if os.path.isdir(fi_d): # 如果该路径下的⽂件是⽂件夹
     
                print(" "*n, fi)
     
                read(fi_d, n+1) # 继续进⾏相同的操作
     
            else:
     
                print(" "*n, fi) # 递归出⼝. 最终在这⾥隐含着return
     
    #递归遍历⽬录下所有⽂件
     
    read('../python_s14/', 0)
  • 相关阅读:
    设计模式（六）—原型模式Prototype（创建型）
    hdu_2039_三角形_解题报告
    古代赌局 俗话说：十赌九输。因为大多数赌局的背后都藏有阴谋。不过也不尽然，有些赌局背后藏有的是：“阳谋”。 有一种赌局是这样的：桌子上放六个匣子，编号是1至6。多位参与者（以下称玩家）可以把
    读《Boost程序库完全开发指南》
    使用HttpSessionListener接口监听Session的创建和失效
    HDU2317：Nasty Hacks
    意淫的需求要不得
    enumerate(s)与range(len(s))的作用是相同
    一种数据展示方式，UI设计新颖，供大家参考(源码部分) (demo已经上传)
    RMAN Compressed Backupset
  • 原文地址：https://www.cnblogs.com/huhuxixi/p/10267222.html
Copyright © 2011-2022 走看看