python进阶

属性

在一个对象中，属性是用来表示对象的重要指标，方法是一系列的功能。如下表格（引自3wschool）

对象 属性 方法
car.name=porsche
car.model = 911
car.length=4499mm
car.color = white		 car.start()
car.drive()
car.brake()
car.stop()

__dict__

该属性字典形式存放了类里所有self.*类型的东西

1
2
3
4
5
6
7
8
9
10
11
12
13
class man():
    cls="man"
    def __init__(self,name,age):
        self.name=name
        self.age=age

jerry=man("jerry",2)
print(shit.__dict__)
print(man.__dict__)

>>>输出内容
{'name': 'jerry', 'age': 2}
{'__module__': '__main__', 'cls': 'man', '__init__': <function man.__init__ at 0x000001927FFBC268>, '__dict__': <attribute '__dict__' of 'man' objects>, '__weakref__': <attribute '__weakref__' of 'man' objects>, '__doc__': None}

  1. 第一个是只返回了已经创建的对象的属性，cls这个全局属性没有被返回

  2. 第二个是返回一个类的所有属性

方法

__getattribute__

这个方法是访问对象属性后进行拦截，每次访问后都会执行该方法里的内容

  • 需要注意访问对象属性会让该方法陷入死循环，所以方法返回值要禁用self
  • 例如以下一个错误用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class man():
    cls="man"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __getattribute__(self,attr):
        print("访问了一个属性",end="")
        return self.name

jerry=man("jerry",2)
print(jerry.name)

>>>返回值
无穷多个 访问了一个属性
  • 使用super().__getattribute__(attr)返回访问到的属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class man():
    cls="man"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __getattribute__(self,attr):
        print("访问了一个属性",end="")
        return super().__getattribute__(attr)

jerry=man("jerry",2)
print(jerry.name)

>>>返回值
访问了一个属性jerry

__getattr__

方法的作用是当__getattribute__抛出异常时执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class man():
    cls="man"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __getattribute__(self,attr):
        print("访问了一个属性",end="")
        if attr != attr:#如果属性中没有调用的属性
            raise AttributeError()#抛出异常也可以不用这两句
        return super().__getattribute__(attr)
    def __getattr__(self,attr):
        print(attr+"不存在")

jerry=man("jerry",2)
print(jerry.name)
print(jerry.ae)

>>>返回值
访问了一个属性jerry
访问了一个属性ae不存在
None

返回值的None是来自print的输出

只要__getattribute__抛出异常则该方法就有效

__setattr__

试图给属性赋值时自动调用该方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class man():
    cls="man"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __setattr__(self,attr,velue):
        print(attr+"被赋值为："+str(velue))
        self.__dict__[attr]=velue #必加的内容，并且会引发__getattribute__

jerry=man("jerry",2)
print(jerry.name)

>>>返回值
name被赋值为：jerry
age被赋值为：2
jerry

如果不加self.__dict__[attr]=velue则属性将无法被赋值

不能使用self.attr=velue,会造成无限循环

raise

当程序出错python会自动抛出异常，也可以通过raise人为地引发异常，raise后面的语句将不能执行

字符串

format格式化

1
print("{0:.4f}{1:>10.2%}".format(10/3,20))

保留4位小数，>是右对齐10.2%表示输出宽度是10保留2位百分比小数

1
print("{0:.}{0:#x}{0:#o}".format(1111))

在千分位插入.，格式化成十六进制，格式化成八进制

统计

1
2
3
text.rindex(*) #最后一个出现位置
text.index(*) #第一个出现位置
text.count(*) #出现次数
1
text.replace(*,*) #替换
1
2
table="".maketrans('123','一二三') #制作替换表
print('123'.translate(table)) #使用替换表
1
2
3
text.ljust(10) #居左长度10
text.rjust(10,'#') #居右长度10填充式#
text.center(20) #居中

常见方法

获得列表最后一个

1
2
3
4
5
6
7
a = [1,2,3]
print(a[-1])
print(a[len(a)-1])

>>>
3
3

split

分隔字符串rsplit从右往左

1
2
3
4
5
a = "123"
print(a.split("2"))

>>>
['1', '3']

以2作为分隔标注

strip

去掉首尾特定字符串

1
2
3
4
5
a = "11231"
print(a.strip("1"))

>>>
23

restrip

去掉尾部特定字符串

1
2
3
4
5
a = "112311"
print(a.rstrip("1"))

>>>
1123

isdigit

判断字串是否为纯数字

1
2
3
4
5
a = "112311"
print(a.isdigit())

>>>
True

find

字符串查找,返回的是索引，没有返回-1

1
2
3
4
5
6
7
a = "112311"
print(a.find("2"))
print(a.find("4"))

>>>
2
-1

join

将符号加在每一个字符串后面

1
2
3
4
5
a = "123"
print(",".join(a))

>>>
1,2,3

lower

转换为小写

1
2
3
4
5
a = "ABC"
print(a.lower())

>>>
abc

upper

capitalize

title

swapcase

lambda

lambda函数是匿名函数，在单行下编写（不能多行）

lambda agument:expression

传入参数，返回的是表达式计算的结果。

1
2
3
4
5
sum=lambda y,x:x+y
print(sum(1,1))

>>>返回值
2

下面返回多个值

1
2
3
4
5
sum=lambda y,x:(x+y,x*y)
print(sum(1,1)) #可以使用列表形式单独取出

>>>
(2, 1)

lambda函数通常和其他函数并用。

生成列表

1
2
3
4
5
l = [i*2 for i in range(5)]
print(l)

>>>
[0, 2, 4, 6, 8]

​ 生成列表的作用是取一个循环i作为参数，对参数进行表达式运算再生成一个列表

单行分支

1
2
3
4
5
l = [i if i%2==0 else None for i in range(5)]
print(l)

>>>
[0, None, 2, None, 4]

处理1 if 条件 else 处理2：如果满足条件进行处理1，否则进行处理2

Json数据

json是一种通用数据，众多语言中都有，长得字典，但是他是字符串

loads&load方法

想要使用json数据就要先转换为字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import json
js_d="""{
        "error_code": 0,
        "stu_info": [
                {
                        "name": "Blosslom",
                        "sex": "男",
                        "age": 20,
                },
                {
                        "name": "Blosslom",
                        "sex": "男",
                        "age": 20,
                }
        ]
}"""
dic = json.loads(js_d)
print(type(dic))


>>>
<class 'dict'>

打印出来的时字典格式了

load是针对文件进行格式转化的

dumps&dump

将字典转化为json

1
2
3
4
5
6
7
import json
dic = {"name":"Blosslom","age":20}
js_d = json.dumps(dic)
print(type(js_d))

>>>
<class 'str'>

同理dump是转化文件的，带s都和字符串有关

高阶函数

1
2
3
4
5
6
7
8
def funa(n,fun): 
    return fun(n)*3 #返回fun(n),是前面传入的funb参数，移步到funb，得到的返回值*3 移步到输出
