python:类基础

什么是面向对象编程

1、面向对象编程(oop)是一种程序设计思想。oop把对象作为程序的基本单元,一个对象包含数据和操作数据的函数

2、在python中,所有数据类型都被视为对象,也可以自定义对象。自定义对象数据类型就是面向对象中类的概念

 

 

面向对象术语简介

1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

2、方法:类中定义的函数

3、类变量(属性):类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用,类变量也称作属性

4、数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据

5、方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写

6、实例变量:定义在__init__方法中的变量,只作用于当前实例的类

7、继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象

8、实例化:创建一个类的实例,类的具体对象。一个类可以实例化出无数个对象

9、对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法

10、多态:对不同类的对象使用同样的操作

11、封装:对外部世界隐藏对象的工作细节

 

 

1、类提供了一种组合数据和功能的方法。创建一个新类意味着创建一个新的对象类型,从而允许创建一个该类型的新实例

2、每个类的实例可以拥有保存自己状态的属性。一个类的实例也可以有改变自己状态的(定义在类中的)方法

3、Python的类提供了面向对象编程的所有标准特性:
    ⑴类继承机制允许多个基类,派生类可以覆盖它基类的任何方法,一个方法可以调用基类中相同名称的的方法。
    ⑵对象可以包含任意数量和类型的数据
    ⑶和模块一样,类也拥有Python天然的动态特性:它们在运行时创建,可以在创建后修改

 

 

类的定义

python中类的定义语法如下:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>
    

注:
1、python中定义类使用class关键字,class后面紧接类名,类名通常是大写开头的单词

2、类包含属性和方法
    ⑴属性:分为类属性和实例属性
    ⑵方法:即定义在类中的函数(与普通的函数类似)

3、一个对象的特征称为"属性",一个对象的行为称为"方法"。属性在代码层面上来看就是变量,方法实际就是函数,通过调用这些函数来完成某些工作

4、在类中定义方法的形式和函数差不多,但其不称为函数,而是叫方法。方法的调用需要绑定到特定的对象上(通过self.或实例对象名),而函数不需要

 

 

类的使用

例1:

class MyClass:
    """一个简单的类实例"""
    i = 12345#定义一个类属性

    def f(self):#定义一个类方法
        return 'hello world'

x = MyClass()  # 实例化类

# 访问类的属性和方法
print("MyClass 类的属性 i 为:", x.i)
print("MyClass 类的属性 i 为:", MyClass.i)
print("MyClass 类的方法 f 输出为:", x.f())

"""
MyClass 类的属性 i 为: 12345
MyClass 类的属性 i 为: 12345
MyClass 类的方法 f 输出为: hello world
"""

注:
1、在未实例化类时(x = MyClass()前),只是定义了对象的属性和方法,此时其还不是一个完整的对象,将定义的这些称为类(抽象类)。需要使用类来创建一个真正的对象,这个对象就叫做这个类的一个实例,也叫作实例对象(一个类可以有无数个实例)

2、创建一个对象也叫做类的实例化,即x = MyClass()。(此时得到的x变量称为类的具体对象)。注意此时类名后面是跟着小括号的,这跟调用函数一样。另外赋值操作并不是必须的,但如果没有将创建好的实例对象赋值给一个变量,那这个对象就没办法使用,因为没有任何引用指向这个实例。一个类可以实例化出无数个对象

3、如果要调用对象里的方法,就需要判断是在类中调用还是在类外调用:
    ⑴在类中调用类方法:self.方法名(参数)或类名.方法名(self,参数)这个这里只是提一下,可以先不纠结
    ⑵在类外调用类方法:实例对象名.方法名(参数)。这里的例子就是类外调用方法,只是说类方法中没有定义参数。x.f():x为实例对象名,f()为类中定义的方法
    
4、 x.i和MyClass.i都是用于调用类的属性,也就是我们前面所说的类变量;x.f()用于调用类的方法
    ⑴调用类属性可以使用:实例对象名.类属性名或类名.类属性名。虽然这两种方法都可以调用类属性,但是两者在调用使用还是有区别的,后面介绍

