大灰羊
0%

发表于
本文字数： 2.8k 阅读时长 ≈ 3 分钟

1.__new__魔术方法

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
# -*- coding:utf-8 -*-
# @Time       :2022/6/21 9:42
# @SOFTWARE   :python基础


# __new__魔术方法

"""
    触发时机：实例化类生成对象的时候触发（触发时机在__init__之前）
    功能：控制对象的创建过程
    参数：至少一个cls接受当前的类，其他根据情况决定
    返回值：通常返回对象或者None

"""
# （1）基本使用
class Myclass2():
    a = 100

obj2 = Myclass2()
class MyClass1():
    def __new__(cls):
        # 类.成员方法(类)
        # 返回本类对象
        return object.__new__(cls)
        # 返回其他类对象
        # return obj2
        # 不返回对象
        # return None

obj = MyClass1()
print(obj)



# （2）__new__触发时机快于__init__
"""
    先有对象，才能初始化对象
    __new__ 创建对象
    __init__ 初始化对象
"""

class Myclass():
    def __init__(self):
        print(2)

    def __new__(cls):
        print(1)
        return object.__new__(cls)

obj = Myclass()

# （3）__new__的参数要和__init__参数一一对应
class Boat():
    def __new__(cls, name):
        return object.__new__(cls)
    def __init__(self,name):
        self.name = name

obj = Boat("山东舰")
print(obj.name)

# 使用手机参数进行改造
class Boat():
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)
    def __init__(self,name,type):
        self.name = name
        self.type = type

obj = Boat("山东舰","304不锈钢")
print(obj.name,obj.type)

# (4) __new__和__init__之间的注意点
"""
    如果__new__没有返回对象或者返回的是其他类的对象，不会调用构造方法
    只有在返回自己本类对象的时候，才会调用构造方法
"""
class Children():
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)
        # pass 没有返回对象，默认是None，无法在None关键字身上加name,skin成员属性
    def __init__(self,name,skin):
        self.name = name
        self.skin - skin

2.__del__魔术方法

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# -*- coding:utf-8 -*-
# @Time       :2022/6/22 9:20
# @SOFTWARE   :python基础


# __del__魔术方法（析构方法）
"""
    触发时机：当对象被内存回收的时候自动触发，(1.页面执行完毕回收所有变量，2.所有对象被del的时候)
    功能：对象使用完毕后资源回收
    参数：一个self接受对象
    返回值：无

"""

# (1)基本语法
class Lion():
    def __init__(self,name):
        self.name = name
    def __del__(self):
        print("析构方法被触发...")

# 触发方式一：页面执行完毕回收所有变量
obj = Lion("辛巴")

# 触发方式二：所有对象被del的时候（引用计数为0时，才会删掉对象）

print("========start===========")
del obj
print("=======end==========")

# （2)模拟文件操作
import os
class ReadFile():
    # 根据文件是否存在，创建对象
    def __new__(cls,filename):
        if os.path.exists(filename):
            return object.__new__(cls)
        else:
            print("抱歉，没有这个文件")
    # 打开文件
    def __init__(self,filename):
        self.fp = open(filename,mode="r",encoding="utf-8")
    # 关闭文件
    def __del__(self):
        self.fp.close()
    # 读取文件
    def readcontent(self):
        self.fp.read()

obj = ReadFile("多态.py")
print(obj.readcontent())

3.__str__和__repr__魔术方法

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
# -*- coding:utf-8 -*-
# @Time       :2022/6/22 9:44
# @SOFTWARE   :python基础

# __str__魔术方法
"""
    触发时机：使用print(对象)或者str(对象)的时候触发
    功能：查看对象
    参数：一个self接受当前对象
    返回值：必须返回字符串类型

"""

# __repr__魔术方法
"""
    触发时机：使用repr（对象）的时候触发
    功能：查看对象
    参数：一个self接受当前对象
    返回值：必须返回字符串类型
"""


# 系统底层默认把__repr__方法赋值给__str__方法,索引通过print()或者str强转可以触发
# __str__ = __repr__



