python--第六天总结

执行系统命令 

可以执行shell命令的相关模块和函数有：

  • os.system
  • os.spawn*
  • os.popen*          --废弃
  • popen2.*           --废弃
  • commands.*      --废弃，3.x中被移除

import commands

result = commands.getoutput(‘cmd‘)
result = commands.getstatus(‘cmd‘)
result = commands.getstatusoutput(‘cmd‘)

以上执行shell命令的相关的模块和函数的功能均在 subprocess 模块中实现，并提供了更丰富的功能。

subprocess

subprocess允许你能创建很多子进程，创建的时候能指定子进程和子进程的输入、输出、错误输出管道，执行后能获取输出结果和执行状态。

call 

执行命令，返回状态码

  1. ret = subprocess.call(["ls", "-l"], shell=False)
  2. ret = subprocess.call("ls -l", shell=True)

shell=True ，参数会让subprocess.call 接受字符串形式的变量作为命令，并调用系统shell去执行这个字符串。
shell=False，subprocess.call只接受数组变量作为命令，并将数组的第一个元素作为命令，剩下的全部作为该命令的参数。

注：shell=False 的参数能让你的程序更加安全，尤其是当你的cmd变量值是从外部读取到的时候。官方声明里说要尽力避免使用shell=True这个参数。

check_call

执行命令，如果执行状态码是 0 ，则返回0，否则抛异常

  1. subprocess.check_call(["ls", "-l"])
  2. subprocess.check_call("exit 1", shell=True)

check_output

执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常

  1. subprocess.check_output(["echo", "Hello World!"])
  2. subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)

用于执行复杂的系统命令

参数：

    • args：shell命令，可以是字符串或者序列类型（如：list，元组）
    • bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
    • stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
    • preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
    • close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
      所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
    • shell：同上
    • cwd：用于设置子进程的当前目录
    • env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
    • universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
    • startupinfo与createionflags只在windows下有效
      将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

eg：

>>> t = subprocess.Popen(["python"], stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
>>> t.stdin.write("print 1\n")
>>> t.communicate()

(‘1\n‘, ‘‘)

注；subprocess.check_output(["df","-h", "|","grep","M"],shell=True) 在测试grep 时  未生效。

shutil

高级的 文件、文件夹、压缩包 处理模块

shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中，可以部分内容

可选参数length指定缓冲区的大小，负数表示一次性读入。默认会把数据切分成小块拷贝，以免占用太多内存。
注意：拷贝是从fsrc的当前文件开始。

shutil.copyfile(src, dst)
拷贝文件

shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变

shutil.copystat(src, dst)
拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copy(src, dst)
拷贝文件和权限

shutil.copy2(src, dst)
拷贝文件和状态信息 类似shell命令cp -p

shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件

shutil.ignore_patterns(*patterns)

copytree的辅助函数，提供glob功能。

例如：copytree(source, destination, ignore=ignore_patterns(‘*.pyc‘, ‘tmp*‘))

shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件

shutil.move(src, dst)
递归的去移动文件

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

    • base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
      如：www                        =>保存至当前路径
      如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
    • format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
    • root_dir： 要压缩的文件夹路径（默认当前目录）
    • owner： 用户，默认当前用户
    • group： 组，默认当前组
    • logger： 用于记录日志，通常是logging.Logger对象
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("wwwwwwwwww", ‘gztar‘, root_dir=‘/Users/wupeiqi/Downloads/test‘)

#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
import shutil
ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", ‘gztar‘, root_dir=‘/Users/wupeiqi/Downloads/test‘)

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

import zipfile

# 压缩
z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘)
z.write(‘a.log‘)
z.write(‘data.data‘)
z.close()

# 解压
z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
z.extractall()
z.close()

zipfile 压缩解压

import tarfile

# 压缩
tar = tarfile.open(‘your.tar‘,‘w‘)
tar.add(‘/Users/wupeiqi/PycharmProjects/bbs2.zip‘, arcname=‘bbs2.zip‘)
tar.add(‘/Users/wupeiqi/PycharmProjects/cmdb.zip‘, arcname=‘cmdb.zip‘)
tar.close()

# 解压
tar = tarfile.open(‘your.tar‘,‘r‘)
tar.extractall()  # 可设置解压地址
tar.close()

tarfile 压缩解压

logging

用于便捷记录日志且线程安全的模块

import logging

logging.basicConfig(filename=‘log.log‘,
                    format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,
                    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
                    level=10)

logging.debug(‘debug‘)
logging.info(‘info‘)
logging.warning(‘warning‘)
logging.error(‘error‘)
logging.critical(‘critical‘)
logging.log(10,‘log‘)

同时将log输出到终端和写入文件

import logging

logger = logging.getLogger(‘example‘)
logger.setLevel(logging.DEBUG)

