哗啦啦Python之路

模块

1. configparser

configparser的作用如下：给一个特定格式的文件，这个模块帮你去找特定的东西。它的东西用open也能实现，只是它更方便。

特定格式如下：

[section1]
k1 = 123
k2:v2

[section2]
k1 = 567

使用步骤如下：

1） 把文件交给configparser

config = configparser.ConfigParser()#创建机器
config.read("1.txt",encoding = "utf-8")

2) 检查节点 （section）

has_sec = config.has_section("section1")
print(has_sec)

3) 获取所有节点

ret = config.sections()
print(ret)

4）获取指定节点下的键值对

ret = config.items("section1")
print(ret) #output: [('k1', '123'), ('k2', 'v2')]

5）获取指定节点下的所有键（option）

ret = config.options("section1")
print(ret) #output: ['k1', 'k2']

6）获取指定节点的指定key的值

ret = config.get("section1","k1")
print(ret)

7）删除节点

config.remove_section("section3")
config.write(open("1.txt","w"))

8）添加节点

config.add_section("section3")
config.write(open("1.txt","w"))

9）键值对的操作跟上面一样，只是把section改成option

10) 设置键值对

config.set("section1","k10","123")
config.write(open("1.txt","w"))

2. XML

1)将文件或者字符串读取，获取节点

from xml.etree import ElementTree as ET

#如果XML是文件
tree = ET.parse("2.xml") #把文件搞到内存里，这个tree叫ElementTree
root = tree.getroot() #节点
print(root,root.tag,root.attrib) #节点标签名,属性
#每个节点都是element对象


#如果XML是字符串，比如说网站上的那种
str_xml = open("2.xml","r").read() #可以替换成request返回值
root = ET.XML(str_xml)#字符串类型的XML

2）读取节点和节点里面的节点

for child in root:
    print(child.tag, child.attrib)#每个孩子也都是一个节点
    for grandson in child:
        print(grandson.tag,grandson.attrib,grandson.text) #孙子也都是节点

for node in root.iter("year"):
    print(node.tag, node.text)

3） 修改节点内容，记住，所有修改都是在内存中，所以要回写到文件里

for node in root.iter("year"):
    new_year = int(node.text) +1
    node.text = str(new_year) #将内容里面的时间都加一年
    node.set("name","alex") #设置属性
    del node.attrib["name"] #删除属性
#保存文件
tree = ET.ElementTree(root) #elementtree用来保存文件
tree.write("2.xml",encoding = "utf-8")

4）创建节点

tree = ET.parse("2.xml") #把文件搞到内存里，这个tree叫ElementTree
root = tree.getroot() #节点
ele = ET.Element("alex",attrib = {"age":"18"}) #创建一个element类的对象，因为节点是element
ele.text = "我是内容"
root.append(ele)
tree.write("3.xml",encoding = "utf-8")

5） 创建XML

#如何创建xml
root = ET.Element("family") #创建根节点
son1 = ET.Element("son",{"name":"li"})
grandson = ET.Element("grandson",{"name":"hehe"})
son1.append(grandson)
root.append(son1)
tree = ET.ElementTree(root)
#tree.write("son.xml",encoding = "utf-8")
# #或者用下面这个方式son1 = root.makeelement("son",{"name":"li"})son2 = ET.SubElement(root,"son",{"name":"li"})

6） 加自动缩进

#加自动缩进
from xml.dom import minidom
def prettify(ele):
    rough_string =ET.tostring(ele,"utf-8")
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent = "	")
raw_str = prettify(root)
tree.write("son.xml",encoding="utf-8")
f = open("son.xml","w")
f.write(raw_str)
f.close()

3. shutil 高级文件，文件夹，压缩包，处理模块

import shutil

#拷贝文件内容
shutil.copyfileobj(open("1.txt","r"),open("2.txt","w"))

#拷贝文件
shutil.copyfile("1.txt","2.txt")

