python常用api_PYTHON 常用API ***

最新推荐文章于 2023-04-23 09:54:36 发布

weixin_39550937

最新推荐文章于 2023-04-23 09:54:36 发布

阅读量140

点赞数

文章标签： python常用api

1、类型判断

data = b''data=bytes()print(type(data))#isinstance(123,int)

if type(L) == type([]):

print ("yes")

if type(L) == list:

print ("yes")

if isinstance(L, list):

print ("yes")

if L is M

print ("Same")

if not isinstance(x, list):

tot += x

2、指定编码格式

with open("d:\kitking\iot.txt", 'rt',encoding='utf-8') as f:

data=f.read()print(data)#二进制读写

with open("d:\kitking\iot.bin", 'rb') as f:

data=f.read()

with open("somefile.bin",'wb') as f:

f.write(b'hello')#如果打开时没有指定编码格式，可以用包装器在打开后指定编码格式

importurllib.requestimportio

u= urllib.request.urlopen('http://www.python.org')

f= io.TextIOWrapper(u, encoding='utf-8')

text=f.read()print(text)

3、无格式字节流

bytes 不可变字节类型

byrearray 可变字节数组

>>> b =bytearray()>>> b.append(10)>>> b.remove(100)>>> b.insert(0, 150)>>> b.extend([1, 3, 5])>>> b.pop(2)>>>b.reverse()>>>b.clear()#返回16进制表示的字符串

>>>bytearray(‘abc’.encode()).hex()#bytes<->str转换

>>> aStr = u'abc'

>>> b= bytes(aStr, encoding='utf-8')>>> newStr = str(b, encoding='utf-8')#动态开buff

buf =bytearray(os.path.getsize(filename))#读文件到buf

with open(fileName, 'rb') as f:

f.readinto(buf)

#数值<->字串转换

int("42"),str(42)

4、I/O映射

importio

s=io.StringIO()

f= io.BytesIO()

5、文件->内存映射（切片方式修改内存）

importmmap

fileName= "d:\kitking\iotBaidu.bin"size=os.path.getsize(fileName)

fd=os.open(fileName, os.O_RDWR)

m= mmap.mmap(fd, size, access=mmap.ACCESS_WRITE)

m[0:11] = b'Hello World'm.close()

#shell下使用"od -x iotBaidu.bin"查看修改情况

6、读写压缩文件

importgzip

with gzip.open("someFile.gz", 'rt') as f:

text=f.read()importbz2

with bz2.open('someFile.bz2', 'rt') as f:

text= f.read()

7、串行化

importpickle

data= ... #some python object

f = open("fileName", 'wb')

pickle.dump(data, f)#如果存储为字符串使用 pickle.dumps()

#Restore from a file

f = open("fileName", 'rb')

data=pickle.load(f)#Restore from a string

data = pickle.loads(f)

迭代式pickle：连续dump/load

>>> importpickle>>> f = open('fileName.pkl', 'wb')>>> pickle.dump([1,2,3,4], f)>>> pickle.dump('hello', f)>>> pickle.dump({'Apple', 'Pear', 'Banana'}, f}>>>f.close>>> f = open('fileName.pkl', 'rb')>>>pickle.load(f)

[1, 2, 3, 4]>>>pickle.load(f)'hello'

>>>pickle.load(f)

{'Apple', 'Pear', 'Banana'}

db方式：

import shelve#串行化

db = shelve.open('persondb')for object in(bob, sue, tom):

db[object.name]=object

db.close()#解串行化

db = shelve.open('persondb')

len(db)

list(db.keys())

bob= db['Bob Smith']for key indb:print(key, '=>', db[key])

二进制串行化

#串行化

from struct importStructdefwrite_records(records, format, f):

record_struct=Struct(format)for r inrecords:

f.write(record_struct.pack(*r))if __name__ == '__main__':

records= [ (1, 2.3, 4.5),

(6, 7.8, 9.0),

(12, 13.4, 56.7) ]

with open('data.b', 'wb') as f:

write_records(records,'

from struct importStructdefunpack_records(format, data):

record_struct=Struct(format)return(record_struct.unpack_from(data, offset)for offset inrange(0, len(data), record_struct.size))if __name__ == '__main__':

with open('data.b', 'rb') as f:

data=f.read()for rec in unpack_records('

from struct importStructdefread_records(format, f):

record_struct=Struct(format)

chunks= iter(lambda: f.read(record_struct.size), b'')return (record_struct.unpack(chunk) for chunk inchunks)if __name__ == '__main__':

with open('data.b','rb') as f:for rec in read_records('

8、lambda

L = [1, 2, 3, 4]

list(map(lambda x: x+3), L))#输出:#[4, 5, 6, 7]

list(filter((lambda x: x > 0), range(-5, 5)))

#输出：

#[1, 2, 3, 4]

list( map((lambda x: x**2), filter((lambda x: x%2) == 0), rang(10))) )

#[0, 4, 16, 36, 64]

9、迭代器、生成器

可迭代的：容器（list, deque, set, frozensets, dict, defaultdict, OrderedDict, Counter, tuple, namedtuple, str）、files、sockets均为可迭代对象

#“可迭代的”指的是支持iter的一个对象，而“迭代器”指的是iter所返回的一个支持next(I)的对象#“可迭代对象”是序列观念的通用化，如果对象是实际保存的序列，或者可以在迭代工具环境中(例如 for循环)一次产生一个结果的对象，就看做是可迭代的

from functools importpartial

RECORD_SIZE= 32with open('data.bin', 'rb') as f:

records= iter(partial(f.read, RECORD_SIZE), b'')for r inrecords:print(r)#偏函数：把一个函数的某些参数固定住（也就是设置默认值），返回一个新函数#输出：#b' 0 5412 N CLARK'#b' 3 5148 N CLARK'

for循环的执行过程

#for作用在可迭代对象上，首先启用对象的迭代器，然后每次循环自动调用迭代器对象的next()方法产生一个值#注意:文件对象、生成器函数、生成器表达式都是自身的迭代器

L = [1, 2, 3]for x inL:printx#执行过程

I =iter(L)

I.next()#1

I.next() #2

I.next() #3

I.next() #迭代结束产生异常

Traceback(most recent call last):

StopIteration#手动迭代变化如下：

I =iter(L)whileTrue:try:

X=next(I)exceptStopIteration:break

生成器表达式

>>> mygenerator = (x*x for x in range(3))　　 #生成器表达式

>>>mygenerator　　　　　　　　#生成器迭代对象#先产生生成器mygenerator，虽然为0/1/4，但不是一次性产生，而是每执行一次for循环产生一个值

>>> for i inmygenerator :

...print(i) #0 1 4#注意生成器是括号()不是[],生成器每次生成一个值#for循环作用在可迭代对象上，首先生成可迭代对象的迭代器“iterator”，再调用迭代器的“next”方法获取容器的一个值

生成器函数yield

#Python延迟生成技术，yield每次返回一个结果，在每个结果之间挂起和继续它们的状态，生成器函数自动在生成值的时刻挂起并继续函数的执行#当调用yiel时，返回一个可迭代对象，该对象支持__next__()方法，迭代完成引发StopIteration异常

deffab(max):

n, a, b= 0, 0, 1

while n

a, b= b, a +b

n= n + 1

for n in fab(5):printn#输出：1 1 2 3 5

#或者使用迭代器

>> f = fab(5)>> f.next #1

>> f.next #1

>> f.next #2

生成器函数 & 生成器表达式都是自身的迭代器

>>>G = (c*4 for c in 'SPAM')>>>iter(G) isG

True

10、类

#属性赋值

x.data = "New value"

#增加属性

x.anothername = "spam"

#覆盖超类方法，即重载

classSecondClass(FirstClass):#重载构造函数

def __init__(self, name, pay):

FistClass.__init__(self, name, 'mgr', pay)defdisplay(self):#运算符重载，使之更像内置类型运算

def __add__(self, other):return SecondClass(self.data +other)def __str__(self):return '[Person: %s, %s]' %(self.name, self.pay)#多态发生在继承类,执行子类还是超类的geveRaise，取决于实例

for object in(bob, sue, tom):

object.geveRaise(.10)print (object)　　#显示object's __ str__

11、JSON

importjson

data= { 'name' : 'ACME','shares' : 100,'price' : 542.3}#python->json

json_str =json.dumps(data)#json->python

data =json.loads(json_str)#序列化JSON

with open('data.json', 'w') as f:

json.dump(data, f)

WEB流

form urlib.request importurlopenimportjsonimportpprint

u= urlopen('http://kitking01.eicp.net')