摘要：序列化的這種過程，我們將其稱為腌制。而把模塊編譯成二進制語言程序的這個過程叫做字節編譯，這個過程會產生一個與編譯的模塊對應的文件。

在Python中常量的使用并不像java等其他編程語言一樣有特定的常量實現的關鍵字，在Python中定義需要用對象的方法來創建。

[代碼演示ConstVar.py]

# coding=utf-8
import const

# java中注解使用 //
# java中使用final關鍵字
# final int STATIC_VAR=5
# java是編譯型語言所以IDE可以實現在編寫代碼時就提醒錯誤【編譯時就會檢查錯誤】
# 而python是解釋型語言，得運行時才會拋出異常
const.STATIC_VAR = 5
print const.STATIC_VAR
#const.STATIC_VAR = 6  # 這一行會拋出異常

# 變量聲明與java的區別
# java中聲明變量必須聲明變量的類型 如 int i=6;
i = 6

# java中變量的類型不能變化【不能把int賦值給String】而python則可以
i = "一二三"

# 通過序列解包(sequence unpacking)可以將多個值的序列解開，讓后一一放置到變量的序列中。
# 解包的序列中的元素必須和等號左邊變量數量一致。
values = "1", 2, True#生成的是一個元組【后面會介紹】

print values  # output: (1, 2, 3)
print values[0]
x, y, z = values  # output: 1 2 3
bob_Info = {"name": "Bob", "email": "bob@gmail.com"}
key, value = bob_Info.popitem()
print value  # output: Bob
# 通過使用鏈式賦值(chained assignment)可以將一個值同時賦給多個變量
x = y = z = 1
print x, y, z  # output: 1 1 1

數：

Python中數的類型主要有5種，分為有符號整數型(int)，長整型(long)，浮點型(float)，布爾型(bool)，復數型(complex)。這些類型是不可變的，就是說整數對象一旦創建，其值便不可更改。相反，系統將創建新的簡單類型對象并將其賦值給變量。
例如： 0、 1、 -1、 1009、 -290這些等等都是int型。例如： 87887l、 -90990l、 234567l這些等等都是long型。例如： 2.7788、 3.277、 8.88這些等等都是float型。bool型只有兩個：一個是True、一個是False。例如： 4+2j、 -9+20j、 56+7j這種類型屬于復數類型。
[代碼演示]

字符串：

Python字符串與java區別較大，與javascript較為相似。
[代碼演示IntString.py]

# coding=utf-8
# 變量
# java 中基本類型是值傳遞，賦值時并不會新建對象
# java 中 String 和 python String一樣時不可變的
i = 100
print id(i)  # 通過Python id 函數可以查看基本PyObject標識的變更方式
print i
i = 101
print id(i)
print i
# 復數  java中沒有此類型
num = -8.222 - 1.34j
print num.real  # num.real    該復數的實數部分
print num.imag  # num.imag    該復數的虛數部分
print num.conjugate()  # num.conjugat()    返回該復數的共軛算數
# 字符串
# java中字符串只可使用雙引號聲明
# 單引號
c1 = "2ght"
print id(c1)
print c1
# 下面的語句在java中需要使用轉義
c2 = "It is a "dog"!"
print c2
# 雙引號
c1 = "2ght11"
print id(c1)
print c1
c2 = "It"s a dog!"
print c2
# java要實現該代碼較為復雜且可讀性較差
c1 = """三引號
聲明的字符串
會保留換行
    也會保留縮進"""
print c1
c2 = """三引號
雙引號也可以
聲明的字符串
會保留換行
    也會保留縮進"""
print c2
# 字符串拼接
str = "one" + "123" + "456"
print str
# str="one"+"123"+
#     "456"這種寫法是錯誤的
# 用于代碼換行時的拼接
# java中沒有編譯時會自動將物理行轉換為邏輯行所以使用+即可并無此特性
one = "第一次" 
      "第二次"