发表于
本文字数： 1.4k 阅读时长 ≈ 1 分钟 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# -*- coding:utf-8 -*-
# @Time       :2022/6/22 9:11
# @SOFTWARE   :python基础

# ### 单态模式 : 同一个类,无论实例化多少次,都有且只有一个对象
"""
每创建一个对象,就会在内存中多占用一份空间
为了节省空间,提升执行效率,使用单态模式
场景:只是单纯调用类中的成员,而不会额外为当前对象添加成员;
"""


class Singleton():
    __obj = None

    def __new__(cls):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)
        return cls.__obj


"""
第一次,在实例化对象时触发__new__魔术方法 
if cls.__obj is None 条件成立  cls.__obj = object.__new__(cls) 创建一个对象给私有成员属性__obj
return cls.__obj  用obj1接收到了对象

第二次,在实例化对象时触发__new__魔术方法 if cls.__obj is None不满足,因为已经在__obj属性中存放了一个对象
return cls.__obj

第三次,在实例化对象时触发__new__魔术方法 if cls.__obj is None不满足,因为已经在__obj属性中存放了一个对象
return cls.__obj
"""
obj1 = Singleton()
obj2 = Singleton()
obj3 = Singleton()
print(obj1, obj2, obj3)


# 
class Singleton():
    __obj = None

    def __new__(cls, *args, **kwargs):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self, name):
        self.name = name


obj1 = Singleton("康玉康")
obj2 = Singleton("张保张")
print(obj1, obj2)
print(obj1.name)
print(obj2.name)
"""
康玉康 康玉康
康玉康 张保张
张保张 张保张

第一次实例化对象时,
触发__new__ if cls.__obj is None: 创建一个新的对象进行返回
然后触发__init__ self.name = 康玉康

第二次实例化对象时
触发__new__ if cls.__obj is None: 条件不满足,返回的是第一次实例化的对象,是同一个
然后触发__init__ self.name = 张保张
"""

name = "康裕康"
name = "张保障"
print(name)

发表于
本文字数： 948 阅读时长 ≈ 1 分钟 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
# -*- coding:utf-8 -*-
# @Time       :2022/6/21 9:24
# @SOFTWARE   :python基础

# 多态：不同的子类对象调用相同的父类方法，得到不同的执行结果

"""
    继承 重写
"""

class soldier():
    def attack(self):
        pass
    def retreat(self):
        pass

class Army(soldier):
    def attack(self):
        print("装甲部队")
    def retreat(self):
        print("跑步撤退")

class Navy(soldier):
    def attack(self):
        print("驱逐舰")
    def retreat(self):
        print("跳水")

class AirForce(soldier):
    def attack(self):
        print("投放原子弹")
    def retreat(self):
        print("跳伞")

# 创建士兵
obj1 = Army()
obj2 = Navy()
obj3 = AirForce()

lst = [obj1,obj2,obj3]
# =>   lst = [Army(),Navy(),AirForce()]


strvar = """
将军请下令：
1.全体出击
2.全体撤退
3.海军上，其他撤退
"""
num = input(strvar)
for i in lst:
    if num == "1":
        i.attack()
    if num == "2":
        i.retreat()
    if num == "3":
        if isinstance(i,Navy):
            i.attack()
        else:
            i.retreat()
    else:
        print("错误指令")

发表于
本文字数： 1.7k 阅读时长 ≈ 2 分钟 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
# -*- coding:utf-8 -*-
# @Time       :2022/6/20 10:06
# @SOFTWARE   :python基础

# 一个类除了自身拥有的属性和方法外，还获取了另外一个类的成员属性和方法，是一种继承关系，
# 被继承的类叫做父类（基类，超类）继承的类叫做子类（衍生类）
# 在python中所有类都继承object这个父类
# 继承：1.单继承 2.多继承

class Human(object):
    eye = "黑色"
    def jump(self):
        print("能上树")
    def __makebaby(self):
        print("能繁衍")

class son(Human):
    pass

