聊聊Python【一文從安裝到掌握語法】

前言：

python是一門高級腳本語言，爲了之後的機器學習，自動化有必要學習下。

1、Mac環境下安裝python3.X

1、查看 mac 自帶系統版本
#查看系統自帶的python
open /System/Library/Frameworks/Python.framework/Versions
#系統當前的python版本。
python -V

2、開始安裝(這裏我們使用神器homebrew)
#安裝前先搜索一下是否已經存在python3的包：
brew search python3
#已經存在，我們可以直接安裝了：
brew install python3
#查找python3安裝路徑
brew info python3
#修改 Mac 系統配置文件
vi ~/.bash_profile
#添加配置信息
alias python="/usr/local/bin/python3"
#編譯系統配置文件
source ~/.bash_profile
#系統當前的python版本。
python -V

效果圖：

2、安裝PyCharm ，python的開發工具

可以去直接搜PyCharm，然後idea官網下載。破解版或者試用版都可以，網上會有很多破解教程。

3、輸出demo,Hello 小誠信驛站！

4、關於python的基本語法

4.1、弱變量類型

如果使用Java Script或者shell，go的時候，你是不需要申明變量類型的，你賦值以後那麼他的類型已經確定了。

如果希望顯示的知道變量類型，可以使用type(變量的名字)，來查看變量的類型。

4.2、我們可以談談python的語法規則

• 標示符由字母、下劃線和數字組成，且數字不能開頭
• python中的標識符是區分大小寫的
• 見名知意
• 駝峯命名法
  目前開發者已經確定的關鍵字

 and 並且
 as   簡短命名   
 assert 斷言    
 break  中斷
 class  類
 continue  繼續
 def   定義腳本註釋頭  
 del 刪除函數
 if   判斷語句相當於if
 elif    判斷語句相當於else if
 else    判斷語句相當於else
 except     異常捕獲
 exec      執行
 finally    最終
 for        遍歷循環 
 from    導包
 global      全局變量
 in     循環遍歷的關鍵字
 import     導包
 is        (ob1 is ob2) 等價於 (id(ob1) == id(ob2))
 lambda     用lambda關鍵詞能創建小型匿名函數。這種函數得名於省略了用def聲明函數的標準步驟。
 not        not(boolean)布爾非 
 or         關鍵字或
 pass       通過什麼也不做
 print   輸出
 raise   拋出異常
 return    返回 
 try       捕獲異常
 while     while循環 
 with      （１）緊跟with後面的語句被求值後，返回對象的“–enter–()”方法被調用，這個方法的返回值將被賦值給as後面的變量；（２）當with後面的代碼塊全部被執行完之後，將調用前面返回對象的“–exit–()”方法。
 yield    帶yield的函數是一個生成器，而不是一個函數，這個生成器有一個函數就是next函數，next就相當於“下一步”生成哪個數，這一次的next開始的地方是接着上一次的next停止的地方執行的，所以調用next的時候，生成器並不會從foo函數的開始執行，只是接着上一步停止的地方開始，然後遇到yield後，return出要生成的數

格式化輸出：

常用的格式化符號

input()函數的輸入

算數運算符

複合賦值運算符

賦值運算符

數據類型的轉換

for循環遍歷，關鍵字判斷

控制檯的輸入：

切片概念：

import random

# 定義一個列表用來保存3個辦公室
offices = [[],[],[]]

# 定義一個列表用來存儲8位老師的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('辦公室%d的人數爲:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

hashmap字典的使用

寫個函數完成調用

函數缺省值

不定長參數函數的使用

#加了星號（*）的變量args會存放所有未命名的變量參數，args爲元組；
# 而加**的變量kwargs會存放命名參數，即形如key=value的參數， kwargs爲字典。
def fun(a, b, *args, **kwargs):
    print ("a =", a)
    print ("b =", b)
    print ("args =", args)
    print ("kwargs: ")
    for key, value in kwargs.items():
       print (key, "=", value)

fun(1, 2, 3, 4, 5, m=6, n=7, p=8)

Python中函數參數是引用傳遞（注意不是值傳遞）。對於不可變類型，因變量不能修改，所以運算不會影響到變量自身；而對於可變類型來說，函數體中的運算有可能會更改傳入的參數變量。這一點和Java很像。

可變類型與不可變類型
可變類型，值可以改變：

列表 list
字典 dict
不可變類型，值不可以改變：

數值類型 int, long, bool, float
字符串 str
元組 tuple

匿名函數的使用：

