ssy的小天地

愿汝如是 千金不换

0%

Python之常用特性补充

发表于 更新于 分类于

本文主要补充了Python中常用的一些特性补充，其中包括数据类型相关的，函数相关的，面向对象编程的，IO输入输出的以及内建模块

数据类型相关的特性

  • 关于tuple
  • dict也可以使用for循环迭代
  • Python内置的enumerate函数可以把list变成索引-元素对
  • 列表生成式
  • 生成器generator
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
print("-"*25, 1, 'tuple', "-"*25) #打印时逗号会被认为是空格
#1.关于tuple
t = (1, 2, 3)
print(t)

# t[0] = 4
# print(t) #此时会报错，tuple中的元素不可修改

print("-"*25, 2, 'dict', "-"*25)
#2.dict也可以使用for循环迭代
d = {'a':1, 'b':2, 'c':3}
for key in d.keys(): #若只有d，则默认是d.keys()
    print(key)
for value in d.values():
    print(value)
for item in d.items():
    print(item)

print("-"*25, 3, 'enumerate', "-"*25)
#3.Python内置的enumerate函数可以把list变成索引-元素对
for idx, value in enumerate(d):
    print(idx, value)

print("-"*25, 4, '列表生成式', "-"*25)
#4.列表生成式
L_list = [x * x for x in range(1, 11)] #列表生成式可以用一行语句代替利用循环生成的list
print(L_list)

L_choose = [x * x for x in range(1, 11) if x % 2 == 0] #for循环后面还可以加上if判断条件，对for遍历出来的数进行筛选
print(L_choose)

L_ifelse = [x * x if x % 2 == 0 else -x for x in range(1, 11)]
print(L_ifelse) #在一个列表生成式中，for前面的if...else是表达式，而for后面的if是筛选条件，不能带else

print("-"*25, 5, '生成器generator', "-"*25)
#5.生成器generator
def odd(): #如果函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator函数
    print('step 1') #generator函数和普通函数的执行流程不一样，
    yield 1         #普通函数是顺序执行，遇到return语句或者最后一句函数语句就返回
    print('step 2') #generator的函数，在每次调用next()的时候执行，遇到yield语句返回，
    yield 3         #再次执行时从上次返回的yield语句处继续执行
    print('step 3')
    yield 5

o = odd() #调用一个generator函数将返回一个generator，即生成一个generator对象
print(next(o))
print(next(o))
print(next(o))
print("*"*10)

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

for n in fib(6): #在循环过程中不断调用yield，就会不断中断
    print(n)     #要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来

结果如下：

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
------------------------- 1 tuple -------------------------
(1, 2, 3)
------------------------- 2 dict -------------------------
a
b
c
1
2
3
('a', 1)
('b', 2)
('c', 3)
------------------------- 3 enumerate -------------------------
0 a
1 b
2 c
------------------------- 4 列表生成式 -------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[4, 16, 36, 64, 100]
[-1, 4, -3, 16, -5, 36, -7, 64, -9, 100]
------------------------- 5 生成器generator -------------------------
step 1
1
step 2
3
step 3
5
**********
1
1
2
3
5
8

函数式编程的相关特性

  • 关于map
  • 关于lambda
  • 关于函数的参数
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
print("-"*25, 1, 'map', "-"*25)
#1.关于map
def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) #map()函数接收两个参数，一个是函数，一个是Iterable
print(list(r)) #map将传入的函数以此作用到序列的每个元素，并把结果作为新的Iterator返回

print("-"*25, 2, 'lambda', "-"*25)
#2.关于lambda
L = map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) #关键字lambda表示匿名函数，冒号前面的x表示函数参数
print(list(L)) #匿名函数只能有一个表达式，不用写return，返回值就是该表达式的结果

print("-"*25, 3, '函数的参数', "-"*25)
#3.关于函数的参数
def f1(a, b, c = 0, *args, city, job, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'arg = ', args, 'city =', city, 'job =',job, 'kw =', kw)

