摘要：序列化的這種過程，我們將其稱為腌制。而把模塊編譯成二進(jìn)制語言程序的這個(gè)過程叫做字節(jié)編譯，這個(gè)過程會產(chǎn)生一個(gè)與編譯的模塊對應(yīng)的文件。

在Python中常量的使用并不像java等其他編程語言一樣有特定的常量實(shí)現(xiàn)的關(guān)鍵字，在Python中定義需要用對象的方法來創(chuàng)建。

[代碼演示ConstVar.py]

# coding=utf-8
import const

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

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

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

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

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
# 通過使用鏈?zhǔn)劫x值(chained assignment)可以將一個(gè)值同時(shí)賦給多個(gè)變量
x = y = z = 1
print x, y, z  # output: 1 1 1

數(shù)：

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

字符串：

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

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

基本數(shù)據(jù)類型：

數(shù)以及字符串

常用的數(shù)據(jù)類型：

列表和元組：

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

# coding=utf-8
# java中List、數(shù)組對應(yīng)的內(nèi)容
# 列表
students = ["小明", "小華", "小李", "小娟", "小云"]
print students[3]
students[3] = "小月"
print students[3]
# 元組java中沒有內(nèi)置對應(yīng)的數(shù)據(jù)結(jié)構(gòu)
studentsArray = ("小明", "小軍", "小強(qiáng)", "小武", "小龍")
print studentsArray[1]
# studentsArray[1] = "小云"  # 這行會報(bào)錯(cuò) 元組不允許修改
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
# 去除重復(fù)元素
new = set(a)
print new
# 字典
k = {"姓名": "韋瑋", "籍貫": "桂林"}
print k["籍貫"]
# 添加字典里面的項(xiàng)目
k["愛好"] = "音樂"
print k["姓名"]
print k["愛好"]

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

有效標(biāo)識符命名有以下幾點(diǎn)規(guī)范：

標(biāo)識符第一個(gè)字符必須只能是字母或下劃線，第一個(gè)字符不能出現(xiàn)數(shù)字或其他字符；
標(biāo)識符除第一個(gè)字符外，其他部分可以是字母或者下劃線或者數(shù)字；
標(biāo)識符大小寫敏感，比如name跟Name是不同的標(biāo)識符。
標(biāo)識符不能是關(guān)鍵字

Python關(guān)鍵字：

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

序列化的這種過程，我們將其稱為pickle（腌制）。pickle中的函數(shù)主要有：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)將對象原樣恢復(fù)，并且對象類型也恢復(fù)為原來的格式
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()存儲在文件里面的數(shù)據(jù)恢復(fù)
f2 = file("1.pk1", "rb")
t = pickle.load(f2)
print t
f2.close()

邏輯行與物理行：

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

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

縮進(jìn)：

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

優(yōu)先級：
優(yōu)先級使用實(shí)戰(zhàn)
優(yōu)先級排行榜第1名——函數(shù)調(diào)用、尋址、下標(biāo)
優(yōu)先級排行榜第2名——冪運(yùn)算**
優(yōu)先級排行榜第3名——翻轉(zhuǎn)運(yùn)算~
優(yōu)先級排行榜第4名——正負(fù)號
優(yōu)先級排行榜第5名——*、/、%
優(yōu)先級排行榜第6名——+、-
優(yōu)先級排行榜第7名——<<、>>
優(yōu)先級排行榜第8名——按位&、^、|，其實(shí)這三個(gè)中也是有優(yōu)先級順序的，但是他們處于同一級別，故而不細(xì)分
優(yōu)先級排行榜第9名——比較運(yùn)算符
優(yōu)先級排行榜第10名——邏輯的not、and、or
優(yōu)先級排行榜第11名——lambda表達(dá)式

函數(shù)的功能：

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


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

函數(shù)的定義：

# coding=utf-8
# 函數(shù)的定義
# 格式
"""
def 函數(shù)名（）：
    函數(shù)內(nèi)容;函數(shù)內(nèi)容
    函數(shù)內(nèi)容;函數(shù)內(nèi)容
"""


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

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

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


