python整理

時間 2019-11-17

標籤 python 整理欄目 Python 简体版

原文原文鏈接

目錄html

目錄前端

說明

侵刪

代碼精簡&優化

函數式編程-高階函數

https://www.jianshu.com/p/a305c66c4f5apython

函數式編程-鏈式調用

https://www.jianshu.com/p/a6dc94930dcdmysql

list變爲字符串

def list_demo():
    list_tmp = ['1', '2', '4', '5']
    pprint(''.join(list_tmp))  # 將list變爲字符串

enumerate()函數

def enumerate_demo():
    """
    enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，同時列出數據和數據下標，通常用在 for 循環當中。
    Python 2.3. 以上版本可用，2.6 添加 start 參數。
    語法
    enumerate(sequence, [start=0])
    參數
    sequence –可迭代對象。
    start -- 下標起始位置。
    返回值
    enumerate(枚舉) 對象。
    """
    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    print(list(enumerate(seasons)))
    print(list(enumerate(seasons, start=1)))  # 小標從 1 開始)

    # for循環中的使用
    seq = ['one', 'two', 'three']
    for i, element in enumerate(seq):
        print(i, seq[i])

zip()函數

def zip_demo():
    """
    zip() 函數用於將可迭代的對象做爲參數，將對象中對應的元素打包成一個個元組，而後返回由這些元組組成的列表。
    若是各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操做符，能夠將元組解壓爲列表
    """
    a, b, c = [1, 2, 3], [4, 5, 6], [4, 5, 6, 7, 8]
    print(zip(a, b))  # 打包爲元組的列表
    print(zip(a, c))  # 元素個數與最短的列表一致
    # print(zip(*zipped))  # 與 zip 相反，可理解爲解壓，返回二維矩陣式

map()函數

def f(x):
    """有函數f(x)=x^2,把這個函數做用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上"""
    return x * x

def map_demo():
    # map()函數接收兩個參數，一個是函數，一個是序列，map將傳入的函數依次做用到序列的每一個元素，並把結果做爲新的list返回。
    list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(map(f, list1))

reduce()函數

def add(x, y):
    return x + y


def reduce_demo():
    """
    reduce把一個函數做用在一個序列[x1, x2, x3...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素作累積計算
    對一個序列求和，就能夠用reduce實現"""
    list2 = [1, 3, 5, 7, 9]
    print(functools.reduce(add, list2))


# 固然求和運算能夠直接用Python內建函數sum()，不必動用reduce。可是若是要把序列[1, 3, 5, 7, 9]變換成整數13579，reduce就能夠派上用場
def fn(x, y):
    return x * 10 + y


def sum_demo():
    list2 = [1, 3, 5, 7, 9]
    print(functools.reduce(fn, list2))


# 上面例子自己沒大用處，可是，若是考慮到字符串str也是一個序列，對上面的例子稍加改動，配合map()，就能夠寫出把str轉換爲int的函數：
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]


def str2int(s):
    return functools.reduce(fn, map(char2num, s))


# 上面簡化/使用lambda
def str2int_lambda(s):
    return functools.reduce(lambda x, y: x * 10 + y, map(char2num, s))

filter()函數

def is_odd(n):
    return n % 2 == 1


