内置函数大总结

Posted 2020-10-14

一层内置函数 >>>>二层基础数据类型>>>>三层和数字相关14个
四层数据类型4个
1 布尔值 ***bool
只有True 和False，并且首字母必须是大写。
True:  1 int（非0），    2 str(非‘‘)      非空： True

False: 1 int（0）,        2  str(‘‘)       空： 0，“”，{}，[],（），set（）

2  数字 ***int
    int 应用于 ：+ ，- ，* ，/ ，** ，% ，

    例：int1 = 2  int2 = 12
        int3 = int1 + int2
        int3 = int1 - int2
        int3 = int1 * int2
        int3 = int1 / int2

3 浮点数（小数）***float
    特点： 在取值中 会取值一定的位数

    print(float (1.343))
    a= 3.141592653123456789
    print(a)
    3.141592653123457
    保留15，16位小数 且最后一位是四舍五入 不太理解

4  复数 complex
    复数由     a + bj : 实部和虚部组成
    实数 ：1
    虚部：j -1的平方
    3+ 4j <  5 +2j  错误  复数不能比较

四层 进制转换3个
print(bin(20))
print(oct(20))
print(hex(20))
0b10100
0o24
0x14

1 二进制 bin()
0b10100

2 八进制 oct()
0o24

3 十六进制 hex()
0x14

四层 数学运算 7个

1 计算绝对值  **abs()
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)
print(l2)

2 返回取（商，余）  **divmod()
ret = divmod(8,3)
ret1 =divmod (8,2)
print(ret)
print(ret1)
(2,2)
(4,0)

3 小数精确  **round(x,n)n为保留小数 具有四舍五入的应用
print(round(2.12133112,2))
2.12
print(round(2.12733112,2))
2.13

4 幂运算  **pow()
(x,n)  x**n
(x,n,y)  x**n\\y 取商余数 和divmod 比较直接输出余数
  >>> 分2种情况
    print(pow(2,3))
    print(pow(2,3,4))
    print(pow(2,3,3))
    8
    0
    2

    1 pow(x,y)    x**y
    2pow(x,y,z)   x**y%z

5 求和  sum(iterable,start) ***
    iterable参数必须是一个可迭代数字集
    start指出求和的初始值。start+iterable中的值为最终的和
    print(sum([1,2,3]))
    print(sum([1,2,3],2))         2 为初始值
    # print(sum([1,2,3],[3,4]))  打印报错 因为([1,2,3],[3,4])不是可迭代对象
    print(sum(range(100)))
    6
    8
    4950
6 计算最小值min（）
    >>>>分2种情况
    字母比较也是一样的 a<b<c
    1 min(iterable,key,default)

    a min({1,2,3,4,-5})
    print(min({1,2,3,4,-5}))
    1-5

    b min({},1)    不理解

    c min({1,2,3,4,5},key=lambda n:abs(n))
        print( min({1,2,3,4,5},key=lambda n:abs(n)))
        1
        print(min({1, 2, 3, 4, -5}, key=abs))
        1
插入小知识  lambda  是匿名函数的关键字相当于def
固定格式  函数名 = lambda 参数（n）：返回值n**n(n的条件)
                print(函数名（参数的值n）)
    a和b 是一样的
  a def add(x,y):
        return x +y
    print(add(1,2))
  b add=lambda x,y: x+y
    print(add(1,2))

    2 min(*args,key,defult)


6 计算最大值max（）
    字母比较也是一样的 a<b<c