5、类中定义方法的要求:在类中定义方法时,第一个参数必须是self,除第一个参数外,类的方法和普通的函数没什么区别,如可以使用默认参数,可变参数,关键字参数和命名关键字参数等
    ⑴虽然在定义方法时会定义一个self参数,但是不管是在类中或是在类外调用方法都不用传递self,其他参数正常传入
    ⑵self参数究竟是什么,这里也可以先不纠结,目前只需要知道定义一个类方法时,第一个参数必须是self,但是在调用类方法时,不需要传递这个self参数

6、类对象(抽象类)支持两种操作:即属性引用和实例化
    ⑴属性引用:方法为类名.类属性名(也可以实例对象名.类属性名)
    ⑵实例化:将一个抽象类实例化成一个实例对象(x = MyClass() )。一个类可以实例化出无数个对象

7、类是一个抽象的概念,对象则是一个实际存在的东西。就像我们说的"狮子",它只是一个抽象的东西,只有具体到狮子这种动物身上它才是实际存在的。在比如设计房子的图纸只能告诉你房子是什么样的,并不是真正的房子,只有通过钢筋水泥建造出来的房子才实际存在,才能住人。
    ⑴"造房子"这个过程就相当于是"实例化类',一个抽象类只有实例化成一个具体的实例对象后,才会有意义

 

 

self是什么:为什么方法中第一个参数必须为self

1、self其实就相当于C++中的this指针

2、如果把类比作图纸,那么由类实例化后的对象才是真正可以住人的房子。根据一张图纸就可以设计出成千上万的房子,他们都长得差不多,但他们都有不同的主人,每个人都只能回自己的家里.....所以self这里就相当于每个房子的门牌号,有了self就可以轻松找到自己房子

3、python中的self参数就是同一个道理,由同一个类可以生成无数对象,当一个对象的方法被调用的时候,对象会将自身的引用作为第一个参数传给该方法,那么python就知道需要操作哪个对象的方法了
4、简单的来说就是:self代表的当前的实例对象本身,这样在调用类方法等时Python就知道当前是哪个实例对象了
    ⑴一个抽象类实例化后,实力对象为a,那么此时self就代表实例对象a
    ⑵一个抽象类实例化后,实力对象为b,那么此时self就代表实例对象b
    
例2:

class Ball:

    def setname(self,name,age):
        self.name = name #这步感觉是将一个方法中的变量变成了一个实例变量
        print(age)

    def kick(self):
        return "我叫%s" % self.name

a = Ball()
b = Ball()
c = Ball()

a.setname("A",1)
b.setname("B",2)
c.setname("C",3)

print(a.kick())
print(b.kick())
print(c.kick())

"""
1
2
3
我叫A
我叫B
我叫C
"""

注:从上面例子可以看出

1、有Ball类生成了三个实例对象a,b,c,这三个对象在调用kick()方法时,是通过self参数去确定究竟当前是哪个对象在调用方法的。因此在写类方法时一定要写self参数且其位置在第一个,在调用时就不需要传入self参数了

2、在方法中定义的参数,一般来说只能在当前方法中使用(作用域)
    ⑴如果想要一个方法中的参数能在其他方法中使用,那么就可以使用"self."来将这个参数变成一个实例变量(实例变量后面介绍,这里主要是遇到了这种写法)
    ⑵name参数:在方法中使用了"self.name = name",这步就相当于是将这个name参数变成了一个实例变量,因此可以在所有方法中使用(感觉这种写法比较少,因为一个实例变量最好直接定义在__init__方法中)
    ⑶age参数:age参数就没有使用name参数那样的写法,仅仅是在setname()方法中定义并使用,因此age参数就只能在setname()方法中使用,而不能在kick()方法中使用,即使他们是在同一个类中(经常遇到的是这种写法)

 

 

类变量和实例变量

1、类变量:是该类所有实例共享的属性和方法(也可以叫"类属性")。类变量是直接定义在类中的,比如例1中的"i = 12345",变量i就是一个类属性,类中的所有方法、实例都可以使用它