def filter_demo():
    """
    接收一個函數和一個序列。把傳入的函數依次做用於每一個元素，而後根據返回值是True仍是False決定保留仍是丟棄該元素。
    在一個list中，刪掉偶數，只保留奇數
    """
    print(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

sorted()函數

def demo_sorted():
    """
    Python內置的sorted()函數就能夠對list進行排序
    一般規定對於兩個元素x和y，如認爲x < y，則返回-1，如認爲x == y，則返回0，若是認爲x > y，則返回1
    :return:
    """
    print(sorted([36, 5, 12, 9, 21]))  # 結果： [5, 9, 12, 21, 36]


# 此外，能夠接收一個比較函數來實現自定義的排序。
def reversed_cmp(x, y):  # 比較函數
    """
    :param x: x
    :param y: y
    :return:
    """
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

返回函數/閉包結構

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax


def lazy_sum(*args):
    """
    返回函數能夠延遲計算
    內部函數能夠引用外部函數的參數和局部變量
    每次調用外部函數都會返回一個新的函數，即便傳入相同的參數

    閉包
        返回的函數並無馬上執行，而是直到調用了才執行
        返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者後續會發生變化的變量。
        若是必定要引用循環變量怎麼辦？方法是再建立一個函數，用該函數的參數綁定循環變量當前的值，
        不管該循環變量後續如何更改，已綁定到函數參數的值不變
    :param args:
    :return:
    """

    def demo_sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax

    return demo_sum

匿名函數lambda

demo_lambda = lambda x, y, z: x + y + z

裝飾器/decorator

"""
裝飾器
    好比在函數調用先後自動打印日誌，但又不但願修改now()函數的定義，
    這種在代碼運行期間動態增長功能的方式，稱之爲「裝飾器」（Decorator）。
    藉助Python的@語法，把decorator置於函數的定義處
    Python的decorator能夠用函數實現，也能夠用類實現
    decorator能夠加強函數的功能，定義起來雖然有點複雜，但使用起來很是靈活和方便。
參考：
    # 不帶參數的decorator
    def log(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print 'call %s():' % func.__name__
            return func(*args, **kw)
        return wrapper

    # 帶參數的decorator
    def log(text):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print '%s %s():' % (text, func.__name__)
                return func(*args, **kw)
            return wrapper
        return decorator

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~↓
# 實例001
# 加強now函數的功能，在函數調用先後自動打印日誌
def log(func):
    def wrapper(*args, **kw):
        print('call func: %s()' % func.__name__)
        return func(*args, **kw)

    return wrapper


@log
def now():
    print('2013-12-25')


# 若是decorator自己須要傳入參數，那就須要編寫一個返回decorator的高階函數，寫出來會更復雜。
# 好比，要自定義log的文本
# 帶參數的decorator
def log_01(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__), end='')
            return func(*args, **kw)

        return wrapper

    return decorator


@log_01('帶參裝飾器 裝飾函數')
def now_01():
    print('2013-12-25')


# __________________________________↑

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~↓
# 實例002
# 在函數調用先後打印信息
class LogPlus:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print('start call {}'.format(self.func.__name__))
        self.func(*args, **kwargs)
        print('end call {}'.format(self.func.__name__))


@LogPlus
def demo_decorator_hello():
    print('2017-11-06')


# __________________________________↑

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~↓
# 實例003
# 實現一個裝飾器，能夠傳參和不傳參
def log(something):
    # if callable, this is a decorator, shape of @log
    if callable(something):
        func = something

        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print('call {}'.format(func.__name__))
            func(*args, **kwargs)

        return wrapper

    elif isinstance(something, str):
        # else, this is a decorator function, shape of @log(something)
        def decorator(func_tmp):
            @functools.wraps(func_tmp)
            def wrapper_tmp(*args, **kwargs):
                print('{} {}'.format(something, func_tmp.__name__))
                func_tmp(*args, **kwargs)

            return wrapper_tmp

        return decorator

    else:
        raise AttributeError("Attribute other than str is not supported")


@log
def demo_decorator_f1():
    pass


@log('execute')
def demo_decorator_f2():
    pass


# __________________________________↑
"""

獲取父節點下多個子節點內容

def demo_get_all_text(self):
    texts_xpath = '//div[@class="text"]'
    elements = self.output(self.start_url, texts_xpath)
    print(elements)
    result = []
    for item in elements:
        result.append(''.jion(item.xpath('p/text()')))
    for item in result:
        print(item)
    return result

# 或者直接以下：
def get_all_text(self):
    texts_xpath = '//div[@class="text"]'
    elements = self.output(self.start_url, texts_xpath)
    result = [''.jion(item.xpath('p/text()')) for item in elements]
    return result

框架-django

Python錯誤：django項目沒法鏈接遠程mysql的問題

https://www.cnblogs.com/zengjielin/p/8582826.htmllinux

Django 設置遠程訪問

setting.py–>ALLOWED_HOSTS = [「*」]               //修改配置
python3 manage.py runserver 0.0.0.0:8000        //啓動

安全

python提取強弱密碼

https://github.com/r35tart/RW_Passwordgit

python混淆腳本打包免殺

https://mp.weixin.qq.com/s?__biz=MzUyMTk5OTUzOQ==&mid=2247483689&idx=1&sn=4474964136fc632647c40884e3f15963&chksm=f9d3c4f5cea44de34e0f2e0fba257cc75ccbf5f934d002ee14fb7237db6c3af10c1f79b53a67&mpshare=1&scene=1&srcid=&key=2cbf6115a3e77fb037c18b51d844f974a7221519d3346d7d73cf29d2ca56baaa6fc853b392cdc0c2e3eb15bd2974211a29fc2e3d9c05cf5eb7da408f877add23a35bcb8670b94b5efa1781b1ef9951d8&ascene=1&uin=MTk3MzU3NjM2MQ%3D%3D&devicetype=Windows+10&version=62060739&lang=zh_CN&pass_ticket=N6gIUbWVtgDoxrlksfFMBznbTlwAcaz9NT2MmEYQ8wLRSKGE2pBTbMA1Z41jzL2M程序員

基礎

編寫完美的 Python 命令行程序

https://mp.weixin.qq.com/s?__biz=MjM5MjAwODM4MA==&mid=2650712683&idx=3&sn=0738fa211001982fb5e64a8c6fa6242a&chksm=bea6dbb889d152ae80a5040982be0eec99ffb8923bc7484872e6474605647d35605446e7b54e&mpshare=1&scene=1&srcid=0119aJ9Le7IjqTCNwLUkdWZ3&key=904312b286f32b60e07c75db136896241949ad27400d020b257efa70019f432e84d91eeab6e6365f16a1ab825e4a4b120600353357da604465f250ce87b2753fb4d7f94aa13349bd6ca847066f2d0822&ascene=1&uin=MTk3MzU3NjM2MQ%3D%3D&devicetype=Windows+10&version=62060739&lang=zh_CN&pass_ticket=N6gIUbWVtgDoxrlksfFMBznbTlwAcaz9NT2MmEYQ8wLRSKGE2pBTbMA1Z41jzL2Mgithub

虛擬環境使用

virtualenv -p /usr/bin/python3 env35        //建立虛擬機環境
source env35/bin/activate                   //激活環境
deactivate                                  //退出當前環境

虛擬環境操做

pip install virtualenv （　virtualenv 是一個建立隔絕的Python環境的工具）
virtualenv venv　　（venv爲虛擬環境目錄名，目錄名自定義）
virtualenv -p /usr/bin/python2.7 venv　　　　（-p參數指定Python解釋器程序路徑）
virtualenv --no-site-packages venv          （不引入已經安裝的第三方包）

$ source venv/bin/activate　     (linux下激活)
$ . venv/bin/deactivate             (linux下退出)
activate.bat        （windows下進入E:\appiumEnv\Scripts後運行activate.bat文件進入虛擬環境）
deactivate.bat      （windows下進入E:\appiumEnv\Scripts後運行deactivate.bat文件退出虛擬環境）

執行 rm -rf venv      （ 要刪除一個虛擬環境，只需刪除它的文件夾）

須要的話能夠安裝使用virtualenvwrapper（鑑於virtualenv不便於對虛擬環境集中管理，因此推薦直接使用virtualenvwrapper）

Python錯誤：安裝cv2失敗

2018年01月30日 15:43:35 我心永恆999 閱讀數：58418
pip install opencv-python

win10 python3.6可用
如今已經不行了，pip3能夠

Python錯誤：IndentationError: unindent does not match any outer indentation level

縮進問題

Python錯誤：控制檯輸出InsecureRequestWarning的問題

問題：

使用Python3 requests發送HTTPS請求，已經關閉認證（verify=False）狀況下，控制檯會輸出如下錯誤：
InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings


解決方法：
在代碼中添加如下代碼便可解決：

import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

Python2添加以下代碼便可解決：

from requests.packages.urllib3.exceptions import InsecureRequestWarning
# 禁用安全請求警告
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

requests取消SSL認證後消除warning信息

# 禁用安全請求警告
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
requests.get(url_temp)....

限制實例屬性,使用slots變量,對繼承的子類不起做用

class Person(object):
    __slots__ = ("name", "age")

GUI

'''
# 比較推薦的開發工具包四個：Gtk、Qt、Tk和wxwidgets
# 七個優秀框架：Kivy、Pyforms、PyGObject（PyGi）、PyQt（收費）、PyGUI、libavg、wxPython、
Kivy
這是一個很是有趣的項目，基於OpenGL ES 2，支持Android和iOS平臺的原生多點觸摸，做爲事件驅動的框架，Kivy很是適合遊戲開發，很是適合處理從widgets到動畫的任務。若是你想開發跨平臺的圖形應用，或者僅僅是須要一個強大的跨平臺圖形用戶開發框架，Kivy都是不錯的選擇。

Pyforms
誕生只有兩年的Pyforms是一個Python2.7/3.x跨環境圖形應用開發框架，模塊化和代碼複用能夠節省大量工做。

PyGObject（PyGi）
PyGObject是一個利用GTK+爲GNOME或Python應用開發的組件，可與跨平臺代碼庫GObject綁定。GTK+是一個功能全面的免費跨平臺widget開發工具包，爲大量Linux和Windows/Mac OSX應用開發圖形用戶界面。

PyQt
Qt是一個C++編寫的跨平臺開發框架，若是你的應用是徹底開源的，就能夠無償使用Qt，不然你須要購買商業許可。Qt已經存在好久，一度屬於諾基亞公司，做爲一個很是全面的工具代碼庫和API，被大量行業普遍採用，覆蓋包括移動在內的多個平臺。你的設備中使用的衛星導航應用，其圖形用戶界面每每就是Qt開發的。

PyGUI
與Kivy和PyQt相比，PyGUI的最大區別是僅僅面向UNIX、Macintosh和Windows平臺。PyGUI的一個主要目的就是儘可能減小Python應用與平臺底層GUI之間的代碼量，若是你須要一個簡單快速容易上手的GUI開發框架，那麼PyGUI是一個不錯的選擇。

libavg
libavg是一個C++編寫的第三方開源庫，能夠運行在Linux、Mac OS X和Windows平臺上。libavg被官方應用於藝術性較強的展現應用，能夠同時處理數以千計的多媒體對象（圖片、文本、視頻和攝像頭數據）。那些大屏幕上展現的多人共玩的多點觸摸遊戲，八成都有libavg的功勞。

wxPython
雖然尚未爲Python3作好準備，可是做爲資格最老，最流行的Python GUI開發框架之一，wxPython名氣很大，不得不提。wxPython基於wxWidgets，是一個C++編寫的跨平臺GUI庫，除了標準的對話框，還提供一個2D路徑繪製API，支持多種文件格式以及文本編輯和字處理widgets。
'''

類/面向對象OOP

'''
類的訪問限制
    類屬性前加雙下劃線、並給方法召回或修改屬性
    python能夠動態綁定屬性和方法
        給實例綁定一個方法，綁定後對其餘實例不適用
        class Student(object):
            pass
        s = Student()
        def set_age(self, age): # 定義一個函數做爲實例方法
            self.age = age
        from types import MethodType
        s.set_age = MethodType(set_age, s, Student) # 給實例綁定一個方法
        s.set_age(25)
        print(s.age) # 驗證

        給class綁定方法
        def set_score(self, score):
            self.score = score
        Student.set_score = MethodType(set_score, None, Student)

限制class的屬性
    使用__slots__,__slots__定義的屬性僅對當前類起做用，對繼承的子類是不起做用的
    子類容許定義的屬性就是自身的__slots__加上父類的__slots__
        class Student(object):
            __slots__ = ('name', 'age') # 用tuple定義容許綁定的屬性名稱

@property
    Python內置的@property裝飾器就是負責把一個方法變成屬性調用的
    @property普遍應用在類的定義中，可讓調用者寫出簡短的代碼，同時保證對參數進行必要的檢查，
    這樣，程序運行時就減小了出錯的可能性。
    定義只讀屬性--只定義getter方法
    實例：
        class Student(object):
            @property
            def score(self):
                return self._score

            @score.setter
            def score(self, value):
                if not isinstance(value, int):
                    raise ValueError('score must be an integer!')
                if value < 0 or value > 100:
                    raise ValueError('score must between 0 ~ 100!')
                self._score = value

多重繼承
    若是須要「混入」額外的功能，經過多重繼承就能夠實現，
    好比，讓Ostrich除了繼承自Bird外，再同時繼承Runnable
    在設計類的時候，咱們優先考慮經過多重繼承來組合多個Mixin的功能，而不是設計多層次的複雜的繼承關係。
    因爲Python容許使用多重繼承，所以，Mixin就是一種常見的設計。
    只容許單一繼承的語言（如Java）不能使用Mixin的設計。
        編寫一個多進程模式的TCP服務，定義以下：
            class MyTCPServer(TCPServer, ForkingMixin):
                pass
定製類
    __slots__屬性限制
        class Student(object):
            __slots__ = ('name', 'age') # 用tuple定義容許綁定的屬性名稱

    __str__優化打印效果
        class Student(object):
            def __init__(self, name):
                self.name = name
            def __str__(self):
                return 'Student object (name: %s)' % self.name
        print Student('Michael')
        這樣打印出來的實例，好看，且易看出實例內部重要的數據。
        可是直接敲變量不用print，打印出來的實例仍是很差看
        這是由於直接顯示變量調用的不是__str__()，而是__repr__()，
        二者的區別是__str__()返回用戶看到的字符串，
        而__repr__()返回程序開發者看到的字符串，也就是說，__repr__()是爲調試服務的。
        解決辦法是再定義一個__repr__()。
        可是一般__str__()和__repr__()代碼都是同樣的，因此，有個偷懶的寫法：
        class Student(object):
            def __init__(self, name):
                self.name = name
            def __str__(self):
                return 'Student object (name=%s)' % self.name
            __repr__ = __str__

        s = Student('Michael')
        print(s)

    __iter__返回一個迭代對象
        以斐波那契數列爲例
            class Fib(object):
                def __init__(self):
                    self.a, self.b = 0, 1  # 初始化兩個計數器a，b
                def __iter__(self):
                    return self  # 實例自己就是迭代對象，故返回本身
                def next(self):
                    self.a, self.b = self.b, self.a + self.b  # 計算下一個值
                    if self.a > 100000:  # 退出循環的條件
                        raise StopIteration();
                    return self.a  # 返回下一個值

            for n in Fib():
                print(n)

    __getitem__按照下標取出元素
        未處理負數和步進，以及一些未知不合理
        class Fib(object):
            def __getitem__(self, n):
                if isinstance(n, int):
                    a, b = 1, 1
                    for x in range(n):
                        a, b = b, a + b
                    return a
                if isinstance(n, slice):
                    start = n.start
                    stop = n.stop
                    a, b = 1, 1
                    L = []
                    for x in range(stop):
                        if x >= start:
                            L.append(a)
                        a, b = b, a + b
                    return L

        f = Fib()
        print(f[0:5])

    __getattr__調用不存在的類的方法或屬性時，避免報錯，動態返回一個屬性
        簡單鏈式調用
        class Person:
            def name(self, name):
                self.name = name
                return self
            def age(self, age):
                self.age = age
                return self
            def show(self):
                print "My name is", self.name, "and I am", self.age, "years old."
        p = Person()
        p.name("Li Lei").age(15).show()

        鏈式調用
        class Chain(object):
            def __init__(self, path=''):
                self._path = path
            def __getattr__(self, path):
                return Chain('%s/%s' % (self._path, path))
            def __str__(self):
                return self._path
        print(Chain().status.user123)

    __call__實例自己調用
        class Student(object):
            def __init__(self, name):
                self.name = name
            def __call__(self):
                print('My name is %s.' % self.name)
        s = Student('Michael')
        s()
'''

模塊

'''
模塊
    在Python中，一個.py文件就稱之爲一個模塊（Module）
    任何模塊代碼的第一個字符串都被視爲模塊的文檔註釋


    try:
        import cStringIO as StringIO
    except ImportError: # 導入失敗會捕獲到ImportError
        import StringIO

    try:
        import json # python >= 2.6
    except ImportError:
        import simplejson as json # python <= 2.5

    做用域 _

    sys.path模塊搜索路徑

    要添加本身的搜索目錄，有兩種方法：
        一是直接修改sys.path，添加要搜索的目錄：
            import sys
            sys.path.append('/Users/michael/my_py_scripts')
            運行時修改，運行結束後失效。
        二是設置環境變量PYTHONPATH

    __future__模塊，把下一個新版本的特性導入到當前版本，因而咱們就能夠在當前版本中測試一些新版本的特性
    from __future__ import unicode_literals #經過unicode_literals來使用Python 3.x的新的字符串的語法

'''

偏函數partial

def demo_add(x, y=1):
    return x + y


def demo_partial():
    """
    把一個函數的某些參數給固定住（也就是設置默認值），返回一個新的函數，調用這個新函數會更簡單。
    當函數的參數個數太多，須要簡化時使用
    :return:
    """
    from functools import partial
    plus = partial(demo_add, 100)
    print(plus(4))

生成器

def demo_009():
    """
        生成器:
        一邊循環一邊計算的機制，稱爲生成器
        能夠簡單地把列表生成式改爲generator，也能夠經過函數實現複雜邏輯的generator。
    構造：
        方式一：列表生成式的[]改爲()，就建立了一個generator
        方式二：函數中帶yield/變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。
    取值：
        交互模式：generator.next()
        代碼中：for循環調用
    :return:
    """
    pass


# 斐波拉契數列
def fib(max_tmp):
    n, a, b = 0, 0, 1
    while n < max_tmp:
        print(b)
        a, b = b, a + b
        n = n + 1


# 生成器版本
def fib_gen_branch(max_tmp):
    n, a, b = 0, 0, 1
    while n < max_tmp:
        yield b
        a, b = b, a + b
        n = n + 1

列表生成式

def demo002():
    """
    列表生成式/List Comprehensions:用來建立list的生成式
    使用兩個變量來生成list
    """
    d = {'x': 'A', 'y': 'B', 'z': 'C'}
    list_aps = [k + '=' + v for k, v in d.items()]
    return list_aps

# 把一個list中全部的字符串變成小寫/列表生成式運用
def lower_list():
    list_tmp = ['Hello', 'World', 18, 'Apple', None]
    print([s.lower() if isinstance(s, str) else s for s in list_tmp])


# 快速生成一個不重複的數字lis/列表推導式
def generate_num_list_not_same():
    print(list(set(list(str(random.randint(1, 9)) for _ in range(11)))))


# [基礎操做]列表推導式/字典推導式/生成器
def demo_list_and_jenerate():
    print([num for num in list(range(21, 99))])
    print([num for num in list(range(21, 99)) if num % 2 == 0])
    print([num for num in range(21, 99) if num % 2 == 0])
    print(num for num in range(21, 99) if num % 2 == 0)  # 這是打印了一個生成器的內存地址
    print([x * x for x in range(1, 11)])
    print([x * x for x in range(1, 11) if x % 2 == 0])
    print([d for d in os.listdir('.')])  # os.listdir能夠列出文件和目錄

切片

def demo001():
    """取一個list或tuple的部分元素"""
    list_tmp = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
    print(list_tmp[0:3])
    print(list_tmp[-1])  # 取倒數第一個元素

requests

def demo_request():
    """
    request 請求
    response 響應
    status_code 狀態碼
    http code
    200 成功
    302 重定向
    400 參數錯誤
    403 無權限
    405 錯誤的請求方法
    500 服務器錯誤、沒法返回
    """
    res = requests.get('http://sogou.com')
    # """ 上一行靜態檢查報錯
    print(res.ok)
    print(res.url)
    print(res.cookies)
    print(res.headers)
    print(dir(res))
    print(res.status_code)  # 獲取響應碼
    print(res.text)  # 字符串類型
    print(res.content)  # 字節流 bytes

文件讀寫

def write_file(file_name, res):
    # FileName = 'http-tutorial.html'
    with open(file_name, 'wb') as file:
        file.write(res.content)

字典處理

def demo_dict():
    """有序字典可使用orderdict類庫、python3.6之前dict無序"""
    # 字典
    my_dict = {}
    my_dict.keys()  # 獲取dict全部鍵
    my_dict.values()  # 獲取dict全部值
    my_dict.items()  # 獲取一個列表、存放dict的鍵值對
    my_dict.get('name')  # 獲取鍵爲name的值、無此key返回None
    # my_dict['key']#無此key則報錯
    my_dict['key'] = 'value'  # 存在則更新/不存在則新增
    my_dict.update(key='value')  # 新增
    my_dict.pop('key')  # 刪除鍵值對

列表排序

def sort_list():
    my_list = ['北京', '上海', '重慶', '廈門', '四川', '三亞']
    print(sorted(my_list))  # sorted不修改list自己元素index位置
    my_list.sort()  # sort方法會修改list自己元素index位置

random

def random_demo():
    pprint(random.randint(1, 100))  # 生成隨機數

json模塊

def demo_json():
    """
    json.dumps        dict轉str
    json.dump         將python數據保存成json文件
    json.loads        str轉dict
    json.load         讀取json數據
    """
    print(json.dumps([]))  # dumps能夠格式化全部的基本數據類型爲字符串
    dict_tmp = {"name": "Tom", "age": 23}
    print(json.dumps(dict_tmp))  # dict轉str

    a = {"name": "Tom", "age": 23}
    with open("test.json", "w", encoding='utf-8') as fo:
        # indent 超級好用，格式化保存字典，默認爲None，小於0爲零個空格
        fo.write(json.dumps(a, indent=4))  # json.dump(a,f,indent=4)   # 效果同樣

    with open("test.json", "r", encoding='utf-8') as fr:
        aa = json.loads(fr.read())
        fr.seek(0)
        bb = json.load(fr)  # 與 json.loads(f.read())一致
        print(aa)
        print(bb)

編譯pyc文件

# python -m compileall xxx.py

@staticmethod和@classmethod的異同

class A(object):
    """
        相同：
        @staticmethod和@classmethod均可以直接類名.方法名()來調用
    形參不一樣：
        @staticmethod不須要self參數和自身類的cls參數，就跟使用函數同樣。
        @classmethod也不須要self參數，但第一個參數須要是表示自身類的cls參數。
    使用不一樣：
        @staticmethod中要調用到這個類的一些屬性方法，只能直接類名.屬性名或類名.方法名。
        @classmethod由於持有cls參數，能夠來調用類的屬性，類的方法，實例化對象等，避免硬編碼。
    """
    bar = 1

    @staticmethod
    def foo():
        print('foo')

    @staticmethod
    def static_foo():
        print('static_foo')
        print(A.bar)

    @classmethod
    def class_foo(cls):
        print('class_foo')
        print(cls.bar)
        cls().foo()

def test_method_001():
    A.static_foo()
    A.class_foo()

庫的安裝

def demo_install_moduls():
    """
    pip -r requirement.txt
    pip3 install dateutil -i http://mirrors.aliyun.com/pypi/simple/
    pip install Pinyin2Hanzi -i https://pypi.douban.com/simple
    pip install pythonModuleName -i https://pypi.douban.com/simple（在命令行中添加鏡像參數，可讓pip從指定的鏡像源安裝軟件。）
    pip3 install progressbar -i https://pypi.douban.com/simple
    pip install concurrently -i https://pypi.douban.com/simple
    python -m pip36 install aiohttp progressbar -i https://pypi.douban.com/simple


    解決pycharm沒法安裝模塊的問題
    python -m pip install --upgrade --force pip
    pip install setuptools==33.1.1 -i https://pypi.douban.com/simple

    python3.exe -m pip install ConfigParser

    國內鏡像
    https://pypi.doubanio.com/simple/
    https://pypi.douban.com/simple/
    如下鏡像未驗證
    http://pypi.douban.com/simple/ 豆瓣
    http://mirrors.aliyun.com/pypi/simple/ 阿里
    http://pypi.hustunique.com/simple/ 華中理工大學
    http://pypi.sdutlinux.org/simple/ 山東理工大學
    http://pypi.mirrors.ustc.edu.cn/simple/ 中國科學技術大學
    https://pypi.tuna.tsinghua.edu.cn/simple 清華
    """
    pass

pep8規範

def demo_pep8():
    """
    1)
    一行列數 : PEP 8 規定爲 79 列，這個太苛刻了，若是要拼接url通常都會超\
    一個函數 : 不要超過 30 行代碼, 便可顯示在一個屏幕類，能夠不使用垂直遊標便可看到整個函數。
    一個類 : 不要超過 200 行代碼，不要有超過 10 個方法。
    一個模塊 : 不要超過 500 行。

    2)不要在一句import中多個庫
    不推薦
    import os, sys

    推薦
    import os
    import sys

    在整理本身代碼的時候記錄的問題。

    錯誤記錄：W292 no newline at end of file
    處理：打個回車有新的一空行便可（新行不要有空格）。

    錯誤記錄：E302 expected 2 blank lines, found 1
    處理：上面只有一行空白，可是須要兩個空白行

    錯誤記錄：E231 missing whitespace after ‘,’
    翻譯：「，」後要有空格
    舉例：
    錯誤 print(「%s %s %s %s %s %s」 % (A,B,D,E,K,L))
    正確 print(「%s %s %s %s %s %s」 % (A, B, D, E, K, L))

    錯誤記錄：E225 missing whitespace around operator
    翻譯：
    舉例：
    錯誤 print(「%s %s %s %s %s %s」%(A, B, D, E, K, L))
    正確 rint(「%s %s %s %s %s %s」% (A, B, D, E, K, L))

    錯誤記錄：E225 missing whitespace around operator
    舉例：
    錯誤 f=open(「D:\\test.txt」, 「ab」)
    正確 f = open(「D:\\test.txt」, 「ab」)

    參考：
    http://www.elias.cn/Python/PythonStyleGuide
    """
    pass

PyCharm選擇性忽略PEP8代碼風格警告信息

def demo_escape_pep8_remind():
    """
    方法一:
    將鼠標移到提示的地方，按alt+Enter，選擇忽略（Ignore）這個錯誤即好。
    方法二
    打開：File - Settings…… - Editor - Inspections
    在python下找到 PEP8 coding style violation，在右邊下面的Ignore errors裏能夠添加忽略的警告信息ID
    id查找網頁：https://pep8.readthedocs.io/en/latest/intro.html#configuration
    """
    pass

python目錄介紹

def demo_py_catalog():
    """
    python模塊位置
    Python自帶的模塊：/usr/lib/python2.7/urllib.py
    Python第三方模塊：/usr/local/lib/python2.7/site-packages
    """
    pass

python經常使用庫

def demo_py_modules():
    """
    網絡請求: urllib/urllib2/httplib/requests/
    網頁解析: lxml/bs4/
    數據分析挖掘: snownlp/jieba/Pinyin2Hanzi/
    圖像: ggplot/matplotlib/PIL/Pillow/
    文本轉語音：pyttsx3/
    多任務：threading/multiprocessing/Queue/
    打印/日誌/調試：pprint/logging/pdb/traceback/
    正則：re/
    系統/調度：sys/subprocess/
    文件處理：cvs/xlib/xlrd/configparser
    加密：hashlib/
    測試：selenium/
    邏輯處理：itertools/functools/
    序列化：json/simplejson/
    數據庫：redis/pymongo(py3)/MySQLdb(py2)/

    註釋：
    lxml性能高於bs4
    據so上的討論simplejson性能高於json
    subprocess調用shell命令的神器
    traceback 調試
    itertools 內建/操做迭代對象
    functools 內建/包含partial及wraps等
    pickle/cPickle 內建/序列化工具
    timeit 內建/計算代碼運行的時間等
    ---------------------------如下未整理

    cProfile python性能測量模塊
    glob 相似與listfile，能夠用來查找文件
    atexit 有一個註冊函數，可用於正好在腳本退出運行前執行一些代碼
    dis python 反彙編，當對某條語句不理解原理時，能夠用dis.dis 函數來查看代碼對應的python 解釋器指令等等。

    第三方庫
    paramiko ssh python 庫
    mechanize  Stateful programmatic web browsing
    pycurl cURL library module for Python
    Fabric Fabric is a Python (2.5 or higher) library and command-line tool for streamlining the use of SSH for application deployment or systems administration tasks
    xmltodict xml 轉 dict，真心好用
    flask web 微框架
    ipdb 調試神器，同時推薦ipython！結合ipython使用
    mako python模版引擎
    numpy ， scipy 科學計算
    scrapy 爬蟲
    django/tornado/web.py/web2py/uliweb/flask/twisted/bottle/cherrypy.等等 python web框架/服務器
    sh 1.08 — sh v1.08 documentation 用來運行shell 模塊的 極佳選擇
    virtualenv。建立獨立 Python 環境的工具。
    IPython。附帶很是額外功能的交互環境。
    httpie。一個命令行HTTP 客戶端，cURL 的替代品，易用性更好。
    you-get。一個 YouTube/Youku/Niconico 視頻下載器。
    youtube-dl。用來下載 YouTube 視頻的工具。
    Cython。優化的 Python 靜態編譯器。使用類型混合使 Python 編譯成 C 或 C++ 模塊來得到性能的極大提高。
    Flake8：靜態檢查工具，它包含PyFlakes（靜態檢查Python代碼邏輯錯誤）、pycodestyle和McCabe（分析Python代碼複雜度）三個工具。
    """
    pass

py命名規範

def demo_name_standard():
    """
    大駝峯：
        類名|AdStats|單詞首字母大寫,內部類可使用額外的前導下劃線。
    大寫，下劃線分割：
        全局變量名
    小寫，下劃線分割：
        文件名、
        模塊名、
        包名、
        普通變量、
        普通函數、
        私有函數、（私有函數以__開頭）
        實例變量、（實例變量以_開頭）
        私有實例變量、（私有實例變量以__開頭）
        專有變量（專有變量__開頭，__結尾，通常爲python的自有變量，勿用）
    ————————————————————————————————————————————————————————————————————
    Python風格指南建議將每一個導入語句單獨成行


    函數和方法的參數|總使用「self」做爲實例方法的第一個參數。總使用「cls」做爲類方法的第一個參數。若是一個函數的參數名稱和保留的關鍵字衝突，一般使用一個後綴下劃線好於使用縮寫或奇怪的拼寫。
    全局變量|對於from M import *導入語句，若是想阻止導入模塊內的全局變量可使用舊有的規範，在全局變量上加一個前導的下劃線。*注意*:應避免使用全局變量
    變量|變量名所有小寫，由下劃線鏈接各個單詞。如color = WHITE，this_is_a_variable = 1 *注意*：1.不管是類成員變量仍是全局變量，均不使用 m 或 g 前綴。2.私有類成員使用單一下劃線前綴標識，多定義公開成員，少定義私有成員。3.變量名不該帶有類型信息，由於Python是動態類型語言。如 iValue、names_list、dict_obj 等都是很差的命名。
    常量|常量名全部字母大寫，由下劃線鏈接各個單詞如MAX_OVERFLOW，TOTAL。
    異常|以「Error」做爲後綴。
    縮寫|命名應當儘可能使用全拼寫的單詞，縮寫的狀況有以下兩種：1.經常使用的縮寫，如XML、ID等，在命名時也應只大寫首字母，如XmlParser。2.命名中含有長單詞，對某個單詞進行縮寫。這時應使用約定成俗的縮寫方式。例如：function 縮寫爲 fn/text 縮寫爲 txt/object 縮寫爲 obj/count 縮寫爲 cnt/number 縮寫爲 num，等。

    前導後綴下劃線|一個前導下劃線：表示非公有。一個後綴下劃線：避免關鍵字衝突。兩個前導下劃線：當命名一個類屬性引發名稱衝突時使用。兩個前導和後綴下劃線：「魔」（有特殊用途）對象或者屬性，例如__init__或者__file__。絕對不要創造這樣的名字，而只是使用它們。*注意*：關於下劃線的使用存在一些爭議。Python 用下劃線做爲變量前綴和後綴指定特殊變量。
    _xxx      不能用'from module import *'導入
    __xxx__ 系統定義名字
    __xxx    類中的私有變量名

    核心風格：避免用下劃線做爲變量名的開始。

    由於下劃線對解釋器有特殊的意義，並且是內建標識符所使用的符號，咱們建議程序員避免用下劃線做爲變量名的開始。通常來說，變量名_xxx被看做是「私有的」，在模塊或類外不可使用。當變量是私有的時候，用_xxx 來表示變量是很好的習慣。由於變量名__xxx__對Python 來講刑厥夂澹雜諂脹ǖ謀淞坑Φ北苊庹庵置綹瘛?br>
    "單下劃線" 開始的成員變量叫作保護變量，意思是隻有類對象和子類對象本身能訪問到這些變量；
    "雙下劃線" 開始的是私有成員，意思是隻有類對象本身能訪問，連子類對象也不能訪問到這個數據。

    以單下劃線開頭（_foo）的表明不能直接訪問的類屬性，需經過類提供的接口進行訪問，不能用「from xxx import *」而導入；以雙下劃線開頭的（__foo）表明類的私有成員；以雙下劃線開頭和結尾的（__foo__）表明python裏特殊方法專用的標識，如 __init__（）表明類的構造函數。
    特定命名方式
    主要是指 __xxx__ 形式的系統保留字命名法。項目中也可使用這種命名，它的意義在於這種形式的變量是隻讀的，這種形式的類成員函數儘可能不要重載。如
    class Base(object):
    def __init__(self, id, parent = None):
    self.__id__ = id
    self.__parent__ = parent
    def __message__(self, msgid):
    # …略
    其中 __id__、__parent__ 和 __message__ 都採用了系統保留字命名法。
    附:Google Python命名規範
        module_name
        package_name
        ClassName
        method_name
        ExceptionName
        function_name
        GLOBAL_VAR_NAME,
        instance_var_name
        function_parameter_name
        local_var_name
    ————————————————————————————————————————————————————————
    from：http://hi.baidu.com/kxw102/blog/item/212e9f3859202fe33b87ce4b.html
    理解Python命名機制

    引子
    我熱情地邀請你們猜想下面這段程序的輸出：
    class A(object):
           def __init__(self):
                  self.__private()
                  self.public()
           def __private(self):
                  print 'A.__private()'
           def public(self):
                  print 'A.public()'
    class B(A):
           def __private(self):
                  print 'B.__private()'
           def public(self):
                  print 'B.public()'
    b = B()

    初探
    正確的答案是：
    A.__private()
    B.public()
    若是您已經猜對了，那麼能夠不看我這篇博文了。若是你沒有猜對或者內心有所疑問，那個人這篇博文正是爲您所準備的。
    一切由爲何會輸出「A.__private()」開始。但要講清楚爲何，咱們就有必要了解一下Python的命名機制。
    據 Python manual，變量名（標識符）是Python的一種原子元素。當變量名被綁定到一個對象的時候，變量名就指代這個對象，就像人類社會同樣，不是嗎？當變 量名出如今代碼塊中，那它就是本地變量；當變量名出如今模塊中，它就是全局變量。模塊相信你們都有很好的理解，但代碼塊可能讓人費解些。在這裏解釋一下：
    代碼塊就是可做爲可執行單元的一段Python程序文本；模塊、函數體和類定義都是代碼塊。不只如此，每個交互腳本命令也是一個代碼塊；一個腳本文件也是一個代碼塊；一個命令行腳本也是一個代碼塊。
    接 下來談談變量的可見性，咱們引入一個範圍的概念。範圍就是變量名在代碼塊的可見性。若是一個代碼塊裏定義本地變量，那範圍就包括這個代碼塊。若是變量定義 在一個功能代碼塊裏，那範圍就擴展到這個功能塊裏的任一代碼塊，除非其中定義了同名的另外一變量。但定義在類中的變量的範圍被限定在類代碼塊，而不會擴展到 方法代碼塊中。

    迷蹤
    據上節的理論，咱們能夠把代碼分爲三個代碼塊：類A的定義、類B的定義和變量b的定義。根據類定義，咱們知道代碼給類A定義了三個成員變量（Python的函數也是對象，因此成員方法稱爲成員變量也行得通。）；類B定義了兩個成員變量。這能夠經過如下代碼驗證：
    # >>> print '\n'.join(dir(A))
    _A__private
    __init__
    public
    # >>> print '\n'.join(dir(B))
    _A__private
    _B__private
    __init__
    public
    咦，爲何類A有個名爲_A__private的 Attribute 呢？並且__private消失了！這就要談談Python的私有變量軋壓了。

    探究
    懂 Python的朋友都知道Python把以兩個或以上下劃線字符開頭且沒有以兩個或以上下劃線結尾的變量看成私有變量。私有變量會在代碼生成以前被轉換爲 長格式（變爲公有）。轉換機制是這樣的：在變量前端插入類名，再在前端加入一個下劃線字符。這就是所謂的私有變量軋壓（Private name mangling）。如類A裏的__private標識符將被轉換爲_A__private，這就是上一節出現_A__private和 __private消失的緣由了。
    再講兩點題外話：
    一是由於軋壓會使標識符變長，當超過255的時候，Python會切斷，要注意所以引發的命名衝突。
    二是當類名所有如下劃線命名的時候，Python就再也不執行軋壓。如：
    #>>> class ____(object):
           def __init__(self):
                  self.__method()
           def __method(self):
                  print '____.__method()'
    #>>> print '\n'.join(dir(____))
    __class__
    __delattr__
    __dict__
    __doc__
    __getattribute__
    __hash__
    __init__
    __method              # 沒被軋壓
    __module__
    __new__
    __reduce__
    __reduce_ex__
    __repr__
    __setattr__
    __str__
    __weakref__
    \>>> obj = ____()
    ____.__method()
    \>>> obj.__method()      # 能夠外部調用
    ____.__method()
    如今咱們回過頭來看看爲何會輸出「A.__private()」吧！

    真相
    相信如今聰明的讀者已經猜到答案了吧？若是你尚未想到，我給你個提示：真相跟C語言裏的宏預處理差很少。
    由於類A定義了一個私有成員函數（變量），因此在代碼生成以前先執行私有變量軋壓（注意到上一節標紅的那行字沒有？）。軋壓以後，類A的代碼就變成這樣了：
    class A(object):
           def __init__(self):
                  self._A__private()          # 這行變了
                  self.public()
           def _A__private(self):           # 這行也變了
                  print 'A.__private()'
           def public(self):
                  print 'A.public()'
    是否是有點像C語言裏的宏展開啊？
    由於在類B定義的時候沒有覆蓋__init__方法，因此調用的仍然是A.__init__，即執行了self._A__private()，天然輸出「A.__private()」了。
    下面的兩段代碼能夠增長說服力，增進理解：
    \>>> class C(A):
           def __init__(self):          # 重寫__init__，再也不調用self._A__private
                  self.__private()       # 這裏綁定的是_C_private
                  self.public()
           def __private(self):
                  print 'C.__private()'
           def public(self):
                  print 'C.public()'
    \>>> c = C()
    C.__private()
    C.public()
    ############################
    \>>> class A(object):
           def __init__(self):
                  self._A__private()   # 調用一個沒有定義的函數，Python會把它給個人 ^_^～
                  self.public()
           def __private(self):
                  print 'A.__private()'
           def public(self):
                  print 'A.public()'
    \>>>a = A()
    A.__private()
    A.public()
    """
    pass

輸出彩色字符

def demo_output_colorful_str():
    r"""
    實現過程：
    終端的字符顏色是用轉義序列控制的，是文本模式下的系統顯示功能，和具體的語言無關。
    轉義序列是以ESC開頭,即用\033來完成（ESC的ASCII碼用十進制表示是27，用八進制表示就是033）

    書寫格式：
    開頭部分：\033[顯示方式;前景色;背景色m + 結尾部分：\033[0m
    注意：開頭部分的三個參數: 顯示方式，前景色，背景色是可選參數，能夠只寫其中的某一個；另外因爲表示三個參數不一樣含義的數值都是惟一的沒有重複的，因此三個參數的書寫前後順序沒有固定要求，系統都能識別；可是，建議按照默認的格式規範書寫。
    對於結尾部分，其實也能夠省略，可是爲了書寫規範，建議\033[***開頭，\033[0m結尾。

    數值表示的參數含義：
    顯示方式: 0（默認值）、1（高亮）、22（非粗體）、4（下劃線）、24（非下劃線）、 5（閃爍）、25（非閃爍）、7（反顯）、27（非反顯）
    前景色: 30（黑色）、31（紅色）、32（綠色）、 33（黃色）、34（藍色）、35（洋 紅）、36（青色）、37（白色）
    背景色: 40（黑色）、41（紅色）、42（綠色）、 43（黃色）、44（藍色）、45（洋 紅）、46（青色）、47（白色）

    常見開頭格式：
    \033[0m            默認字體正常顯示，不高亮
    \033[32;0m       紅色字體正常顯示
    \033[1;32;40m  顯示方式: 高亮    字體前景色：綠色  背景色：黑色
    \033[0;31;46m  顯示方式: 正常    字體前景色：紅色  背景色：青色
    """
    print("\033[1;31;40m您輸入的賬號或密碼錯誤！\033[0m")  # 輸出格式爲：字體高亮，紅色前景，黃色背景  PS：前景色也就是字體的顏色
    print("\033[0;31m%s\033[0m" % "輸出紅色字符")  # 輸出格式爲：字體默認，紅色前景
    print("\033[0;32m%s\033[0m" % "輸出字符")  # 輸出格式爲：字體默認，紅色前景

format函數

class DemoFormat(object):
    """相對基本格式化輸出採用‘%’的方法，format()功能更強大，該函數把字符串當成一個模板，經過傳入的參數進行格式化，而且使用大括號‘{}’做爲特殊字符代替‘%’。"""

    # 方法一：位置替換。在字符串模板中肯定位置，而且位置能夠不按順序，format()可傳入任意數目的參數。
    @staticmethod
    def demo_001():
        print('{0} {1}'.format('hello', 'world'))
        print('{} {}'.format('hello', 'world'))
        print('{0} {1} {0}'.format('hello', 'world'))

    # 方法二：關鍵字替換。
    @staticmethod
    def demo_002():
        print('i love {python}'.format(python='you'))

    # 其餘方法：能夠指定輸出長度和輸出的對齊方式，其中對齊方式有一下幾種
    @staticmethod
    def demo_003():
        """
        < （默認）左對齊
        > 右對齊
        ^ 中間對齊
        = （只用於數字）在小數點後進行補齊
        """
        print(format('string', '2s'))
        print(format(3.14151617, '.5f'))
        print('{0:>10}'.format('sqxu'))  # 10個佔位符，右對齊
        print('{0:4.2f}'.format(3.141516))
        print('{0:6.2f}'.format(3.141516))
        print('{0:>6.2f}'.format(3.141516))
        print('{1:<10},{0:<15}'.format('sqxu', 'USTC'))
        print('name={name},age={age}'.format(name='sqxu', age=25))

    # 經過格式化指示符來控制格式
    @staticmethod
    def demo_004():
        """
        'b' - 二進制。將數字以2爲基數進行輸出。
        'c' - 字符。在打印以前將整數轉換成對應的Unicode字符串。
        'd' - 十進制整數。將數字以10爲基數進行輸出。
        'o' - 八進制。將數字以8爲基數進行輸出。
        'x' - 十六進制。將數字以16爲基數進行輸出，9以上的位數用小寫字母。
        'e' - 冪符號。用科學計數法打印數字。用'e'表示冪。
        'g' - 通常格式。將數值以fixed-point格式輸出。當數值特別大的時候，用冪形式打印。
        'n' - 數字。當值爲整數時和'd'相同，值爲浮點數時和'g'相同。不一樣的是它會根據區域設置插入數字分隔符。
        '%' - 百分數。將數值乘以100而後以fixed-point('f')格式打印，值後面會有一個百分號。
        """
        print('{0:b}'.format(3))
        print('{0:c}'.format(30))
        print('{0:d}'.format(3))
        print('{0:o}'.format(10))
        print('{0:x}'.format(30))
        print('{0:e}'.format(3))
        print('{0:f}'.format(3))
        print('{0:g}'.format(3))
        print('{0:n}'.format(3))
        print('{0:n}'.format(3.1415))
        print('{0:%}'.format(3.15))

bs4模塊

def demo_bs4():
    """
    bs4模塊
    新的庫、可是價值小。支持多進程、不支持多線程、單例對象、每次只能一個一個處理、；
    bs  4一分鐘解析30多個頁面、lxml700多頁面
    :return:
    """
    pass

python代碼簡單性能調優

def demo_xingneng_simple():
    """
    參考地址：https://blog.csdn.net/sinat_38682860/article/details/80600473?from=timeline&isappinstalled=0
    方法：
        一、優化算法時間複雜度
            算法的時間複雜度對程序的執行效率影響最大，在 Python 中能夠經過選擇合適的數據結構來優化時間複雜度，如 list 和 set 查找某一個元素的時間複雜度分別是O(n)和O(1)。
            不一樣的場景有不一樣的優化方式，總得來講，通常有分治，分支界限，貪心，動態規劃等思想。
        二、減小冗餘數據
            如用上三角或下三角的方式去保存一個大的對稱矩陣。在0元素佔大多數的矩陣裏使用稀疏矩陣表示。
        三、合理使用 copy 與 deepcopy
            對於 dict 和 list 等數據結構的對象，直接賦值使用的是引用的方式。
            而有些狀況下須要複製整個對象，這時可使用 copy 包裏的 copy 和 deepcopy，這兩個函數的不一樣之處在於後者是遞歸複製的。效率也不同：（如下程序在 ipython 中運行）
        四、使用 dict 或 set 查找元素
        五、合理使用生成器（generator）和 yield
            使用()獲得的是一個 generator 對象，所須要的內存空間與列表的大小無關，因此效率會高一些。
            可是對於須要循環遍歷的狀況，後者的效率反而更高，可是若是循環裏有 break,用 generator 的好處是顯而易見的。yield 也是用於建立 generator：
        六、優化循環
            循環以外能作的事不要放在循環內
        七、優化包含多個判斷表達式的順序
            對於 and，應該把知足條件少的放在前面，對於 or，把知足條件多的放在前面。
        八、用 join 合併迭代器中的字符串
        九、選擇合適的格式化字符方式
            % format 和 string直接相加 三種方式 選用format吧
        十、不借助中間變量交換兩個變量的值
            a,b=1,2
            a,b=b,a
        十一、使用 if is
        十二、使用級聯比較x < y < z
        1三、hile 1 比 while True 更快
        1四、使用**而不是 pow
        1五、使用 cProfile, cStringIO 和 cPickle 等用c實現相同功能（分別對應profile, StringIO, pickle）的包
        1六、使用最佳的反序列化方式
        1七、使用C擴展(Extension)
        1八、並行編程
        1九、終級大殺器：PyPy
        20、使用性能分析工具
    """

python中os._exit()和 sys.exit(), exit(0)和exit(1) 的用法和區別

概述
    python的程序有兩中退出方式：os._exit()， sys.exit()
    os._exit()會直接將python程序終止，以後的全部代碼都不會繼續執行。
    sys.exit()會引起一個異常：SystemExit，若是這個異常沒有被捕獲，那麼python解釋器將會退出。若是有捕獲此異常的代碼，那麼這些代碼仍是會執行。捕獲這個異常能夠作一些額外的清理工做。0爲正常退出，其餘數值（1-127）爲不正常，可拋異常事件供捕獲。

os._exit()直接將python解釋器退出，餘下的語句不會執行。
sys.exit()的退出比較優雅，調用後會引起SystemExit異常，能夠捕獲此異常作清理工做。

通常來講
os._exit() 用於在線程中退出，通常在fork出來的子進程中使用
sys.exit() 用於在主線程中退出。

安裝pygame

pip install wheel
    pip list ， 出現 wheel ，證實wheel插件安裝成功
網址 http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame
    下載須要的版本
    而後到目錄下執行命令 pip install pygame-1.9.2a0-cp27-none-win_amd64.whl(你下載pygame的對應名稱)
檢測安裝是否成功 pip list

Python錯誤：pip install SSLError【There was a problem confirming the ssl certificate】

證書不受信任，關閉打開的fiddler

Python錯誤：AttributeError: module 'enum' has no attribute 'IntFlag'

從python 3.6開始，enum34庫再也不與標準庫兼容。該庫也是沒必要要的，所以您只需卸載它便可。
pip3 uninstall enum34
pip3 install --index-url https://pypi.douban.com/simple/ pyinstaller

python打包exe

方式1：cx_Freeze

方式2：py2exe
    py2exe與安裝的py版本有關
方式3：pyinsatller
    pyinstaller -F -w (-i icofile) filename
    
    默認-D，生成的帶目錄
    -F，生成單一文件
    -w，表示隱藏程序運行時的命令行窗口（不加-w會有黑色窗口）
    -p，指定依賴路徑
    -i，指定圖標

pycharm 快捷鍵

def demo_pycharm():
    """
    ctrl+alt+l  格式化
    ctrl+f4     關閉頁籤
    """
    pass

pycharm設置

def demo_set_pycharm():
    """
    Ctr+Alt+L快速格式化
    ctrl+/快速註釋
    code style->python設置代碼默認快速格式化格式

    PyCharm3.0默認快捷鍵(翻譯的)
    一、編輯（Editing）
    Ctrl + Space 基本的代碼完成（類、方法、屬性）
    Ctrl + Alt + Space 快速導入任意類
    Ctrl + Shift + Enter 語句完成
    Ctrl + P 參數信息（在方法中調用參數）
    Ctrl + Q 快速查看文檔
    Shift + F1 外部文檔
    Ctrl + 鼠標 簡介
    Ctrl + F1 顯示錯誤描述或警告信息
    Alt + Insert 自動生成代
    Ctrl + O 從新方法
    Ctrl + Alt + T 選中
    Ctrl + / 行註釋
    Ctrl + Shift + / 塊註釋
    Ctrl + W 選中增長的代碼塊
    Ctrl + Shift + W 回到以前狀態
    Ctrl + Shift + ]/[ 選定代碼塊結束、開始
    Alt + Enter 快速修正
    Ctrl + Alt + L 代碼格式化
    Ctrl + Alt + O 優化導入
    Ctrl + Alt + I 自動縮進
    Tab / Shift + Tab 縮進、不縮進當前行
    Ctrl+X/Shift+Delete 剪切當前行或選定的代碼塊到剪貼板
    Ctrl+C/Ctrl+Insert 複製當前行或選定的代碼塊到剪貼板
    Ctrl+V/Shift+Insert 從剪貼板粘貼
    Ctrl + Shift + V 從最近的緩衝區粘貼
    Ctrl + D 複製選定的區域或行
    Ctrl + Y 刪除選定的行
    Ctrl + Shift + J 添加智能線
    Ctrl + Enter 智能線切割
    Shift + Enter 另起一行
    Ctrl + Shift + U 在選定的區域或代碼塊間切換
    Ctrl + Delete 刪除到字符結束
    Ctrl + Backspace 刪除到字符開始
    Ctrl + Numpad+/- 展開摺疊代碼塊
    Ctrl + Numpad+ 所有展開
    Ctrl + Numpad- 所有摺疊
    Ctrl + F4 關閉運行的選項卡
    二、查找/替換(Search/Replace)
    F3 下一個
    Shift + F3 前一個
    Ctrl + R 替換
    Ctrl + Shift + F 全局查找
    Ctrl + Shift + R 全局替換
    三、運行(Running)
    Alt + Shift + F10 運行模式配置
    Alt + Shift + F9 調試模式配置
    Shift + F10 運行
    Shift + F9 調試
    Ctrl + Shift + F10 運行編輯器配置
    Ctrl + Alt + R 運行manage.py任務
    四、調試(Debugging)
    F8 跳過
    F7 進入
    Shift + F8 退出
    Alt + F9 運行遊標
    Alt + F8 驗證表達式
    Ctrl + Alt + F8 快速驗證表達式
    F9 恢復程序
    Ctrl + F8 斷點開關
    Ctrl + Shift + F8 查看斷點
    五、導航(Navigation)
    Ctrl + N 跳轉到類
    Ctrl + Shift + N 跳轉到符號
    Alt + Right/Left 跳轉到下一個、前一個編輯的選項卡
    F12 回到先前的工具窗口
    Esc 從工具窗口回到編輯窗口
    Shift + Esc 隱藏運行的、最近運行的窗口
    Ctrl + Shift + F4 關閉主動運行的選項卡
    Ctrl + G 查看當前行號、字符號
    Ctrl + E 當前文件彈出
    Ctrl+Alt+Left/Right 後退、前進
    Ctrl+Shift+Backspace 導航到最近編輯區域
    Alt + F1 查找當前文件或標識
    Ctrl+B / Ctrl+Click 跳轉到聲明
    Ctrl + Alt + B 跳轉到實現
    Ctrl + Shift + I查看快速定義
    Ctrl + Shift + B跳轉到類型聲明
    Ctrl + U跳轉到父方法、父類
    Alt + Up/Down跳轉到上一個、下一個方法
    Ctrl + ]/[跳轉到代碼塊結束、開始
    Ctrl + F12彈出文件結構
    Ctrl + H類型層次結構
    Ctrl + Shift + H方法層次結構
    Ctrl + Alt + H調用層次結構
    F2 / Shift + F2下一條、前一條高亮的錯誤
    F4 / Ctrl + Enter編輯資源、查看資源
    Alt + Home顯示導航條F11書籤開關
    Ctrl + Shift + F11書籤助記開關
    Ctrl + #[0-9]跳轉到標識的書籤
    Shift + F11顯示書籤
    六、搜索相關(Usage Search)
    Alt + F7/Ctrl + F7文件中查詢用法
    Ctrl + Shift + F7文件中用法高亮顯示
    Ctrl + Alt + F7顯示用法
    七、重構(Refactoring)
    F5複製F6剪切
    Alt + Delete安全刪除
    Shift + F6重命名
    Ctrl + F6更改簽名
    Ctrl + Alt + N內聯
    Ctrl + Alt + M提取方法
    Ctrl + Alt + V提取屬性
    Ctrl + Alt + F提取字段
    Ctrl + Alt + C提取常量
    Ctrl + Alt + P提取參數
    八、控制VCS/Local History
    Ctrl + K提交項目
    Ctrl + T更新項目
    Alt + Shift + C查看最近的變化
    Alt + BackQuote(’)VCS快速彈出
    九、模版(Live Templates)
    Ctrl + Alt + J當前行使用模版
    Ctrl +Ｊ插入模版
    十、基本(General)
    Alt + #[0-9]打開相應的工具窗口
    Ctrl + Alt + Y同步
    Ctrl + Shift + F12最大化編輯開關
    Alt + Shift + F添加到最喜歡
    Alt + Shift + I根據配置檢查當前文
    Ctrl + BackQuote(’)快速切換當前計劃
    Ctrl + Alt + S　打開設置頁
    Ctrl + Shift + A查找編輯器裏全部的動做
    Ctrl + Tab在窗口間進行切換

    一些經常使用設置：
        1. pycharm默認是自動保存的，習慣本身按ctrl + s 的能夠進行以下設置：
            1. file -> Setting -> General -> Synchronization -> Save files on frame deactivation 和 Save files automatically if application is idle for .. sec 的勾去掉
            2. file ->Setting -> Editor -> Editor Tabs -> Mark modified tabs with asterisk 打上勾
        2. Alt + Enter: 自動添加包
        3. 對於經常使用的快捷鍵，能夠設置爲visual studio(eclipse...)同樣的：
        file -> Setting -> Keymap -> Keymaps -> vuisual studio -> Apply
        4. Pycharm中默認是不能用Ctrl+滾輪改變字體大小的，能夠在file -> Setting ->Editor-〉Mouse中設置
        5. 要設置Pycharm的字體，要先在file -> Setting ->Editor-〉Editor中選擇一種風格並保存，而後才能夠改變
        6. 在setting中搜索theme能夠改變主題，全部配色統一改變
    """
    pass

python導出已安裝庫方法

def demo_output_moudles():
    """
    pip freeze > requirements.txt           //導出dependency
    若是須要導入項目的庫的話，能夠先安裝pip install pipreqs，而後命令行執行 pipreqs ./
    pip install -r requirements.txt         //安裝dependency

    另外，有些小細節也是值得一提的，
    那就是"pip freeze > requirements.txt"指令必須用在整個工程項目徹底跑通了（也就是項目依賴已經所有安裝完成）的狀況下，
    才能將全部的有關依賴庫寫入requirements.txt文件中去，
    而「pip install -r requirements.txt」指令則使用於服務器部署時較爲合適
    :return:
    """
    pass

python中子類初始化使用super報錯

def demo_lower_calss_init_use_super_error():
    """
    出現的TypeError: must be type, not classobj 緣由及解決
    python中super只能應用於父類爲新類，而不能應用於父類爲經典類
    所謂新類就是全部類都必需要有繼承的類，若是什麼都不想繼承，就繼承到object類。經典類報錯
    """
    pass

time模塊

def demo_time():
    """
    # python中時間日期格式化符號：
    # %y 兩位數的年份表示（00-99）
    # %Y 四位數的年份表示（000-9999）
    # %m 月份（01-12）
    # %d 月內中的一天（0-31）
    # %H 24小時制小時數（0-23）
    # %I 12小時制小時數（01-12）
    # %M 分鐘數（00=59）
    # %S 秒（00-59）
    # %a 本地簡化星期名稱
    # %A 本地完整星期名稱
    # %b 本地簡化的月份名稱
    # %B 本地完整的月份名稱
    # %c 本地相應的日期表示和時間表示
    # %j 年內的一天（001-366）
    # %p 本地A.M.或P.M.的等價符
    # %U 一年中的星期數（00-53）星期天爲星期的開始
    # %w 星期（0-6），星期天爲星期的開始
    # %W 一年中的星期數（00-53）星期一爲星期的開始
    # %x 本地相應的日期表示
    # %X 本地相應的時間表示
    # %Z 當前時區的名稱
    # %% %號自己
    """
    # 時間戳都以自從1970年1月1日午夜（曆元）通過了多長時間來表示。時間間隔是以秒爲單位的浮點小數
    print("當前時間戳爲: %s" % time.time())
    # 時間元組
    print((time.localtime()))
    # 格式化時間
    print("本地時間爲: %s" % time.asctime(time.localtime(time.time())))
    # 格式化日期
    # time.strftime(format[, t])
    # 格式化成2016-03-20 11:45:39形式
    print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

    # 格式化成2016-03-20形式
    print(time.strftime("%Y-%m-%d", time.localtime()))

    # 格式化成Sat Mar 28 22:24:24 2016形式
    print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

    # 將格式字符串轉換爲時間戳
    a = "Sat Mar 28 22:24:24 2016"
    print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))