# 子类继承父类之后，子类可以调用父类的公有成员，不能调用私有成员
obj = son()
obj.jump()
# obj.__makebaby()    AttributeError: 'son' object has no attribute '__makebaby'

# 子类继承父类之后，子类可以改写父类的公有成员



# 多继承
# 1.
class Father():
    property ="才高八斗"
    def f_hobby(self):
        print("吃喝玩乐")

class Mother():
    property = "貌美如花"
    def m_hobby(self):
        print("琴棋书画")

class Daughter(Father,Mother):
    pass

obj = Daughter()
print(obj.property)
obj.f_hobby()


# 2.
class Father():
    property ="才高八斗"
    def f_hobby():
        print("吃喝玩乐")

class Mother():
    property = "貌美如花"
    def m_hobby():
        print("琴棋书画")

class Son(Father,Mother):
    # 用类调用成员
    def skill(self):
        Father.f_hobby()
        print(Mother.property)
    def skill2(self):
        print(super())
        print(super().property)
        print(super().m_hobby())

obj2 = Son()
obj2.skill()
obj2.skill2()



# super本身是一个类，super()是一个对象，用语调用父类的绑定方法
# suoer()只应用于绑定方法中，默认自动传递self对象，（前提：super所在作用域存在self）
# super用途：解决复杂的多继承调用顺序
# 只调用父类的相关成员，不调用自己的


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
# -*- coding:utf-8 -*-
# @Time       :2022/6/20 9:46
# @SOFTWARE   :python基础

# 魔术方法
# 1. __init__魔术方法（构造方法）
"""
    触发时机：实例化对象，初始化的时候触发
    功能：为对象添加成员
    参数：参数不固定，至少是一个self参数
    返回值：无
"""
# 基本语法
class MyCar():
    def __init__(self):
        print("构造方法被触发")

obj = MyCar()

# 2.带有多个参数的构造方法
class Myclass():
    def __init__(self,num):
        self.num = num

# 3.类可以是一个，对象可以是多个

发表于
本文字数： 3.7k 阅读时长 ≈ 3 分钟 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
# -*- coding:utf-8 -*-
# @Time       :2022/6/19 9:38
# @SOFTWARE   :python基础


# 用几大特征表达一类事物称为一个类，类更像是一张图纸，表达的是一个抽象概念
# 对象是类的具体实现，更像是由这图纸产出的具体产品，类只有一个，但对象可以通过这个类实例化出多个
# 对象是类的实例，类是对象的模板
# 类中的成员只有方法和属性，不要裸露的把判断和循环直接写在类中（严禁使用，会破坏类中的结构），而是用方法包起来

# 类的定义
# 1.
class Car:
    pass
# 2.推荐
class Car():
    pass
# 3.
class Car(object):
    pass

# 类的实例化
obj = Car()
print(obj) # 返回一个内存地址

# 类的基本结构：成员属性和成员方法
class Car():
    # 成员属性
    color = "白色"
    # 成员方法
    def fun(self):
        print("燃油车")


# 类的命名—大驼峰命名法（每个单词首字母大写）


# 面向对象的三大特征：封装，继承，多态

# 封装：对类中成员属性和方法的保护，控制外界对内部成员的访问，修改，删除等操作
# 1.私有封装
# 在类内可以互相访问，类外不能
# 2.公有封装
# 在类内和类外都能访问
class MyCar():
    # 公有属性
    logo = "奥迪"
    # 私有属性
    __price = "2000万"
    # 公有方法
    def fun(self):
        print("百公里油耗7l")
    # 私有方法
    def __info(self):
        print("我的车")
# self -> 绑定方法：
# 1.绑定到对象：当对象调用类中的成员方法时，系统会默认把该对象作为参数传递给该方法
# 2.绑定到类：当对象或者类去调用类中成员方法时，系统会默认把该类作为参数传递给该方法

#（1）实例化对象
obj = MyCar()
# (2)实例化的对象访问成员属性和方法
# 公有
print(obj.logo)
obj.fun()

# （3）实例化的对象动态添加公有成员属性
obj.logo = "捷豹"
obj.color = "黑色"

