6. 模块pickle\json\random\os\zipfile\面对对象(类的封装 操作 __init__)

1.模块

1.1 pickle模块

# ### pickle 序列化模块
import pickle
"""
序列化:
    把不能够直接存储的数据变得可存储
反序列化:
    把数据恢复成原本的数据格式
    
serialize   序列化
unserialize 反序列化
"""
# 正常情况下,不能够直接把容器类型数据等直接存储在文件当中
"""
with open("ceshi.txt",mode="w",encoding="utf-8") as fp:
    lst = [1,2,3]
    fp.write(lst)
"""

#dumps 把任意对象序列化成一个bytes
lst = [1,2,3,4,5]
res = pickle.dumps(lst)
print(res)

#loads 把任意bytes反序列化成原来数据
res = pickle.loads(res)
print(res,type(res))

# 序列化函数
def func():
    print("我是一个函数")

res = pickle.dumps(func)
print(res)

# 反序列化函数
func = pickle.loads(res)
func()

# 序列化迭代器
from collections import Iterator,Iterable
it = iter(range(10))
print(isinstance(it,Iterator))

res = pickle.dumps(it)
print(res)
res = pickle.loads(res)
print(res)
for i in res:
    print(i)

# dumps 和 loads 把数据存储在文件
setvar = {"a","b"}
with open("ceshi.txt",mode="rb+") as fp:
    res = pickle.dumps(setvar)
    fp.write(res)
    
    # 读取内容的时候,先把光标移动的文件行首.
    fp.seek(0)
    res2 = fp.read()
    print(res2)
    setvar = pickle.loads(res2)
    print(setvar,type(setvar))



#dump  把对象序列化后写入到file-like Object(即文件对象)
def func2():
    print("我是func2")

with open("ceshi02.txt",mode="wb") as fp:
    # 参数1:要序列化的数据 参数2:对应的文件对象
    pickle.dump(func2,fp)

#load  把file-like Object(即文件对象)中的内容拿出来,反序列化成原来数据
with open("ceshi02.txt",mode="rb") as fp:
    func = pickle.load(fp)

# 调用函数
func()

# pickle模块可以序列化所有的数据类型.

1.2 json模块

# ### json
import json
"""
json可以序列化数据,转化成一个字符串.
json格式的数据,可以让所有的编程语言都能够识别,
有数据类型的限制:bool float int list tuple dict str None
"""

# 第一组:dumps 和 loads 用来序列化或反序列化字符串
"""
ensure_ascii=True 是否显示中文 设置ensure_ascii=False 显示中文
sort_keys=True    对字典的键按照ascii进行排序
"""
dic = {"name":"李祖清","age":58,"sex":"man","family":["爸爸","妈妈","姐姐","妹妹"]}
res = json.dumps(dic,ensure_ascii=False,sort_keys=True)
print(res,type(res))

dic = json.loads(res)
print(dic,type(dic))

# 第二组: dump 和 load 用来对数据进行存储
dic = {"name":"李祖清","age":58,"sex":"man","family":["爸爸","妈妈","姐姐","妹妹"]}
with open("ceshi03.json",mode="w",encoding="utf-8") as fp:
   json.dump(dic,fp,ensure_ascii=False)

with open("ceshi03.json",mode="r",encoding="utf-8") as fp:
   dic = json.load(fp)

print(dic,type(dic))

# json 和 pickle 两个模块的区别?

# json 用法特征:
"""
json 可以连续dump,但是不能连续load
load 只可以load一次,它是一次性把所有的数据作为一个整体来进行转化
可以使用loads 来进行解决
"""
dic1 = {'a':1,"b":2}
dic2 = {"c":3,"d":4}

with open("ceshi04.json",mode="w",encoding="utf-8") as fp:
   json.dump(dic1,fp)
   fp.write("\n")
   json.dump(dic2,fp)
   fp.write("\n")

# error 只能load一次,是一次性把所有数据转化.
"""
with open("ceshi04.json",mode="r",encoding="utf-8") as fp:
   res = json.load(fp)
print(res)
"""
# 解决方式
with open("ceshi04.json",mode="r",encoding="utf-8") as fp:
   for line in fp:
      res = json.loads(line)
      print(res)


# pickle 用法特征:
import pickle
"""
pickle 可以连续dump,也可以连续load
"""
dic1 = {'a':1,"b":2}
dic2 = {"c":3,"d":4}

