一.面向对象编程

面向过程编程与面向对象编程

1.面向过程编程:

核心是过程2字,过程指的是做事的步骤,即先干啥,在干啥,后干啥
基于该思想编写程序就好比在设计一条条的流水线优点:复杂的问题流程化,简单化
缺点:扩展性差

2.面向对象编程:

核心是对象2字,对象就是一个用来盛放相关数据与功能的容器优点:程序耦合强,扩展性高
缺点:比面向过程更复杂

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

对象1:#学生1的数据name = 'egon'age = 18gender = 'male'
对象2:#学生2的数据name = '王三炮'age = 19gender = 'female'
对象3:#学生3的数据name = '李大炮'age = 20gender = 'male'
学生类#学生对象相同的数据school = '上海校区'# 学生对象相同的功能选课功能

类与对象

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

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

class Student:# 学生对象相同的数据school = '上海校区'# 学生对象相同的功能def choose_course(self):print('正在选课')# print('<=====>') # 在调用之前运行一下我们会发现这行代码运行了
# print(Student.__dict__)

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

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

选课案例:

class Student:school = "上海校区"def choose_course(self):print('正在选课')stu1 = Student()
stu2 = Student()
stu3 = Student()
# print(stu1.__dict__) # ==>{}
# print(stu2.__dict__) # ==>{}
# print(stu3.__dict__) # ==>{}# 非常麻烦的写法
# stu1.__dict__['name'] = 'egon'
# stu1.__dict__['age'] = 18
# stu1.__dict__['gender'] = 'male'# 可以这样写
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'
# print(stu1.__dict__) #{'name': 'egon', 'age': 18, 'gender': 'male'}
# print(stu2.__dict__) #{'name': '王三炮', 'age': 19, 'gender': 'female'}
# print(stu3.__dict__) #{'name': '李大炮', 'age': 20, 'gender': 'male'}# print(stu1.name)  # egon
# print(stu1.age)   # 18
# print(stu1.gender) # male
# print(stu1.school) # 上海校区
# print(stu1.choose_course) # 会打印绑定的方法选课功能的内存地址def func(stu1):print(stu1.name)print(stu1.age)print(stu1.gender)print(stu1.school)print(stu1.choose_course)

二. __init__方法

选课案例改进1:

class Student:school = '上海校区'def choose_course(self):print('正在选课')stu1 = Student()
stu2 = Student()
stu3 = Student()def init(obj,x,y,z):obj.name = xobj.age = yobj.gender = zinit(stu1,'egon',18,'male')
init(stu2,'王三炮',19,'female')
init(stu3,'李大炮',20,'male')print(stu1.__dict__) #{'name': 'egon', 'age': 18, 'gender': 'male'}
print(stu2.__dict__) #{'name': '王三炮', 'age': 19, 'gender': 'female'}
print(stu3.__dict__) #{'name': '李大炮', 'age': 20, 'gender': 'male'}

选课案例改进2:

class Student:school = '上海校区'#           空对象,'egon',18,'male'def __init__(self,x,y,z):self.name = x  # 空对象.name='egon'self.age = y   # 空对象.age=18self.gender = z # 空对象.gender='male'print('======>')#该函数内可以有任意代码,但是该函数不能返回非None值# return 123  报错 不能返回非None值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')

类属性操作:

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

class Student:school = "上海校区"def __init__(self, x, y, z):self.name = xself.age = yself.gender = zdef choose_course(self):print('%s 正在选课' %self.name)def func(self,x,y):print(self.name,x,y)stu1 = Student("egon",18,"male")
stu2 = Student("王三炮",19,"female")
stu3 = Student("李大炮",20,"male")print(Student.__dict__)
#1.访问类的数据属性
# Student.school='xxx'
# print(Student.school)  # xxx# Student.xxx = 111   # 在类空间增加数据
# print(Student.__dict__)
# del Student.xxx     # 在类空间删除数据
# print(Student.__dict__)#2.访问类的函数属性:它就是一个普通函数,该传几个参数就传几个参数
print(Student.choose_course)
Student.choose_course(stu1) #egon 正在选课
Student.choose_course(stu2) #王三炮 正在选课
Student.choose_course(stu3) #李大炮 正在选课

对象属性操作:

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

class Student:school = "上海校区"def __init__(self, x, y, z):self.name = xself.age = yself.gender = zdef choose_course(self):print('%s 正在选课' %self.name)def func(self,x,y):print(self.name,x,y)stu1 = Student("egon",18,"male")
stu2 = Student("王三炮",19,"female")
stu3 = Student("李大炮",20,"male")# 1.类中定义的数据属性为了给对象用的,而且所有对象共享的,大家访问的都是同一个地址
# print(id(Student.school))  # 1678873462128
# print(id(stu1.school))   # 1678873462128
# print(id(stu2.school))   # 1678873462128
# print(id(stu3.school))   # 1678873462128
#
# Student.school = 'XXX' # 修改类的数据属性,所有对象都会跟着改
# print(stu1.school)  # XXX
# print(stu2.school)  # XXX
# print(stu3.school)  # XXXstu1.school='YYY'   # 只是在stu1这个子空间做了增加操作
print(stu1.__dict__) # {'name': 'egon', 'age': 18, 'gender': 'male', 'school': 'YYY'}
print(stu1.school) # YYYprint(Student.school) #上海校区
print(stu2.school)  #上海校区
print(stu3.school)  #上海校区# 2.类中的定义的函数属性,类可以调用但就是一个普通函数,而类中函数通常都是为对象
# 准备的,也就是说是给对象用的,如何给对象用? 绑定给对象print(Student.choose_course)
print(stu1.choose_course)stu1.choose_course() #choose_course(stu1) =>egon 正在选课
stu2.choose_course() #choose_course(stu2) =>王三炮 正在选课
stu3.choose_course() #choose_course(stu3) =>李大炮 正在选课