snownlp庫

def demo_snownlp():
    """
    國人開發/針對中文文本進行挖掘/已有算法，需本身調用函數，根據不一樣的文本構建語料庫/
    snownlp：
    中文分詞（算法是Character-Based Generative Model）
    詞性標註（原理是TnT、3-gram隱馬）
    情感分析（官網指明購物類評論準確率較高，由於語料庫主要是購物方面，可本身構建相關領域語料庫替換）
    文本分類（原理是樸素貝葉斯）
    轉換拼音
    繁體轉簡體
    提取文本關鍵詞（原理是TextRank）
    提取摘要（原理是TextRank）
    分割句子
    文本類似（原理是BM25）。
    """
    pass

內置模塊

def builtin_modules():
    """
    help(obj) 在線幫助, obj但是任何類型
    callable(obj) 查看一個obj是否是能夠像函數同樣調用
    repr(obj) 獲得obj的表示字符串，能夠利用這個字符串eval重建該對象的一個拷貝
    eval_r(str) 表示合法的python表達式，返回這個表達式
    dir(obj) 查看obj的name space中可見的name
    hasattr(obj,name) 查看一個obj的name space中是否有name
    getattr(obj,name) 獲得一個obj的name space中的一個name
    setattr(obj,name,value) 爲一個obj的name
    space中的一個name指向vale這個object
    delattr(obj,name) 從obj的name space中刪除一個name
    vars(obj) 返回一個object的name space。用dictionary表示
    locals() 返回一個局部name space,用dictionary表示
    globals() 返回一個全局name space,用dictionary表示
    type(obj) 查看一個obj的類型
    isinstance(obj,cls) 查看obj是否是cls的instance
    issubclass(subcls,supcls) 查看subcls是否是supcls的子類

    #################    類型轉換  ##################

    chr(i) 把一個ASCII數值,變成字符
    ord(i) 把一個字符或者unicode字符,變成ASCII數值
    oct(x) 把整數x變成八進制表示的字符串
    hex(x) 把整數x變成十六進制表示的字符串
    str(obj) 獲得obj的字符串描述
    list(seq) 把一個sequence轉換成一個list
    tuple(seq) 把一個sequence轉換成一個tuple
    dict(),dict(list) 轉換成一個dictionary
    int(x) 轉換成一個integer
    long(x) 轉換成一個long interger
    float(x) 轉換成一個浮點數
    complex(x) 轉換成複數
    max(...) 求最大值
    min(...) 求最小值
    :return:
    """
    pass