def funb(n):
    return n*10 #返回上步传入的n*10，移步到funa
print(funa(9,funb)) #调用funa传入参9，funb 移步到funa，输出270

>>>
270

高阶函数使用非常绕，遇到复杂的问题需要分析很久，尽量避免。

map

对列表每一个数执行函数的运算，map返回的是iterators而不是list，需要转成list能直接输出

1
2
3
4
5
6
7
8
9
l1=[1,2,3]
l2=map(lambda x:x*2,l1)
for i in l2:
    print(i)
   
>>>
2
4
6

下面转化为list

1
2
3
4
5
6
l1=[1,2,3]
l2=list(map(lambda x,y:(x,y),l1,l1))
print(l2)

>>>
[(1, 1), (2, 2), (3, 3)]

zip

合并列表

1
2
3
4
5
6
l1=[1,2,3]
l2=list(zip(l1,l1))
print(l2)

>>>
[(1, 1), (2, 2), (3, 3)]

可以不用list转化，直接用for循环

filter

根据函数进行过滤

1
2
3
4
5
6
l1=[1,2,3]
l2=list(filter(lambda x:x%2==0,l1))
print(l2)

>>>
[2]

对列表进行了过滤，只返回了偶数

reduce

需要from functools import reduce

对列表进行累加

1
2
3
4
5
6
7
from functools import reduce
l1=[1,2,3]
l2=reduce(lambda x,y:x+y,l1)
print(l2)

>>>
6

enumerate

添加标注

1
2
3
4
5
6
l1=[1,2,3]
l2=list(enumerate(l1,start=0))
print(l2)

>>>
[(0, 1), (1, 2), (2, 3)]

代表从0开始进行标注。

偏函数

偏函数就是函数的辅助，将一个函数生成一个新函数。

1
2
3
4
5
6
7
8
9
10
a = int("0x67",base=16) #将16进制转成10进制
print(a)

from functools import partial #导入方法
new_int = partial(int,base=16) #生成一个新函数
print(new_int("0x67"))

>>>
103
103

在生成新函数的同时，函数的最后一个参数被赋值，在新参数里只需要对前面的参数赋值即可

1
2
3
4
5
6
7
8
from functools import partial
def fun(a,b,c,d):
    print(a,b,c,d)
new_fun = partial(fun,b=2,c=3)
new_fun(1,d=4)

>>>
1 2 3 4

上面的输出结果可以看出，偏函数可以给任意参数赋值生成新函数。但是偏函数的第一个参数一定是那个函数名

闭包

在一个函数中有一个子函数，retrun 子函数名 在外面接收的子函数名可以当一个函数使用

1
2
3
4
5
6
7
8
9
10
def test(num):
      def test_in(num1):
            print(num+num1)
      return test_in

a = test(10)
a(11)

>>>
21

函数嵌套，返回处理值

1
2
3
4
5
6
7
8
9
10
11
def fun_1():
    def fun_2(i):
        def fun_3():
            return i*2 #可以访问到上个函数的参数，返回运算
        return fun_3() #返回自己里面函数的运算结果
    print(fun_2(2))

fun_1()

>>>
4

也可以循环嵌套函数

1
2
3
4
5
6
7
8
9
10
11
12
13
def fun_1():
    for i in range(4): #循环
        def fun_2(i):
            return i*2
        print(fun_2(i))

fun_1()

>>>
0
2
4
6

装饰器

  • 作用：在执行一个函数之前先进行装饰处理

  • 原理：装饰函数将函数作为参数传入了，只是将他在外面套了一层

    1
    2
    3
    4
    5
    @函数名
    def 另一个函数名
    原理同下：

    另一个函数名 = 函数名(另一个函数名)
    1
    2
    3
    4
    5
    def dec(fun):
        def dec_in():
            print("this is dec")
            fun()
        return dec_in

    参数fun是要被装饰的函数，在装饰函数需要第二层进行返回，返回的函数不能带括号。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    def fun_a(a):
        print("装饰器")
        def fun_c():
            a()
        return fun_c

    @fun_a  #等同于 func_b=fun_a(func_b)
    def fun_b():
        print("1")

    fun_b()  #其实是fun_a(func_b)()

    >>>
    装饰器
    1

    还有一种写法，可以简单理解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    def fun_a(a):
        print("装饰器")
        return a

    @fun_a  #等同于 func_b=fun_a(func_b)
    def fun_b():
        print("1")

    fun_b()   #其实是fun_a(func_b)()

    >>>
    装饰器
    1

    里面的a就是fun_b

多装饰器

1
2
3
@函数1
@函数2
def 函数3

装饰器只能装饰函数，所以2先装饰函数3

被装饰函数带参装饰器

带参装饰器返回值装饰器==>通用装饰器

1
2
3
4
def dec(func):
    def dec_in(*args,**kwargs): #被传入的函数带的参数
        func(*args,**kwargs)
    return dec_in

这里的带参数是指的函数带参数，上面有个直接返回的例子，里面没有嵌套函数无法使用带参数的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def fun_a(fun_a):
    print("装饰器")
    def fun_c(b): #可以换成*或**接收多个参数
        fun_a(b)  #同理要加
    return fun_c

@fun_a
def fun_b(b): #多个值可以使用拆包或正常传入方式
    print(b)

fun_b("1")

>>>
装饰器
1

看起来还是挺易懂的。

装饰器带参

在外面多定义一层专门用来用来处理装饰器的参数，比较麻烦

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def fun_a(*d): #*d是收到的装饰器的参数
    print(d[0])
    def fun_c(fun_b): #这一层起到的是装饰作用
        def fun_d(*b): #*b是fun_b传入的参数
            fun_b(*b)
        return fun_d
    return fun_c

@fun_a("装饰器")
def fun_b(b,c,d="4"):
    print(b,c,d)

fun_b("1","2")

>>>
装饰器
1 2 4

字符串对比

set()

set函数可以将字符串转化成set形式，可以使用遍历的形式进行单个输出，并且它会对列表里重复的进行去重

1
2
3
4
5
a = "123"
print(set(a))

>>>
{'3', '2', '1'}

&交集

求出两个都有的

1
2
3
4
5
6
a = "123"
b = "234"
print(set(a)&set(b))

>>>
{'3', '2'}

|并集

求出两个的和

1
2
3
4
5
6
a = "123"
b = "234"
print(set(a)|set(b))

>>>
{'4', '3', '2', '1'}

-差集

前面一个减去后面的，后面的一个都不留，只留下前面没重复的

1
2
3
4
5
6
a = "123"
b = "234"
print(set(a)-set(b))

>>>
{'1'}

^对称差集

前面一个减去后面的,留下前后没有重复的

1
2
3
4
5
6
a = "123"
b = "234"
print(set(a)^set(b))

>>>
{'4', '1'}

排序

sort方法的另一种方式，key=abs设置绝对值，reverse=True倒排

