关于数据结构：
列表 list： 定义的数据包括在 [] 中。列表中的数据是可修改的。例如
testlist = [1,2,3]. 或 testlist = list([1,2,3])
testlist[0] = 7
元组 tuple： 定义的数据包括在() 中，元组中的数据是不可修改的。当定义的元组只有一个数据时，数据后必须有一个逗号，如：(1, )。
testtuple = (1,2,3) 或 testtuple = tuple((1,2,3))
字典 dict: 字典中数据是以键值对的形式存在的，关于函数：d = {key1:value1, key2:value2}。定义及读取方式
集合 set：是无值的字典。使用 {} 括起来。集合中不包含重复元素。定义空集合的时候，必须使用 set 函数进行创建。
a = {1,2,3,4,5} 或 a = set((1,2,3,5)) 集合只可以包含值不可变的元素。添加列表list，或字典时会报错
集合和列表、字典可以通过解析函数（循环部分写右边，集合表达式写在左边）定义
{x for x in ‘spam’} = {‘s’,’p’,’a’,’m’}
[x for x in ‘spam’] = [‘s’,’p’,’a’,’m’]
{x:x*2 for x in range(2)} {0: 0, 1: 2}
list, tuple,set 这些函数中，参数可以是任何序列。需要拷贝时，
需要使用copy函数进行拷贝，
分片L[:] 可以拷贝。
有些内置函数如 list(L) 可以拷贝。
切片 L[1 : 10 : 3] 1表示起始位置。 10 表示结束位置， 3 表示步长。
文件中打包二进制数据的存储与解析：
需要用到struct模块。struct模块能够把文件中的字符串解读为二进制数据。
fmt 参数：
The optional first format char indicates byte order, size and alignment:
@: native order, size & alignment (default)
=: native order, std. size & alignment
<: little-endian, std. size & alignment
>: big-endian, std. size & alignment
!: same as >
pack(...)
pack(fmt, v1, v2, ...) -> bytes
unpack(...)
unpack(fmt, buffer) -> (v1, v2, ...)
Return a tuple containing values unpacked according to the format string
fmt. The buffer's size in bytes must be calcsize(fmt). See help(struct)
for more on format strings.
关于语法：
if 语句格式
if x == 'test':
print('test')
elif x == 'no':
print('no')
else:
print('default')if / else 三元表达式
A = Y if X else Z
当 X 为真， 执行 Y，
当X 为假， 执行 Z。
while 循环
i = 10
while i > 0:
print("i = %d"%i)
i = i - 1
else:
print("End")
for 循环
for i in range(1,10):
for j in range(1,i+1):
print("%d * %d = %d"%(j,i,j*i), end = ' ')
print("")
else:
print("endfor")
output:
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
endfor循环中可以使用 break ， continue， pass(什么都不做。)
关于函数：
python 中函数参数可以使用* , **修饰。
def func(*name) *name 表示可变参数。参数为一个序列(元组)，跟在*后的任何正式或默认的参数名称，都是keyword-only参数(带关键字名字的参数)
def func(**name) **name 表示一个字典，对应有相应的key和value。此形式的参数必现放在参数列表最后。
def func(**name):
for item in name:
print("name[%s]"%(item), "=" ,name[item])
func(value=1,hell=2)
输出结果为：
name[value] = 1
name[hell] = 2
当前执行的文件的 __name__ 值为 ‘__main__’
装饰器decorator，是使用一个返回函数的函数放置在定义的函数前面。例如：
def log(func):
def wrapper(*arg, **kw):
print("Call %s"%func.__name__)
return func(*arg,**kw)
return wrapper
@log
def now():
print("Test log")
print(now.__name__)
输出 wrapper类似于 __xxx 这样的函数或变量就是非公开的(private) 不能直接引用。__xx__ 此种变量名表示是特殊变量，是可以直接访问的，定义时避免使用此种类型的变量。
日志打印
import logging
logging.basicConfig(level=logging.INFO) #设置日志级别
logging.info(“打印日志”)
匿名函数
lambda arg1, arg2,....argN : expression using arg
f = lambda x,y,z : x+y+z
f(2,3,4) = 9
关于类：
class ClassName(Objec1, Object2,...):
passClassName 表示类名， Object表示继承自某类。
__init__ 函数 初始化类中的变量等。此函数在创建类的实例时调用。类似于构造函数。
class Test:
testparam = 0
# __init__ 初始化函数。
def __init__(self):
self.one = 10
__slots__ 用来限制绑定的属性名称。使用此属性约束后，添加的属性名称必须是约定的。否则会报错 AttributeError
class Test:
testparam = 0
__slots__ = ("name","age","__one")
def __init__(self):
self.__one = 10
def __get_1(self):
print(self.one)
def get_1(self):
print(self.__one)类中，方法的第一个参数总是接收方法调用的隐性主题，也就是实例对象。self.
运算符重载：
__repr__, __str__ 打印，转换，当类需要进行print 打印类本身时，可以重载此函数。
Python中的重载运算符都是类似于此。常见的运算符重载方法可以搜索获得。
class Readimg:
def __init__(self,filePath):
self.filePath = filePath
with open(filePath,'rb') as file:
bitdata = file.read(4*4)
data = struct.unpack(">4i",bitdata)
self.magic_num,self.num_images,self.row,self.columns=data
def saveimg(self,imgbuf,imgname,row = 28,columns = 28):
print("Enter saveimg ",type(imgname))
print("type imgbuf ",type(imgbuf))
#img = np.array(list(imgbuf)).reshape(row,columns)
#cv.imwrite("%s.png"%imgname,img)
def readimg(self):
with open(self.filePath,'rb') as file:
file.seek(4*4)
#i = 1
print("row = %d, columns = %d"%(self.row,self.columns))
imgbuf = file.read(self.row * self.columns)
img = struct.unpack('>784B',imgbuf)
Readimg.saveimg(self,list(img),"img0")
输出：
row = 28, columns = 28
Enter saveimg <class 'str'>
type imgbuf <class 'list'>当类中定义的函数中，第一个参数是比较特殊的，它总是接受将方法调用视为隐含主体的实例对象，按惯例定义为self。写成其他名字时，也会默认为实例对象。 内部调用时有两种方法：1、 直接使用self. 调用。 self.saveimg(list(img),”img0”)
2、 使用类名调用， 函数参数中加入 self 参数。 Readimg.saveimg(self,list(img),"img0")
技巧：
使用timeit 统计函数执行时间。
通常在一段程序的前后都用上time.time(),然后进行相减就可以得到一段程序的运行时间，不过python提供了更强大的计时库：timeit
timeit
通常在一段程序的前后都用上time.time(),然后进行相减就可以得到一段程序的运行时间，不过python提供了更强大的计时库：timeit
#导入timeit.timeit
from timeit import timeit
#看执行1000000次x=1的时间：
timeit('x=1')
#看x=1的执行时间，执行1次(number可以省略，默认值为1000000)：
timeit('x=1', number=1)
#看一个列表生成器的执行时间,执行1次：
timeit('[i for i in range(10000)]', number=1)
#看一个列表生成器的执行时间,执行10000次：
timeit('[i for i in range(100) if i%2==0]', number=10000)
测试一个函数的执行时间：
from timeit import timeit
def func():
s = 0
for i in range(1000):
s += i
print(s)
# timeit(函数名_字符串，运行环境_字符串，number=运行次数)
t = timeit('func()', 'from __main__ import func', number=1000)
print(t)此程序测试函数运行1000次的执行时间
扫一扫
1455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