os模塊

def demo_os():
    """
    os.environ 一個dictionary 包含環境變量的映射關係
    os.environ["HOME"] 能夠獲得環境變量HOME的值
    os.chdir(dir) 改變當前目錄 os.chdir('d:\\outlook')
    注意windows下用到轉義
    os.getcwd() 獲得當前目錄
    os.getegid() 獲得有效組id os.getgid() 獲得組id
    os.getuid() 獲得用戶id os.geteuid() 獲得有效用戶id
    os.setegid os.setegid() os.seteuid() os.setuid()
    os.getgruops() 獲得用戶組名稱列表
    os.getlogin() 獲得用戶登陸名稱
    os.getenv 獲得環境變量
    os.putenv 設置環境變量
    os.umask 設置umask
    os.system(cmd) 利用系統調用，運行cmd命令
    :return:
    """
    pass

sys模塊

def demo_sys():
    import sys
    """
    sys.argv 是一個 list,包含全部的命令行參數
    sys.stdout sys.stdin sys.stderr 分別表示標準輸入輸出,錯誤輸出的文件對象.
    sys.stdin.readline() 從標準輸入讀一行 sys.stdout.write("a") 屏幕輸出a
    sys.exit()  # 直接退出程序，不須要考慮平臺等因素的影響，通常是退出Python程序的首選方法。
    sys.exit(0)  # 默認爲0，表示正常退出。爲1，表示異常退出
    os._exit()  # 直接退出，不會拋出異常，可是其使用會受到平臺的限制，但咱們經常使用的Win32平臺和基於UNIX的平臺不會有所影響
    os.kill()  # 通常用於直接Kill掉進程，可是隻能在UNIX平臺上有效
    os.popen()  # 直接執行系統命令，而在Windows下其實就是使用taskkill來kill掉進程，其基本形式是，taskkill   /pid   程序的PID號碼
    """
    print(sys.path)  # sys.path 是一個list,指明全部查找module，package的路徑
    print(sys.platform)  # 獲得運行的操做系統環境
    print(sys.modules)  # 是一個dictionary，表示系統中全部可用的module