1
2
3
4
5
6
a = "123"
b = set(a)
print(sorted(b,reverse=True))

>>>
['3', '2', '1'] #可以发现set变成了列表

collections

collections是python内建的一个模块,主要和数据类型有关

namedtuple

定义一个可以通过属性来访问的tuple数据结构

1
2
3
4
5
6
7
from collections import namedtuple as nt #导入模块
tp = nt("tp",["a","b"]) #定义一个固定的数据结构
t = tp(1,2)
print(t.a,t.b)

>>>
1 2

tp = nt(“tp”,[“a”,“b”])第一个tp是一个句柄，用来后面赋值所用，第二个tp是结构标志，当使用print(t)时可以看到tp(a=‘1’, b=‘2’)

OrderedDict

有序字典，普通字典是无序的，ordereddict作用是记住key里面值的添加顺序。从下面代码我们可以看到遍历输出的是key

1
2
3
4
5
6
7
8
dic = {"a":1,"b":2,"c":3}
for i in dic:
    print(i)
dic["a"]=2 #更改字典    
>>>
a
b
c

实例展示：

无，python3中已将没有这个症状了

Counter

统计次数生成一个字典形式

1
2
3
4
5
6
7
8
9
10
11
from collections import Counter as ct
st = "123123123"
li = ["a",1,"b","a",1,"b","a",1,"b"]
st = ct(st)
li = ct(li)
print(st)
print(li)

>>>
Counter({'1': 3, '2': 3, '3': 3})
Counter({'a': 3, 1: 3, 'b': 3})

可以看到吧字符作为key，次数是key值

depue

队列和栈，实现双向增删

1
2
3
4
5
6
7
8
9
10
from collections import deque as dq
li = [1,2,3]
li = dq(li)
li.popleft() #删除左面的
li.appendleft(0) #在左面添加
li.append(4)
print(li)

>>>
deque([0, 2, 3, 4])

序列化和反序列化

Pickle

python中一切皆对象，对象就是一小块内存的数据，而将这些数据写入硬盘或传输需要进行序列化或反序列化

广泛的应用在分布式、并行系统上。

序列化：将对象转化成“串行化”数据形式，存储到硬盘或通过网络传输到其他地方。pickle.dump(obj,f)，obj是要被序列化的对象，f是要保存到的文件

1
2
3
4
5
6
7
import pickle
with open(r"data.dat","wb") as f:
    a = "123"
    a = pickle.dump(a,f) #序列化后保存到文件
    
>>>打开文件
€X   123q .

反序列化：是指相反的过程，将读取到的“串行化数据”转化成对象。Python中使用 pickle 模块中的函数，实现序列化和反序列操作。pickle.load(f)，f是一个被序列化的一个文件

1
2
3
4
5
6
7
import pickle
with open(r"data.dat","rb") as f: #这个文件是被序列化的
    a = pickle.load(f) #反序列化
    print(a)
    
>>>
123

shelve

相当于一个小型的数据库，它可以保存python所支持的数据类型（以字典形式）

1
2
3
4
5
6
7
8
9
import shelve
with shelve.open(r"date") as sl:
    a = ["1","2","3"]
    dic = {"a":1,"2":"b"}
    sl["a"]=a
    sl["dic"]=dic
    
>>>
生成三个文件

查看文件的方法

1
2
3
4
5
6
7
8
9
10
import shelve
with shelve.open(r"date") as sl:
    print(list(sl.keys())) #列出所有的key名
    print(list(sl.values())) #列出所用的key值
    print(sl["a"],sl["dic"]) #列出指定的

>>>
['a', 'dic']
[['1', '2', '3'], {'a': 1, '2': 'b'}]
['1', '2', '3'] {'a': 1, '2': 'b'}

深拷贝

模块重导入

需要使用imp模块，应用场景是：如果模块在执行中会被改变，那么需要重新导入这模块才能改变作用。

1
2
3
import sys
from imp import * # 模块重导入
reload(sys)

深拷贝

平时使用的拷贝都是浅拷贝：仅仅在地址上打一个新标签，当原地址的东西改变后拷贝的也跟着改变，深拷贝：单独使用一个空间拷贝进去，不随原地址改变而改变

对于不可变类型（数值，字符串，元组）：

深拷贝，浅拷贝，等号赋值的所有的id结果都一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import copy
a = (111,111,'asdf')
b = a
c = copy.copy(a) #只拷贝父对象，不会拷贝对象的内部的子对象。
d = copy.deepcopy(a) #拷贝父对象以及拷贝对象的内部的子对象。
print(id(a))
print(id(b))
print(id(c))
print(id(d))

>>>
2555731777360
2555731777360
2555731777360
2555731777360

对于可变类型（列表和字典）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import copy
a = [111,111,'asdf']
b = a
c = copy.copy(a) #只拷贝父对象，不会拷贝对象的内部的子对象。
d = copy.deepcopy(a) #拷贝父对象以及拷贝对象的内部的子对象。
print(id(a))
print(id(b))
print(id(c))
print(id(d))

>>>
2237365186312
2237365186312
2237365186440
2237365190920

我们可以看到c和d的id已经被改变，下面看一些原地址内容改变的情况。

简单的单层对象改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import copy
a = [111,111,'asdf']
b = a
c = copy.copy(a) #只拷贝父对象，不会拷贝对象的内部的子对象。
d = copy.deepcopy(a) #拷贝父对象以及拷贝对象的内部的子对象。
a.append(1)
print(a)
print(b)
print(c)
print(d)

>>>
[111, 111, 'asdf', 1]
[111, 111, 'asdf', 1]
[111, 111, 'asdf']
[111, 111, 'asdf']

多层对象改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import copy
a = [111,111,'asdf',[1,2]]
b = a
c = copy.copy(a) #浅拷贝：只拷贝父对象，不会拷贝对象的内部的子对象。
d = copy.deepcopy(a) #深拷贝：拷贝父对象以及拷贝对象的内部的子对象。
a[3].append(3)
print(a)
print(b)
print(c)
print(d)

>>>
[111, 111, 'asdf', [1, 2, 3]]
[111, 111, 'asdf', [1, 2, 3]]
[111, 111, 'asdf', [1, 2, 3]]
[111, 111, 'asdf', [1, 2]]

对比发现，浅拷贝只能拷贝一层，深拷贝多层

迭代器&生成器

迭代器：一个可以按顺序访问的对象，只能往前访问无法往后访问（list不是可迭代对象）

1
2
3
4
5
6
7
8
9
10
11
a = (i for i in range(10)) #生成一个可迭代对象，他不是元组类型
print(a)
print(next(a)) #访问第一个
print(next(a)) #访问下一个
print(a.__next__()) #后面一个

>>>
<generator object <genexpr> at 0x0000013DD7778480>
0
1
2

可以看到可迭代对象是单独生成的，它是边生成边调用，不像list浪费内存。可以使用for

