python
Python
(np.array([0.8,0.4,0.3,1])>0.5).astype('int32')
a or b
isinstance(outputs, (list, tuple))
requirements.txt的作用
用于记录所有依赖包及其精确的版本号。以便新环境部署。
使用pip生成
pip freeze >requirements.txt
当需要创建这个虚拟环境的完全副本,可以创建一个新的虚拟环境,并在其上运行以下命令
pip install -r requirements.txt
如果在pyqt里头使用多进程,需在Main函数里头加入multiprocessing.freeze_support()
单个Python32.exe最大1G运行内存
http://www.lfd.uci.edu/~gohlke/pythonlibs/
PyPI是Python官方包仓库,从PyPI安装包是一件很简单的事,因为Python有一个工具"pip"。
pyc文件S是由py文件经过编译后二进制文件,py文件变成pyc文件后,加载的速度有所提高,而且pyc是一种跨平台的字节码,是由python的虚拟机来执行的。
pyo是源文件优化编译后的文件
pyd是其他语言写的Python库
pyx是python的c扩展文件,代码要符合cython的规范,是源代码文件,要想被python调用,运行,还要转成.c或c++文件并进一步转成pyd文件,pyd文件才是可以直接使用的文件。
安装后的python库都是py和pyd文件
直接下载的tar,gz等文件是源码文件,一般都能找到Pyd文件的对应pyx文件
socket.gethostname()# get computer hostname
t0 = time.time()
dt = time.time() - t0
print("The time is {0}".format(time.ctime()))
python导入某个库,会先加载库中的_init_.py文件
重新导入模块
import importlib
importlib.reload(xxx)
import os
cmd=''
os.system(cmd)
1.tuple元组是不可修改的
2.python 对变量重新初始化后内存地址会改变。但赋值(增删改等)并不会改变其内存地址
如 int1 =1 ;int2 = int1; int1.append(2);#则int2的值也会随之改变,因为int1,int2指向同一块地址
3.浅拷贝:拷贝的是地址 (copy.copy)
4.深拷贝:对拷贝变量与被拷贝变量的任意改变,它们之间互不影响。(copy.deepcopy)
a.top(),删除最后a的一个元素
a.remove([]),删除a中的元素[]
a[0:100]即为C++的[0:99]
列表list才可以用append
-- coding: utf-8 --
python2.7#D:\python\Anacon_python\Code\neural-networks-and-deep-learning-master1\src\mmass_v5.5.0_source\mMass
python3.5#D:\python\python3.5\code\
所以如果有需要求(集合,列表等)的并集和交集的时候,最好使用Set
a*b(矩阵点乘)
np.dot(a,b)(矩阵乘法)
np.multiply(a,b)(矩阵点乘)
a[:,k]
a[i,:]
m, n = a.shape
np.zeros((n,m))
数值数组转字符串数组
a=np.array([1,2,3])
a.astype(str)
a.astypr(int),限定a中的元素为整型,或者以a或a中的元素作为索引会出错
list()很适合用于链表结构
字符串转数组
str = '1,2,3'
arr = str.split(',')
字符串数组转字符串
arr = ['a','b']
str = ','.join(arr)
python类中的self实质是一对象,因此可以通过把self赋给其他变量进行类之间通信
{'x':1,'y':2}
fromkeys()创建一个默认字典,字典中元素具有相同的值
dict.fromkeys(('x','y'),1)
for key in x.keys():
x[key]
for else,for循环运行成功后才会接着运行else语句
for x in range(10) :
print(x)
else :
print('succeed')
del dict2#删除字典dict2
del dict2['name']删除键为"name"的条目
dict2.pop('name')删除并返回键为"name"的条目
'name' in dict2#判断'name'是否是一个键
列表list的元素可以是互不相同的且可以是任意类型
对于序列(列表,元组,字符串),+,*等就变为重复操作符
x=[1,2,3] ;y=iter(x)
这里x是可迭代对象,y是迭代器
任何具有__next__()方法的对象都是迭代器
生成器其实就是一种特殊的迭代器。它使一种更为高级、更为优雅的迭代器
任意生成器都是迭代器(反过来不成立)
后进先出: 一堆盘子
先进先出:排队取钱
一个数据类型是不可变的,就意味着一旦一个对象被定义了,它的值(之前的值)就不能再被更新,但可以添加新值
除非重新创建一个新的对象。
squared = [x**2 for x in range[4] ]一行代码使用一个for循环将所有值放到一个列表中
Operation Result Notes
x or y if x is false, then y, else x (1)
x and y if x is false, then x, else y (2)
not x if x is false, then True, else False (3)
python中的self类似于matlab gui里的handles
Python中没有专门定义结构体的方法,但可以使用class标记定义类来代替结构体
class item:
def init(self):
self.name = '' # 名称
self.size = 10 # 尺寸
self.list = [] # 列表
a = item() # 定义结构对象
a.name = 'cup'
a.size = 8
a.list.append('water')
dir([obj]) 显示对象的属性,如果没有提供参数,则显示全局变量的名字
str(obj) 将一个对象转为字符串
type(obj)返回对象的类型
\(换行分割符)
代码对象是编译过的python源代码片段,它是可执行对象。通过调用内建函数compile()
可以得到代码对象。代码对象可以被exec命令或eval()内建函数来执行。
eval("1+3")
帧对象表示python的执行栈帧。用到帧对象的一个地方是跟踪记录对象。 P60
not a ;a andb; a or b;
i=cmp(a,b)
i<0 if a<b ;i>0 if a>b;i0 if ab
repr(obj) 返回一个对象的字符串表示
一个能保存单个字面对象的类型,称它为原子或标量存储;
那些可容纳多个对象的类型,称之为容器存储。
所有的python容器对象都能够容纳不同类型的对象
id(x) 得到x的身份号,这是最接近于指针的地址。但不能控制这个值。所以
没有太大意义。
存储模型 更新模型 访问模型
数字 标量 不可更改 直接访问
字符串 标量 不可更改 顺序访问
列表 容器 可更改 顺序访问
元组 容器 不可更改 顺序访问
字典 容器 可更改 映射访问
a/b 其中a是nxm,b是1xm
/传统除法 1/2=0 ;1/2.0=0.5
//地板除 1//2.0=0
%取余
divmod()把除法和取余运算结合起来,返回一个包含商和余数的元组
round(3.499)=3 四舍五入
round(3.499,1)=3.5
ord()接受一个字符,返回其对应的整型值
chr()接受一个单字节整型值,返回一个字符串
smaller = x if x<y else y 得到小的值
prev = np.zeros(d) if t == 0 else Hout[t-1]
sorted()和zip()返回一个序列(列表),而另外两个函数reversed()和enumerate()返回迭代器(类似序列)
根本上说,迭代器就是有一个next()方法的对象,而不是通过索引来计数。当你或是一个循环机制(例如for语句)需要下一个项时,调用迭代器的next()方法就可以获得它。条目全部取出后,会引发一个StopIteration异常,这并不表示错误发生,只是告诉外部调用者,迭代完成。
itertools模块,包含各种有用的迭代器。
[x for x in seq if x%2]
[(x+1,y+1) for x in range(3) for y in range(5) ]
列表解析:一个非常有用,简单而且灵活的工具,可以用来动态的创建列表。
a=[expr for iter_var in iterable]
生成器表达式是列表解析的一个拓展。生成器是特定的函数,允许你返回一个值,然后
“暂停”代码的执行,稍后恢复。
包是一个有层次的文件目录结构,它定义了一个由模块和子包组成的python应用程序执行环境。
类:类是对象的定义,而实例是“真正的实物”,它存放了类中所定义的对象的具体信息。
class Assistant(object): #定义类
def printFoo(self): #定义方法
print 'hello'
class AddrBookEntry(object):
def init(self,nm,ph): #构造器
self.name = nm
self.phone = ph
def updatePhone(self, newph)
self.phone = newph
ADD= AddrBookEntry() #报错,参数不对 ;ADD= AddrBookEntry('bda',7456798)
为与OOP惯例保持一致,Python严格要求,没有实例化,类方法是不能被调用的
dir()返回的仅是对象的属性的一个名字列表。 而__dict__返回的是一个字典,它的
键是属性名,键值是相应的属性对象的数据值。(通常用__dict__会比较好)
方法仅仅是类内部定义的函数(这意味着方法是类属性而不是实例属性)
当存在一个实例时,方法才被认为是绑定到那个实例了
方法,不管绑定与否,都是由相同的代码组成的。唯一的不同在于是否存在一个实例
可以调用此方法
class TestStaticMethod:
@staticmethod
def foo():
print('dadas')
@classmethod
def foos(cls):
print('sti[')
def fooo(self):
print('foo')
经典类使用的深度优先搜寻
新式类使用的广度优先搜寻
.mro,查找搜寻顺序
issubclass(sub,sup)判断一个类是另一个类的子类或子孙类
isinstance(obj1,class)判断obj1是否是class的实例
进程(重量级进程)是程序的一次执行。每个进程都有自己的地址空间、内存、数据栈
以及其他记录其运行轨迹的辅助数据。
线程(轻量级进程)跟进程有些相似,不同的是 ,所有的线程运行在同一个进程中,共享相
同的运行环境。它们可以被想象成是在主进程或“主线程”中并行运行的"迷你进程"
线程有开始,顺序执行和结束三部分。它有一个自己的指令指针,记录自己运行到什么地方。
线程的运行可能被中断,或暂时的被挂起,让其他的线程运行(让步)
python提供了几个用于多线程编程的模块,包括thread,threading和Queue等。thread和
threading模块允许程序员创建和管理线程。thread模块提供了基本的线程和锁的支持,而
threading提供了更高级别,功能更强的线程管理的功能。Queue模块允许用户创建一个可以用于多个线程之间共享数据的队列数据结构。
class ThreadFunc(object):
def init(self,func,args,name='')
self.name = name
self.func =func
self.args = args
def __call__(self):
self.func(*self.args)
Queue模块可以用来进行线程间通讯, 让各个线程之间共享数据。
结构化查询语句(SQL)
open(file_name,access_mode='r',)
seek()可以在文件中移动文件指针到不同的位置。
os.listdir()#列出当前目录下的文件
os.path.exists()#判断文件是否存在
os.path.dirname()去掉文件名,返回目录路径
os.path.basename() 去掉目录路径,返回文件名
os.path.splitext(line) 返回文件类型
os.path.abspath(path)#返回path规范化的绝对路径
os.path.isabs(path) #如果path是绝对路径,返回true
os.path.isfile(path) #如果path是一个存在的文件,true
os.path.isdir(path)#如果path是一个存在的目录,则返回True
os.path.join(path1[, path2[, ...]])
将多个路径组合后返回,第一个绝对路径之前的参数将被忽略。
os.path.normcase(path) #在windows平台上会将路径中所有字符转换为小写,并将所有斜杠转换为饭斜杠。
os.getcwd()获取当前工作路径
os.chdir('xxx')切换工作路径
Numpy (np)
np.arange(-8,8,2)以2的间隔
np.linspace(-8,8,1000)生成1000个数
np.info()#查看例子,说明文档
np.argsort (a) %索引
对于数组变量a,可以先把它转换成list,再del a[0]
np.concatenate((a,a)) 数组合并
xAxis.shape = (-1,1)
yAxis.shape = (-1,1)
data = numpy.concatenate((xAxis,yAxis), axis=1)
b=[a,a],那么b就会变成一个长度为2的list
a[10💯20] 从10:100个元素,以20的间隔取值
a[10:0:-2] == a[[2,4,6,8,10]]
c = b.astype(int)转化数据类型
np.argsort(x)排序并返回索引
np.random.permutation(10)==randperm(10)
np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])p,是概率,1,4是不会选到的。
random.randrange(10)
n*m矩阵
wcoef.shape=(-1,1)
if i==0:
wCoefs = wcoef
else:
wCoefs = np.concatenate((wCoefs,wcoef),axis=1)
np.vstack((c,c))
np.hstack((c,c))
此时 wCoefs是ndarray ,shape=n*m,且操作比较方便
wCoefs=[]
wCoefs.append(temp)
此时wCoefs是一个list,长度为n,n个长度为m个temp
通过np.array(wCoefs)可将其转化为矩阵结构。所以平时可先将其保存为list,list
里的每个元素都是一个数组
x.flatten()将一个m*n展开成一向量
np.where(localMax[:,iInit]>0)[0] 返回行索引
np.delete()
c=[1,2,3]
c.index(max(c))
d=np.array(c)
np.where(d==max(d))[0][0]
d.tolist()
Pyqt(python qt Gui快速编程)
python的控制台应用程序和python的木块文件总是会使用.py的文件后缀,不过对于Python GUI应用程序来说,则会使用.pyw的文件后缀。
布局窗口部件(Windows中称为空间)
每个PyQt GUI应用程序都必须有一个QApplication对象。这个对象会提供访问全局信息的能力
无论是QDialog还是QMainWindow,实际上,PyQt里面的所有窗口部件都是继承自QWidget的
在有些情况下,即使应用程序不可见,但仍旧希望该程序依然能够运行。对于这些情况,可以调用QApplication.setQuitOnLastWindowClosed(False)来实现。
setFocus光标定在那
self.connect()#触发事件
principalLabel = QLabel("Principal:")#生成一个标签
self.principalSpinBox = QDoubleSpinBox()
self.principalSpinBox.setRange(1, 1000000000)#设置范围
self.principalSpinBox.setValue(1000)#设置值
self.principalSpinBox.setPrefix("$ ")#设置符号
yearsLabel = QLabel("Years:")
self.yearsComboBox = QComboBox()
self.yearsComboBox.addItem("1 year")
self.yearsComboBox.addItems(["%d years" % x
for x in range(2, 26)])
amountLabel = QLabel("Amount")
self.AmountLabel = QLabel()
第四章主要内容包含一些常用的QT函数,以及如何创建简单的GUI
QTextBrowser,QVBoxLayout ,QLineEdit ,QListWidget
,QDoubleSpinBox ,QLabel,QComboBox,setFocus,connect,setLayout,setWindowTitle
app = QApplication(sys.argv)
app.exec_()
简易对话框
当对一个对话框调用exec_()方法时,该对话框就会以模态形式显示出来。
penButtonInline = QPushButton("Set Pen... (Dumb &inline)")
setBuddy(),为那些无法使用鼠标的键盘用户提供支持。
模态与非模态对话框的不同之处看似只是按钮上文字的区别。然而,实际上却有两个非常重要的不同:调用窗体的方法在创建和调用对话框时有所不同,且在关系对话框时,务必要确保删除了对话框,而不是仅仅隐藏了对话框。
QImage不是QObject的子类,所以它并不需要父对象
从最终用户的角度看,一个对话框的用户界面是用手写代码完成的还是用Qt designer完成的没两样。然而,在实现一个对话框的初始化程序时却有着显著的不同,因为如果是用手写代码的形式完成的,就必须自己去创建,布局并连接对话框的各个窗口部件,而如果是用Qt设计师完成的用户界面,则只需调用特定的方法就可以达到同样的效果
QWidget.setTabOrder()设置哪些窗口部件依次获得键盘光标。
pyrcc4 -o images.py images.qrc
pyuic4 -o ui_name.py name.ui
在目录PyQt4\uic下运行 python pyuic.py -o ui_name.py name.ui
D:\python\Anacon_python\Lib\site-packages\PyQt4\uic>py2 pyuic.py -o ui_findandreplacedlg.py findandreplacedlg.ui
安装Qt设计师
使用Qt设计师的一些基本原理都总是一样的:先把窗口部件拖到窗体,容器(比如框架,群组框,Tab窗口部件等)上,然后,设置这些窗口部件的各个属性。接着,添加一些分隔符来占用空隙。再然后,选择一些特殊的窗口部件,分隔符,布局等,然后对它们应用布局功能,重复这一步骤, 直至布局了所有一切。再次,对窗体自身布局。最后,设置伙伴,按键次序和信号槽连接
信号和槽机制用于完成界面操作的响应,是完成任意两个Qt对象之间的通信机制。其中,信号会在某个特定情况或动作下被出发,槽是等同于接收并处理信号的函数。每个Qt对象都包含若干个预定义的信号和若干个预定义的槽,当某个特定事件发生时,一个信号被发送,与信号相关联的槽则会响应信号并完成相应的处理。当一个类被继承时,该类的信号和槽也同时被继承,也可以根据需要自定义信号和槽。
信号和槽机制增强了对象之间通信的灵活性,然而也损失了一些性能。同回调函数相比,信号和槽机制运行速度有些慢。
无论何时,在需要自动连接时,都可以使用@pyqtSignature修饰符来给定信号的参数。使用修饰符的目的是为了区分各个具有同样名字不同参数的信号。
在加载和保存自定义数据时,可供使用的选项有5种。可以使用二进制、普通文本、XML文件,或者可以使用带有明确文件名的QSetting对象,又或者可以使用数据库。
QMainWindow是一个为用户提供主窗口程序的类,包含一个菜单栏(menu bar)、多个工具栏(tool bars)、多个dock widget。,一个状态栏(status bar)以及一个中心部件,是许多应用程序的基础。
QT的菜单就是由一系列的QAction动作对象构成的列表。
QT的状态栏通常显示GUI应用程序的一些状态信息。一个主窗口最多只有一个状态栏、
QMainWindow::createPopupMenu()激活上下文菜单
简单框架:
class Form(QDialog):
def __init__(self,parent=None):
super(Form,self).__init__(parent)
#添加控件
self.widthSpinBox = QDoubleSpinBox()
#设置控件属性
self.widthSpinBox.setValue()
#添加控件入主窗口
grid = QGridLayout()
grid.addWidget(self. widthSpinBox)
self.setLayout(grid)
#添加事件
self.connect(self.colorButton,SIGNAL("clicked()")
,self.getColor)
app = QApplication(sys.argv)
form = Form()
form.show()
app.exec_()
在pyqt上matplotlib画图
Alt+Shift+R #预览
Ctrl+Shift+F11 #全屏
安装whl方法
将whl文件放在python的Scripts目录下,在该目录下打开命令窗口,运行pip install whl即可
在线下载
pip install
QVBoxLayout,QHBoxLayout和QGridLayout均是框式布局,网格布局(grid layout)
伸展因子,用来说明布局管理器是如何分配窗口部件之间的空间的。
QLabel()标签
QListWidget()框
QPushButton()按钮
QLineEdit()文本输入框
QLCDNumber()数字显示框
- coding: utf-8 --中文
qm文件是QT工程用于进行自定义中英文翻译的源文件
The typical use of a QSplitter is to create several widgets and add them using insertWidget() or addWidget().
self.next_page_button.hide()#隐藏button
self.v_layout.addStretch()
self.v_layout.setSpacing(50) #平均分配
self.v_layout.setContentsMargins(0, 15, 0, 0) #设置距离边界的值
编写规则:
1.文件名用main_Widget
2.类名 MainWidget
3.变量名 mainWidget
4.self. timeSeries_button(控件)
在pyinstaller.exe所在目录终端下运行pyinstaller name.py
--hidden-import sklearn.neighbors.typedefs
pyinstaller -F -w D:\Projects\PYTHON\TensorFlow-Examples-master\breath.py --hidden-import sklearn.neighbors.typedefs
D:\python\anaconda3_64\scripts\pyinstaller --paths D:\python\Anaconda3_64\Lib\site-packages\scipy\extra-dll --hidden-import=scipy --hidden-import scipy._lib.messagestream EKMA.py
若用了QT,则需要把打包后Pyqt5文件夹下的platforms,imageformats文件夹复制到exe目录下
若运行打包好的exe出错,则把-w去掉,让错误显示在DOS窗口上
scikit-learn
import sklearn
from sklearn.linear_model import LogisticRegression
class Pipeline(_BasePipeline):
"""Pipeline of transforms with a final estimator.
Sequentially apply a list of transforms and a final estimator.
Intermediate steps of the pipeline must be 'transforms', that is, they
must implement fit and transform methods.
The final estimator only needs to implement fit.
The :mod:sklearn.grid_search
includes utilities to fine-tune the parameters
of an estimator.
from sklearn import linear_model (自动加载了包linear_model里的__init__.py文件)
clf=linear_model.LinearRegression()初始化类实例对象
clf.fit([[0,0],[1,1],[2,2]],[0,1,2])
clf.coef_
import numpy as np
X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
from sklearn.decomposition import NMF(自动加载了包decomposition 里的__init__.py文件)
model = NMF(n_components=2, init='random', random_state=0)//初始化类实例
model.fit(X)//调用类NMF中的方法
print(model.components_)# doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
The objective function is::
0.5 * ||X - WH||_Fro^2
+ alpha * l1_ratio * ||vec(W)||_1
+ alpha * l1_ratio * ||vec(H)||_1
+ 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2
+ 0.5 * alpha * (1 - l1_ratio) * ||H||_Fro^2
Where::
||A||_Fro^2 = \sum_{i,j} A_{ij}^2 (Frobenius norm)
||vec(A)||_1 = \sum_{i,j} abs(A_{ij}) (Elementwise L1 norm)
The objective function is minimized with an alternating minimization of W
and H.
4.1 广义线性模型
ord与chr相反
divmod(a,b),求a除以b的整数值与余
enumerate() returns a tuple containing a count (from start which defaults to 0) and the values obtained from iterating over iterable.
Equivalent to:
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
eval(expression, globals=None, locals=None)
he expression is executed in the environment where eval() is called. The return value is the result of the evaluated expression
exec(object[, globals[, locals]])
This function supports dynamic execution of Python code. object must be either a string or a code object
The built-in functions globals() and locals() return the current global and local dictionary,
filter(function, iterable)
Construct an iterator from those elements of iterable for which function returns true. iterable may be either a sequence, a container which supports iteration, or an iterator
format(value[, format_spec])¶
Convert a value to a “formatted” representation, as controlled by format_spec.
'{0}{1}{0}'.format('abra', 'cad')
from collections import Counter
Counter(seq)%计算seq中各个元素出现的频数
zip()
Make an iterator that aggregates elements from each of the iterables.
super(ClockProcess,self).init() #父类初始化
multiprocessing.cpu_count() #cpu核心个数
python 2to3.py -w E:\ipv6--master\IPV6.py
获取文件夹下的文件以及文件夹名称
def getListFiles(path):
ret = []
for root, dirs, files in os.walk(path):
return [dirs,files]
Python可以在Java,.NET开发平台上使用
Python是强类型语言,变量创建后会对应一种数据类型
Python文件类型
1.Python的文件类型分为3种,即源代码、字节代码和优化代码。这些都可以直接运行,不需要进行编译或连接。
2.源代码以.py为扩展名,由python来负责解释
3.源文件经过编译后生成扩展名为.pyc的文件,即编译过的字节文件。这种文件不能使用文本编辑器修改。pyc文件是和平台无关的,可以在大部分操作系统上运行。如下语句可以用来产生pyc文件:
import py_compile
py_compile.compile('hello.py')
4.经过优化的源文件会以.pyo为后缀,即优化代码。它也不能直接用文本编辑器修改,如下命令可用来生成pyo文件:
python -O -m py_complie hello.py
id()可以获取变量标识
可以把全局变量放到一个专门的文件中,然后通过import来引用
三引号中可以输入单引号、双引号或换行等字符。
数组
一,元组(tuple)
1.元素可以是不同类型的数据
2.元组是写保护的。
二,列表(list)
三,字典(dictionary)
由键-值对组成的集合
四,序列
序列是具有索引和切片能力的集合
函数相关
1.python程序由包,模块,和函数组成包是由一系列模块组成的集合。模块是处理某一类问题的函数和类的集合。
2 包就是一个完成特定任务的工具箱。
3 包必须含有一个__init__.py文件,它用于标识当前文件夹是一个包。
4.Python的程序是由一个个模块组成的。模块把一组相关的函数或代码组织到一个文件中,一个文件即是一个模块。模块由代码,函数和类组成。导入模块使用import语句
对象和类
1.类名首字符要大写
2.python没有保护类型的修饰符
3.类的方法也分为公有方法和私有方法
4.python使用函数"staticmethod()"或@staticmethod指令的方法把函数转换为静态方法。
5.python的构造函数名为__init__,析构函数为__del__
连接MySql
import os, sys
import MySQLdb
try:
conn MySQLdb.connect(host=’localhost’,user=’root’,passwd=’’,db=’address’
except Exception,e:
print e
sys.exit()
cursor=conn.cursor()
sql=’insert into address(name, address) values(%s, %s)’
value=((“zhangsan”,”haidian”),(“lisi”,”haidian”))
try
cursor.executemany(sql,values)
except Exception, e:
print e
sql=”select * from address”
cursor.execute(sql)
data=cursor.fetchall()
if data
for x in data:
print x[0],x[1]
cursor.close()
conn.close()
python函数传参传的是引用
hasattr(object,attribute)#判断对象是否有某一属性
'type'#表示类
'class 'main.Objectxxx''#表示
type不仅能查看对象的类型,也能动态创建类
type(类名,父类的元组(针对继承的情况,空则为object),包含属性的字典)
MyShinyClass = type('MyShinyClass', (), {}) 等价于
class MyShinyClass(object):
pass
def echo(self):
print 1
Foo = type('Foo', (), {'bar':True,'echo':echo})等价于
class Foo(object):
bar = True
def echo(self):
print 1
#Python捕获Ctrl+C,Ctrl+D事件
try
do_some_func()
except KeyboardInterrupt:
print("User Press Ctrl+C,Exit")
except EOFError:
print("User Press Ctrl+D,Exit")
包->模块->类
一个文件夹下有__init__.py文件的就是一个包;包里会有许多模块(.py文件),通常__init__.py会先把各个模块里的类导入;这样在导入包的时候就会自动导入__init__.py里导入的模块或者类,当然也可以从包里只导入那些模块或类
一个.py文件就是一个模块;
在linux系统下,pip需要管理员权限,sudo /xx/pip install xxx(此处pip需要绝对路径)
270W个颗粒数据,转换所需内存约10G,转换后剩5G,所以推荐至少16G内存
bytes('123',encoding='utf8')#字符串转bytes
bytes.decode(b'sd')#bytes转字符串
req = urlopen(pdf_url, None, timeout_secs)#下载pdf文件,如pdf_url='http://arxiv.org/pdf/1807.04734v1.pdf'
with open(fname, 'wb') as fp:
shutil.copyfileobj(req, fp)
with open('msp.pkl','wb') as f:#写
pickle.dump(binmass,f)
with open(self.MSPsDir+'/'+MSPName,'rb') as f:#读
self.MSPs.append(pickle.load(f))
sys.exit()#推出程序
os.system()#运行dos命令
y=getattr(x,'bar',None) 获得对象x的属性bar值,不存在的话返回None
callable(x) 判断x是否是可以调用的,即x()是否不会报错
python调用C++
1.在*dll.h要添加
ifdef __cplusplus
extern "C"{
endif
或者可能会找不到函数
2.不支持函数重载
VS调试Python调用dll:https://blog.csdn.net/lacoucou/article/details/80066637
python里头要用吗ctypes,如ctypes.c_float
from ctypes import *
import numpy as np
import ctypes
import baseMethod
data=baseMethod.getSpectrumFromFile("D:\\Data\\diverse\\MALDI\\华大样品-内标测试\\txt\\B2_1_20190424144921.mld.txt")
x=data[:,0]
y=data[:,1]
Debug=False
input()
if Debug:
dll_dir = 'D:\\Projects\\C++\\newProject10\\MSAlgorithm-v2.0\\x64\\Debug\\MSAlgorithm.dll'
else:
dll_dir='D:\\Projects\\C++\\newProject10\\MSAlgorithm-v2.0\\x64\Release\\MSAlgorithm.dll'
dll_dir=','
np_dll=np.ctypeslib.load_library('MSAlgorithm',dll_dir)
np_dll.ConvSmooth.argtypes = [np.ctypeslib.ndpointer(dtype=ctypes.c_float),np.ctypeslib.ndpointer(dtype=ctypes.c_float),ctypes.c_int,ctypes.c_double]
np_dll.ConvSmooth.restype = ctypes.c_void_p
smoothy=np.ones(len(y),dtype=ctypes.c_float)#用ctypes,而不是np里头的float
d=np.asarray(y,dtype=ctypes.c_float)
np_dll.ConvSmooth(d,smoothy,len(smoothy),90.0)
``
使用CUDA
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
python鸭子类型的灵活性在于它关注的是这个所调用的对象是如何被使用的,而没有关注对象类型的本身是什么。所以在python中使用isinstance来判断传入参数的类型是不提倡的,更pythonic的方法是直接使用传入的参数,通过try,except来处理传入参数不符合要求的情况。我们应该通过传入对象的能力而不是传入对象的类型来使用该对象