疑惑的姓名首字母k,平凡的世界电子书下载,上海坐车网
我要评论'''
1.什么是面向对象？
面向对象是一门编程思想!
- 面向过程编程思想:
核心是 “过程” 二字，过程指的是解决问题的步骤，即先干什么再干什么！
基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。
优点:
将复杂的问题流程化，进而简单化
缺点:
牵一发而动全身，程序的可扩展性差。
注意: 编程思想仅仅是一门思想，与任何的技术无关。
- 面向对象编程思想:
注意: 要将自己当做一个上帝！！！
核心是 “对象” 二字，对象指的是 “特征与技能” 的结合体。
基于该编程思想编写程序，就好比在创造世界，一种 “上帝式” 的思维方式。
优点:
可扩展性高。
缺点:
编写程序的复杂程度比面向过程高。
2.如何产生对象:
1) 什么是类？
类指的是类型、类别。
- 在两种角度去看待:
- 现实世界中:
- 先有一个个的对象，经过社会的文明发展，随之总结出类。
对象是实际存在的，而类抽象产生的。
- 在程序中:
- 必须先有类，再通过“调用类，产生对象”。
对象指的是 “特征与技能” 的结合体， 类指的是一系列 “对象之间相同的特征与技能” 的结合体。
2) 如何定义类:
- 如何写类并产生对象:
- 先从现实世界中通过一个个对象总结出类。
- 然后再定义类，后调用类产生对象。
- 比如: 选课系统:
- 选课系统学生类:
- 学生对象1:
特征:
- 姓名: 马冬梅
- 性别: female
- 年龄: 26
- 学校: oldboy
- 技能:
- 技术: python
- 学习: learn
- 选课: course
- 学生对象2:
特征:
- 姓名: 迪丽热巴
- 性别: female
- 年龄: 18
- 学校: oldboy
- 技能:
- 技术: python
- 学习: learn
- 选课: course
3) 定义类语法:
class 关键字: 帮你产生类的。
class 类的名字:
- 对象之间相同的特征
- 学校
school = 'oldboy'
- 对象之间相同的技能
- python
def python():
pass
- learn
def learn():
pass
- course
def course():
pass
'''
'''
class 类名:
特征
技能
定义类名的规范:
- 驼峰命名法
- 用变量表示特征
- 用函数表示技能
- 注意：在定义类的阶段会立刻执行类体内的代码，将产生的名字存放于名称空间中
- 用.__dict__的方法去查看名称空间
- 在类内定义一个__init__的函数，该函数会在调用类时自动触发执行，并且会将对象自动传给
传给函数的第一个参数，然后会将其他的参数一起传给__init__
- 函数的名称空间：
在调用函数时产生，函数调用结束后销毁。
- 类的名称空间:
在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。
对象的产生:
- 调用类产生对象
类名 + () 调用类产生对象
类的名称空间在定义时产生，对象的名称空间在调用类时产生。
调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
由对象来调用类内部的函数，称之为对象的绑定方法。
对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。
'''
class oldboy:
school = 'oldboy'
def __init__(self, name, age, gender):
#给对象增加新的属性
self.name = name
self.age = age
self.gender = gender
def learn(self):
print('is learning....')
obj = oldboy('热巴', 18, 'female')
print(obj) #<__main__.oldboy object at 0x00000236533cde48>
print(obj.name) #热巴(.后面的名字叫属性attribute)
print(obj.age) #18
print(obj.gender) #female
#查看类的名称空间
print(oldboy.__dict__)
#{'__module__': '__main__', 'school': 'oldboy',
# '__init__': <function oldboy.__init__ at 0x000002c6b7afbee8>,
# 'learn': <function oldboy.learn at 0x000002c6b7b16948>,
# '__dict__': <attribute '__dict__' of 'oldboy' objects>,
# '__weakref__': <attribute '__weakref__' of 'oldboy' objects>, '__doc__': none}
#增
obj.hobby = 'dance'
print(obj.hobby) #dance
#删
del obj.hobby
print(obj.hobby)
attributeerror: 'oldboy' object has no attribute 'hobby'
#改
obj.name = '迪丽热巴'
print(obj.name) #迪丽热巴
#查
print(obj.age) #18
'''
对象名字的查找顺序： *******
1.对象.属性，会先找对象自己的。
2.若对象没有，会去找类的。
3.若类没有，则会报错。
'''
class man:
country = 'china'
name = '亚峰'
def __init__(self, name, age, gender):
print(self.__dict__) #此时是一个空{}
self.name = name
self.age = age
self.gender = gender
print(self.__dict__) #此时是添加完以后的字典{'name': '热巴', 'age': 18, 'gender': 'female'}
def run(self):
print('running....')
obj = man('热巴', 18, 'female')
print(obj.name) #热巴,对象自己有的属性，会用自己的属性
print(obj.country) #china,对象没有的属性，会拿类中的属性
print(obj.number) #attributeerror: 'man' object has no attribute 'number'
#对象没有，类中也没有，会报错
#给对象添加自己的属性
obj.country = '中国'
print(obj.country) #中国
'''在python中一且皆对象'''
class province:
def __init__(self, gdp, number, view):
self.gdp = gdp
self.number = number
self.view = view
obj = province(12345678974123, 66666666, '黄山')
print(obj) #<__main__.province object at 0x000001fa83dae7c8>
int #class int(object):
float #class float(object):
str #class str(object):
list #class list(object):
set #class set(object):
tuple #class tuple(object):
dict #class dict(object):
filter #class filter(object):
....
'''
需求: 有一个人对象，狗对象，人狗互咬。
- 对象人1:
- 特征:
- 生命
- 名字: name = '小明'
- 攻击力: arg
- 技能:
- 咬：bite
- 对象人2:
- 特征:
- 生命
- 名字: name = '张三'
- 攻击力: arg
- 技能:
- 咬：bite
- 抽象出类:
- 人类:
- 相同特征
- 生命
- 相同技能
- 咬
狗对象1:
- 特征:
- 生命: 250
- 名字: name = '阿黄'
- 品种: dog_type = '哈士奇'
- 攻击力: arg
- 技能:
- 咬：bite
狗对象2:
- 特征:
- 生命: 400
- 名字: name = '旺财'
- 品种: dog_type = '哈巴犬'
- 攻击力: arg
- 技能:
- 咬：bite
狗类:
- 相同特征
- 相同技能
- 咬
'''
#人类
class man:
def __init__(self, name, life, attack_bility):
self.name = name
self.life = life
self.attack_bility = attack_bility
#人调用bite时，传入狗对象
def bite(self, dog_obj):
print(f'人{self.name}开始咬狗{dog_obj.name}!')
#减掉狗的生命值，值为人的攻击力
dog_obj.life -= self.attack_bility
print(f'狗的生命值减掉{self.attack_bility},还剩{dog_obj.life}!')
if dog_obj.life <= 0:
print(f'狗{dog_obj.name}已经挂了')
return true
#狗类
class dog:
def __init__(self, name, life, attack_bility):
self.name = name
self.life = life
self.attack_bility = attack_bility
#狗调用bite时，传入人对象
def bite(self, man_obj):
print(f'狗{self.name}开始咬人{man_obj.name}!')
#减掉人的生命值，值为狗的攻击力
man_obj.life -= self.attack_bility
print(f'人的生命值减掉{self.attack_bility},还剩{man_obj.life}!')
if man_obj.life <= 0:
print(f'人{man_obj.name}已经挂了')
return true
man_obj = man('小明', 1001, 100)
dog_obj = dog('阿黄', 500, 200)
import time
while true:
res1 = man_obj.bite(dog_obj)
if res1:
break
time.sleep(1)
res2 = dog_obj.bite(man_obj)
if res2:
break
time.sleep(1)
'''
面向对象编程:
核心是 “对象”， 对象指的是 特征与技能 结合体。
基于该编程思想编写程序，就好比在创造世界，一种上帝式思维方式。
优点:
可扩展性强。
缺点:
编写复杂难度较面向过程高。
'''
# 1.类的实例化: 调用类的过程称之为类的实例化，产生的对象也可以称之为类的一个实例。
'''
调用类产生对象发生的事情:
1.会产生一个空对象的名称空间
2.会自动触发__init__，并且会将对象当做第一个参数传入。
3.会将调用类括号内的参数一并传给__init__().
'''
class people:
country = 'china'
def __init__(self, name, age, sex):
print(self.__dict__)
print(self)
self.name = name
self.age = age
self.sex = sex
print(self.__dict__)
# 注意: 看到self就应该知道是对象本身
def learn(self):
print('learning....')
p_obj = people('tank', 17, 'male')
# print(p_obj.name, p_obj.age, p_obj.sex)
# 2.查看类与对象的名称空间 类.__dict__ 对象.__dict__
# print(people.__dict__)
# print(p_obj.__dict__)
# 3.类或对象的属性操作: 查、增、改、删
# print(people.country)
# people.number = 1500
# print(people.number)
# people.country = '中国'
# print(people.country)
# del people.country
# print(people.country)
# print(p_obj.name)
# p_obj.sal = 150000000
# print(p_obj.sal)
# p_obj.age = 16
# print(p_obj.age)
# del p_obj.sal
# print(p_obj.sal)
# 4.类中数据属性（类中的变量）: 类中属性是给对象使用的，对象引用类中的属性，指向的都是类中同一个内存地址。
# p_obj1 = people('tank', 17, 'male')
# p_obj2 = people('jason', 71, 'female')
# p_obj3 = people('大饼', 72, 'female')
# print(p_obj1.country, id(p_obj1.country))
# print(p_obj2.country, id(p_obj2.country))
# print(p_obj3.country, id(p_obj3.country))
# 5.类中的方法（类中的函数）: 类中的方法是给对象使用的，
# 由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入。
# print(people.learn)
# print(p_obj1.learn) # bound method
# print(p_obj2.learn)
# print(p_obj3.learn)
# 6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找
# print(p_obj1.country)
# print(p_obj1.country2)
# 7.对象绑定方法的特殊之处:
'''
1.会将对象当做第一个参数传入。******
2.若对象的绑定方法中还有其他参数，会一并传入。
'''
# p_obj1对象.对象的绑定方法learn(p_obj1):
# p_obj1.learn()
# 8.一切皆对象: 在python3中，类即类型。
# print(type(p_obj1)) # <class '__main__.people'>
# str1 = 'tank'
# print(type(str1)) # <class 'str'>
#
# list1 = [1, 2, 3]
# print(type(list1)) # <class 'list'>
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
新手学习Python2和Python3中print不同的用法
Python基于os.environ从windows获取环境变量
网友评论