def f2(a, b, c = 0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd = ', d, 'kw =', kw)

f1(1, 2, city = 'xm', job = 'ic')
f1(1, 2, c = 3, city = 'xm', job = 'ic') #一旦使用名字来赋值传参，那么后面的参数传递都需要使用名字来传参
f1(1, 2, 3, 4, 5, city = 'xm', job = 'ic', x = 99, y =100)

args = [1, 2, 8]
kw = {'d': 88, 'x': '#'} #通过list(tuple)或dict，可以调用上述函数
f2(*args, **kw) #对于任意函数，都可以使用func(*arg, **kw)的形式调用它，无论它的参数是如何定义的
###############
#3.1 参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数
#3.2 可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple，写法为*args
#3.3 关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装成dict，写法为**kw
#3.4 就相当于*args接收list或者tuple，**kw接收字典
#3.5 命名关键字参数与必选参数与默认参数之间需要跟着一个特征分隔符*，即*后面的参数被视为命名关键字参数，其传参时需要写出名字
#3.6 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不需要用特殊分隔符*了
###############

结果如下：

1
2
3
4
5
6
7
8
9
------------------------- 1 map -------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81]
------------------------- 2 lambda -------------------------
[1, 4, 9, 16, 25, 36, 49, 64, 81]
------------------------- 3 函数的参数 -------------------------
a = 1 b = 2 c = 0 arg =  () city = xm job = ic kw = {}
a = 1 b = 2 c = 3 arg =  () city = xm job = ic kw = {}
a = 1 b = 2 c = 3 arg =  (4, 5) city = xm job = ic kw = {'x': 99, 'y': 100}
a = 1 b = 2 c = 8 d =  88 kw = {'x': '#'}

面向对象编程

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
print("-"*25, 1, '类与实例', "-"*25)
#1.类与实例
class Student(object): #class声明一个类，后面跟着的是类名，如果没有合适的类继承，那么就继承object类
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def print_score(self):
        print('%s: %.2f' % (self.name, self.score))

base = Student('ssy', 100) #通过类名()创建出Student实例，变量base是指向Student的一个实例
base.print_score()
###########################
#1.1 __init__方法的第一个参数永远是self，表示创建出的实例本身
#1.2 和普通函数相比，在类中定义函数只是有一点不同，就是第一个参数永远是实例变量self，并且调用时，不用传递参数
#1.3 在类中将封装数据的函数称为类的方法
#1.4 与静态语言不同，python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称可能不同
#1.5 可以用object.变量 = xxx来对实例对象绑定数据
###########################

print("-"*25, 2, '访问限制', "-"*25)
#2.访问限制
class Student2(object): 
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
        
    def print_score(self):
        print('%s: %.2f' % (self.__name, self.__score))  

base2 = Student2('ssy', 100) #通过类名()创建出Student实例，变量base是指向Student的一个实例
base2.print_score()
#print(base2.__name) #会报错，因为加上了属性名称前加上了__（两个下划线），代表变量是个私有变量，不能被外部访问了
base2.__name = 'wcf'
print(base2.__name) #表面上看似成功设置了__name变量，但实际上这个__name变量和class内部的__name变量不是一个变量
print(base2._Student2__name) #内部的变量__name已经被外部的Python解释器自动改成了_Student2__name，而外部代码给base2新增了__name变量
###########################
#2.1 在class内部，可以有属性和方法，而外部代码可以通过调用实例变量的方法来操作数据，通过object.变量 = xxx
#2.2 在Python中，实例的变量名如果以__开头，就变成了一个私有变量，只有内部可以访问，外部不能访问
#2.3 双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。
#2.4 不能直接访问__name是因为__name已经被外部的Python解释器自动改成了_Student2__name
#2.5 所以仍然可以通过_Student2__name来访问__name
#2.6 但强烈建议不要这么干，因为不同版本的Python解释器可以会把__name改成不同的变量名
###########################

print("-"*25, 3, '继承和多态', "-"*25)
#3.继承和多态
class Animal(object):
    def run(self):
        print("Animal is running!")

class Dog(Animal): #对Dog来说，Animal就是它的父类；对于Animal来说，Dog就是它的子类
    def run(self):
        print("Dog is running!")

class Cat(Animal):
    def run(self):
        print("Cat is running!")

ani = Animal()
dog = Dog()
cat = Cat()
ani.run()
dog.run()
cat.run()
print('*'*20)

def run_twice(animal):
    animal.run()
    animal.run()

class Otherani(object):
    def run(self):
        print("Other Animal is running!")

