PYTHON学习笔记

PYTHON学习笔记

---

1.os 模块

• os.sep 可以取代操作系统特定的路径分隔符。windows下为 ‘\’
• os.name 字符串指示你正在使用的平台。比如对于Windows，它是’nt’，而对于Linux/Unix用户，它是 ‘posix’
• os.getcwd() 函数得到当前工作目录，即当前Python脚本工作的目录路径
• os.getenv() 获取一个环境变量，如果没有返回none
• os.putenv(key, value) 设置一个环境变量值
• os.listdir(path) 返回指定目录下的所有文件和目录名
• os.remove(path) 函数用来删除一个文件
• os.system(command) 函数用来运行shell命令
• os.linesep 字符串给出当前平台使用的行终止符。例如，Windows使用 ‘\r\n’，Linux使用 ‘\n’ 而Mac使用 ‘\r’
• os.path.split(path) 函数返回一个路径的目录名和文件名
• os.path.isfile() 和os.path.isdir()函数分别检验给出的路径是一个文件还是目录
• os.path.exists() 函数用来检验给出的路径是否真地存在
• os.curdir 返回当前目录 (‘.’)
• os.mkdir(path) 创建一个目录
• os.makedirs(path) 递归的创建目录
• os.chdir(dirname) 改变工作目录到dirname
• os.path.getsize(name) 获得文件大小，如果name是目录返回0L
• os.path.getmtime(filepath)获得文件更新日期
• os.path.abspath(name) 获得绝对路径
• os.path.normpath(path) 规范path字符串形式
• os.path.splitext() 分离文件名与扩展名
• os.path.join(path,name) 连接目录与文件名或目录
• os.path.basename(path) 返回文件名
• os.path.dirname(path) 返回文件路径
• os.walk(top,topdown=True,οnerrοr=None) 遍历迭代目录
• os.rename(src, dst) 重命名file或者directory src到dst 如果dst是一个存在的directory, 将抛出OSError. 在Unix, 如果dst在存且是一个file, 如果用户有权限的话，它将被安静的替换. 操作将会失败在某些Unix 中如果src和dst在不同的文件系统中. 如果成功, 这命名操作将会是一个原子操作 (这是POSIX 需要). 在 Windows上, 如果dst已经存在, 将抛出OSError，即使它是一个文件. 在unix，Windows中有效。
• os.renames(old, new) 递归重命名文件夹或者文件。像rename()
  

  ---

2.re fnmatch 模块

def iterfindfiles(path="..\\..\\..\\synth\\ip_core\\",fnexp1="*\mentor",fnexp2="msim_setup.tcl"):
  for root, dirs, files in os.walk(path):    
    for filename in fnmatch.filter(files, fnexp2):
      if fnmatch.fnmatch(root,fnexp1):       
        yield os.path.join(root, filename)

函数	说明
re.match(pat, s)	只从字符串s的头开始匹配，比如(‘123’, ‘12345’)匹配上了，而(‘123’,’01234’)就是没有匹配上，没有匹配上返回None，匹配上返回matchobject
re.search(pat, s)	从字符串s的任意位置都进行匹配，比如(‘123’,’01234’)就是匹配上了，只要s只能存在符合pat的连续字符串就算匹配上了，没有匹配上返回None，匹配上返回matchobject
re.sub(pat,newpat,s)	对字符串中s的包含的所有符合pat的连续字符串进行替换，如果newpat为str,那么就是替换为newpat,如果newpat是函数，那么就按照函数返回值替换。sub函数两个有默认值的参数分别是count表示最多只处理前几个匹配的字符串，默认为0表示全部处理；最后一个是flags，默认为0

for filename in iterfindfiles(path="..\\testbench_"+cwd_c+"\\",fnexp1="*",fnexp2="*.sv"):
    filename = filename.replace('\\','/')
    pattern = re.compile(r'_v[0-9]+|[\u4e00-\u9fa5]+')
    if not pattern.search(filename):
      fd.write(filename+'\n')

