Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

05 python内置函数大全

Tammy~ 2019-09-11 19:40:00 阅读数:7 评论数:0 点赞数:0 收藏数:0

一、数学运算

abs:返回数字的绝对值

abs(-1)                     #

round:保留浮点数的小数位数,默认保留整数。四舍五入。

round(1.553,1)                 #1.6

divmod:计算除数和被除数的结果,并返回一个包含商和余数的元组

divmod(5,2)                 # (2,1)

pow:求x**y次幂(当有第三参数时,x**y的结果对z取余 )

pow(2,5)               #
pow(2,3,5)             # 这里为3个参数,2的3次方,结果为8。用8和5做除法,取余为3,最终输出3

sum:对可迭代对象进行求和计算(可设置初始值)

# sum最多只有2个参数
sum([1,2,3,4,5])            #
sum([1,2,3,4,5],100)         #
sum(1,2,3,4,5)              #报错

min:返回可迭代对象的最小值(可加key,key为函数名,通过函数的规则,返回最小值)。

  I. 将iterable的每一个元素当作函数的参数传给函数,字典中,元素是键

  II. 按照函数的返回值进行比较大小

  III. 返回的是遍历的元素x,即传入函数的参数

min([1,-2,3,-4,5])                        #-4
min([1,-2,3,-4,5],key=abs)                # 按照绝对值的大小,返回此序列最小值 1
min(1,2,-5,6,-3,key=lambda x:abs(x))      # 可以设置很多参数比较大小
ls=[('spring',100),('summer',18),('winter',500)]
def func(x):
    return x[1]
print(min(ls,key=func))              #('summer',18)
dic = {'a': 3, 'b': 2, 'c': 1}
def func1(x):
    return dic[x]
print(min(dic,key=func1))          #c
# x为dic的key,lambda的返回值(即dic的值进行比较)返回最小的值对应的键
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))

max:返回可迭代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)。与min用法相同

 

二.类型转换

进制转化

bin:将十进制转化成二进制

bin(100)       #0b1100100

oct:将十进制转化成八进制

oct(100)        #0o144

hex:将十进制转化成十六进制

hex(100)       #0x64

 

字符串和ASCll编码转换

ord:输入字符,找该字符在unicode编码的位置

ord('a')           #97 
ord('')           #

chr:输入位置数字,找出相对应的字符,与ord相反

chr(97)             # a 
chr(20320)         #

ascii:是ascii码表中的内容返回原值,不是返回\u + 他在Unicode中的位置

ascii('q')          #'q' 
ascii('')         #'\u4f60' 转化成十进制就是 20320

 

数据类型转化相关

int:用于将字符串或数字转化成整型,用于将其他进制数转化成十进制。取整数,不会四舍五入

int(1.543)       #
int('')       #
int('',base=2)   #

float:字符串或整数转化成浮点型

float(1)         #1.0
float('')       #1.0

bool:用于将给定参数转化为布尔类型

bool(123)        #True

complex:用于创建一个值为 real+image*j的复数,当第一个参数为字符串时,不要设置第二个参数。

complex(1,2)     #(1+2j)
complex('')     #(1+0j)

str:将数据转化成字符串

str(2.3)                           # 转换为字符串2.3

bytes:用于不同编码之间的转化。将unicode 转为非unicode。只能编码,不能解码

编码转换,将unicode转换为utf-
方法一:
s1 = '小太阳'
s2 = s1.encode('utf-8')
print(s2)                           # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

方法二:
s1 = '小太阳'
print(bytes(s1,encoding='utf-8')) # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

