面向对象编程

与面向过程对比

• 1、面向过程编程：
  核心是过程二字，过程指的是做事的步骤，即先干啥、再干啥、后干啥
  基于该思想编写程序就好比在涉及一条条的流水线

  优点：复杂的问题流程化、进而变得简单化
  缺点：扩展性差

• 2、面向对象编程：
  核心是对象二字，对象就是一个用来盛放相关数据与相关功能的容器

  优点：程序解耦合强，扩展性高
  缺点：比面向过程更复杂

代码逻辑与语法

对象是数据与功能的集合体，而类则对象之间相同数据与功能的集合体：

有如下各种对象的数据

对象1：

# 学生1的数据
name = "egon"
age = 18
gender = "male"

对象2：

# 学生2的数据
name = "王三炮"
age = 19
gender = "female"

对象3：

# 学生3的数据
name = "李大炮"
age = 20
gender = "male"

学生类（共同属性）：

# 学生对象相同的数据
school = "上海校区"
# 学生对象相同的功能
print('选课功能')

第一步：定义类

在程序必须先定义类：是申请内存空间，把对象之间相同的数据与功能存起来

• 类在定义时就会立即执行类体代码，会产生类的名称空间，然后类名指向该名称空间

class Student:
# 学生对象相同的数据
school = "上海校区"
# 学生对象相同的功能
def choose_course(self):
print('正在选课')

第二步：调用类来产生对象

然后调用类来产生对象，调用类的过程又称之为实例化

• 调用类的本质：就是产生一个与类相关联子空间

stu1 = Student()
stu2 = Student()
stu3 = Student()

对象的属性操作

stu1.name = "egon"
stu1.age = 18
stu1.gender = "male"
stu2.name = "王三炮"
stu2.age = 19
stu2.gender = "female"
stu3.name = "李大炮"
stu3.age = 20
stu3.gender = "male"

• 这儿的第三步与第二步不难发现写了许多重复代码，接下来开始简化代码至最优解

最优解代码简化

第一步，定义类的简化

class Student:
school = "上海校区"
#
对应对象,"egon",18,"male"
def __init__(self, x, y, z):
self.name = x
# 对应对象.name="egon"
self.age = y
# 对应对象.age=18
self.gender = z
# 对应对象.gender="male"
# 该函数内可以有任意代码，但是该函数不能返回非None值
# 返回非None值时会使
#
stu1
def choose_course(self):
print('%s 正在选课' %self.name)
def func(self,x,y):
print(self.name,x,y)

第二步，调用类的简化

1、会先创造一个与类相关联的子空间，也就对象=》空对象
2、自动触发类内__init__(空对象,“egon”,18,“male”)
3、返回一个初始化好的对象，我们可以赋值给一个变量名

stu1 = Student("egon",18,"male")
stu2 = Student("王三炮",19,"female")
stu3 = Student("李大炮",20,"male")

类属性操作：类与对象都可以通过 . 来访问属性完成增删改查的操作：

访问类的数据属性的语法

# 修改类属性
Student.school="xxx"
# 定义类的新属性
Student.xxx=111

访问类的函数属性：它就是一个普通函数，该传几个参数就传几个参数

print(Student.choose_course)
Student.choose_course(stu1)

对象属性操作：对象.属性，会先从对象自己的空间里找，没有话去类中找

类中的定义的数据属性为了给对象用的，而且所有对象共享的，大家访问的都是同一个地址

修改类的数据属性，所有对象都会跟着改

类中的定义的函数属性，类可以调用但就是一个普通函数，而类中函数通常都是为对象

准备的，也就是说是给对象用的，如何给对象用？绑定给对象

print(Student.choose_course)
print(stu1.choose_course)
stu1.choose_course() # choose_course(stu1)

内置函数

eval()：将字符串中的值取出，并当作代码运行

案例：将文件中的‘字典’取出并运行

dic={"k1":111}
with open('a.txt',mode='wt',encoding='utf-8') as f:
f.write(str(dic))
with open('a.txt',mode='rt',encoding='utf-8') as f:
line=f.read() # line="{'k1': 111}"
# print(type(line))
line=eval(line)
print(line['k1'])

frozenset()：冰冻集合：使集合进入无法被删改的冰冻模式

pow()：将传入的三个数a,b,c进行a**b%c的运算，数字c默认为0

reversed()：传入的数列，并返回一个反转顺序后的迭代器

round()：四舍五入 (n.5 n为偶数则舍去 n.5 n为奇数，则进一!)

slice()：将切片的首尾步长存成一个变量名，并可以直接代入切片[]中使用（了解即可）

s=slice(0,5,2)
l=[111,222,333,44,555,666,777,888]
print(l[s]) # 0 2 4

sorted()：将序列以自定义的顺序进行排列

sorted更加深入的分析介绍.
语法：

dic={
'zegon':3000,
"lxx":2000,
'axx':4000
}
res=sorted(dic,key=lambda x:dic[x],reverse=True)

sum()：计算一个序列的和

zip()：将多个可迭代对象中的值,一个一个拿出来配对组成元组放入迭代器中，不能匹对的多余值会被舍弃

zip更加深入的分析介绍.

msg={"name":"egon"}
l=[111,222,333]
res=zip(msg,l)
print(list(res))

最后

以上就是温婉钢笔为你收集整理的python学习 day18_面向对象，内置函数面向对象编程内置函数的全部内容，希望文章能够帮你解决python学习 day18_面向对象，内置函数面向对象编程内置函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。