使用**iter()**可以创建迭代对象

生成器：从本质上讲生成器就是一个迭代器，每次遇到yield函数都会保存信息返回yield的值，下一次继续从这个位置开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def gen():
    get = yield 0
    print(get) #输出a
    get = yield 1 #
    print(get) #输出b
try:
    g=gen() #创建一个对象
    print(g.__next__()) #输出0
    print(g.send("a")) #输出1
    print(g.send("b")) #输出错误
except:
    pass
    
>>>
0
a
1
b

这必有一个报错，报错类型是StopIteration，迭代终止，所以使用错误处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def gen():
    i=0
    while True:
        get = yield i
        print(get)
        i+=1


g = gen()
print(next(g))
for i in range(2):
    print(g.send(i))

>>>
0
0
1
1
2

创建完对象后，首先需要进行next处理(必须进行这一步)，后面才能对值进行传输，最后一个2是print(g.send(i))打印的。

shell命令

check_output

可以在windows或者linux中执行系统命令，方式都是一样的命令不同

1
2
3
4
5
6
import subprocess
net = subprocess.check_output('netstat',shell=True)
print(net)

>>>
b'\r\n\xbb\xee\xb6\xaf\xc1\xac\xbd\xd3\r\n\r\n  \xd0\xad\xd2\xe9  \xb1\xbe\xb5\xd8\xb5\xd8\xd6\xb7          \xcd\xe2\xb2\xbf\xb5\xd8\xd6\xb7        \xd7\xb4\xcc\xac\r\n  TCP    127.0.0.1:5354         IIMOC0WEW2QSP65:49676  ESTABLISHED\r\n  TCP    127.0.0.1:5354         IIMOC0WEW2QSP65:49679  ESTABLISHED\r\n  TCP    127.0.0.1:49676        IIMOC0WEW2QSP65:5354   ESTABLISHED\r\n  TCP    127.0.0.1:49679        IIMOC0WEW2QSP65:5354   ESTABLISHED\r\n  TCP    127.0.0.1:50986        IIMOC0WEW2QSP65:50990  ESTABLISHED\r\n  TCP    127.0.0.1:50990        IIMOC0WEW2QSP65:50986  ESTABLISHED\r\n'

输出的是二进制，想要能看懂必须进行编码。

getoutput

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import subprocess
net = subprocess.getoutput('netstat',shell=True)
print(net)

>>>
活动连接

  协议  本地地址          外部地址        状态
  TCP    127.0.0.1:5354         IIMOC0WEW2QSP65:49676  ESTABLISHED
  TCP    127.0.0.1:5354         IIMOC0WEW2QSP65:49679  ESTABLISHED
  TCP    127.0.0.1:49676        IIMOC0WEW2QSP65:5354   ESTABLISHED
  TCP    127.0.0.1:49679        IIMOC0WEW2QSP65:5354   ESTABLISHED
  TCP    127.0.0.1:50986        IIMOC0WEW2QSP65:51703  ESTABLISHED
  TCP    127.0.0.1:51703        IIMOC0WEW2QSP65:50986  ESTABLISHED
  TCP    192.168.0.103:51299    server-13-224-166-53:https  ESTABLISHED
  TCP    192.168.0.103:51329    52.139.250.253:https   ESTABLISHED
  TCP    192.168.0.103:51349    104.31.72.241:https    ESTABLISHED
  TCP    192.168.0.103:51356    172.67.71.181:https    ESTABLISHED
  TCP    192.168.0.103:51392    104.26.13.56:https     ESTABLISHED
  TCP    192.168.0.103:51693    server-13-225-103-113:https  TIME_WAIT
  TCP    192.168.0.103:51694    server-13-225-103-103:https  TIME_WAIT
  TCP    192.168.0.103:51695    server-13-225-103-103:https  TIME_WAIT

getstatusoutput

返回元组，可以调用结果

1
2
3
4
5
6
import subprocess
net = subprocess.getoutput('netstat',shell=True)
print(net)

>>>
(0, '\n活动连接\n\n  协议  本地地址          外部地址        状态\n  TCP    127.0.0.1:5354         IIMOC0WEW2QSP65:49676  ESTABLISHED\n  TCP    127.0.0.1:5354         IIMOC0WEW2QSP65:49679  ESTABLISHED\n  TCP    127.0.0.1:49676        IIMOC0WEW2QSP65:5354   ESTABLISHED\n  TCP    127.0.0.1:49679        IIMOC0WEW2QSP65:5354   ESTABLISHED\n  TCP    127.0.0.1:50986        IIMOC0WEW2QSP65:51758  ESTABLISHED\n  TCP    127.0.0.1:51758        IIMOC0WEW2QSP65:50986  ESTABLISHED\n  TCP    192.168.0.103:51299    server-13-224-166-53:https  ESTABLISHED\n  TCP    192.168.0.103:51329    52.139.250.253:https   ESTABLISHED\n  TCP    192.168.0.103:51349    104.31.72.241:https    ESTABLISHED\n  TCP    192.168.0.103:51356    172.67.71.181:https    ESTABLISHED\n  TCP    192.168.0.103:51392    104.26.13.56:https     ESTABLISHED\n  TCP    192.168.0.103:51750    40.81.30.101:https     ESTABLISHED\n  TCP    192.168.0.103:51751    a104-74-21-118:https   ESTABLISHED\n  TCP    192.168.0.103:51754    server-13-224-166-27:https  ESTABLISHED\n  TCP    192.168.0.103:51755    server-13-224-166-40:https  ESTABLISHED\n  TCP    192.168.0.103:51756    server-13-224-166-40:https  ESTABLISHED\n  TCP    192.168.0.103:51757    server-13-224-166-40:https  ESTABLISHED')

多线程

threading

多线程需要导入threading模块，可以同时对一个函数进行多次执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
import threading
def a():
    global n #共享全局变量，不然后面的n无法改变
    n+=1
    print(n)
n=0
for i in range(10):
    i = threading.Thread(target=a) #目标函数是a
    i.start() #线程开始
    
>>>
134256789
10

上面的输出每次都不一样，因为线程结束不一样。

1
2
3
4
5
6
7
8
9
import threading
def a(n):
    print(n)
for i in range(10):
    i = threading.Thread(target=a,args=(i,)) #参数，而且后面的点必须要
    i.start()

>>>
1023456789

上面试带参数多线程调用

资源竞争及解决方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
"""再用到多线程时，往往会出现资源竞争的情况"""
import threading
import time
def test1(temp):
    global num
    for i in range(temp):
        num+=1
    print(num)

def test2(temp):
    global num
    for i in range(temp):
        num+=1
    print(num)

num=0
def main():
    # target是指定的函数，args表示压传入的参数。
    t1=threading.Thread(target=test1, args=(100000,))
    t2=threading.Thread(target=test2, args=(100000,))
    t1.start()
    t2.start()
if __name__ == "__main__":
    main()
    
>>>
100000179523