# create file handler which logs even debug messages
fh = logging.FileHandler(‘log.log‘)
fh.setLevel(logging.WARNING)

# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s - %(thread)d‘)
ch.setFormatter(formatter)
fh.setFormatter(formatter)
# add the handlers to logger
logger.addHandler(ch)
logger.addHandler(fh)

# ‘application‘ code
logger.debug(‘debug message‘)
logger.info(‘info message‘)
logger.warn(‘warn message‘)
logger.error(‘error message‘)
logger.critical(‘critical message‘)

对于等级：

  1. CRITICAL = 50
  2. FATAL = CRITICAL
  3. ERROR = 40
  4. WARNING = 30
  5. WARN = WARNING
  6. INFO = 20
  7. DEBUG = 10
  8. NOTSET = 0

只有大于当前日志等级的操作才会被记录。

对于格式，有如下属性可是配置：

time

时间相关的操作，时间有三种表示方式：

  • 时间戳               1970年1月1日之后的秒，即：time.time()
  • 格式化的字符串    2014-11-11 11:11，    即：time.strftime(‘%Y-%m-%d‘)
  • 结构化时间          元组包含了：年、日、星期等... time.struct_time    即：time.localtime()

import datetime

datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")

print time.time()
print time.mktime(time.localtime())

print time.gmtime()    #可加时间戳参数
print time.localtime() #可加时间戳参数
print time.strptime(‘2014-11-11‘, ‘%Y-%m-%d‘)

print time.strftime(‘%Y-%m-%d‘) #默认当前时间
print time.strftime(‘%Y-%m-%d‘,time.localtime()) #默认当前时间
print time.asctime()
print time.asctime(time.localtime())
print time.ctime(time.time())

import datetime
‘‘‘
datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
‘‘‘
import datetime
print datetime.datetime.now()
print datetime.datetime.now() - datetime.timedelta(days=5)

注：相差的日期通过days 获取    d1 = datetime.datetime(2015,12,10)    d2 = datetime.datetime(2015,12,1)    d3 = (d1-d2).days

re 

re模块用于对python的正则表达式的操作。

字符：

　　. 匹配除换行符以外的任意字符
　　\w 匹配字母或数字或下划线或汉字
　　\s 匹配任意的空白符
　　\d 匹配数字
　　\b 匹配单词的开始或结束
　　^ 匹配字符串的开始
　　$ 匹配字符串的结束

次数：

　　* 重复零次或更多次
　　+ 重复一次或更多次
　　? 重复零次或一次
　　{n} 重复n次
　　{n,} 重复n次或更多次
　　{n,m} 重复n到m次

匹配IP：

 t = ‘‘inet 192.168.100.100  netmask 255.255.255.0  broadcast 192.168.255.255‘

 re.search(r‘(?<![\.\d])(?:\d{1,3}\.){3}\d{1,3}(?![\.\d])‘,t).group()

 re.search(r‘(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])‘,t).group()

 re.search(r‘\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b‘,t).group()

-------------------------------------------类

一、类定义：

class <类名>:
  <语句>

二、类的方法
在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数。

其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法。

class people:
    #定义基本属性
    name = ‘‘
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s is speaking: I am %d years old, weight %s" %(self.name,self.age,self.__weight))

p = people(‘tom‘,10,30)
p.speak()

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性
如果直接使用类名修改其属性，那么将直接影响到已经实例化的对象
【类属性和实例属性】

1、对于公有的类属性，在类外可以通过类对象和实例对象访问。
class people:
    name = ‘jack‘  #公有的类属性
    __age = 12     #私有的类属性

p = people()

print p.name             #正确
print people.name        #正确
print p.__age            #错误，不能在类外通过实例对象访问私有的类属性
print people.__age       #错误，不能在类外通过类对象访问私有的类属性复制代码

2、实例属性是不需要在类中显示定义的，比如：

class people:
    name = ‘jack‘

p = people()
p.age =12
print p.name    #正确
print p.age     #正确

print people.name    #正确
print people.age     #错误

3、在类外对类对象people进行实例化之后，产生了一个实例对象p，然后p.age = 12这句给p添加了一个实例属性age，赋值为12。
这个实例属性是实例对象p所特有的，注意，类对象people并不拥有它（所以不能通过类对象来访问这个age属性）。
当然还可以在实例化对象的时候给age赋值。
class people:
    name = ‘jack‘

    def __init__(self,name,age):
        self.name = name
        self.age = age

p = people(‘alex‘,12)
print p.name         #正确
print p.age          #正确

print people.name    #正确
print people.age     #错误

如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。
如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，
并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。

class people:
    country = ‘china‘

print people.country
p = people()
print p.country
p.country = ‘japan‘
print p.country      #实例属性会屏蔽掉同名的类属性
print people.country
del p.country    #删除实例属性
print p.country

 

时间： 2024-10-12 08:36:53