2、实例变量:每个实例都独有的数据(也可以叫"实例属性")。实例变量通常是定义在__init__方法中的

3、即某个属性对于每个实例都是独有的,就需要将其定义为实例变量;某个属性是每个实例同共有的就可以定义为类属性

例3:

class Student():
    address = "china"     #定义类变量address

    def __init__(self,name,age):    #定义实例变量age和name
        self.name = name
        self.age = age

    def Info(self,score):#定义在方法中的变量(普通的变量:作用域为这个方法内)
        return "学生来自于%s,名字为%s,年龄为%s,成绩为%s"%(Student.address,self.name,self.age,score)
        #类中访问实例变量:self.实例变量名
        #类中访问类变量:类名.类变量名
        #类中访问方法中的普通变量:直接变量名(且该变量只能在这个方法中使用,不能再其他方法或类外调用)


student = Student("张三",18)  #实例化类
print(student.name) #类外访问实例变量:实例名.实例属性名
print(Student.address)  #类外访问类变量:类名.类属性名(也可以实例名.类属性名)
print(student.Info(98)) #类外访问类方法:实例名.方法名(参数)

#另一个实例对象
student_1 = Student("李四",20)
print(student_1.name)
print(student_1.address)
print(student_1.Info(100))

"""
张三
china
学生来自于china,名字为张三,年龄为18,成绩为98
李四
china
学生来自于china,名字为李四,年龄为20,成绩为100
"""

注:
1、在Student类中,类属性address为所有实例所共享;实例属性name和age每个student的实例独有(每个实例有不同的name和age)
    ⑴类属性:实例对象student和student_1拥有一样的address属性
    ⑵实例属性:实例对象student和student_1拥有不一样的name和age属性(每个实例独有的属性)
    
2、调用类属性:
    ⑴类中访问类变量:类名. 类属性名
    ⑵类外访问类变量:类名.类属性名或实例名.类属性名

3、调用实例属性:
    ⑴类中访问实例变量:self.实例变量名
    ⑵类外访问实例变量:实例名.实例属性名

4、调用类方法:
    ⑴类中访问类方法:self.方法名(参数)或类名.方法名(self,参数),这个例子中未涉及到
    ⑵类外访问类方法:实例名.方法名(参数)
    
5、类变量直接定义在类中,实例变量需要定义在__init__方法中
    ⑴定义类变量:类变量直接写就好了,定义一个变量然后赋值,相当于定义一个普通的变量
    ⑵定义实例变量:需要使用self来将变量绑定到实例上。self.name = name,表示将外部传来的参数name的值赋值给Student当前实例对象自己的实例变量name
    ⑶因为实例属性是每个实例独有的,而self表示实例对象本身,因此就需要将变量用self绑定到每个实例
    
6、类中存在__init__方法时,在实例化类时需要传入参数(实例变量的实参),在调用类的方法时也需要传入方法的实参(方法中存在形参时)

 

 

类对象和实例对象

类对象

Python中一切皆对象;类定义完成后,会在当前作用域中定义一个以类名为名字,指向类对象的名字

例4:

class Dog:
    pass

注:

1、上面例子中创建了一个Dog抽象类,定义好类后会在当前作用域定义名字Dog,指向类对象Dog

2、总的来说,类对象仅支持两个操作
    实例化:使用instance_name = class_name()的方式实例化,实例化操作创建该类的实例
    属性引用:使用class_name.attr_name的方式引用类属性。(类名.属性名)

 

实例对象

1、实例对象是类对象实例化的产物,实例对象仅支持一个操作:属性引用

2、属性引用:与类对象属性引用的方式类似,使用instance_name.attr_name的方式。(实例对象名.属性名)

 

 

属性绑定

1、在定义类时,通常我们说的定义属性,其实是分为两个方面的:类属性绑定、实例属性绑定(也就是定义类属性或实例属性)