with open("ceshi05.pkl",mode="wb") as fp:  
   pickle.dump(dic1,fp)
   pickle.dump(dic2,fp)

with open("ceshi05.pkl",mode="rb") as fp:
   try:
      while True:
         dic = pickle.load(fp)
         print(dic)
   except:
      pass
print(333)

# 文件对象是迭代器么? 是的!
from collections import Iterator
print(isinstance(fp,Iterator))

"""
try ... except ...
把有问题的代码直接卸载try这个代码块当中,
如果出现异常,直接走except这个代码块,防止报错终止程序.
try:
   print(wangwendashuaiguo)   
except:
   pass
"""


# 总结:
"""

# json 和 pickle 两个模块的区别:
(1)json序列化之后的数据类型是str,所有编程语言都识别,
   但是仅限于(int float bool)(str list tuple dict None)
   json不能连续load,只能一次性拿出所有数据
(2)pickle序列化之后的数据类型是bytes,
   所有数据类型都可转化,但仅限于python之间的存储传输.
   pickle可以连续load,多套数据放到同一个文件中

"""

1.3 random模块

# ### random 随机模块
import random#random() 获取随机0-1之间的小数(左闭右开) 0<= x < 1
res = random.random()
print(res)

#randrange() 随机获取指定范围内的整数(包含开始值,不包含结束值,间隔值)

# 0 1 2 不包含3
res = random.randrange(3)
print(res)

# 1 ~ 4
res = random.randrange(1,5)
print(res)

# 1 4 7 
res = random.randrange(1,10,3)
print(res)

#randint()   随机产生指定范围内的随机整数 (必须两个参数) (了解)
# 1 2 3 4
res = random.randint(1,4)
print(res)
# randint是给1个还是给3个都是错误的,只能给2个参数
# res = random.randint(1,10,3)


#uniform() 获取指定范围内的随机小数(左闭右开) 1 <= x < 3
res = random.uniform(1,3)  # 推荐写法
print(res)
res = random.uniform(2,-1) # 不推荐
print(res)

# a = 2 b =-1
# return a + (b-a) * self.random() (0<= x < 1)
# self.random()  # -1 < x <= 2 
# 2 + (-1-2) * 0 = 2
# 2+  (-1-2) * 1 =  2 - 3 = -1
# 2


#choice()  随机获取序列中的值(多选一)
lst = ["舒则会","郭一萌","银燕","廖萍萍"]
res = random.choice(lst)
print(res)

# 自定义choice
def mychoice():
   length = len(lst)
   res = random.randrange(0,length)
   return lst[res]
print(mychoice())

#sample()  随机获取序列中的值(多选多) [返回列表]
lst = ["舒则会","郭一萌","银燕","银燕2","廖萍萍","刘璐"]
lst = random.sample(lst,3)
print(lst)

#shuffle() 随机打乱序列中的值(直接打乱原序列)
lst = [1,2,3,4,5]
random.shuffle(lst)
print(lst)

# 随机验证码 
def yanzhengma():
   strvar = ""
   for i in range(4):
      # a~z  97 ~ 122 获取小写字母
      res1 = chr(random.randrange(97,123))
      # A~Z  65 ~ 90  获取大写字母
      res2 = chr(random.randrange(65,91))
      # 0~9  获取0~9 十个数字  
      res3 = random.randrange(0,10)
      # 把可能的字符放到列表当中
      lst = [res1,res2,res3]
      # 拼接字符串
      strvar += str(random.choice(lst))
   # 返回字符串
   return strvar

res= yanzhengma()
print(res)

1.4 os模块

# ### os 模块 对系统进行操作
import os

#system()  在python中执行系统命令
# os.system("mspaint")
# os.system("ipconfig")

#popen()   执行系统命令返回对象,通过read方法读出字符串,不会乱码
obj = os.popen("ipconfig")
print(obj.read())

#listdir() 获取指定文件夹中所有内容的名称列表
"""
.  代表的是当前路径
.. 代表的是上一级路径
"""
res = os.listdir(".")
print(res) # ['1.py', '2.py', '20190728_1.json_pickle.mp4', '3.py', '4.py', 'ceshi.txt', 'ceshi02.txt', 'ceshi03.json', 'ceshi04.json', 'ceshi05.pkl', 'ceshi_shengyin.mp4', 'part10.md', 'part11.md']