import re
m = re.match(r'(\w+) (\w+)(?P<sign>.*)', 'hello world!')

print ("m.string:", m.string)
print ("m.re:", m.re)
print ("m.pos:", m.pos)
print ("m.endpos:", m.endpos)
print ("m.lastindex:", m.lastindex)
print ("m.lastgroup:", m.lastgroup)

print ("m.group(1,2):", m.group(1, 2))
print ("m.groups():", m.groups())
print ("m.groupdict():", m.groupdict())
print ("m.start(2):", m.start(2))
print ("m.end(2):", m.end(2))
print ("m.span(2):", m.span(2))
print (r"m.expand(r'\2 \1\3'):", m.expand(r'\2 \1\3'))

### output ###
# m.string: hello world!
# m.re: <_sre.SRE_Pattern object at 0x016E1A38>
# m.pos: 0
# m.endpos: 12
# m.lastindex: 3
# m.lastgroup: sign
# m.group(1,2): ('hello', 'world')
# m.groups(): ('hello', 'world', '!')
# m.groupdict(): {'sign': '!'}
# m.start(2): 6
# m.end(2): 11
# m.span(2): (6, 11)
# m.expand(r'\2 \1\3'): world hello!

• match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]):
  这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None。
  pos和endpos的默认值分别为0和len(string)；re.match()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。
  注意：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’。
• search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]):
  这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。
  pos和endpos的默认值分别为0和len(string))；re.search()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。

# encoding: UTF-8 
import re 

# 将正则表达式编译成Pattern对象 
pattern = re.compile(r'world') 

# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None 
# 这个例子中使用match()无法成功匹配 
match = pattern.search('hello world!') 

if match: 
    # 使用Match获得分组信息 
    print match.group() 

### 输出 ### 
# world

• split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
  按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。

import re

p = re.compile(r'\d+')
print p.split('one1two2three3four4')

### output ###
# ['one', 'two', 'three', 'four', '']

• findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):
  搜索string，以列表形式返回全部能匹配的子串。

import re

p = re.compile(r'\d+')
print p.findall('one1two2three3four4')

### output ###
# ['1', '2', '3', '4']

• finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):
  搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

import re

p = re.compile(r'\d+')
for m in p.finditer('one1two2three3four4'):
    print m.group(),

### output ###
# 1 2 3 4

• sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):
  使用repl替换string中每一个匹配的子串后返回替换后的字符串。
  当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。
  当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
  count用于指定最多替换次数，不指定时全部替换。

import re

p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'

print p.sub(r'\2 \1', s)

def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()

print p.sub(func, s)

### output ###
# say i, world hello!
# I Say, Hello World!

• subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]):
  返回 (sub(repl, string[, count]), 替换次数)。

import re

p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'

print p.subn(r'\2 \1', s)

def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()

print p.subn(func, s)

### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)

---

3.tkinter 模块

from tkinter import *
from tkinter import ttk

root = Tk() 
root.title('-- working_'+cwd_c+' --  仿真 （版本：'+banben+'）')

row1 = Frame(root)
row1.pack(side='top',fill = X)

row1.columnconfigure(0, weight=1)
row1.columnconfigure(1, weight=1)
row1.columnconfigure(2, weight=1)

row1.rowconfigure(0, weight=1)
row1.rowconfigure(1, weight=1)
row1.rowconfigure(2, weight=1)
row1.rowconfigure(3, weight=1)

Button(row1,text='生成完整tcl',width=20,command=create_tcl_z0).grid(row=0,column=0,pady=10,padx=15)
Button(row1,text='生成增量tcl',width=20,command=create_tcl_z1).grid(row=0,column=1,pady=10,padx=15)
Button(row1,text='生成f文件',width=20,command=create_f).grid(row=0,column=2,pady=10,padx=15)

