Day04——Python模組

Rangle發表於2018-01-25

一、模組簡介

模組是實現了某個功能的程式碼集合，比如幾個.py檔案可以組成程式碼集合即模組。其中常見的模組有os模組（系統相關）,file模組（檔案操作相關）

模組主要分三類：

自定義模組：所謂自定義模組，即自己編寫Python檔案組成的模組。
第三方模組：採用其他人編寫的模組，即第三方提供的模組
內建模組：python內建的模組

二、模組匯入

匯入模組的方法有好幾種方式，其中可以直接匯入，也可匯入模組的方法

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename 
from module.xx.xx import *

匯入模組其實就是告訴Python直譯器去解釋那個py檔案

匯入一個py檔案，直譯器解釋該py檔案
匯入一個包，直譯器解釋該包下的 __init__.py 檔案【py2.7】

注意：

　　匯入模組時候，預設讀取的路徑為sys.path，可以通過下面的方法檢視當前系統預設路徑：　　

import sys
print sys.path

輸出結果如下：
['', '/usr/lib64/python2.7/site-packages/MySQL_python-1.2.5-py2.7-linux-x86_64.egg', '/usr/lib/python2.7/site-packages/setuptools-19.4-py2.7.egg', '/usr/lib/python2.7/site-packages/Django-1.8.8-py2.7.egg', '/usr/lib/python2.7/site-packages/django_pagination-1.0.7-py2.7.egg', '/usr/lib64/python27.zip', '/usr/lib64/python2.7', '/usr/lib64/python2.7/plat-linux2', '/usr/lib64/python2.7/lib-tk', '/usr/lib64/python2.7/lib-old', '/usr/lib64/python2.7/lib-dynload', '/usr/lib64/python2.7/site-packages', '/usr/lib/python2.7/site-packages']

　　匯入模組時候，如果其不再預設路徑裡，則可以通過以下方法將其加入預設路徑

import sys
import os
project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(project_path)

三、常用內建模組

內建模組是Python自帶的功能，在使用時，需要先匯入再使用

1、sys模組

用於提供python直譯器相關操作

import sys

sys.argv           命令列引數List，第一個元素是程式本身路徑
sys.exit(n)        退出程式，正常退出時exit(0)
sys.version        獲取Python解釋程式的版本資訊
sys.maxint         最大的Int值
sys.path           返回模組的搜尋路徑，初始化時使用PYTHONPATH環境變數的值
sys.platform       返回作業系統平臺名稱
sys.stdin          輸入相關
sys.stdout         輸出相關
sys.stderror       錯誤相關

2、os模組

提供系統級別的操作

os.getcwd()                 獲取當前工作目錄，即當前python指令碼工作的目錄路徑
os.chdir("dirname")         改變當前指令碼工作目錄；相當於shell下cd
os.curdir                   返回當前目錄: ('.')
os.pardir                   獲取當前目錄的父目錄字串名：('..')
os.makedirs('dir1/dir2')    可生成多層遞迴目錄
os.removedirs('dirname1')   若目錄為空，則刪除，並遞迴到上一級目錄，如若也為空，則刪除，依此類推
os.mkdir('dirname')         生成單級目錄；相當於shell中mkdir dirname
os.rmdir('dirname')         刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname
os.listdir('dirname')       列出指定目錄下的所有檔案和子目錄，包括隱藏檔案，並以列表方式列印
os.remove()                 刪除一個檔案
os.rename("oldname","new")  重新命名檔案/目錄
os.stat('path/filename')    獲取檔案/目錄資訊
os.sep                      作業系統特定的路徑分隔符，win下為"\\",Linux下為"/"
os.linesep                  當前平臺使用的行終止符，win下為"\t\n",Linux下為"\n"
os.pathsep                  用於分割檔案路徑的字串
os.name                     字串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command")   執行shell命令，直接顯示
os.environ                  獲取系統環境變數
os.path.abspath(path)       返回path規範化的絕對路徑
os.path.split(path)         將path分割成目錄和檔名二元組返回
os.path.dirname(path)       返回path的目錄。其實就是os.path.split(path)的第一個元素
os.path.basename(path)      返回path最後的檔名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)         如果path是絕對路徑，返回True
os.path.isfile(path)        如果path是一個存在的檔案，返回True。否則返回False
os.path.isdir(path)         如果path是一個存在的目錄，則返回True。否則返回False
os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑之前的引數將被忽略
os.path.getatime(path)      返回path所指向的檔案或者目錄的最後存取時間
os.path.getmtime(path)      返回path所指向的檔案或者目錄的最後修改時間

3、hashlib模組

用於加密相關的操作，代替了md5模組和sha模組，主要提供SHA1，SHA224，SHA256，SHA384，SHA512，MD5演算法

import hashlib
 
# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())
 
 
######## sha1 ########
 
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha256 ########
 
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
 
# ######## sha384 ########
 
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha512 ########
 
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

hashlib直接加密可能會被裝庫破解密碼，所以這裡我們可以通過在加密演算法中自定義key做加密，具體示例如下：

import hashlib
 
# ######## md5 ########
 
hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