oth = Otherani()
run_twice(ani)
print('*'*20)
run_twice(dog)
print('*'*20)
run_twice(cat)
print('*'*20)
run_twice(oth)
###########################
#3.1 继承最大的好处就是子类获得了父类的全部功能
#3.2 当子类和父类都存在相同的run()方法时，子类的run()覆盖了父类的run()，在代码运行时，总会调用子类的run()
#3.3 这样，就得到了继承的好处-->多态
#3.4 在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做父类，但反过来就不行，即Dog可以看成Animal，但Animal不能看成Dog
#3.5 对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则将无法调用run()方法
#3.6 对于Python这样的动态语言来说，则不一定要传入Animal类型，只需要保证传入的对象有一个run()方法就可以了
###########################

print("-"*25, 4, '获取对象信息', "-"*25)
#4.获取对象信息
print(isinstance(ani, Animal)) #使用isinstance()判断数据类型
print(isinstance(ani, Dog))
print(isinstance(dog, Dog))
print(isinstance(cat, Cat))
print(isinstance(cat, Animal))

print(dir(ani)) #使用dir(object)查看一个对象的所有属性和方法
print(dir('ssy'))

class MyDog(object):
    def __len__(self):
        return 100

dog = MyDog()
print("The length of MyDog is:", len(dog))
print("The length of MyDog is:", dog.__len__())
###########################
#4.1 类似__xxx__的属性和方法在Python中都有特殊的用途
#4.2 比如__len__方法返回长度，在Python中如果调用len()函数试图获取一个对象的长度，
#4.3 实际上在len()函数的内部，它自动去调用该对象的__len__()方法
#4.4 如果自己写一个类，也想用len(object)的话，就自己写一个__len__()方法
###########################

print("-"*25, 5, '实例属性和类属性', "-"*25)
#5.实例属性和类属性
class Myobj(object):
    name = "ssy"
m1 = Myobj()
m2 = Myobj()
print('m1.name:', m1.name) #打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
print('Myobj.name:', Myobj.name)
print('m2.name:', m2.name)
m1.name = 'wcf'
Myobj.name = 'ybl'
print('New m1.name:', m1.name) #由于实例属性优先级高于类属性，所以它会屏蔽掉类的name属性
print('New Myobj.name:', Myobj.name) 
print('m2.name:', m2.name)
del m1.name #删除实例的name属性
print('After del, m1.name:', m1.name)
###########################
#5.1 由于Python是动态语言，根据类创建的实例可以任意绑定属性
#5.2 给实例绑定属性的方法是通过实例变量，或者通过self变量
#5.3 但如果Myobj类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有
###########################

结果如下：

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
------------------------- 1 类与实例 -------------------------
ssy: 100.00
------------------------- 2 访问限制 -------------------------
ssy: 100.00
wcf
ssy
------------------------- 3 继承和多态 -------------------------
Animal is running!
Dog is running!
Cat is running!
********************
Animal is running!
Animal is running!
********************
Dog is running!
Dog is running!
********************
Cat is running!
Cat is running!
********************
Other Animal is running!
Other Animal is running!
------------------------- 4 获取对象信息 -------------------------
True
False
True
True
True
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'run']
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
The length of MyDog is: 100
The length of MyDog is: 100
------------------------- 5 实例属性和类属性 -------------------------
m1.name: ssy
Myobj.name: ssy
m2.name: ssy
New m1.name: wcf
New Myobj.name: ybl
m2.name: ybl
After del, m1.name: ybl

2.高级编程

  • __slots__
  • @property
  • 定制类
    • __str__
    • __iter__
    • __getitem__
  • 使用枚举类Enum
    • @unique
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
from types import MethodType

print("-"*25, 1, '__slots__', "-"*25)
#1.__slots__
class Student(object):
    pass
s = Student()

def set_age(self, age): #定义一个函数作为实例方法
    self.age = age

s.set_age = MethodType(set_age, s) #给实例绑定一个方法
s.set_age(25)
print(s.age)

s2 = Student()
# s2.set_age(20) #此时报错，给一个实例绑定的方法，对另一个实例是不起作用的

class Student(object):
    __slots__ = ('name', 'age') #用tuple定义允许绑定的属性名称