日曆模塊

class DemoCalendar(object):
    # 返回指定年的某月
    @staticmethod
    def get_month(year, month):
        return calendar.month(year, month)

    # 返回指定年的日曆
    @staticmethod
    def get_calendar(year):
        return calendar.calendar(year)

    # 判斷某一年是否爲閏年，若是是，返回True，若是不是，則返回False
    @staticmethod
    def is_leap(year):
        return calendar.isleap(year)

    # 返回某個月以每一週爲元素的序列
    @staticmethod
    def get_month_calendar(year, month):
        return calendar.monthcalendar(year, month)

獲取當前函數名

def return_func_name():
    """
    sys.getframe().f_code.co_name 方法永遠獲取當前所在的函數名稱，inspect.stack()方法相對更靈活一些，在get_current_function_name函數中，sys獲取的函數名稱是get_cu
    rrent_function_name,而inspect方法返回的結果是function_one。inspect.stack記錄了當前的棧內信息，想進一步瞭解能夠打印inspect.stack()信息。
    我在function_one函數中調用了get_current_function_name，所以inspect.stack()返回的list中的第一個元組是有關get_current_function_name信息的，第二個元組纔是function_one的相關信息。
    :return:
    """
    pass

文件操做

class DemoFileHandle(object):
    """
    r   以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。
    rb  以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。通常用於非文本文件如圖片等。
    r+  打開一個文件用於讀寫。文件指針將會放在文件的開頭。
    rb+ 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。通常用於非文本文件如圖片等。
    w   打開一個文件只用於寫入。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
    wb  以二進制格式打開一個文件只用於寫入。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。通常用於非文本文件如圖片等。
    w+  打開一個文件用於讀寫。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
    wb+ 以二進制格式打開一個文件用於讀寫。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。通常用於非文本文件如圖片等。
    a   打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
    ab  以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
    a+  打開一個文件用於讀寫。若是該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。
    ab+ 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。若是該文件不存在，建立新文件用於讀寫。
    """

    @staticmethod
    def demo001():
        # 打開一個文件
        fo = open("foo.txt", "w")
        # 打印文件的屬性
        print("文件名: ", fo.name)
        print("是否已關閉 : ", fo.closed)
        # print("訪問模式 : ", fo.mode)
        # print("末尾是否強制加空格 : ", fo.softspace)
        print(
            fo.read())  # read方法從一個打開的文件中讀取文件的字符串。fo.read([count])在這裏，count是要從已打開文件中讀取的字節計數。該方法從文件的開頭開始讀入，若是沒有傳入count，它會嘗試儘量多地讀取更多的內容，極可能是直到文件的末尾。
        fo.close()  # 關閉打開的文件

        # 打開一個文件
        fo = open("foo.txt", "r+")
        str_tmp = fo.read(10)
        print("讀取的字符串是 : ", str_tmp)

        # 查找當前位置
        position = fo.tell()
        print("當前文件位置 : ", position)

        # 把指針再次從新定位到文件開頭
        # position = fo.seek(0, 0)
        fo.seek(0, 0)
        str_tmp = fo.read(10)
        print("從新讀取字符串 : ", str_tmp)

        # 關閉打開的文件
        fo.close()

        # 重命名文件test1.txt到test2.txt。
        os.rename("test1.txt", "test2.txt")

        # remove()方法刪除文件，須要提供要刪除的文件名做爲參數
        # 刪除一個已經存在的文件test2.txt
        os.remove("test2.txt")

        # 在當前目錄下建立一個新目錄test
        # 建立目錄test
        os.mkdir("test")

        # 進入"/home/newdir"目錄
        # 將當前目錄改成"/home/newdir"
        os.chdir("/home/newdir")

        # 給出當前目錄
        # # getcwd()方法顯示當前的工做目錄
        print(os.getcwd())

        # 刪除目錄
        # rmdir()方法刪除目錄，目錄名稱以參數傳遞。在刪除這個目錄以前，它的全部內容應該先被清除。語法：os.rmdir('dirname')。目錄的徹底合規的名稱必須被給出，不然會在當前目錄下搜索該目錄。
        # 刪除」/tmp/test」目錄
        os.rmdir("/tmp/test")

