os常用模块，json，pickle，shelve模块，正则表达式（实现运算符分离），logging模块，配置模块，路径叠加，哈希算法

一.os常用模块

显示当前工作目录

print(os.getcwd())

返回上一层目录

os.chdir("..")

创建文件包

os.makedirs('python2/bin2')

移除文件包

os.removedirs(python2/bin2)

列出当前目录下所有文件名类型(列出后缀)

print(os.listdir())

查看bin.py属性

print(os.stat('bin.py'))
显示结果如下：os.stat_result(st_mode=33206, st_ino=31806672368655133, st_dev=3627865533, st_nlink=1, st_uid=0, st_gid=0, st_size=47, st_atime=1552409257, st_mtime=1552409257, st_ctime=1552409140)

显示路径分隔符

print(os.sep) #win:
  linux:(:)

打印当前文档所有信息

os.system('dir')

将path分开，目录+文件名，将这两部分放在元祖中

print(os.path.split(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py'))

取出路径的dirname部分

print(os.path.dirname(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py'))

取出绝对路径的basename部分

print(os.path.basename(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py'))

路径存在，输出True，不存在输出False

print(os.path.exists(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py'))

文件是否存在，存在输出True，不存在输出False

print(os.path.exists(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py'))

路径拼接，有两路径：a="xxx"，b="yyy"

a = 'XXX'
b = 'yyy'
print(os.path.join(a,b))  #路径拼接 os.path.join(path1,path2)
print(os.path.getatime(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py')) #返回path所指向的文件或者目录的最后存取时间
print(os.path.getmtime(r'C:UsersAdministrator.PC-20160817HMOWPycharmProjectsa byte of pythonin.py')) #返回path所指向的文件或目录的最后修改时间

二.json,pickle,shelve模块

json模块

import json
dic = {'name':'alex'}
data = json.dumps(dic)
print(data)
#{"name"："alex"}

json模块

json.dump(), json.dumps:dump用于将dict类型的数据转转化为str类型，并写入json文件

json.load(), json.loads():load用于从json文件中读取数据

pickle模块

pickle应用同json，但pickle不可读，计算机可读，支持类型比json多，比如支持类序列化，函数序列化

序列化：把对象从内存中变成可存储或可传输的过程称为序列化，python中为pickling

序列化之后，可以把序列化之后的内容写入磁盘，或者通过网路传输到别的机器上（可传输指前后端交互）

shelve模块

import shelve
f = shelve.open('a.txt') #把字典放入文本
f['stu1_info'] = {'name':'alex','age':'18'}
f['stu2_info'] = {'name':'alvin','age':'20'}
f['school_info'] = {'website':'oldboyedu.com','city':'beijing'}
f.close()
print(f.get('stu1_info')['age'])#从字典文本中取值

xml操作，框架

xml标签语言，闭合标签（有结尾），非闭合标签（无结尾）

'''
<data>
    <...>
    <...>
    <...>
    <...>
</data>
'''
# 比如 如下结构
# <data>
'''
<country name="Liechtenstein">
    <rank updated="yes">2</rank>
    <year updated="yes">2010</year>
    <gdppc>141100</gdppc>
    <neighbor direction="E" name="Austria" />
    <neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
    <rank updated="yes">5</rank>
    <year updated="yes">2013</year>
    <gdppc>59900</gdppc>
    <neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
    <rank updated="yes">69</rank>
    <year updated="yes">2013</year>
    <gdppc>13600</gdppc>
    <neighbor direction="W" name="Costa Rica" />
    <neighbor direction="E" name="Colombia" />
</country>
</data>
'''

xml操作基本步骤

1.xml查找

import xml.etree.ElementTree as ET
# import as 简写
tree = ET.parse("xml_lesson.xml")
root = tree.getroot() #拿到根结点地址
print(root.tag) #tag=根结点标签名字 输出data
for i in root: #打印根结点子对象  i是每个country
    print(i) #输出country对象地址
    print(i.tag) #输出country
    for j in i:
        print(j.tag) #输出所有country对象名字

for i in root:
    print(i.tag)
    print(i.attrib) #输出对象属性，比如第一个country中neighbor,数据类型是字典，name="Austria"
for i in root:
    for j in i:
        print(i.text) #输出对象属性，比如第一个country中neighbor，数据类型是字符串，"Austria"
for node in root.iter('year'):
    print(node.tag,node.text)
'''
输出
# year 2008
# year 2011
# year 2011
# '''

2.查找并写入xml

for node in root.iter("year"):
    new_year = int(node.text) + 1
    node.text = new_year
    node.set("updated","yes")
tree.write("abc.xml")

3.删除node节点

#5删除node
for country in root.findall("country"):
    rank = int(country.find("rank").text)
    if rank > 50:
        root.remove(country)
tree.write("output.xml") #输出xml,同时更新修改后的xml

创建xml文本：创建缩写，创建xml项目名，创建子项目，将元素树保留，赋值给et，文件操作写入yyk.xml

import xml.etree.ElementTree as ET #1缩写标记
new_xml = ET.Element("yyk") #2创建xml项目名
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"}) #3创建子项目 创建子项目1
age = ET.SubElement(name,"age",attrib={"checked":"33"}) #创建子项目1 age属性的第一种操作方法
sex = ET.SubElement(name,"sex") #性别子元素
sex.text = "male" #性别文本
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"}) #创建子项目2
age = ET.SubElement(name2,"age")
age.text = "19"

et = ET.ElementTree(new_xml) #4将元素树保留，幅值给et
et.write("yyk.xml",encoding="utf-8",xml_declaration=True) #5文件操作写入yyk.xml  4+5固定格式
ET.dump(new_xml) #打印

三.正则表达式：

1.字符

“.”匹配任意字符串（除换行符外）

print(re.findall("b.","bbbbbbb"))
['bb', 'bb', 'bb']

“”转义字符，“.”失去本身含义，因为“”是转义符，使"."失去匹配任意字符串的功能

print(re.findall("a.c","a.c"))
['a.c']

"[...]"字符集，对应位置可以是字符集中任意字符

print(re.findall("a[bcd]e","abeaceaded"))
['abe', 'ace', 'ade']

2.预定义字符

“d”数字

print(re.findall("ade","a9e"))
['a9e']

"D"非数字

print(re.findall("aDe","a$eaFe"))
['a$e', 'aFe']

"s"空白字符: [<空格>, fv]

print(re.findall("ase","a e"))
['a e']

"S"非空白字符：[^s]

print(re.findall("aSe","ade"))
['ade']

w单词字符：[A-Za-z0-9]

print(re.findall("awe","abea4e"))
['abe', 'a4e']

W非单词字符：[^w]

print(re.findall("aWe","a ea e"))
['a e', 'a e']

3.数量词(用在字符或...之后)

"*"匹配一个字符0次或无限次

print(re.findall("abc*","ab,abccc"))
['ab', 'abccc']

"+"匹配资格字符1次或无限次

print(re.findall("abc+","ab,abccc"))
['abccc']

"?"匹配前一个字符0次或1次

print(re.findall("abc?","ab,abccc"))
['ab', 'abc']

{m}匹配前一个字符m次

print(re.findall("ab{2}c","ab,abbccc"))
['abbc']

{m,n}匹配前一个字符m至n次，m和n可以省略，若m省略，则匹配0-n次；若n省略，则匹配m-无限次

print(re.findall("ab{1,2}c","abbc"))
print(re.findall("ab{1,}c","abbbc"))
print(re.findall("ab{,3}c","ac"))
['abbc']
['abbbc']
['ac']

*?,+?,??,{m,n}?：使* + ? {m,n} 变成非贪婪模式

 4.边界匹配：不消耗待匹配字符串中的字符

"^":匹配字符串开头，在多行模式中匹配每一行的开头

print(re.findall("^abc","abc2ddf"))

"$":匹配字符串末尾，在多行模式中匹配每一行的末尾

print(re.findall("abc$","abc2abc"))

"A"仅匹配字符串开头一个字符，没有多行模式

print(re.findall("Aabc","abc23abc"))

""仅匹配字符串末尾，没有多行模式

print(re.findall("abc","abc"))

"":分割数字与非字母数字边界

print(re.split("123\b","==123!! abc123. 123	abc 123"))
显示结果为：['==', '!! abc', '. ', '	abc ', '']

"B":分割字母与字母数字的边界

print(re.split(r"pycB","1python py5 2pyc342 pyc1py2py4 pyp3 3pyc# pyc")) #r表示源生字符串

5.逻辑，分组

"|"代表左右表达式任意匹配一个，先匹配左边的表达式，一旦匹配成功则跳过匹配右边的表达式，如果"|"没有被包括在()中，则匹配范围是整个正则表达式

print(re.findall("abc|def","abcdf33"))
print(re.findall("abc|def","213def"))

"(...)"被括号的表达式将作为分组，从表达式左边开始每遇到一个分组的左括号"（"，编号+1

分组表达式作为一个整体，可以后接数量词，表达式中的"|"仅在该组中有效

print(re.findall("(abc){2}","abcabc"))
#["abc"]
print(re.findall("a(123|456)c","a456c")) #仅匹配括号中的字段
#["456"]

(?P<name>...) 分组，除了原有的编号外再指定一个额外的别名

print(re.findall("(?P<id>abc){2}","abcabc"))

引用标号为<number>的分组匹配到的字符串

print(re.findall("(d)abc1","1abc1"))
print(re.findall("(d)abc5","5abc5"))

引用别名为<name>的分组匹配到到的字符串

print(re.findall("(?P<id>D)abc(?P=id)","!abc!"))

6.其它

6.1 "(?:...)" (...)的不分组版本，用于使用"|"或后接数量词

print(re.findall("(?:abc){2}","abcabc"))

6.2 "?:Lmsux" 每个字符代表一个匹配模式，只能用在正则表达式开头，对”完整匹配的字符串“进行模糊匹配输出”完整匹配字符串“字段

print(re.findall("(?i)ABC","AbC"))
['AbC']

6.3 "(?#...)" #后的内容将作为注释被忽略

print(re.findall("abc(?#comment)123","abc123"))

6.4 "a(?=...)" a之后字符串内容需要是数字，匹配成功

print(re.findall("a(?=d)","a5 b4 a3"))

6.5 "a(?!...)" a之后字符串内容不需要是数字，匹配成功

print(re.findall("a(?!d)","a!dfadd"))

6.6 "(?<=d)a" a之前的字符是数字，匹配成功输出a

print(re.findall("(?<=d)a","dd2a!df23adda"))

6.7 "(?<!d)a" a之前的字符不是数字，匹配成功输出a

print(re.findall("(?<!d)a","dd2a!df23adda"))

6.8 "?(id ame)yes-pattern|no-pattern" 如果编号为id/别名为name的组匹配到字符，则需要匹配yes-pattern,否则需要匹配no-pattern. no-pattern可以省略

print(re.findall("(d)abc(?(1)d|abc)","1abc3"))
#(d)匹配1 abc匹配abc  ?后面的(1)匹配id d匹配name,数字组 3代表匹配数字组，与表达式中第二个d匹配成功，输出yes-pattern,否则为no-pattern，不输出内容

7.re模块实例

用re模块找出最内层括号，找出"*"和"/"两边数字，找出"+"和”-“两边数字

#这部分代码有问题 1不能用正则处理*/两边的数，2不能用计算出来的值代替原有括号中的值
import re
str = "  (1+2*(3+(4+523*61+3*223))*6)"
str = re.sub(" ","",str)
while True:
    if re.search("D",str):
        # print(str.replace(" ",""))
        # print(re.sub(" ","",str))
        # print(len(re.findall("(",str)))
        # print(len(re.findall("[a-zA-Z]",str)))
        temp = re.findall("([^()]*)",str)[0]
        val = temp[1:-1]
        val_1 = re.split("+",val)
        print(val_1) #['4', '523*61', '3*223']
        for num in range(len(val_1)):
            if '*' in val_1[num]:
                print(val_1[num]) #val_2是带有*的表达式 523*61 3*223
                res = re.split("*",val_1[num])
                multi_res = int(res[0])*int(res[1])
                print(multi_res)
                val_1[num] = multi_res
            else:
                val_1[num] = int(val_1[num])
        # for j in range(len(val_1)):
        temp = sum(val_1)
        print(temp)
    else:
        break

8.利用正则表达式做计算器

分6个步骤，未理解（'d+(.d+)?[*/]-?d+(.d+)?'）代表取出字符串中*/以及两边数字；（'[-+]?d(?:.d+)?'）代表取出字符串中+-以及两边数字。算法优化分6个步骤

import re
from functools import reduce
brackets = re.compile("([^()]+)")
mulDiv_regular = re.compile('d+(.d+)?[*/]-?d+(.d+)?')
addSub_regular = re.compile('[-+]?d+(?:.d+)?')

def addSub(inner_num):
    inner_first = addSub_regular.findall(inner_num) #找到所有加减符号两边的数字,带符号
    return str(reduce(lambda x,y: float(x) + float(y), inner_first)) #加减识别  实现累加操作  第一次reduce()返回传入进去的第一个值，第二次第一个值赋给y,第二个值赋给x，以上值均进行带符号赋值

def cal_mulDiv(aut_bracket):
    if "*" in aut_bracket:
        x,y = re.split("*",aut_bracket)
        return float(x)*float(y)
    elif "/" in aut_bracket:
        x,y = re.split("/",aut_bracket)
        return float(x)/float(y)

def mulDiv(str_innerest):
    while True:
        inner_first = mulDiv_regular.search(str_innerest)
        if not inner_first:break  #判断最终有没有乘除号
        mul_Div_mulDiv = inner_first.group()
        # print(aut_mulDiv) 提取所有乘除号和两边的数字
        # 对取到的算式切割取数字运算,但数字是字符串类型,要用float强转为float类型
        # 负数也能通过数据类型强转进行转换
        mul_Div_mulDiv_res = cal_mulDiv(mul_Div_mulDiv)
        str_innerest = str_innerest.replace(mul_Div_mulDiv,str(mul_Div_mulDiv_res))
    return str_innerest

def format_str_innerest(trans_format):
    trans_format = trans_format.replace("--","+") #识别乘除后字符串中的所有加减符号,并对其进行替换操作
    trans_format = trans_format.replace("+-","-")
    trans_format = trans_format.replace("++","+")
    trans_format = trans_format.replace("-+","-")
    return trans_format

def cal_innerest_bracket(str_innerest): #对括号中内容进行处理,原则先乘除后加减，最终返回计算结果
    str_innerest = mulDiv(str_innerest)
    str_innerest = format_str_innerest(str_innerest) #比如一个算式计算出结果后得到:40++1680,格式转化后得到40+1680;如果40+-1680,那么是40-1680
    return addSub(str_innerest)

if __name__ == "__main__":
    s1 = "1-2*((60-30 +(9-2*5/3+7/3*99/4*2998+10*568/14)*(-40 / 5))-(-4*3)/(16-3*2))"
    s = s1.replace(" ","")
    while True:
        innerest_bracket = brackets.search(s) #1找到最内层括号
        if not innerest_bracket:break #2如果找完了，括号内为空，则不进入判断语句 ，调出循环
        innerest_bracket = innerest_bracket.group() #3re.search()提取最内层括号的值
        res = cal_innerest_bracket(innerest_bracket) #4计算括号里值的表达式
        s = s.replace(innerest_bracket,res) #5计算得到的结果替换4中值（连同括号）
    res_last = cal_innerest_bracket(s) #6作为最后一次进入cal_innerest_bracket函数没有括号时计算值的结果
    res_eval = eval(s1)
    print(res_last,"_______",res_eval)

9..logging模块

#logging 显示信息根据级别定
#--------------------------logging---------------
'''
import logging
logging.basicConfig(
    level = logging.DEBUG,
    filename = "logger.log",
    filemode = "w",
    format = "%(asctime)s %(filename)s[%(lineno)d] %(message)"
) #asctime结构化时间
logging.basicConfig(level=logging.DEBUG)
logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")
'''
#上述代码输出一下内容
'''
2016-12-14 11:51:31,276 logging.py[14] debug message
2016-12-14 11:51:31,276 logging.py[15] info message
2016-12-14 2016-12-14 11:51:31,276 logging.py[16] warning message
2016-12-14 11:51:31,276 logging.py[17] errpr message
2016-12-14 11:51:31,276 logging.py[18] critical message
'''
#--------------------------------------logger-------------------

def logger():
    logger = logging.getLogger()
    fh = logging.FileHandler("logging") #向loggingtext中发送文件内容
    ch=logging.StreamHandler() #向屏幕上发送文件内容
    fm = logging.Formatter("%(asctime)s %(message)s") #输入要输出的格式
    fh.setFormatter(fm) #fh,ch设置输出格式
    ch.setFormatter(ch)
    logger.addHandler(fh) #l向ogger中添加入fh,ch
    logger.addHandler(ch)
    logger.setLevel("DEBUG")
    #-----------------------------------以下调用logger
    logger.debug("hello")
    logger.info("hello")
    logger.warning("warning")
    logger.error("error")
    logger.critical("critical")

#------------------------------------------ 
import logging logger = logging.getLogger() 
#创建根用户，根logger对象；根用户下有两个对象mylogger 
logger.setLevel(logging.WARNING)#设置logger等级  
logger1 = logging.getLogger("mylogger") #导入logging模块 
logger1.setLevel(logging.DEBUG)#设置logger1等级 # logger2 = logging.getLogger("mylogger") # logger2.setLevel(logging.WARNING)  
fh = logging.FileHandler("test_log_new") #把logging中的内容添加到test_log_new 
ch = logging.StreamHandler() #向屏幕中投射logging传过来的内容  
logger.addHandler(ch) #往logger中添加ch和fh内容 
logger.addHandler(fh) logger1.addHandler(fh) #往logger1中添加ch和fh内容 
logger1.addHandler(ch) # logger2.addHandler(fh) # logger2.addHandler(ch)  
logger.debug("logger debug message") logger.info("logger info message") 
logger.warning("logger warning message") logger.error("logger error message") 
logger.critical("logger critical message") 
logger1.debug("logger1 debug message") 
logger1.info("logger1 info message") 
logger1.warning("logger1 warning message") 
logger1.error("logger1 error message") 
logger1.critical("logger1 critical message") 
''' 
上述代码输出以下内容 
logger warning message logger error 
message logger critical message logger1 
debug message logger1 info message logger1 
warning message logger1 error message logger1 
critical message logger1 debug message logger1 
info message logger1 warning message logger1 error
 message logger1 critical message 
注意点： 
1.子对象的名字不能重复，否则第一次子对象输出被覆盖 
2.logger1输出两次是因为每次调用子对象时，会搜索父对象是否在工作？
如果父对象工作，会输出一次父对象内容，父对象有几级，就输出几次打印内容 
'''

10.logging日志级别顺序：critical > error > warning > info >debug

11.文件配置

#-----------------------------------------------对文件的增加
import configparse
config = configparse.ConfigParser() #config={}
config["DEFAULT"] = {
    "ServerAliveInterval":"45",
    "Compression":"yes",
    "CompressionLevel":"9"
}
config["bitbucket.org"] = {}
config["bitbucket.org"]["user"] = "hg"

config["topsecret.server.com"] = {}
topsecret = config["topsecret.sercer.com"]
topsecret["Host port"] = "50022"
topsecret["ForwardX11"] = "no"
with open("example.ini","w") as configfile:
    config.write(configfile) #区别于原先句柄f的写入方式f.write()
#--------------------------------------------------对文件的修改

import configparse
config = configparse.ConfigParser()
print(config.sections())
config.read("example.ini") #取出除了DEFAULT外其余的块
print(config.sections())
print("bytebong.com" in config) #判断bytebong块是否在config中，输出False
print(config["bitbucket.org"]["User"]) #hg 查阅取值大小写五关
print(config["DEFAULT"]["Compression"]) #yes
print(config["topsecret.server.com"]["ForwardX11"]) #no
for key in config["bitbucket.org"]:
    print(key) #遍历bitbucket.org中的user,同时遍历出DEFAULT
print(config.oprions("bitbucket.org")) #把用户的key放入列表中
print(config.items("bitbucket.org")) #输出key and value
print(config.get("bitbucket.org","compression"))#yes
#-----------------------------------------------------对文件的删除
config.add_section('yuan') #加入新块
config.set("yuan","k1","1111")
config.remove_section("topsecret.server.com") #删除块
config.remove_option("bitbucket.org","user") #删除块下某个键值对
config.write(open("i.cfg","w")) #这种方式不用关闭文件

12.多个路径进行路径拼接

from module import yuyukun，首先找到yuyukun.py的绝对路径，比如不在module文件夹下，那么此时拼接moduleyuyukun.py这个路径，如图1所示：

图1 路径拼接

文件执行从bin.py出发(所以要导入lhf.py的绝对路径)-->lhf.py(要导入cal.py的绝对路径)-->cal.py

13.多个文件模块互相导入分析

(bin.py在module package下面，module在day023文件夹下面，cal.py和lhf.py在module下面

a>bin.py执行，导入lhf.py模块，接着执行lhf.cal.add(3,4)这条代码时，命令转到lhf.py中；

b>执行lhf.py，导入cal.py模块，命令转到cal.py中；

c>执行cal.py，执行语句def add(x,y): return x+y 

d>最后c>返回b>,b>返回a>，输出a>中结果

如图2所示：

图2 模块互相调用

总结import模块2点：1文件绝对路径设置正确；2文件最终在bin.py中执行

7.哈希算法，摘要算法

#摘要算法， 哈希算法
#用于加密相关的操作。3.x代替md5模块和sha模块，主要提供SHA1,SHA224,SHA256,SHA384,SHA512,MD5模块
import hashlib  #1.md5不能反解；2.只能正解，正解后比较
obj = hashlib.md5("hello".encode("utf8"))   #生成密文1，在正式加密之前添加一条字符串密文
obj.update("admin".encode("utf8")) #生成加密2，此时obj已添加入hello,此时再加入admin后加密，所以不能将密文反解得到正文
print(obj.hexdigest()) #16进制输出
#以hello+admin输出得到 #dbba06b11d94596b7169d83fed72e61b
#或者以helloadmin一个整体字符串得到 #dbba06b11d94596b7169d83fed72e61b
#两者相同

复习字符串分割操作：str = '1234'; 按照‘2’分割; str.split('2'); 得到结果['1','3']

8.面向对象编程引入

三大编程范式：a)面向过程；b)函数式；c)面向对象（类+对象）

c1)类：具体一个特定功能的类别（特征+属性），形如

class Chinese:
    '这是一个类'
    dang='ONLY ONE'
    def sui_di_tu_tan():
        print('朝着墙上就是一口痰')
    def cha_dui(self):
        print('插到了前面')

c2)对象：基于类而创建的一个具体的事物，具有抽象特征，抽象属性，形如

    def __init__(self,name,age,gender):
        self.mingzi=name  #p1.mingzi=name
        self.nianji=age   #p1.nianji=age
        self.xingbie=gender

9.类属性（数据属性和函数属性）

a)数据属性负责处理初始化__init__（self）中的内容

b)函数属性负责给类调用

9.1 面向对象(本人代码丢失，为了节省时间和方便理解，以下代码来自linhaifeng老师)

#狗的特征
dog1={
    'name':'元昊',
    'gender':'母',
    'type':'藏獒'
}
dog2={
    'name':'alex',
    'gender':'母',
    'type':'腊肠',
}
person1={
    'name':'武sir',
    'gender':'母',
    'type':'人'
}

def dog(name,gender,type):
    # 狗的动作
    def jiao(dog):
        print('一条狗[%s]，汪汪汪' % dog['name'])
    def chi_shi(dog):
        print('一条[%s] 正在吃屎' % dog['type'])
    def init(name,gender,type):
        dog1 = {
            'name':name,
            'gender': gender,
            'type': type,
            'jiao':jiao,
            'chi_shi':chi_shi,
        }
        return dog1
    return init(name,gender,type)

d1=dog('元昊','母','中华田园犬')
d2=dog('alex','母','藏敖')
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2)

9.2类相关介绍

#类编程框架
# class Chinese:
#     '这是一个类'
#     pass
#
# print(Chinese) #输出类名
# p1=Chinese() #实例化
# print(p1) #输出类对象地址

'''
1.数据属性
2.函数属性
'''

class Chinese:
    '这是一个类'
    dang='ONLY ONE'
    def sui_di_tu_tan():
        print('朝着墙上就是一口痰')
    def cha_dui(self):
        print('插到了前面')

# print(Chinese.dang) #类的第一种调用方法
# Chinese.sui_di_tu_tan()
# Chinese.cha_dui('元昊')
# print(Chinese.__dict__['dang']) #类的第二种调用方法
# Chinese.__dict__['sui_di_tu_tan']()
# Chinese.__dict__['cha_dui'](1)
print(Chinese.__name__)
print(Chinese.__doc__)
print(Chinese.__module__)

9.3 对象数据属性和函数属性综合实例

'''
1.数据属性
2.函数属性
'''
class Chinese:
    '这是一个的类'
    dang='dang'
    def __init__(self,name,age,gender):
        # print('我是初始化函数，我开始运行了')
        self.mingzi=name  #p1.mingzi=name
        self.nianji=age   #p1.nianji=age
        self.xingbie=gender
        # print('我结束啦')
    def sui_di_tu_tan(self):
        print('%s 朝着墙上就是。。' %self.mingzi)
    def cha_dui(self):
        print(self) #self输出类对象地址
        print('%s 插到了前面' %self.mingzi)
    def eat_food(self,food):
        print('%s 正在吃%s' %(self.mingzi,food))
p1=Chinese('元昊',18,'female') #--->__init__(self,name,age,gender)
p1.eat_food('XX')
p1.cha_dui() #调用插队函数
p1.sui_di_tu_tan() #默认传送self
Chinese.sui_di_tu_tan(p1)
p2=Chinese('武sir',10000,'姑娘')
p2.eat_food('韭菜馅饼')
print(p1.__dict__) #区别p1.__dict__ 和dir(p1)  p1.__dict__输出对象中包括的变量;输出python本身具有的键值对
print(dir(p1)) #区别p1.__dict__ 和dir(p1)  p1.__dict__输出对象中包括的变量;输出python本身具有的键值对
print(p1.__dict__['xingbie']) #这种方式调用只能取到对象内部变量
print(p1.dang) #对象内部没有dang变量，继续在对象外部找，找到类中的变量定义
print(Chinese.__dict__) #输出Chinese中所有的键值对，同时输出系统定义的键值对

9.4类和对象功能图

图3 实例和类的关系与区别