python-类

类

1、类是一个独立存放 变量的空间

注：每个实例都是一个独立的变量空间。不同实例之间的空间互不可见

运算符“.”—用于进行变量空间的计算

class Person:
	pass
p1 = Person()
p2 = Person()
p1.var = '在实例中封装的变量'
print(p1.var)
print(Person.var)  #类中找不到，不回去找实例中的
print(p2.var)   #p2也没有，去找Person也没有

2.类与实例之间的关系

类：是实物的抽象，不是真实存在的，描绘了该类事物的共性。如：动物、植物

实例：某类实物的具体个体，是该类实物及具体表现，他是真实存在的。如：小明，小红

3.实例方法表示的是实例的行为

调用过程

​ 通常，将默认会传入的那个参数命名为self，用来表示调用这个方法的实例对象本身。

​ 方法总是定义在类中，但是却叫"实例方法"，因为它表示该类所有实例所共有的行为。

4.–init__

它会在实例化之后自动被调用，以完成实例的初始化。

orange = cat()

这时已经将orange进行初始化

5.类的定义

# 面向过程编程：程序按照流程一步步往下走
tu = ('fei', 18, 160)
di = {'name': 'sophia', 'age': 20, 'height': 165}

print(dict(zip(di.keys(), tu)))  # {'name': 'fei', 'age': 18, 'height': 160}
print(tuple(di.values()))   # ('sophia', 20, 165)


# 面向函数编程：将不同的功能设置成不同的函数，在需要的时候随时调用
def func(tu, di):
    return dict(zip(di.keys(), tu)), tuple(di.values())


x, y = func(tu, di)
print(x)
print(y)

# 面向对象编程：类
# 一切事物皆为对象
# 面向对象最重要的概念是类（class）和实例（instance）

​ 类的定义

class Cat:
    """这是一个猫类"""

# class 关键字
# Cat 类名 大驼峰命名法
# """这是一个猫类""" 解释类的用途

实例化对象

orange = Cat()

6.类属性

# 实例属性
# 类属性
# 私有属性
# 初始化
# __   __
# __init__, 实例化之后自动被调用,完成实例的初始化


class Cat:
    """这是一个猫类"""
    def __init__(self, color, eat):
        self.color = color  # 实例属性：记录是具体对象的特征
        self.eat = eat
        print("内部调用：", self.color)   # 内部调用：需要加上self


kitty = Cat('white', 'milk')    # kitty, 'white', 'milk'
print(kitty.color)

orange = Cat('orange', 'food')  # orange, 'orange', 'food'
print(orange.eat)   # 外部调用：实例名.属性


# 类属性：记录与类相关的特征
# 在__init__外初始化的
class Cat:
    """这是一个猫类"""
    count = 0   # 类属性

    def __init__(self, color, eat):
        self.color = color  # 实例属性：记录是具体对象的特征
        self.eat = eat
        # 计数
        Cat.count += 1  # 内部调用：类名.类属性名


# 实例化对象
kitty = Cat('white', 'milk')
orange = Cat('orange', 'food')
hua = Cat('hua', 'fish')

# 输出创建对象的个数
print("现在创建了{}只猫".format(Cat.count))    # 外部调用：类名.类属性名
print(kitty.count)  # 外部调用：实例名.类属性名


# 总结
"""
实例可以访问实例属性，实例可以访问类属性
类只能访问类属性
"""

# 3.私有属性
# a.单下划线开头：只是告诉别人这是私有属性，外部依然可以访问更改
# b.双下划线开头：外部不能通过实例名(instancename).属性名(propetyname)来访问或者更改


class Cat:
    def __init__(self, color, eat):
        self._color = color
        self.__eat = eat


kitty = Cat('white', 'milk')
print(kitty._color)
# print(kitty.__eat)

7.类方法

# 类和函数
class Cat:
    """这是一个猫类"""
    def __init__(self, color, age):
        self.color = color
        self.age = age


kitty = Cat("white", 2)
hua = Cat("hua", 1)

# 以上部分，我们实现了：1.创建了Cat类 2.实例化了两个对象kitty&hua


# 接下来，我们来创建一个函数,实现上面两只猫猫的年龄求和后的新属性，给第三只猫
def add_cat(name, c1, c2):
    cat = Cat(name, c1.age + c2.age)
    return cat


yellow = add_cat("yellow", kitty, hua)
print(yellow.age)

red = add_cat("red", kitty, yellow)
print(red.age)


# 方法：和某个特定的类相关联的函数
# 函数--->方法：只需要将函数的定义移动到类的定义中即可
class Cat:
    """这是一个猫类"""
    def __init__(self, color, age):
        self.color = color
        self.age = age

    def print_cat(self):
        print("{}-{}".format(self.color, self.age))


kitty = Cat("white", 2)
hua = Cat("hua", 1)

# print_cat调用
Cat.print_cat(kitty)

kitty.print_cat()

# 封装：self指向对象，在对象中封装数据，对类进行优化的方法，就叫封装


class Cat:
    """这是一个猫类"""
    count = 0   # 类属性

    def __init__(self, name, color, eat, age):
        self.eat = eat
        self.name = name    # 实例属性
        self._color = color  # 外部可访问私有属性
        self.__age = age    # 外部不可访问私有属性
        Cat.count += 1  # 内部调用：类名.类属性名

    def print_cat(self):
        print("{}-{}-{}".format(self._color, self.__age, self.name))

    def __get_none(self):
        # 私有方法，不可以被实例和类直接调用
        return "我是私有方法"

    def test(self):
        self.__get_none()


kitty = Cat('kitty', 'white', 'milk', 2)
print(kitty.eat)
print(Cat.count)
print(kitty.count)

kitty.print_cat()
# kitty.__get_none()

如果想获取更多有关python的信息，和想玩python制作的小程序，可以关注微信公众号（dreamspy）。我们一起用python改变世界，一起用python创造梦想。