# 關(guān)鍵參數(shù)
def function(a=1, b=6, c=7):
    print a
    print b
    print c

#python中可以指定參數(shù)從而無需依循參數(shù)的順序[java無此功能]
# function(5)
# function(b=7,a=8)
# function(5,c=2,b=3)
# function(b=4,c=2,a=1)
"""但是要注意，參數(shù)不能沖突"""
# function(b=2, c=3, 2)#這行會報(bào)錯(cuò)，因?yàn)榈谌齻€(gè)默認(rèn)是c參數(shù)，前面已經(jīng)給c參數(shù)賦值，所以沖突

全局變量：

# 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

函數(shù)的使用：

# coding=utf-8
# 函數(shù)使用與返回值
# 函數(shù)調(diào)用
"""
函數(shù)的調(diào)用我們已經(jīng)接觸過了多次，要想調(diào)用一個(gè)函數(shù)，
在函數(shù)定以后，直接輸一遍這個(gè)函數(shù)名即可，如果要傳
遞實(shí)參到函數(shù)里面執(zhí)行，直接在調(diào)用的時(shí)候括號里面輸
入實(shí)參即可。比如一個(gè)函數(shù)是def func3()：這樣定
義的,那么我們調(diào)用它直接輸入func3(參數(shù))即可。其
中參數(shù)可以省略。
"""
def a():
    i = 1
a()
# 函數(shù)返回值
"""函數(shù)的返回值是通過return語句來實(shí)現(xiàn)的"""
# 一個(gè)返回值的情況
def test():
    i = 7
    return i
# print test()
# 多個(gè)返回值的情況
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):
    """這個(gè)函數(shù)實(shí)現(xiàn)一個(gè)乘法運(yùn)算。
    函數(shù)會返回一個(gè)乘法運(yùn)算的結(jié)果。"""
    k = i * j
    return k

# print d.__doc__

help(d)

函數(shù)是可以實(shí)現(xiàn)一項(xiàng)或多項(xiàng)功能的一段程序。

模塊是函數(shù)功能的擴(kuò)展，模塊是可以實(shí)現(xiàn)一項(xiàng)或多項(xiàng)功能的程序塊。
Python中在一個(gè)程序中要使用某個(gè)模塊，不能直接使用模塊里面的功能。在使用模塊之前，必須先導(dǎo)入指定模塊，只要導(dǎo)入了一個(gè)模塊，才能使用一個(gè)模塊。

由于計(jì)算機(jī)只認(rèn)識二進(jìn)制的機(jī)器語言，所以在執(zhí)行Python模塊的時(shí)候，有兩種執(zhí)行方式：

一種是先將模塊里面的內(nèi)容編譯成二進(jìn)制語言，然后執(zhí)行這些二進(jìn)制語言；
另一種是直接執(zhí)行對應(yīng)模塊的二進(jìn)制語言程序。

第二種方式省略了編譯這一步，所以執(zhí)行速度相對來說要快一些。而把模塊編譯成二進(jìn)制語言程序的這個(gè)過程叫做字節(jié)編譯，這個(gè)過程會產(chǎn)生一個(gè)與編譯的模塊對應(yīng)的.pyc文件。

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

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

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

# coding=utf-8
# 分別直接執(zhí)行這個(gè)模塊與導(dǎo)入這個(gè)模塊，看一下結(jié)果
print __name__
if __name__ == "__main__":
    print "This is main"
else:
    print "This is not main"

函數(shù)是可以實(shí)現(xiàn)一項(xiàng)或多項(xiàng)功能的一段程序。

模塊是函數(shù)功能的擴(kuò)展，模塊是可以實(shí)現(xiàn)一項(xiàng)或多項(xiàng)功能的程序塊。
Python中在一個(gè)程序中要使用某個(gè)模塊，不能直接使用模塊里面的功能。在使用模塊之前，必須先導(dǎo)入指定模塊，只要導(dǎo)入了一個(gè)模塊，才能使用一個(gè)模塊。

本人的直播課程在 7 月份就要開始了，希望小伙伴們支持一下，現(xiàn)在報(bào)名有優(yōu)惠噢

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

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