print one
# 子字符串
# 索引運算符從0開始索引
# 切片運算符[a:b]是指從第a下標開始到第b-1下標。同樣第一位的下標為0.
str = "0123456789"
print "str[7] %s" % str[7]
print "str[0:3] %s" % str[0:3]  # 截取第一位到第三位的字符
print "str[:] %s" % str[:]  # 截取字符串的全部字符 java中不支持默認值，所以沒有該對應的方法
print "str[6:] %s" % str[6:]  # 截取第七個字符到結尾
print "str[:-3] %s" % str[:-3]  # 截取開始到倒數
print "str[-1] %s" % str[-1]  # 截取倒數第一個字符
print "str[::-1] %s" % str[::-1]  # 倒序 java中反轉字符需要自行編寫方法實現
print "str[-3:-1] %s" % str[-3:-1]  # 截取倒數第三位與倒數第一位之前的字符
print "str[-3:] %s" % str[-3:]  # 截取倒數第三位到結尾
print "str[:-5] %s" % str[:-5]  # 逆序截取
print "str[:-5:-3] %s" % str[:-5:-3]  # 逆序截取
# 去空格及特殊符號
# strip(rm)刪除s字符串中開頭、結尾處，位于 rm刪除序列的字符，默認為空格。
# lstrip(rm)刪除s字符串中開頭處，位于 rm刪除序列的字符
# rstrip(rm)刪除s字符串中結尾處，位于 rm刪除序列的字符
s = " 12313 "
print s
print s.strip()#對應java.trim()單java中不可傳參
s = ",12313,"
print s
print s.lstrip(",")#java API沒有對應方法
print s.rstrip(",")#java API沒有對應方法
# str -- 分隔符，默認為空格。
# num -- 分割次數。
str = "#Line1-abcdef #Line2-abc #Line4-abcd";
print str.split()#java中有對應方法只是沒有默認參數
print str.split(" ", 1)
# 字符串的重復
str = "字符串的重復
" * 20#java中不支持此特性需要循環實現
print str
# 轉義符
print "It"s a dog!"
print "hello boy
hello boy"
# 自然字符串
print "hello boy
hello boy"
print r"hello boy
hello boy"  # java中則是
來實現
# 其他API可以自行查詢

基本數據類型：

數以及字符串

常用的數據類型：

列表和元組：

在Python中沒有數組的概念， Python中跟數組最接近的概念就是列表和元組。
列表就是用來存儲一連串元素的容器。列表用[]來表示元組里面的元素也是進行索引計算列表跟元組有什么區別呢？
一是列表里面的元素的值可以修改，而元組里面的元素的值不能修改，只能讀取。二是列表的符號是[],而元組的符號是（）集合：
Python中集合主要有兩個功能，一個功能是建立關系，另一個功能是消除重復元素。
字典：Python中的字典也叫做關聯數組，用大括號{}括起來
[代碼演示DataType.py]

# coding=utf-8
# java中List、數組對應的內容
# 列表
students = ["小明", "小華", "小李", "小娟", "小云"]
print students[3]
students[3] = "小月"
print students[3]
# 元組java中沒有內置對應的數據結構
studentsArray = ("小明", "小軍", "小強", "小武", "小龍")
print studentsArray[1]
# studentsArray[1] = "小云"  # 這行會報錯 元組不允許修改
print studentsArray[1]
#java中set接口
a = set("abcnmaaaaggsng")
b = set("cdfm")
print a  # 會自動去重
print b
# 交集
x = a & b
print x
# 并集
y = a | b
print y
# 差集
z = a - b
print z
# 去除重復元素
new = set(a)
print new
# 字典
k = {"姓名": "韋瑋", "籍貫": "桂林"}
print k["籍貫"]
# 添加字典里面的項目
k["愛好"] = "音樂"
print k["姓名"]
print k["愛好"]

在Python中標識符的命名是有規則的。
按正確命名規則命名的可以使用的標識符叫做有效標識符，否則不能使用的標識符叫做無效標識符。

有效標識符命名有以下幾點規范：

標識符第一個字符必須只能是字母或下劃線，第一個字符不能出現數字或其他字符；
標識符除第一個字符外，其他部分可以是字母或者下劃線或者數字；
標識符大小寫敏感，比如name跟Name是不同的標識符。
標識符不能是關鍵字

Python關鍵字：

