产品解决方案文档与社区免费试用定价云市场合作伙伴支持与服务了解阿里云
备案控制台登录/注册
开发者社区 开发与运维 文章 正文

【Python之旅】第四篇（三）：Python面向对象编程详解

2017-11-26 1193
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
+关注继续查看

   终于是来到了Python的面向对象编程，以前是没有接触过其它的面向对象编程的语言，因此学习这一部分是相当带劲的，这里也总结一下。


1.面向对象编程的相关名词及解释

    世界万物，皆可分类，一切皆为对象。

    所谓的面向对象编程，指的是一种编程的思想，通过对具体代码实现过程（面向过程编程）的不断抽象，以形成一个个的类别，以提高我们进行大型程序编写的效率（面向对象的具体实现需要面向过程，大型程序也可以用面向过程来编写，只是比较麻烦）。对于面向对象编程的相关名词和解释如下：

对象 ：类的实体\一个叫Rain的好色的男人

类：人\动物\机器

方法：人会走,会思考\狗会叫,会咬人\定义一个类的各个功能

消息传递：狗叫了,人听见了,就叫通信

继承：狗都四条腿走路

封装：人不能引用狗的特性,比如四条腿走路

多态性：一个叫的功能,可能是低吼,也可是大声叫

抽象性：简化复杂的现实问题的途径，它可以为具体问题找到最恰当的类定义

    对“类”这个名词举个简单的例子：

杯子：类

这个杯子：对象（实体），属于“杯子”这个类

    对“方法”这个名词举个例子：动态方法（动态属性）与静态方法（静态方法可以理解为类的属性）。


2.类、对象、方法

    关于三者的关系，用下面的一张图片可以非常清晰明确的说明：

wKiom1YNXzXhVqtqAAG2f59r2RI144.jpg


3.类的语法：第一个面向对象程序

1
2
3
4
5
6
7
8
9
10
11
程序代码如下：
class dog:                    #定义一个类
    def name(self):       #定义类的方法
        print "Hello master, my name is Python."
 
D = dog()    #类的实例化，产生类的对象，如果不实例化，将无法访问该类
D.name()     #使用类的方法
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python myclass4.py 
Hello master, my name is Python.

 

4.类的方法：有关self

    类的方法（类函数）与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。

    如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)。

    类中如果有多个不同的方法，并且类中的变量需要相互访问，这时候就需要使用self即用类自身来作为中间变量以进行变量在不同类中的传递了，可以看下面的一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
程序代码如下：
class Dog:
    class_object = 'food' #这是一个类变量
    def sayHi(self):
        print 'Hi master , I am your little dog, who do you want me to bite...'
        favorate_food = 'bone'
        self.FavorFood = favorate_food    #将favorate_food变为全局变量，让其它方法可以引用
    def eat(self, food_type):
        if food_type == self.FavorFood:  #不同类方法之间的变量调用，需要通过类本身
            print 'I like it very much..thanks'
        else:
            print 'Do not give me this bull shit...'
 
d = Dog()
d.sayHi()   '''如果不调用sayHi()，则无法将favorrate_food变成一个类变量，所谓类变量，
            即是类下定义的第一级变量'''
d.eat('bone') 
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python class7.py 
Hi master , I am your little dog, who do you want me to bite...
I like it very much..thanks


    当然这里实际上是把sayHi方法中的favorate_food变量变为变中的全局变量，需要注意的是，下面的方法是不可以的：

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
程序代码如下：
class Dog:
    class_object = 'food' 
    def sayHi(self):
        print 'Hi master , I am your little dog, who do you want me to bite...'
        favorate_food = 'bone'
 
    def eat(self, food_type):
        if food_type == self.sayHi().favorate_food: #这样使用是不行的
            print 'I like it very much..thanks'
        else:
            print 'Do not give me this bull shit...'
 
d = Dog()
d.sayHi()   
d.eat('bone') 
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python class7.py 
Hi master , I am your little dog, who do you want me to bite...
Hi master , I am your little dog, who do you want me to bite...
Traceback (most recent call last):
  File "class7.py", line 16, in <module>
    d.eat('bone') 
  File "class7.py", line 9, in eat
    if food_type == self.sayHi().favorate_food: 
AttributeError: 'NoneType' object has no attribute 'favorate_food'

    上面程序不行是因为，self.sayHi()时，其实会执行sayHi()方法，因为它本来就是一个函数，并且没有定义返回值，因此会返回None值，导致程序执行出错。

    上面的例子意在说明，不同类方法之间调用变量时，需要将其变为全局变量，并且要通过self即类本身进行引用。即类下的各个方法（函数，name也认为是一个函数），不能独自相互通信，必须要通过类作为中间人来进行通信，self即代表self本身，通过self.name即可完成通信，所以在定义类下的方法时，必须要加一个参数，即self，来代表类本身，否则这个方法就不能被使用当然参数不一定要是self。