2、用绑定这个词更加确切;不管是类对象还是实例对象,属性都是依托对象而存在的。我们说的属性绑定,首先需要一个可变对象,才能执行绑定操作,使用objname.attr = attr_value的方式,为对象objname绑定属性attr。这分两种情况:
    ⑴若属性attr已经存在,绑定操作会将属性名指向新的对象
    ⑵若不存在,则为该对象添加新的属性,后面就可以引用新增属性


类属性绑定

Python作为动态语言,类对象和实例对象都可以在运行时绑定任意属性。因此,类属性的绑定发生在两个地方
    ⑴类定义时
    ⑵运行时任意阶段
例5:

class Dog:

    kind = 'canine'

Dog.country = 'China'

print(Dog.kind, ' - ', Dog.country)  # 输出: canine  -  China
del Dog.kind
print(Dog.kind, ' - ', Dog.country)  #由于上一行删除的kind属性,因此输出为AttributeError: type object 'Dog' has no attribute 'kind'

注:
1、在类定义中,类属性的绑定并没有使用objname.attr = attr_value的方式,这是一个特例,其实是等同于后面使用类名绑定属性的方式

2、因为是动态语言,所以可以在运行时增加属性,删除属性

 

实例属性绑定

与类属性绑定相同,实例属性绑定也发生在两个地方:类定义时、运行时任意阶段
例6:

class Dog:

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

dog = Dog('Lily', 3)
dog.fur_color = 'red' #为实例对象dog增加一个fur_color属性

print('%s is %s years old, it has %s fur' % (dog.name, dog.age, dog.fur_color))

#上面代码的输出结果为:Lily is 3 years old, it has red fur

注:
1、语句self.name = name,self.age = age以及后面的语句dog.fur_color = 'red'为实例dog增加三个属性name, age, fur_color。

2、Python类实例有两个特殊之处:
    ⑴__init__在实例化时执行
    ⑵Python实例对象调用方法时,会将实例对象作为第一个参数传递因此,__init__方法中的self就是实例对象本身,这里是dog

 

 

属性引用

属性的引用与直接访问名字不同,不涉及到作用域

 

类属性引用

类属性的引用,肯定是需要类对象的,属性分为两种:数据属性、函数属性。只是通常很少有引用类函数属性的需求

例7:数据属性引用很简单

class Dog:

    kind = 'canine'

Dog.country = 'China'

print(Dog.kind, ' - ', Dog.country)  # output: canine  -  China


例7_1:

class Dog:
    kind = 'canine'

    def tell_kind(self):
        print(Dog.kind)

    def info(self):
        return self.tell_kind() #类中调用类方法

dog = Dog()
dog.tell_kind()  # Output: canine
dog.info()  # Output: canine

 

实例属性引用

使用实例对象引用属性稍微复杂一些,因为实例对象可引用类属性以及实例属性。但是实例对象引用属性时遵循以下规则:
    ⑴总是先到实例对象中查找属性,再到类属性中查找属性
    ⑵属性绑定语句总是为实例对象创建新属性,属性存在时,更新属性指向的对象

例8:

class Dog:

    kind = 'canine'
    country = 'China'

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

dog = Dog('Lily', 3, 'Britain')
print(dog.name, dog.age, dog.kind, dog.country)   #output:Lily 3 canine Britain

注:
类对象Dog与实例对象dog均有属性country,按照规则,dog.country会引用到实例对象的属性;但实例对象dog没有属性kind,按照规则会引用类对象的属性。
 

例9:

class Dog:

    kind = 'canine'
    country = 'China'

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

dog = Dog('Lily', 3, 'Britain')

print(dog.name, dog.age, dog.kind, dog.country)   # Lily 3 canine Britain
print(dog.__dict__)                               # {'name': 'Lily', 'age': 3, 'country': 'Britain'}

dog.kind = 'feline'

print(dog.name, dog.age, dog.kind, dog.country)   # Lily 3 feline Britain
print(dog.__dict__)                               # {'name': 'Lily', 'age': 3, 'country': 'Britain', 'kind': 'feline'}
print(Dog.kind)                                   # canine (没有改变类属性的指向)