在python，使用open函數，可以打開一個已經存在的文件，或者創建一個新文件

open(文件名，訪問模式)

 # 新建一個文件，文件名爲:test.txt
    f = open('test.txt', 'w')

    # 關閉這個文件
    f.close()

# 寫數據
f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()

# 讀數據
f = open('test.txt', 'r')

content = f.read(5)

print(content)

print("-"*30)

content = f.read()

print(content)

f.close()


# 讀行數據
f = open('test.txt', 'r')

content = f.readlines()

print(type(content))

i=1
for temp in content:
    print("%d:%s"%(i, temp))
    i+=1

f.close()

# 讀行數據
f = open('test.txt', 'r')

content = f.readline()
print("1:%s"%content)

content = f.readline()
print("2:%s"%content)


f.close()

面向對象編程

# 定義類
class Car:
    # 方法
    def getCarInfo(self):
        print('車輪子個數:%d, 顏色%s'%(self.wheelNum, self.color))

    def move(self):
        print("車正在移動...")

所謂的self，可以理解爲自己
可以把self當做C++中類裏面的this指針一樣理解，就是對象自身的意思
某個對象調用其方法時，python解釋器會把這個對象作爲第一個參數傳遞給self，所以開發者只需要傳遞後面的參數即可
init()方法，在創建一個對象時默認被調用，不需要手動調用
init(self)中，默認有1個參數名字爲self，如果在創建對象時傳遞了2個實參，那麼__init__(self)中出了self作爲第一個形參外還需要2個形參，例如__init__(self,x,y)
init(self)中的self參數，不需要開發者傳遞，python解釋器會自動把當前的對象引用傳遞進去

在python中方法名如果是__xxxx__()的，那麼就有特殊的功能，因此叫做“魔法”方法
Python中沒有像C++中public和private這些關鍵字來區別公有屬性和私有屬性
它是以屬性命名方式來區分，如果在屬性名前面加了2個下劃線’__’，則表明該屬性是私有屬性，否則爲公有屬性（方法也是一樣，方法名前面加了2個下劃線的話表示該方法是私有的，否則爲公有的）

創建對象後，python解釋器默認調用__init__()方法；

當刪除一個對象時，python解釋器也會默認調用一個方法，這個方法爲__del__()方法

'''
單繼承
'''

# 定義一個父類，如下:
class Cat(object):

    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color

    def run(self):
        print("%s--在跑"%self.name)


# 定義一個子類，繼承Cat類如下:
class Bosi(Cat):

    def setNewName(self, newName):
        self.name = newName

    def eat(self):
        print("%s--在吃"%self.name)


bs = Bosi("印度貓")
print('bs的名字爲:%s'%bs.name)
print('bs的顏色爲:%s'%bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()

'''
多繼承
'''
class base(object):
    def test(self):
        print('----base test----')
class A(base):
    def test(self):
        print('----A test----')

# 定義一個父類
class B(base):
    def test(self):
        print('----B test----')

# 定義一個子類，繼承自A、B
class C(A,B):
    pass


obj_C = C()
obj_C.test()

print(C.__mro__) #可以查看C類的對象搜索方法時的先後順序

'''
重寫
所謂重寫，就是子類中，有一個和父類相同名字的方法，在子類中的方法會覆蓋掉父類中同名的方法
'''
class Cat(object):
    def sayHello(self):
        print("halou-----1")


class Bosi(Cat):

    def sayHello(self):
        print("halou-----2")

bosi = Bosi()

bosi.sayHello()

通過super函數調用父類函數
class Cat(object):
    def __init__(self,name):
        self.name = name
        self.color = 'yellow'


class Bosi(Cat):

    def __init__(self,name):
        # 調用父類的__init__方法1(python2)
        #Cat.__init__(self,name)
        # 調用父類的__init__方法2
        #super(Bosi,self).__init__(name)
        # 調用父類的__init__方法3
        super().__init__(name)

    def getName(self):
        return self.name

bosi = Bosi('xiaohua')

print(bosi.name)
print(bosi.color)

'''
多態 所謂多態：定義時的類型和運行時的類型不一樣，此時就成爲多態
'''

class F1(object):
    def show(self):
        print ('F1.show')

class S1(F1):

    def show(self):
        print ('S1.show')

class S2(F1):

    def show(self):
        print ('S2.show')

def Func(obj):
    print (obj.show())

s1_obj = S1()
Func(s1_obj)

s2_obj = S2()
Func(s2_obj)

'''
類和類屬性和對象屬性
'''

class People(object):
    country = 'china' #類屬性


print(People.country)
p = People()
print(p.country)
p.country = 'japan'
print(p.country)      #實例屬性會屏蔽掉同名的類屬性
print(People.country)
del p.country    #刪除實例屬性
print(p.country)

'''
類方法和靜態方法
'''


class People(object):
    country = 'china'

    @staticmethod
    #靜態方法
    def getCountry():
        return People.country

    # 類方法，用classmethod來進行修飾
    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls, country):
        cls.country = country


