一.编程思想
- 编程思想
编程思想：
1.面向过程编码——逻辑、算法
遇到问题，考虑直接把逻辑思维转换成代码，解决问题
2.函数式编程——函数
遇到问题，就考虑是否有一个这种功能的函数
3.面向对象编程——类和对象
遇到问题，就考虑是否有一个对象能够帮我解决这个问题
- 类和对象
1.定义
类：拥有相同属性和相同功能的对象的集合(类是抽象的)
对象：类的实例(对象是具体的)
2.从生活的角度考类的对象
如果'dota英雄'是一个类，影魔是一个对象，剑圣是一个对象
如果网络小说作家是一个类，辰东是一个对象，我吃西红柿是一个对象
二.类
- 类的声明
语法：
class 类名(父类列表):
类的内容
说明：
class——声明类的关键字
类名——标识符，不能是关键字(要求！)；
采用驼峰式命名，并且首字母大写；
见名知义
(父类列表)——继承语法；可以省略，省略的时候相当于(object)
类的内容——主要包含属性和方法
补：驼峰式命名：名字由多个单词组成，通过单词首字母大写来区分不同的单词
- 属性和方法
类中的属性——指的是在类中声明的变量；分为类的字段和对象属性
类中的方法——指的是在类中的函数；分为对象方法、类方法和静态方法
#声明了一个Human类
class Human:
"""人类"""
#属性
num = 61
#方法
def eat(self):
print('人在吃饭！')
#Human是类(类就是类型)
print(Human)#<class '__main__.Human'>
- 创建对象
类名()-->创建类对应的对象
#创建Human类的对象xiao_ming
xiao_ming = Human()
print(xiao_ming)#<__main__.Human object at 0x006330B0>
三.对象方法
- 什么是对象方法
直接声明在类中，并且自带一个叫self的参数的函数
- 对象方法的调用——通过对象调用对象方法
对象.对象方法()
- self(当前对象)
通过对象调用对象方法的时候，对象方法中的第一个参数self不用传参，
系统会自动将当前对象传给self。
哪个对象调用的，self就指向谁。
注意：当前类的对象能做的事情，self都能够做
class Human:
"""人类"""
def __init__(self):
self.name = ''
#声明了一个对象方法sleep
def sleep(self,a):
#self = p1
print('self:',self)
print('睡觉！',a)
self.run()
def run(self):
# self = p1
print('跑')
def eat(self):
print('%s在吃饭' % self.name)
#创建Human的对象p1
p1 = Human()
print('p1:',p1)
p1.sleep(10)
p2 = Human()
p2.name = '小明'
p2.eat()#小明在吃饭
p3 = Human()
p3.name = 'ddf'
p3.eat()#ddf在吃饭
四.init方法和构造方法
- 魔法方法
python类中，用 __ 开头并且是__ 结尾的方法，就是魔法方法。
魔法方法不需要主动调用，都会自动调用
- __ init__方法
a.是对象方法
b.不需要自己调用，会被自动调用
c.专门用来对对象进行初始化的 - 构造方法
概念：函数名和类名一样的函数，就是构造方法
当我们创建类的时候，系统会自动创建这个类的构造方法，用来创建对象。
当我们通过构造方法创建对象的时候，系统会自动调用init方法来对创建好的对象进行初始化
注意：当init方法中除了self以外如果需要别的参数，那么这些参数是通过构造方法来传的参
只要调用了构造方法，就会产生新的对象。（想要对象，调用构造方法）
class Person(object):
def __init__(self,name='DDF'):
print('self',self)
print('init方法',name)
"""
def Person(*args, **kwargs):
在堆中开辟空间创建对象
对象.__init__(*args, **kwargs)
return 对象
"""
p1 = Person('小明')#self <__main__.Person object at 0x01E23850>
###################init方法 小明
print('p1',p1)#p1 <__main__.Person object at 0x01E23850>
p2 = Person('小花')
p3 = Person()
# 模拟构造方法和init方法
def __init__(a, b):
print('自己实现', a, b)
def Person1(*args, **kwargs):
# args = (10, 20)
print('创建对象')
__init__(*args, **kwargs)
print('返回对象')
Person1(10, 20)#创建对象
###############自己实现 10 998
###############返回对象
五.对象属性
- 什么是对象属性
a.声明在__ init__方法中
b.self.属性名 = 值
c.通过对象使用: 对象.属性
语法：
self.变量名 = 值
说明：变量名就是属性名，这个变量就是对象属性
- 什么样的属性应该声明称对象属性
如果属性的值会因为对象不同而不一样，那这样的属性就应该声明成对象属性。反之就声明称类的字段
# 情况一：所有对象属性创建的时候都使用一个固定的默认值
class Person:
def __init__(self):
# 这儿的name和age就是Person类的对象属性
self.name = 'ddf'
self.age = 0
# 创建对象
p1 = Person()
# 使用对象属性
print(p1.name)#ddf
print(p1.age)#0
p1.name = 'cyy'
p2 = Person()
p2.name = '小红'
print(p2.name, p1.name)#小红 cyy
# 情况二：创建对象的时候，决定对象属性的值
class Human:
def __init__(self, name1, age=1):
self.name = name1
self.age = age
p11 = Human('小猴子')
p12 = Human('李逍遥',0)
print(p11.age,p12.age)#1 0
print(p11.name, p12.name)#小猴子 李逍遥
#修改对象属性的值
p11.name = '老王'
print(p11.name)#老王
#练习：声明一个矩形类
"""
属性：长和宽
方法：求面积和求周长
"""
class Rectangle:
def __init__(self,length1,width1):
self.length = length1
self.width = width1
#一个对象方法需不需要除了self以外的其他参数
#看实现这个函数的功能需不需要除了属性以外的其他数据
def area(self):
#self = rec1
return self.length * self.width
def perimeter(self):
return (self.length + self.width)*2
rec1 = Rectangle(20,30)
print(rec1.length,rec1.area(),rec1.perimeter())#20 600 100
rec1.length = 30
print(rec1.length,rec1.area())#30 900
# 练习：声明一个Point类，拥有属性x坐标和y坐标。功能：求两个点之间的距离
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
# 求当前点到另外一个点的距离
def distance(self, other):
"""
求两个点的距离
:param other: Point对象
:return: 距离
"""
# self = p1 other = p2
return ((self.x - other.x)**2 + (self.y - other.y)**2)**0.5
# 创建点p1
p1 = Point(0, 0)
print(p1.x, p1.y)#0 0
# 创建点p2
p2 = Point(3, 4)
# 求p1到p2的距离
print(p1.distance(p2))#5
六.对象属性的增删改查
class Dog:
def __init__(self,name,color,type):
self.name = name
self.color = color
self.type = type
dog1 = Dog('旺财','黄色','二哈')
1.查(获取对象属性的值)
a.对象.属性——属性不存在的时候会报错
b.getattr(对象,属性名,默认值)——属性不存在的时候，如果设置了默认值，程序不崩溃，而是返回默认值
2.增、改
a.对象.属性 = 值
b.setattr(对象,属性名,值)
注意：属性存在的时候，对应的功能是修改属性的值。当属性不存在的时候，对应的功能是添加属性的值。
dog1.name = '大黄'#修改
print(dog1.name)#大黄
dog1.sex = '公'#添加
print(dog1.sex)#公
setattr(dog1,'name','热狗')
print(dog1.name)#热狗
setattr(dog1,'name2','肉狗')
print(dog1.name2)#肉狗
3.删除
a. del 对象.属性
b. delattr(对象,属性名)
del dog1.name2
#print(dog1.name2)#AttributeError: 'Dog' object has no attribute 'name2'
delattr(dog1,'color')
#print(dog1.color)#AttributeError: 'Dog' object has no attribute 'color'
注意：对象属性的增删改查，都是针对指定的那一个对象，不会影响其他对象
4.__ slots__魔法
__ slots__是用来约束当前这个类有哪些对象属性
class Student:
#Student类的对象只能用name,study_id,age和sex属性
__slots__ = ('name','study_id','age','sex')
def __init__(self,name,age):
self.name = name
self.study_id = '001'
self.age = age
stu1 = Student('夏明',18)
#stu1.neme = '小明'#AttributeError: 'Student' object has no attribute 'neme'
stu1.sex = '男'
七.类的字段和内置类属性
- 类的字段
a.直接声明在类里面,函数的外面的变量就是类的字段
b.类的字段需要通过类来使用：类.字段——(不管是在类里面还是类的外面都一样)
不会因为对象不同而不一样的数据就是类的字段
class Person:
#声明了一个字段number
number = 61
def show_number(self):
print('人类的数量%d亿' % Person.number)
print(Person.number)#61
Person().show_number()#人类的数量61亿
- 内置类属性
内置属性就是声明类的时候，类中已经声明好的属性(包括类的字段和对象的属性)
class Dog:
"""说明文档:狗类"""
# 类的字段
type = '犬科'
# 对象属性
def __init__(self, name='', age=0, color=''):
self.name = name
self.age = age
self.color = color
# 对象方法
def eat(self, food):
print('%s在吃%s' % (self.name, food))
# 类方法
@classmethod
def shout(cls):
print('汪汪汪~~~~')
# 静态方法
@staticmethod
def bite():
print('狗咬人！！！')
dog1 = Dog('小黑', 3, '黑色')
a. __ name__
类.__ name__ - 获取类的名字(字符串)
class_name = Person.__name__
print(class_name, type(class_name))#Person <class 'str'>
with open(Person.__name__+'.json','w') as f:
pass
b.__ class__
对象.__ class__——获取对象对应的类(结果是一个类，原来类能做的事情)
aa = dog1.__class__
d1 = Dog()
d2 = aa()
print(d1, d2)
print(Dog.type)#犬科
print(aa.type)#犬科
print(dog1.__class__.__name__) # 获取对象对应的类的名字#Dog
c.__ dict__
(了解)类.__ dict__ - 获取当前类的所有的类的字段及其对对应的值
(重点)对象.__ dict__ - 将当前对象所有的对象属性及其值转换成字典,key是属性名,value是属性的值
print(Dog.__dict__)
print(dog1.__dict__)#{'name': '小黑', 'age': 3, 'color': '黑色'}
d.__ bases__
类.__ bases__——获取当前类的父类(以元组的形式返回，元祖中的元素就是类的父类)
print(Dog.__bases__)#(<class 'object'>,)
print(dict.__bases__)#(<class 'object'>,)
e.__ module__
类.__ module__——获取当前类所在的模块的模块名
print(Dog.__module__)#__main__
print(int.__module__)#builtins
f.__ doc__
类.__ doc__——获取类的说明文档
print(Dog.__doc__)#说明文档：狗类
print(int.__doc__)