按照常理来说应该输出100000，和200000的但是到后面就乱了，这是由于俩个对全局变量的竞争导致的。

使用互斥锁解决

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import threading
import time
def test1(temp):
    lock.acquire() #上锁
    global num
    for i in range(temp):
        num+=1
    lock.release() #解锁
    print(num)

def test2(temp):
    lock.acquire() #上锁
    global num
    for i in range(temp):
        num+=1
    lock.release() #解锁
    print(num)

lock = threading.Lock() #必须是在全局创建一把锁
num=0
def main():
    t1=threading.Thread(target=test1, args=(100000,))
    t2=threading.Thread(target=test2, args=(100000,))
    t1.start()
    t2.start()
if __name__ == "__main__":
    main()
    
>>>
100000200000

互斥锁的原理是，上锁后全局变量只提供这个函数使用，在多次循环中不至于两个函数互挣。

多进程

multiprocessing

使用方法和多线程同理，不过他是创建多个应用程序运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import multiprocessing

def nult1(arg):
    while True:
        print(arg)

def mult2():
    while True:
        print("2")

def main():
    t1=multiprocessing.Process(target=nult1,args=("1",)) #传入参数
    t2=multiprocessing.Process(target=mult2)
    t1.start()
    t2.start()

>>>
这个运行会创建两个运行程序

Queue队列

这个队列是用来共享数据的，同样是multiprocessing模块，队列就是先进先出

1
2
3
4
5
6
7
8
9
10
import multiprocessing
q = multiprocessing.Queue()
for i in range(10):
    q.put(i) #存入数据
print(q.get()) #拿出数据
print(q.get()) #拿出数据

>>>
0
1

进程池

进程池可以对进程进行批量创建，并且统一管理。用到mutiprocessing的Pool

1
2
3
4
5
6
7
8
9
from multiprocessing import Pool
def work(i):
    print(i)

po = Pool(2) #创建容量为2的进程池
for i in range(10):
    po.apply_async(work,(1)) #把内容放入进程池，1为传入的参数
po.close() #结束进程池
po.join() #等待所有进程结束

进程池有容量设定，如果设定2个，不管多少个任务同时开的进程只有两个，一个任务完成再让下一个任务进入池中。

-5~256定理

-5到256包括-5和256。这个区域被称为小整数池，他是原本就存在内存中的，使用id查看都是一样的。当使用交互式的时候这个区域的数字都是一个地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> b=-5
>>> a=-5
>>> a is b
True
>>> a=-6
>>> b=-6
>>> a is b
False
>>> a=256
>>> b=256
>>> a is b
True
>>> b=257
>>> a=247
>>> a is b
False

有时候会遇到这种，也不要感觉惊讶，因为这是一个定理。

进制转换

二进制

1
2
3
print(bin(10)) #将十进制转成二进制
>>>
0b1010

0b是二进制的标志

1
2
3
print(int(0b1010)) #将二进制转成十进制
>>>
10

八进制

1
2
3
print(oct(10)) #将十进制转成八进制
>>>
0o12

0o是八进制的标志

1
2
3
print(int(0o12)) #将八进制转成十进制
>>>
10

十六进制

1
2
3
print(hex(10)) #将十进制转成十六进制
>>>
0xa

0x是十六进制标志

1
2
3
print(int(0xa)) #将十六进制转成十进制
>>>
10

字符串

使用chr可以将二到十六进制转成字符串

1
2
3
4
5
6
7
8
print(chr(0b1))
print(chr(0o1))
print(chr(0x1))

>>>




但是每个都有上限

二进制表示上限：0b100010000000000000000

八进制表示上限：0o4200000

十六进制表示上限：0x110000

将字符串转为十进制ASCII码

1
2
3
4
print(ord(""))

>>>
1

一次只能够转化一个字符串，之后还可将十进制转成其他进制

其他转换

网页的十六进制编码\xc9\xc1\xd2\xd5\xbb\xa5\xb6\xaf 是这种形式的

1
2
3
4
5
str = "\xc9\xc1\xd2\xd5\xbb\xa5\xb6\xaf"
print(str)

>>>
ÉÁÒÕ»¥¶¯

可以直接使用输出

正则表达式

这则表达式是一种匹配一类型语句的表达式，可以进行查找修改替换。原子是是表达式的基本组成单位

普通字符作为原子

1
2
3
4
5
6
7
8
import re
str = "this is a centence"
exp = "is" #普通字符作为原子
get = re.compile(exp).findall(str)
print(get)

>>>
['is', 'is']

通用字符作为原子

1
2
3
4
5
6
7
8
import re
str = "this is a centence"
exp = "\w" #通用字符作为原子
get = re.compile(exp).findall(str)
print(get)

>>>
['t', 'h', 'i', 's', 'i', 's', 'a', 'c', 'e', 'n', 't', 'e', 'n', 'c', 'e']
\w 字母，数字，下划线
\W 非字母，数字，下划线
\d 十进制数字
\D 非十进制数字
\s 空白字符
\S 非空白字符

非打印字符作为原子

1
2
3
4
5
6
7
8
9
10
import re
str = """this is a centence
do you understand this mean
it is so easy"""
exp = "\n" #非打印字符作为原子
get = re.compile(exp).findall(str)
print(get)

>>>
['\n', '\n']
\n 换行符
\t 制表符

原子表

. 除换行为任意一个字符
^ 开始位置
$ 结束位置
* 任意次
+ 1次或多次
？ 0或1次
{n} n次
{n,m} n-m次
| 或
() 模式单元 
1
2
3
4
5
6
7
8
9
10
import re
str = """this is a centence
do you understand this mean
it is so easy"""
exp = "^th." #对开头查找 exp = "(.*)$"对结尾查找
get = re.compile(exp).findall(str)
print(get)

>>>
['thi']

模式修正符

I 匹配时忽略大小写
M 多行匹配
L 本地化识别匹配
U unicode
S 匹配包括换行符* 
1
2
3
4
5
6
7
8
9
10
import re
str = """this Is a centence
do you understand this mean
it is so easy"""
exp = "i"
get = re.compile(exp,re.I).findall(str) #添加的模式修正符
print(get)

>>>
['i', 'I', 'i', 'i', 'i']

贪婪模式

尽可能多跨度的进行匹配特定内容

1
2
3
4
5
6
7
8
import re
str = "楼外青山楼外楼"
exp = "楼.*楼" #跨度尽可能多
get = re.compile(exp).findall(str)
print(get)

>>>
['楼外青山楼外楼']

懒惰模式

尽可能少跨度的进行匹配特定内容

1
2
3
4
5
6
7
8
import re
str = "楼外青山楼外楼"
exp = "楼.*?楼" #跨度尽可能少
get = re.compile(exp).findall(str)
print(get)

>>>
['楼外青山楼']

sys

argv

实现外部向程序传入参数，其中第一个参数为文件本身。

1
2
3
4
5
import sys
print(sys.argv)

