Python自用指令合集

最新推荐文章于 2023-11-22 14:45:00 发布
置顶 最新推荐文章于 2023-11-22 14:45:00 发布
阅读量451 收藏 1
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_ljy/article/details/105779971
版权

Python自学指令合集

线程

线程一 开启线程

#导入模块
import time
import threading
from time import ctime,sleep
#定义函数
def A(n):
    print('ok A', ctime())
    sleep(1)
    print ('end A', ctime())
def B(n):
    print('ok B', ctime())
    sleep(2)
    print('end B', ctime())
 
#创建线程t1和t2
t1 = threading.Thread(target=A, args=(10,))
t2 = threading.Thread(target=B, args=(20,))
 
#开启线程t1和t2
t1.start()
t2.start()
#输出主函数
print('________________main_________________', ctime())

输出结果：
ok A Fri Aug 16 11:27:51 2019
ok B Fri Aug 16 11:27:51 2019
main_____ Fri Aug 16 11:27:51 2019
end A Fri Aug 16 11:27:52 2019
end B Fri Aug 16 11:27:53 2019

线程二 线程中join（）方法的使用

1.在程序不使用join方法的时候：

#导入模块
import time
import threading
from time import ctime,sleep
#定义函数
def A(n):
    print('ok A', ctime())
    sleep(1)
    print ('end A', ctime())
def B(n):
    print('ok B', ctime())
    sleep(3)
    print('end B', ctime())
 
 创建线程t1和t2
t1 = threading.Thread(target=A, args=(10,))
t2 = threading.Thread(target=B, args=(20,))
 
 开启线程t1和t2
t1.start()
t2.start()
#使用join方法
#t1.join()
#t2.join()
 输出主函数
print('________________main_________________', ctime())

输出结果是：

ok A Fri Aug 16 11:52:10 2019
ok B Fri Aug 16 11:52:10 2019
_ main__ Fri Aug 16 11:52:10 2019
end A Fri Aug 16 11:52:11 2019
end B Fri Aug 16 11:52:13 2019

结论：

在没有使用join方法的时候，首先输出的线程一二和主线程，然后输出线程一二。

2.在使用join方法的情况下：

#导入模块
import time
import threading
from time import ctime,sleep
#定义函数
def A(n):
    print('ok A', ctime())
    sleep(1)
    print ('end A', ctime())
def B(n):
    print('ok B', ctime())
    sleep(3)
    print('end B', ctime())
 
 创建线程t1和t2
t1 = threading.Thread(target=A, args=(10,))
t2 = threading.Thread(target=B, args=(20,))
 
开启线程t1和t2
t1.start()
t2.start()
#使用join方法
t1.join()
t2.join()
#输出主函数
print('________________main_________________', ctime())

输出结果：

ok A Fri Aug 16 11:54:57 2019
ok B Fri Aug 16 11:54:57 2019
end A Fri Aug 16 11:54:58 2019
end B Fri Aug 16 11:55:00 2019
_ main__ Fri Aug 16 11:55:00 2019

结论：

在使用join方法的情况下，主函数main会等待线程运行结束后，再执行主函数。

3.当join方法放置位置不同的时候：

#导入模块
import time
import threading
from time import ctime,sleep
#定义函数
def A(n):
    print('ok A', ctime())
    sleep(1)
    print ('end A', ctime())
def B(n):
    print('ok B', ctime())
    sleep(3)
    print('end B', ctime())
 
#创建线程t1和t2
t1 = threading.Thread(target=A, args=(10,))
t2 = threading.Thread(target=B, args=(20,))
 
#开启线程t1和t2
t1.start()
t1.join()
t2.start()
#使用join方法
t2.join()
#输出主函数
print('________________main_________________', ctime())

输出：

ok A Fri Aug 16 11:57:51 2019
end A Fri Aug 16 11:57:52 2019
ok B Fri Aug 16 11:57:52 2019
end B Fri Aug 16 11:57:55 2019
__ main___ Fri Aug 16 11:57:55 2019

结论：

可以看出，此时的结果如同串行结果，子啊线程一执行完成之后，再开始执行线程二，可以将join方法理解为阻塞。

线程三：锁的概念

第一步：

一个减一的多线程程序

#导入模块
import threading
import time
from time import ctime,sleep
num=100
#定义函数
def addNum():
    global num
    num-=1