#getcwd()  获取当前文件所在的默认路径
res = os.getcwd()
print(res) # D:\周末四期\L006
print(__file__) # 完整路径(外加文件名)




#os.mkdir   创建目录(文件夹)
# os.mkdir("ceshi100")
# os.rmdir   删除目录(文件夹)
# os.rmdir("ceshi100")
#os.rename  对文件,目录重命名
# os.rename("ceshi100","ceshi200")

#copy(src,dst)       #复制文件权限和内容
# import shutil
# shutil.copy("ceshi02.txt","ceshi333.py")


#chdir()   修改当前文件工作的默认路径
# os.chdir(r"D:\周末四期\L005")
# os.mkdir("ceshi200")

#environ   获取或修改环境变量
# print(os.environ)
# os.system("QQScLauncher")

# environ 返回的是字典,通过path环境变量,追加路径,在执行命令的时候,一个一个路径取找,如果找到了直接执行,反之报错
'''
print(os.environ["PATH"])
os.environ["PATH"] += r""";C:\Program Files (x86)\Tencent\QQ\Bin"""
os.system("QQScLauncher.exe")
'''

#--os 模块属性
#name 获取系统标识   linux,mac ->posix      windows -> nt
print(os.name)
#sep 获取路径分割符号  linux,mac -> /       window-> \
print(os.sep)
#linesep 获取系统的换行符号  linux,mac -> \n    window->\r\n 或 \n
print(repr(os.linesep))


1.5 os.path 路径

# ### os.path
import os
#abspath()  将相对路径转化为绝对路径
res = os.path.abspath(".")
print(res)

#basename() 返回文件名部分 5颗星
pathvar = r"D:\周末四期\L006\filename.py"
res = os.path.basename(pathvar)
print(res)

#dirname()  返回路径部分 5颗星
pathvar = r"D:\周末四期\L006\filename.py"
res = os.path.dirname(pathvar)
print(res)

# 获取当前文件所在的路径 5颗星
print(os.getcwd())
# 获取完整文件路径 5颗星
print(__file__)

#split() 将路径拆分成单独的文件部分和路径部分 组合成一个元组
# ('D:\\周末四期\\L006', 'filename.py')
pathvar = r"D:\周末四期\L006\filename.py"
res = os.path.split(pathvar)
print(res)


#join()  将多个路径和文件组成新的路径 可以自动通过不同的系统加不同的斜杠  linux / windows\ 5颗星
"""
linux :    /home/wangwen/a.py  
windows:   d:\周末四期\L006\filename.py

# 绝对路径
以 / 开头的是绝对路径 linux
以 盘符开头的完整路径是绝对路径 windows

# 相对路径
.  当前路径
.. 上一级路径

"""
path1 = "周末四期"
path2 = "L006"
path3 = "filename.py"
res = os.path.join(path1,path2,path3) # 推荐
print(res)
res = path1 + os.sep + path2 + os.sep + path3
print(res)

#splitext() 将路径分割为后缀和其他部分
pathvar = r"d:\周末四期\L006\filename.py"
res = os.path.splitext(pathvar)
print(res)

#getsize()  获取文件的大小 5颗星
pathvar = r"D:\周末四期\L006\4.py"
res = os.path.getsize(pathvar)
print(res)

pathvar = r"D:\周末四期\L006"
#isdir()    检测路径是否是一个文件夹 (重点记) 5颗星
res = os.path.isdir(pathvar)
print(res)

#isfile()   检测路径是否是一个文件 (重点记) 5颗星
pathvar = r"D:\周末四期\L006\4.py"
res = os.path.isfile(pathvar)
print(res)

#islink()   检测路径是否是一个链接 (了解)
pathvar = r"D:\周末四期\L006\4.py"
res = os.path.islink(pathvar)
print(res)

#getctime() [windows]文件的创建时间,[linux]权限的改动时间(返回时间戳)
pathvar = r"D:\周末四期\L006\4.py"
res = os.path.getctime(pathvar)
print(res)
import time
str_time = time.ctime(res)
print(str_time)

#getmtime() 获取文件最后一次修改时间(返回时间戳)
res = os.path.getmtime(pathvar)
print(res)
import time
str_time = time.ctime(res)
print(str_time)
#getatime() 获取文件最后一次访问时间(返回时间戳)
res = os.path.getatime(pathvar)
print(res)
import time
str_time = time.ctime(res)
print(str_time)