Button(row1,text='IP完全编译',width=20,command=run).grid(row=1,column=0,pady=10,padx=15)
Button(row1,text='IP增量编译',width=20,command=run_r).grid(row=1,column=1,pady=10,padx=15)
Button(row1,text='开始仿真',width=20,command=run1).grid(row=1,column=2,pady=10,padx=15)

Button(row1,text='软停止',width=20,command=sstop).grid(row=2,column=0,pady=10,padx=15)
Button(row1,text='强制停止',width=20,command=stop_baoli).grid(row=2,column=1,pady=10,padx=15)

Button(row1,text='查看覆盖率',width=20,command=see_cover).grid(row=3,column=1,pady=10,padx=15)
Button(row1,text='查看波形',width=20,command=see_wave).grid(row=3,column=0,pady=10,padx=15)
Button(row1,text='帮助',width=20,command=help).grid(row=3,column=2,pady=10,padx=15)

fff=Frame(root)
fff.pack(expand = YES,fill = BOTH)

S = Scrollbar(fff)

S.pack(side=RIGHT,fill=Y)
ttt=Text(fff,yscrollcommand = S.set)

ttt.pack(expand = YES,fill = BOTH)
S.config(command=ttt.yview)

root.mainloop()

  ttop = Toplevel()
  ttop.title('帮助')
  ttop.geometry('700x800')

  tabControl = ttk.Notebook(ttop) # Create Tab Control
  tab1 = ttk.Frame(tabControl) # Create a tab
  tabControl.add(tab1, text='注意事项') # Add the tab
  tabControl.pack(expand=1, fill="both") # Pack to make visible
  tab2 = ttk.Frame(tabControl) # Add a second tab
  tabControl.add(tab2, text='项目目录结构') # Make second tab visible
  tab3 = ttk.Frame(tabControl) # Add a second tab
  tabControl.add(tab3, text='各功能说明') # Make second tab visible


  var1 = StringVar()
  var2 = StringVar()
  var3 = StringVar()

  Label(tab1,textvariable=var1,justify = 'left',anchor = 'w').pack()
  Label(tab2,textvariable=var2,justify = 'left',anchor = 'w').pack()
  Label(tab3,textvariable=var3,justify = 'left',anchor = 'w').pack()


  var1.set('''                                                                                         

        注意事项：  （以pdsch_top为例） 
        ''')    

---

4.threading subprocess 模块

廖雪峰学习网站-线程与进程

t2=threading.Thread(target=create_f_1)
t2.start()

r_tcl_r = subprocess.Popen('vsim -c -do run_r.do', shell=True, stdout=subprocess.PIPE)
a=r_tcl_r.stdout.readline()

---

5. shutil 模块

• shutil.copyfile( src, dst) 从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉
• shutil.move( src, dst) 移动文件或重命名
• shutil.copymode( src, dst) 只是会复制其权限其他的东西是不会被复制的
• shutil.copystat( src, dst) 复制权限、最后访问时间、最后修改时间
• shutil.copy( src, dst) 复制一个文件到一个文件或一个目录
• shutil.copy2( src, dst) 在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西
• shutil.copy2( src, dst) 如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作
• shutil.copytree( olddir, newdir, True/Flase)
  把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接
• shutil.rmtree( src ) 递归删除一个目录以及目录内的所有内容
  

  ---

6. hashlib 模块

import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print md5.hexdigest()

import hashlib
md5file=open(filepath,'rb')
md5=hashlib.md5(md5file.read()).hexdigest()

import hashlib
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()

---

7 time 模块

#!/usr/bin/env python3
#coding=utf-8 
#时间

