print(os.getcwd())

os.chdir("..")

os.makedirs('python2/bin2')

os.removedirs(python2/bin2)

print(os.listdir())

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:\r\n  linux:(:)

os.system('dir')

print(os.path.split(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py'))

print(os.path.dirname(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py'))

print(os.path.basename(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py'))

print(os.path.exists(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py'))

print(os.path.exists(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py'))

a = 'XXX'

b = 'yyy'

print(os.path.join(a,b))  #路径拼接 os.path.join(path1,path2)

print(os.path.getatime(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py')) #返回path所指向的文件或者目录的最后存取时间

print(os.path.getmtime(r'C:\Users\Administrator.PC-20160817HMOW\PycharmProjects\a byte of python\bin.py')) #返回path所指向的文件或目录的最后修改时间

import json

dic = {'name':'alex'}

data = json.dumps(dic)

print(data)
#{"name"："alex"}

import shelve

f = shelve.open('a.txt') #把字典放入文本

f['stu1_info'] = {'name':'alex','age':''}

f['stu2_info'] = {'name':'alvin','age':''}

f['school_info'] = {'website':'oldboyedu.com','city':'beijing'}

f.close()

print(f.get('stu1_info')['age'])#从字典文本中取值

'''

<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>

'''

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

# '''

for node in root.iter("year"):

    new_year = int(node.text) + 1

    node.text = new_year

    node.set("updated","yes")

tree.write("abc.xml")

#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

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":""}) #创建子项目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 = ""

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) #打印

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']

print(re.findall("a\de","a9e"))

['a9e']

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

print(re.findall("a\se","a e"))

['a e']

print(re.findall("a\Se","ade"))

['ade']

print(re.findall("a\we","abea4e"))

['abe', 'a4e']

print(re.findall("a\We","a ea e"))

['a e', 'a e']

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

['ab', 'abccc']

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

['abccc']

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

['ab', 'abc']

print(re.findall("ab{2}c","ab,abbccc"))

['abbc']

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']

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

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

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

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

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

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

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

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

print(re.findall("(abc){2}","abcabc"))
#["abc"]

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

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

print(re.findall("(\d)abc\1","1abc1"))

print(re.findall("(\d)abc\5","5abc5"))

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

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

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

['AbC']

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

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

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

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

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

print(re.findall("(\d)abc(?(1)\d|abc)","1abc3"))

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

#这部分代码有问题 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

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)

#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输出两次是因为每次调用子对象时，会搜索父对象是否在工作？
如果父对象工作，会输出一次父对象内容，父对象有几级，就输出几次打印内容 
'''

#-----------------------------------------------对文件的增加

import configparse

config = configparse.ConfigParser() #config={}

config["DEFAULT"] = {

    "ServerAliveInterval":"",

    "Compression":"yes",

    "CompressionLevel":""

}

config["bitbucket.org"] = {}

config["bitbucket.org"]["user"] = "hg"

config["topsecret.server.com"] = {}

topsecret = config["topsecret.sercer.com"]

topsecret["Host port"] = ""

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","")

config.remove_section("topsecret.server.com") #删除块

config.remove_option("bitbucket.org","user") #删除块下某个键值对

config.write(open("i.cfg","w")) #这种方式不用关闭文件

#摘要算法， 哈希算法

#用于加密相关的操作。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

#两者相同

class Chinese:

    '这是一个类'

    dang='ONLY ONE'

    def sui_di_tu_tan():

        print('朝着墙上就是一口痰')

    def cha_dui(self):

        print('插到了前面')

    def __init__(self,name,age,gender):

        self.mingzi=name  #p1.mingzi=name

        self.nianji=age   #p1.nianji=age

        self.xingbie=gender

#狗的特征

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)

#类编程框架
# 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__)

'''

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中所有的键值对，同时输出系统定义的键值对