注:
使用属性绑定语句dog.kind = 'feline',按照规则,为实例对象dog增加了属性kind,后面使用dog.kind引用到实例对象的属性。这里不要以为会改变类属性Dog.kind的指向,实则是为实例对象新增属性,可以使用查看__dict__的方式证明这一点。

 

 

可变类属性引用

例10:

class Dog:
    
    tricks = []

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

    def add_trick(self, trick):
        self.tricks.append(trick)

d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
print(d.tricks)             output:# ['roll over', 'play dead']

注:

语句self.tricks.append(trick)并不是属性绑定语句,因此还是在类属性上修改可变对象

 

 

类、类对象、实例对象

例11:

class C:
    count = 0
a = C()
b = C()
c = C()
print(a.count,b.count,c.count)   #output:0,0,0

a.count += 10   #实例对象调用类属性
print(a.count,b.count,c.count)   #output:10,0,0

C.count += 100  #类对象调用类属性
print(a.count,b.count,c.count)   #output:10 100 100

#print(count)   #name 'count' is not defined,不能直接访问类属性,具体访问方法参考前面的属性访问

注:

1、对实例对象的count属性进行赋值后,就相当于覆盖了类对象C的count属性,如果没有赋值覆盖,那么引用的就是类对象的count属性

2、即找属性的顺序为:现在当前实例中找,有就用当前实例中的,如果没有就找类中的

3、如果属性的名字跟方法相同,属性会覆盖方法

4、类变量和实例变量的区别在于:类变量是所有对象共有,其中一个对象将它值改变,其他对象得到的就是改变后的结果;而实例变量则属对象私有,某一个对象将其值改变,不影响其他对象

 

 

拓展:python中的self参数

例12:定义任意一个类:

class Student(object):
    pass
student = Student()

注:
由于类起到模板的作用,因此,可以在创建实例的时候,把我们认为必须绑定的属性强制填写进去(绑定实例变量)。这里就用到Python当中的一个内置方法__init__方法,例如在Student类时,把name、score等属性绑上去

 

例12_1:

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

>>>student = Student("Hugh", 99)
>>>student.name
"Hugh"
>>>student.score
99

注:        

1、__init__方法的第一参数永远是self,表示创建的类实例本身,因此,在__init__方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身

2、有了__init__方法,在创建实例的时候(类实例化),就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器会自己把实例变量传进去

3、这里self就是指类实例本身,self.name就是当前student实例对象的name属性,是该student实例对象独有的

4、name是外部传来的参数,不是Student类自带的。故,self.name = name的意思就是把外部传来的参数name的值赋值给student实例对象自己的实例属性name(只是实例变量的名字和形参的一样而已)
 

例12_2:

class Student(object):
    def __init__(self, name_1, score_1):
        self.name = name_1
        self.score = score_1

student = Student("zh",12)
print(student.name)
print(student.score)

"""
zh
12
"""

注:

这个例子中就特意把实例变量名和形参名定义成不一样了:self.name = name_1
    ⑴name_1相当于是占位的形参,只是方便外部向类中传递参数(给实例变量传递值),没有什么实际意义
    ⑵self.name中的name才是真正的实例变量了,是每个实例独有的属性
    ⑶只是说这两个变量表示的属性意义是一样的,因此更多的是将两个写成一样的名字。不然,有一个实例属性是"名字",形参用的是"a",实例属性用的是"name",这样就看起来比较奇怪的,都表示的是"名字"却用了不一样的名字
 

例12_3:

class Person:
    def __init__(self, name, job=None, pay=10):
        self.name = name
        self.job = job
        self.pay = pay

    def getRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
        return self.pay


p = Person("xiaoming", "jixie")
print(p.getRaise(0.8))  # output:18

注:
self是指当前被调用的对象,对的,就是上边刚被你实例化的对象p。当你需要调用当前对象(实例对象)的方法或者属性时,要用self.来进行调用(类中调用实例属性或方法:self.)
 

例13:

class CC:
    def setXY(self,x,y):
        self.x = x
        self.y = y
    def printXY(self):
        print(self.x ,self.y)