import time
print(time.time())
#获取当前时间
print(time.localtime())
#获取格式化的时间
print(time.asctime())#接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串
print("==========================================")
#日期格式化
t = (1970, 1, 1, 8, 0, 10, 3, 1, 0)
print(time.strftime("%Y-%m-%d %H:%M:%S",t))#参数：时间元组可有可无，将时间元组按照格式输出字符串表示时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))#格式：yyyy-mm-dd hh:min:ss
print(time.strftime("%a %b %d %H:%M:%S %Y"))#格式:Sat Mar 28 22:24:24 2016
print("=========================================")
a = "Sat Mar 28 22:24:24 2016"
print(time.strptime(a,"%a %b %d %H:%M:%S %Y"))#根据fmt的格式把一个时间字符串解析为时间元组。
print(time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))#接受时间元组并返回时间戳
print(time.mktime(time.strptime("2013-11-11 11:11:11","%Y-%m-%d %H:%M:%S")))

print("===========================================")
#内置函数
print(time.clock())
print(time.clock())#该函数有两个功能，在第一次调用的时候，返回的是程序运行的实际时间；以第二次之后的调用，返回的是自第一次调用后,到这次调用的时间间隔;在win32系统下，这个函数返回的是真实时间（wall time），而在Unix/Linux下返回的是CPU时间。

print(time.ctime(10))#作用相当于asctime(localtime(secs))，未给参数相当于asctime()
print(time.gmtime(10))#接收时间辍（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
print(time.localtime(10))#接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
t = (1970, 1, 1, 8, 0, 10, 3, 1, 0)
print(time.mktime(t))#接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）。
print("====================")
print(time.asctime())
time.sleep(10)#推迟调用线程的运行，secs指秒数。
print(time.asctime())
'''
    %y 两位数的年份表示（00-99）
    %Y 四位数的年份表示（000-9999）
    %m 月份（01-12）
    %d 月内中的一天（0-31）
    %H 24小时制小时数（0-23）
    %I 12小时制小时数（01-12）
    %M 分钟数（00=59）
    %S 秒（00-59）
    %a 本地简化星期名称
    %A 本地完整星期名称
    %b 本地简化的月份名称
    %B 本地完整的月份名称
    %c 本地相应的日期表示和时间表示
    %j 年内的一天（001-366）
    %p 本地A.M.或P.M.的等价符
    %U 一年中的星期数（00-53）星期天为星期的开始
    %w 星期（0-6），星期天为星期的开始
    %W 一年中的星期数（00-53）星期一为星期的开始
    %x 本地相应的日期表示
    %X 本地相应的时间表示
    %Z 当前时区的名称
    %% %号本身
'''
#日历

import calendar
cal = calendar.month(2017,4)#获取2017年4月的日历
#print(cal)
#calendar.prcal(2017)#返回一个多行字符串格式的year年年历
#print(calendar.calendar(2017))#返回一个多行字符串格式的year年年历
#print(calendar.firstweekday())#返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。
print(calendar.isleap(2016))#是闰年返回True，否则为false。
print(calendar.leapdays(2016,2021))#返回两个间隔之间的闰年总数(不包含末尾)
print(calendar.monthcalendar(2017,4))#返回一个整数的单层嵌套列表，表示一个月里面的每天
print(calendar.month(2017,4))
calendar.prmonth(2017,4)#打印出某年某月的日历
print(calendar.monthrange(2017,4))#得到本月的天数 第一返回为月第一日为星期几（0-6）, 第二返回为此月天数
calendar.setfirstweekday(6)#设置一周的第一天，周一（0）-周天（6），默认第一天是周一
calendar.prmonth(2017,4)
print("=================================")
print(calendar.timegm((1970,1,1,0,0,10,3,1,0)))#和time.gmtime相反，根据时间元组返回一个时间戳
print(calendar.weekday(2017,4,12))#返回这天的所在周里的日期码，周一（0），周天（6）

8 str 操作

'asdfasf{a}adfa{b}dfa'.format(a='1111',b='2222')
'asdfasf1111adfa2222dfa'

'asdfasf%sadfa%sdfa'%('1111','2222')
'asdfasf1111adfa2222dfa'