list:将一个可迭代对象转化成列表(如果是字典,默认将key作为列表的元素

l1 = list((1,2,3))                # [1, 2, 3]
l2 = list({1,2,3})                # [1, 2, 3]
l3 = list({'name':'xiaoming','age':13})    # ['name', 'age']

tuple将一个可迭代对象转化成元组(如果是字典,默认将key作为元组的元素

tup1 = tuple([1,2,3])                # (1, 2, 3)
tup2 = tuple({'name':'xiaoming','age':13})  # ('name', 'age')

dict:创建一个字典

dict(a = 1,b = 2)                 # {'b': 2, 'a': 1}
dict(zip(['a','b'],[1,2]))           # 可以传入映射函数创建字典。{'b': 2, 'a': 1}
dict((('a',1),('b',2)))             # 可以传入可迭代对象创建字典。{'b': 2, 'a': 1}

set:创建一个集合

a = set(range(10))                 # 传入可迭代对象,创建集合{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

 

其他

bytearry:返回一个新字节数组。数组中元素可变,并且每个元素的值范围: 0 <= x < 256。(很少用)

ret = bytearray('hello',encoding='utf-8')
print(ret)   #bytearray(b'hello')
print(id(ret))   #1979800230744
print(ret[])   #  h在ascii码中的位置

ret[] =    #将第一位改为a
print(ret)   #bytearray(b'aello')
print(id(ret))   #1979800230744  id是相同的
bytearray('中文','utf-8') # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

memoryview:返回对象obj的内存查看对象。所谓内存查看对象,就是对象符合缓冲区协议的对象,为了给别的代码使用缓冲区里的数据,而不必拷贝,就可以直接使用。(没啥用)

ret = memoryview(bytes('你好',encoding='utf-8'))
print(ret)   #<memory at 0x000001DA89DDB408>
print(len(ret)) # 
print(bytes(ret[:]).decode('utf-8'))   #你
print(bytes(ret[:]).decode('utf-8'))   #好
 
ret = memoryview(b'abcefg')
print(ret[])                   # 
print(ret[-])                  # 

frozenset:返回一个冻集合(新的不可变集合),冻结后的集合不能再添加或删除任何元素

a = frozenset(range())
print(a)                                # frozenset({, , , , , , , , , })

enumerate:枚举,返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2])

li = ['spring', 'summer', 'autumn', 'winter']
print(enumerate(li)) # <enumerate object at 0x02E3D558>
print('__iter__' in dir(enumerate(li))) # True
print('__next__' in dir(enumerate(li))) # True

enumerate是一个迭代器, 返回结果为:列表元素的索引以及对应的值

li = ['spring', 'summer', 'autumn', 'winter']
for i in enumerate(li):
    print(i)

执行输出:
(0, 'spring')
(1, 'summer')
(2, 'autumn')
(3, 'winter')

li = ['spring', 'summer', 'autumn', 'winter']

for k,v in enumerate(li):
    print(k,v)

执行输出:

0 spring

1 summer

2 autumn

3 winter

enumerate的第2个参数,表示从多少开始。默认从1开始

li = ['spring', 'summer', 'autumn', 'winter']

for k,v in enumerate(li,):
    print(k,v)

执行输出:
10 spring
11 summer
12 autumn
13 winter

li = ['spring', 'summer', 'autumn', 'winter']
print(list(enumerate(li)))                 # [(, 'spring'), (, 'summer'), (, 'autumn'), (, 'winter')]
print(list(enumerate(li, start=)))        #指定起始值,[(, 'spring'), (, 'summer'), (, 'autumn'), (, 'winter')]

range:根据传入的参数创建一个新的range对象,一般用在for循环中

a = range()
b = range(,)
c = range(,,)

print(a,list(a))        # range(, ) [, , , , , , , , , ]
print(b,list(b))        # range(, ) [, , , , , , , , ]
print(c,list(c))        # range(, , ) [, , ]

三、序列操作

slice:构建一个切片对象,用于列表的切片

l1 = [i for i in range()]
l2 = l1[::]

print(l2)    #[, , ],按照普通切片方法

reversed:将一个序列反转,并返回此反转序列的迭代器,字典不能反转。

l1 = [,,,]
print(reversed(l1))   #<list_reverseiterator object at 0x0000026B679FA4E0>

for i in reversed(l1):
    print(i)    #    
s = 'asdf'
for i in reversed(s):
    print(i)   # f d s a
dic = {'name':'xiaoming','age':}
for i in reversed(dic):
    print(i)   #字典不能反转  TypeError: 'dict' object is not reversible

Sorted:对可迭代对象进行排序,只能列表使用. 可加key,key为函数名,通过函数的规则进行  排序。默认从小到大,加入reverse = True时按照从大到小。与 li.sort()相比,原列表不发生改变

  sorted(iterable,key=None,reverse=False)

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

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

默认升序
li = [,,,,,,]
print(sorted(li))         # [, , , , , , ]

按照绝对值排序
li = [,-,-,,,-,]
print(sorted(li,reverse=True,key=abs))        # [, -, , -, , -, ]

原列表改变
l1 = [,,,,]
l1.sort()
print(l1)          #[, , , , ]  

原列表不发生改变
l2 = [,,,,,]
print(sorted(l2))                  #[, , , , , ]
print(l2)                      #[, , , , , ]  

l3 = [(,),(,),(,),(,)]
def func1(x):
    return x[]
print(sorted(l3,key=func1))          #[(, ), (, ), (, ), (, )]