>>>>分2种情况
    1 max(iterable,key,defult)
    dic = {‘k1‘:10,‘k2‘:100,‘k3‘:30}
    print(max(dic))
    k3  因为此时比较的是ascii 码的大小
    lis = [1,3,6,-22]
    print(max(lis ,key=lambda k :k))
    print(max(lis ,key=abs))
    6
    -22
    2max(*args,key,defult)

    dic = {‘k1‘: 10, ‘k2‘: 100, ‘k3‘: 30}
    print(max(dic, key=lambda k: dic[k]))
    k2
    条件是dic[k]
    值最大的键
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>列表和元祖2个
1 列表 ***list

    增加

    1append
    增加到最后一个列表
    li = [1, 3, 4, ‘wang‘, ]
    li.append(‘wangyan‘)
    print(li)
    [1, 3, 4, ‘wang‘, ‘wangyan‘]

    2insert
    插入，   xx.insert(3)表示列表里第2位插入，此处是内容)

    li = [1, 3, 4, ‘wang‘, ]
    li.insert(3, ‘wangyan‘)
    print(li)
    [1, 3, 4, ‘wang‘,‘wangyan’]
    li = [1, 3, 4, ‘wang‘, ]

    3  # extend 迭代的添加 添加的元素分开了叠加，也就是extend后如果是字符串（‘ABC’）后边则是‘A‘, ‘B‘, ‘C‘,如果后边是[]
    li = [1, 3, 4, ‘wang‘, ]
    li.extend([1, 2, 3, ‘www‘])
    print(li)
    [1, 3, 4, ‘wang‘, 1, 2, 3, ‘www‘]

    li.extend([1, 2, 3, ‘www‘])
    则变成[1, 2, 3, ‘www‘]
    li = [1, 3, 4, ‘wang‘, ]
    li.extend(‘luodan‘)
    print(li)
    [1, 3, 4, ‘wang‘, ‘l‘, ‘u‘, ‘o‘, ‘d‘, ‘a‘, ‘n‘]

    二删除  #
    1pop
    按照索引去删除，有返回值，
    此时注意压栈思想
    和insert用法类似
    。pop(索引对应的值，数字是多少就是列表的数字的N - 1)删除那个

    li = [1, 3, 4, ‘wang‘, ]
    li.pop(3)
    print(li)[1, 3, 4]

    2remove
    按照元素去删除说白了就是删除名字就行
    例如1‘wang‘

    li = [1, 3, 4, ‘wang‘, ]
    li.remove(‘wang‘)
    print(li)[1, 3, 4]

    3clear
    列空列表结果[]
    li = [1, 3, 4, ‘wang‘, ]
    li.clear()
    print(li)

    4del 用法和正常的键盘删除基本几样
    区别.pop.remove.clear
    直接del[]   删除列里面切片  取值在删除

    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    del li[3:6:2]
    print(li)
    [1, 3, 4, ‘True‘, ‘yy‘]

    三改
    先切片 在删除 在改正

    1
    字符串的
    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    li[1:4] = ‘宝宝‘
    print(li)
    [1, ‘宝‘, ‘宝‘, ‘True‘, 33, ‘yy‘]
    切片后先删除
    4 ‘wang’  变为2位 ‘宝’宝 ‘宝’ 并且迭加

    2，后边的是列表[]
    取片删除后进行在删除的位置合并
    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    li[1:3] = [‘ad‘, ‘efe‘, ‘eded‘, ‘wian‘]
    print(li)
    [1, ‘ad‘, ‘efe‘, ‘eded‘, ‘wian‘, ‘wang‘, ‘True‘, 33, ‘yy‘]

    四查 切片 查看
    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    print(li[3:6])
    [‘wang‘, ‘True‘, 33]

    li = [1, 3, 4, ‘wang‘, ‘True‘, 33, ‘yy‘]
    del li
    print(li)
    结果为空的

    打印长度
    li = [1, ‘dfs‘, 23, 87]
    print(len(li))

2 元祖*** tuple
    元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。
    例：（1，2，3）（"a","b","c"）
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>相关内置函数2个
    1 反转 **reversed()   迭代器的
                recersed()  迭代器   1 新生成一个列表不改变原列表 2 有返回值还是一个迭代器
                                2还有个是就是强转的list(ret)
                reserse()  反转   1 不会生成一个列表改变原来的列表 2  返回值是Npne

    l = [1, 3, 5, 4, 2, 7]
    ret = reversed(l)
    print(ret)
    print(list(ret))
    <list_reverseiterator object at 0x02B6A370>  迭代器
    [7, 2, 4, 5, 3, 1]

    l = [1, 3, 5, 4, 2, 7]
    l.reverse()
    print(l)
    [7, 2, 4, 5, 3, 1]
    拓展 sort（） 是从小到大排序
    sort() reversed()

    li = [1,3,5,6,4,2]
    li.sort()
    print(li)

    li.reverse()
    print(li)
    [2, 4, 6, 5, 3, 1] 列表反转

    li = [2, 4, 6, 5, 3, 1]
    li .sort(reverse = True)
    print(li)
    [6, 5, 4, 3, 2, 1]  列表倒序