s = Student()
s.name = 'ssy'
s.age = '22'
# s.score = 100 #此时报错，因为score没有放到__slots__中，不能被绑定此属性
###########################
#1.1 __slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
#1.2 除非在子类中也定义__slots__，这样子类实例允许定义的属性就是自身的__slots__加上父类的__slots__
###########################

print("-"*25, 2, '@property', "-"*25)
#2.@property
class Student(object):
    def __init__(self, score):
        self.__score = score

    @property #方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改
    def score(self):
        return self.__score
    
    @score.setter #@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100 !')
        self.__score = value
    
s = Student(60)
print(s.score)
s.score = 80
print(s.score)
# s.score = 999 #此时会报错，因为score超出规定范围了


print("-"*25, 3, '定制类', "-"*25)
#3.定制类
#3.1 __str__
print("#"*25, '3.1', '__str__', "#"*25)
class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self): #不写__str__则打印结果为<__main__.Student object at 0x000001ABEEEA3D00>
        return 'Student object (name: %s)' % self.name 
    
s = Student('ssy')
print(s)

#3.2 __iter__
print("#"*25, '3.2', '__iter__', "#"*25)
class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1
    def __iter__(self): #如果一个类想要被用于for...in循环，类似list或tuple那样，就必须实现一个__iter__()方法
        return self #该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值
    def __next__(self):#直到遇到StopIteration错误时退出循环
        self.a, self.b = self.b, self.a + self.b 
        if self.a > 10:
            raise StopIteration()
        return self.a
for n in Fib():
    print(n)

#3.3 __getitem__
print("#"*25, '3.3', '__getitem__', "#"*25)
class Fib(object): 
    def __getitem__(self, n): #Fib实例虽然能作用于for循环，但想要像list那样按照下标取出元素，需要用__getitem__()方法
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b 
        return a
f = Fib()
print(f[0])
print(f[1])
print(f[2])
print(f[3])
print(f[4])  
print(f[5]) 


print("-"*25, 4, '使用枚举类Enum', "-"*25)
#3.使用枚举类Enum
from enum import Enum, unique
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value) #value属性是自动赋给成员的int常量，默认从1开始计数

@unique #@unique装饰器可以帮助检查保证没有重复值
class Weekday(Enum): #若需要更准确地控制枚举类型，可以从Enum派生出自定义类 
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

day1 = Weekday.Mon #访问这些枚举类型可以有若干种方法
print(day1)
print(Weekday.Tue)
print(Weekday['Tue'])
print(Weekday.Tue.value)
print(day1 == Weekday.Mon)
print(day1 == Weekday.Tue)
print(Weekday(1))
print(day1 == Weekday(1))
for name, member in Weekday.__members__.items():
    print(name, '=>', member)

结果如下：

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
------------------------- 1 __slots__ -------------------------
25
------------------------- 2 @property -------------------------
60
80
------------------------- 3 定制类 -------------------------
######################### 3.1 __str__ #########################
Student object (name: ssy)
######################### 3.2 __iter__ #########################
1
1
2
3
5
8
######################### 3.3 __getitem__ #########################
1
1
2
3
5
8
------------------------- 4 使用枚举类Enum -------------------------
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12
Weekday.Mon
Weekday.Tue
Weekday.Tue
2
True
False
Weekday.Mon
True
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat

IO编程

  • 文件读写：也请参考我之前的文章Python基础之文件的读写
  • 操作文件和目录
    • os.name
    • os.path.abspath('.')
    • os.path.join
    • os.mkdir
    • os.rename
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
print("-"*25, 1, '文件读写', "-"*25)
#1.文件读写
f = open('filetest.txt', 'r')
print(f.read())
f.close()

print(25*'#')
with open('filetest.txt', 'r') as f:
    print(f.read(13)) #会将换行符也读入
    print(f.readline()) 

print(25*'#')
with open('filetest.txt', 'r') as f:
    print(f.readlines()) #一次读取所有内容并按行返回list
    f.seek(0) #改变当前文件操作指针的位置，0(代表回到文件开头)，1（代表当前位置），2（代表回到文件结尾）
    for line in f.readlines():
        print(line.strip()) #把末尾的'\n'删掉

print(25*'#')
with open('filetest.txt', 'a+') as f:
    f.writelines(['You are my sunshine\n', 'IC Design'])
    f.seek(0)
    for line in f.readlines():
        print(line.strip()) #把末尾的'\n'删掉

