2019-01-21 22:58:09 weixin_44239454 阅读数 256
  • Python可以这样学(第一季:Python内功修炼)

    购买课程后,可扫码进入学习群,获取董付国老师答疑 董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

    27150 人正在学习 去看看 董付国

1.计算机由CPU、内存条、磁盘、键盘、鼠标和输入工具组成

  • 多任务

  1. 定义:同时运行多个程序
  2. CPU在多个进程之间高速切换
  3. 在一个时间戳上只有一个程序在运行
  4. 单核CPU:只有一个核心,来处理程序

   双核CPU:有两个核心,来处理程序

   四核CPU:有4个核心,来处理程序

  1. 查看CPU:电脑属性-->设备管理器 --->处理器 ,有四个表示一个CPU有四个核心
  2. 双核双线程:模拟四核,实际还是双核
  • 进程

  • .定义

  1. 双击应用程序时,加载内容,操作系统分配资源当它运行起来时,称为进程
  2. 一个应用程序对应多个进程
  3. 查看进程: Ctrl+Alt+Delete
  4. 进程是系统进行资源分配的最小单位  
  • 创建多进程

  1. 当所有子进程执行完之后,主进程才会结束,子进程执行完指向的目标,就结束了
  2. 一个CPU指向一个进程,谁能先抢到CPU,就先打印谁,多进程没有先后顺序
import time
import multiprocessing
def sing():
    for i in range(3):
        print('....正在唱歌....')
        time.sleep(1)
def dance():
    for i in range(3):
        print('.....正在跳舞.....')
        time.sleep(1)
def main():
    #创建一个多进程
    p1=multiprocessing.Process(target=sing)#创建一个子进程
    p2=multiprocessing.Process(target=dance)
    #开启子进程
    p1.start()
    p2.start()
'''当所有子进程结束后,主进程才会结束'''
if __name__=='__main__':
    main()
    print('结束了')
  • 进程状态

 

  1. 就绪状态(Ready):进程已分配的除CPU外的所有必要资源,只要获得处理机便可以立即执行,此时的状态为就绪状态
  2. 运行状态(Running ):进程已获得处理机,程序正在处理机上执行,此时的状态为运行状态
  3. 阻塞状态(Blacked):正在执行的进程,由于某个事件发生而无法执行时,便放弃处理机,而处于阻塞状态
  • 进程之间通讯

  1. 一个子进程往queue里写内容,一个进程从queue中取出数据,可以实现通讯
  2. 进城之间是相互独立的
  3. 队列:先进先出

   堆栈:先进后出

3.1队列

import multiprocessing
'''创建一个队列'''
q=multiprocessing.Queue(3)
q.put('hahahah')#向队列中添加数据
q.put(123)
q.put([1,2,3])
#q.put('xixixi')#如果超出指定存放的参数个数。阻塞了。直到有数据被移除使用后,才能继续放进去,否则一直等待放入
#q.put_nowait('vvvvv')#超出存放个数,不等待,直接抛出异常 queue.Full
print(q.get())#获取队列中的数据
print(q.get())
print(q.get())
#print(q.get())#如果队列中没有了数据,则一直等待,直到有数据才执行。
#print(q.get_nowait())#如果队列中没有了数据,则不等待,直接抛出异常   queue.Empty
print(q.empty())#判断队列是否还有数据
print(q.full())#判断队列是否满了,满了为True

 

 

  1. 进程通讯

import multiprocessing
'''创建一个队列'''
q=multiprocessing.Queue(3)
q.put('hahahah')#向队列中添加数据
q.put(123)
q.put([1,2,3])
#q.put('xixixi')#如果超出指定存放的参数个数。阻塞了。直到有数据被移除使用后,才能继续放进去,否则一直等待放入
#q.put_nowait('vvvvv')#超出存放个数,不等待,直接抛出异常 queue.Full
print(q.get())#获取队列中的数据
print(q.get())
print(q.get())
#print(q.get())#如果队列中没有了数据,则一直等待,直到有数据才执行。
#print(q.get_nowait())#如果队列中没有了数据,则不等待,直接抛出异常   queue.Empty
print(q.empty())#判断队列是否还有数据
print(q.full())#判断队列是否满了,满了为True
  • 传递参数

  1. 参数args的参数传递给子进程
import time
import multiprocessing
def sing(num):
    for i in range(num):
        print('...正在唱歌....')
        time.sleep(1)
def dance(num):
    for i in range(num):
        print('...正在跳舞....')
        time.sleep(1)
def main():
    p1=multiprocessing.Process(target=sing,args=(3,))
    p2=multiprocessing.Process(target=dance,args=(3,))
    p1.start()
    p2.start()