# 创建列表
thread_list=[]
# 写一个循环，同时执行100个线程
for i in range(100):
    t=threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)
# 给每个线程添加一个join方法，为了让print函数随后输出
for t in thread_list:
    t.join()
# 输出print函数
print ('final num:',num)

输出结果：

final num: 0
结论：没有任何问题，就是一个减一的操作。

第二步：

对原始程序进行修改：

def addNum():
    global num
#     num-=1
    temp=num
    num=temp-1
    print()
#修改部分

现程序：

#导入模块
import threading
import time
from time import ctime,sleep
num=1000
#定义函数
def addNum():
    global num
    temp=num
    sleep(0.001)
    num=temp-1
    # num-=1
# 创建列表
thread_list=[]
# 写一个循环，同时执行100个线程
for i in range(1000):
    t=threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)
# 给每个线程添加一个join方法，为了让print函数随后输出
for i in thread_list:
    t.join()
# 输出print函数
print ('final num:',num)

输出：

final num: 916（在变化）

结论：
在这里插入图片描述
如图所示， python解释器调用原生线程，在cpu上执行，由于sleep，会自动释放gil，此时并没有执行减一，所以导致出现这种情况。

第三步：加锁

修改代码

r=threading.Lock()
#定义函数
def addNum():
    global num
    r.acquire()
    temp=num
    sleep(0.1)
    num=temp-1
    r.release()

修改后代码：

##导入模块
import threading
import time
from time import ctime,sleep
num=100
r=threading.Lock()
#定义函数
def addNum():
    global num
    r.acquire()
    temp=num
    sleep(0.1)
    num=temp-1
    r.release()
    # num-=1
# 创建列表
thread_list=[]
# 写一个循环，同时执行100个线程
 
for i in range(100):
    t=threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)
# 给每个线程添加一个join方法，为了让print函数随后输出
for i in thread_list:
    t.join()
# 输出print函数
print ('final num:',num)

运行结果：

final num: 0

结论:

加锁之后，程序就会将锁住的地方执行完成再释放gil。

不用join反而用锁的原因是，如果用了join，整个函数里面就是串行的了，如果使用锁，则只有锁住的地方才是串行，而函数的其余地方任然是多线程。

线程四：守护线程

# !/usr/bin/python
# coding=utf-8

import threading
import time
def a():
    time.sleep(3)
    print('a hanshu')

w =threading.Thread(target=a)
w.setDaemon(True)
w.start()
print('main_____')

一旦主线程结束后，子线程也就结束。

队列

Queue模块 队列模块
FIFO——先进先出

q=queue.Queue(4) 创建一个队列含四个坑位
q.put(‘a’) 在q中填满第一个坑位
q.put(‘b’) 在q中填满第二个坑位

q.full() 判断q队列是否为满的
q.empty() 判断q队列是否为空的
q.qsize() 判断当前队列中的数量
q.get() 从q中取出第一个值

Subprocess

subproces.call 默认将回显打印打印出来
stdout 将回显指定位置放置