字典使用sorted排序, 字典排序返回的就是排序后的key
dic = {:'a',:'c',:'b'}
print(sorted(dic))                 # [,,]
 
和函数组合使用
定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
def func(s):
    return len(s)

print(sorted(lst,key=func))                        #  ['西游记', '红楼梦', '天龙八部', '三国演义']


和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))                #  ['西游记', '红楼梦', '天龙八部', '三国演义']

lst = [{'id':,'name':'alex','age':},
    {'id':,'name':'wusir','age':},
    {'id':,'name':'taibai','age':},]
 
# 按照年龄对学生信息进行排序
print(sorted(lst,key=lambda e:e['age']))
 
结果:[{'id': , 'name': 'taibai', 'age': }, {'id': , 'name': 'wusir', 'age': }, {'id': , 'name': 'alex', 'age': }]

all:可迭代对象中,全是True才是True

print(all([,,,]))   #False
print(all([,,,]))   #True

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

print(any([,[],{},,()]))   #True

zip:将可迭代对象作为参数,将对象中的元素打包成一个元组,返回由这些元组组成的迭代器。

        如果可迭代对象中元素的数量不一致,则返回元组个与最短的对象相同。zip结果取决于最短的一个,返回的数据是元组。

        拉链方法:将多个iter纵向组成一个个的元组

l = [,,]
tu = ('china','america','japan','korean')
dic = {'name':,'age':,'hobby':}
for i in zip(l,tu,dic):
    print(i)      
    
输出结果:
(, 'china', 'name')
(, 'america', 'age')
(, 'japan', 'hobby')

lst1 = [,,]
lst2 = ['a','b','c','d']
lst3 = (,,,,)
for i in zip(lst1,lst2,lst3):
    print(i)
​
输出结果:
(, 'a', )
(, 'b', )
(, 'c', )

filter:通过函数过滤可迭代对象,函数中return的是一个条件,返回一个迭代器。相当于生成器表达 式的筛选模式。类似于[i for i in range(10) if i > 3]

  filter(function,iterable)

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

  iterable:可迭代对象

l = [i for i in range()]
def func1(x):
    return x>

for i in filter(func1,l):
    print(i)
lst = [{'id': , 'name': 'Joe', 'age': },
       {'id': , 'name': 'Paul', 'age': },
       {'id': , 'name': 'May', 'age': }, ]

ls = filter(lambda e: e['age'] > , lst)
print(list(ls))    # [{'id': , 'name': 'Joe', 'age': }, {'id': , 'name': 'Paul', 'age': }]
取列表中的偶数
def func(x):
    return x %  == 
ret = filter(func,[,,,,,,])
print(ret)
for i in ret:
    print(i) 

执行输出:
<filter object at 0x0000021325A4B6D8>


使用列表生成式完成
li = [i for i in [,,,,,,] if i %  == ]
print(li) 

map:根据提供的函数对指定的序列做映射,返回一个迭代器,相当于生成器表达式中的循环模式

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

计算列表各个元素的平方
def square(x):                         
    return x ** 

ret = map(square,[,,,,])                 
for i in ret:
    print(i) 

执行输出:




改写成lambda
lst = [,,,,]
print(list(map(lambda s:s*s,lst)))
map也是迭代器
l = [i for i in range()]
def func(x):
    return x**

for i in map(func,l):
    print(i) 
计算两个列表中相同位置的数据的和
lst1 = [, , , , ]
lst2 = [, , , , ]
print(list(map(lambda x, y: x+y, lst1, lst2)))        # [, , , , ]

四、对象操作

hash:获取一个对象(可哈希对象:int,str,Bool,tuple)的哈希值

print(hash(''))          #6154395912723147770
print(hash())         #,数字不变

id:获取对象的内存地址

print(id())            #1785819168

dir:查看对象或者当前作用域内的属性列表。函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

print(dir(list))         # ['__add__', '__class__', '__contains__'...]
print(dir())            # ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print(dir('hello'))        # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',             '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__',             '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__ne...........
print('__iter__' in dir(iter))    # False

help:返回对象的帮助信息,主要用于查看函数或模块用途的详细说明。

help(abs)
help(str)

len:返回一个对象中元素的个数

print(len('abcd'))                     #  字符串
print(len(bytes('abcd','utf-8')))             #  字节数组
print(len((,,,)))                     #  元组
print(len([,,,]))                     #  列表
print(len(range(,)))                 #  range对象
print(len({'a':,'b':,'c':,'d':}))             #  字典
print(len({'a','b','c','d'}))                 #  集合
print(len(frozenset('abcd')))             # 不可变集合