2 slice 切片  转成元祖
    l = (1,2,23,213,5612,342,43)
    sli = slice(1,5,2)
    print(l[sli]）
    (2, 213)

一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>字符串9个
    1 字符串***str
    a 带引号的都是字符串    三引号 可以跨行
    name = ‘郭鹏达‘name2 = "王岩"
    例：  msg = ‘‘‘

         字符串

    ‘‘
    b 字符串拼接。 字符串加法和乘法。 S1 = ‘abc’  s2 = ‘123’  print(s1 + s2)  ‘abc123’
    2 .format()  
         大括号内是改变输出前的内容  大括号内空 和。format() 一一对应
    li = [‘alex‘,‘eric‘,‘rain‘]
    # # 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
    
    info = "{}_{}_{}".format(li[0],li[1],li[2])
    print(info)
    
    #第一种： 大括号内是改变输出前的内容  大括号内空 和。format() 一一对应
    ret18 = ‘name :{},sex:{},hig:{}‘.format("王岩","男",174)
    print(ret18)
    name :王岩,sex:男,hig:174
    
    3 字节 *** bytes 
        1 acsic码   基本不用    不同编码之间互用会产生乱码，
        2 unicode  　　　  A 字母  4个字节   00000000 00000000 00100100 01000000
    　　　　　　　　           中 文    4个字节    00000000 00000000 00100100 00000000 
        3utf-8 中文        A 字母  1个字节      00000001  
    　　　　　　　　欧  洲  2个字节     00000000 00000000 00100100 00000000
    　　　　　　　  亚洲  中文 3个字节  00000000 00000000 00000000 00100100 0000000
        4 gbk              A  字母 2个字节        00000000 00001000
    
    　　　　　　                中文  亚洲  2个字节    00100100 00000000
    
    bytes ：表现形式：    s =  ‘Q’   b1 = s.encode (‘utf-8‘)   print (b1)   b1 = b‘Q‘  
    　　　 内部存储是（utf-8 ，gbk ，gb232等）
    
    　　　  s1 = ‘晓梅‘      b11 = s1.encode(‘utf-8‘)
    表现形式： s = b‘\\xe6\\x99\\x93\\xe6\\xa2\\x85‘ （utf-8,gbk，gb2312.....）010101
    
         0000 1000 0000 0000 0000 0001 0000 1001 0000 0000 0000 0001
    注意：在utf-8 的情况下b 后边有6个 （e6 99 等） 说名 晓梅 是中文 utf-8 是两个字6个字节
    4 bytearray  
    5 memoryview
    6 ord   字符按照unicode转数字
    7 chr   数字按照unicode转字符
    8 ascii 只要是ascii码中的内容，就打印出来，不是就转换成\\u
    9 **rep  用于%r格式化输出     
    区别就是 输出什么就是什么 注意引号
    print(‘name,%r‘%‘金老板‘)
    name,‘金老板‘
    print(‘name,%s‘%‘金老板‘)
    name ，金老板
    一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
    四层序列13个>>>数据集合3个
    
    1 **字典   
    字典相关的代码
    1、字典的特性：a 字典的无序性； b 数据关联性强 C 键键值对   唯一一个映射数据类型
    字典的键必修二是可哈希的（不可变的数据类型：,字符串，数字的，布尔值，元祖）
    并且是唯一的
    不可哈希的（可变的数据：列表，字典，set 集合）
    例子 ,
    dic = {‘name‘:‘aima‘,‘age‘:43}
    2 增加
    a、 增加 dic [‘k‘] = v 直接可覆盖  dic[‘name‘] = ‘wangyan‘
    b 、dic.sedefault (‘k‘)  有键值对不做任何改变，没有键值对才添加
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    dic[‘name‘] = ‘wangyan‘
    print(dic)
    dic.setdefault(‘goodmen‘,‘wangyan‘)
    print(dic)
    有键值 不做任何反应还是原来的字典 ，没有的就添加新的
    
    3 、删除
    a .pop()  删除一个键 就删除一个组
    dic.pop(‘name‘)
    print(dic)
    
    压栈思想 .pop()  默认返回最后一个值 
    li=[]
    l = [1,2,3,4,5]
    l1 = l.pop()
    print(l1)
    5 
    
    b 、del 直接删除k 键
    del dic[‘age‘]
    print(dic)
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    4 改
    a 和第一种增加一样 覆盖
    
    dic[‘name‘] = ‘luodan‘
    print(dic)
    b   .update()
    dic1 = {‘boy‘:‘wangmutian‘}
    dic .update(dic1)
    print(dic)
    {‘name‘: ‘aima‘, ‘age‘: 43, ‘sex‘: ‘men‘, ‘boy‘: ‘wangmutian‘}
    5 查 直接打印k 就能得到V的值 但是如果没有k键 就会报错 提示None
     a 直接打印k
    
    for key in dic:
        print(key)
    
    name
    age
    sex
    
    b for i in dic.keys():
    for i in dic.keys():
        print(i)
    
    6重要的格式 一定要记住!!!!!!!!! 低级尽量不用
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    for key,value in dic.items():
        print(key,value)
    name aima
    age 43
    sex men
    for key in dic:
        print(key,dic[key])
    
    dic = {‘name‘:‘aima‘,‘age‘:43,‘sex‘:‘men‘}
    7列表变成字典 如果后边有1 ，就是值 否则[]里面都是k 值
    分别给键对值
    
    
    dic = dict.fromkeys([‘22‘,(1,2),‘wangyan‘,‘zhang‘],‘kk‘)
    print(dic
    {‘22‘: ‘kk‘, (1, 2): ‘kk‘, ‘wangyan‘: ‘kk‘, ‘zhang‘: ‘kk‘}
    固定格式  一定的是
    dic =  dict.fromkeys()                                   ）
    
    2 **集合
    集合是无序的 元素是可哈希的（不可变的数据类型：int  str   tuple bool ）
    但是集合本身是不可哈希的（可变的数据类型） 所以做不了字典的键
    主要是用于去重
    
    a  每次打印都是无序的 都不一样的
    set = {1,‘wag‘,4 ,‘Tru‘,3}
        print(set)
    set = {1,‘wag‘,4 ,‘Tru‘,3，3}
    print(set)
    直接打印去重 
    b  集合的增删改查
     增加 。add()   .update
     删  。pop
     改 
     查 for i in set1
    c 集合的交集 并集 反交集
    
    交集&（and） 取公共部分
    差集(-)  取set1  交集以外的set1
    并集  取所有的  但是重复部分取一次  用|表示
    set(lis)&set1(lis2)
    set(lis)-et1(lis2)
    
    set1 ={1,2,3,4}
    set2 ={2,3,4,5,6,7,8}
    交集
    print(set1&set2)
    {2, 3, 4}
    
    去重 并集  | 表示
    print(set1|set2)
    {1, 2, 3, 4, 5, 6, 7, 8}
    
    差集
    print(set1-set2)
    {1}
    
    3 **冷冻集合  暂无资料
    
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>相关内置函数8个
    
    1 **len() 长度  字符串 列表  包含空
    lis = [1,4,3,2]
    print(len(lis))
    s = ‘wangyanluodanwangmutian  ‘
    s1 = ‘wangyanluodanwangmutian‘
    print(len(s))
    print(len(s1))
    4
    25
    23
    
    2 **枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），
      enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
    就是打印列表的索引和值
    li = [‘alex‘,‘银角‘,‘女神‘,‘egon‘,‘太白‘]
    for i in enumerate(li):
        print(i)
        (0, ‘alex‘)
        (1, ‘银角‘)
        (2, ‘女神‘)
        (3, ‘egon‘)
        (4, ‘太白‘)
    
    for index,name in enumerate(li,1):
        print(index,name)
        1 alex
        2 银角
        3 女神
        4 egon
        5 太白
3 all 判断是否有bool值为False 的值
4 any 判断是否有bool值为True  的值
5 **zip 返回一个迭代器必须有个list 转化   以最短的为基准 将两个列表整合成两个列表 分别取值
     print( list(zip([1,2,3,4,5],[2,3,4])))
     [(1, 2), (2, 3), (3, 4)]

    
6 filer 过滤 通过函数的定义过滤
    def small(x):
        if x < 10:
            return True
    ret = filter(small,[1,4,3,22,55,33])
    print(list(ret))
    [1,4,3]
    def small(x):
        return x % 2 == 1
    ret = filter(small,[1,4,3,22,55,33])
    print(list(ret))
7 map 返回一个新的列表
    L = [1,2,3,4,]
    def pow2(x):
        return x*x
    print(list(map(pow2,L)))
8sorted
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l2)

一层内置函数 >>>>二层作用域相关
1 global  改变全局的
     n = 1
    def func():
        global n
        n = n +1
        print(n)
    print(n)
    func()
    print(n)
   1 ，2，2
2 local  的内容会根据执行位置来决定作用域中的内容 如果在全局执行 和globals() 一样
3 nonlocl  修改最近拥有该变量的外层函数  不影响全局 
    n = 1
    def func1():
        n = 2
        def func2():
            nonlocal n
            n+=1
            print(n)
        func2()
    func1()
    print(n)
    答案 是 3 引用上级的, 1 全局的
一层内置函数>>>>二层迭代器/生成器相关(3)
    判断是不是可迭代对象 print(‘__iter__‘in dir(对象))
            print(isinsstance(对象)，iterable  )
   迭代器的含义   含有 .__iter__() 的 且比可迭代对象多一个next 方法 
   方 法  next    iter 两个个用法
   生成器的含义本质 生成器的本质就是迭代器
   方法
1 iter    可迭代对象的一个方法

2 next  迭代器的比可迭代对象多个方法

3 ***range  
    yield  py关键字   genertaor   生成器  
    含有yield的话就变成了生成器 
    条件有二
    1是有yield
    2函数的调用
    3 print(g) 是 F 或者T   是不是生成器？？？
    4 打印t(g._next_())
    打出来就是yield 后面 
    例子 
    打印出100件衣服 标上序号
        def  cloth():
        for i in range (100):
            yield (‘衣服%s‘%i)
    g = cloth()
    1 一件一件的打印
    print(g.__next__())
    2打印前50件
    for i in range(50):
        print(g.__next__())
    3全打出了来
    for i in g:
        print(i)
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>字符串类型代码的实行3个
        注意这个三个尽量不要用 或者请示领导再用
    1 **eval   执行 有返回值的  可以拿到结果的 
    2 **exec 用于流程性代码的执行   
        print(exec(‘1+3-3-1‘))
        print(eval(‘1+3-3-1‘))
        None
        0
    3 compile  编译
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>输入输出2个
    1  ***input 用户交互  name = input (‘请输入内容‘) 必须是str
    2  ***print  打印出内容  默认是sep = ‘,‘
    print(1,2,3,4,5 ,sep = ‘*‘)
        1*2*3*4*5
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>内存相关2个
    id  hashi函数是一个算法  结果是一个数字   每次数字不一样的 
        存储和查找    只要不可变就是
    1 ***hash 可哈希（不可变）  不可哈希（可变）
    2 id  内存地址
    print(id(‘wangyan‘))
    print(hash(‘wangyan‘))
    每次打印的数字都是u不一样的
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>文件操作相关(1)
 1 **open  
 f = open(‘文件名‘,encoding = ‘utf-8‘)
 打开模式 有 默认 r  读模式
                 w 写模式 清空
                 a  不可读 追写文件的最后 没有则创建
                 b 以字节的形式打开
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>模块相关(1）
1 ***import  
    import os
    os.remove()
    os.rename(‘old‘,‘new‘)
    import  time
    start = time.time()
    end = time.time()
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>查看(1）
    在pyxm   左键单击
    help 包含所有的用法
    in dir 只包含方法名字
1 help
    a  直接help   退出 q
    b  help(数据类型)   制定查看某对象的帮助信息
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>调用相关(1）
1 callable 是否可以调用  返回布尔值  
    a = [1,3,4,6]
    print(callable(a))
    print(callable(print()))
    print(callable(‘abc‘)) 
       全是False
2 **dir  1 查看内置属性  dir(__builthin__)
       2 查看某对象的属性及方法 dir()