当前位置:脚本大全 > > 正文

python的基本函数及用法(Python3.6.x中内置函数总结及讲解)

时间:2022-01-25 00:26:41类别:脚本大全

python的基本函数及用法

Python3.6.x中内置函数总结及讲解

Python3.6.x中内置函数总结

  • ?
  • 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
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421
  • 422
  • 423
  • 424
  • 425
  • 426
  • 427
  • 428
  • 429
  • 430
  • 431
  • 432
  • 433
  • 434
  • 435
  • 436
  • 437
  • 438
  • 439
  • 440
  • 441
  • 442
  • 443
  • 444
  • 445
  • 446
  • 447
  • 448
  • 449
  • 450
  • 451
  • 452
  • 453
  • 454
  • 455
  • 456
  • 457
  • 458
  • 459
  • 460
  • # -*- coding:utf-8 -*-
  • """
  • abs()      dict()     help()     min()      setattr()
  • all()      dir()      hex()      next()     slice()
  • any()      limod()    id()      object()    sorted()
  • ascii()     enumerate()   input()     oct()      staticmethod()
  • bin()      eval()     int()      open()     str()
  • bool()     exec()     isinstance()  ord()      sum()
  • bytearray()   filter()    issubclass()  pow()      super()
  • bytes()     float()     iter()     print()     tuple()
  • callable()   format()    len()      property()   type()
  • chr()      frozenset()   list()     range()     vars()
  • classmethod()  getattr()    locals()    repr()     zip()
  • compile()    globals()    map()      reversed()   __import__()
  • complex()    hasattr()    max()      round()
  • delattr()    hash()     memoryview()  set()
  • """
  • from collections import Iterator,Iterable
  • # abs(x)
  • # 求绝对值
  • print(abs(-1),abs(1))
  • # all(iterable)
  • # 如果iterable的所有元素都为真,则返回True(iterable为空,返回True)
  • print(all([1,'a',[2]])) # True
  • print(all([0,'a',[]])) # False
  • print(all(''))     # True
  • # any(iterable)
  • # 只要iterable中有一个元素为真,则返回True(iterable为空,返回False)
  • print(any([1,[],'']))    # True
  • print(any([0,0.0,'',[],{},set()]))  # False
  • print(any([]))       # False
  • # ascii(s)
  • # 只在Python3中支持,用于在不支持Unicode的平台查看Unicode字符串
  • # 就像repr()那样,创建对象的可打印形式,但在结果中只是用ascii字符,非ascii字符都转换为合适的转义序列。
  • print(ascii('hello你好'))
  • # 'hello\u4f60\u597d'
  • # repr(obj)
  • # 将其它类型数据转换为字符串,支持大部分内置数据类型
  • print(repr(123))      # 123
  • print(repr('hello 你好'))  # 'hello 你好'
  • print(repr([1,2,3]))    # [1, 2, 3]
  • print(repr({'a':1}))    # {'a': 1}
  • print(repr(object()))    # <object object at 0x7f4e9de470a0>
  • # str(value='', encoding=None, errors='strict')
  • # 转换为字符串
  • print(str())    # ''
  • print(str(666))   # 666
  • print(str(6.66))  # 6.66
  • print(str(b'666')) # b'666'
  • # bin(x)
  • # 返回一个字符串,其中包含整数x的二进制形式 0b1010
  • print(bin(0),bin(1),bin(10))
  • # 0b0 0b1 0b1010
  • # class bool([x])
  • # 是class,返回True或False
  • print(bool(),bool(0),bool(1),bool(''),bool('abc'),bool([]),bool([1]),bool(False),bool(True))
  • # False False True False True False True False True
  • # class bytearray(source=None, encoding=None, errors='strict')
  • # 返回一个字节数组,字符范围[0,255]
  • print(bytearray("hello 你好","utf-8"))
  • # bytearray(b'hello \xe4\xbd\xa0\xe5\xa5\xbd')
  • # bytes(value=b'', encoding=None, errors='strict')
  • # 返回字节类型,字符范围[0,255]
  • print(bytes("hello 你好","utf-8"))
  • # b'hello \xe4\xbd\xa0\xe5\xa5\xbd'
  • # callable(o)
  • # 返回True或者False,判断一个给定对象 o 是否是可调用对象
  • print(callable(1),callable(''),callable(str))
  • # False False True
  • # chr(x)
  • # 返回Unicode编码表中整数x对应的字符
  • print(chr(65),chr(20001))
  • # A 両
  • # ord()
  • # 返回单个字符在Unicode码表中对应的整数编码
  • print(ord('A'),ord('李'),ord('永'),ord('平')) # 65 26446 27704 24179
  • # @classmethod()
  • # 将一个普通函数转换为类方法,等价于@classmethond装饰器
  • class A():
  •   def func01(*args):
  •     print('classmethod()',*args)
  •   classmethod(func01)
  •   @classmethod
  •   def func02(clz,*args):
  •     print('@classmethond',*args)
  • A.func01()
  • A.func02()
  • # 输出
  • # classmethod()
  • # @classmethond
  • # @staticmethod
  • # 将一个普通函数转换为静态方法
  • class A():
  •   def func01(*args):
  •     print('staticmethod()',*args)
  •   staticmethod(func01)
  •   @staticmethod
  •   def func02(*args):
  •     print('@staticmethod',*args)
  • A.func01()
  • A.func02()
  • # 输出
  • # staticmethod()
  • # @staticmethod
  • # compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
  • # 将字符串格式的源代码,编译为可以被exec()或eval()函数执行的代码code对象
  • # source:一个Python模块或多个代码块,或者是单一代码块,或者是一个表达式
  • # filename:运行时错误消息提示
  • # mode:与source对应,模块或多个代码块--"exec",单一代码块--"single",表达式--"eval"
  • statements="""
  • print('-'*50)
  • num=3
  • while num:
  •   print("hello")
  •   num-=1
  • print('-'*50)"""
  • filename="run-time error"
  • codes=compile(source=statements,filename=filename,mode="exec")
  • print(type(codes))
  • # eval(codes)
  • exec(codes)
  • # 输出
  • # <class 'code'>
  • # --------------------------------------------------
  • # hello
  • # hello
  • # hello
  • # --------------------------------------------------
  • # eval(expression, globals=None, locals=None)
  • # 运行Python表达式字符串或者是经过compile()编译后生成的code对象
  • # obj可以是字符串对象或者已经由compile编译过的代码对象,
  • # globals和locals是可选的,分别代表了全局和局部名称空间中的对象,其中globals必须是字典,而locals是任意的映射对象
  • print(eval("2**3"))   # 8
  • print(eval("type({'key':'value'})"))  # <class 'dict'>
  • # exec(object[, globals[, locals]])
  • # 运行Python代码字符串或者是经过compile()编译后生成的code对象
  • statements="""
  • num=1
  • if num<3:
  •   print("1<3")"""
  • exec(statements)  # 1<3
  • exec('print("exec")'# exec
  • # class complex(real, imag=None)
  • # 返回复数
  • c=complex(1,2)
  • print(c,c.real,c.imag)
  • c=complex('1+2j')
  • # c=complex('1 +2j')  # 报错ValueError,字符串中不能包含空格
  • # c=complex('1+2i')  # 报错ValueError,复数虚部必须使用英文字母 j 表示
  • print(c,c.real,c.imag)
  • # 输出
  • # (1+2j) 1.0 2.0
  • # (1+2j) 1.0 2.0
  • # delattr(obj,attr)
  • # 等价于 del obj.attr
  • # 删除对象obj的attr属性
  • class A:
  •   attr_01=1
  •   attr_02=2
  • print(A.attr_01)
  • delattr(A,'attr_01')
  • # print(A.attr_01)  # AttributeError: type object 'A' has no attribute 'attr_01'
  • print(A.attr_02)
  • del A.attr_02
  • # print(A.attr_02)  # AttributeError: type object 'A' has no attribute 'attr_02'
  • # class dict(**kwarg)
  • # class dict(mapping, **kwarg)
  • # class dict(iterable, **kwarg)
  • # 返回一个字典对象
  • print(dict())  # {}
  • print(dict(a=2,b=1))  # {'b': 1, 'a': 2}
  • print(dict([('a',1),('b',2),('c',3)])) # {'a': 1, 'b': 2, 'c': 3}
  • print(dict({'a':'A','b':'B'})) # {'a': 'A', 'b': 'B'}
  • # dir(obj)
  • # 参数为空,返回当前作用域中的属性和方法列表
  • # 参数不为空,返回参数对象obj的作用域中的属性和方法列表
  • # 参数不为空,且该参数对象所属类中重载了 __dir__(self) 运算符,则返回 __dir__(self)的返回值
  • print(dir())
  • print(dir(int))
  • print(dir(dict))
  • class B():
  •   def __dir__(self):
  •     return ['哼','哈']
  •   def func(self):
  •     pass
  • b=B()
  • print(dir(b))  # ['哈', '哼']
  • # limod(a,b)
  • # 等价于 (a//b,a%b)
  • # 返回长除法的商与余数组成的元组
  • print(limod(10,3),(10//3,10%3))
  • print(limod(10,3.0),(10//3.0,10%3.0))
  • print(limod(10.0,3),(10.0//3,10.0%3))
  • # (3, 1) (3, 1)
  • # (3.0, 1.0) (3.0, 1.0)
  • # (3.0, 1.0) (3.0, 1.0)
  • # enumerate(i,start=0)
  • # 根据给定iterable,返回枚举类型对象,是iterator类型
  • print(list(enumerate('abc',start=1)))
  • for item in enumerate('123',start=0):
  •   print(item)
  • # 输出
  • # [(1, 'a'), (2, 'b'), (3, 'c')]
  • # (0, 'a')
  • # (1, 'b')
  • # (2, 'c')
  • # filter(function, iterable)
  • # 过滤序列中的值
  • # filter函数将序列iterable中的每一个元素传入函数function中,如果返回值为真,则添加到结果集中;否则,过滤掉
  • # 如果function为None,则将iterable中值为True的元素添加到结果集中
  • data=[-1,0,1,2,3,False]
  • res=filter(lambda x:x>=0,data)
  • print(res)   # <filter object at 0x7f97fe23f7b8>
  • print(list(res))  # [0, 1, 2, 3, False]
  • res=filter(None,data)
  • print(list(res))  # [-1, 1, 2, 3]
  • # class float([x])
  • # 生成浮点数,x为数字或者字符串
  • # inf:无穷
  • print(float(),float(1),float('1'),float('+1.23'),float('+1E6'),float('-Infinity'),float('  -12345\n'))
  • # 0.0 1.0 1.0 1.23 1000000.0 -inf -12345.0
  • # format(value, [format_spec])
  • # 格式化显示value的值,类型为str
  • # 如果format_spec为空,则等效于str(value)
  • print(format(123)) # 123
  • print(format(True)) # True
  • print(format({'a':1,'b':2}))  # {'a':1,'b':2}
  • print(format(123,'b')) # 格式化为2进制 1111011
  • print(format(123,'o')) # 格式化为8进制 173
  • print(format(123,'d')) # 格式化为10进制 123
  • print(format(123,'x')) # 格式化为16进制,使用小写字母显示 7b
  • print(format(123,'X')) # 格式化为16进制,使用大写在木显示 7B
  • print(format(123456789.123456789,'e'))   # 科学计数法,默认保留6位小数 1.234568e+08
  • print(format(123456789.123456789,'0.2e'))  # 科学计数法,保留2位小数 1.23e+08
  • print(format(123456789.123456789,'E'))   # 科学计数法,1.234568E+08
  • print(format(123456789.123456789,'0.2E'))  # 科学计数法,1.23E+08
  • print(format(123456789.123456789,'f'))   # 小数点计数法,默认保留6位小数,123456789.123457
  • print(format(123456789.123456789,'0.2f'))  # 小数点计数法,保留2位小数,123456789.12
  • print(format(1.0e+1000,'F'),format(-1.0e+1000,'F')) # 小数点计数法,无穷大转换为字母 INF,-INF
  • # class set([iterable])
  • # 获取一个set实例对象,可变,元素不重复
  • print(set())   # set()
  • print(set('123')) # {'2', '3', '1'}
  • # class frozenset([iterable])
  • # 返回一个frozenset实例对象,不可变,元素不重复
  • print(frozenset())   # frozenset()
  • print(frozenset('123')) # frozenset({'2', '3', '1'})
  • # getattr(object, name[, default])
  • # 返回object的name属性值,name必须是str类型
  • # 如果不存在name属性,设置了default返回default值,否则,抛出异常AttributeError
  • class A(object):
  •   attr_01='value_01'
  • print(getattr(A,'attr_01'))
  • print(getattr(A,'attr_02','value_02'))
  • # print(getattr(A,'attr_03')) # AttributeError: type object 'A' has no attribute 'attr_03'
  • # hasattr(object, name)
  • # 判断object是否拥有属性name,返回True或False
  • print(hasattr(A,'attr_01')) # True
  • print(hasattr(A,'attr_02')) # False
  • # setattr(object, name, value)
  • # 给object设置属性name,值为value
  • setattr(A,'attr_02','value_02')
  • print(hasattr(A,'attr_02')) # True
  • # globals()
  • # 返回属于全局作用域的属性或者方法的字典表
  • print(globals())
  • # locals()
  • # 返回属于本地作用域的属性和方法的字典表
  • print(locals())
  • def function():
  •   a,b=1,2
  •   print(locals())   # {'b': 2, 'a': 1}
  • function()
  • # vars(object)
  • # 返回任意对象的__dict__属性,前提是存在该属性
  • print(vars(int))
  • # hash(object)
  • # 返回object的哈希值,大小相等的数字,哈希值一定相同
  • print(hash(1),hash(1.0))
  • print(hash(A),hash(A()))
  • print(hash(int),hash(hash))
  • # help([object])
  • # 调用内置的帮助系统
  • # object可以为空,module, function, class, method, keyword, or documentation topi
  • # help()
  • # import re
  • # help(re)
  • # help(hash)
  • # help('class')
  • # class int(x=0)
  • # class int(x, base=10)
  • # 将给定数据x从base进制转换为10进制int
  • # x为数字或可转换为数字的字符串,base为数字x本来的进制
  • print(int(255)) # 255
  • print(int('255'))  # 255
  • print(int('255',base=10))  # 255
  • print(int('255',base=8))  # 173
  • # oct(x)
  • # 将10进制数x转换为8进制数
  • print(oct(255)) # 0o377
  • # hex(x)
  • # 将一个int类型的数字转换为16进制
  • print(hex(255),hex(0)) # 0xff 0x0
  • # id()
  • # 返回代表object身份的一个int数字,可以认为C语言中"对象的内存地址"
  • print(id(0))
  • print(id(id))
  • # input([prompt])
  • # 接收用户的输入并返回字符串
  • # value=input('--->')
  • # print(value)
  • # print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
  • # *args:任意多个字符串
  • # sep:字符串之间的分割符,默认为空格
  • # end:结束符号,默认为换行 \n
  • print('a','b','c',sep='$',end='\n\n')
  • # isinstance(object, classinfo)
  • # 判断object是否是classinfo的一个实例
  • class A():pass
  • print(isinstance(1,int))  # True
  • print(isinstance(A(),A))  # True
  • # issubclass(class, classinfo)
  • # 判断class是否是classinfo的一个子类
  • class A():pass
  • class B(A):pass
  • print(issubclass(B,A)) # True
  • # iter(object[, sentinel])
  • # 将一个可迭代对象转换为迭代器Iterator
  • i=iter('abc')
  • print(type(i))
  • # next(iterator[, default])
  • # 返回迭代器的下一个元素
  • # 如果没有下一个,返回default参数,如果没有default,抛出StopIteration异常
  • print(next(i),next(i),next(i))
  • # print(next(i)) # StopIteration
  • print(next(i,'没有更多元素了'))
  • # len(iterable)
  • # 返回iterable的元素个数
  • print(len('abc'))  # 3
  • print(len([1,2,3])) # 3
  • print(len((1,2,3))) # 3
  • print(len({'a':1})) # 1
  • print(len({1,2,3})) # 3
  • # class list([iterable])
  • # 实例化一个list对象
  • print(list())
  • print(list('abcd'))
  • print(list(range(5)))
  • # map(function, iterable, ...)
  • # 在序列中映射函数:map函数会对一个序列对象中的每一个元素应用被传入的函数,并返回一个包含所有函数调用结果的映射集合
  • # res=map(lambda x:x,[1,2,3])
  • res=map(lambda x,y:x+y,[1,2,3],[4,5,6])
  • print(type(res))
  • print(list(res))
  • # max()
  • # 返回给定序列中的最大值
  • print(max(1,2))   # 2
  • print(max([1,2]))  # 2
  • print(max({'a':2,'b':1})) # b
  • print(max({'a','b'}))   # b
  • # min()
  • # 返回给定序列中的最小值
  • print(min(1,2))   # 1
  • print(min([1,2]))  # 1
  • print(min({'a':2,'b':1})) # a
  • print(min({'a','b'}))   # a
  • # memoryview(object)
  • # 什么鬼?内存视图?C中的指针?
  • view=memoryview(b'abcd')
  • print(view[0]) # 97
  • # class object
  • # 返回一个object
  • print(object) #<class 'object'>
  • print(object()) # <object object at 0x7fc4731ef0c0>
  • # open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
  • # 打开一个文件对象
  • # pow(x,y,[z])
  • # 2个参数时,等效于x**y
  • # 3个参数时,等效于x**y%z
  • print(pow(10,3))  # 1000
  • print(pow(10,3,3)) # 1
  • # class property(fget=None, fset=None, fdel=None, doc=None)
  • # 不懂?
  • # range([start,]stop[,sep])
  • # 生成数字列表
  • r=range(5)
  • print(type(r),isinstance(r,Iterator))  # <class 'range'> False
  • for i in range(1,10,2):
  •   print(i,end=' ')    # 1 3 5 7 9
  • print('\n')
  • # reversed(seq)
  • # 翻转序列seq,返回Iterator
  • i=reversed(['a','b','c'])
  • print(i)
  • print(next(i),next(i),next(i),next(i,'没有了'))
  • # round(number[, ndigits])
  • # 四舍五入
  • # ndigits为保留小数点位数,默认为0
  • print(round(16),round(16.18),round(8.88),round(-8.88))     # 16 16 9 -9
  • print(round(16,1),round(16.18,1),round(8.88,1),round(-8.88,1)) # 16 16.2 8.9 -8.9
  • # class slice(stop)¶
  • # class slice(start, stop[, step])
  • # 返回一个切片slice对象,表示步距,可用于切片操作,实际上对可迭代对象的切片操作就是调用了slice方法
  • print(slice(5))   # slice(None, 5, None)
  • print(slice(1,5))  # slice(1, 5, None)
  • print(slice(1,5,2)) # slice(1, 5, 2)
  • seq='abcdefghj'
  • print(seq[slice(5)])  # abcde
  • print(seq[slice(1,5,2)])# bd
  • # sorted(iterable, *, key=None, reverse=False)
  • # 对可迭代对象进行排序
  • # key为函数,依次作用于每个元素
  • # reverse为是否倒序排序
  • print(sorted('872Aadbc',key=None,reverse=True))
  • # ['d', 'c', 'b', 'a', 'A', '8', '7', '2']
  • print(sorted('872Aadbc',key=lambda x :str.lower(x),reverse=True))
  • # ['d', 'c', 'b', 'A', 'a', '8', '7', '2']
  • # sum(iterable[, start])
  • # 求和:iterable中各元素之和,加上第二个参数start的值
  • # 第二个参数start默认为0
  • print(sum([1,2,3]))
  • print(sum([1,2,3],10))
  • # super([type[, object-or-type]])
  • # 调用父类中的方法
  • class A(object):
  •   def methond(self):
  •     print('----A----')
  • class B(A):
  •   def methond(self):
  •     super(B,self).methond()
  •     # 等价于
  •     # super().methond()
  •     print('----B----')
  • B.methond(B())
  • # tuple([iterable])
  • # 返回一个元祖对象,不可变的list
  • print(tuple(['L','O','V','E','E']))
  • # type(obj)
  • # 返回obj的数据类型
  • print(type(0))
  • print(type(''))
  • print(type([]))
  • print(type((0,)))
  • print(type({}))
  • # zip()
  • # 创建一个迭代器,结果为俩个Iterable中各元素从开始位置开始的映射关系
  • # 如果2个Iterable中的元素个数不同,则舍弃比较多的元素
  • ziped=zip('abcd','1234')
  • print(isinstance(ziped,Iterator))  # True
  • print(list(ziped)) # [('a', 'A'), ('b', 'B'), ('c', 'C'), ('d', 'D')]
  • ziped=zip('abc','1234')
  • print(list(ziped))   # [('a', '1'), ('b', '2'), ('c', '3')]
  • ziped=zip('abcd','123')
  • print(list(ziped))   # [('a', '1'), ('b', '2'), ('c', '3')]
  • print(list(zip('abc'))) # [('a',), ('b',), ('c',)]
  • print(list(zip('abc',''))) # []
  • # __import__(name, globals=None, locals=None, fromlist=(), level=0)
  • # 不常用的高级函数
  • # import importlib
  • # importlib.import_module('module_name')
  • 总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对开心学习网的支持。如果你想了解更多相关内容请查看下面相关链接

    原文链接:https://blog.csdn.net/topleeyap/article/details/79222771

    上一篇下一篇

    猜您喜欢

    热门推荐