print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})

print('%.*f'%(3,1.2454545))
1.245
print('%.*f'%(5,1.2454545))
1.24545


'''
%s    字符串 (采用str()的显示)

%r    字符串 (采用repr()的显示)

%c    单个字符

%b    二进制整数

%d    十进制整数

%i    十进制整数

%o    八进制整数

%x    十六进制整数

%e    指数 (基底写为e)

%E    指数 (基底写为E)

%f    浮点数

%F    浮点数，与上相同

%g    指数(e)或浮点数 (根据显示长度)

%G    指数(E)或浮点数 (根据显示长度)



%%    字符"%"
'''

9 动态变量名

>>> names = locals()
>>> for i in xrange(1, 101):
...   names['x%s' % i] = i
...
>>> x1
1
>>> x2
2
>>> x100
100

版权声明：非技术文章禁止转载，如有需要请私信作者。技术类文章欢迎转载，转载请注明出处： http://blog.csdn.net/ztf312/
一共三种方法：

>>> var = "This is a string"  
>>> varName = 'var'  
>>> s= locals()[varName]  
>>> s  
'This is a string'  
>>> s2=vars()[varName]  
>>> s2  
'This is a string'  
>>> s3=eval(varName)  
>>> s3  
'This is a string'  

• locals()
  locals是Python的内置函数，他可以以字典的方式去访问局部和全局变量。
  python里面用名字空间记录着变量，就像JavaScript的window一样，他记录着各种全局变量。
  每个模块，每个函数都有自己的名字空间，记录着变量，常量，类的命名和值。
  就像JS一样，当python在使用变量时，会按照下面的步骤去搜索：
  函数或类的局部变量。
  全局变量。
  内置变量。
  以上三个步骤，其中一步骤找到对应的变量，就不会再往下找。如果在这三个步骤都找不到，就会抛出异常。
  locals与globals的区别
  locals()是只读的。globals()不是。这里说的只读，是值对于原有变量的只读。其实还可以对locals()赋值的。
  globals返回的是当前模块的全局变量 locals返回的是局部变量。注意，locals返回的是当前所在最小命名空间的局部变量的一个拷贝。
  体检locals

list1 = [1,2,3]  
locals()  

# 在全局中使用locals，会打印出list1和__builtins__、__name__、__doc__、__package__  
复制代码  
def foo(args):  
    x=1  
    print locals()  

foo(123)  

#将会得到 {'arg':123,'x':1}  

• vars()
  本函数是实现返回对象object的属性和属性值的字典对象。如果默认不输入参数，就打印当前调用位置的属性和属性值，相当于locals()的功能。如果有参数输入，就只打印这个参数相应的属性和属性值。

#vars()    

print(vars())    

class Foo:    
    a = 1    
print(vars(Foo))    

foo = Foo()    
print(vars(foo))   

• eval()
  eval()函数十分强大，官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。
  结合math当成一个计算器很好用。
  其他用法，可以把list,tuple,dict和string相互转化。见下例子：

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"  
b = eval(a)  
b  
Out[3]: [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]  
type(b)  
Out[4]: list  
a = "{1: 'a', 2: 'b'}"  
b = eval(a)  
b  
Out[7]: {1: 'a', 2: 'b'}  
type(b)  
Out[8]: dict  
a = "([1,2], [3,4], [5,6], [7,8], (9,0))"  
b = eval(a)  
b  
Out[11]: ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))  

强大的函数有代价。安全性是其最大的缺点。
想一想这种使用环境：需要用户输入一个表达式，并求值。
如果用户恶意输入，例如：

__import__('os').system('dir')

那么eval()之后，你会发现，当前目录文件都会展现在用户前面。
那么继续输入：

open('文件名').read()

代码都给人看了。获取完毕，一条删除命令，文件消失。哭吧！
怎么避免安全问题？
(1) 自行写检查函数；
(2) 使用ast.literal_eval