Python內建模組hmac可以對我們建立key和內容進行進一步的處理，然後加密

import hmac
 
h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))
h.update(bytes('admin',encoding="utf-8"))
print(h.hexdigest())

4、random模組

用於產生隨機數的模組

import random

random.random()                ##隨機取(0-1）之間的數值
0.9151227988883402
random.randint(1,3)            ##隨機取[m-n]之間的整數
3
random.randrange(1,5)            ##隨機取[m-n)之間的整數
1
random.choice('chinese')    ##隨機取一個字元或列表數值
's'
random.choice([1,5,'abc'])
1
random.sample('hello',2)    ##從字串中隨機取出N個字元
['h', 'l']
random.uniform(3,10)        ##從區間(m,n)中取浮點數
7.797497264321265
l=[1,2,3,4,5]                ##讓有序列表變無序
random.shuffle(l)            
l
[2, 4, 1, 5, 3]

編寫由數字和字母組成的4位驗證碼程式：（##大寫字母ascii:65-90,小寫字母：97-122）

#!/usr/bin/env python
# -*- UTF-8 -*-
# Author:Rangle

##大寫字母ascii:65-90,小寫字母：97-122

import  random
check_code=''

for i in range(4):
    num=random.randint(0,3)
    if num==i:
        num1=random.randint(0,3)
        if num==num1:
            code = chr(random.randint(65, 90))
        else:
            code = chr(random.randint(97,122))
    else:
        code=random.randint(1,9)
    check_code+=str(code)

print(check_code)

5、re模組

re提供正規表示式相關操作

字元：
　　. 匹配除換行符以外的任意字元
　　\w 匹配字母或數字或下劃線或漢字
　　\s 匹配任意的空白符
　　\d 匹配數字
　　\b 匹配單詞的開始或結束
　　^ 匹配字串的開始
　　$ 匹配字串的結束

次數：
　 * 重複零次或更多次
　　+ 重複一次或更多次
　　? 重複零次或一次
　　{n} 重複n次
　　{n,} 重複n次或更多次
　　{n,m} 重複n到m次

match：

match，從起始位置開始匹配，匹配成功返回一個物件，未匹配成功返回None
match(pattern, string, flags=0)

# match，從起始位置開始匹配，匹配成功返回一個物件，未匹配成功返回None
 
 
 match(pattern, string, flags=0)
 # pattern： 正則模型
 # string ： 要匹配的字串
 # falgs  ： 匹配模式
     X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
     I  IGNORECASE  Perform case-insensitive matching.
     M  MULTILINE   "^" matches the beginning of lines (after a newline)
                    as well as the string.
                    "$" matches the end of lines (before a newline) as well
                    as the end of the string.
     S  DOTALL      "." matches any character at all, including the newline.
 
     A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D
                    match the corresponding ASCII character categories
                    (rather than the whole Unicode categories, which is the
                    default).
                    For bytes patterns, this flag is the only available
                    behaviour and needn't be specified.
      
     L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
     U  UNICODE     For compatibility only. Ignored for string patterns (it
                    is the default), and forbidden for bytes patterns.

match語法