type:返回对象的类型,或者根据传入的参数创建一个新的类型

type() # <class 'int'>

五、反射操作

hasattr(obj, attr): 用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。

getattr(obj, attr): 返回obj中名为attr值的属性的值

setattr(obj, attr, val): 给obj的attr属性赋值为val。例如attr为'bar',则相当于obj.bar = val

delattr(obj, name)该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar

class Test:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Test('Joe',)

#检测是否含有某属性
print(hasattr(obj,'name'))          # True
print(hasattr(obj,'say_hi'))        # True
 
#获取属性
n=getattr(obj,'name')
func=getattr(obj,'say_hi')
print(n,func)               # Joe <bound method Test.say_hi of <__main__.Test object at 0x0000000009F69128>> 
 
 
#设置属性
setattr(obj,'self.hobby','paiting')
setattr(obj,'show_hobby',lambda self:self.name+' like paiting')
print(obj.__dict__)         # {'name': 'Joe', 'age': , 'self.hobby': 'paiting', 'show_hobby': <function <lambda> at 0x00000000029947B8>}
print(obj.show_hobby(obj))  # Joe like paiting

#删除属性
delattr(obj,'age')
delattr(obj,'show_hobby')
print(obj.__dict__)         # {'name': 'Joe', 'self.hobby': 'paiting'}

isinstance(a,b):判断a是否是b类(或者b类的基类)实例化的对象

issubclass(a,b): 判断a类是否是b类(或者b的基类)的派生类

class A:
    pass

class B(A):
    pass

class C(B):
    pass

obj = B()
print(isinstance(obj,B))    # True
print(isinstance(obj,A))    # True


print(issubclass(B,A))    # True
print(issubclass(C,A))    # True

callable:检测对象是否可被调用。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。callable其实就是判断一个对象是否是函数,是就返回True,其他类型直接返回False

name = 'summer'
print(callable(name))      #False,不可调用
def func1():
    pass
print(callable(func1))     #True,可以调用
class A:  # 定义类B
    def __call__(self):
        print('instances are callable now.')

print(callable(A))          # 类A是可调用对象,True
a = A()                     # 实例
print(a)                    # <__main__.A object at 0x02A6C490>
a()                         # 调用实例a成功,instances are callable now.

 

六、装饰器

property:标示属性的装饰器。property是一个装饰器函数,可以将一个方法伪装成属性,调用的时候可以不用加()

例如:BMI指数

