建购物网站 教程,简单网页的设计过程,昵图网免费素材图库,作文网站哪个平台好1.Python里面如何实现tuple和list的转换python中#xff0c;tuple和list均为内置类型#xff0c; 以list作为参数将tuple类初始化#xff0c;将返回tuple类型tuple([1,2,3]) #list转换为tuple以tuple作为参数将list类初始化#xff0c;将返回list类型list((1,2,3)) #tuple转…1.Python里面如何实现tuple和list的转换python中tuple和list均为内置类型 以list作为参数将tuple类初始化将返回tuple类型tuple([1,2,3]) #list转换为tuple以tuple作为参数将list类初始化将返回list类型list((1,2,3)) #tuple转换为list
1.函数tuple(seq)可以把所有可迭代的(iterable)序列转换成一个tuple, 元素不变排序也不变。 例如tuple([1,2,3])返回(1,2,3), tuple(‘abc’)返回(‘a’.b’,c’).
如果参数已经是一个tuple的话函数不做任何拷贝而直接返回原来的对象所以在不确定对象是不是tuple的时候来调用tuple()函数也不是很耗费的。
2.函数list(seq)可以把所有的序列和可迭代的对象转换成一个list,元素不变排序也不变。 例如 list([1,2,3])返回(1,2,3), list(‘abc’)返回[a, b, c]。
如果参数是一个list, 她会像set[:]一样做一个拷贝 2.Python里面re模块match()和search()的区别 # 一、解释 # match()函数只检测RE是不是在string的开始位置匹配 # search()会扫描整个string查找匹配,会扫描整个字符串并返回第一个成功的匹配 # 也就是说match只有在0位置匹配成功的话才有返回如果不是开始位置匹配成功的话match()就返回none# 二、例子 # match(): # print(re.match(‘super’, ‘superstition’).span())会返回(0, 5) # print(re.match(‘super’, ‘insuperable’))则返回None search(): # print(re.search(‘super’, ‘superstition’).span())返回(0, 5) # print(re.search(‘super’, ‘insuperable’).span())返回(2, 7)3.下面代码会输出什么 def f(x,l[]):for i in range(x):l.append(i*i)print(l)
f(2)#[0,1]
f(3,[3,2,1])#[3,2,1,0,1,4]
f(3)#[0,1,0,1,4] 4.请用至少一种方法删除下面list里面的重复元素li [1, 1, 2, 3, 3, 4, 4, 5, 5, 6]
a []
# 列表去重方法一集合方法
b set(li)
print(b)# 列表去重方法二遍历统计次数删除重复选项
for i in li:while li.count(i) 1:del li[li.index(i)]
print(li)# 列表去重方法三遍历列表添加新列表对比
a []
for i in li:if i in li:if i not in a:a.append(i)
print(a)#列表去重方法四先对元素进行排序然后从列表的最后开始扫描
list [1, 1, 2, 3, 3, 4, 4, 5, 5, 6]
if list:list.sort()last list[-1]for i in range(len(list)-2,-1,-1):if last list[i]:del list[i]else:last list[i]print(list)#列表去重方法五利用map的fromkeys来自动过滤重复值
l1 [1, 1, 2, 3, 3, 4, 4, 5, 5, 6]
l2 {}.fromkeys(l1).keys()
print(l2)5.请简述python中单例模式的特点并手写一个单例模式# 所谓单例是指一个类的实例从始至终只能被创建一次。# 方法1
# 如果想使得某个类从始至终最多只有一个实例使用__new__方法会很简单。Python中类是通过__new__来创建实例的class Singleton(object):_instance Nonedef __new__(cls, *args, **kw):if not cls._instance:cls._instance super(Singleton, cls).__new__(cls, *args, **kw)return cls._instanceclass MyClass(Singleton):a 1
oneMyClass()
twoMyClass()
print(id(one),id(two))# 结果id相同
# 在上面的代码中我们将类的实例和一个类变量 _instance 关联起来
# 如果 cls._instance 为 None 则创建实例否则直接返回 cls._instance。# 方法2
# 有时候我们并不关心生成的实例是否具有同一id而只关心其状态和行为方式。
# 我们可以允许许多个实例被创建但所有的实例都共享状态和行为方式class Borg(object): _shared_state{} def __new__(cls,*args,**kwargs): objsuper(Borg,cls).__new__(cls,*args,**kwargs) obj.__dict__cls._shared_state return obj
# 将所有实例的__dict__指向同一个字典这样实例就共享相同的方法和属性。
# 对任何实例的名字属性的设置无论是在__init__中修改还是直接修改所有的实例都会受到影响。
# 不过实例的id是不同的。要保证类实例能共享属性但不和子类共享注意使用cls._shared_state,
# 而不是Borg._shared_state。
# 因为实例是不同的id所以每个实例都可以做字典的keyif __name____main__: class Example(Borg): pass aExample() bExample() cExample() adict{} j0 for i in a,b,c: adict[i]j j1 for i in a,b,c: print(adict[i] )
# 结果
# 0
# 1
# 2
# 如果这种行为不是你想要的可以为Borg类添加__eq__和__hash__方法
# 使其更接近于单例模式的行为class Borg(object): _shared_state{} def __new__(cls,*args,**kwargs): objsuper(Borg,cls).__new__(cls,*args,**kwargs) obj.__dict__cls._shared_state return obj def __hash__(self): return 1 def __eq__(self,other): try: return self.__dict__ is other.__dict__ except: return False
if __name____main__: class Example(Borg): pass aExample() bExample() cExample() adict{} j0 for i in a,b,c: adict[i]j j1 for i in a,b,c: print(adict[i])
# 结果
# 2
# 2
# 2
# 所有的实例都能当一个key使用了。# 方法3
# 当你编写一个类的时候某种机制会使用类名字基类元组类字典来创建一个类对象。新型类中这种机制默认为type而且这种机制是可编程的称为元类__metaclass__ 。class Singleton(type): def __init__(self,name,bases,class_dict): super(Singleton,self).__init__(name,bases,class_dict) self._instanceNone def __call__(self,*args,**kwargs): if self._instance is None: self._instancesuper(Singleton,self).__call__(*args,**kwargs) return self._instance
if __name____main__: class A(object): __metaclass__Singleton aA() bA() print (id(a),id(b))
# 结果
# 34248016 34248016
# id是相同的。
# 例子中我们构造了一个Singleton元类并使用__call__方法使其能够模拟函数的行为。
# 构造类A时将其元类设为Singleton那么创建类对象A时行为发生如下
# ASingleton(name,bases,class_dict),A其实为Singleton类的一个实例。
# 创建A的实例时A()Singleton(name,bases,class_dict)()Singleton(name,bases,class_dict).__call__()这样就将A的所有实例都指向了A的属性_instance上这种方法与方法1其实是相同的。# 方法4
# python中的模块module在程序中只被加载一次本身就是单例的。可以直接写一个模块将你需要的方法和属性写在模块中当做函数和模块作用域的全局变量即可根本不需要写类。
# 而且还有一些综合模块和类的优点的方法class _singleton(object): class ConstError(TypeError): pass def __setattr__(self,name,value): if name in self.__dict__: raise self.ConstError self.__dict__[name]value def __delattr__(self,name): if name in self.__dict__: raise self.ConstError raise NameError
import sys
sys.modules[__name__]_singleton()
# python并不会对sys.modules进行检查以确保他们是模块对象
# 我们利用这一点将模块绑定向一个类对象而且以后都会绑定向同一个对象了。
# 将代码存放在single.py中import single single.a1single.a2 ConstError del single.a
ConstError# 方法5
# 最简单的方法class singleton(object): pass
singletonsingleton()
# 将名字singleton绑定到实例上singleton就是它自己类的唯一对象了。
