[python]一些常用的python知识总结

标签：实现   fun   enc   +=   查找   reading   自定义   ace   space   

Pthon知识积累，遇到的各种python问题汇总

json.dumps()和json.loads()是json格式处理函数

1. json.dumps()函数是将一个Python数据类型列表进行json格式的编码（可以这么理解，json.dumps()函数是将字典转化为字符串）
2. json.loads()函数是将json格式数据转换为字典（可以这么理解，json.loads()函数是将字符串转化为字典）
3. https://www.json.cn/ json解析网站

python2与python3编码

1. python2默认以ASCII编码，python默认为utf-8
2. #-- coding:utf-8 -- 申明编码
3. 字符串是由字符构成，字符在计算机硬件中通过二进制形式存储，这种二进制形式就是编码。如果直接使用 “字符串??字符??二进制表示（编码）” ，会增加不同类型编码之间转换的复杂性。所以引入了一个抽象层，“字符串??字符??与存储无关的表示??二进制表示（编码）” ，这样，可以用一种与存储无关的形式表示字符，不同的编码之间转换时可以先转换到这个抽象层，然后再转换为其他编码形式。在这里，unicode 就是 “与存储无关的表示”，utf—8 就是 “二进制表示”。 python2中字符串有两种表示形式，str和unicode。str可以理解为上面这段话中的二进制编码格式，unicode可以理解为抽象层。encode是编码，即从unicode格式到二进制的编码格式如utf-8、gb2312等。decode是解码，即从二进制编码格式到unicode编码格式。

数据结构与算法之快速排序算法

最优时间复杂度：O(nlogn)
最坏时间复杂度：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 ‘<h1>‘ + func(*args, **kwargs) + ‘<h1>‘
	return call_func
# 装饰器2  set_func2
def set_func2(func):
	def call_func(*args, **kwargs):
		return ‘<td>‘ + func(*args, **kwargs) + ‘</td>‘
	return call_func

@set_func1
@set_func2   # 此时相当于test = set_func(test)
def test():
	return ‘ok‘ 


print(test())

# 显示结果
<h1><td>ok</td><h1>

__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 0x00000207618E91D0>
# <__main__.Singleton object at 0x00000207618E91D0>

迭代器和生成器

如何判断一个对象是否可以迭代 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 < len(self.mylist.items):
            item = self.mylist.items[self.current]
            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