class Person(object):
    def __init__(self,name,weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height

    @property
    def bmi(self):
        return self.__weight / self.__height **

classmethod:标示方法为类方法的装饰器。必须通过类的调用,而且此方法的意义:就是对类里面的变量或者方法进行修改添加

class Goods:
    __discount = 0.8                  # 折扣
    def __init__(self,name,origin_price):
        self.name = name
        self.__price = origin_price        # 原价

    @property
    def price(self):                  # 价格
        return self.__price * Goods.__discount

    @classmethod
def change_discount(self,new_discount):  
# 类方法 可以直接被类调用 不需要默认传对象参数 只需要传一个类参数就可以了
        Goods.__discount = new_discount

Goods.change_discount()  # 不依赖对象的方法 就应该定义成类方法 类方法可以任意的操作类中的静态变量
apple = Goods('apple',)
banana = Goods('banana',)
print(apple.price)            # 
print(banana.price)              # 

staticmethod:标示方法为静态方法的装饰器。不依赖类以及对象。 

class Student:
def __init__(self,name):pass

    @staticmethod
    def login(a):  # login就是一个类中的静态方法 静态方法没有默认参数 就当成普通的函数使用即可
        user = input('user :')
        if user == 'alex':
            print('success')

        else:
            print('faild')

Student.login() 

七、变量作用域相关

globals:返回一个字典,包含全部的全局变量

locals:返回一个字典,包含当前作用域的全部变量

vars:返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表

class Test:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def variation(self):
        hobby = 'paiting'
        print(globals())
        print(locals())

obj = Test('Joe', )
obj.variation()
print(obj.__dict__)         # {'name': 'Joe', 'age': }
print(vars(obj))            # {'name': 'Joe', 'age': }

globals()的输出:

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DEC208>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/Python/test.py', '__cached__': None, 'Test': <class '__main__.Test'>, 'obj': <__main__.Test object at 0x0000000001F50A20>}

locals()的输出:

{'hobby': 'paiting', 'self': <__main__.Test object at 0x0000000001F50A20>}

八、字符串类型代码的执行

eval:执行字符串类型的代码,并返回最终结果。相当于拨开字符串2边的引号,执行里面的代码

print(eval('3+4'))             # 
ret = eval('{"name":"summer"}')
print(ret)                 #  {'name': 'summer'}

exec:执行字符串类型的代码,不返回结果

print(exec('3+4'))         # None
ret1 = '''
li = [,,]
for i in li:
    print(i)
'''
print(exec(ret1)) 

执行输出:



None

val和exec 功能是类似的, 区别:

  eval有返回值,exec没有没有值

  exec适用于有流程控制的,比如for循环。eval只能做一些简单的。

compile:将字符串类型的代码编译,代码对象能够通过exec语句执行或eval()求值。(了解即可)

code1 = 'for i in range(0,3): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1) 

执行输出:


repr:返回一个对象的string形式(原形毕露)。

#%r  原封不动的写出来
name = 'Joe'
print('我叫%r' % name)        # 我叫'Joe'

print(repr('{"name":"Joe"}'))    # '{"name":"Joe"}'
print('{"name":"Joe"}')        # {"name":"Joe"}

 

九、输入输出相关

input:函数接收一个标准输入数据,返回str类型

print(self,*args,sep=' ',end='\n',file=None, flush=False)

  sep:打印多个内容的分隔符,默认是空格

  end:默认是换行符

  file:默认是None,默认输出到屏幕,设置文件句柄可输出到文件

  flush: 立即把内容输出到流文件,不作缓存

sep默认是用空格拼接
print(, , )             #   

sep 指定分隔符 |
print(, , , sep = '|')         # ||

end结尾符
print(,end=' ')
print()               #  


print(,end='')
print(,)                #333666

print(,end='**')
print(,)             # **

file写入文件

with open('log.txt',encoding='utf-8',mode='w') as f1:
    print('',file=f1)             # 执行程序,查看log.txt文件内容为: 

f = open('t1',encoding='utf-8',mode='w')
print(,'',file=f)                # 执行程序,查看t1文件内容为:  

f = open('tmp_file','w')
print(,,sep=',',file = f,flush=True)

打印进度条

import time
for i in range(,,):  
     time.sleep(0.1)
     char_num = i//2                      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i ==  else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)

十、迭代器、生成器相关

iter:函数用来生成迭代器(将一个可迭代对象,生成迭代器)

from collections import Iterable
from collections import Iterator
l = [,,]
print(isinstance(l,Iterable))  # 判断是否可迭代 True
print(isinstance(l,Iterator))  # 判断是否为迭代器 False
from collections import Iterable
from collections import Iterator
l = [,,]

l1 = iter(l)             #生成迭代器
print(isinstance(l1,Iterable))      # True
print(isinstance(l1,Iterator))      # True
print(l1)                           # <list_iterator object at 0x031D3690>
print(next(l1))                     # 
print(next(l1))                     # 
print(next(l1))                     # 
print(next(l1))                     # 报错 StopIteration

next:内部实际使用了__next__方法,返回迭代器的下一个项目。

# 首先获得Iterator对象:
it = iter([, , , , ])
while True:
    try:
        # 获得下一个值:
        x = next(it) #next内部封装了__next__方法,都是求下一个值
        print(x)

    except StopIteration:
        # 遇到StopIteration就退出循环
        break 

执行输出:




十一、其他

文件操作相关

open()  :打开一个文件,返回一个文件操作符(文件句柄), 可以用encoding指定编码。操作文件的模式有r,w,a,r+,w+,a+ 共6种,每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)

 

format:1、提供参数,指定对其方式,<是左对齐,>是右对齐,^是居中

    2、将整数转化成二进制’b‘、’n‘、unicode ’c‘、八进制’o‘、十六进制’x’、’X‘等

    3、将浮点数用科学计数法或小数点计数法表示

print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20')) 

执行输出:
test                
                test
        test         

super:根据传入的参数创建一个新的子类和父类关系的代理对象

class A(object):
    def __init__(self):
        print('A.__init__')

class B(A):
    def __init__(self):
        print('B.__init__')
        super().__init__()

#super调用父类方法
b = B()

结果输出:
B.__init__
A.__init__

__import__:动态导入模块

index = __import__('index')
index.sayHello()

 

 参考链接:

        https://www.cnblogs.com/sesshoumaru/p/6140987.html

        https://www.cnblogs.com/vamei/archive/2012/11/09/2762224.html

        https://www.cnblogs.com/pyyu/p/6702896.html

版权声明
本文为[Tammy~]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/Summer-skr--blog/p/11503602.html