p = People()
print (p.getCountry())    #可以用過實例對象引用
print (People.getCountry())     #可以通過類對象引用

p.setCountry('japan')

print (p.getCountry()) 
print (People.getCountry()) 

'''
_new_返回的對象 就是init的self實例，cls是必傳參數
'''

class A(object):
    def __init__(self):
        print("這是 init 方法")

    def __new__(cls):
        print("這是 new 方法")
        return object.__new__(cls)

A()

# 實例化一個單例 並且只執行一次init方法
class Singleton(object):
    __instance = None
    __first_init = False

    def __new__(cls, age, name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):
        if not self.__first_init:
            self.age = age
            self.name = name
            Singleton.__first_init = True


a = Singleton(18, "dongGe")
b = Singleton(8, "dongGe")

print(id(a))
print(id(b))


print(a.age)
print(b.age)

a.age = 19
print(b.age)

#異常的把控
import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    except:
        #如果在讀取文件的過程中，產生了異常，那麼就會捕獲到
        #比如 按下了 ctrl+c
        pass
    finally:
        f.close()
        print('關閉文件')
except:
    print("沒有這個文件")

# 拋出自定義異常
class ShortInputException(Exception):
    '''自定義的異常類'''
    def __init__(self, length, atleast):
        #super().__init__()
        self.length = length
        self.atleast = atleast

def main():
    try:
        s = input('請輸入 --> ')
        if len(s) < 3:
            # raise引發一個你定義的異常
            raise ShortInputException(len(s), 3)
    except ShortInputException as result:#x這個變量被綁定到了錯誤的實例
        print('ShortInputException: 輸入的長度是 %d,長度至少應是 %d'% (result.length, result.atleast))
    else:
        print('沒有異常發生.')

main()

# raise觸發默認的異常
class Test(object):
    def __init__(self, switch):
        self.switch = switch #開關
    def calc(self, a, b):
        try:
            return a/b
        except Exception as result:
            if self.switch:
                print("捕獲開啓，已經捕獲到了異常，信息如下:")
                print(result)
            else:
                #重新拋出這個異常，此時就不會被這個異常處理給捕獲到，從而觸發默認的異常處理
                raise


a = Test(True)
a.calc(11,0)

print("----------------------華麗的分割線----------------")

a.switch = False
a.calc(11,0)

模塊的導入
當你導入一個模塊，Python解析器對模塊位置的搜索順序是：

當前目錄
如果不在當前目錄，Python則搜索在shell變量PYTHONPATH下的每個目錄。
如果都找不到，Python會察看默認路徑。UNIX下，默認路徑一般爲/usr/local/lib/python/
模塊搜索路徑存儲在system模塊的sys.path變量中。變量裏包含當前目錄，PYTHONPATH和由安裝過程決定的默認目錄。


#as用法
import time as tt
# 把一個模塊的所有內容全都導入到當前的命名空間也是可行的，只需使用如下聲明：
from modname import *
# 要導入模塊fib的fibonacci函數
from fib import fibonacci
# 關鍵字import來引入某個模塊
from 模塊名 import 函數名1,函數名2....

模塊的製作和測試
可以根據__name__變量的結果能夠判斷出，是直接執行的python腳本還是被引入執行的，從而能夠有選擇性的執行測試代碼

test.py
    def add(a,b):
        return a+b

    # 用來進行測試
    ret = add(12,22)
    print('int test.py file,,,,12+22=%d'%ret)


main.py
    import test

    result = test.add(11,22)
    print(result)


如果一個文件中有__all__變量，那麼也就意味着只有這個變量中的元素會被from xxx import *時導入

重點

__init__.py可以用來管理包

pip 是 python 自帶的一個軟件，相當於手機裏的應用市場，可以用來安裝、卸載、搜索 python 的常見模塊。

直接輸入 pip 後回車，可以查看 pip 命令的所有可用參數。

1.安裝模塊
在命令行執行

pip install 模塊名
2.卸載模塊
在命令行執行

pip uninstall 模塊名
3.搜索模塊
在命令行執行

pip search 模塊名