###############
#1.1 文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用
#1.2 Python引入了with语句来自动帮我们调用close()
#1.3 read(size)用法，每次读取size个字节
###############


print("-"*25, 2, '操作文件和目录', "-"*25)
#2.操作文件和目录
import os 
print(os.name) #os.name获取操作系统的类型：如果是posix，说明系统是Linux、Unix或Mac OS X，如果是nt，就是Windows系统
print(os.path.abspath('.')) #查看当前目录所在的绝对路径
test= os.path.join('D:\App_Data_File\VScode_Project\Python\python_for_some_easy_error', 'OStest') #把多个部分合成一个路径
print(test)
os.mkdir(test) #创建一个目录
os.rmdir(test) #删除一个目录

#os.rename('test.py', 'OStest.py') #对文件重命名
#os.remove('OStest.py') #删掉文件

结果如下：

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
------------------------- 1 文件读写 -------------------------
hello, world
hello, ssy
hello, xmu

#########################
hello, world

hello, ssy

#########################
['hello, world\n', 'hello, ssy\n', 'hello, xmu\n']
hello, world
hello, ssy
hello, xmu
#########################
hello, world
hello, ssy
hello, xmu
You are my sunshine
IC Design
------------------------- 2 操作文件和目录 -------------------------
nt
D:\App_Data_File\VScode_Project\Python\python_for_some_easy_error
D:\App_Data_File\VScode_Project\Python\python_for_some_easy_error\OStest

常用的内建模块

  • datetime
  • argparse
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
print("-"*25, 1, 'datetime', "-"*25)
#1.datetime
from datetime import datetime, timedelta
now = datetime.now() #获取当前日期和时间
print(now)
dt = datetime(2015, 4, 19, 12, 20, 54) #用指定日期时间创建datetime
print(dt)
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
print(cday) #将字符串转化为datetime
print(now.strftime('%a, %b %d %H:%M')) #将datetime转化为字符串

print(now) #对时间进行加减运算
print(now + timedelta(hours=10))
print(now - timedelta(days=1))
print(now + timedelta(days=2, hours=12))


print("-"*25, 2, 'argparse', "-"*25)
#2.argparse
import argparse
if __name__ == '__main__':
    # 定义一个ArgumentParser实例:
    parser = argparse.ArgumentParser(
        prog='backup', # 程序名
        description='Backup MySQL database.', # 描述
        epilog='Copyright(r), 2023' # 说明信息
    )
    # 定义位置参数:
    parser.add_argument('--outfile', default='./parsertest', help='The position of output file')
    # 定义关键字参数:
    parser.add_argument('--host', default='localhost')
    # 此参数必须为int类型:
    parser.add_argument('--port', default='3306', type=int) #默认的参数类型是str类型，如果需要一个整数参数，需要设置type=int
    # choices：参数值只能从几个选项里面选择
    parser.add_argument('--arch', choices=['alexnet', 'vgg'])
    # 允许用户输入简写的-u:
    # parser.add_argument('-u', '--user', required=True) #required: 表示这个参数是否一定需要设置；-u表示允许用户输入简写-u
    # parser.add_argument('-p', '--password', required=True) #如果设置了required=True,则在实际运行的时候不设置该参数将报错：python normal_ku.py -u ssy

    # 解析参数:
    args = parser.parse_args()
    args.u = 'ssy'
    args.p = '12345'
    args.arch = 'vgg'
    # 打印参数:
    print('parsed args:')
    print(f'outfile = {args.outfile}')
    print(f'host = {args.host}')
    print(f'port = {args.port}')
    print(f'port = {args.arch}')
    # print(f'user = {args.user}')
    # print(f'password = {args.password}')

结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
------------------------- 1 datetime -------------------------
2023-09-07 19:06:04.071888
2015-04-19 12:20:54
2015-06-01 18:19:59
Thu, Sep 07 19:06
2023-09-07 19:06:04.071888
2023-09-08 05:06:04.071888
2023-09-06 19:06:04.071888
2023-09-10 07:06:04.071888
------------------------- 2 argparse -------------------------
parsed args:
outfile = ./parsertest
host = localhost
port = 3306
port = vgg
user = ssy
欢迎来到ssy的世界