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

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

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

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()

 

2019-02-06 00:01:53 weixin_43328213 阅读数 33
  • Python可以这样学(第一季:Python内功修炼)

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

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

1.返回操作系统类型

import os
from os.path import exists, splitext, join

#1.返回操作系统类型
print(os.name)
#值为posix,是linux系统,如果是nt,是windows系统
运行结果:posix

2.操作系统的详细信息

import os
from os.path import exists, splitext, join

#2.操作系统的详细信息
info = os.uname()
print(info)	#查看所有信息
print(info.sysname)		#查看某一项信息
运行结果:
posix.uname_result(sysname='Linux', nodename='foundation55.ilt.example.com', release='3.10.0-514.el7.x86_64', version='#1 SMP Wed Oct 19 11:24:13 EDT 2016', machine='x86_64')
Linux

3.系统环境变量

import os
from os.path import exists, splitext, join

#3.系统环境变量
print(os.environ)

4.通过key值获取环境变量对应的value值

import os
from os.path import exists, splitext, join
print(os.environ.get('PATH'))

5.判断是否为绝对路径

import os
from os.path import exists, splitext, join

print(os.path.isabs('/tmp/hello'))
print(os.path.isabs('hello'))
运行结果:
True
False

6.生成绝对路径

import os
from os.path import exists, splitext, join

print(os.path.abspath('hello.png'))
print(os.path.join('/home/kiosk','hello.png'))
运行结果:
/home/kiosk/PycharmProjects/untitled/hello.png
/home/kiosk/hello.png

7.获取目录名或文件名

import os
from os.path import exists, splitext, join

filename = '/home/kiosk/PycharmProjects/westos_python/day08/hello.png'
#获取路径中的文件名
print(os.path.basename(filename))
#获取路径中的目录名
print(os.path.dirname(filename))
运行结果:
hello.png
/home/kiosk/PycharmProjects/westos_python/day08

8.创建目录/删除目录

import os
from os.path import exists, splitext, join

os.mkdir('img')	#创建目录
os.rmdir('img')	#删除目录

os.makedirs('img/file') #创建递归目录
os.rmdir('img')	#删除目录失败,rmdir只能删除空目录

9.创建文件/删除文件

import os
from os.path import exists, splitext, join

os.mknod('westos.txt')	#创建
os.remove('westos.txt')	#删除

10.文件重命名

import os
from os.path import exists, splitext, join

os.rename('westos.txt','data.txt')

11.判断文件或者目录是否存在

import os
from os.path import exists, splitext, join

print(os.path.exists('data.txt'))
运行结果:False

12.分离后缀名和文件名

import os
from os.path import exists, splitext, join

print(os.path.splitext('data.txt'))
运行结果:('data', '.txt')

13.将目录名和文件名分离

import os
from os.path import exists, splitext, join

print(os.path.split('/tmp/hello/hello.png'))
运行时间:('/tmp/hello', 'hello.png')
2019-01-19 12:02:34 yang889999888 阅读数 760
  • Python可以这样学(第一季:Python内功修炼)

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

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

python文件系统模拟

文章来源:企鹅号 - 老虎太太的咖啡馆

OS课设:python的类ufs的多用户文件系统模拟。

 

结构图

github 地址:

https://github.com/TIGERTAITAI/FileSystem-Simulation

不想用c写的最主要原因是为了强迫自己不要抄代码(c++的文件系统源码网上比较多,用python写的少)。

文件系统模拟ufs格式。

用python的multiprocessing.connection Server 和Listener去处理多用户进程。

inodes和data blocks,以及各自的map。inodes是类数组data blocks是bytes数组。用bytes数组去模拟各种文件读写操作,包括目录文件。

写代码遇到的最大问题就是不知道系统结构怎样写比较好。如何巧妙利用语言的特性同时又要在原理上不破坏文件系统的机制。比如map的设置就是一个对文件系统的模拟,但事实上在python里直接对list操作会更加方便。

另外的一个问题是刚开始写的时候用一些外部函数去处理,然后就写的很乱。比如我要新建一个文件,就需要分配inode和block,然后用一个inode去记录所有分配的blocks,就要牵涉到inode, inodelist, inodeindex, inodemap, block, blocklist, blockindex, blockmap。往函数传参数时有时都不知道自己传的是inode还是inodeindex, inodeindex是list的index还是二维的map的index。然后函数又要调用一些子函数,很乱。各种参数和函数导致维护性很差,不好写。

最后代码经过了一次重构,设计了一些manager类去统一管理,并且规范之间的接口。如结构图所述。就清晰很多。

github里有使用说明。

2019-02-11 01:36:32 weixin_39454561 阅读数 18
  • Python可以这样学(第一季:Python内功修炼)

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

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

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 阅读数 996
  • Python可以这样学(第一季:Python内功修炼)

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

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

今天学习一下使用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开发环境搭建

阅读数 997

python os系统操作

阅读数 12

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