🤵‍♂️ 个人主页: @Flyme awei 个主页
👨‍💻 作者简介：Python领域新星创作者。
🐋 希望大家多多支持😘一起进步呀！
📝 如果文章对你有帮助的话，欢迎评论💬点赞👍收藏📂加关注

前言

  今天是《CSDN21天学习挑战赛》的第16天
  上一节学习了Python的异常处理机制
  今天将Python基础语法的类和对象

活动地址：CSDN21天学习挑战赛

Python类和对象

一、两大编程思想

1.面向过程

面向过程:事物比较简单，可以用线性思维取解决（宏观上）

2.面向对象

面向对象:事物比较复杂，使用简单线性思维无法解决（细节上）

共同点:面向过程和面向对象都是解决实际问题的一种思维方式

二者相辅相成，并不是独立的,解决复杂问题，通过面向对象便于我们从宏观上把握事物之间复杂关系，方便我们分析整个系统；具体到微观操作，仍然使用面向过程来处理

二、类和对象

1.类

类(class):多个类似事物组成的群体统称，能够帮我们快速理解和判断事物的性质。

数据类型:
1.不同数据类型属于不同的类
2.使用内置函数type查看数据类型

2.对象

对象(object)：类的具体化 Python中一切皆对象，创建对象称为类的实例化

3.类的创建

创建类的语法：

class 类名:
    pass
1
2

类的组成:

1. 类属性 类中方法外的变量，被该类的所有对象所共享
2. 实例方法 方法必须有第一个形参，通常叫做self
3. 静态方法 使用@staticmethod修饰，使用类名直接访问的方法
4. 类方法 使用@calassmethod修饰，使用类名直接访问的方法

类的创建：

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 21:24

# 类的创建
class Student:  # Student 类名 由一个或多个单词组成，每个单词首字母大写，其余字母小写  Student称为类对象
    native_pace = '天津'  # 类属性
    name = '李华'  # 直接写在类里的变量（类中方法外的变量），称为 类属性：类中方法外的变量，被该类的所有对象所共享
    age = 30  # 类属性

    def __init__(self, name, age):  # 初始化方法方法
        self.name = name  # self.name 称为实例属性，进行了一次赋值操作，将局部变量name的值赋给实例属性
        self.age = age

    def eat(self):  # 实例方法  方法必须有第一个形参，通常叫做 'self'
        print('学生在吃饭')

    @staticmethod  # 静态方法
    def se():  # 在静态方法中不能写 self
        print('静态方法')

    @classmethod  # 类方法
    def cm(cls):
        print('类方法')

# Python中一切皆对象，类Student也是对象
print(id(Student))  # 有内存空间
print(type(Student))  # 类型
print(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

4.对象的创建

对象的创建又称类的实例化
意义:有了实例 就可以调用类中的内容

语法:

实例名(对象名) = 类名()
1

# 创建对象
stu1 = Student('张三', 20)  # # 创建Student类的对象  stu1叫做实例对象
# 对象三要素
print(id(stu1))  # id标识
print(type(stu1))  # type类型
print(stu1)  # value值
1
2
3
4
5
6

5.方法调用

类属性，类方法，静态方法都是使用类名.方法名调用
实例方法采用对象名.方法名调用

# 调用方法
stu1.eat()  # 对象名.方法名  调用Student类中的eat方法
print(stu1.name)
print(stu1.age)
stu1.eat()  # 对象名.方法()   stu1-->实际上就是方法定义处的self  调用Student类中的eat方法

print('----------类属性的使用方式----------')
print(Student.name)
stu2 = Student('张三', 20)
stu3 = Student('李四', 20)
print(Student.native_pace)
Student.native_pace = '吉林'
print(stu2.native_pace)
print(stu3.native_pace)
print(stu2.name, stu2.age)
print(stu3.name, stu3.age)

print('----------类方法的使用方式----------')
Student.cm()

print('----------静态方法的使用方式----------')
Student.se()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6.为对象动态绑定属性和方法

动态绑定属性：对象名.属性 = "值"
动态绑定方法：对象名.方法名 = 方法名

# -*- coding: utf-8 -*-
# @File  : 动态绑定属性和方法.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 22:25


class Student:
    def __init__(self, name, age):  # 初始化方法
        self.name = name  # 将局部变量 name的值赋给实例属性self.name,为所有对象所共享
        self.age = age  # 局部变量 age的值赋给实例属性self.age

    def eat(self):  # 实例方法
        print("{}在吃饭".format(self.name))


# 创建对象
stu1 = Student('张三', 18)
stu2 = Student('李四', 20)

print(id(stu1))  # 2502200745408
print(id(stu2))  # 2502201262576

print("------------为对象stu1动态绑定性别属性----------")
stu1.gender = '女'
print(stu1.name, stu1.age, stu1.gender)  #张三 18 女
print(stu2.name, stu2.age)  # 李四 20

stu1.eat()
stu2.eat()


def fun():  # 在类外面定义函数fun
    print('定义在类外的称为函数')


print("-----------为stu1动态绑定方法-----------")
stu1.fun = fun
stu1.fun()
# stu2.fun()

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

三、总结

1.编程界两大思想

1. 面向过程
2. 面向对象

2.类对象class

1.类属性 类中方法外的变量，被该类的所有对象所共享
2.实例方法 方法必须有第一个形参，通常叫做self
3.静态方法 使用@staticmethod修饰，使用类名直接访问的方法
4.类方法 使用@calassmethod修饰，使用类名直接访问的方法

3.实例对象

c = 类名() # 创建实例对象c
动态绑定属性
动态绑定方法