#exists()   检测指定的路径是否存在 5颗星
res = os.path.exists(r"D:\周末四期\L006\4.py")
print(res)
 
#isabs()    检测一个路径是否是绝对路径  abspath 4颗星
"""
别人传变量给你,先判断是不是绝对路径,如果不是用abspath配合转换.
"""
strvar = "." 
res = os.path.isabs(strvar)
print(res)

1.6 例子计算一个文件夹内所有的文件大小(递归函数)

# ### 计算一个文件夹所有文件的大小
import os
path1 = os.getcwd()
# print(path1)
pathvar = os.path.join(path1,"ceshi300")
# D:\周末四期\L006\ceshi300
print(pathvar)



# part1 基本操作
lst = os.listdir(pathvar)
print(lst)

# 初始化变量size =  0 
size = 0
for i in lst:  

   # 拼接成完整的绝对路径
   pathnew = os.path.join(pathvar,i)
   # 判定它是不是文件
   if os.path.isfile(pathnew):
      print(i,"是一个[文件]")
      # 如果是文件,计算大小 getsize 只能算文件的大小
      size += os.path.getsize(pathnew)
   # 判定它是不是文件夹
   elif os.path.isdir(pathnew):
      print(i,"是一个[文件夹]")
print(size)  # 4834


# part2 递归方法计算文件夹里所有内容大小
def getallsize(pathvar):

   size = 0
   lst = os.listdir(pathvar)
   
   for i in lst:
      pathnew = os.path.join(pathvar,i)
      if os.path.isfile(pathnew):
         print(pathnew)
         # 统计文件大小
         size += os.path.getsize(pathnew)
      elif os.path.isdir(pathnew):   
         print(pathnew) # D:\周末四期\L006\ceshi300\ceshi400
         # 递归统计文件夹里面的文件名称
         size += getallsize(pathnew)
         
   return size
res = getallsize(pathvar)
print(res) # 6882 + 953 2048 4834


1.7 zipfile压缩文件

# ### zipfile 压缩模块 后缀是 zip
import zipfile

# [part1] 压缩文件

# 1.创建压缩包
zf = zipfile.ZipFile("ceshi01.zip","w",zipfile.ZIP_DEFLATED)

# 2.写入文件
# write(路径,别名)
zf.write(r"D:\周末四期\L006\1.py","1111.py")
zf.write(r"D:\周末四期\L006\2.py","22222.py")
# 可以在写入文件的同时,创建一个文件夹
zf.write(r"D:\周末四期\L006\3.py","tmp/333.py")

# 3.关闭文件
zf.close()

# [part2] 解压文件
zf = zipfile.ZipFile("ceshi01.zip","r")
"""
extractall 解压所有
extract    解压单个文件
"""
# 解压所有文件到某个路径下 ./代表当前路径下的某个文件夹sdf
zf.extractall("./ceshi001")
# extract    解压单个文件
zf.extract("1111.py","./ceshi002")
zf.close()

# [part3] 追加文件 自动完成关闭zip压缩包操作
with zipfile.ZipFile("ceshi01.zip","a",zipfile.ZIP_DEFLATED) as zf:
   zf.write("5.py")

# [part4] 查看压缩包中的内容
with zipfile.ZipFile("ceshi01.zip","r",zipfile.ZIP_DEFLATED) as zf:
   lst = zf.namelist()

print(lst)

 2. 面向对象

2.1 面向对象 oop

# ### 面向对象 oop
"""
用几大特征表达一类事物称为一个类,类更像是一张图纸,表达的是一个抽象概念

#对象是类的具体实现,更像是由这图纸产出的具体物品,类只有一个,但对象可以通过这个类实例化出多个
"""

# (1)类的定义
class MyClass:
    pass
    
# 推荐写法
class MyClass():
    pass

class MyClass(object):
    pass

# (2)类的实例化
class Car():
    color = "蓝色"
# 类的实例化 产生的是对象
obj = Car()
print(obj)


# (3)类的基本结构
"""
类中只有两样东西:
    (1)成员属性
    (2)成员方法
"""
# 标准写法
class MyCar():
    # 成员属性
    color="红色"
    # 成员方法
    def run():
        pass

# 例外不标准写法,不推荐使用
"""
类中的逻辑,在定义类的时候,直接执行,这个写法语法上不报错,
但是严令禁止使用
"""
class MyCar():
    if 5==5 :
        print(1233)