#递归地去拷贝文件夹
shutil.copytree("folder1","folder2",ignore = shutil.ignore_patterns("*.pyc"))

#创建压缩包并返回路径,这是将文件夹下面的内容打包放置当前程序目录
ret = shutil.make_archive("1.txt","gztar",root_dir="/user/test")

import zipfile #压缩模块
z = zipfile.ZipFile("1.zip","w") #将a.log装到这个zip包里面
z.write("a.log")
z.close()

z = zipfile.ZipFile("1.zip","r")#解压
z.extractall()
z.namelist() #压缩包里所有的文件名
z.extract("1.txt") #单独解压压缩包里某个文件
z.close()

2） 压缩，解压

import tarfile

压缩
tar = tarfile.open("your.tar","w")
tar.add("1.txt",arcname = "1.txt")
tar.close()

解压
tar.extractall() #可设置解压地址

tar = tarfile.open("your.tar","r")
for item in tar.getmembers():
    print(item)
obj = tar.getmember("1.txt")
tar.extract(obj)
tar.close()

面向对象

1. 面向对象编程实现：发送邮件的功能

#如果是函数发送邮件，下面这种写法
def mail(email,message):
    print("发送")
    return True

mail("hui_zhang_fiona@163.com","gg")

#如果是面向对象：发送邮件的功能
class Foo:
    #函数如果放到类里面，这叫方法
    def mail(self,email,message):
        print("发送")
        return True
#调用方法
# 1）创建对象，类名后面加（）
obj = Foo()
obj.mail("hui_zhang_fiona@163.com","gg")

2. 面向对象的适用范围：对象里能封装参数，这样就不用每次调用对象方法的时候传参数了。

如果一对函数有共同的参数，那么就用面向对象，将参数值一次性封装到对象

class SQLHelper:
    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        pass
    def remove(self, sql):
        pass
    def create(self, sql):
        pass
    def modify(self, sql):
        pass

obj = SQLHelper()
obj.hhost = "salt.com"
obj.uusername = "fiona"
obj.pwd = "123"
obj.fetch("select*from SQL")

3. self是什么？self是一个python自动回给传值的参数，就是上面那个obj

#类里面有个特殊的方法叫init，自动被执行，这个叫构造方法
class SQLHelper:
    def __init__(self,host,username):#构造方法，对象自动执行
        print("自动执行init方法")
        self.hhost = host
        self.username = username
        self.create('sss") #可以类里面调用方法，类里面没有顺序
    def fetch(self,sql):
        print(self.hhost)
        print(self.username)
    def createself, sql):
        pass

obj = SQLHelper("salt.com","alex")
obj.fetch("heheh")

4. 创建人物，掉血

class role():
    def __init__(self,name,age,gender,initial_fight):
        self.name = name
        self.age = age
        self.gender = gender
        self.initial_fight = int(initial_fight)
        if self.initial_fight <= 1000:
            print("死了")
    def dachai(self):
        self.initial_fight -= 100
        print(("{} {} {} {}").format(self.name,self.age,self.gender,self.initial_fight))
    def Kachai(self):
        self.initial_fight -= 100
        print(("{} {} {} {}").format(self.name, self.age, self.gender, self.initial_fight))

a = role("小名",18,"male","1000")
a.dachai()

5. 面向对象三大特性：封装，继承，多态

1) 继承

class Animal:
    def eat(self):
        print("吃")
    def foo(self):
        print(self.name)
class cat(Animal): #继承。Cat是子类，Animal是父类
    def __init__(self,name):
        self.name = name
    def cry(self):
        print("喵")

class dog(Animal):
    def cry(self):
        print("汪")

haha = cat("haha")
haha.eat()
haha.foo()

2）多继承

#多继承
class S0:
    def F1(self):
        print("0")

class S1(S0):
    pass

class S2:
    def F1(self):
        print("2")

class S3(S1,S2): #谁在前面先继承谁
    pass

obj = S3()
obj.F1()