# 無分組
        r = re.match("h\w+", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組結果

        # 有分組

        # 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的區域性內容提取出來）

        r = re.match("h(\w+).*(?P<name>\d)$", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組中所有執行了key的組

Demo

match示例

search:

search,瀏覽整個字串去匹配第一個，未匹配成功返回None
search(pattern, string, flags=0)

# 無分組

        r = re.search("a\w+", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組結果

        # 有分組

        r = re.search("a(\w+).*(?P<name>\d)$", origin)
        print(r.group())     # 獲取匹配到的所有結果
        print(r.groups())    # 獲取模型中匹配到的分組結果
        print(r.groupdict()) # 獲取模型中匹配到的分組中所有執行了key的組

demo

search示例

findall:

findall，獲取非重複的匹配列表；如果有一個組則以列表形式返回，且每一個匹配均是字串；如果模型中有多個組，則以列表形式返回，且每一個匹配均是元祖；
空的匹配也會包含在結果中
findall(pattern, string, flags=0)

# 無分組
        r = re.findall("a\w+",origin)
        print(r)

        # 有分組
        origin = "hello alex bcd abcd lge acd 19"
        r = re.findall("a((\w*)c)(d)", origin)
        print(r)

Demo

findall示例

sub：

替換匹配成功的指定位置字串

sub(pattern, repl, string, count=0, flags=0)
pattern：正則模型
repl ：要替換的字串或可執行物件
string ：要匹配的字串
count ：指定匹配個數
flags ：匹配模式

# 與分組無關
origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a\w+", "999", origin, 2)
print(r)

sub示例

split:

split，根據正則匹配分割字串

split(pattern, string, maxsplit=0, flags=0)
pattern：正則模型
string ：要匹配的字串
maxsplit：指定分割個數
flags ：匹配模式

# 無分組
        origin = "hello alex bcd alex lge alex acd 19"
        r = re.split("alex", origin, 1)
        print(r)

        # 有分組
        
        origin = "hello alex bcd alex lge alex acd 19"
        r1 = re.split("(alex)", origin, 1)
        print(r1)
        r2 = re.split("(al(ex))", origin, 1)
        print(r2)

Demo

split示例

常用正則匹配：

IP：
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
手機號：
^1[3|4|5|8][0-9]\d{8}$
郵箱：
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

6、序列化模組

Python中用於序列化的兩個模組

json 用於【字串】和【python基本資料型別】間進行轉換
pickle 用於【python特有的型別】和【python基本資料型別】間進行轉換

Json模組提供了四個功能：dumps、dump、loads、load
pickle模組提供了四個功能：dumps、dump、loads、load

#!/usr/bin/env python
# -*- UTF-8 -*-
# Author:Rangle
import  json
import  pickle

data={'k1':123,'k2':'lucy'}

p_str=pickle.dumps(data)    ##將資料通過特殊形式轉化為只有Python語言認識的字串
print(p_str)

with open('F:\\python_project\\Day03\\test.txt','wb+') as fp:
    p_str=pickle.dump(data,fp)    ##將資料通過特殊形式轉化為只有Python語言認識的字串,並寫入檔案


j_str=json.dumps(data)      ##將資料通過特殊形式轉為所有程式都認識的字串
print(j_str)

with open('F:\\python_project\\Day03\\test1.txt','w+') as fp:
    j_str=json.dump(data,fp)    ##將資料通過特殊形式轉化為所有程式認識的字串，並寫入檔案

7、configparser模組

configparser用於處理特定格式的檔案，其本質上是利用open來操作檔案。

檔名為xxx000的內容如下：

# 註釋1
;  註釋2
 
[section1] # 節點
k1 = v1    # 值
k2:v2       # 值
 
[section2] # 節點
k1 = v1    # 值

指定格式

具體操作示例如下：

（1）獲取檔案中所有節點
import configparser
 
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.sections()
print(ret)
（2）獲取指定節點的所有鍵值對
import configparser
 
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.items('section1')
print(ret)
（3）獲取指定節點的所有的鍵
import configparser
 
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
ret = config.options('section1')
print(ret)
（4）獲取指定節點下指定key的值
import configparser
 
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
 
 
v = config.get('section1', 'k1')
# v = config.getint('section1', 'k1')
# v = config.getfloat('section1', 'k1')
# v = config.getboolean('section1', 'k1')
 
print(v)
（5）檢查、刪除、新增節點
import configparser
 
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
 
 
# 檢查
has_sec = config.has_section('section1')
print(has_sec)
 
# 新增節點
config.add_section("SEC_1")
config.write(open('xxxooo', 'w'))
 
# 刪除節點
config.remove_section("SEC_1")
config.write(open('xxxooo', 'w'))
（6）檢查、刪除、設定指定組內的鍵值對
import configparser
 
config = configparser.ConfigParser()
config.read('xxxooo', encoding='utf-8')
 
# 檢查
has_opt = config.has_option('section1', 'k1')
print(has_opt)
 
# 刪除
config.remove_option('section1', 'k1')
config.write(open('xxxooo', 'w'))
 
# 設定
config.set('section1', 'k10', "123")
config.write(open('xxxooo', 'w'))

8、xml模組

XML是實現不同語言或程式之間進行資料交換的協議，XML檔案格式如下：

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

(1)解析xml

#!/usr/bin/env python
# -*- UTF-8 -*-
# Author:Rangle
from xml.etree import ElementTree as ET


# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)

print(str_xml)
#利用ElementTree.XML將字串解析成xml物件

#!/usr/bin/env python
# -*- UTF-8 -*-
# Author:Rangle
from xml.etree import ElementTree as ET

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

#利用ElementTree.parse將檔案直接解析成xml物件

(2)操作xml

XML格式型別是節點巢狀節點，對於每一個節點均有以下功能，以便對當前節點進行操作：

class Element:
    """An XML element.

    This class is the reference implementation of the Element interface.

    An element's length is its number of subelements.  That means if you
    want to check if an element is truly empty, you should check BOTH
    its length AND its text attribute.

    The element tag, attribute names, and attribute values can be either
    bytes or strings.

    *tag* is the element name.  *attrib* is an optional dictionary containing
    element attributes. *extra* are additional element attributes given as
    keyword arguments.

    Example form:
        <tag attrib>text<child/>...</tag>tail

    """

    當前節點的標籤名
    tag = None
    """The element's name."""

    當前節點的屬性

    attrib = None
    """Dictionary of the element's attributes."""

    當前節點的內容
    text = None
    """
    Text before first subelement. This is either a string or the value None.
    Note that if there is no text, this attribute may be either
    None or the empty string, depending on the parser.

    """

    tail = None
    """
    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.

    """

    def __init__(self, tag, attrib={}, **extra):
        if not isinstance(attrib, dict):
            raise TypeError("attrib must be dict, not %s" % (
                attrib.__class__.__name__,))
        attrib = attrib.copy()
        attrib.update(extra)
        self.tag = tag
        self.attrib = attrib
        self._children = []

    def __repr__(self):
        return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self))

    def makeelement(self, tag, attrib):
        建立一個新節點
        """Create a new element with the same type.

        *tag* is a string containing the element name.
        *attrib* is a dictionary containing the element attributes.

        Do not call this method, use the SubElement factory function instead.

        """
        return self.__class__(tag, attrib)

    def copy(self):
        """Return copy of current element.

        This creates a shallow copy. Subelements will be shared with the
        original tree.

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

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

    def __bool__(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

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

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

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

    def append(self, subelement):
        為當前節點追加一個子節點
        """Add *subelement* to the end of this element.

        The new element will appear in document order after the last existing
        subelement (or directly after the text, if it's the first subelement),
        but before the end tag for this element.

        """
        self._assert_is_element(subelement)
        self._children.append(subelement)

    def extend(self, elements):
        為當前節點擴充套件 n 個子節點
        """Append subelements from a sequence.

        *elements* is a sequence with zero or more elements.

        """
        for element in elements:
            self._assert_is_element(element)
        self._children.extend(elements)

    def insert(self, index, subelement):
        在當前節點的子節點中插入某個節點，即：為當前節點建立子節點，然後插入指定位置
        """Insert *subelement* at position *index*."""
        self._assert_is_element(subelement)
        self._children.insert(index, subelement)

    def _assert_is_element(self, e):
        # Need to refer to the actual Python implementation, not the
        # shadowing C implementation.
        if not isinstance(e, _Element_Py):
            raise TypeError('expected an Element, not %s' % type(e).__name__)

    def remove(self, subelement):
        在當前節點在子節點中刪除某個節點
        """Remove matching subelement.

        Unlike the find methods, this method compares elements based on
        identity, NOT ON tag value or contents.  To remove subelements by
        other means, the easiest way is to use a list comprehension to
        select what elements to keep, and then use slice assignment to update
        the parent element.

        ValueError is raised if a matching element could not be found.

        """
        # assert iselement(element)
        self._children.remove(subelement)

    def getchildren(self):
        獲取所有的子節點（廢棄）
        """(Deprecated) Return all subelements.

        Elements are returned in document order.

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

    def find(self, path, namespaces=None):
        獲取第一個尋找到的子節點
        """Find first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        return ElementPath.find(self, path, namespaces)

    def findtext(self, path, default=None, namespaces=None):
        獲取第一個尋找到的子節點的內容
        """Find text for first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *default* is the value to return if the element was not found,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return text content of first matching element, or default value if
        none was found.  Note that if an element is found having no text
        content, the empty string is returned.

        """
        return ElementPath.findtext(self, path, default, namespaces)

    def findall(self, path, namespaces=None):
        獲取所有的子節點
        """Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Returns list containing all matching elements in document order.

        """
        return ElementPath.findall(self, path, namespaces)

    def iterfind(self, path, namespaces=None):
        獲取所有指定的節點，並建立一個迭代器（可以被for迴圈）
        """Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        """
        return ElementPath.iterfind(self, path, namespaces)

    def clear(self):
        清空節點
        """Reset element.

        This function removes all subelements, clears all attributes, and sets
        the text and tail attributes to None.

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

    def get(self, key, default=None):
        獲取當前節點的屬性值
        """Get element attribute.

        Equivalent to attrib.get, but some implementations may handle this a
        bit more efficiently.  *key* is what attribute to look for, and
        *default* is what to return if the attribute was not found.

        Returns a string containing the attribute value, or the default if
        attribute was not found.

        """
        return self.attrib.get(key, default)

    def set(self, key, value):
        為當前節點設定屬性值
        """Set element attribute.

        Equivalent to attrib[key] = value, but some implementations may handle
        this a bit more efficiently.  *key* is what attribute to set, and
        *value* is the attribute value to set it to.

        """
        self.attrib[key] = value

    def keys(self):
        獲取當前節點的所有屬性的 key

        """Get list of attribute names.

        Names are returned in an arbitrary order, just like an ordinary
        Python dict.  Equivalent to attrib.keys()

        """
        return self.attrib.keys()

    def items(self):
        獲取當前節點的所有屬性值，每個屬性都是一個鍵值對
        """Get element attributes as a sequence.

        The attributes are returned in arbitrary order.  Equivalent to
        attrib.items().

        Return a list of (name, value) tuples.

        """
        return self.attrib.items()

    def iter(self, tag=None):
        在當前節點的子孫中根據節點名稱尋找所有指定的節點，並返回一個迭代器（可以被for迴圈）。
        """Create tree iterator.

        The iterator loops over the element and all subelements in document
        order, returning all elements with a matching tag.

        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.

        *tag* is what tags to look for (default is to return all elements)

        Return an iterator containing all the matching elements.

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

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

    def itertext(self):
        在當前節點的子孫中根據節點名稱尋找所有指定的節點的內容，並返回一個迭代器（可以被for迴圈）。
        """Create text iterator.

        The iterator loops over the element and all subelements in document
        order, returning all inner text.

        """
        tag = self.tag
        if not isinstance(tag, str) and tag is not None:
            return
        if self.text:
            yield self.text
        for e in self:
            yield from e.itertext()
            if e.tail:
                yield e.tail

節點功能一覽表

操作XML

由於每個節點都具有以上的方法，並且在上一步驟中解析時均得到了root（xml檔案的根節點），so 可以利用以上方法進行操作xml檔案。

a.遍歷xml文件所有內容

#!/usr/bin/env python
# -*- UTF-8 -*-
# Author:Rangle
from xml.etree import ElementTree as ET

############ 解析方式一 ############
"""
# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)
"""
############ 解析方式二 ############

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()


### 操作

# 頂層標籤
print(root.tag)


# 遍歷XML文件的第二層
for child in root:
    # 第二層節點的標籤名稱和標籤屬性
    print(child.tag, child.attrib)
    # 遍歷XML文件的第三層
    for i in child:
        # 第二層節點的標籤名稱和內容
        print(i.tag,i.text)

遍歷XML文件所有內容

b.遍歷xml中指定的節點

from xml.etree import ElementTree as ET

############ 解析方式一 ############
"""
# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)
"""
############ 解析方式二 ############

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()


### 操作

# 頂層標籤
print(root.tag)


# 遍歷XML中所有的year節點
for node in root.iter('year'):
    # 節點的標籤名稱和內容
    print(node.tag, node.text)

遍歷XML中指定的節點

c.修改節點內容

由於修改的節點時，均是在記憶體中進行，其不會影響檔案中的內容。所以，如果想要修改，則需要重新將記憶體中的內容寫到檔案。

解析字串方式修改、儲存

from xml.etree import ElementTree as ET

############ 解析方式一 ############

# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)

############ 操作 ############

# 頂層標籤
print(root.tag)

# 迴圈所有的year節點
for node in root.iter('year'):
    # 將year節點中的內容自增一
    new_year = int(node.text) + 1
    node.text = str(new_year)

    # 設定屬性
    node.set('name', 'alex')
    node.set('age', '18')
    # 刪除屬性
    del node.attrib['name']


############ 儲存檔案 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')

解析字串方式，修改，儲存

解析字串方式修改、儲存

解析檔案方式修改、儲存

from xml.etree import ElementTree as ET

############ 解析方式二 ############

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

############ 操作 ############

# 頂層標籤
print(root.tag)

# 迴圈所有的year節點
for node in root.iter('year'):
    # 將year節點中的內容自增一
    new_year = int(node.text) + 1
    node.text = str(new_year)

    # 設定屬性
    node.set('name', 'alex')
    node.set('age', '18')
    # 刪除屬性
    del node.attrib['name']


############ 儲存檔案 ############
tree.write("newnew.xml", encoding='utf-8')

解析檔案方式，修改，儲存

修改節點內容

d.刪除節點內容

解析字串方式刪除、儲存

from xml.etree import ElementTree as ET

############ 解析字串方式開啟 ############

# 開啟檔案，讀取XML內容
str_xml = open('xo.xml', 'r').read()

# 將字串解析成xml特殊物件，root代指xml檔案的根節點
root = ET.XML(str_xml)

############ 操作 ############

# 頂層標籤
print(root.tag)

# 遍歷data下的所有country節點
for country in root.findall('country'):
    # 獲取每一個country節點下rank節點的內容
    rank = int(country.find('rank').text)

    if rank > 50:
        # 刪除指定country節點
        root.remove(country)

############ 儲存檔案 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')

解析字串方式開啟，刪除，儲存

刪除節點內容

解析檔案方式刪除、儲存

from xml.etree import ElementTree as ET

############ 解析檔案方式 ############

# 直接解析xml檔案
tree = ET.parse("xo.xml")

# 獲取xml檔案的根節點
root = tree.getroot()

############ 操作 ############

# 頂層標籤
print(root.tag)

# 遍歷data下的所有country節點
for country in root.findall('country'):
    # 獲取每一個country節點下rank節點的內容
    rank = int(country.find('rank').text)

    if rank > 50:
        # 刪除指定country節點
        root.remove(country)

############ 儲存檔案 ############
tree.write("newnew.xml", encoding='utf-8')

解析檔案方式開啟，刪除，儲存

刪除節點內容

(3)建立xml文件

from xml.etree import ElementTree as ET


# 建立根節點
root = ET.Element("famliy")


# 建立節點大兒子
son1 = ET.Element('son', {'name': '兒1'})
# 建立小兒子
son2 = ET.Element('son', {"name": '兒2'})

# 在大兒子中建立兩個孫子
grandson1 = ET.Element('grandson', {'name': '兒11'})
grandson2 = ET.Element('grandson', {'name': '兒12'})
son1.append(grandson1)
son1.append(grandson2)


# 把兒子新增到根節點中
root.append(son1)
root.append(son1)

tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

建立方式（一）

建立方式一

from xml.etree import ElementTree as ET

# 建立根節點
root = ET.Element("famliy")


# 建立大兒子
# son1 = ET.Element('son', {'name': '兒1'})
son1 = root.makeelement('son', {'name': '兒1'})
# 建立小兒子
# son2 = ET.Element('son', {"name": '兒2'})
son2 = root.makeelement('son', {"name": '兒2'})

# 在大兒子中建立兩個孫子
# grandson1 = ET.Element('grandson', {'name': '兒11'})
grandson1 = son1.makeelement('grandson', {'name': '兒11'})
# grandson2 = ET.Element('grandson', {'name': '兒12'})
grandson2 = son1.makeelement('grandson', {'name': '兒12'})

son1.append(grandson1)
son1.append(grandson2)


# 把兒子新增到根節點中
root.append(son1)
root.append(son1)

tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

建立方式（二）

建立方式二

from xml.etree import ElementTree as ET


# 建立根節點
root = ET.Element("famliy")


# 建立節點大兒子
son1 = ET.SubElement(root, "son", attrib={'name': '兒1'})
# 建立小兒子
son2 = ET.SubElement(root, "son", attrib={"name": "兒2"})

# 在大兒子中建立一個孫子
grandson1 = ET.SubElement(son1, "age", attrib={'name': '兒11'})
grandson1.text = '孫子'


et = ET.ElementTree(root)  #生成文件物件
et.write("test.xml", encoding="utf-8", xml_declaration=True, short_empty_elements=False)

建立方式（三）

建立方式三

以原生方式儲存XML時預設無縮排，如果要設定縮排，需更改儲存方式，具體如下：

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


def prettify(elem):
    """將節點轉換成字串，並新增縮排。
    """
    rough_string = ET.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="\t")

# 建立根節點
root = ET.Element("famliy")


# 建立大兒子
# son1 = ET.Element('son', {'name': '兒1'})
son1 = root.makeelement('son', {'name': '兒1'})
# 建立小兒子
# son2 = ET.Element('son', {"name": '兒2'})
son2 = root.makeelement('son', {"name": '兒2'})

# 在大兒子中建立兩個孫子
# grandson1 = ET.Element('grandson', {'name': '兒11'})
grandson1 = son1.makeelement('grandson', {'name': '兒11'})
# grandson2 = ET.Element('grandson', {'name': '兒12'})
grandson2 = son1.makeelement('grandson', {'name': '兒12'})

son1.append(grandson1)
son1.append(grandson2)


# 把兒子新增到根節點中
root.append(son1)
root.append(son1)


raw_str = prettify(root)

f = open("xxxoo.xml",'w',encoding='utf-8')
f.write(raw_str)
f.close()

設定縮排

(4)名稱空間

參考：http://www.w3school.com.cn/xml/xml_namespaces.asp

from xml.etree import ElementTree as ET

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)

tree.write("page.xml",
           xml_declaration=True,
           encoding='utf-8',
           method="xml")

名稱空間

名稱空間

9、requests模組

Python標準庫中提供了：urllib等模組以供Http請求，但是，它的 API 太渣了。它是為另一個時代、另一個網際網路所建立的。它需要巨量的工作，甚至包括各種方法覆蓋，來完成最簡單的任務。

傳送get請求

傳送帶header的get請求

Requests 是使用 Apache2 Licensed 許可證的基於Python開發的HTTP 庫，其在Python內建模組的基礎上進行了高度的封裝，從而使得Pythoner進行網路請求時，變得美好了許多，使用Requests可以輕而易舉的完成瀏覽器可有的任何操作。

使用requests模組獲取http請求，需要安裝requests模組，pip3 install requests

# 1、無引數例項
 
import requests
 
ret = requests.get('https://github.com/timeline.json')
 
print(ret.url)
print(ret.text)
 
 
 
# 2、有引數例項
 
import requests
 
payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.get("http://httpbin.org/get", params=payload)
 
print(ret.url)
print(ret.text)

GET請求

get請求

# 1、基本POST例項
 
import requests
 
payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.post("http://httpbin.org/post", data=payload)
 
print(ret.text)
 
 
# 2、傳送請求頭和資料例項
 
import requests
import json
 
url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}
 
ret = requests.post(url, data=json.dumps(payload), headers=headers)
 
print(ret.text)
print(ret.cookies)

POST請求

post請求

requests.get(url, params=None, **kwargs)
requests.post(url, data=None, json=None, **kwargs)
requests.put(url, data=None, **kwargs)
requests.head(url, **kwargs)
requests.delete(url, **kwargs)
requests.patch(url, data=None, **kwargs)
requests.options(url, **kwargs)
 
# 以上方法均是在此方法的基礎上構建
requests.request(method, url, **kwargs)

其他請求

其他請求

Http請求和XML例項

例項1：

import urllib
import requests
from xml.etree import ElementTree as ET

# 使用內建模組urllib傳送HTTP請求，或者XML格式內容
"""
f = urllib.request.urlopen('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=424662508')
result = f.read().decode('utf-8')
"""


# 使用第三方模組requests傳送HTTP請求，或者XML格式內容
r = requests.get('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=424662508')
result = r.text

# 解析XML格式內容
node = ET.XML(result)

# 獲取內容
if node.text == "Y":
    print("線上")
else:
    print("離線")

檢測QQ賬號是否線上

例項2：

import urllib
import requests
from xml.etree import ElementTree as ET

# 使用內建模組urllib傳送HTTP請求，或者XML格式內容
"""
f = urllib.request.urlopen('http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G666&UserID=')
result = f.read().decode('utf-8')
"""

# 使用第三方模組requests傳送HTTP請求，或者XML格式內容
r = requests.get('http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G666&UserID=')
result = r.text

# 解析XML格式內容
root = ET.XML(result)
for node in root.iter('TrainDetailInfo'):
    print(node.find('TrainStation').text,node.find('StartTime').text,node.tag,node.attrib)

檢測火車票停靠資訊

其他介面請求例項，參考：http://www.cnblogs.com/wupeiqi/archive/2012/11/18/2776014.html

10、logging模組

用於便捷記錄日誌且執行緒安全的模組

import logging

  
logging.basicConfig(filename='log.log',
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)
  
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')

單檔案日誌

日誌等級：

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

注：只有【當前寫等級】大於【日誌等級】時，日誌檔案才被記錄。

日誌記錄格式：

對於上述記錄日誌的功能，只能將日誌記錄在單檔案中，如果想要設定多個日誌檔案，logging.basicConfig將無法完成，需要自定義檔案和日誌操作物件。

多檔案日誌

# 定義檔案
file_2_1 = logging.FileHandler('l2_1.log', 'a')
fmt = logging.Formatter()
file_2_1.setFormatter(fmt)

# 定義日誌
logger2 = logging.Logger('s2', level=logging.INFO)
logger2.addHandler(file_2_1)

日誌（二）

多檔案日誌2

如上述建立的兩個日誌物件

當使用【logger1】寫日誌時，會將相應的內容寫入 l1_1.log 和 l1_2.log 檔案中
當使用【logger2】寫日誌時，會將相應的內容寫入 l2_1.log 檔案中

11、shutil模組

高階的檔案、資料夾、壓縮包處理模組

（1）檔案拷貝

import shutil
 
shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

檔案內容拷貝到另一個檔案中

shutil.copyfile('f1.log', 'f2.log')

拷貝檔案

shutil.copymode('f1.log', 'f2.log')

僅拷貝許可權：內容、組、使用者均不變

shutil.copystat('f1.log', 'f2.log')

僅拷貝狀態的資訊：包括：mode bits, atime, mtime, flags

import shutil
 
shutil.copy('f1.log', 'f2.log')

拷貝檔案和許可權

import shutil
 
shutil.copy2('f1.log', 'f2.log')

拷貝檔案和狀態

import shutil
 
shutil.copytree('folder1', 'folder2',  symlinks=True, ,ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

遞迴拷貝資料夾

（2）檔案刪除

import shutil
 
shutil.rmtree('folder1')

遞迴刪除檔案

import shutil
 
shutil.move('folder1', 'folder3')

遞迴的去移動檔案：類似mv命令，其實就是重新命名。

（3）檔案壓縮和解壓縮

建立壓縮包並返回檔案路徑，例如：zip、tar

base_name：壓縮包的檔名，也可以是壓縮包的路徑。只是檔名時，則儲存至當前目錄，否則儲存至指定路徑，
如：www =>儲存至當前路徑
如：/Users/wupeiqi/www =>儲存至/Users/wupeiqi/
format：壓縮包種類，“zip”, “tar”, “bztar”，“gztar”
root_dir：要壓縮的資料夾路徑（預設當前目錄）
owner：使用者，預設當前使用者
group：組，預設當前組
logger：用於記錄日誌，通常是logging.Logger物件

#將 /Users/test 下的檔案打包放置當前程式目錄
import shutil
ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/test')
  
  
#將 /Users/test 下的檔案打包放置 /Users/目錄
import shutil
ret = shutil.make_archive("/Users/wwwwwwwwww", 'gztar', root_dir='/Users/test')

建立壓縮包

shutil 對壓縮包的處理是呼叫 ZipFile 和 TarFile 兩個模組來進行的：

import zipfile

# 壓縮
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解壓
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()

zipfile壓縮和解壓縮（zip格式）

import tarfile

# 壓縮
tar = tarfile.open('your.tar','w')
tar.add('/Users/bbs2.log', arcname='bbs2.log')
tar.add('/Users/cmdb.log', arcname='cmdb.log')
tar.close()

# 解壓
tar = tarfile.open('your.tar','r')
tar.extractall()  # 可設定解壓地址
tar.close()

tar格式壓縮和解壓縮

12、paramiko模組

paramiko是一個用於做遠端控制的模組，使用該模組可以對遠端伺服器進行命令或檔案操作，值得一說的是，fabric和ansible內部的遠端管理就是使用的paramiko來現實。

此模組不屬於內建模組，需要單獨下載安裝，具體安裝命令如下：

pycrypto，由於 paramiko 模組內部依賴pycrypto，所以先下載安裝pycrypto
pip3 install pycrypto
pip3 install paramiko

paramiko安裝

#!/usr/bin/env python
#coding:utf-8

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.108', 22, 'alex', '123')
stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close();

執行命令 - 使用者名稱+密碼

帶使用者名稱密碼執行指令碼

import paramiko

private_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(private_key_path)

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('主機名 ', 埠, '使用者名稱', key)

stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close()

執行命令 - 金鑰

帶私鑰執行命令

import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test.py','/tmp/test.py') 
t.close()


import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test.py','/tmp/test2.py')
t.close()

上傳或下載檔案 - 使用者名稱+密碼

帶使用者和密碼上傳、下載檔案

import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test3.py','/tmp/test3.py') 

t.close()

import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test3.py','/tmp/test4.py') 

t.close()

上傳或下載檔案 - 金鑰

帶私鑰上傳、下載檔案

13、time模組

時間相關的操作，時間有三種表示方式：

時間戳 1970年1月1日之後的秒，即：time.time()，具體示例：print(time.time()) ，結果：1501377801.9864273
格式化的字串 2014-11-11 11:11，即：time.strftime('%Y-%m-%d') ，具體示例：print(time.strftime("%Y-%m-%d %X")) ，結果：2017-07-30 10:00:24
結構化時間元組包含了：年、日、星期等... time.struct_time 即：time.localtime()，具體示例：print(time.localtime())，結果：time.struct_time(tm_year=2017, tm_mon=7, tm_mday=30, tm_hour=9, tm_min=25, tm_sec=4, tm_wday=6, tm_yday=211, tm_isdst=0)

##時間戳轉化為元組形式
time.gmtime():將秒轉化為UTC的元組形式 ,返回的是標準時間即0時區的當前時間
time.localtime():將秒轉為為UTC元組形式，顯示當前時間，引數值是秒，預設當前時間
##元組轉化為時間戳形式
time.mktime() :將元組形式資料轉化為時間戳形式(秒)，傳入的變數值是元組

##元組轉化為格式化的字串時間形式
time.strftime():將元組形式的時間，轉化為格式化的字串形式
x=time.localtime()
print(time.strftime('%Y-%m-%d %X',x))
##字串時間格式轉為元組時間格式
time.strptime()：將字串時間格式轉化為元組形式時間格式
x=time.strftime("%Y-%m-%d %X")
print(time.strptime(x,"%Y-%m-%d %X"))

時間格式：
 %Y  Year with century as a decimal number.
 %m  Month as a decimal number [01,12].
 %d  Day of the month as a decimal number [01,31].
 %H  Hour (24-hour clock) as a decimal number [00,23].
 %M  Minute as a decimal number [00,59].
 %S  Second as a decimal number [00,61].
 %z  Time zone offset from UTC.
 %a  Locale's abbreviated weekday name.
 %A  Locale's full weekday name.
 %b  Locale's abbreviated month name.
 %B  Locale's full month name.
 %c  Locale's appropriate date and time representation.
 %I  Hour (12-hour clock) as a decimal number [01,12].
 %p  Locale's equivalent of either AM or PM.

常用獲取當前時間：
time.strftime("%Y-%m-%d %X")
time.localtime()
time.time()

補充datetime模組：

三天後的時間：
str(datetime.now()+timedelta(3))
'2017-08-04 16:49:51.377186'
三小時前時間：
str(datetime.now()+timedelta(hours=-3))
'2017-08-01 13:50:51.167165'
三分鐘後時間：
str(datetime.now()+timedelta(minutes=+3))
'2017-08-01 18:30:37.745793'

四、練習題

1、通過HTTP請求和XML實現獲取電視節目

API：http://www.webxml.com.cn/webservices/ChinaTVprogramWebService.asmx

2、通過HTTP請求和JSON實現獲取天氣狀況

API：http://wthrcdn.etouch.cn/weather_mini?city=北京

Day04
2024-08-24
機器學習day04
2024-06-20
機器學習
傳智黑馬python基礎學習——day04
2019-01-24
Python
day04 函式
2024-07-02
函式
python 模組：itsdangerous 模組
2020-02-16
Python
Python模組：time模組
2021-09-09
Python
urlparse模組（python模組）
2017-11-12
Python
python模組-re模組
2014-05-15
Python
python模組 - functools模組
2014-05-24
Python
day04 -js04
2018-09-06
JS
嵌入式day04
2024-04-25
python模組之collections模組
2019-01-04
Python
Day04——Java新手學習
2019-02-23
Java
## day04總結（作業）
2020-10-29
多執行緒Day04
2024-10-04
執行緒
Python 模組
2021-11-23
Python
python模組
2017-07-30
Python
Python 內建模組：os模組
2020-04-05
Python
Python模組之urllib模組
2020-10-30
Python
[Python模組學習] glob模組
2018-05-26
Python
孫空空的Vue之路-Day04
2020-10-23
Vue
Python中模組是什麼？Python有哪些模組?
2021-09-15
Python
Python的defaultdict模組和namedtuple模組
2014-12-24
Python
Python functools 模組
2020-05-23
Python
Python Execl模組
2019-02-16
Python
Python webargs 模組
2022-01-21
PythonWeb
python collections模組
2021-09-09
Python
Python mongoHelper模組
2018-11-20
PythonGo
Python pymsql模組
2020-09-04
PythonSQL
Python模組(module)
2023-01-04
Python
Python-模組
2021-11-23
Python
python 模組fnmatch
2021-01-01
Python
Python：requests模組
2020-10-18
Python
python random模組
2018-03-28
Pythonrandom
Python Re模組
2017-10-23
Python
python：time模組
2017-05-08
Python
python：模組0
2017-05-08
Python
Python cmd模組
2017-04-18
Python

Day04——Python模組

相關文章