1.subprocess模块 因为方法较多我就写在code里面了，后面有注释
#!/usr/bin/env python
#_*_coding:utf-8_*_
#linux 上调用python脚本
#os.system输出命令结果到屏幕，返回命令执行状态
#os.popen("dir") 返回内存对象，需要单独去取一下
#os.popen("dir").read() 保存命令的执行结果输出，但是不返回执行状态
#
#py 2.7 from only linxu 2.7....
#commands = = == = commands.getstatusoutput("dir") 返回执行状态和结果
#print(res[0]) (res[1])
#subprocess python 3.5 ___run
import subprocess
# subprocess.run(["df","-h"])
# subprocess.run(["df","-h","|","grep","sda1"]) 命令执行会报错，因为加上管道符他解决不了
# subprocess.run(["df -h | grep sda1",shell=True]) 不需要python解析这个字符串，传给linux自己去解析
#os.system = = = subprocess.call("df -h",shell=True)输出命令结果到屏幕，返回命令执行状态
#subprocess.checkcall("df -h",shell=True)如果报错就抛出异常，也是返回状态
#subprocess.getstatusoutput("df -h",shell=True)返回执行状态和结果 ==== commands.getstatusoutput("dir")
#subprocess.getoutput("df -h",shell=True)返回结果= = =os.popen("dir")
#
#subprocess.Popen("ifconfig|grep 192",shell=True,subprocess.PIPE) pipe 管道意思
#res.stdout.read() 标准输出
#subprocess.Popen("dddd",shell=True,subprocess.PIPE,stderr=subprocess.PIPE)
#res.stderr.read() 标准错误
#subprocess.Popen("sleep30:echo 'hello'",shell=True,subprocess.PIPE,stderr=subprocess.PIPE)
#print(res.poll()) 这个是返回执行的状态，执行完了返回0没有执行返回None
#print(res.wait()) 等待返回结果
#terminate()杀掉所启动的进程
#subprocess.Popen("sleep30:echo 'hello'",shell=True,subprocess.PIPE,stderr=subprocess.PIPE)
#res.terminate()
#res.stdout.read() 是没有结果的，因为在上一个命令进程杀掉了
#communicate()等待任务结束 忘了他吧
#subprocess.Popen(['python3'],shell=True,subprocess.PIPE,stderr=subprocess.PIPE,stdin=subprocess.PIPE)
#res.stdin.write(b"print(1)")
#res.stdin.write(b"print(2)")
#res.communicate()
#cwd新启动的shell环境默认在哪个地方
#subprocess.Popen(['pwd'],shell=True,subprocess.PIPE,cwd="/tmp")
#res.stdout.read()
#subprocess 交互输入密码
#subprocess.Popen("sudo apt-get install vim",shell=True) 环境乱了
#echo "pwd" | sudo -S apt-get install vim -S从标准输入读取密码
#subprocess.Popen("echo 'pwd' | sudo -S apt-get install vim ",shell=True) 通过python可以
2.面向编程与面向对象，我把这部分内容写在core里面显示更好一些
2.1#面向对程 #自上而下的解决问题，基本设计思路一开始就是要着手解决问题 #以为有依赖，所以当一处要改就都要改 2.2#面向对象 #oop object oriented programing #class 类 就是模板 #一个类即是对一类拥有相同属性的对象的抽象，蓝图，原图 #object对象 通过模板推出来的人，或是实际上真实存在的东西 #一个对象即是一个类的实例化后的实例，就是造人的过程 2.3#面对对象的几个核心特性 #封装 在类中对数据的赋值，内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法 #1.防止数据被随意修改，2.使外部程序不需要关注对象内部的构造，只需要通过对象对外提供的接口进行直接访问即可 #继承 一个类可以派生出子类，在这个父类里定义的属性，方法自动被子类继承 #通过父类——》》子类的方式实现不同角色的共同点和不同点 #警察和犯罪组织 都属于人类，但是单拿出来又不同 #多态 一个接口，多种实现 一个基类派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类方法做了不同的实现 #黄种人 黑种人 白种人 都是继承了父类（基类）talk 但是说的语言又不同 2.4#面向对象编程介绍 #1.写重复代码是非常不好的低级行为 #2.写的代码需要经常变更 #（可读性好，易扩展）
3.类的定义
#类的定义
# class Dog(object):
# def sayhti(self):
# print("hello,im a dog") #狗有了，但是得调用
# d = Dog() #实例化 D叫做实例化后的对象 叫实例 ，当前这个类的实例
# #print(d) 内存对象
# d.sayhti() #先去实例化，在去调用方法
#无法判断谁是谁 那就需要传参数进来了。
#类就是一堆函数组合的，具有函数的性质，所以调用的时候需要self做个中介
class Dog(object):
def __init__(self,name): #叫做构造函数，构造方法，初始化方法
self.Name = name #调用方法，这个相当于类的全局变量
def sayhai(self): #类的方法
print("hello,im a dog",self.Name)
def eat(self,food):
print("%s is eating %s" % (self.Name,food))
#假如这里面你定义的一个买枪操作，初始构造的时候是51，现在你买了91.所以需要在全局上
#改变一下枪的名字 self.weapon = gun_name 就可以了
d = Dog("lili") #相当于 Dog(d,"lili")
d2 = Dog("liuzheng") #
d.sayhai()
d2.sayhai()
# d.eat("hanbao")
# d2.eat("zhurou") #可以往方法里面传参数
4.类的部分称呼
#类 --- 实例化 --- 实例对象
#_init_构造函数
#self.name = name 属性，成员变量，字段
#def sayhi() 方法 ，动态属性
5.封装的定义
#封装 #共有属性 所有属于我这类的对象都可以访问的 ，谁实例化了我都可以访问 #构造方法下面 叫做成员属性 __叫做私有属性 #共有属性写在类下面 nationality = "japan" # print(r1.nationality ) # print(r2.nationality ) #但是在调用的时候如果，更改了r1的共有属性，r1会变，r2不会变 #但是通过类名字去改，就是改变了全的Role。nationality = "us" #这2种方法更改的共有属性，将会按照对象更改属性去改为第一
6.析构方法
#析构方法
#方法的时候 def _del_(self):
# print("del ... run...") 当程序（实例销毁的时候）最后的时候会显示出来不需要调用
7.继承的定义
#当同一个类的对象有共同属性，也有不同属性的就要搞一个父类个多个子类 #通过继承创建的新类称为“子类”或“派生类” #被继承的类称为“基类”，“父类”或“超类” #继承的过程就是从一般到特殊。一般父类就是普通，特殊就是子类
8.继承的core
#oo开发范式大致为：划分对象-抽象类-将类组织成为层次化结构-用类与实例进行设计和实现的几个阶段
#
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
self.sex = "normal"
def talk(self):
print("person is talking....")#父类
class WhitePerson(Person):
pass
class Blackperson(Person):
def __init__(self,name,age,strength):#先继承，在重构
self.strength =strength
Person.__init__(self,name,age) #调用父类的构造方法
print(self.name,self.age,self.strength)
def talk(self):
print("bababababa %s" % self.name) #父类重写
def walk(self):
print("is walking") #定义自己的 子类
b = Blackperson("zhanmosi",22,"da")
b.talk()
b.walk()
#代码本身传送参数先去 Blackperson(Person): 然后需要父类的sex就需要直接调用父类的构造方法
9.继承的深度用法
学校 学生 老师
class schoolmember(object):#学校基类
member = 0
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
self.enroll()
def enroll(self):#注册
print("new schllo member [%s]" % self.name)
schoolmember.member += 1 #实例本身没有的话可以访问全局的
def tell(self):
print("————%s__info" % self.name)
for k,v in self.__dict__.items():
print("\t",k,v)
print("————end")
def __del__(self):
print("开出了 %s" % self.name)
schoolmember.member -= 1
class teacher(schoolmember):#讲师类 ###多继承就是在后面再加上个父类
def __init__(self,name,age,sex,salary,course):
schoolmember.__init__(self,name,age,sex) #经典类写法 继承写法
#super(teacher,self).__init__(name,age,sex) (另一种写法 新式类写法)
self.salary = salary
self.course = course
#self.enroll()
def tell(self):#打印教师信息
print("teache infromation %s" % self.name,self.age,self.course,self.salary)
def teaching(self):
print("teacher %s is" % self.name,self.course)
class student(schoolmember):
def __init__(self,name,age,sex,course,tuition):
schoolmember.__init__(self,name,age,sex)
self.course = course
self.tuition = tuition
#self.enroll()
self.amount = 0
def pat_tuition(self,amount):
print("student paid many %s" % self.name,amount)
self.amount += amount
t1 = teacher("whsir",28,"fm",3000,"python")
s1 = student("haitao",38,"f","pys15",30000)
s2 = student("lili",12,"m","pys15",10000)
print(t1.__dict__)
# print(schoolmember.member)
# print(s1.member)
print(s1.tell())
s2.tell() #不需要print 也可以展现出来
# del s2
# print(schoolmember.member) #这个时候会删除个人，因为析构函数是最后执行的
10.多继承的用法
#多继承时候 继承顺序的区别
class A(object):
def __init__(self):
self.n = "A"
class B(A):
pass
# def __init__(self):
# self.n = "B"
class C(A):
pass
# def __init__(self):
# self.n = "C"
class D(B,C):
pass #自身不在定义了 所以打印B 从左往右继承
#def __init__(self): #肯定是自身的所以打印D
# self.n = "D"
d = D()
print(d.n)
#python 3里面新式类和经典类都是从 D BC A这个顺序继承 称为广度查找
#python 2里面的经典类 D B A 没法找到C 称为深度查询 但是 D B A没有的话可以找C
11.新式类和经典类
#新式类，和经典类 #经典类 #class person(object) new style #super(teacher,self).__init__(name,age,sex) #class person classical style #schoolmember.__init__(self,name,age,sex)
12.多态
#多态
print("duotai".center(20,'+'))
class Animal:
def __init__(self, name): # Constructor of the class
self.name = name
print(name)
def talk(self): # Abstract method, defined by convention only
raise NotImplementedError("Subclass must implement abstract method")
class Cat(Animal):
def talk(self):
return 'Meow!'
class Dog(Animal):
def talk(self):
print(self.name)
return 'Woof! Woof!'
d = Dog("d")
c = Cat("c")
def animal_talk(d): #d或者c就是对象,为了方便看出来是谁这么写
print(d.talk())
animal_talk(d) #___ dog("d")___ obj-d
animal_talk(c)
13.私有属性
#私有属性 #构造方法下面 #self.__heart = "Normal" __2个下划线 对外面不可见的 通过调用构造方法下面的值是无用的 #在方法下面self._heart = "die" 对内部访问是可以的，通过调用类的方法 #外面可以访问我的私有属性，但是不能改 #可以定义一个方法，然后return self._heart #强制访问 #r1._Role__heart ##我们说的外面就是类外面调用的时候
14.普通方法与静态方法
#普通方法 在保存在类种，调用者对象，至少有一个self
class f1:
def __init__(self,name):
self.name = name
def a1(self):
print(self.name)
obj = f1('alex')
obj.a1()
#静态方法 在保存在类种，调用者直接是类，无需创建对象，可以有任意个参数
class f1:
@staticmethod
def a1(): #里面也是可以接受参数
print('alex')
obj.a1() #里面可以传值