三.内置函数

1.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'])

2.frozenset():返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

s = frozenset({1,2,3})
print(s)

3.pow():计算x的y次方，如果z存在，则再对结果进行取模，其结果等于pow(x,y) %z

print(pow(x,y,z))
print(pow(10,3,3)) # 10 ** 3 % 3

4.reversed():返回一个反转的序列

l = [111,'aaa',333]
res = reversed(l) #res是一个迭代器
for x in res:print(x)l=list(reversed(l)) # 将迭代器中的值一个个添加进列表
print(l)

5.round():返回浮点数x的四舍五入值,小数点后一位小于等于5舍去,大于5进1

print(round(x))
print(round(4.6))  #5
print(round(4.7))  #5
print(round(4.4))  #4
print(round(4.5))  #4

6.slice():实现切片对象，主要用在切片操作函数里的参数传递(了解)

s=slice(0,5,2)print(l[0:5:2]) # 0 2 4
print(l[s]) # 0 2 4msg="hello world"
print(msg[s])

7.sorted():排序

l = [444,111,222,555,666,333,777,888]
new_l=sorted(l)
print(new_l)dic = {'zegon':3000,'lxx':2000,'axx':4000
}
res = sorted(dic,key=lambda x:dic[x],reverse=True)
print(res)  #['axx', 'zegon', 'lxx']

8.sum():计算总和

print(sum([1,2,3,4]))

9.zip():

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

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

十八.面向对象编程,__init__方法,内置函数相关推荐

1. 面向对象常用魔法方法(内置方法)合集, 超级无敌宇宙详细

   引入 众所周知,方法是需要调用执行的,而魔法方法则不一样,他无需你的调用,在特定的时候会自己执行, 例如我们之前所学的__init__, 在示例对象 ([类名]+()) 的时候触发执行它 1.什么是内 ...

2. “约见”面试官系列之常见面试题之第六十八篇之本地对象 内置对象 宿主对象（建议收藏）

   首先解释下宿主环境:一般宿主环境由外壳程序创建与维护,只要能提供js引擎执行的环境都可称之为外壳程序.如:web浏览器,一些桌面应用系统等.即由web浏览器或是这些桌面应用系统早就的环境即宿主环境. ...

3. Python面向对象编程 __init__方法

   __init__方法 魔术方法 __init__初始化方法 code:_3magic_Intialization.py # ************************************** ...

4. Python面向对象编程 __init__()方法

   class YouXi:def __init__(self,yingxionglianmeng,wangzherongyao):self.yingxionglianmeng=yingxionglian ...

5. 1000道Python题库系列分享21（11道编程题：内置函数专项练习）

   本期题目,答案在文末: 温馨提示 进入公众号,通过菜单"最新资源"==>"历史文章"可以快速查看分专题的文章列表,通过"最新资源"== ...

6. Hive学习之路 （二十二）Hive 常用的内置函数(补充)

   hive 查看函数: show functions; desc functions 函数名 1.parse_url parse_url(url, partToExtract[, key]) - ext ...

7. python里面的内置函数_【python】函数之内置函数

   今天来介绍一下Python解释器包含的一系列的内置函数,下面表格按字母顺序列出了内置函数: 下面就一一介绍一下内置函数的用法: 1.abs() 返回一个数值的绝对值,可以是整数或浮点数等. print ...

8. python_day21面向对象的进阶(反射,内置方法,)

   # 两个内置函数 *# 反射 *****# 内置方法 *** # 类(定义) # 静态属性 类属性(变量) 直接写在类中,全大写 # 动态属性 方法(函数) self # 类方法 @classmeth ...

9. 在python中用递归的方法编程_python基础之函数，递归，内置函数

   阅读目录 一 数学定义的函数与python中的函数 初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量, ...

最新文章

1. java 字符间距_java中,label或者文本框怎么设置字符之间的间距
2. 喊了好久的AI落地究竟卡在哪里了？
3. 2015 Multi-University Training Contest 1 - 1002 Assignment
4. bzoj 4547: Hdu5171 小奇的集合
5. MFC-Tab Control控件使用
6. 纯CSS实现React Logo图形，内含详细解析
7. Pytorch 中 matmul 广播
8. 【jeecg-mybatis版本】 mybatis+spring mvc 完美整合方案 查询，保存，更新，删除自动生成
9. 九个工作谎言_书评：关于工作的九种谎言
10. LoadRunner - 实战,转发
11. Keepalived-在没有之前配置的Nginx高可用(不建议采纳)
12. pandas 数据集的端到端处理
13. SAP漏洞：为什么补丁没有发挥作用？
14. Spring Boot 2.0 从入门到精通 From Zero to Hero with Spring Boot - Brian Clozel
15. 基于ADS仿真的465khz检波电路
16. 国外一些DICOM资源下载网址
17. ACM常用数据结构小结与实现
18. Ubuntu 配置利用aira2进行百度网盘下载
19. 经典算法题(中级)-----自定义函数之字符类型统计
20. python爬虫之一：爬取网页小说（魂破九天）

热门文章

1. Java将字节数组转换成字符串
2. 代码重构与体系结构重构
3. 男性耳鸣是什么原因引起的
4. Egret部分低版本安卓手机闪屏
5. 老公是用来欺负的....
6. 老赵书托（3）：深入理解计算机系统
7. 【LeetCode】题解笔记
8. 服务器虚拟化中的系统迁移一——V2V迁移
9. Android 高通骁龙CPU线程与CPU核的绑定
10. Unreal UE4 、角色换色解决方案—多象限UV—及渲染材质到贴图（CanvastoRenderTarget）（渲染多象限UV）