輸出不換行

def no_change_line():
    """
    對於python2和python3都兼容的寫法是：
    print('hello', end='')
    python 2.x, print 不換行
    print x,
    python 3.x print 不換行
    print(x, end="")
    :return:
    """
    print('---', end="")
    print('hello', end='')
    # print 'hello', # py2
    print('---', end="")

讀取鍵盤輸入

def demo_input():
    """
    Raw_input函數從標準輸入讀取一個行，並返回一個字符串（去掉結尾的換行符）
    input([prompt]) 函數和 raw_input([prompt]) 函數基本相似，可是 input 能夠接收一個Python表達式做爲輸入，並將運算結果返回。
    """
    # pass
    # str = raw_input("Enter your input: ") # py2
    str_tmp = input("Enter your input: ")  # 都轉化爲字符串類型
    print(str_tmp)

併發問題

def demo_concurrency():
    """
    [問題]
    python中因爲使用了全局解釋鎖（GIL）的緣由，代碼並不能同時在多核上併發的運行，也就是說，Python的多線程不能併發

    [GIL總結]
    Python的多線程在多核CPU上，只對於IO密集型計算產生正面效果；而當有至少有一個CPU密集型線程存在，那麼多線程效率會因爲GIL而大幅降低。
    Python GIL實際上是功能和性能之間權衡後的產物，它有其存在的合理性，也有較難改變的客觀因素。
    若是對並行計算性能較高的程序能夠考慮把核心部分寫成C模塊，或用其餘語言實現
    GIL將會繼續存在和改進

    [避免GIL影響]
    用multiprocessing替代Thread
    multiprocessing庫的出現很大程度上是爲了彌補thread庫由於GIL而低效的缺陷。
    它完整的複製了一套thread所提供的接口方便遷移。惟一的不一樣就是它使用了多進程而不是多線程。
    每一個進程有本身的獨立的GIL，所以也不會出現進程之間的GIL爭搶。
    固然multiprocessing也不是萬能良藥。它的引入會增長程序實現時線程間數據通信和同步的困難。
    就拿計數器來舉例子，若是咱們要多個線程累加同一個變量，對於thread來講，申明一個global變量，用thread.Lock的context包裹住三行就搞定了。
    而multiprocessing因爲進程之間沒法看到對方的數據，只能經過在主線程申明一個Queue，put再get或者用share memory的方法。
    這個額外的實現成本使得原本就很是痛苦的多線程程序編碼，變得更加痛苦了。

    用其餘解析器
    既然GIL只是CPython的產物，那麼其餘解析器是否是更好呢？沒錯，像JPython和IronPython這樣的解析器因爲實現語言的特性，他們不須要GIL的幫助。
    然而因爲用了Java/C#用於解析器實現，他們也失去了利用社區衆多C語言模塊有用特性的機會。
    因此這些解析器也所以一直都比較小衆。畢竟功能和性能你們在初期都會選擇前者，Done is better than perfect。

    固然Python社區也在很是努力的不斷改進GIL，甚至是嘗試去除GIL。並在各個小版本中有了很多的進步。
    有興趣的讀者能夠擴展閱讀這個Slide 另外一個改進Reworking the GIL - 將切換顆粒度從基於opcode計數改爲基於時間片計數 -
    避免最近一次釋放GIL鎖的線程再次被當即調度 - 新增線程優先級功能（高優先級線程能夠迫使其餘線程釋放所持有的GIL鎖）
    :return:
    """
    pass