# __dict__获取类对象的内部成员
print(obj.__dict__)
print(MyCar.__dict__)

# (4)实例化的对象动态添加公有成员方法

# 1.无参方法
def dhf():
    print("我叫大黄蜂")

# 2.有参方法
# 基本版
def qtz(name):
    print("我叫{}".format(name))
obj.qtz = qtz
obj.qtz("擎天柱")

# 升级版
def qtz1(obj,name):
    print("我叫{},我的颜色是{}".format(name,obj.color))
obj.qtz1 = qtz1
obj.qtz1(obj,"擎天柱")

# 终极版
def qtz2(obj,name):
    print("我叫{},我的颜色是{}".format(name, obj.color))

import types
# 创建绑定方法，系统自动把该对象当成参数传递给方法
# types.MethodType(方法，对象) => 绑定方法
res = types.MethodType(qtz2,obj)
print(res)
obj.qtz2 =types.MethodType(qtz2,obj)
obj.qtz2("擎天柱")

# lambda表达式
obj.wzt = lambda :print("我是威震天")
obj.wzt()

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# -*- coding:utf-8 -*-
# @Time       :2022/6/20 8:53
# @SOFTWARE   :python基础

class Mycar():
    # 公有属性
    platnum = "晋ACK099"
    # 私有属性
    __salary = "10000元"
    # 公有成员方法
    def car_info(self):
        print("牌照信息公开")
    # 私有成员方法
    def __car_money(self):
        print("汽车成本不公开")

# 1.定义的类访问公有成员属性和方法
print(Mycar.platnum)
Mycar.car_info(Mycar)
# 2.定义的类动态添加公有成员属性
Mycar.oil = "1000l"
print(Mycar.oil, Mycar.__dict__)
# 3.定义的类动态添加公有成员方法 -》 只能添加公有成员方法
# （1）无参方法
def car_light():
    print("天使眼大灯")
Mycar.car_light = car_light
Mycar.car_light()

# （2）有参方法
def car_engine(name):
    print("{}牌发动机".format(name))
Mycar.car_engine = car_engine
Mycar.car_engine("三缸直列发动机")

# （3）lambda表达式
Mycar.car_logo = lambda name:print("{}牌汽车".format(name))
Mycar.car_logo("奥迪")

# 对比 对象和类的不同
# 1.类中无参方法
# 默认只能类来调用，对象无法调取
# 对象可以调用类中的成员，反过来，类不能调用对象中的成员
# 每创建一个对象都会在内存中占用一份空间，对象之间是彼此独立的


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
31
32
33
# -*- coding:utf-8 -*-
# @Time       :2022/6/20 9:22
# @SOFTWARE   :python基础

# 1.如何在类外访问私有成员
class Plane():
    __engine = "空客"
    air_sister = "3名空姐"
    def __sister_age(self):
        print("年龄保密")
    def earn(self):
        print("1000万")

obj = Plane()
print(Plane.__dict__)
"""
{'__module__': '__main__', 
'_Plane__engine': '空客', 
'air_sister': '3名空姐', 
'_Plane__sister_age': <function Plane.__sister_age at 0x000001FD8642A280>, 
'earn': <function Plane.earn at 0x000001FD8642A310>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}
"""
# 方法1：
# python私有化：采取了改名策略     _类名+方法名 -》 _Plane__engine': '空客'

# 方法2：使用类中的公有方法，间接访问类中的私有方法



# 删除成员属性和方法
# del + 方法名或者属性名（私有无法删除）

# 对象无法调用无参方法，且类可以调用对象的绑定方法

发表于
本文字数： 1.4k 阅读时长 ≈ 1 分钟 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
# -*- coding:utf-8 -*-
# @Time       :2022/6/18 8:52
# @SOFTWARE   :python基础

# 导入模块相当于导入该模块的所有内容，且不会重复导入
# 导入模块，程序优先检索同级目录下的模块


# 1.import 导入的基本使用
# 模块.变量

# 模块.函数()

# 模块.类
# 模块.类().变量 调用类中的变量


