>>> import copy
>>> dir(copy)
['Error', 'PyStringMap', '_EmptyClass', '__all__', '__builtins__', '__cached__',
 '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_c
opy_dispatch', '_copy_immutable', '_copy_with_constructor', '_copy_with_copy_met
hod', '_deepcopy_atomic', '_deepcopy_dict', '_deepcopy_dispatch', '_deepcopy_lis
t', '_deepcopy_method', '_deepcopy_tuple', '_keep_alive', '_reconstruct', 'built
ins', 'copy', 'deepcopy', 'dispatch_table', 'error', 'name', 't', 'weakref']
>>> [x for x in dir(copy) if not x.startswith('_')]
['Error', 'PyStringMap', 'builtins', 'copy', 'deepcopy', 'dispatch_table', 'erro
r', 'name', 't', 'weakref']

>>> copy.__all__
['Error', 'copy', 'deepcopy']

>>> help(copy)
Help on module copy:

NAME
    copy - Generic (shallow and deep) copying operations.

DESCRIPTION
    Interface summary:
....


>>> help(copy.copy)
Help on function copy in module copy:

copy(x)
    Shallow copy operation on arbitrary Python objects.

    See the module's __doc__ string for more info.

>>> copy.__file__
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python35\\lib\\copy
.py'

>>> random.__all__
['Random', 'seed', 'random', 'uniform', 'randint', 'choice', 'sample', 'randrang
e', 'shuffle', 'normalvariate', 'lognormvariate', 'expovariate', 'vonmisesvariat
e', 'gammavariate', 'triangular', 'gauss', 'betavariate', 'paretovariate', 'weib
ullvariate', 'getstate', 'setstate', 'getrandbits', 'SystemRandom']

import fileinput, re

pat = re.compile('Form: (.*) <.*?>$')  #*、+限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。

for line in fileinput.input():
    m = pat.search(line)
    if m:
        print(m.group(1))

>>> import re
>>> pat = re.compile("<(.*)>")
>>> st = "a email from <ld@qq.com>"
>>> ret = pat.search(st)
>>> ret
<_sre.SRE_Match object; span=(13, 24), match='<ld@qq.com>'>

>>> st2 = "a email from ld@qq.com"
>>> ret2 = pat.search(st2)
>>> ret2
>>>

import re
st = 'a email from <ld@qq.com>'
pat = re.compile("<(.*)>")

ret3 = pat.match(st)
print(ret3)        #None  因为字符串开头没有匹配到

st = '<ld@qq.com> a email from '

pat = re.compile("<(.*)>")

ret3 = pat.match(st)　　　　#匹配数据出现在开头，才能够被匹配

print(ret3)  #<_sre.SRE_Match object; span=(0, 11), match='<ld@qq.com>'>

some_text = "alpha, fawfgwa,,,,,fwafaw  fwafaaaa"

pat = re.compile('[, ]+')  #[]  中括号中的任意数据

ret = pat.split(some_text)

print(ret)  #['alpha', 'fawfgwa', 'fwafaw', 'fwafaaaa']

some_text = "[faw非f]服务[wfw发a]adawf[你faw]"

pat = re.compile('\[(.*?)\]')  #记得取消贪婪模式*和+后面加上?

ret = pat.findall(some_text)

print(ret)  #['faw非f', 'wfw发a', '你faw']

some_text = "[faw非f]服务[wfw发a]adawf[你faw]"

pat = re.compile('faw')  #记得取消贪婪模式*和+后面加上?

ret = pat.sub(" haha ",some_text,2)

print(ret)  #[ haha 非f]服务[wfw发a]adawf[你 haha ]

some_text = "\. *+?"

ret = re.escape(some_text)

print(ret)  #\\\.\ \*\+\?

st = 'https://www.baidu.com'
pat = re.compile("https://((.*?)\.(.*?)\.(.*))")

ret3 = pat.search(st)

print(ret3)     #<_sre.SRE_Match object; span=(0, 21), match='https://www.baidu.com'>
print(ret3.group(0))    #https://www.baidu.com
print(ret3.group(1))    #www.baidu.com
print(ret3.group(2))    #www
print(ret3.group(3))    #baidu
print(ret3.group(4))    #com

st = 'https://www.baidu.com'
pat = re.compile("https://((.*?)\.(.*?)\.(.*))")

ret3 = pat.search(st)

print(ret3.group(2))    #www
print(ret3.span(2))     #(8, 11)
print(ret3.start(2))    #8
print(ret3.end(2))      #11

<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2023</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2026</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2026</year>
        <gdppc>13600</gdppc>
        <neighbor direction="W" name="Costa Rica" />
        <neighbor direction="E" name="Colombia" />
    </country>
</data>

from xml.etree import ElementTree as ET

#打开文件，读取xml内容
str_xml = open('ts.xml','r').read()

#将字符串解析为xml文档对象，获取xml文件的根节点
root = ET.XML(str_xml)

print(root)  #<Element 'data' at 0x253b7b8>

from xml.etree import ElementTree as ET

tree = ET.parse('ts.xml')   #获取整个文档树<xml.etree.ElementTree.ElementTree object at 0x00000000024C6EB8>

root = tree.getroot()   #获取根节点<Element 'data' at 0x24ce7f0>

class Element(object):
    # <tag attrib>text<child/>...</tag>tail

    ##
    # (Attribute) Element tag.

    tag = None

    ##
    # (Attribute) Element attribute dictionary.  Where possible, use
    # {@link #Element.get},
    # {@link #Element.set},
    # {@link #Element.keys}, and
    # {@link #Element.items} to access
    # element attributes.

    attrib = None

    ##
    # (Attribute) Text before first subelement.  This is either a
    # string or the value None.  Note that if there was no text, this
    # attribute may be either None or an empty string, depending on
    # the parser.

    text = None

    ##
    # (Attribute) Text after this element's end tag, but before the
    # next sibling element's start tag.  This is either a string or
    # the value None.  Note that if there was no text, this attribute
    # may be either None or an empty string, depending on the parser.

    tail = None # text after end tag, if any

    # constructor

    def __init__(self, tag, attrib={}, **extra):
        attrib = attrib.copy()
        attrib.update(extra)
        self.tag = tag
        self.attrib = attrib
        self._children = []

    def __repr__(self):
        return "<Element %s at 0x%x>" % (repr(self.tag), id(self))

    ##
    # Creates a new element object of the same type as this element.
    #
    # @param tag Element tag.
    # @param attrib Element attributes, given as a dictionary.
    # @return A new element instance.

    def makeelement(self, tag, attrib):
        return self.__class__(tag, attrib)

    ##
    # (Experimental) Copies the current element.  This creates a
    # shallow copy; subelements will be shared with the original tree.
    #
    # @return A new element instance.

    def copy(self):
        elem = self.makeelement(self.tag, self.attrib)
        elem.text = self.text
        elem.tail = self.tail
        elem[:] = self
        return elem

    ##
    # Returns the number of subelements.  Note that this only counts
    # full elements; to check if there's any content in an element, you
    # have to check both the length and the <b>text</b> attribute.
    #
    # @return The number of subelements.

    def __len__(self):
        return len(self._children)

    def __nonzero__(self):
        warnings.warn(
            "The behavior of this method will change in future versions.  "
            "Use specific 'len(elem)' or 'elem is not None' test instead.",
            FutureWarning, stacklevel=2
            )
        return len(self._children) != 0 # emulate old behaviour, for now

    ##
    # Returns the given subelement, by index.
    #
    # @param index What subelement to return.
    # @return The given subelement.
    # @exception IndexError If the given element does not exist.

    def __getitem__(self, index):
        return self._children[index]

    ##
    # Replaces the given subelement, by index.
    #
    # @param index What subelement to replace.
    # @param element The new element value.
    # @exception IndexError If the given element does not exist.

    def __setitem__(self, index, element):
        # if isinstance(index, slice):
        #     for elt in element:
        #         assert iselement(elt)
        # else:
        #     assert iselement(element)
        self._children[index] = element

    ##
    # Deletes the given subelement, by index.
    #
    # @param index What subelement to delete.
    # @exception IndexError If the given element does not exist.

    def __delitem__(self, index):
        del self._children[index]

    ##
    # Adds a subelement to the end of this element.  In document order,
    # the new element will appear after the last existing subelement (or
    # directly after the text, if it's the first subelement), but before
    # the end tag for this element.
    #
    # @param element The element to add.

    def append(self, element):
        # assert iselement(element)
        self._children.append(element)

    ##
    # Appends subelements from a sequence.
    #
    # @param elements A sequence object with zero or more elements.
    # @since 1.3

    def extend(self, elements):
        # for element in elements:
        #     assert iselement(element)
        self._children.extend(elements)

    ##
    # Inserts a subelement at the given position in this element.
    #
    # @param index Where to insert the new subelement.

    def insert(self, index, element):
        # assert iselement(element)
        self._children.insert(index, element)

    ##
    # Removes a matching subelement.  Unlike the <b>find</b> methods,
    # this method compares elements based on identity, not on tag
    # value or contents.  To remove subelements by other means, the
    # easiest way is often to use a list comprehension to select what
    # elements to keep, and use slice assignment to update the parent
    # element.
    #
    # @param element What element to remove.
    # @exception ValueError If a matching element could not be found.

    def remove(self, element):
        # assert iselement(element)
        self._children.remove(element)

    ##
    # (Deprecated) Returns all subelements.  The elements are returned
    # in document order.
    #
    # @return A list of subelements.
    # @defreturn list of Element instances

    def getchildren(self):
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'list(elem)' or iteration over elem instead.",
            DeprecationWarning, stacklevel=2
            )
        return self._children

    ##
    # Finds the first matching subelement, by tag name or path.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return The first matching element, or None if no element was found.
    # @defreturn Element or None

    def find(self, path, namespaces=None):
        return ElementPath.find(self, path, namespaces)

    ##
    # Finds text for the first matching subelement, by tag name or path.
    #
    # @param path What element to look for.
    # @param default What to return if the element was not found.
    # @keyparam namespaces Optional namespace prefix map.
    # @return The text content of the first matching element, or the
    #     default value no element was found.  Note that if the element
    #     is found, but has no text content, this method returns an
    #     empty string.
    # @defreturn string

    def findtext(self, path, default=None, namespaces=None):
        return ElementPath.findtext(self, path, default, namespaces)

    ##
    # Finds all matching subelements, by tag name or path.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return A list or other sequence containing all matching elements,
    #    in document order.
    # @defreturn list of Element instances

    def findall(self, path, namespaces=None):
        return ElementPath.findall(self, path, namespaces)

    ##
    # Finds all matching subelements, by tag name or path.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return An iterator or sequence containing all matching elements,
    #    in document order.
    # @defreturn a generated sequence of Element instances

    def iterfind(self, path, namespaces=None):
        return ElementPath.iterfind(self, path, namespaces)

    ##
    # Resets an element.  This function removes all subelements, clears
    # all attributes, and sets the <b>text</b> and <b>tail</b> attributes
    # to None.

    def clear(self):
        self.attrib.clear()
        self._children = []
        self.text = self.tail = None

    ##
    # Gets an element attribute.  Equivalent to <b>attrib.get</b>, but
    # some implementations may handle this a bit more efficiently.
    #
    # @param key What attribute to look for.
    # @param default What to return if the attribute was not found.
    # @return The attribute value, or the default value, if the
    #     attribute was not found.
    # @defreturn string or None

    def get(self, key, default=None):
        return self.attrib.get(key, default)

    ##
    # Sets an element attribute.  Equivalent to <b>attrib[key] = value</b>,
    # but some implementations may handle this a bit more efficiently.
    #
    # @param key What attribute to set.
    # @param value The attribute value.

    def set(self, key, value):
        self.attrib[key] = value

    ##
    # Gets a list of attribute names.  The names are returned in an
    # arbitrary order (just like for an ordinary Python dictionary).
    # Equivalent to <b>attrib.keys()</b>.
    #
    # @return A list of element attribute names.
    # @defreturn list of strings

    def keys(self):
        return self.attrib.keys()

    ##
    # Gets element attributes, as a sequence.  The attributes are
    # returned in an arbitrary order.  Equivalent to <b>attrib.items()</b>.
    #
    # @return A list of (name, value) tuples for all attributes.
    # @defreturn list of (string, string) tuples

    def items(self):
        return self.attrib.items()

    ##
    # Creates a tree iterator.  The iterator loops over this element
    # and all subelements, in document order, and returns all elements
    # with a matching tag.
    # <p>
    # If the tree structure is modified during iteration, new or removed
    # elements may or may not be included.  To get a stable set, use the
    # list() function on the iterator, and loop over the resulting list.
    #
    # @param tag What tags to look for (default is to return all elements).
    # @return An iterator containing all the matching elements.
    # @defreturn iterator

    def iter(self, tag=None):
        if tag == "*":
            tag = None
        if tag is None or self.tag == tag:
            yield self
        for e in self._children:
            for e in e.iter(tag):
                yield e

    # compatibility
    def getiterator(self, tag=None):
        # Change for a DeprecationWarning in 1.4
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'elem.iter()' or 'list(elem.iter())' instead.",
            PendingDeprecationWarning, stacklevel=2
        )
        return list(self.iter(tag))

    ##
    # Creates a text iterator.  The iterator loops over this element
    # and all subelements, in document order, and returns all inner
    # text.
    #
    # @return An iterator containing all inner text.
    # @defreturn iterator

    def itertext(self):
        tag = self.tag
        if not isinstance(tag, basestring) and tag is not None:
            return
        if self.text:
            yield self.text
        for e in self:
            for s in e.itertext():
                yield s
            if e.tail:
                yield e.tail

tree = ET.parse('ts.xml')   #获取整个文档树<xml.etree.ElementTree.ElementTree object at 0x00000000024C6EB8>

root = tree.getroot()   #获取根节点<Element 'data' at 0x24ce7f0>

first_rank = root.iter('rank')
for item in first_rank:
    print(item.tag,item.attrib,item.text,item.tail)
输出结果：
('rank', {'updated': 'yes'}, '2', '\n        ')
('rank', {'updated': 'yes'}, '5', '\n        ')
('rank', {'updated': 'yes'}, '69', '\n        ')

from xml.etree import ElementTree as ET

tree = ET.parse('ts.xml')   #获取整个文档树<xml.etree.ElementTree.ElementTree object at 0x00000000024C6EB8>

root = tree.getroot()   #获取根节点<Element 'data' at 0x24ce7f0>

#已知节点共3层
#遍历第二层
for child in root:
    print(child.tag,child.attrib)
    #遍历第三层
    for item in child:
        print('---%s-%s'%(item.tag,item.text),item.attrib)

from xml.etree import ElementTree as ET

data = open("ts.xml","r").read()
root = ET.XML(data)

for item in root.iter("rank"):
    #排名内容加一
    new_rank = int(item.text) + 1
    item.text = str(new_rank)   #注意只能是字符串，否则TypeError

    #添加/修改属性
    item.set('name','dsa')

    #删除属性
    del item.attrib['name']  #因为属性本来就是字典


#上面操作都是在内存中进行的，我们需要将他保存在文件中
#而保存数据，需要树结构，然后向树中添加数据（将根节点添加上去，数据都会添加，就像链表一样）
#保数据
tree = ET.ElementTree(root)
tree.write("newts.xml",encoding="utf-8")

from xml.etree import ElementTree as ET

tree = ET.parse('ts.xml')   #获取整个文档树<xml.etree.ElementTree.ElementTree object at 0x00000000024C6EB8>
root = tree.getroot()   #获取根节点<Element 'data' at 0x24ce7f0>

for item in root.iter("rank"):
    #排名内容加一
    new_rank = int(item.text) + 1
    item.text = str(new_rank)   #注意只能是字符串，否则TypeError

    #添加/修改属性
    item.set('name','dsa')

    #删除属性
    del item.attrib['name']  #因为属性本来就是字典


#保数据
#树在解析文件时已经存在，这棵树是包含所有数据的（包括根节点）
tree.write("newts.xml",encoding="utf-8")

from xml.etree import ElementTree as ET

tree = ET.parse('ts.xml')   #获取整个文档树<xml.etree.ElementTree.ElementTree object at 0x00000000024C6EB8>
root = tree.getroot()   #获取根节点<Element 'data' at 0x24ce7f0>

for item in root.findall("country"):
    #排名小于大于50删除
    rank = int(item.find("rank").text)
    if rank > 50:
        root.remove(item)   #remove是根据父来移除子


#上面操作都是在内存中进行的，我们需要将他保存在文件中
#而保存数据，需要树结构，而且每个树需要一个根节点
#保数据
tree = ET.ElementTree(root)
tree.write("newts.xml",encoding="utf-8")

from xml.etree import ElementTree as ET

#创建元素
root = ET.Element("School")

major1 = ET.Element("major",{'name':"材料"})
major2 = ET.Element("major",{'name':"计算机"})

classes1 = ET.Element("class")
classes1.text = "3"

classes2 = ET.Element("class")
classes2.text = "5"
#创建连接关系

#专业添加班级数
major1.append(classes1)
major2.append(classes2)

#根节点添加专业
root.append(major1)
root.append(major2)

#保存
tree = ET.ElementTree(root)
tree.write("school.xml",encoding="utf-8",xml_declaration=True)

from xml.etree import ElementTree as ET
import sys

#创建元素
root = ET.Element("School")
print(sys.getdefaultencoding()) #ascii
reload(sys)
sys.setdefaultencoding("utf-8")

major1 = ET.Element("major",{'name':"材料"})
major2 = ET.Element("major",{'name':"计算机"})

classes1 = ET.Element("class")
classes1.text = "3"

classes2 = ET.Element("class")
classes2.text = "5"
#创建连接关系

#专业添加班级数
major1.append(classes1)
major2.append(classes2)

#根节点添加专业
root.append(major1)
root.append(major2)

#保存
tree = ET.ElementTree(root)
tree.write("school.xml",encoding="utf-8",xml_declaration=True)

from xml.etree import ElementTree as ET


#创建元素
root = ET.Element("School")

major1 = root.makeelement("major",{'name':"材料"})
major2 = root.makeelement("major",{'name':"计算机"})

classes1 = major1.makeelement("class",{})
classes1.text = "3"

classes2 = major2.makeelement("class",{})
classes2.text = "5"
#创建连接关系

#专业添加班级数
major1.append(classes1)
major2.append(classes2)

#根节点添加专业
root.append(major1)
root.append(major2)

#保存
tree = ET.ElementTree(root)
tree.write("school2.xml",encoding="utf-8",xml_declaration=True)

major1 = root.makeelement("major",{'name':"材料"})
major2 = root.makeelement("major",{'name':"计算机"})

classes1 = major1.makeelement("class",{})
classes1.text = "3"

classes2 = major2.makeelement("class",{})
classes2.text = "5"
#创建连接关系

#专业添加班级数
major1.append(classes2)
major2.append(classes1)


#从这个例子中不难看出，这里只是单纯的创建一个独立的节点。对于是谁（哪个节点）创建的他，并没有任何关联
上面例子中使用    “材料”创建班级3个，“计算机”创建班级5个，但是添加关系时，调换顺序后，依然成功。所以说。这个功能有点鸡肋。要想实现可以直接使用Element类创建，或者使用sunelement方法

from xml.etree import ElementTree as ET


#创建元素
root = ET.Element("School")

major1 = ET.SubElement(root,"major",{'name':"材料"})
major2 = ET.SubElement(root,"major",{'name':"计算机"})

classes1 = ET.SubElement(major1,"class",{})
classes1.text = "3"

classes2 = ET.SubElement(major2,"class",{})
classes2.text = "5"

#保存
tree = ET.ElementTree(root)
tree.write("school3.xml",encoding="utf-8",xml_declaration=True)

from xml.etree import ElementTree as ET
from xml.dom import minidom

#对xml节点转换为字符串进行缩进处理
def prettify(elem):
    '''
    对xml节点转换为字符串进行缩进处理
    :param elem:
    :return:
    '''
    elem_str = ET.tostring(elem,encoding="utf-8")   #先解析为字符串
    reparsed = minidom.parseString(elem_str)        #再将字符串解析为dom对象，因为dom中含有可以处理缩进的方法
    return reparsed.toprettyxml(indent='\t')        #将dom对象转换为字符串（其中添加缩进）

#创建元素
root = ET.Element("School")

major1 = ET.SubElement(root,"major",{'name':"材料"})
major2 = ET.SubElement(root,"major",{'name':"计算机"})

classes1 = ET.SubElement(major1,"class",{})
classes1.text = "3"

classes2 = ET.SubElement(major2,"class",{})
classes2.text = "5"

raw_string = prettify(root)

#保存
fp = open("school5.xml","w",encoding="utf-8")
fp.write(raw_string)
fp.close()

ET.register_namespace('com',"http://www.company.com") #some name

# build a tree structure
root = ET.Element("{http://www.company.com}STUFF")
body = ET.SubElement(root, "{http://www.company.com}MORE_STUFF", attrib={"{http://www.company.com}hhh": "123"})
body.text = "STUFF EVERYWHERE!"

# wrap it in an ElementTree instance, and save as XML
tree = ET.ElementTree(root)

import shutil

shutil.copyfileobj(open('school3.xml','r',encoding="utf-8"),open('new_sch.xml','w',encoding="utf-8"))

import shutil

shutil.copyfile('school3.xml','new_sch3.xml')

import shutil

shutil.copymode('newts.xml','2.xml')

import shutil

shutil.copystat('newts.xml','2.xml')

import shutil

ret = shutil.copy('newts.xml','2.xml')  #返回目的文件名
print(ret)#2.xml

import shutil

ret = shutil.copy2('newts.xml','2.xml')  #返回目的文件名
print(ret)#2.xml

import shutil

ret = shutil.copytree("D:/MyPython/day24/基础回顾","D:/tree/")

import shutil

ret = shutil.move("1.xml","D:/MyPython/day24/基础回顾")

import shutil

ret = shutil.rmtree("D:/MyPython/day24/基础回顾/02")

import shutil

ret = shutil.make_archive("3","zip",base_dir="D:/MyPython/day24/基础回顾/03/1.xml")  #返回目的文件名
print(ret)#3.zip

其中3.zip中目录结构是：MyPython/day24/基础回顾/03/1.xml

import shutil

ret = shutil.make_archive("3","zip",root_dir="D:/MyPython/day24/基础回顾/03/")  #返回目的文件名
print(ret)#D:\MyPython\day24\基础回顾\01装饰器\3.zip

#其中3.zip中是root_dir目录下的文件及目录

import shutil

ret = shutil.make_archive("3","zip",root_dir="D:/MyPython/day24/基础回顾/02/",base_dir="D:/MyPython/day24/基础回顾/03/2.xml")  #返回目的文件名
print(ret)#D:\MyPython\day24\基础回顾\01装饰器\3.zip

#其中内容会是 MyPython/day24/基础回顾/03/2.xml，几乎与root_dir无关了，但是加上root_dir会返回压缩文件的全路径

import shutil

shutil.unpack_archive("3.zip")

# Example MySQL config file for small systems.
#
# This is for a system with little memory (<= 64M) where MySQL is only used
# from time to time and it's important that the mysqld daemon
# doesn't use much resources.
#
# MySQL programs look for option files in a set of
# locations which depend on the deployment platform.
# You can copy this option file to one of those
# locations. For information about these locations, see:
# http://dev.mysql.com/doc/mysql/en/option-files.html
#
# In this file, you can use all long options that a program supports.
# If you want to know which options a program supports, run the program
# with the "--help" option.

# The following options will be passed to all MySQL clients
[client]
#password    = your_password
port        = 3306
socket        = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server
[mysqld]
port        = 3306
socket        = /tmp/mysql.sock
;skip-external-locking
key_buffer_size = 16K
max_allowed_packet = 1M
table_open_cache = 4
sort_buffer_size = 64K
read_buffer_size = 256K
read_rnd_buffer_size = 256K
net_buffer_length = 2K
thread_stack = 128K

# Don't listen on a TCP/IP port at all. This can be a security enhancement,
# if all processes that need to connect to mysqld run on the same host.
# All interaction with mysqld must be made via Unix sockets or named pipes.
# Note that using this option without enabling named pipes on Windows
# (using the "enable-named-pipe" option) will render mysqld useless!
# 
#skip-networking
server-id    = 1

# Uncomment the following if you want to log updates
#log-bin=mysql-bin

# binary logging format - mixed recommended
#binlog_format=mixed

# Causes updates to non-transactional engines using statement format to be
# written directly to binary log. Before using this option make sure that
# there are no dependencies between transactional and non-transactional
# tables such as in the statement INSERT INTO t_myisam SELECT * FROM
# t_innodb; otherwise, slaves may diverge from the master.
#binlog_direct_non_transactional_updates=TRUE

# Uncomment the following if you are using InnoDB tables
#innodb_data_home_dir = C:\\mysql\\data\\
#innodb_data_file_path = ibdata1:10M:autoextend
#innodb_log_group_home_dir = C:\\mysql\\data\\
# You can set .._buffer_pool_size up to 50 - 80 %
# of RAM but beware of setting memory usage too high
#innodb_buffer_pool_size = 16M
#innodb_additional_mem_pool_size = 2M
# Set .._log_file_size to 25 % of buffer pool size
#innodb_log_file_size = 5M
#innodb_log_buffer_size = 8M
#innodb_flush_log_at_trx_commit = 1
#innodb_lock_wait_timeout = 50

[mysqldump]
;quick
max_allowed_packet = 16M

[mysql]
;no-auto-rehash
# Remove the next comment character if you are not familiar with SQL
#safe-updates

[myisamchk]
key_buffer_size = 8M
sort_buffer_size = 8M

[mysqlhotcopy]
;interactive-timeout

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0