dd = CC()
dd.setXY(4,5)

注:
self参数:当实例对象dd去调用setXY方法的时候,它传入的第一个参数就是dd,那么self.x = 4,self.y = 5也就相当于dd.x = 4,dd.y = 5,所以你在实例对象,甚至类对象中都看不到x和y,因为这两个属性是只属于实例对象dd的
 

例14:

class TestClass(object):
    val1 = 100

    def __init__(self):
        self.val2 = 200

    def fcn(self, val=400):
        val3 = 300
        
        self.val4 = val
        self.val5 = 500


if __name__ == '__main__':
    inst = TestClass()

    print(TestClass.val1)
    print(inst.val1)
    print(inst.val2)
    #print(inst.val3)
    #val3为局部变量,无法在函数为调用'TestClass' object has no attribute 'val3'
    #print(inst.val4)
    #print(inst.val5)

注:
1、val1是类变量,可以由类名直接调用,也可以有对象来调用;

2、val2是实例变量,可以由类的对象来调用,这里可以看出成员变量一定是以self.的形式给出的,因为self的含义就是代表实例对象

3、val3既不是类变量也不是实例变量,它只是函数fcn内部的局部变量

4、val4和val5也都不是实例变量,虽是以self.给出,但并没有在构造函数中初始化

 

 

在类方法中也可以调用其他方法

例15:

class Dog():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def get_dog_information(self):
        dog_information = "name is {0},age is {1}".format(self.name,self.age)
        return dog_information

    def get_dog_speak(self,love):
        dog_speak = self.get_dog_information() + love
        return dog_speak

dog = Dog("jake",13)
print(dog.get_dog_speak("swimming"))

#name is jake,age is 13swimming

注:在上面例子中
在get_dog_information()方法中调用了get_dog_information(),且get_dog_information()方法前加了self参数,该参数的意义与其他self的意思一样,都是代表实际本身

 

 

已标记关键词 清除标记
【为什么学PythonPython 是当今非常热门的语言之一,2020年的 TIOBE 编程语言排行榜中 ,Python名列第一,并且其流行度依然处在上升势头。 在2015年的时候,在网上还经常看到学Python还是学R的讨论,那时候老齐就选择了Python,并且开始着手出版《跟老齐学Python》。时至今日,已经无需争论。Python给我们带来的,不仅仅是项目上的收益,我们更可以从它“开放、简洁”哲学观念中得到技术发展路线的启示。 借此机会,老齐联合CSDN推出了本课程,希望能影响更多的人走进Python,踏入编程的大门。 【课程设计】 本课程共包含三大模块: 一、基础知识篇 内置对象和基本的运算、语句,是Python语言的基础。本课程在讲解这部分知识的时候,不是简单地将各种知识做简单的堆砌,而是在兼顾内容的全面性的同时,更重视向学习者讲授掌握有关知识的方法,比如引导学习者如何排查错误、如何查看和理解文档等。   二、面向对象篇 “面向对象(OOP)”是目前企业开发主流的开发方式,本课程从一开始就渗透这种思想,并且在“函数”和“”的学习中强化面向对象开发方式的学习——这是本课程与一般课程的重要区别,一般的课程只在“”这里才提到“对象”,会导致学习者茫然失措,并生畏惧,乃至于放弃学习。本课程则是从开始以“润物细无声”的方式,渗透对象概念,等学习到本部分的时候,OOP对学习者而言有一种“水到渠成”的感觉。   三、工具实战篇 在项目实战中,除了前述的知识之外,还会用到很多其他工具,至于那些工具如何安装?怎么自己做工具?有那些典型工具?都是这部分的内容。具体来说,就是要在这部分介绍Python标准库的应用以及第三方包的安装,还有如何开发和发布自己的工具包。此外,很多学习Python的同学,未来要么从事数据科学、要么从事Web开发,不论哪个方向,都离不开对数据库的操作,本部分还会从实战的角度,介绍如何用Python语言操作常用数据库。
©️2020 CSDN 皮肤主题: 创作都市 设计师:CSDN官方博客 返回首页