• 内置函数和匿名函数


     内置函数的思维导图https://www.processon.com/view/5bdbfba6e4b0e452133837a3#map

    内置函数:python自带的函数

    作用域相关

    基于字典的形式获取局部变量全局变量

    globals()——获取全局变量字典

    • any() 

    如果所有元素中有一个值非0、''或False,那么结果就为True,当iterable所有的值都是0、''或False时,那么结果为False

    •  ascii()  

    调用对象的__repr__()方法,获得该方法的返回值.

    • bool()  

    测试一个对象是True还是False.

    •  bytes()  

    将一个字符串转换成字节类型

    • callable(object)

    callable()函数用于测试对象是否可调用,如果可以则返回1(真);否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了 调用 方法的类实例。

    • chr(i)

    chr()函数返回ASCII码对应的字符串。

    • complex(real[,imaginary])

    complex()函数可把字符串或数字转换为复数。

    • delattr()  

    删除对象的属性

    • dict()  

    创建数据字典

    • dir()  

    不带参数时返回当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性,方法列表

    • divmod(x,y)

    divmod(x,y)函数完成除法运算,返回商和余数。

    • enumerate()  

    返回一个可以枚举的对象,该对象的next()方法将返回一个元组

    • eval()  

    将字符串str当成有效的表达式来求值并返回计算结果

    s = "1 + 3 +5"
    print(eval(s))  #9
    • exec()  

    执行字符串或complie方法编译过的字符串,没有返回值

    • float(x)

    float()函数把一个数字或字符串转换成浮点数。

    print(float("12"))  #12.0
    • format()  

    格式化输出字符串

    print("i am {0},age{1}".format("tom",18))
    i am tom,age18
    • frozenset()  

    创建一个不可修改的集合

           setfrozenset最本质的区别是前者是可变的,后者是不可变的。当集合对象会被改变时(例如删除,添加元素),只能使用set

           一般来说使用fronzet的地方都可以使用set

           参数iterable:可迭代对象。

    • hex(x)

    hex()函数可把整数转换成十六进制数。

    locals()——获取执行本方法所在命名空间内的局部变量字典

    复制代码
    def func():
        a = 1
        b = 2
        print(locals())     
        print(globals())    #始终不变
      func(){'b': 2, 'a': 1}

      {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at       0x00  000  226639E59E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__   '_  _cac  hed__': No  ne, 'func': <function func at 0x0000022663AB89D8>}

    复制代码

    其他

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

    print(eval('1+2+3+4'))    #10

     

     s.upper()全大写,全小写s.lower()全小写

    s.swapcase()大小写翻转

    s.title()每个隔开(特殊字符或者数字)的单词首字母大写
    s.center(20,'~')居中

    s6 = s.expandtabs()空白填充

    以什么开头s.startswith('alex')startswith('e',2,5)结尾endswith

    strip 默认删除前后空格

    split   str ---->list  s.split('a)以a分割符

    find 通过元素找索引,找不到返回-1 s = 'alexWUsir' s.find('A')
    index通过元素找索引,找不到报错

    增加 append insert
    元祖 只读列表,可循环查询,可切片。
    儿子不能改,孙子可能可以改。
    list.reverse()
    反向列表中元素

    数据类型划分:可变数据类型,不可变数据类型
    不可变数据类型:元组,bool int str 可哈希
    可变数据类型:list,dict set 不可哈希
    dict key 必须是不可变数据类型,可哈希,
    value:任意数据类型。
    dict 优点:二分查找去查询
    存储大量的关系型数据
    特点:无序的

    # 操作文件
    # 读
    # read 一次性读
    # readlines 一次性读
    # readline 一行一行读
    #不知道在哪儿结束
    #视频 图片 rb bytes 按照字节读
    # for循环 —— 最好!!!
    # 写
    # write
    # 光标 —— 文件指针
    #seek _ 指定光标移动到某个位置
    #tell _ 获取光标当前的位置
    #truncate _ 截取文件
    # 关闭文件
    #close
    rename()方法需要两个参数,当前的文件名和新文件名。
    remove()方法删除文件,需要提供要删除的文件名作为参数

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

    print(exec("1+2+3+4"))    #没有返回值,结果None
    exec("print('hello,world')")  #hello,world

    compile  将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

    参数说明:   

    1. 参数source:字符串或者AST(Abstract Syntax Trees)对象。即需要动态执行的代码段。  

    2. 参数 filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时,filename参数传入空字符即可。  

    3. 参数model:指定编译代码的种类,可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时,model应指定为‘exec’;当source中只包含一个简单的求值表达式,model应指定为‘eval’;当source中包含了交互式命令语句,model应指定为'single'。

    exec("print('12345')")  #12345
    eval("print('12345')")  #12345
    print(exec('1+2+3-4'))  #None
    print(eval('1+2+3-4'))  #2
    code1 = 'for i in range(0,10): print (i)'
    compile1 = compile(code1,'','exec')
    exec(compile1)        #0 1 2 3 4 5 6 7 8 9
    #简单求值表达式用eval
    code2 = '1 + 2 + 3 + 4'
    compile2 = compile(code2,'','eval')
    print(eval(compile2))
    code3 = 'name = input("please input your name:")'
    compile3 = compile(code3,'','single')
    # # name #执行前name变量不存在
    exec(compile3)
    print(name)    #name在pycharm里飘红,但是可以执行please input your name:

    range#可迭代对象,可以for循环,惰性运算

    复制代码
    # range(100)  #[0,100)
    # range(5,100) #[5,100)
    # range(1,100,2)
    #可迭代对象,可以for循环,惰性运算
    # def iter():    #定义迭代器
    #     return range(100).__iter__()
    
    iterator = iter(range(100))  #拿到一个迭代器
    print(iterator.__next__())   #0    
    print(next(iterator))      #1
    
    for i in range(100):
        print(i)        #for循环迭代每一个元素
    复制代码

    dir查看参数所属类型的所有内置方法

    dir() 默认查看全局空间内的属性,也接受一个参数,查看这个参数内的方法或变量

    print(dir(list))  #查看列表的内置方法
    print(dir(int))  #查看整数的内置方法

    callable

    和调用相关

    callable(o),o是参数,看这个变量是不是可调用。

    如果o是一个函数名,就会返回True

    a = 1
    def func():pass
    print(callable(a))      #不可以调用
    print(callable(print))  #可以调用
    print(callable(func))   #可以调用

    查看关键字用法

    ctrl + 左键单击 :pycharm
    help:包含所有方法名以及他的使用方法 —— 不知道用法的情况下

    在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入quit退出

    
    

    或者直接执行help(o),o是参数,查看和变量o有关的操作


    dir:只包含方法名 —— 想查看某方法是否在这个数据类型中

    import 引用模块
    import time   #时间
    import os #操作系统

    open()  打开一个文件,返回一个文件操作符

    操作文件的模式有r,w,a,rb,wb,ab

    可以用encoding指定编码.utf-8,gbk

    f = open('文件名','w',encoding='utf-8')
    input输入,输入内容是字符串
    s = input("请输入内容 : ") 
    print(s)  

    print输出打印

    复制代码
    print(self, *args, sep=' ', end='
    ', file=None):
        """
        print(value, ..., sep=' ', end='
    ', file=sys.stdout, flush=False)
        file:  默认是输出到屏幕,如果设置为文件句柄,输出到文件
        sep:   打印多个值之间的分隔符,默认为空格
        end:   每一次打印的结尾,默认为换行符
        flush: 立即把内容输出到流文件,不作缓存
        """
    复制代码
    f = open('tmp_file','w')
    print(123,456,sep=',',file = f,flush=True)
    复制代码
    ##打印进度条
    import time for i in range(0,101,2): time.sleep(0.2) char_num = i//2 #打印多少个'*' per_str = ' %s%% : %s ' % (i, '*' * char_num) if i == 100 else ' %s%% : %s'%(i,'*'*char_num) print(per_str,end='', flush=True) # 可以把光标移动到行首但不换行
    复制代码



    type(o)返回变量o的数据类型


    id(o)返回变量o的内存地址
    hash(o)返回一个可hash变量的哈希值,不可hash的变量被hash之后会报错
    t = (1,2,3)
    l = [1,2,3]
    print(hash(t))  #可hash
    print(hash(l))  #会报错

    hash函数会根据一个内部的算法对当前可hash变量进行处理,返回一个int数字。

    *每一次执行程序,内容相同的变量hash值在这一次执行过程中不会发生改变。多次执行,对同一个值的hash结果可能改变

     
    数字相关

    数字——数据类型相关:bool(布尔型),int(整型),float(浮点型),complex(复数),一般用于强转类型

        进制转换相关:bin(二进制),oct八进制(),hex(十六进制),一般用于强转类型

        数学运算:abs(绝对值),divmod(取商和余),min(最小值),max(最大值),sum(求和),round(取几位小数),pow(幂运算)

    abs 取绝对值
    print(abs(-5))  #5
    
    

    divmod 取商余

    ret = divmod(10,2)  
    print(ret)  #(5, 0)
    ret = divmod(3,2) 
    print(ret)  #(1, 1)
    ret = divmod(7,2) 
    print(ret)  #(3,1)

    round 取几位小数

    
    
    print(round(3.14159,2))  #取小数位数,后面的2表示去几位小数,结果为3.14
    
    

    pow 幂运算

    print(pow(2,3.5))  #可以是小数,结果11.313708498984761
    print(pow(3,2))  #9print(pow(2,3,3))  #x**y%z结果2

    sum 求和,接收一个可迭代对象

    print(sum([1,2,3,4,5,6],-2))  #后面的-2同样和前面的相加,结果为19  
    print(sum(range(100)))  #4950

    min 最小值

    print(min([1,-4,0,9,6]))  #-4
    print(min([],default=0))  #取默认值0
    print(min([-9,1,23,5],key=abs))  #匿名函数,序列里先经过后面的函数运算再比较,结果为1
    print(min({'z':1,'a':2}))  #比较字典键的大小,结果为a

    max 最大值

    t = (-25,1,3,6,8)
    print(max(t))  #8
    print(max(t,key = abs))  #-25
    print(max((),default=100))  #100
    数据结构相关

    序列:list,tuple,str,format,bytes,bytearry,memoryview,ord,chr,ascii,repr

    
    
    复制代码
    ret = bytearray('alex',encoding='utf-8')  #对比较长的字符串做修改的时候,指定某一处进行修改,不会改变这个bytearry的内存地址
    print(id(ret))  #2235695791048
    print(ret[0])  #97,a的asii码
    ret[0] = 65
    print(ret)   #bytearray(b'Alex'),小写a变大写A
    print(id(ret))  #2235695791048,内存不变
    复制代码
    
    
    ret = memoryview(bytes('你好',encoding='utf-8'))
    print(len(ret))  #6
    print(bytes(ret[:3]).decode('utf-8'))  #你
    print(bytes(ret[3:]).decode('utf-8'))  #好

    reversed反转

    l = [3,4,2,5,7,1,5]       
    ret = reversed(l)
    print(ret)  # <list_reverseiterator object at 0x000001EFDFF27BA8>
    print(list(ret))  #[5, 1, 7, 5, 2, 4, 3]
    l.reverse()
    print(l)  #[5, 1, 7, 5, 2, 4, 3]

    slice 实现了切片的函数

    l = (1,2,23,213,5612,342,43)
    sli = slice(1,5,2)   #实现了切片的函数
    print(l[sli])  #(2, 213)
    
    #l[1:5:2]  语法糖
    format
    复制代码
    print(format('test', '<20'))#20个字符,test左对齐
    print(format('test', '>20'))#20个字符,test右对齐
    print(format('test', '^20'))#20个字符,test居中

    结果:

    test               
                    test
            test

    复制代码
    
    

    bytes

    #网络编程的时候:能在网络上传递的必须是字节
    ret = bytes('你好,哈哈哈,再见',encoding='utf-8')
    #中间是网络传输的过程
    print(ret.decode(encoding='utf-8'))  #你好,哈哈哈,再见

    ord

    print(ord('a'))  #97

    chr

    print(chr(97))  #a

    ascii

    
    
    print(ascii(97))  #97
    print(ascii('a')  #'a',原内容输出字符,a带引号
    repr
    print(repr(1))  #1
    print(repr('1'))  #'1'
    print(repr('name : %r'%('金老板')))  #'name : '金老板'',整体带引号

    enumerate枚举

    复制代码
    l = ['笔记本','phone','apple','banana']
    for i,j in enumerate(l,1):
        print(i,j)
    输出

    1 笔记本
    2 phone
    3 apple
    4 banana

    复制代码

    all只要有一个布尔值为False的内容,结果就为False,否则为True

    any只要有一个布尔值为True的内容,结果就为True,否则为False

    复制代码
    print(all([1,2,3,4,0]))  #F
    print(all([1,2,3,4]))  #T
    print(all([1,2,3,None]))  #F
    print(all([1,2,3,'']))  #F
    
    print(any([1,None,False]))  #T
    print(any([False,None,False]))  #F
    复制代码

    zip 拉链函数

    print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))

    结果[(0, 5, 'a'), (1, 6, 'b')]
    filter过滤函数
    def is_odd(x):
        if x>10:
            return True
    ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
    print(list(ret))  #[12, 17]
    
    
    复制代码
    #filter就是有一个可迭代对象,想要一个新的内容集,是从原可迭代对象中筛选出来的
    def func(x):
        #return x.strip()    #‘   ’.strip() ==> '' ==> return False
                             # 'test'.strip() ==> 'test'
        return x and x.strip() #None  False and
    #去掉所有的空内容和字符串中的空格
    l = ['test', None, '', 'str', '  ', 'END']
    ret = filter(func,l)
    print(list(ret))
    #新内容少于等于原内容的时候,才能用到filter
    复制代码

    map

    ret = map(abs,[-1,-5,6,-7])   #abs(-1) = 1   abs(-5) = 5
    print(list(ret))  #[1, 5, 6, 7]
    filter和map
    参数很相近:都是一个函数名+可迭代对象
    且返回值很相近:都是返回可迭代对象
    区别:
    filter是做筛选的,结果还是原来就在可迭代对象中的项
    map是对可迭代对象中的每一项做操作的,结果不一定是原来就在可迭代对象中的项
    
    
    有一个list, L = [1,2,3,4,5,6,7,8],我们要将f(x)=x^2作用于这个list上,那么我们可以使用map函数处理
    
    
    def func(x):
        return x*x
    ret = map(func,[1,2,3,4,5,6,7,8])
    print(list(ret))  #[1, 4, 9, 16, 25, 36, 49, 64]
    
    

    sorted排序

    对List、Dict进行排序,Python提供了两个方法
    对给定的List L进行排序,
    方法1.用List的成员函数sort进行排序,直接修改原列表顺序,节省内存
    方法2.用内置函数sorted进行排序,生成新列表,原列表不变

    复制代码
    print(sorted([-5,3,-4,2,-1],reverse=True))  #[3, 2, -1, -4, -5],reverse=True默认从大打小排序
    print(sorted([-5,3,-4,2,-1],key=abs))  #[-1, 2, 3, -4, -5],按绝对值大小排序(原列表元素不变)
    
    l2 = ['ajkhs',(1,2),'a',[1,2,3,4]]  
    print(sorted(l2,key=len,reverse=True))  #['ajkhs', [1, 2, 3, 4], (1, 2), 'a'],按元素长度排序
    复制代码
    匿名函数

    lambda表达式

    
    
    复制代码
    def calc(n):
        return n**n
    print(calc(10))
     
    #换成匿名函数
    calc = lambda n:n**n
    print(calc(10))
    复制代码
    
    
    复制代码
    dic={'k1':10,'k2':100,'k3':30}
    print(max(dic.values()))  #找出字典中最大的值
    print(max(dic))  #找出字典中最大的键
    print(max(dic,key=lambda k:dic[k]))  #找出字典中值最大的键
    结果:

      100
      k3
      k2

    复制代码
    #找出序列中大于10的数
    ret = filter(lambda num:num>10,[1,4,6,823,67,23]) print(list(ret))  
    #也可以下面这样写 ret = filter(lambda num:True if num>10 else False,[1,4,6,823,67,23]) print(list(ret))

    一、数学运算类

    1,abs(x)求绝对值参数可以是整型,也可以是复数

    2,divmod(a, b)分别取商和余数,整型、浮点型都可以

    3,pow(x, y)x的y次幂

    4,round(x, n)小数四舍五入

    5,sum(iterable)求和

    6,int转为int类型

    7,bool转为bool类型

    8,float转为float类型

    二、序列操作

    1,enumerate返回一个可枚举的对象,该对象的next()方法将返回一个tuple

    2,max(iterable[args][key])返回最大值

    3,min(iterable[args][key])返回最小值

    4,sorted(iterable,key,reverse)对序列排序

    5,reversed反转

    三,判断类

    1,all集合中的元素都为真的时候为真

    2,any集合中的元素有一个为真的时候为真

    3,callable检查对象是否可调用

    4,dir返回方法或者参数的属性

    四,字符串类

    1,bytes

    2,eval将字符串类型的代码执行并返回结果

    3,exec将自字符串类型的代码执行

    4,compile将字符串类型的代码编译

    5,len返回集合长度

    五,函数类

    1,filter过滤函数

    2,map遍历每个元素,执行function操作

    3,zip拉链函数

    4,repr用于%r格式化输出

    5,range(start, stop, step]) 产生一个可跌代对象,默认从0开始

    六,其他

    1,input输入

    2,print输出

    3,hash返回一个可哈希值

    4,open打开文件

    5,import引用模块

    带key值的函数,key=func

    min()

    max()

    sorted()

  • 相关阅读:
    工作中遇到的令人头疼的bug
    Cookie的简单用法
    C#之#if #endif的简单用法
    我们一起学习WCF 第十篇Wcf中实现事务
    一次性搞定Session
    设计模式-观察者模式
    类的扩展之 DataReader的扩展
    C#之Ref,Out以及TryParse()的用法
    C#之Lambda不得不说的用法
    C#之Action和Func的用法
  • 原文地址:https://www.cnblogs.com/xyhh/p/10833611.html
Copyright © 2020-2023  润新知