>>>1.py 第一个参数 第二个参数
['F:\\桌面\\1.py', '第一个参数', '第二个参数']

输出的形式是list，可以使用for循环进行遍历。

exit

退出程序0表示正常退出，可以定义退出提示

1
2
3
4
5
6
7
8
import sys
try:
    sys.exit("执行错误")
except SystemExit as valueas:
    print(values)
    
>>>
执行错误

提示抛出到values，打印values。

platform

打印当前运行的平台（win32，Linux）

1
2
3
4
5
import sys
print(sys.platform)

>>>
win32

modules

返回程序导入的所有模块

1
2
3
4
5
6
7
8
9
import sys
print(sys.modules["random"]) #打印该模块的路径
print(sys.modules.keys()) #打印所有导入的模块名
print(sys.modules.values()) #打印所有导入模块名和路径

>>>
<module 'random' from 'F:\\python-3.7.0\\lib\\random.py'>
dict_keys(['sys', 'builtins', '_frozen_importlib', '_imp', '_thread', '_warnings', '_weakref', 'zipimport', '_frozen_importlib_external', '_io', 'marshal', 'nt', 'winreg', 'encodings', 'codecs', '_codecs', 'encodings.aliases', 'encodings.utf_8', '_signal', '__main__', 'encodings.latin_1', 'io', 'abc', '_abc', 'site', 'os', 'stat', '_stat', 'ntpath', 'genericpath', 'os.path', '_collections_abc', '_sitebuiltins', '_bootlocale', '_locale', 'encodings.gbk', '_codecs_cn', '_multibytecodec', 'types', 'importlib', 'importlib._bootstrap', 'importlib._bootstrap_external', 'warnings', 'importlib.util', 'importlib.abc', 'importlib.machinery', 'contextlib', 'collections', 'operator', '_operator', 'keyword', 'heapq', '_heapq', 'itertools', 'reprlib', '_collections', 'functools', '_functools', 'mpl_toolkits', 'idlelib', 'idlelib.run', 'linecache', 'tokenize', 're', 'enum', 'sre_compile', '_sre', 'sre_parse', 'sre_constants', 'copyreg', 'token', 'queue', 'threading', 'time', 'traceback', '_weakrefset', '_queue', 'tkinter', '_tkinter', 'tkinter.constants', 'idlelib.autocomplete', 'string', '_string', 'idlelib.autocomplete_w', 'platform', 'subprocess', 'signal', 'errno', 'msvcrt', '_winapi', 'idlelib.multicall', 'idlelib.config', 'configparser', 'collections.abc', 'idlelib.hyperparser', 'idlelib.pyparse', 'idlelib.calltips', 'inspect', 'dis', 'opcode', '_opcode', 'textwrap', 'idlelib.calltip_w', 'idlelib.debugger_r', 'idlelib.debugger', 'bdb', 'fnmatch', 'posixpath', 'idlelib.macosx', 'idlelib.scrolledlist', 'idlelib.windows', 'idlelib.debugobj_r', 'idlelib.rpc', 'pickle', 'struct', '_struct', '_compat_pickle', '_pickle', 'select', 'socket', '_socket', 'selectors', 'math', 'socketserver', 'idlelib.iomenu', 'shlex', 'tempfile', 'shutil', 'zlib', 'bz2', '_compression', '_bz2', 'lzma', '_lzma', 'random', 'hashlib', '_hashlib', '_blake2', '_sha3', 'bisect', '_bisect', '_random', 'weakref', 'locale', 'idlelib.stackviewer', 'idlelib.debugobj', 'idlelib.tree', 'idlelib.zoomheight', 'pydoc', 'pkgutil', 'urllib', 'urllib.parse'])
dict_values([<module 'sys' (built-in)>, <module 'builtins' (built-in)>, <module 'importlib._bootstrap' (frozen)>, <module '_imp' (built-in)>, <module '_thread' (built-in)>, <module '_warnings' (built-in)>, <module '_weakref' (built-in)>, <module 'zipimport' (built-in)>, <module 'importlib._bootstrap_external' (frozen)>, <module 'io' (built-in)>, <module 'marshal' (built-in)>, <module 'nt' (built-in)>, <module 'winreg' (built-in)>, <module 'encodings' from 'F:\\python-3.7.0\\lib\\encodings\\__init__.py'>, <module 'codecs' from 'F:\\python-3.7.0\\lib\\codecs.py'>, <module '_codecs' (built-in)>, <module 'encodings.aliases' from 'F:\\python-3.7.0\\lib\\encodings\\aliases.py'>, <module 'encodings.utf_8' from 'F:\\python-3.7.0\\lib\\encodings\\utf_8.py'>, <module '_signal' (built-in)>, <module '__main__' (built-in)>, <module 'encodings.latin_1' from 'F:\\python-3.7.0\\lib\\encodings\\latin_1.py'>, <module 'io' from 'F:\\python-3.7.0\\lib\\io.py'>, <module 'abc' from 'F:\\python-3.7.0\\lib\\abc.py'>, <module '_abc' (built-in)>, <module 'site' from 'F:\\python-3.7.0\\lib\\site.py'>, <module 'os' from 'F:\\python-3.7.0\\lib\\os.py'>, <module 'stat' from 'F:\\python-3.7.0\\lib\\stat.py'>, <module '_stat' (built-in)>, <module 'ntpath' from 'F:\\python-3.7.0\\lib\\ntpath.py'>, <module 'genericpath' from 'F:\\python-3.7.0\\lib\\genericpath.py'>, <module 'ntpath' from 'F:\\python-3.7.0\\lib\\ntpath.py'>, <module '_collections_abc' from 'F:\\python-3.7.0\\lib\\_collections_abc.py'>, <module '_sitebuiltins' from 'F:\\python-3.7.0\\lib\\_sitebuiltins.py'>, <module '_bootlocale' from 'F:\\python-3.7.0\\lib\\_bootlocale.py'>, <module '_locale' (built-in)>, <module 'encodings.gbk' from 'F:\\python-3.7.0\\lib\\encodings\\gbk.py'>, <module '_codecs_cn' (built-in)>, <module '_multibytecodec' (built-in)>, <module 'types' from 'F:\\python-3.7.0\\lib\\types.py'>, <module 'importlib' from 'F:\\python-3.7.0\\lib\\importlib\\__init__.py'>, <module 'importlib._bootstrap' (frozen)>, <module 'importlib._bootstrap_external' (frozen)>, <module 'warnings' from 'F:\\python-3.7.0\\lib\\warnings.py'>, <module 'importlib.util' from 'F:\\python-3.7.0\\lib\\importlib\\util.py'>, <module 'importlib.abc' from 'F:\\python-3.7.0\\lib\\importlib\\abc.py'>, <module 'importlib.machinery' from 'F:\\python-3.7.0\\lib\\importlib\\machinery.py'>, <module 'contextlib' from 'F:\\python-3.7.0\\lib\\contextlib.py'>, <module 'collections' from 'F:\\python-3.7.0\\lib\\collections\\__init__.py'>, <module 'operator' from 'F:\\python-3.7.0\\lib\\operator.py'>, <module '_operator' (built-in)>, <module 'keyword' from 'F:\\python-3.7.0\\lib\\keyword.py'>, <module 'heapq' from 'F:\\python-3.7.0\\lib\\heapq.py'>, <module '_heapq' (built-in)>, <module 'itertools' (built-in)>, <module 'reprlib' from 'F:\\python-3.7.0\\lib\\reprlib.py'>, <module '_collections' (built-in)>, <module 'functools' from 'F:\\python-3.7.0\\lib\\functools.py'>, <module '_functools' (built-in)>, <module 'mpl_toolkits' (namespace)>, <module 'idlelib' from 'F:\\python-3.7.0\\lib\\idlelib\\__init__.py'>, <module 'idlelib.run' from 'F:\\python-3.7.0\\lib\\idlelib\\run.py'>, <module 'linecache' from 'F:\\python-3.7.0\\lib\\linecache.py'>, <module 'tokenize' from 'F:\\python-3.7.0\\lib\\tokenize.py'>, <module 're' from 'F:\\python-3.7.0\\lib\\re.py'>, <module 'enum' from 'F:\\python-3.7.0\\lib\\enum.py'>, <module 'sre_compile' from 'F:\\python-3.7.0\\lib\\sre_compile.py'>, <module '_sre' (built-in)>, <module 'sre_parse' from 'F:\\python-3.7.0\\lib\\sre_parse.py'>, <module 'sre_constants' from 'F:\\python-3.7.0\\lib\\sre_constants.py'>, <module 'copyreg' from 'F:\\python-3.7.0\\lib\\copyreg.py'>, <module 'token' from 'F:\\python-3.7.0\\lib\\token.py'>, <module 'queue' from 'F:\\python-3.7.0\\lib\\queue.py'>, <module 'threading' from 'F:\\python-3.7.0\\lib\\threading.py'>, <module 'time' (built-in)>, <module 'traceback' from 'F:\\python-3.7.0\\lib\\traceback.py'>, <module '_weakrefset' from 'F:\\python-3.7.0\\lib\\_weakrefset.py'>, <module '_queue' from 'F:\\python-3.7.0\\DLLs\\_queue.pyd'>, <module 'tkinter' from 'F:\\python-3.7.0\\lib\\tkinter\\__init__.py'>, <module '_tkinter' from 'F:\\python-3.7.0\\DLLs\\_tkinter.pyd'>, <module 'tkinter.constants' from 'F:\\python-3.7.0\\lib\\tkinter\\constants.py'>, <module 'idlelib.autocomplete' from 'F:\\python-3.7.0\\lib\\idlelib\\autocomplete.py'>, <module 'string' from 'F:\\python-3.7.0\\lib\\string.py'>, <module '_string' (built-in)>, <module 'idlelib.autocomplete_w' from 'F:\\python-3.7.0\\lib\\idlelib\\autocomplete_w.py'>, <module 'platform' from 'F:\\python-3.7.0\\lib\\platform.py'>, <module 'subprocess' from 'F:\\python-3.7.0\\lib\\subprocess.py'>, <module 'signal' from 'F:\\python-3.7.0\\lib\\signal.py'>, <module 'errno' (built-in)>, <module 'msvcrt' (built-in)>, <module '_winapi' (built-in)>, <module 'idlelib.multicall' from 'F:\\python-3.7.0\\lib\\idlelib\\multicall.py'>, <module 'idlelib.config' from 'F:\\python-3.7.0\\lib\\idlelib\\config.py'>, <module 'configparser' from 'F:\\python-3.7.0\\lib\\configparser.py'>, <module 'collections.abc' from 'F:\\python-3.7.0\\lib\\collections\\abc.py'>, <module 'idlelib.hyperparser' from 'F:\\python-3.7.0\\lib\\idlelib\\hyperparser.py'>, <module 'idlelib.pyparse' from 'F:\\python-3.7.0\\lib\\idlelib\\pyparse.py'>, <module 'idlelib.calltips' from 'F:\\python-3.7.0\\lib\\idlelib\\calltips.py'>, <module 'inspect' from 'F:\\python-3.7.0\\lib\\inspect.py'>, <module 'dis' from 'F:\\python-3.7.0\\lib\\dis.py'>, <module 'opcode' from 'F:\\python-3.7.0\\lib\\opcode.py'>, <module '_opcode' (built-in)>, <module 'textwrap' from 'F:\\python-3.7.0\\lib\\textwrap.py'>, <module 'idlelib.calltip_w' from 'F:\\python-3.7.0\\lib\\idlelib\\calltip_w.py'>, <module 'idlelib.debugger_r' from 'F:\\python-3.7.0\\lib\\idlelib\\debugger_r.py'>, <module 'idlelib.debugger' from 'F:\\python-3.7.0\\lib\\idlelib\\debugger.py'>, <module 'bdb' from 'F:\\python-3.7.0\\lib\\bdb.py'>, <module 'fnmatch' from 'F:\\python-3.7.0\\lib\\fnmatch.py'>, <module 'posixpath' from 'F:\\python-3.7.0\\lib\\posixpath.py'>, <module 'idlelib.macosx' from 'F:\\python-3.7.0\\lib\\idlelib\\macosx.py'>, <module 'idlelib.scrolledlist' from 'F:\\python-3.7.0\\lib\\idlelib\\scrolledlist.py'>, <module 'idlelib.windows' from 'F:\\python-3.7.0\\lib\\idlelib\\windows.py'>, <module 'idlelib.debugobj_r' from 'F:\\python-3.7.0\\lib\\idlelib\\debugobj_r.py'>, <module 'idlelib.rpc' from 'F:\\python-3.7.0\\lib\\idlelib\\rpc.py'>, <module 'pickle' from 'F:\\python-3.7.0\\lib\\pickle.py'>, <module 'struct' from 'F:\\python-3.7.0\\lib\\struct.py'>, <module '_struct' (built-in)>, <module '_compat_pickle' from 'F:\\python-3.7.0\\lib\\_compat_pickle.py'>, <module '_pickle' (built-in)>, <module 'select' from 'F:\\python-3.7.0\\DLLs\\select.pyd'>, <module 'socket' from 'F:\\python-3.7.0\\lib\\socket.py'>, <module '_socket' from 'F:\\python-3.7.0\\DLLs\\_socket.pyd'>, <module 'selectors' from 'F:\\python-3.7.0\\lib\\selectors.py'>, <module 'math' (built-in)>, <module 'socketserver' from 'F:\\python-3.7.0\\lib\\socketserver.py'>, <module 'idlelib.iomenu' from 'F:\\python-3.7.0\\lib\\idlelib\\iomenu.py'>, <module 'shlex' from 'F:\\python-3.7.0\\lib\\shlex.py'>, <module 'tempfile' from 'F:\\python-3.7.0\\lib\\tempfile.py'>, <module 'shutil' from 'F:\\python-3.7.0\\lib\\shutil.py'>, <module 'zlib' (built-in)>, <module 'bz2' from 'F:\\python-3.7.0\\lib\\bz2.py'>, <module '_compression' from 'F:\\python-3.7.0\\lib\\_compression.py'>, <module '_bz2' from 'F:\\python-3.7.0\\DLLs\\_bz2.pyd'>, <module 'lzma' from 'F:\\python-3.7.0\\lib\\lzma.py'>, <module '_lzma' from 'F:\\python-3.7.0\\DLLs\\_lzma.pyd'>, <module 'random' from 'F:\\python-3.7.0\\lib\\random.py'>, <module 'hashlib' from 'F:\\python-3.7.0\\lib\\hashlib.py'>, <module '_hashlib' from 'F:\\python-3.7.0\\DLLs\\_hashlib.pyd'>, <module '_blake2' (built-in)>, <module '_sha3' (built-in)>, <module 'bisect' from 'F:\\python-3.7.0\\lib\\bisect.py'>, <module '_bisect' (built-in)>, <module '_random' (built-in)>, <module 'weakref' from 'F:\\python-3.7.0\\lib\\weakref.py'>, <module 'locale' from 'F:\\python-3.7.0\\lib\\locale.py'>, <module 'idlelib.stackviewer' from 'F:\\python-3.7.0\\lib\\idlelib\\stackviewer.py'>, <module 'idlelib.debugobj' from 'F:\\python-3.7.0\\lib\\idlelib\\debugobj.py'>, <module 'idlelib.tree' from 'F:\\python-3.7.0\\lib\\idlelib\\tree.py'>, <module 'idlelib.zoomheight' from 'F:\\python-3.7.0\\lib\\idlelib\\zoomheight.py'>, <module 'pydoc' from 'F:\\python-3.7.0\\lib\\pydoc.py'>, <module 'pkgutil' from 'F:\\python-3.7.0\\lib\\pkgutil.py'>, <module 'urllib' from 'F:\\python-3.7.0\\lib\\urllib\\__init__.py'>, <module 'urllib.parse' from 'F:\\python-3.7.0\\lib\\urllib\\parse.py'>])

