面向对象基础

我们在写代码的时候有时候会反复使用一些模板或者是用到同样功能，为了简洁并且方便起见就引入了函数式编程以及面向对象编程

1.函数式编程

用函数封装减少代码重复性

def func(s):
    count = 0
    for i in s:
        count += 1
    return count

另外创建一个.py文件调用模板

# 调用模板
import 函数式编程
print(函数式编程.func("a1111")) # 5

这是最基本函数式编程以及调用模板
还有一种封装方式就是面向对象来方便我们进行一些同样的操作

2.面向对象

1.面向对象的定义

# 面向对象思想（上帝式思维） 所创造的事物为（对象）
# 类：就是具有相同的属性且具有相同功能的一类事物
# 对象：就是类的具体表现形式

# 下面举一个例子
"""
恐龙  一个群体的总称
共同的特点：觅食、斗争、身材、生活习惯
霸王龙 肉食类恐龙、很凶、强壮、陆地
"""
class KongLong:

    def __init__(self):
        self.mishi = "吃东西"
        self.douzheng = "打架"
        self.shencai = "强壮"
        self.shenghuoxiguan = "陆地"
# 对象：就是类的具体表现形式
# class 就是定义类的关键字
bawanglong = KongLong()  # 创建一个对象
print(bawanglong) # <__main__.KongLong object at 0x0000020F6FEC6C50>  返回一个内存
print(bawanglong.mishi) # 吃东西

2.定义一个类

# 从类名的角度去研究
# 定义猫类
class Cat():
    """
    静态变量
    动态方法
    """
    # 静态变量：共同的功能和相同的属性
    eat = "吃" # 静态属性/静态变量
    dic = {}
    list1 = []
    
	# 动态方法  方法、函数、动态属性
    def eat1(self):
        print("吃鱼")

    def tools(self):
        print("会使用工具")

# 下面是几种方法：
#1.查看类的所有内容  类名__dict__方式  只能用来增删查，不能用来改
print(Cat.__dict__）
print(Cat.__dict__["eat"]) # 吃
# print(Cat.__dict__["eat"] = "run") 不能通过这样的方法修改

# 万能的点  可以实现增删改查类中的属性
Cat.run = "跑" # 会添加一个属性
del Cat.eat # 删除
Cat.eat = "吃鱼"  # 修改
print(Cat.eat) # 吃   查询


# 类名操作动态方法
#注意 ： 除了两个特殊方法：静态方法、类方法之外，一般不会通过类名操作一个类中的方法

Cat.eat1(111) # 吃鱼
Cat.tools(222) # 会使用工具

3.创建一个对象

# 从对象的角度研究类
class Cat:
    cat = "吃鱼"

    def __int__(self):
        print(666)
        print(self)
       
    # 动态方法  方法、函数、动态属性
    def eat1(self):
        print("吃鱼")
        print(self)
    def tools(self):
        print("会使用工具")
    def work(self):
        print("猫会打工！")
	
	# 对象是从类中创建出来的，只要是类名加上（），这就是一个实例化的过程，实例化对象
# 只要实例化对象，它会自动的执行_init_方法
a = Cat()
print(a) # <__main__.Cat object at 0x000001CB538266E0>  self指向调用该函数的对象的内存地址，这里的对象是Cat类
#a.eat1(11) # 吃鱼

实例化对象时发生的事情：
1.在内存中开辟了一个对象空间
2.自动执行类中的_init_方法，并且将这个对象空间（内存地址）传给了_init_的第一个位置参数self
3.在_init_方法中通过self给对象添加属性

# 创建一个人的类
class Human():
    main = "有思想"
    language = "语言"

	# 初始化方法_init_()  与生俱来的属性  在构造类的过程中就赋予了这类所具有的属性
    def __init__(self,sex,age,name,hobby):
        # self 是和类指向的是同一个内存空间，同一个空间,下面就是通过self给对象空间封装四个属性
        self.sex = sex
        self.age = age
        self.n = name
        self.h = hobby

	def work(self):
        print("人类会工作")
    def tools(self):
        print("人类会使用工具")

# 创建的对象不具备自身传参的功能  一个类可以实例化为多个对象
haier = Human("男",0.5,"海尔","运行")
# haier("男",0.5,"海尔","运行") # 自身传参会报错

print(haier) # <__main__.Human object at 0x0000016F12683E50>
print(haier.__dict__) # {'sex': '男', 'age': 0.5, 'n': '海尔', 'h': '运行'}

haier.n = "海尔兄弟"
print(haier.n) # 海尔兄弟

# 对象查看类中的属性
print(haier.sex) # 男
print(haier.language) # 语言

# 对象操作类中的方法  通过类名调用要传参，通过对象调用不用传参
# 因为类当中的方法一般都是通过对象执行的（除了类方法和静态方法），并且对象执行这些方法时都会自动将对象空间传给方法中第一个self
# self 代表当前的对象
a = Human("男",0.5,"海尔","运行")
a.work() # 人类会工作

4.属性的分类以及应用场景

# 类的命名空间

class A():
    # 对象属性
    def __init__(self,name):
        self.name = name

    def func(self,sex):
        self.sex = sex

    def func1(self):
        A.add = "cc" # 类来添加实例属性

# 类外面调用和添加：
a = A("Eliaukgit")
a.age = 18
print(a.__dict__) # {'name': 'Eliaukgit', 'age': 18}

# 类内部调用和添加：
b = A("1")
b.func("男")
print(b.__dict__) # {'name': '1', 'sex': '男'}

# 对象的属性不仅可以在_init_里面添加，还可以在类的其他方法或者类的外部添加
# 类的静态属性

# 类的外部添加
A.add = "11"
print(A.__dict__) # 'add': '11'

# 类的内部添加
A.func1("111")
print(A.__dict__) # 'add': 'cc'

#类的属性不仅可以在类的内部还可以在类的外部添加