# 2.导入任意路径下的任意模块，需要借助sys模块
# 首先看一下sys.path里面有没有想要导入的这个模块路径
# 如果有，默认导入，如果没有，需要手动追加
import sys
print(sys.path)
sys.path.append("模块绝对路径")   # 手动追加路径

# 3.from ..import..基本使用
# from 模块 import 具体的某些成员
# 使用时直接使用，不需要 模块.xxx

# from ..import * 导入所有成员

# 设置*号导入的范围
# 在导入的模块中添加 __all__ = [] 列表中添加可导入的模块

# 设置引入成员的别名 as
# from 模块 import 成员 as 成员别名,成员 as 成员别名

# 4.关于__name__使用
# 返回模块名字的魔术属性 __name__
# 如果当前文件时直接运行的，返回“__main__”字符串
# 如果当前文件时间接导入的，返回当前文件名（模块名）

# 魔术属性
# __doc__ 获取文档
# __file__ 获取文件名和路径

# -*- coding:utf-8 -*-
# @Time       :2022/6/18 9:27
# @SOFTWARE   :python基础


# 文件夹：包
# 文件：模块

# 当引入包时，会自动指定包中的__init__.py的初始化文件，对包进行初始化


# 1.引入包的语法
# import 包名
# 导入包的属性
# 包名.属性名

# 导入包下的某个模块
# 方法一：
# import 包名.模块名

# 方法二： as 起别名
# import 包名.模块名 as xx

# 方法三：把要引入的模块放入__init__.py中
# 常用

# 2.from .. import 引入包的语法
# 引入包的属性
# from .. import 属性

# 引入包的模块
# from .. import 模块

# 引入包的模块的成员
# from 包.模块 import 成员

# 3.单入口模式
# 只通过主文件来调用分模块内容，分模块不单独执行
# 分模块不能单独进行调用，同意由主文件main进行调用
# 模块之间的互相嵌套导入，使用相对路径实现
# 单入口文件必须和包在同意层级，包里面可以含有各种包和模块

# 相对路径
# . 当前路径
# .. 上一级路径
# ... 上一级的上一级
# .... 上一级的上一级的上一级

# from . import 模块名 相对于当前路径引入模块
# from .模块名 import 属性 相对于当前模块引入具体属性
# from .. import 模块名 相对于上一级引入模块
# from ..包名 import 模块 相对于上一级的某个包引入某个属性
# from ..包名.模块 import 属性 相对于上一级某个包下的某个模块引入某属性

发表于
本文字数： 471 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding:utf-8 -*-
# @Time       :2022/6/17 9:16
# @SOFTWARE   :python基础

import shutil

# shutil.copyfileobj(原文件，复制的文件，length = 16 * 1024)  复制文件（length的单位是字符，表达一次杜多少字符、字节）
# shutil.copyfile()     单纯的仅复制文件内容，底层调用了 copyfileobj

# shutil.copymode()     单纯的仅复制文件权限  不包括文件内容(虚拟机共享目录默认都是777)
# shutil.copystat()     复制所有状态信息，包括权限，组，用户，修改时间等，不包括内容
# shutil.copy()     复制文件的权限和内容
# shutil.copy2()    复制文件的权限和内容，包括权限，组，用户，时间等

# shutil.copytree()   拷贝文件夹里所有内容，递归拷贝
# shutil.rmtree()     删除当前文件夹及其中所有的内容（递归删除）
# shutil.move()     移动文件或者文件夹

发表于
本文字数： 471 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding:utf-8 -*-
# @Time       :2022/6/17 9:16
# @SOFTWARE   :python基础

import shutil

# shutil.copyfileobj(原文件，复制的文件，length = 16 * 1024)  复制文件（length的单位是字符，表达一次杜多少字符、字节）
# shutil.copyfile()     单纯的仅复制文件内容，底层调用了 copyfileobj

# shutil.copymode()     单纯的仅复制文件权限  不包括文件内容(虚拟机共享目录默认都是777)
# shutil.copystat()     复制所有状态信息，包括权限，组，用户，修改时间等，不包括内容
# shutil.copy()     复制文件的权限和内容
# shutil.copy2()    复制文件的权限和内容，包括权限，组，用户，时间等