tempfile

属于内置模块用于创建临时文件和目录，当程序运行结束会自动删除文件和目录。

临时文件

临时是创建在寄存器里的，在普通的目录文件中无法找到，使用是必须使用seek改变指针

1
2
3
4
5
6
7
8
9
10
11
from tempfile import TemporaryFile
with TemporaryFile("w+") as fl:
    fl.write("这是第一句话\n")
    fl.write("这是第二句话")
    fl.seek(0) #使用seek改变指针为0
    content = fl.read()
    print(content)
    
>>>
这是第一句话
这是第二句话

这个文件和普通文件一样可以使用普通文件语法例如：readline

创建临时文件

创建的临时文件夹在该语句结束之前可以找到路径，一旦语句结束文件夹立刻消失、

1
2
3
4
5
6
7
8
from tempfile import TemporaryDirectory
with TemporaryDirectory() as Dirc:
    print(f"{Dirc}")
    input(":")

>>>
C:\Users\Administrator\AppData\Local\Temp\tmpxxad9z09
:

当输入一个任意字符串后该目录立刻消失，就算里面放进去东西也一起消失.。

Os

os模块是对系统操作的模块，属于python内置库

getcwd()

得到当前路径

1
2
3
4
5
import os
print(os.getcwd())

>>>
F:\桌面

