| 编辑推荐: |
| 来源于csdn，这篇文章主要是讲解了在机器学习的前提下，python应该学习那些内容。 |
|
最近刚好有时间，前面一段时间看了tensorflow，看了深度学习的理论，可是自己还不会python。让我自己写个什么机器学习算法，还真有点困难。所以就吧python基础拿出来看看；所以这个笔记的标题是按时间+内容进行索引的
第一阶段：python基础
0615
python基本数据结构
1）list: a[1,2,3]
2)tuple: a(1,2,3) 一旦初始化，就不能改变内容
3)dict:{‘a’:1,’b’:2,’c’:3} key:value (dict中的key值不能改变)
4)set: a([1,2,3]) (初始化的时候，传入的是list，set中的key也不能重复，set可以看做是数学意义上的无序和无重复元素的集合)
python的for循环
1)for … in 的循环，一次把list或者tuple中的元素迭代出来
2）for x in …的循环，把每个元素带入变量x中进行计算
python的函数参数
1）默认参数：
| def power(x):
->
def power(x,n=2): |
必选参数在前，默认参数在后。且默认参数必须指向不变对象（不能是list）
2）可变参数：（传入的参数的个数是可变的）
| def calc(numbers):
->
def calc(*numbers): |
3)关键字参数：
| def person(name,age,**kw): |
python的列表生成式
python的列表生成式有点过于强大，能够花式生成各种符合要求的列表，包括全排列，if判断都行。由于内容有点多，这里直接贴一个链接python的列表生成式
这里还有一个生成器的概念，现在并不是很懂，还是先把链接放这里，以后用到了看不懂再回过头来看这个。
生成器
python的函数
1）高阶函数：python当中的函数也可以复制给变量
f = abs
cmp(abs(-10),f(-10))#等于0 |
如果一个函数以函数为参变量，那么这个函数称为高阶函数
python当中的map和reduce，还有filter
这两个都是高阶函数，接受两个参数，第一个参数是函数变量，第二个参数是一个list。
map(f,nums)意思是将函数f作用于nums这个list中的每一个元素
reduce(f,nums)的作用类似于归约
def f(s):
return s[0].upper() + s[1:].lower()
a = ['adam','batT','LISA']
print map(f,a)
#输出位Adam，Batt,Lisa
def prod(nums):
def fm(x,y):
return x*y
return reduce(fm,nums)
a = [1,3,5]
print prod(a)
#输出为15，将a中的元素依次相乘
def is_odd(n):
return n %2 == 1
filter(is_odd,[1,2,3,4,5])
#输出为[1,3,5]
import math
def is_prism(n):
if n==1:
return True
if n>2:
for i in range(2,int(math.sqrt(n) + 1)):
if n %i == 0:
return True
return False
a = range(101)
print filter(is_prism,a) |
同为高阶函数的sorted
sorted要单独拿出来说，因为它的输入和前面所描述的输入正好相反
sorted(nums,func),sorted可以对list直接排序，但是默认升序，我们可以自定义排序函数来实现sorted函数的任意排序功能
def reversed_cpm(x,y):
if x>y:
return -1
if x<y:
return 1
return 0
sorted([36,5,12,9,21],reversed_cmp) |
将函数作为返回值实现python闭包
这里也没太弄明白用处在哪里，先贴链接，以后遇到了回过头来再看
python闭包
python中的正则表达式
python中的正则表达式lamda也叫做匿名函数
def reversed_cpm(x,y):
if x>y:
return -1
if x<y:
return 1
return 0
sorted([36,5,12,9,21],reversed_cmp) |
使用匿名函数的好处是因为匿名函数没有名字，不用担心函数名产生的冲突问题
0616
python模块概念
1）
| import sys
def test():
args = sys.argv
if len(args) == 1:
print 'hello'
elif len(args)==2:
print '2'
else:
print 'nan'
#当此python文件被当作为模块被其他模块引用时，并不会直接执行test函数，if判断将失败。因此这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试
if __name__=='__main__':
test() |
2）python，实现函数和变量的私有保护，可以通过_前缀来实现
,_前缀表示该变量/函数为此模块私有，其他模块并不应该访问（不应该访问并不能代表不能访问）
| import sys
def _test_():
args = sys.argv
if len(args) == 1:
print 'hello'
elif len(args)==2:
print '2'
else:
print 'nan'
def test2():
print 'haha'
if __name__=='__main__':
_test_()
|
在主函数中调用
| import my_sys
my_sys.test2()
my_sys._test_() |
同样是可以调用的，单数从编程习惯上来说不应该引用private函数
0617
python中的面向对象编程
和普通函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且调用时不用传递该参数
| class Student(object):
def __init__(self,name,score):
self.name = name
self.score = score
def print_info(self):
print('%s: %S' % (self.name,self.score))
bart = Student('Bart Simpson',59) |
下面的代码展示了使用@property修饰器完成了成员变量通过属性变量的方法来进行异常检测（c++语言中成员变量值的异常检测通常是通过set和get方法来实现的，使用了@property之后，python可以通过实例属性来进行异常检测，更加符合动态语言的规范）
class Screen(object):
@property
def width(self):
return self._width
@property
def height(self):
return self._height
@width.setter
def width(self,width):
if width<0:
raise ValueError('bad value')
self._width = width
s = Screen()
s.width = -1 |
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在python中，实例的变量名如果以开头，该变量就变成了私有变量。
python定制类
python当中有许多带xxx的函数，这些函数通常是定制函数
| class Fib(object):
def __getitem__(self, n):
if isinstance(n, int):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice):
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
f = Fib()
print(f[0])
print(f[5])
print(f[100])
print(f[0:5])
print(f[:10]) |
0618
python文件系统
1)打开和关闭文件
with open('a.txt','r')
as fd:
fd.read()#一次性读取
fd.read(size)#每次读取size个数据
fd.readline()#按行读取
with open('b.txt','w') as fd:
fd.write() |
2)操作文件和目录
os.path.abspath(‘.’)#获取绝对路径
os.path.join(‘/usr’,’test’)#合并目录
os.path.split(”)#讲文件名和文件夹名拆分
os.path.splitext()#得到文件的后缀名
例如列出文件夹下所有.py文件
| [x for x in os.listdir('.')
if os.path.isfile(x) and os.path.splitext(x)[1]=='.py'] |
下面的实例是寻找当前文件夹下的所有文件夹里的带指定关键字的所有文件
| import os
def find_files(dir = os.curdir,key = 'python'):
adrs=[]
for root,folder,files in os.walk(dir):
for file in files:
tfile = file.partition('.')[0]
if key in tfile:
adrs.append(os.path.relpath(os.path.join(root,file),dir))
print ('current directin:%s'%os.path.abspath(dir))
print ('find files:%s'%adrs)
find_files(key = 't') |
python多进程和多线程
linux系统提供了一个fork（）系统调用，它非常特殊。普通的函数调用，调用一次返回一次，但是fork()函数条用一次返回两次。因为操作系统自动吧当前进程（称为父进程）复制了一份（称为子进程），然后分别在父进程和子进程内返回。子进程运用返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以父进程需要记住每个子进程的ID，而子进程只需要调动getppid()就可以拿到父进程的ID。
| import os
print('current process id %s:' % os.getpid())
pid = os.fork()
if pid == 0:
#child
print('child id %s and my father id %s' % (os.getpid(),os.getppid()))
else:
print('father %s child %s'%(os.getpid(),pid))
#运行结果如下
#current process id 3676:
#father 3676 child 3759
#child id 3759 and my father id 3676 |
也可以用multiprocessing来创建子进程
from multiprocessing import
Process
import os
# 子进程要执行的代码
def run_proc(name):
print('Run child process %s (%s)...' % (name,
os.getpid()))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test',))
print('Child process will start.')
p.start()
p.join()
print('Child process end.'
#parent process 928
process will start
run child process test(929)...
process end |
创建子进程的时候，只需要传入一个执行函数和函数的参数，创建一个process实例，用start方法启动，这样创建进程比fork还要简单，join()方法可以等待子进程结束后在继续往下运行，通常用于进程间的同步。
在linux下，multiprocessing模块封装了fork()调用。由于windows下没有fork调用，multiprocessing需要模拟出fork的效果，所以父进程所有的python对象都必须通过pickle序列化再传到子进程去，所以如果Windows下调用multiprocessing失败，要先考虑是不是pickle失败了
python中的多线程
注意锁，同时要避免死锁
# multithread and lock
import time,threading,multiprocessing
balance = 0
lock = threading.Lock()
def changeIt(n):
global balance
balance = balance + n
balance = balance - n
def runThread(n):
for i in range(100):
lock.acquire()
try:
changeIt(n)
finally:
lock.release()
t1 = threading.Thread(target = runThread,args=(5,))
t2 = threading.Thread(target = runThread,args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)
#start loop thread
#for i in range(multiprocessing.cpu_count()):
# t = threading.Thread(target = func)
# t.start |
多线程VS多进程
多进程：最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。缺点就是，在windows环境下，创建多个进程开销巨大。
多线程：通常比多进程快一点，但是也块不到哪里去。多线程模型下，任一个线程崩溃都会导致整个程序崩溃，因为所有线程共享进程的内存。
在线程和进程中，应当优选process，因为process更稳定，而且process可以分布到多台机器上，而thread最多只能分布到同一台机器的多个cpu上。
python当中的正则表达式(re模块)
这部分内容涉及到python中独特而又强大的字符串匹配机制，内容比较复杂和庞大，先留个坑
正则表达式
python基础大概就记了这些笔记，当然python编程是很强大的，分布式和网络编程包括python爬虫等都相当强大。后面写代码的时候，有什么新的发现，我都会及时来更新这篇笔记。
后面的主要内容就是拿python来做机器学习了。后面的内容会有公式，有理论，当然也有代码。 |
