Python——面向对象编程（十一）-526互联

1. 对象的封装

# coding=utf-8
# 对象的封装
# 类的概念
"""
类的名字：当名字由多个单词构成时，我们采用驼峰命名法
就是说多个单词，每个单词的首字母需要大写
这也是python的命名规则
"""
class BeautifulGirl():
    # 类的属性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""

    # 构造函数
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("构造函数运行了")
    # 在这就叫做类的方法
    def dance(self):
        print ("美女在跳舞")

    def get_beautiful_girl(self):
        print ("这个美女的样貌是：")
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)

# 实例化就是获取具体对象的一个过程 new新的一个。
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"乌黑亮丽的头发"
                     ,"清秀的脸庞")
girl.dance()
girl.get_beautiful_girl()

girl2 = BeautifulGirl("小小的眼睛",'鼻子','嘴','头发','脸庞')
girl2.get_beautiful_girl()

print打印结果：

大大的眼睛
小巧的嘴唇
乌黑亮丽的头发
清秀的脸庞
小小的眼睛
这个美女的样貌是：
鼻子
嘴
头发
脸庞

2. 类的私有属性

# coding=utf-8
# 类的私有属性
class BeautifulGirl():
    # 类的属性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""
    # 这就是私有属性，私有属性在类的外部是不可以访问的
    __name ="高圆圆"
    address = "河北省唐山市"
    # 构造函数
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("构造函数运行了")
    # 在这就叫做类的方法
    def dance(self):
        print ("美女在跳舞")
    def __dd(self):
        print ("美女在跳舞")

    def get_beautiful_girl(self):
        print ("这个美女的样貌是：")

        print (self.__name)
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"乌黑亮丽的头发"
                     ,"清秀的脸庞")
print (girl.mouth)
print (girl.address)
# print (girl.__name)
# # 类的私有属性可以访问吗？
# print (BeautifulGirl.__dict__)
# print (girl._beautiful__name)
girl.get_beautiful_girl()

print打印结果：

构造函数运行了
这个美女的样貌是：
高圆圆
大大的眼睛
小巧的鼻子
薄薄的嘴唇
乌黑亮丽的头发
清秀的脸庞

3. 类中的方法

# coding=utf-8
# 类的私有属性
class BeautifulGirl():
    # 类的属性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""
    # 这就是私有属性，私有属性在类的外部是不可以访问的
    __name ="高圆圆"
    address = "河北省唐山市"
    # 构造函数，也叫构造方法
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("构造函数运行了")
    # 在这就叫做类的方法
    def dance(self):
        print ("美女在跳舞")
    # 这个叫做私有方法
    def __dd(self):
        print ("美女在跳舞")
    # 这个叫做一般方法
    def get_beautiful_girl(self):
        print ("这个美女的样貌是：")

        print (self.__name)
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)
    # 静态方法
    # 静态方法不能够访问类中的属性
    @staticmethod
    def study():
        print ("美女在shixi")

    # 类方法
    # 类方法是不可以访问实例变量的，它可以访问类变量（类的属性
    @classmethod
    def girl_friend(cls):
        print (cls.__name)
        print (cls.address)
        print (cls.face)
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"乌黑亮丽的头发"
                     ,"清秀的脸庞")

# print (BeautifulGirl.__dict__)
# 这就访问了类中的私有方法
# girl.beautifulGirl__dd()

girl.study()
BeautifulGirl.study()

# 类名，一般方法的名称调用是会报错的
# BeautifulGirl.dance(girl)

girl.girl_friend()
BeautifulGirl.girl_friend()
girl.get_beautiful_girl()

print打印结果：

构造函数运行了
这个美女的样貌是：
高圆圆
河北省唐山市
高圆圆
河北省唐山市
大大的眼睛
小巧的鼻子
薄薄的嘴唇
乌黑亮丽的头发
清秀的脸庞

4. 类的继承

# coding=utf-8
# 类的继承
# 父类和子类
class Father(object):
    age = 38

    def __init__(self,name):
        self.name = name
        print ("父类的构造函数运行了")

    def father_money(self):
        print ("爸爸有很多钱")

    def __father_knowleger(self):
        print ("爸爸的知识体系")

    @staticmethod
    def study():
            print ("爸爸在学xi")

    @classmethod
    def father_friend(cls):
            print ("爸爸有很多朋友")

    def face(self):
            print ("爸爸非常帅")
# 意味着son这个类继承了father这个类
class Son(Father):
   def __init__(self):
       print ("子类的构造函数运行了")
# son = Son("小王")
son = Son()
# 在继承中，子类如果有构造函数，name就不会调用弗雷德构造函数

# 在继承中，一般的方法是可以被继承的
son.father_money()

# 私有方法可以被继承
# son.__father_knowleger()
son.study()
son.father_friend()

class Mother():
    def face(self):
        print ("妈妈长的很漂亮")

# 这就叫做多继承
class Son2(Mother,Father):
    def __init__(self):
        print("2儿子的构造函数运行了")

son2 = Son2()
son2.father_money()
son2.face()
# 当多继承的时候，多个父类拥有一个名称的变量或方法时
# 哪个父类写在继承列表的前边，子类就继承谁的

print打印结果：

子类的构造函数运行了
爸爸有很多钱
爸爸在学xi
爸爸有很多朋友
2儿子的构造函数运行了
爸爸有很多钱
妈妈长的很漂亮

5. 类的多态

# coding=utf-8
# 类的多态
# 指的是多种形态

class Animal():
    def run(self):
       print ("动物开始跑")
# 子类在继承父类的过程中，重写了父类中的方法
class Dog(Animal):
    def run(self):
        print ("狗狗跑")

class Cat(Animal):
    def run(self):
        print ("猫跑")

class Person(Animal):
    def run(self):
        print ("人类跑")

dog = Dog()
dog.run()

cat = Cat()
cat.run()

person = Person()
person.run()

# 多个类继承同一个类，都重写了父类的方法，呈现出了不同的形态

# 多态性
class A(Animal):
    pass
a = A()

def run(obj):
    obj.run()

run(dog)
run(cat)
run(person)
run(a)

print打印结果：

狗狗跑
猫跑
人类跑
狗狗跑
猫跑
人类跑
动物开始跑

6. 多进程编程

# coding=utf-8
# 多进程编程代码演示
import time
from multiprocessing import Process
import os

def target_function():
    print ("子进程的ID:{}".format(os.getpid()))
    time.sleep(2)
if __name__== "__main__":
    print (__name__)
    print ("主进程ID:{}".format(os.getpid()))
    ps = []
    for i in range(10):
        p = Process(target_function())
        p.start()
        ps.append(p)
    # 让主进程等待子进程进行运行完成后在停止
    for p in ps:
        p.join()

print打印结果：

__main__
主进程ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692
子进程的ID:2692