if __name__=='__main__':
    main()

  • 进程池

  1. multiprocessing提供的Pool类
  2. 缓存进程
  3. Join让主进程等待,子进程全部结束后,主进程往下执行,且必须在close的后面。
  4. Close等待所有程序结束才关闭进程池
import time
from multiprocessing import Process,Pool
def foo(i):
    print('i的值是:',i)
    time.sleep(1)
    print('end.....')
if __name__=='__main__':
    pool=Pool()
    for i in range(5):
        pool.apply_async(func=foo,args=(i,))#将任务添加到进程池中
    pool.close()#关闭进程池,等待所有进程结束才关闭
    pool.join()#请主进程等待,所有子进程结束,主进程才往下走
    print('--->>>>')
'''
i的值是: 0
i的值是: 1
i的值是: 2
i的值是: 3  ----->已经有一个任务睡醒了
end.....    ----->有个任务结束了,进程池空出一个位置,等待的任务运行
i的值是: 4  ----->又有一个任务睡醒了
end.....
end.....
end.....
end.....
--->>>>
'''
  • 线程

  • .定义

  1. 线程是CPU调度的最小单位
  2. 程序真的执行的时候调用的是线程,每个线程中至少有一个线程
  3. 进程和线程都可以实现多任务
  4. 进程和线程的关系

 

  • 使用threading模块创建线程


 

import threading,time
def sing():
    for i in range(3):
        print('正在唱歌。。。。')
        time.sleep(1)
def dance():
    for i  in range(3):
        print('正在跳舞。。。。。')
        time.sleep(1)
def main():
    '''创建子线程'''
    t1=threading.Thread(target=sing)
    t2=threading.Thread(target=dance)
    '''开启子线程'''
    t1.start()
    t2.start()
if __name__=='__main__':
    main()

'''
正在唱歌。。。。
正在跳舞。。。。。
正在跳舞。。。。。
正在唱歌。。。。
正在跳舞。。。。。
正在唱歌。。。。
'''

  • 传递参数

  1. 给子线程传递参数,以元组形式
import threading,time
def sing(num):
    for i in range(num):
        print('正在唱歌。。。。')
        time.sleep(1)
def dance(num):
    for i in range(num):
        print('正在跳舞。。。')
        time.sleep(1)
def main():
    t1=threading.Thread(target=sing,args=(3,))
    t2=threading.Thread(target=dance,args=(3,))
    t1.start()
    t2.start()
if __name__=='__main__':
    main()

  • Join()方法

  1. 功能:当前线程执行完后,其他线程才会继续执行
import threading,time
def sing(num):
    for i in range(num):
        print('正在唱歌')
        time.sleep(1)
def dance(num):
    for i in range(num):
        print('正在跳舞')
        time.sleep(1)
def main():
    t1=threading.Thread(target=sing,args=(4,))
    t2=threading.Thread(target=dance,args=(4,))
    #t1.join()#---->还未开启线程,报错
    t1.start()
    t1.join()
    t2.start()

if __name__=='__main__':
    main()
    print('结束了')
'''
正在唱歌
正在唱歌
正在唱歌
正在唱歌------>t1执行结束,
正在跳舞
结束了
正在跳舞
正在跳舞
正在跳舞------》t2和主进程同时开始,谁抢占CPU快,谁先打印

 

  • setDoemon()方法

  1. setDoemon()将当前线程设置成守护线程来守护主线程
  2. 当主线程结束后,守护线程也结束,不管是否执行完成。
import threading,time
def sing(num):
    for i in range(num):
        print('正在唱歌....')
        time.sleep(1)
def dance(num):
    for i in  range(num):
        print('正在跳舞。。。')
        time.sleep(1)
def main():
    t1=threading.Thread(target=sing,args=(3,))
    t2=threading.Thread(target=dance,args=(3,))
    '''设置守护线程'''
    t1.setDaemon(True)
    t2.setDaemon(True)
    t1.start()
    t2.start()
if __name__=='__main__':
    main()
    print('结束了')

'''
正在唱歌....
正在跳舞。。。
结束了-------->主线程结束,守护线程也结束