# 改造
class MyCar():
    def func():
        if 5==5 :
            print(1233)


# (4)类的命名
"""
推荐使用驼峰命名法:
    每个单词首字符大写;
    myclass => MyClass
    mycar => MyCar
    iloveboy => ILoveBoy
"""

2.2 类的封装

# ### 封装
"""
# 对象的使用方式:
   对象.属性
   对象.方法()
   
"""
class MyCar():
   # 公有成员属性
   pinpai = "布加迪威行"
   
   # 私有成员属性
   __oil = "2.5L"

   # 公有成员方法
   def run(self):
      # self.pinpai <==> obj.pinpai
      print("我的小车会跑",self.pinpai)
      
   # 私有成员方法
   def __oil_info(self):
      print("油耗信息是保密的")
"""
绑定方法:
   (1) 绑定到对象 : 系统会默认把对象当成参数进行传递,让self形参进行接收. ( 对象.方法 )
   (2) 绑定到类   : 系统会默认把类当成参数进行传递,让形参进行接收.( 对象.方法 或 类.方法 通过装饰器修饰)
"""
# 实例化对象 或者 类的实例化 两个名字都可以,都是产生对象
obj = MyCar()


#(1)实例化的对象访问公有成员属性和方法
print(obj.pinpai)
# obj.run(),系统自动把obj这个对象当成参数传递给run方法中self这个参数进行接收.
obj.run()

# (2)实例化的对象动态添加公有成员属性和方法 
# __dict__ 可以获取对象或者类的内部成员 , 它是魔术属性.
print(obj.__dict__) # 第一次为什么打印? 想要告诉你当前对象obj,没有成员 {}
obj.color = "屎黄色" # 添加成员
print(obj.color ) # 屎黄色
print(obj.__dict__) # {'color':'屎黄色'} 

# 动态添加成员方法
# (1) 添加无参方法
def fangxiangpan():
   print("我是制造方向盘的方法")

# 让类外的函数赋值给obj对象的成员方法fangxiangpan
obj.fangxiangpan = fangxiangpan
obj.fangxiangpan()
print(obj.__dict__)

# (2) 添加有参方法
def func(self,something):
   print(self.pinpai,something)
# 将右侧的值赋值给左侧的成员属性func
obj.func = func
# 需要手动把对象传进去,不如使用绑定方法
obj.func(obj,"有参方法")


# 使用绑定方法自动把obj当成参数传递 依靠 MethodType
import types
# MethodType(函数,要绑定在哪个对象上)
# 将创建的绑定方法赋值给成员属性func2,意味着下次调用不需要手动传递该对象,系统会自动帮你传递;
obj.func2 = types.MethodType(func,obj)
obj.func2("有参方法")


# (3) 添加lambda表达式

obj.dahuangfeng = lambda : print("请叫我大黄蜂")
obj.dahuangfeng()
obj.qingtianzhu = lambda n : print(n)
obj.qingtianzhu("擎天柱")


# obj.pinpai = "abc"
print(obj.pinpai)

2.3 类的相关操作

# ### 类的相关操作
"""
语法:
   类.属性
   类.方法()
"""
class Plane():
   # 公有成员属性
   captain = "李祖清"
   # 私有成员属性
   __air_sistem = 20
   
   # 普通公有方法
   def fly():
      # 灰机会飞 20
      print("灰机会飞",Plane.__air_sistem)
   # 普通私有方法
   def __fly2():
      print("空姐数量是保密的")
      
obj = Plane()
# 对象无法调用无参的普通方法,必须要加上self
# obj.fly() error
# (1)定义的类访问公有成员属性和方法

print(Plane.captain)
# 无论是对象还是类,都无法在类外调用类中的私有成员
# print(Plane.__air_sistem) error
Plane.fly()

# 查看类Plane的所有成员
print(Plane.__dict__)



 # (2)定义的类动态添加公有成员属性和方法
Plane.engine = "烧汽油的"
print(Plane.__dict__)
print(obj.__dict__)

# 添加方法
# (1)无参方法
def bianxing():
   print("我的飞机能变成小鸟")
Plane.bianxing = bianxing
Plane.bianxing()


# (2)有参方法
def setname(name):
   print("我的飞机名",name)