python--第六天总结的相关文章

python第六天

今天学习第一模块的最后一课课程--函数: python的第一个函数: 1 def func1(): 2 print('第一个函数') 3 return 0 4 func1() 函数可返回各种数据类型: 同时返回多种类型时,将是返回一元组: 1 def func2(): 2 return 1,"二",[3,'4'],{'五':'六','七':8}#返回多种数据类型 3 data=func2() 4 print(data) 函数参数的调用: 1,位置调用:编写时需要一一对应,如果少了,或是

python 第六天

递归,阶乘 1*2*3*...7 def func(num):     if num == 1:         return 1     return num * func(num-1) x = func(7) print(x) 反射 #利用字符串的形式去对像(模块)中操作(寻找/检查/删除/设置)成员 hasattr    #利用字符串的形式去对像(模块)判断是否存在,存在True,不存在False getatrr    #利用字符串的形式去对像(模块)中操作(寻找)成员 delattr s

python第六天：一些常用函数，面向对象入门

上节回顾 yield的表达式用法→协程函数 只要函数内有yield关键字,函数名得到的结果就是生成器,表达式形式的生成器就是在整个生成的过程中使用send传值. 面向过程 面向过程的是编程范式的一种,是流水线式的编程范式,一般来说逻辑比较清晰,但是可扩展性差,牵一发而动全身. 匿名函数 匿名函数定义的时候要使用关键字lambda,格式如下 lambda val:val1,其中val是传的参数,val1是返回值. 递归函数   递归调用:在函数的调用过程中,直接或者间接的调用本身的话就是递归函数.

Python第六天(字符串转换)

Python字符串转换 int函数将字符串转换为数字 str函数将数字转换为字符串 >>> int('100') 100 >>> str(100) '100' repr函数可以将一个对象转换为其他字符串形式,然后这些返回的 对象将作为代码的字符串 内置的函数可以把浮点数转换为字符串 或者把字符串转化为浮点数 >>> str(1.1) '1.1' >>> float('1.1') 1.1000000000000001 字符串代码转换 o

python第六天面向对象的编程

类和实例: 定义 class  类名(父类名):  其中object是所有类的祖先类 __int__方法(两个下划线)表示把属性绑定到类上,如下把name.score等属性绑上去 注意类中所有方法的第一个参数都是self表示对象本身,调用的时候不需要传递这个参数 class Student(object): def __init__(self, name, score): self.name = name self.score = score 限制访问:如果在实例的变量前加上两个下划线,那么此变

python第六天，元组

Python的元组与列表类似,不同之处在于元组的元素不能修改. 元组使用小括号,列表使用方括号. 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可. tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5 ) tup3 = "a", "b", "c", "d" 创建空元组 tup1 = () tps: 元组中只包含一个元素时,需要在元素后面添

Python第六天(字符串格式化表达式)

字符串格式化表达式 格式化字符串 在%操作符的左侧放一个需要进行格式化的字符串,以%开头 在%操作符的右侧放一个对象,这些对象就是左边进行格式化字符串转换的字符 >>> 'I am %s I am %d old!' % ('wuang',22) 'I am wuang I am 22 old!' 字符串格式化代码 s 字符串 rs,使用repr,不是str c 字符 d 十进制 i整数 u 无号 o  八进制 x 十六进制 Xx,打印大写 e 浮点指数 E e,打印大写 f  浮点十进制

Python第六天-----面向对象

说面向对象之前,我们有必要提一下我们的老朋友函数,函数作为面向对象之前的产物,从诞生的那天注定了他的不平凡,早在C语言中根本没有面向对象这种概念,但是依旧C语言活的好好的.所以面向对象并不是必须的,面向对象的存在只是为了简化过程. 我们不妨考虑一下,假设我们不知道面向对象,而此时我们需要写人,此时采用传统函数式编程,我们需要考虑人有多少属性,例如:人有头.胳膊腿等等等等.按照传统函数式的方法我们只能定义字典来去实现 people1 = { "head":1, "eyes&qu

Python第六天(字符串-索引和分片)

索引和分片 >>> wu = 'wuang' >>> wu[0] 'w' >>> wu[1] 'u' >>> wu[1:] 'uang' >>> wu[1:3] 'ua' >>> wu[-1] 'g' >>> wu[:-1] 'wuan' 索引: wu[i] 第一个元素的偏移为0 [0]:第一个元素 [-1]:最后一个元素 分片wu[i:j] 上边界(i)不包含 如果i没给出,默认

Python第六天(字符串修改)

字符串修改 >>> wu 'wuang' >>> wu = wu[:2] + 'zhang' >>> wu 'wuzhang' >>> wu 'wuzhang' 直接使用replace修改替换 >>> wu = wu.replace('uzh','u') >>> wu 'wuang' >>> 'zhangsAn'.replace('A','a') 'zhangsan' 替换一次 &