listdir()

列出当前目录的所有东西

1
2
3
4
5
import os
print(os.listdir())

>>>
['05_芯片手册.rar.baiduyun.uploading.cfg',...]

chdir()

改变当前的工作路径

1
2
3
4
5
6
7
8
import os
print(os.getcwd())
os.chdir("C:\\")
print(os.getcwd())

>>>
F:\桌面
C:\

path

使用join进行路径连接

1
2
3
4
5
6
7
8
import os
disc = "C:\\"
path = "windows\system32"
all = os.path.join(disc,path)
print(all)

>>>
C:\windows\system32

使用isdir判断是否是文件夹

1
2
3
4
5
6
import os
a=os.path.isdir("./51")
print(a)

>>>
True

使用exists判断是否存在

1
2
3
4
5
6
import os
a=os.path.exists("./51")
print(a)

>>>
True

access

用来判断是否存在这个路径，并且可以根据传入的参数进行判断

1
2
3
4
5
import os
print(os.access(r"F:\Keil uvision C51\新建文件夹\UV4\UV4.exe",os.R_OK))

>>>
True

os.access(path,mode),mode还有几个参数:

  • os.F_OK，是否存在
  • os.R_OK，是否可读
  • os.W_OK，是否可写
  • os.X_OK，是否可执行

scandir

不带路径返回一个当前目录的迭代对象，需要使用到for循环输出。

1
2
3
4
5
6
7
8
9
import os
for i in os.scandir("C:"):
    print(i.name)
    
>>>
$RECYCLE.BIN
1B1F8E3E0CB3
Boot
......

除了获得name属性还有其他一些

  • name 获得名字

  • path 获得绝对路径

  • is_dir 是否为文件夹

  • .stat() 文件信息

    st_size 大小

    st_atime 最近访问时间

    st_mtime 最近修改时间

    st_ctime windows系统文件创建时间

    st_birthtime linux系统文件创建时间

walk

遍历路径，输出一个元组，有三个返回参数，分别是路径，目录名，文件名

1
2
3
4
5
6
7
8
9
import os
for dirpath,dirname,filenames in os.walk("C:"):
    print(dirpath)
    print(dirname)
    print(filenames)
    
>>>
C:
['$RECYCLE.BIN'......

文件夹

mkdir可以在系统中创建文件夹，makedirs可以进行创建递归文件夹。

1
2
3
4
5
6
import os
os.mkdir("./1")
os.makedirs("./1/1")

>>>
当前目录出现一个文件夹

removedirs删除指定目录的文件夹基本上被忽略，因为他只能删除空文件夹。

文件

remove(path)删除指定路径的文件。

rename(src,dst)重命名文件

操作文件不建议使用，os.open

1
2
3
4
5
6
7
8
# 打开文件
fd = os.open( "1.txt", os.O_RDWR|os.O_CREAT )

# 写入字符串
os.write(fd, "This is centence")

# 关闭文件
os.close( fd )

shutil

copy

复制文件

1
2
3
4
5
import shutil
shutil.copy("./1.py","./2.py")

>>>
同目录下多一个2.py

copytree

复制文件夹

1
2
3
4
5
import shutil
shutil.copytree("./51","./52")

>>>
同目录下多一个52

move

移动文件/文件夹

使用方法和上面的一样

shutil.move(“src”,“dst”)

停止更新