Plane.setname = setname
Plane.setname("空军一号")  

   
# (3)lambda表达式
Plane.lunzi = lambda : print("我是制造飞机轮胎的方法")
Plane.lunzi()


"""
调用类中成员的时候,要么使用对象,要么使用类来调用,不能直接写.
对象可以使用类中的相关公有成员,但是没有归属权,
类中的成员都归当前这个类所有,但是不能使用对象中的相关成员

对象中如果有这个成员,用对象自己的
如果没有,用类中的成员.
"""
2.4 删除类对象中的成员

# ### 删除类对象中的成员
class MyCar():
   price="100元"
   __oil= "百公里1升"
   
   # 普通方法
   def bianxing_cat1():   
      print("车会变形成猫",MyCar.price)
      
   # 绑定到对象方法
   def bianxing_cat2(self):
      print("车会变形成猫",self.price)
      
   # 普通私有方法
   def __oil_info1():
      print("油耗信息保密")
      
   # 私有绑定方法
   def __oil_info2(self):
      print("油耗信息保密")
      
   # 定义公有绑定方法
   def pub_func(self):
      print(self.__oil)
      self.__oil_info2()
      
   # 定义公有普通方法
   def pub_func2():
      print(MyCar.__oil)
      MyCar.__oil_info1()
    
# 实例化对象
obj = MyCar()
print(obj.__dict__)
print(MyCar.__dict__)
   
# (1)实例化的对象删除公有成员属性和方法
obj.price = "2元" # 动态为该对象付成员属性price
print(obj.price)
del obj.price # 删除成员属性
print(obj.price)

# func这个成员是一个静态方法,无论是类还是对象都能当成普通方法调用,
"""在类外动态添加成员方法,返回的是静态方法."""
obj.func = lambda  n : print("我是func函数",n)
obj.func(123)
# del obj.func # 删除方法
# obj.func(123) # 删除之后无法调用
   
# (2)定义的类删除公有成员属性和方法
# del MyCar.price
# print(MyCar.price)
# print(obj.price) # 对象无法调用
# MyCar.func(123) # 类无法调用对象中的成员
   
   
# del MyCar.bianxing_cat1
# MyCar.bianxing_cat1()
   
# (3) 可否在类外调用私有成员?
"""
改名策略:
   _类名+私有成员名:比如
   __oil => _MyCar__oil
   __oil_info1 => _MyCar__oil__oil_info1
"""
# 对象的调用
print(obj._MyCar__oil)
obj._MyCar__oil_info2()
# 类的调用
print(MyCar._MyCar__oil)
MyCar._MyCar__oil_info1()
# obj.bianxing_cat2()

print("<==>")
# (4)通过公有方法,调用私有成员
obj.pub_func()
MyCar.pub_func2()
 
2.5 __int__构造方法

# ### 构造方法 __init__
#__init__魔术方法(构造方法)
'''
   触发时机：实例化对象,初始化的时候触发
   功能：为对象添加成员
   参数：参数不固定,至少一个self参数
   返回值：无
'''

# (1) 基本语法
class MyClass():
   def __init__(self):
      self.name = "廖萍萍"

# 实例化对象
obj = MyClass()
print(obj.name)

# (2) 多个参数的__init__
class MyClass():
   def __init__(self,name):
      # self.name (成员属性name) = name (参数name)
      self.name = name
      
# 实例化对象的同时,在括号中加上对应的参数,self是系统自己传递的,name需要手动传递 郭一萌会被name形参接收走,在实例化的时进行赋值.
obj = MyClass("郭一萌")
print(obj.name)

# (3) 综合实力: 类可以有一个,对象可以有多个,不同的对象之间彼此数据隔离
class Children():
   def __init__(self,name,skin):
      self.name = name
      self.skin = skin
   
   def cry(self):
      print("小孩一下生就哭")
   
   def eat(self):
      print("小孩饿了喝奶奶")
      
   def sleep(self):
      print("小孩一天23个小时睡觉,还有一个小时上厕所")
      
   def child_info(self):
      print("该对象姓名:{},肤色是{}".format(self.name,self.skin))
      
# 实例化对象1
child1 = Children("王铁杵","黑色")
child1.cry()
child1.child_info()
   
# 实例化对象2
child2 = Children("廖凡","屎黄色")
child2.eat()
child2.child_info()
   
# 实例化对象3
child3 = Children("王宝强","绿色的")
child3.sleep()
child3.child_info()