# shutil.copytree()   拷贝文件夹里所有内容，递归拷贝
# shutil.rmtree()     删除当前文件夹及其中所有的内容（递归删除）
# shutil.move()     移动文件或者文件夹

发表于
本文字数： 1.7k 阅读时长 ≈ 2 分钟 
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
31
32
33
34
35
36
37
# -*- coding:utf-8 -*-
# @Time       :2022/6/17 8:25
# @SOFTWARE   :python基础

import os

# system() 在python中执行系统命令
os.system('ipconfig') # linux中查询ip地址 ifconfig windows中会乱码

# popen() 执行系统命令返回对象，通过read方法读出字符串
obj = os.popen("ipconfig")
print(obj.read())

# listdir() 获取指定文件夹中所有内容的名称列表
# getcwd() 获取当前文件夹中所在的默认路径
print(os.getcwd())

# 获取路径和文件名
print(__file__)

# chdir() 修改当前文件工作的默认路径
# environ() 修改当前文件的环境变量
# Linux下
# 1.在家目录中创建个文件夹，里面创建个文件xxxx,写入ifconfig
# 2.增加xxxx的可执行去哪先 chmod 777
# 3.添加环境变量在os.environ(["PATH"]) 中拼接xxxx的所有绝对路径
# 4.os.system("xxxx")

# 总结：环境变量path的好处是 让系统自动找到该命令的实际路径并执行


# --os 模块属性
# name() 获取系统标识 linux,mac -> posix  windows -> nt
# sep() 获取路径分割符号 linux,mac -> /   windows -> \
# linesep() 获取系统换行符 Linux,mac -> \n windows -> \n或者\r\n


path模块

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
31
32
# -*- coding:utf-8 -*-
# @Time       :2022/6/17 9:42
# @SOFTWARE   :python基础
import os

# os.path.basename()    返回文件名部分

# os.path.dirname()     返回路径部分

# os.path.split()     将路径拆分成单独的文件部分和路径部分，返回一个元组

# os.path.join()      将多个路径和文件组成新的路径，可以自动通过不同的系统加不同的斜杠

# os.path.splitext()    将路径分割为后缀和其他部分，返回元组

# os.path.getsize()     获取文件大小 -> 字节

# os.path.isdir()      检测路径是否是一个文件夹     返回布尔值
# os.path.isfile() ***     检测路径是否是一个文件     同上
# os.path.islink()      检测路径是否是一个链接 同上


# os.path.getctime()    windows文件得创建时间，Linux 权限的修改时间（返回时间戳）
# os.path.getmtime()    获取文件最后一次修改的时间 -> 返回时间戳  根据time.ctimme()转换成时间字符串
# os.path.getatime()    获取文件最后一次访问时间 -> 返回时间戳

# os.path.exists()  ***    检测指定的路径是否存在
# os.path.isabs()   检测一个路径是否是绝对路径
# os.path.abspath()     将相对路径转换成绝对路径



文件操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# -*- coding:utf-8 -*-
# @Time       :2022/6/17 9:00
# @SOFTWARE   :python基础
import os

# os.mknod() 创建文件

# os.remove() 删除文件

# os.mkdir() 创建目录（文件夹）

# os.chdir()  更改目录

# os.rmdir() 删除目录（）文件夹

# os.rename() 对文件，目录重命名

#os.makedirs() 递归创建文件夹

# os.removedirs 递归删除文件夹（空文件夹）

发表于 更新于
本文字数： 207 阅读时长 ≈ 1 分钟

序列化：把不能直接存储在文件中的数据变的可存储

反序列化：把存储在文件中的数据拿出来恢复成原来的数据类型

1.dumps

把任意对象(列表，函数，迭代器….)序列化成一个bytes

pickle.dumps()

2.loads

pickle.loads()

3.dump

把对象序列化后写入到file-like object (即文件对象)

4.load

阅读全文 »