5.类的构造函数__init__()与解构函数__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
程序代码如下：
class Person:
    def __init__(self,name,age):                #构造函数，只要把类实例化，就会执行此函数
        print 'I am being called right now...'
        self.Name = name
        self.Age = age
 
    def sayHi(self):                            #类的普通方法
        print 'Hi my name is %s, i am %s years old' % (self.Name,self.Age)
 
    def __del__(self):                          #解构函数，当实例在内存中释放时，才会执行此函数
        print 'I got killed just now...bye...', self.Name
 
p = Person('Alex',29)
p.sayHi()
#del p
print '*'*60
 
p2 = Person('Jack',40)
p2.sayHi()
#del p2
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python person_class5.py 
I am being called right now...
Hi my name is Alex, i am 29 years old
************************************************************
I am being called right now...
Hi my name is Jack, i am 40 years old
I got killed just now...bye... Jack
I got killed just now...bye... Alex

    可以看到程序最后有两行相同内容的输出（除了名字不一样），是因为程序结束时，会把该程序在内存中占用的空间释放，于是执行两次解构函数（因为进行了两次类的实例化），才出现这样的情况为了验证这个结论，将程序代码修改为如下并执行：

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
程序代码如下：
class Person:
    def __init__(self,name,age):
        print 'I am being called right now...'
        self.Name = name
        self.Age = age
 
    def sayHi(self):
        print 'Hi my name is %s, i am %s years old' % (self.Name,self.Age)
 
    def __del__(self):
        print 'I got killed just now...bye...'， self.Name
 
p = Person('Alex',29)
p.sayHi()
del p    #其它不变，只是在做类的另一个实例前，删除该实例
print '*'*60
 
p2 = Person('Jack',40)
p2.sayHi()
#del p2
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python person_class5.py 
I am being called right now...
Hi my name is Alex, i am 29 years old
I got killed just now...bye... Alex
************************************************************
I am being called right now...
Hi my name is Jack, i am 40 years old
I got killed just now...bye... Jack

    上面的程序代码及执行结果便可以说明，解构函数在类完成调用并且在内存中释放时才会执行。


6.类的公有属性与私有属性及其调用

    类的公有属性即是类下的普通方法，这些方法是可以直接被调用的；而类的私有属性只有在类中不同方法之间可以相互调用，一般情况下是不能在类外直接调用的。

    可以看下面一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
程序代码如下：
class Person:
    def __init__(self,name,age):
        print 'I am being called right now...'
        self.Name = name
        self.Age = age
 
    def sayHi(self):
        print 'Hi my name is %s, i am %s years old' % (self.Name,self.Age)
        self.__talk()    #可以引用类中的私有属性
 
    def __talk(self):    #私有属性的定义方法
        print "I'm private..."
 
p=Person('Alex',29)
p.sayHi()
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python private6.py 
I am being called right now...
Hi my name is Alex, i am 29 years old
I'm private...

    如果将代码修改为如下，即在类外调用私有属性：

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
程序代码如下：
class Person:
    def __init__(self,name,age):
        print 'I am being called right now...'
        self.Name = name
        self.Age = age
 
    def sayHi(self):
        print 'Hi my name is %s, i am %s years old' % (self.Name,self.Age)
        self.__talk()
 
    def __talk(self):
        print "I'm private..."
 
p=Person('Alex',29)
p.sayHi()
p.__talk()    #在类外通过普通方式调用类的私有属性
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python private6.py 
I am being called right now...
Hi my name is Alex, i am 29 years old
I'm private...
Traceback (most recent call last):
  File "private6.py", line 17, in <module>
    p.__talk()
AttributeError: Person instance has no attribute '__talk' #会出现找不到类方法的错误提示

    当然可以通过特殊的方法引用类中的私有属性：

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
程序代码：
class Person:
    def __init__(self,name,age):
        print 'I am being called right now...'
        self.Name = name
        self.Age = age
 
    def sayHi(self):
        print 'Hi my name is %s, i am %s years old' % (self.Name,self.Age)
        self.__talk()
 
    def __talk(self):
        print "I'm private..."
 
p=Person('Alex',29)
p.sayHi()
 
print '*'*30
 
p._Person__talk()
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python private6.py 
I am being called right now...
Hi my name is Alex, i am 29 years old
I'm private...
******************************
I'm private...


