[python]一些常用的python知识总结
2021-05-17 12:31
标签：实现 fun enc += 查找 reading 自定义 ace space 最优时间复杂度：O(nlogn) 代码Pthon知识积累，遇到的各种python问题汇总
json.dumps()和json.loads()是json格式处理函数
python2与python3编码
数据结构与算法之快速排序算法
最坏时间复杂度：O(n2)
稳定性：不稳定def quick_sort(alist, start, end):
"""快排算法"""
left = start
right = end
mid = alist[start]
if start >= end:
return
while left right:
# 与基准值mid比较，如果alist[right]大于mid,指针向左移动
while alist[right] >= mid and left right:
right -= 1
alist[left] = alist[right]
# 与基准值mid比较，如果alist[left]小于mid,指针向右移动
while alist[left] mid and left right:
left += 1
alist[right] = alist[left]
alist[left] = mid
# 递归
quick_sort(alist, start, left-1)
quick_sort(alist, left+1, end)
if __name__ == ‘__main__‘:
li = [54, 26, 93, 77, 77, 31, 44, 55, 20]
print(li)
quick_sort(li, 0, len(li)-1)
print(li)
Python super() 函数
super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
python2代码实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class FooParent(object):
def __init__(self):
self.parent = ‘I\‘m the parent.‘
print (‘Parent‘)
def bar(self,message):
print ("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
super(FooChild,self).__init__()
print (‘Child‘)
def bar(self,message):
super(FooChild, self).bar(message)
print (‘Child bar fuction‘)
print (self.parent)
if __name__ == ‘__main__‘:
fooChild = FooChild()
fooChild.bar(‘HelloWorld‘)文件夹中的__init__
将文件夹目录变成python包
装饰器
通用装饰器
# 装饰器set_func
def set_func(func):
print(‘开始装饰‘)
def call_func(*args, **kwargs):
print (‘相关业务‘)
return func(*args, **kwargs)
return call_func
@set_func # 此时相当于test = set_func(test)
def test(num):
print(‘测试装饰器‘)
return ‘ok‘
test(100)多个装饰器装饰同一个函数，注意装饰顺序
# 装饰器1 set_func1
def set_func1(func):
def call_func(*args, **kwargs):
return ‘‘ + func(*args, **kwargs) + ‘‘
return call_func
# 装饰器2 set_func2
def set_func2(func):
def call_func(*args, **kwargs):
return ‘‘ + func(*args, **kwargs) + ‘
‘
return call_func
@set_func1
@set_func2 # 此时相当于test = set_func(test)
def test():
return ‘ok‘
print(test())
# 显示结果
ok/td>
__new__实现单例模式
单例模式：不管做了多少次实例化操作，都只创建一个对象。
魔法方法__new__：当创建实例对象时，先调用__new__方法，创建对象，分配内存空间，然后才会进行调用__init__方法进行初始化
class Singleton(object):
‘‘‘用__new__实现单例模式‘‘‘
# 定义类属性，用于存放实例
__instance = None
def __new__(cls, *args, **kwargs):
if cls.__instance is None:
# 继承父类，创建一个对象，即分配内存地址
cls.__instance = super().__new__(cls)
# __new__魔法方法中必须有返回值
return cls.__instance
# 创建实例对象
p1 = Singleton()
p2 = Singleton()
# 输出结果
print(p1)
print(p2)
# 显示结果，只创建了一个对象
# <__main__.singleton object at># <__main__.singleton object at>
迭代器和生成器
如何判断一个对象是否可以迭代 isinstance
from collections import Iterable
iter = isinstance([], Iterable)
print(iter)
可迭代对象
可迭代对象通过__iter__方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.
那么也就是说，一个具备了__iter__方法的对象，就是一个可迭代对象。
迭代器
一个实现了__iter__方法和__next__方法的对象，就是迭代器
可迭代对象和迭代器
class MyList(object):
"""自定义的一个可迭代对象"""
def __init__(self):
self.items = []
def add(self, val):
self.items.append(val)
def __iter__(self):
myiterator = MyIterator(self)
return myiterator
class MyIterator(object):
"""自定义的供上面可迭代对象使用的一个迭代器"""
def __init__(self, mylist):
self.mylist = mylist
# current用来记录当前访问到的位置
self.current = 0
def __next__(self):
if self.current 1
return item
else:
raise StopIteration
def __iter__(self):
return self
if __name__ == ‘__main__‘:
mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
mylist.add(4)
mylist.add(5)
for num in mylist:
print(num)
线程和进程
多线程共享全局变量，多进程不能共享全局变量
线程类
import threading
import time
class Mythread(threading.Thread):
"""线程类"""
def run(self):
for i in range(3):
time.sleep(1)
print(‘线程类‘)
self.login()
self.register()
def login(self):
print(‘登录‘)
def register(self):
print(‘注册‘)
if __name__ == "__main__":
t = Mythread()
t.start()
[python]一些常用的python知识总结
标签：实现 fun enc += 查找 reading 自定义 ace space
原文地址：https://www.cnblogs.com/skyell/p/9746765.html
上一篇：spring boot打包