在Python中，一切皆為對象。Python的內置的對象類型主要有數字、字符串、列表、元組、字典、集合等等。
在Python中如果我們有一些對象需要持久性存儲，并且不丟失我們這個對象的類型與數據，我們則需要將這些對象進行序列化，序列化之后，需要使用的時候，我們再恢復為原來的數據。

序列化的這種過程，我們將其稱為pickle（腌制）。pickle中的函數主要有：dumps(object),loads(string),dump(object,file),loads(file)
[代碼演示pickleTest.py]

# coding=utf-8
# pickle腌制
import pickle

# dumps(object)將對象序列化
lista = ["mingyue", "jishi", "you"]
listb = pickle.dumps(lista)
# print listb

# loads(string)將對象原樣恢復，并且對象類型也恢復為原來的格式
listc = pickle.loads(listb)
# print listc

# dump(object,file),將對象存儲到文件里面序列化
group1 = ("bajiu", "wen", "qingtian")
# file是python中IO操作的模塊 wb 代表寫 rb 代表讀
f1 = file("1.pk1", "wb")
pickle.dump(group1, f1, True)
f1.close()

# load(object,file)將dump()存儲在文件里面的數據恢復
f2 = file("1.pk1", "rb")
t = pickle.load(f2)
print t
f2.close()

邏輯行與物理行：

Python中邏輯行主要是指一段代碼，在意義上它的行數，而物理行，指的是我們實際看到中的行數。

在Python中一個物理行一般可以包含多個邏輯行，在一個物理行中編寫多個邏輯行的時候，邏輯行與邏輯行之間用分號隔開。
每個邏輯行的后面必須是有一個分號的，但是我們在編寫程序的時候，如果一個邏輯行占了一個物理行的最后，這個邏輯行可以省略分號。

縮進：

在Python中我們常見的運算符有： +、 -、 *、 /、 **、 <、 >、 !=、 //、 % 、 & 、 |、 ^、~、 >>、 <<、 <=、 >=、 ==、 not、 and、 or。[代碼演示 運算符.py]

優先級：
優先級使用實戰
優先級排行榜第1名——函數調用、尋址、下標
優先級排行榜第2名——冪運算**
優先級排行榜第3名——翻轉運算~
優先級排行榜第4名——正負號
優先級排行榜第5名——*、/、%
優先級排行榜第6名——+、-
優先級排行榜第7名——<<、>>
優先級排行榜第8名——按位&、^、|，其實這三個中也是有優先級順序的，但是他們處于同一級別，故而不細分
優先級排行榜第9名——比較運算符
優先級排行榜第10名——邏輯的not、and、or
優先級排行榜第11名——lambda表達式

函數的功能：

# coding=utf-8
# 函數的功能
# 系統自帶的函數
# 1.實現取字符串長度的功能
"""
a="hellomyteacher"
print len(a)
"""
# 2.實現字符串的切割
"""
a="student"
b=a.split("u")
print b
"""


# 自定義的函數
def a():
    print "hello";
    print 777
    print "a"
a()

函數的定義：

# coding=utf-8
# 函數的定義
# 格式
"""
def 函數名（）：
    函數內容;函數內容
    函數內容;函數內容
"""


# 實例
def function1():
    a = 8
    print a

# coding=utf-8
# 函數形參與實參
# 參數的概念
# print len()

"""
a="abcdm"
print len(a)
"""
# 什么是形參
"""
def function1(a,b):
    if a>b:
        print a
    else:
        print b
   """
# 什么是實參
"""
def function1(a,b):
    if a>b:
        print a
    else:
        print b
function1(1,3)#1 3是實參
"""
# 參數的傳遞
# 第一中，最簡單的傳遞
"""
def function(a,b):
    if a>b:
        print "前面這個數大于后面這個數"
    else:
        print "后面這個數比較大"
function(7,8)
"""
# 第二種，賦值傳遞
"""
def function(a,b=8):
    print a
    print b
#function(1)
function(1,2)
"""


# 關鍵參數
def function(a=1, b=6, c=7):
    print a
    print b
    print c

#python中可以指定參數從而無需依循參數的順序[java無此功能]
# function(5)
# function(b=7,a=8)
# function(5,c=2,b=3)
# function(b=4,c=2,a=1)
"""但是要注意，參數不能沖突"""
# function(b=2, c=3, 2)#這行會報錯，因為第三個默認是c參數，前面已經給c參數賦值，所以沖突