web應用：關於wsgi、框架、模板

def demo_wsgi():
    """
    其實一個Web App，就是寫一個WSGI的處理函數，針對每一個HTTP請求進行響應。
    可是如何處理HTTP請求不是問題，問題是如何處理100個不一樣的URL。
    一個最簡單的想法是從environ變量裏取出HTTP請求的信息，而後逐個判斷.只是這麼寫下去代碼是確定無法維護了
    須要在WSGI接口之上能進一步抽象，讓咱們專一於用一個函數處理一個URL，至於URL到函數的映射，就交給Web框架來作。
    用Python開發一個Web框架十分容易，因此Python有上百個開源的Web框架。
    常見web框架
    Flask : Flask經過request.form['name']來獲取表單的內容。
    Django：全能型Web框架；
    web.py：一個小巧的Web框架；
    Bottle：和Flask相似的Web框架；
    Tornado：Facebook的開源異步Web框架。
    :return:
    """
    pass

如何使用Headless Chrome

def demo_chrome_headless():
    """
    Headless模式是Chrome59中的新特徵、要使用Chrome須要安裝chromedriver、其餘用法與PhantomJS基本相同。更多資料請查看官方文檔。參考資料：https://developers.google.com/web/updates/2017/04/headless-chrome
    :return:
    """
    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options
    chrome_options = Options()
    chrome_options.add_argument('--headless')
    chrome_options.add_argument('--disable-gpu')
    driver = webdriver.Chrome(chrome_options=chrome_options)
    driver.get("https://cnblogs.com/")
    print(driver.title)