subprocess.call(['ping', '118.25.52.128', '-n' ,'1' ],shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

模块

sys模块

sys模块：
（和python解释器进行交互）

1.sys.argv

效果：
这是图片
2.sys.path
相当于环境变量，打印出来是一个列表：
在这里插入图片描述
当我们使用import导入的时候，会从按照这个顺序进行查找。
如果没有，则需要我们自行进行添加
添加的方式例如：sys.path.insert(0,path)

示例：
当前环境
在这里插入图片描述
我们在two中写一个普通的函数，我们在one中进行调用
Step one：
在bin中输出sys.path查看当前的环境
在这里插入图片描述

发现，当前环境查找顺序为：当前目录——site-packetage——pydatabase，并无我们需要的two路径，所以需要我们自行添加

Step two：
添加sys.path
在这里插入图片描述

3.sys.platform
Windows——输出win32
Linux（kali）——输出linux2

文件读写

读：
打开文本： f=open(r’D:\abc.txt’)
设置文本指针： f.seek(0)
打开所有文本： f.read()
打开指定字符数量文本：f.read(5)
读行数： f.readline()
读所有行数： f.readlines(0)
关闭文件： f.close()

写： f=open(r’D:\abc.txt’,’w’)
写入： fw.write(‘woaini’) 覆盖原有

追加： f=open(r’D:\abc.txt’,’a’)
写入： fa.writelines([fa mode write’,’2kfja’])

Json

当我们想把一个字典放入一个文件中时，文件报错，提示字符类型必须是str。

a=  {'height':180,'sex':'boy'}
with open('a.txt','w') as f:
    f.write(a)
    #程序报错
    #TypeError: write() argument must be str, not dict

a=  {'height':180,'sex':'boy'}
import json
with open('a.txt','w') as f:
    f.write(json.dumps(a))
    #程序正常执行，成功存入
    #a.txt内容——{"height": 180, "sex": "boy"} 
with open('a.txt','r') as f:
    data=json.load(f)
    print(data)
    print(type(data))
    #加载（读取）a.txt中的内容

pickle

Json对函数对象无法进行序列化，而pickle可以
用法同json

模块

OS模块

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

os.chdir(r’D:) 修改工作目录

os.curdir 一个.

os.pardir 两个…

os.makedirs('a/b/c;) 生成多层递归目录

os.mkdir(‘a’) 生成目录，只能一个一个创建

os.removedirs(‘a/b/c’) 删除目录，如果目录上一级是空的，则一并删除

os.rmdir(‘a/b/c’) 删除指定文件

os.listdir(‘D://’) 显示当前目录内容

os.sep 当前目录下的分隔符

os.linesep 行终止符

os.pathsep 文件路径分隔符

os.system（‘dir’） 运行shell命令，直接显示

os.environ 环境变量

os.path.abspath(’./1.py’) 拿文件的绝对路径

os.path.split(r’D:\PyCharm 2018.3.5\pydatabase\魔法方法’)

效果：(‘D:\PyCharm 2018.3.5\pydatabase’, ‘魔法方法’)

os.path.dirname(D:\a\b’) 显示当前文件所在目录

os.path.basename(‘D:\PyCharm 2018.3.5\pydatabase’, ‘魔法方法’) 返回路径最后的文件名

os.path.join(‘ss’+‘c’) 字符拼接

SYS模块

sys.platform #返回当前操作系统名称

sys.argv #返回程序本身路径，可在后添加参数

sys.path #打印程序环境变量

sys.stdin.readline().strip() #标准输入

sys.version #返回当前系统版本

RE模块

#元字符
#1.通配符（（（（.））））
a=re.findall('w..l','hello world')
print ('1',a)
print('')
#(((.)))代指所有得符号 除了换行符
#只能代指任意一个字符

#2.尖角符（（（^）））
#只看开始，从开头开始匹配
b=re.findall('^h...o','henlojadflkjfehello')
print('2',b)
print('')

#3.dollor符（（（$）））
#只看结尾，从结尾开始匹配
ret=re.findall('a..x$','fasdjflkasjdfkljakljealexakdx')
print('3',ret)
print('')

#4.重复匹配（（（*）））
#【0，+无穷】
ret=re.findall('ab*','csdfsdfdsfweabbbbbbb')
print('4',ret)
print('')

#5.重复匹配（（（+）））
#可以匹配a和【1，无穷】个b
#【1，+无穷】
ret=re.findall('ab+','csdfsdfdsfweabbbb')
print('5',ret)
print('')

#6.重复匹配（（（？）））
#【0，1】
ret=re.findall('a?b','acsdfsdabfdsfweba')
print('6',ret)
print('')

#7.重复匹配（（（{}）））
#贪婪匹配
#【a，b】
#{1，}代表1到正无穷
ret=re.findall('a{1,3}b','aaaasdab')
print('7',ret)
print('')

#8.选择（（（【】）））
选择
ret=re.findall('a[c,d]b','acb adb acdb')
print('8',ret)

ConfigParser模块

import configparser
config=configparser.ConfigParser()
config['DEFAULT']={'AA':'1','BB':'2'}
config['A']={'CC':'3','DD':'4'}
config['B']={'EE':'5','FF':'6'}
with open('cons','w') as configfile:
    config.write(configfile)        #将文件保存在cons这个文件里面

Logging模块

logging.basicConfig(
    level=logging.DEBUG,
    # 日志格式
    # 时间、代码所在文件名、代码行号、日志级别名字、日志信息
    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
    # 打印日志的时间
    datefmt='%a, %d %b %Y %H:%M:%S',
    # 日志文件存放的目录（目录必须存在）及日志文件名
    filename='test.log',
    # 打开日志文件的方式
    filemode='a'
)

logger=logging.getLogger()

fh=logging.FileHandler(‘test.log’)#文件对象
ch=logging.StreamHandler()#屏幕对象

formatter=logging.Formatter(’%(asctime)s’)

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh)
logger.addHandler(ch)
logger.setLevel(logging.DEBUG)

logging.debug(‘debug message1’)
logging.info(‘info message1’)
logging.warning('warning1 ')#默认
logging.error(‘error message1’)
logging.critical(‘critical message1’)

函数

静态方法

'''静态方法'''
class foo:
    @staticmethod
    def sta():
        print('123')
foo.sta()

多继承

class A:
    def a(self):
        print("i am 'a'")
        self.m()
    def m(self):
        print("i am 'm'")

class B:
    def m(self):
        print("i am 'Mb'")

class W(B,A):
    pass

obj=W()
obj.a()

输出：
i am ‘a’
i am ‘Mb’

闭包

def outer():
    x=10
    def inner():#条件一 内部函数

        print(x)#条件二 外部环境的一个变量

    return inner#结论： 内部函数inner就是一个闭包

闭包：

闭包=内部函数+内置函数的环境

闭包的定义：如果在一个内部函数里，对在外部作用域（但不是再全局作用域）的变量进行应用，那么内部函数就呗认为是闭包。

如上所示，我的inner函数脱离了outer（）但是依然可以用x=10 这个值

@property@setter@deleter

class BB:
    #@property
    def foo(self):
        print('hello')

a =BB()
a.foo()

class BB:
    @property
    def foo(self):
        print('hello')

a =BB()
a.foo

@property 使调用方法的时候可以像调用属性一样调用

class Student(object):
    x=100
    @property
    def per(self):
        x=100
        return x

    @per.setter
    def per(self,val):
        print(val)

    @per.deleter
    def per(self):
        print(666)

obj=Student()


obj.per = 123
del obj.per

#setter是设置参数

四夕王君_Y
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python数据类型汇编
bcli_幻化的博客
10-28 756
1.基本概念 1.1表达式 （1）表达式（类似数学公式），是由数字、算符、数字分组符号（括号）、⾃由变量和约束变量等以能求得数值的有意义排列⽅法所得的组合 （2）表达式特点 ①表达式⼀般仅仅⽤于计算⼀些结果，不会对程序产⽣实质性的影响 ②如果在交互模式中输⼊⼀个表达式，解释器会⾃动将表达式的结果输出 1.2语句 （1）⼀个语法上⾃成体系的单位，它由⼀个词或句法上有关连的⼀组词构成 （2）语句的执⾏⼀般会对程序产⽣⼀定的影响,在交互模式中不⼀定会输出语句的执⾏结果 （3）代码块：执行的话，都会执行，不执行的话
DL编程常用python命令合集
AI扑社
08-11 934
1. 列表list操作 排序 2. 文件相关的操作 路径和文件名分离 文件复制 glob获取文件绝对路径 前缀后缀判断 3. 字符串str操作 分割切片 4. 其他问题 自定义的py文件import后找不到路径 5. 注意事项 文件命名 6. 一些操作合集 判断数据类型 集合set 利用bool矩阵进行索引 执行字符串表达式 filter()过滤序列 1. 列 表lis t操 作 排序 注意 ：文件夹读取相关的最好都先排序，否则zip排序出BUG不好找 文件读..
python使用命令大全
weixin_38293440的博客
06-08 2万+
三方包操作函数： os.getced()  无需参数，返回该运行文件的目录。 os.path.join（A,B）  参数AB为地址，该函数为地址拼接，新地址为A+B。 os.walk(path)  返回三个值，按顺序分别为parent、dirnames、filenames。分别表示为path路径，该路径下的文件夹名字，除文件夹以外的其他文件   os.listdir(path)  与os....
Python指令汇总（一）
mozheng_zy的博客
01-26 1153
Python指令汇总BIFhelp()random.randint()类型转换函数int()float()str()type() BIF BIF即Built-in Functions，意为内置函数。 可输入dir(_ _ builtins _ _)查看Python提供的内置函数列表。 >>> dir(__builtins__) ['ArithmeticError', 'Asser...
全网最全的Python常见命令大全，建议收藏，以防备用
Python单行客的博客
10-10 1036
全网最全的Python常见命令大全，建议收藏，以防备用
Python基础语法合集.pdf
06-06
Python基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdf
python循环指令.docx
06-12
python循环指令 Python循环指令是Python编程语言中最重要的一部分之一。循环指令是一种重复执行某些操作的方法，这些操作可以是任何Python代码。Python提供了两种类型的循环指令：for循环和while循环。 for循环是...
python自用笔记综合
10-07
python自用笔记综合
python基础语法合集
01-17
适合所有的python使用者、学习者
Python 小游戏合集
最新发布
05-15
python Python 小游戏合集
python基本42个命令
Python单行客的博客
11-22 1万+
python基本42个命令
python中class的定义及使用_python基础教程之类class定义使用方法
weixin_39524741的博客
11-28 312
面对对象(oop)中的对象，是一个非常重要的知识点，我们可以把它简单看做是数据以及由存取、操作这些数据的方法所组成的一个集合。我们在学习函数(function)之后，知道了如果重用代码，那为什么还要用类来取代函数呢？类有这样一些的优点1) 、类对象是多态的：也就是多种形态，这意味着我们可以对不同的类对象使用同样的操作方法，而不需要额外写代码。2)、类的封装：封装之后，可以直接调用类的对象，来操作内...
python部分常用命令
moonlione的博客
11-12 1万+
python中文注释方法 在python编写代码的时候，避免不了会出现或是用到中文，这时候你需要在文件开头加上中文注释。如果开头不声明保存编码的格式是什么，那么它会默认使用ASKII码保存文件，这时如果你的代码中有中文就会出错了，即使你的中文是包含在注释里面的。所以加上中文注释很重要。 #coding=utf-8 或者： #coding=gbk type()函数可以做什么 在介
python 代码命令大全-Python常用命令最全合集
q6q6q的专栏
10-28 7947
文章目录一、Python环境配置命令二、Python 常用命令三、pip管理工具命令四、发布包到pypi(官网)命令Mac 电脑自带python2.x版本，终端输入python -V // 查看当前版本如果需要安装python3.x ,输入命令brew install python3 // 安装python3二、Python环境配置命令1. 配置pip的镜像源 （pip是python的包...
python 代码命令大全
热门推荐
机器学习-深度学习-图像处理-opencv-段子
05-25 4万+
以下命令都是我边做项目边学习的 strip命令 知道stripper 吧，哈哈。 对，strip就是将某部分内容删除。 map命令 一张图搞定 power 命令  可是让我好找，一直找不到，， sqrt命令 就是一个开方命令 。
python 小白学习-列表
weixin_42543778的博客
05-09 659
如果有过编程语言在去学习另外一门语言会很快，这里直接看方法。 python的列表是比较强大的，它包含了很多不同类型的数据：整型数字，浮点型，字符串以及对象等。 对于python列表里元素的操作主要分为以下几个方面： 1、 向列表里面加元素； 2、 删减列表中的一些元素； 3、 获取列表里面的特定元素； 4、 列表分片； 5、 常用的列表操作符； 6、 其他常见列表操作函数 7、 列表的拷贝 下面我...
2020-12-07
weixin_52873933的博客
12-07 163
三方包操作函数： os.getced() 无需参数，返回该运行文件的目录。 os.path.join（A,B） 参数AB为地址，该函数为地址拼接，新地址为A+B。 os.walk(path) 返回三个值，按顺序分别为parent、dirnames、filenames。分别表示为path路径，该路径下的文件夹名字，除文件夹以外的其他文件 os.listdir(path) 与os.walk有点类似，返回的类型为列表，返回的内容为该路径下所有文件的名字 np.squeeze() 移除长度为1的轴。压缩维度
python字符串相关命令合集
Yangyang
06-02 977
字符串定义：变量 = “值”学习中记录了相关字符串操作命令，以下命令可以直接运行查看结果。name = "abcdefABCDEF" print(name[5]) print(name[len(name)-1]) print(name[-1]) print(name[2:]) #从开始到结束 print(name[2:-1:2]) #跳一个取一个值 print(name[-1::-1]) ...
python 初级指令
11-30
Python初级指令是指最基础的Python编程指令，用于实现简单的程序功能。下面是几个常用的Python初级指令： 1. 输出指令：使用print()函数可以将数据输出到屏幕上。例如，print("Hello World!")会在屏幕上输出"Hello ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值