'''

 

  • Threading模块提供的方法

1.返回当前的线程变量------>threading.currentThread()

2.返回正在运行的线程的list------>threading.enumerate()

3.返回正在运行的线程的数量: ------>threading.activeCount()

4.获取线程的名称: getName

5.设置线程的名称:setName

6.判断当前线程是否存活:is_Alive()

  • 使用继承方式开启线程

i

mport threading,time
class MyThread(threading.Thread):
    def __init__(self,num ):
        super().__init__()
        self.num=num
    def run(self):
        for i in range(3):
            print('i......>>',i)
            time.sleep(1)
if __name__=='__main__':
    my_thread=MyThread(3)
    my_thread.start()#继承父类

  • 线程之间共享全局变量及问题

  1. 多个线程同时操作共享全局变量,会造成数据不安全
  2. 两个同时写会出现数据被覆盖现象
  3. 同时读没有问题
  4. 一个读一个写有问题
import threading
g_num=10
def test1():
    '''修改全局变量'''
    global g_num
    g_num+=1
    print('test1....',g_num)
def tese2():
    '''打印全局变量'''
    print('test2....',g_num)
def main():
    t1=threading.Thread(target=test1)
    t2=threading.Thread(target=tese2)
    t1.start()
    t2.start()
if __name__=='__main__':
    main()

  • 互斥锁

  1. 互斥锁保证了每次只有一个线程进入写操作
  2. 互斥锁是最简单的同步机制
  3. 可以解决共享全局变量问题,但必须保证是同一把锁。
import threading
g_num=0
def test1(num):
    global g_num
    lock1.acquire()
    for i in range(num):
        g_num+=1
    lock1.release()
    print('test1....',g_num)
def test2(num):
    global g_num
    lock1.acquire()
    for i in range(num):
        g_num+=1
    lock1.release()
    print('test1.....',g_num)
lock1=threading.Lock()
def main():
    t1=threading.Thread(target=test1,args=(10000000,))
    t2=threading.Thread(target=test2,args=(10000000,))
    t1.start()
    t2.start()
if __name__=='__main__':
    main()

  • 生产值和消费者模式

import queue,threading
q=queue.Queue()

def producter(name):
    count=1
    while count<=100:
        q.join()#接收信号
        lock1.acquire()
        q.put(count)#把第一晚放进去
        print('{}正在做第{}面条'.format(name,count))

        count+=1
        lock1.release()

lock1=threading.Lock()
#lock2=threading.Lock()
def customer(name):
    count=1
    while count<=100:
        data=q.get()#取第一碗
        lock1.acquire()#先去在上锁
        print('{}正在吃第{}碗面条'.format(name,data))
        count+=1
        lock1.release()
        q.task_done()#发出信号


def main():
    t1=threading.Thread(target=producter,args=('海参',))
    t2=threading.Thread(target=customer,args=('小包',))
    t1.start()
    t2.start()
if __name__=='__main__':
    main()

  • GIL全局解锁

  1. GIL:global interpreter lock
  2. 并行:多个CPU同时执行多个任务
  3. 并发:CPU交替处理多个任务
  4. 一个CPU不能同时运行多个程序,即一个CPU不可能实现并行
  • 协程

  • .定义

  1. 协程是非抢占式,主要解决IO操作
  2. 协程执行效率极高,因为子程序切换不是线程切换,是由程序自身控制
  3. 不需要多线程的锁机制,因为只有一个线程,不存在同时写变量冲突,协程中共享资源不加锁,只需判断就可以
  • Yield实现协程

import time
def test1():
    while True:
        print('test1')
        time.sleep(1)
        yield#遇到yield停止
def test2():
    while True:
        print('test2')
        time.sleep(1)
        yield
def main():
    g1=test1()#创建两个生成器对象
    g2=test2()
    while True:
        next(g1)#执行test1函数体
        next(g2)
if __name__=='__main__':
    main()

 

2018-08-22 16:44:09 qq_33567641 阅读数 9735
  • Python可以这样学(第一季:Python内功修炼)

    购买课程后,可扫码进入学习群,获取董付国老师答疑 董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

    27150 人正在学习 去看看 董付国

操作系统(Operating System,简称OS)是管理和控制计算机硬件与软件资源的计算机程序,是直接运行在“裸机”上的最基本的系统软件,任何其他软件都必须在操作系统的支持下才能运行。

单道程序系统

手工操作——穿孔卡片

1946年第一台计算机诞生--20世纪50年代中期,计算机工作还在采用手工操作方式。此时还没有操作系统的概念。

穿孔卡带
穿孔卡带
早期计算机

程序员将对应于程序和数据的已穿孔的纸带(或卡片)装入输入机,然后启动输入机把程序和数据输入计算机内存,接着通过控制台开关启动程序针对数据运行;计算完毕,打印机输出计算结果;用户取走结果并卸下纸带(或卡片)后,才让下一个用户上机。

手工操作的两个特点:

  • 用户独占全机,不会出现等待的情况,但是资源利用率极低。
  • 完全手工操作,等待时间较长,CPU利用率低。
  • 编码和操作繁琐复杂,难以广泛利用。

20世纪50年代后期,出现人机矛盾:手工操作的慢速度和计算机的高速度之间形成了尖锐矛盾,手工操作方式已严重损害了系统资源的利用率(使资源利用率降为百分之几,甚至更低),不能容忍。唯一的解决办法:只有摆脱人的手工操作,实现作业的自动过渡。这样就出现了成批处理。

批处理——磁带储存

批处理系统:加载在计算机上的一个系统软件,在它的控制下,计算机能够自动地、成批地处理一个或多个用户的作业(这作业包括程序、数据和命令)。

批处理计算机

主机与输入机之间增加一个存储设备——磁带,在运行于主机上的监督程序的自动控制下,计算机可自动完成:成批地把输入机上的用户作业读入磁带,依次把磁带上的用户作业读入主机内存并执行并把计算结果向输出机输出。完成了上一批作业后,监督程序又从输入机上输入另一批作业,保存在磁带上,并按上述步骤重复处理。

监督程序不停地处理各个作业,从而实现了作业到作业的自动转接,减少了作业建立时间和手工操作时间,有效克服了人机矛盾,提高了计算机的利用率。

但是,在作业输入和结果输出时,主机的高速CPU仍处于空闲状态,等待慢速的输入/输出设备完成工作: 主机处于“忙等”状态。

脱机批处理系统

为克服与缓解:高速主机与慢速外设的矛盾,提高CPU的利用率,又引入了脱机批处理系统,即输入/输出脱离主机控制。

脱机批处理系统

功能

  • 从输入机上读取用户作业并放到输入磁带上。
  • 从输出磁带上读取执行结果并传给输出机。

特点

优点:

  • 主机不是直接与慢速的输入/输出设备打交道,而是与速度相对较快的磁带机发生关系,有效缓解了主机与设备的矛盾。
  • 主机与卫星机可并行工作,二者分工明确,可以充分发挥主机的高速计算能力。
  • 极大缓解了人机矛盾及主机与外设的矛盾。

缺点:

  • 每次主机内存中仅存放一道作业,每当它运行期间发出输入/输出(I/O)请求后,高速的CPU便处于等待低速的I/O完成状态,致使CPU空闲。

多道程序系统

 所谓多道程序系统,就是指允许多个程序同时进入内存并运行。即同时把多个程序放入内存,并允许它们交替在CPU中运行,它们共享系统中的各种硬、软件资源。当一道程序因I/O请求而暂停运行时,CPU便立即转去运行另一道程序的系统。

多道程序系统的出现,标志着操作系统渐趋成熟的阶段,先后出现了作业调度管理、处理机管理、存储器管理、外部设备管理、文件系统管理等功能。由于多个程序同时在计算机中运行,开始有了空间隔离的概念,只有内存空间的隔离,才能让数据更加安全、稳定。除了空间隔离之外,多道技术还第一次体现了时空复用的特点,遇到IO操作就切换程序,使得cpu的利用率提高了,计算机的工作效率也随之提高。

操作系统的分类

分时系统:把处理机的运行时间分成很短的时间片,按时间片轮流把处理机分配给各联机作业使用的一种操作系统。

实时系统:系统能够及时响应随机发生的外部事件,并在严格的时间范围内完成对该事件的处理的操作系统。

网络操作系统:通过通信设施,将地理上分散的、具有自治功能的多个计算机系统互连起来,实现信息交换、资源共享、互操作和协作处理的系统。

分布式操作系统:将地理上分散的具有自治功能的数据处理系统或计算机系统互连起来,实现信息交换和资源共享,协作完成任务的系统。

其它系统:嵌入式开发系统,个人操作系统等。

操作系统的作用

  • 管理计算机所有的硬件和资源,为用户提供了一个抽象概念上的计算机。
  • 用户使用计算机时,避免了对计算机系统硬件的直接操作。
  • 操作系统抽象了计算机的操作命令,简化了计算机的操作。
  • 拓展计算机之间的功能。
2020-01-04 17:02:50 yrx420909 阅读数 32
  • Python可以这样学(第一季:Python内功修炼)

    购买课程后,可扫码进入学习群,获取董付国老师答疑 董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

    27150 人正在学习 去看看 董付国

1. 返回操作系统类型

posix 表示linux操作系统
nt 表示windows操作系统

在这里插入图片描述

2. 操作系统详细信息

在这里插入图片描述在这里插入图片描述

3. 环境变量

在这里插入图片描述在这里插入图片描述

4. 获取一段时间内CPU的占有率

import psutil
import time

# cpu_res = psutil.cpu_percent()
# print(cpu_res)

# 每一秒获取获取cpu的占有率 --->持久化保存
# 如何将时间和对应的cpu占有率去匹配

while True:
    # 获取当前时间和cpu的占有率
    t = time.localtime()
    cpu_time = '%d:%d:%d' %(t.tm_hour,t.tm_min,t.tm_sec)
    cpu_res = psutil.cpu_percent()
    print(cpu_res)

    # 保存在文件中
    with open('cpu.txt','a+') as f:
        f.write('%s %s \n' %(cpu_time,cpu_res))
    time.sleep(1)

在这里插入图片描述
在这里插入图片描述
还可以使用pyecharts模块绘制图形

import random
from pyecharts.charts import Line
import pyecharts.options as opts

# 获取折线图需要绘制的数据信息;
x = []
y = []

with open('cpu.txt') as f:  # 以读的方式打开文件
    for line in f:          # 依次遍历文件的每一行内容
        time, per = line.split()    # 返回时间和对应时间
        # 的cpu占有率
        x.append(time)
        y.append(per)

# 添加x和y对应的点;
line = (
     Line()
    .add_xaxis(x)
    .add_yaxis("", y)

    .set_global_opts(title_opts=opts.
                     TitleOpts(title="Cpu占有率散点图"))
)
# 将折线图信息保存到文件中;
line.render()
2019-02-11 01:36:32 weixin_39454561 阅读数 33
  • Python可以这样学(第一季:Python内功修炼)

    购买课程后,可扫码进入学习群,获取董付国老师答疑 董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

    27150 人正在学习 去看看 董付国

python os模块 其他操作系统接口

python官宣内容

This module provides a portable way of using operating system dependent functionality.
If you just want to read or write a file see open(), if you want to manipulate paths, see the os.path module, and if you want to read all the lines in all the files on the command line see the fileinput module. For creating temporary files and directories see the tempfile module, and for high-level file and directory handling see the shutil module.

翻译:该模块提供了一种使用操作系统相关功能的便携方式。
如果您只想读取或写入文件,请参阅open(),如果要操作路径,请参阅os.path模块,如果要读取命令行中所有文件中的所有行,请参阅fileinput模块。 有关创建临时文件和目录的信息,请参阅tempfile模块,有关高级文件和目录的处理,请参阅shutil模块。

简单说就是:os可以利用它提供的方法和当前的操作系统交互

os模块常用方法

os.remove(‘path/filename’) 删除文件

os.rename(oldname, newname) 重命名文件

os.walk() 生成目录树下的所有文件名

os.chdir(‘dirname’) 改变目录

os.mkdir/makedirs(‘dirname’)创建目录/多层目录

os.rmdir/removedirs(‘dirname’) 删除目录/多层目录

os.listdir(‘dirname’) 列出指定目录的文件

os.getcwd() 取得当前工作目录

os.chmod() 改变目录权限

os.path.basename(‘path/filename’) 去掉目录路径,返回文件名

os.path.dirname(‘path/filename’) 去掉文件名,返回目录路径

os.path.join(path1[,path2[,…]]) 将分离的各部分组合成一个路径名

os.path.split(‘path’) 返回( dirname(), basename())元组

os.path.splitext() 返回 (filename, extension) 元组

os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间

os.path.getsize() 返回文件大小

os.path.exists() 是否存在

os.path.isabs() 是否为绝对路径

os.path.isdir() 是否为目录

os.path.isfile() 是否为文件

2016-04-12 22:29:06 Java_HYL 阅读数 1015
  • Python可以这样学(第一季:Python内功修炼)

    购买课程后,可扫码进入学习群,获取董付国老师答疑 董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

    27150 人正在学习 去看看 董付国

今天学习一下使用python操作系统资源 (命令、ip),这也是作为基础部分大最后一篇,从下次开始将进行实战,从小项目入手已具体需求为出发点来系统的学习使用python。

#!/usr/local/bin/python2.7
# -*- coding:utf-8 -*-
'''
Created on 2016年4月12日

@author: damuou
使用python获取本机ip地址
'''
import socket

def get_local_ip():
    #获取本机电脑名
    this_name = socket.getfqdn(socket.gethostname())
    #获取本机ip
    this_ip = socket.gethostbyname(this_name)
    print this_name
    print  this_ip

get_local_ip()

'''
python 执行命令
'''
import  os
#python 方法1:执行ls命令
os.system("ls")

#方法二:
import commands
commands.getstatusoutput("ls")  

Python开发环境搭建

阅读数 1010

python os系统操作

阅读数 32

没有更多推荐了,返回首页