其餘

python2和3不一樣

def demo_diff_between_py2_and_py3():
    """
    換行
    引包
    一些模塊名（mysql庫等）
    hashlib在hashing以前要編碼
    csv&ini讀取文件時3須要加編碼格式
    異常處理寫法，另外python3中一個except捕獲多個異常須要用元組。
    捕獲異常時、文件不存在的異常狀況異常名不一樣
    使用套接字的時候有區別，python3要求加一個b
    """
    pass

語法變化

print再也不是語句而是函數
捕獲異常由except exc , var 改成 except exc as var
棄用比較運算符<>爲!=
from module import * 如今只能用於模塊不能用於函數
from .[mouodle] import name 是相對導入惟一正確語法，不以點開頭的爲絕對導入
sorted函數與列表的sort方法再也不接收cmp參數，使用key參數代替
整數除法如1/2返回浮點數，取整能夠用1//2

標準庫變化

模塊刪除或者重組,如：
urlparse移到urllib.parse

延遲加載模塊（import在函數內部）會使函數被調用時纔可能發現庫不可用

數據類型與集合的變化

字符串編碼

python優點

def demo_005():
    """
    軟件開發：遊戲後臺、搜索、圖形界面、網站、c/s軟件、科學運算、
    系統管理：腳本、it自動化工具、
    """
    pass

代碼合規手段

def demo_code_standard():
    """
    代碼合規手段：
        測試驅動開發
        代碼審查
        結對編程
        性能分析
        以及其餘讓代碼更加可靠且符合預期的手段
    :return:
    """

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。