7.类的继承

    类有分父类和子类，在有多个子类的情况下，子类通过继承父类的属性或方法，就可以节省很多代码空间。可以先看下面一个没有参数传递的类的继承简单例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
程序代码如下：
class person:                #父类
 
    def tell(self, name):
        print 'hi my name is', name
 
class student(person):       #子类，继承父类
 
    def study(sefl):
        print 'I am studying Py right now.'
 
s = student()
 
s.study()
s.tell('MengFanHao') #子类继承父类后便可以直接调用父类的方法
                     #在有多个需要同时执行相同功能的子类情况下，使用类的继承可以节省代码空间
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python cla_with_no_arg9.py 
I am studying Py right now.
hi my name is MengFanHao

    看过上面的例子后，再看下面一个含有参数传递的例子，通过该例子也可以很好地理解前面第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
class SchoolMember:        #父类，学校成员
    school_name = 'Oldboy Linux edu.'    #第一级变量，即类属性
    def __init__(self,name,gender,nationality = 'CN'):    #构造函数
        self.name = name
        self.gender = gender
        self.nation = nationality
 
    def tell(self):    #普通的类方法
        print 'Hi, my name is %s , I am from %s' % (self.name,self.nation)
 
class Student(SchoolMember):    #子类，学生，继承父类学校成员的相关属性
    def __init__(self, Name, Gender, Class, Score, Nation = 'US'): #子类下的方法
        SchoolMember.__init__(self, Name, Gender, Nation） #让父类使用子类传递过去的参数
        self.Class = Class
        self.Score = Score
 
    def payTuition(self, amount):    #子类下的方法
        if amount < 6499:
            print 'Get the fuck off...'
        else:
            print 'Welcome onboard!'
 
class Teacher(SchoolMember):    #子类，老师，继承父类学校成员的相关属性
    def __init__(self, Name, Gender, Course, Salary, Nation = 'FR'):
        SchoolMember.__init__(self, Name, Gender, Nation)
        self.course = Course
        self.Salary = Salary
 
    def teaching(self):
        print 'I am teaching %s, i am making %s per month !' % (self.course, self.Salary)
 
S1 = Student('WangFanHao', 'Male', 'Python', 'C+', 'JP') #实例化一个子类对象，学生
S1.tell()    #直接继承父类中的tell()方法
S1.payTuition(4999)    #使用子类Student()自身中的类方法
print S1.school_name   #直接继承父类的一个属性   
 
print '*'*60
 
S2 = Student('ShitTshirt', 'Male', 'Linux', 'B')
S2.tell()
S2.payTuition(6500)
#S2.age = 29
#print S2.age
 
print '*'*60
 
T1 = Teacher('Alex', 'Male', 'C++', 5000)   #实例化一个子类对象，学生
T1.tell()            #直接继承父类中的tell()方法
T1.teaching()        #直接继承父类的一个属性
 
print 'S1.name:', S1.name    #测试用，观察输出结果
print 'S2.name:', S2.name
print 'T1.name:', T1.name
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python class_continue8.py
Hi, my name is WangFanHao , I am from JP
Get the fuck off...
Oldboy Linux edu.
************************************************************
Hi, my name is ShitTshirt , I am from US
Welcome onboard!
************************************************************
Hi, my name is Alex , I am from FR
I am teaching C++, i am making 5000 per month !
S1.name: WangFanHao
S2.name: ShitTshirt
T1.name: Alex 

    通过上面的例子便可以很好地理解类的继承的作用了，即如果需要在多个子类中执行相同的代码功能时，就可以通过类的继承来节省代码空间。


8.类的属性修改：setattr()，delattr()与getattr()

    以上面程序为例，做如下的演示：

首先在交互器中导入该类：

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
>>> import class_continue8
Hi, my name is WangFanHao , I am from JP
Get the fuck off...
Oldboy Linux edu.
************************************************************
Hi, my name is ShitTshirt , I am from US
Welcome onboard!
************************************************************
Hi, my name is Alex , I am from FR
I am teaching C++, i am making 5000 per month !
S1.name: WangFanHao
S2.name: ShitTshirt
T1.name: Alex
>>> import tab
>>> class_continue8.
class_continue8.S1                 class_continue8.__hash__(
class_continue8.S2                 class_continue8.__init__(
class_continue8.SchoolMember       class_continue8.__name__
class_continue8.Student            class_continue8.__new__(
class_continue8.T1                 class_continue8.__package__
class_continue8.Teacher            class_continue8.__reduce__(
class_continue8.__class__(         class_continue8.__reduce_ex__(
class_continue8.__delattr__(       class_continue8.__repr__(
class_continue8.__dict__           class_continue8.__setattr__(
class_continue8.__doc__            class_continue8.__sizeof__(
class_continue8.__file__           class_continue8.__str__(
class_continue8.__format__(        class_continue8.__subclasshook__(
class_continue8.__getattribute__(


setattrr()：在类中添加属性

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
1.子类有的属性，属于该子类的对象没有定义，会继承该属性；如果有定义，则不会继承子类的该属性
>>> class_continue8.Student.age    #原来Student类中并没有age属性
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: class Student has no attribute 'age'
>>> setattr(class_continue8.S)
class_continue8.S1            class_continue8.SchoolMember
class_continue8.S2            class_continue8.Student
>>> setattr(class_continue8.Student,'age',29)    #在Student类中添加age属性
>>> class_continue8.Student.age    #再次查看age属性
29
>>> class_continue8.S1.age    #S1与S2作为Student类的实例化对象，也会有age属性
29
>>> class_continue8.S2.age
29
>>> setattr(class_continue8.S1,'age',26)
>>> class_continue8.S1.age        #此时S1对象有定义，因此不会继承所属子类的该属性
26
 
2.子类的对象有的属性，但在其所属子类没有定义，则该子类不会反继承该属性
>>> setattr(class_continue8.S1,'tuition',5000)    #如果仅仅是在对象中添加tuition属性
>>> class_continue8.Student.age
29
>>> class_continue8.Student.tuition    #则在S1对象所属的类Student中并不会有tuition属性
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: class Student has no attribute 'tuition'
>>> class_continue8.S1.tuition
5000
>>> class_continue8.S2.tuition        #因此S2对象也不会有该属性
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: Student instance has no attribute 'tuition'
 
3.父类有的属性，子类中没有定义，则子类会继承该属性；如果子类中有定义，则不会继承
>>> setattr(class_continue8.SchoolMember,'name','Python')    #在子类在没有定义
>>> class_continue8.SchoolMember.name
'Python'
>>> class_continue8.Student.name    #因此子类会继承该属性
'Python'
>>> setattr(class_continue8.SchoolMember,'age',25)    #在父类中定义子类有定义的属性
>>> class_continue8.SchoolMember.age
25
>>> class_continue8.Student.age    #子类已经定义了age属性，因此不会再继承父类的该属性
29

    从上面的例子可以看出，对于父类、子类、对象，属性的优先级以本地定义的为主，如果本地没有定义，则继承上一级的属性，如果有定义，则使用本地的。


delattr()：删除类中的属性

1
2
3
4
5
6
7
>>> class_continue8.SchoolMember.name
'Python'
>>> delattr(class_continue8.SchoolMember,'name')
>>> class_continue8.SchoolMember.name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: class SchoolMember has no attribute 'name'


getattr()的主要用法如下：

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
程序代码如下：
class person:
 
    def tell(self, name):
        print 'hi my name is', name
 
    def study(sefl):
        print 'I am studying Py right now.'
 
class student(person):
 
    def study(sefl):
        print 'I am studying Py right now.'
 
p = person()
 
vars = ['tell', 'study']
 
v1 = vars[0]
 
getattr(p, v1)('Oldboy')
 
执行情况如下：
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python cla_getattr_with_no_arg10.py 
hi my name is Oldboy

    对于该程序，如果直接使用p.v1('name')来访问类中的方法是不行的，会有如下的提示错误：

1
2
3
4
5
xpleaf@xpleaf-machine:/mnt/hgfs/Python/day4$ python cla_getattr_with_no_arg10.py 
Traceback (most recent call last):
  File "cla_getattr_with_no_arg10.py", line 21, in <module>
    p.v1('Oldboy')
AttributeError: person instance has no attribute 'v1'

    因此getattr()的主要用途就在于有一个类有多个方法时，需要对该类的所有方法都执行一遍，那么可以将类中的方法都写入一个列表中，再通过getattr()和循环的方法来完成，这样就可以节省很多代码空间。




本文转自 xpleaf 51CTO博客，原文链接：http://blog.51cto.com/xpleaf/1699864，如需转载请自行联系原作者

文章标签：
Python
C++
关键词：
Python面向对象编程
技术小阿哥
目录
相关文章
小馒头学Python
|
10天前
|
数据安全/隐私保护 开发者 Python
面向对象编程（OOP）：Python中的抽象与封装
面向对象编程（OOP）：Python中的抽象与封装
小馒头学Python
9 0
TechLead
|
10天前
|
存储 开发者 Python
< Python全景系列-6 > 掌握Python面向对象编程的关键：深度探索类与对象
< Python全景系列-6 > 掌握Python面向对象编程的关键：深度探索类与对象
TechLead
4 0
Python编程站
|
20天前
|
Python
深入Python编程语言 - 理解Python的面向对象编程
深入Python编程语言 - 理解Python的面向对象编程
Python编程站
48 0
JosieBook
|
2月前
|
Python
【Python入门系列】第五篇：Python面向对象编程
在Python中，面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式。它通过将数据和操作封装在对象中，以模拟现实世界的实体和交互。
JosieBook
22 0
全栈若城
|
2月前
|
Python
【从零学习python 】44.面向对象编程中的私有属性和方法
【从零学习python 】44.面向对象编程中的私有属性和方法
全栈若城
13 0
全栈若城
|
2月前
|
Python
【从零学习python 】47. 面向对象编程中的继承概念及基本使用
【从零学习python 】47. 面向对象编程中的继承概念及基本使用
全栈若城
16 0
全栈若城
|
2月前
|
Python
【从零学习python 】50.面向对象编程中的多态应用
【从零学习python 】50.面向对象编程中的多态应用
全栈若城
14 0
全栈若城
|
2月前
|
Python
【从零学习python 】43. Python面向对象编程中的实例属性和类属性
【从零学习python 】43. Python面向对象编程中的实例属性和类属性
全栈若城
23 0
LyShark
|
2月前
|
安全 Python
7.0 Python 面向对象编程
python是一种面向对象的编程语言，面向对象编程（Object-Oriented Programming，OOP）是一种编程思想，其核心概念是“对象”。对象是指一个具有特定属性和行为的实体，而面向对象编程就是通过对这些实体进行抽象、分类、封装和继承等操作，来实现程序的结构和逻辑。在python中，我们可以通过定义类、创建实例和调用方法等方式，来实现面向对象编程的思想，从而编写出更加灵活、可扩展、易维护的程序。
LyShark
19 0
LeapMay
|
2月前
|
数据库 Python
【100天精通python】Day13：面向对象编程_多态和封装，实战模拟电影院的自动售票机选票页面
【100天精通python】Day13：面向对象编程_多态和封装，实战模拟电影院的自动售票机选票页面
LeapMay
37 0
热门文章
最新文章
1
Python pip 源设置成国内源，阿里云源，清华大学源,最方便的方式，都在这里了
2
python 快排模板
3
使用Python绘制多个股票的K线图
4
python实现一个简单的消消乐游戏
5
使用Python编写一个多线程的12306抢票程序
6
Python logging模块怎么使用，你会了吗？
7
如何使用try-except语句处理Python中的异常
8
【python基础知识】10.用Python实现石头剪刀布小游戏-函数实操篇
9
使用python连接MySQL数据库，进行增删改查，实现步骤
10
在Python中如何使用BeautifulSoup进行页面解析
1
Python 布尔类型
12
2
自动群发节日祝福，1行Python代码搞定!
46
3
百度搜索：蓝易云【如何通过Python将JSON格式文件导入redis？】
85
4
百度搜索：蓝易云【Python 使用ConfigParser操作ini配置文件教程。】
77
5
你在开玩笑吧 居然还有人不知道为什么开发Java、Python、PHP程序要配置环境变量 你看完之后不秒懂都不行
18
6
我决定以后一直使用Eclipse了 因为它也可以安装集成PyDec插件来实现Python开发了 哇哈哈哈
31
7
处理不平衡数据的十大Python库
40
8
Python报错ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
16
9
基于大量文件的名称特征自动新建多个文件夹并自动复制对应文件：Python
74
10
Python 中的字符串基础与应用
25
相关产品
云迁移中心
文档详情 产品详情
相关课程
更多
Python 脚本进阶 Python 脚本入门 面向运维的 python 脚本速成-1024程序员节创造营公益课 【科技少年】Python绘画编程第一课 【科技少年】Python基础语法 高校精品课-华东师范大学 - Python数据科学基础与实践
相关电子书
更多
给运维工程师的Python实战课 Python 脚本速查手册 ACE 区域技术发展峰会：Flink Python Table API入门及实践
相关实验场景
更多
搭建Java Web开发环境 Python入门 Python新手入门 Python选择及循环结构 Python新手入门（Anolis OS） Python兴趣案例14个，帮助新手快速上路
推荐文章
更多
重磅来袭！参与评测赢Iphone14 pro！ 文件存储NAS评测征集令！ 招募！寻找技术人的伯乐！ 乘风者计划邀您入驻社区，精彩权益即刻享
下一篇
部署并使用Docker（CentOS 8）