全局變量：

# coding=utf-8
# 全局變量與局部變量
# 作用域
def func():
    i = 8
# print i
# print j
j = 9
# print j
# 局部變量
def func2(a):
    i = 7
    print i
i = 9
# func2(i)
# print i
# 全局變量
def func3():
    global i
    i = 7
    # print i
# i=9
func3()
i = 9
print i

函數的使用：

# coding=utf-8
# 函數使用與返回值
# 函數調用
"""
函數的調用我們已經接觸過了多次，要想調用一個函數，
在函數定以后，直接輸一遍這個函數名即可，如果要傳
遞實參到函數里面執行，直接在調用的時候括號里面輸
入實參即可。比如一個函數是def func3()：這樣定
義的,那么我們調用它直接輸入func3(參數)即可。其
中參數可以省略。
"""
def a():
    i = 1
a()
# 函數返回值
"""函數的返回值是通過return語句來實現的"""
# 一個返回值的情況
def test():
    i = 7
    return i
# print test()
# 多個返回值的情況
def test2(i, j):
    k = i * j
    return (i, j, k)
# x=test2(4,5)
# print x
y, z, m = test2(4, 5)
print y

文檔字符串：

# coding=utf-8
# 文檔字符串
def d(i, j):
    """這個函數實現一個乘法運算。
    函數會返回一個乘法運算的結果。"""
    k = i * j
    return k

# print d.__doc__

help(d)

函數是可以實現一項或多項功能的一段程序。

模塊是函數功能的擴展，模塊是可以實現一項或多項功能的程序塊。
Python中在一個程序中要使用某個模塊，不能直接使用模塊里面的功能。在使用模塊之前，必須先導入指定模塊，只要導入了一個模塊，才能使用一個模塊。

由于計算機只認識二進制的機器語言，所以在執行Python模塊的時候，有兩種執行方式：

一種是先將模塊里面的內容編譯成二進制語言，然后執行這些二進制語言；
另一種是直接執行對應模塊的二進制語言程序。

第二種方式省略了編譯這一步，所以執行速度相對來說要快一些。而把模塊編譯成二進制語言程序的這個過程叫做字節編譯，這個過程會產生一個與編譯的模塊對應的.pyc文件。

把模塊編譯成二進制語言程序的這個過程叫做字節編譯。
Python中雖然出現了編譯這個過程，但是Python中編譯的過程是在Python的解釋器中發生的。換句話來說，其實每種程序要想讓計算機執行，都只能變成二進制的形式，編譯型語言是指在軟件中就有一個獨立的編譯模塊去將程序編譯，而Python中字節編譯這部分功能是由解釋器完成的，所以Python仍然是解釋型語言。[對應java中.class]

Python函數中，如果一個函數調用其他函數完成一項功能，我們稱這個函數為主函數，如果一個函數沒有調用其他函數，我們這種函數叫做非主函數。
模塊也類似，如果一個模塊是被直接使用的，而沒有被別人調用，我們稱這個模塊為主模塊，如果一個模塊被別人調用，我們這種模塊叫做非主模塊。

如果一個模塊的__name__屬性的值是__main__，那么就說明這個模塊是主模塊，反之亦然。
其實我們可以把__name__看作一個變量，這個變量是系統給出的，這個變量的功能是判斷一個模塊是否是主模塊。
[modul.py]

# coding=utf-8
# 分別直接執行這個模塊與導入這個模塊，看一下結果
print __name__
if __name__ == "__main__":
    print "This is main"
else:
    print "This is not main"

函數是可以實現一項或多項功能的一段程序。

模塊是函數功能的擴展，模塊是可以實現一項或多項功能的程序塊。
Python中在一個程序中要使用某個模塊，不能直接使用模塊里面的功能。在使用模塊之前，必須先導入指定模塊，只要導入了一個模塊，才能使用一個模塊。

本人的直播課程在 7 月份就要開始了，希望小伙伴們支持一下，現在報名有優惠噢

https://segmentfault.com/l/15...

https://segmentfault.com/l/15...