python的基本使用

print 功能

print 字符串

• python 中 print 字符串 要加’ ‘(單引號)或者” “(雙引號)。
• 要顯示引號：加反斜杠\ 或者外層用雙引號

>>> print('hello world')
hello world
>>> print("hello world 2")
hello world 2
print('I\'m')
I'm
print("I'm")
I'm

print 字符串疊加

可以使用 + 將兩個(gè)字符串鏈接起來。

>>> print('Hello world' + ' Hello Gong Kong')
Hello world Hello Gong Kong

字符串不能直接+數(shù)字,可以包在' '里面或者通過str()轉(zhuǎn)化成string

>>>print('apple'+4)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: must be str, not int
>>>print('apple'+'4')
apple4
>>>print('apple'+str(4))
apple4

int()可以把整數(shù)的string轉(zhuǎn)化為int，而小數(shù)形式的string需要通過float()轉(zhuǎn)化

>>>print(int('2.2')+2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '2.2'
>>>print(int('2')+2)
4
>>>print(float('2.2')+2)
4.2

簡單運(yùn)算

可以直接print 加法+,減法-,乘法*,除法/.
注意：字符串不可以直接和數(shù)字相加，否則出現(xiàn)錯(cuò)誤。

>>> print(1 + 1)
2
>>> print(3 - 1)
2
>>> print(3 * 4)
12
>>> print(12 / 4)
3.0
>>> print('iphone' + 4)
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
print('iphone' + 4)
TypeError: must be str, not int

int()和 float()；當(dāng)int()一個(gè)浮點(diǎn)型數(shù)時(shí)，int會保留整數(shù)部分,比如 int(1.9),會輸出1,而不是四舍五入。

>>> print(int('2') + 3) # int為定義整數(shù)型 
5
>>> print(int(1.9)) # 當(dāng)定義為一個(gè)浮點(diǎn)型數(shù)時(shí)，int會保留整數(shù)部分
1
>>>print(int(2.6)+2)
4
>>> print(float('1.2') + 3) # float是浮點(diǎn)型，可以把字符串轉(zhuǎn)換為小數(shù)
4.2

基礎(chǔ)數(shù)學(xué)運(yùn)算

基本的加減乘除

python可以直接運(yùn)算數(shù)字，也可以加print 進(jìn)行運(yùn)算。

>>> 1 + 1
2
>>> 2 - 1
1
>>> 2 * 3
6
>>> 4 / 3
1.3333333333333333

^ 與 *

python當(dāng)中^{符號，區(qū)別于其他語言，在python中，}用兩個(gè)表示，如3的平方為3*2 , 3表示立方，4表示4次方，依次類推。

>>> 3 ** 2  # **2表示3的二次方
9
>>> 3 ** 3  # **3表示3的三次方
27

取余數(shù) %

取余數(shù)符號為“%”。

>>> 8 % 3
2

取整//

>>>9//4
2

Python比較運(yùn)算符

以下假設(shè)變量a為10，變量b為20：

Python賦值運(yùn)算符

以下假設(shè)變量a為10，變量b為20：

Python邏輯運(yùn)算符

Python語言支持邏輯運(yùn)算符，以下假設(shè)變量 a 為 10, b為 20:

Python成員運(yùn)算符

除了以上的一些運(yùn)算符之外，Python還支持成員運(yùn)算符，測試實(shí)例中包含了一系列的成員，包括字符串，列表或元組。

Python身份運(yùn)算符

身份運(yùn)算符用于比較兩個(gè)對象的存儲單元

變量 variable

自變量命名規(guī)則

可以將一個(gè)數(shù)值，或者字符串串附值給自變量，如apple=1中，apple為自變量的名稱，1為自變量的值。 也可以將字符串賦值給自變量

>>>apple='iphone'
>>>pear=10
>>>print(apple)
iphone
>>>print(pear)
10

自變量名稱區(qū)分大小寫；如果需要用多個(gè)單詞來表示自變量，需要加下劃線，如

>>>apple_2016 = 'iphone7 plus and new macbook'
>>>print(apple_2016)  # 輸出值為iphone7 plus and new macbook
iphone7 plus and new macbook

可在自變量后面進(jìn)行運(yùn)算,運(yùn)算結(jié)果存儲在自變量里

>>>c=1+2+3
>>>c
6

python允許一次定義多個(gè)自變量，如

>>>a, b, c = 11, 12, 13
>>>print(a, b, c) # 輸出值為11, 12, 13
11 12 13

while和for循環(huán)

while循環(huán)

基本使用

主要結(jié)構(gòu)如下：

while condition:
    expressions

其中 condition為判斷條件，在 Python 中就是True 和False 其中的一個(gè)，如果為 True， 那么將執(zhí)行 expressions語句,否則將跳過該 while 語句塊接著往下執(zhí)行。

實(shí)例

比如要打印出 0 - 9 的所有數(shù)據(jù)：

condition = 0
while condition < 10:
    print(condition)
    condition = condition + 1

輸出的結(jié)果將是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 第一行設(shè)置condition的 初始值為 0，在進(jìn)行 while 判斷的時(shí)候0 < 10為 True，將會執(zhí)行 while 內(nèi)部 的代碼，首先先打印出該值，然后將 condition 值加 1，至此將完成一次循環(huán)；再 condition的值與 10進(jìn)行比較，仍然為True，重復(fù)如上過程，至到condiiton等于 10 后，不滿足condition < 10的條件（False），將不執(zhí)行 while 內(nèi)部的內(nèi)容，所以10不會被打印。

注意點(diǎn)

在使用 while 句法的時(shí)候一定要注意在循環(huán)內(nèi)部一定要修改判斷條件的值，否則程序的while部分將永遠(yuǎn)執(zhí)行下去。
如果按以下程序執(zhí)行，程序?qū)⒁恢贝蛴〕?I’m True，要停止程序，使用ctrl + c終止程序。

while True:
    print("I'm True")

高級主題

在 Python 中除了常規(guī)比較操作

• 小于（<)
• 大于 (>)
• 不大于 (<=)
• 不小于 (>=)
• 等于 (==)
• 不等于 (!=)

會返回True 和 False值，其他操作也會返回 True 和 False。

1.數(shù)字

整數(shù)和浮點(diǎn)數(shù)也能進(jìn)行 Boolean數(shù)據(jù)操作，如果該值等于0或者0.0將會返回False，其余的返回True。

condition = 10
while condition:
    print(condition)
    condition=-1

輸出的結(jié)果將會是 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 在這里condition在while語句中，如果該值大于0，那么將會返回為True，執(zhí)行循環(huán)內(nèi)部語句，直至 condition等于0，返回 False。

2.None 類型

如果 while 后面接著的語句數(shù)據(jù)類型None, 將會返回 False。

3.集合類型

在Python中集合類型有list、tuple、dict和set等，如果該集合對象作為while判斷語句， 如果集合中的元素?cái)?shù)量為 0，那么將會返回False，否則返回True。
下列程序?qū)祷?9, 8, 7, 6, 5, 4, 3, 2, 1, 0，程序首先判斷列表是否空，如果不為空，則打印出最后一個(gè)內(nèi)容，然后使用切片操作去掉最后一個(gè)元素，并更新列表；如此重復(fù)，直至列表為空。

a = range(10)
while a:
    print(a[-1])
    a = a[:len(a)-1]

for循環(huán)

基本使用

在Python中的基本使用方法如下：

for item in sequence:
    expressions

sequence為可迭代的對象，item為序列中的每個(gè)對象。

實(shí)例

example_list = [1, 2, 3, 4, 5, 6, 7, 12, 543, 876, 12, 3, 2, 5]
for i in example_list:
    print(i)

以下程序輸出的結(jié)果為1,2,3,4,5,6,7,12,543,876,12,3,2,5, 內(nèi)容依次為 example_list中的每一個(gè)元素。注意 Python 是使用縮進(jìn)表示程序的結(jié)構(gòu)，如果程序如下編寫

example_list = [1, 2, 3, 4, 5, 6, 7, 12, 543, 876, 12, 3, 2, 5]
for i in example_list:
    print(i)
    print("inner of for")
print("outer of for')

那么每次循環(huán)都會輸出 inner of for，在循環(huán)結(jié)束后，輸出outer of for一次。

進(jìn)階

range使用

在 Python 內(nèi)置了工廠函數(shù)，range 函數(shù)將會返回一個(gè)序列，總共有三種使用方法

1.range(start, stop)

其中start 將會是序列的起始值，stop為結(jié)束值，但是不包括該值，類似數(shù)學(xué)中的表達(dá) [start, stop),左邊為閉區(qū)間，右邊為開區(qū)間。

for i in range(1, 10):
    print(i)  # 上述表達(dá)將會返回1-9所有整數(shù)，但不包括10

2.range(stop)

如果省略了 start 那么將從 0開始，相當(dāng)于range(0, stop)。

3.range(start, stop, step)

step 代表的為步長，即相隔的兩個(gè)值的差值。從 start 開始，依次增加 step 的值，直至等于或者大于 stop。

for i in range(0, 13, 5):
    print(i)  # 將會輸出0,5,10

高級主題

4.1內(nèi)置集合

Python共內(nèi)置了list、tuple 、dict和set四種基本集合，每個(gè)集合對象都能夠迭代。
tuple 類型

tup = ('python', 2.7, 64)
for i in tup:
    print(i)  # 程序?qū)⒁源税葱休敵觥畃ython’, 2.7, 64

dictionary 類型
字典在迭代的過程 中將key作為可迭代的對象返回。
（注意字典中 key是亂序的，也就是說和插入的順序是不一致的。
如果想要使用順序一致的字典，請使用collections 模塊中的 OrderedDict對象。）——似乎是舊版問題
下列程序輸出的結(jié)果為：lan python,version 2.7,platform 64,a b,c 1,1 2,1 v
。

dic = {'lan': 'python', 'version': 2.7, 'platform': 64}
for key in dic:
    print(key, dic[key])

dic={}
dic['a']='b'
dic['c']=1
dic[1]=2
dic['1']='v'
for key in dic:
    print(key, dic[key])

set 類型

set 集合將會去除重復(fù)項(xiàng)。輸出的 結(jié)果也不是按照輸入的順序。
下列程序?qū)敵?python, python3, python2。

s = set(['python', 'python2', 'python3', 'python'])   
for item in s:
    print(item)

迭代器

Python 中的 for句法實(shí)際上實(shí)現(xiàn)了設(shè)計(jì)模式中的迭代器模式 ，所以我們自己也可以按照迭代器的要求自己生成迭代器對象，以便在 for 語句中使用。只要類中實(shí)現(xiàn)了iter 和next函數(shù)，那么對象就可以在for 語句中使用。現(xiàn)在創(chuàng)建 Fibonacci 迭代器對象，以下程序?qū)敵銮?5 個(gè) Fibonacci 數(shù)據(jù) 1，1，2，3，5。

# define a Fib class
class Fib(object):
    def __init__(self, max):
        self.max = max
        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.max:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n = self.n + 1
            return r
        raise StopIteration()

# using Fib object
for i in Fib(5):
    print(i)

4.3 生成器

除了使用迭代器以外，Python 使用yield 關(guān)鍵字也能實(shí)現(xiàn)類似迭代的效果。yield 語句每次執(zhí)行時(shí)，立即返回結(jié)果給上層調(diào)用者，而當(dāng)前的狀態(tài)仍然保留，以便迭代器下一次循環(huán)調(diào)用。這樣做的好處是在于節(jié)約硬件資源，在需要的時(shí)候才會執(zhí)行，并且每次只執(zhí)行一次。

def fib(max):
    a, b = 0, 1
    while max:
        r = b
        a, b = b, a + b
        max -= 1
        yield r

# using generator
for i in fib(5):
    print(i)

將會輸出前 5 個(gè) Fibonacci 數(shù)據(jù)1，1, 2, 3, 5

if 判斷

if 判斷

基本使用

與其他編程語言中的 if 語句一樣，使用方法如下

if condition:
    expressions

如果 condition 的值為 True,將會執(zhí)行 expressions 語句的內(nèi)容，否則將跳過該語句往下執(zhí)行。

實(shí)例

x = 1
y = 2
z = 3
if x < y:
    print('x is less than y')

上述代碼中，if 語句的條件為 x < y 為 True, 那么將執(zhí)行條件內(nèi)部語句，程序?qū)⑤敵?x is less than y。 當(dāng)我們將代碼修改為一下

if x < y < z:
    print('x is less than y, and y is less than z')

在這里的條件變成了 x < y < z, 其相當(dāng)于 x < y and y < z, 如果 and 兩邊的條件都為 True 那么才會返回 True。 注意這個(gè)用法是 python 語言特有，不鼓勵 大家寫出這樣的代碼，以便其他語言的程序員能夠看懂你的代碼。

注意點(diǎn)

在 python 語言中等號的判斷使用 == 而不是 =, 因?yàn)楹笠环N是賦值語句。

x = 1
y = 2
z = 3
if x = y:
    print('x is equal to y')

如果這樣寫的話，是有句法錯(cuò)誤的，程序?qū)o法執(zhí)行。當(dāng)然如果是從 C/C++ 語言轉(zhuǎn)過來的同學(xué)，剛才那一句是非常熟悉的，也是我們經(jīng)常錯(cuò)誤的來源。

修改如下

x = 2
y = 2
z = 0
if x == y:
    print('x is equal to y')

因?yàn)?x 和 y 都等于2, 所以將會輸出 x is equal to y。

if else 判斷

基本使用

if condition:
    true_expressions
else:
    false_expressions

當(dāng) if 判斷條件為 True,執(zhí)行 true_expressions 語句; 如果為 False，將執(zhí)行 else 的內(nèi)部的 false_expressions。

實(shí)例

x = 1
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal to y')

在這個(gè)例子中，因?yàn)?x > y 將會返回 False, 那么將執(zhí)行 else 的分支內(nèi)容。輸出 x is less or equal to y

x = 4
y = 2
z = 3
if x > y:
    print('x is greater than y')
else:
    print('x is less or equal y')

在這里，因?yàn)?condition 條件為 True, 那么將會輸出 x is greater than y。

高級主題

對于從其他編程語言轉(zhuǎn)過來的同學(xué)一定非常想知道 python 語言中的三目操作符怎么使用，很遺憾的是 python 中并沒有類似 condition ? value1 : value2 三目操作符。然后現(xiàn)實(shí)中很多情況下我們只需要簡單的判斷 來確定返回值，但是冗長的 if-else 語句似乎與簡單的 python 哲學(xué)不一致。別擔(dān)心，python 可以通過 if-else 的行內(nèi)表達(dá)式完成類似的功能。

var = var1 if condition else var2

可以這么理解上面這段語句，如果 condition 的值為 True, 那么將 var1 的值賦給 var;如果為 False 則將 var2 的值賦給 var。

worked = True
result = 'done' if worked else 'not yet'
print(result)

首先判斷如果 work 為 True,那么將 done 字符串賦給 result，否則將 not yet 賦給 result。 結(jié)果將輸出 done。

if elif else 判斷

基本使用

if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

如果有多個(gè)判斷條件，那可以通過 elif 語句添加多個(gè)判斷條件，一旦某個(gè)條件為 True，那么將執(zhí)行對應(yīng)的 expression。 并在之代碼執(zhí)行完畢后跳出該 if-elif-else 語句塊，往下執(zhí)行。

實(shí)例

x = 4
y = 2
z = 3
if x > 1:
    print ('x > 1')
elif x < 1:
    print('x < 1')
else:
    print('x = 1')
print('finish')

因?yàn)?x = 4 那么滿足 if 的條件，則將輸出 x > 1 并且跳出整個(gè) if-elif-else 語句塊，那么緊接著輸出 finish。 如果將 x = -2 那么將滿足 elif x < 1 這個(gè)條件，將輸出 x <1, finish。

定義功能

def 函數(shù)

如果我們用代碼實(shí)現(xiàn)了一個(gè)小功能，但想要在程序代碼中重復(fù)使用，不能在代碼中到處粘貼這些代碼，因?yàn)檫@樣做違反 了軟件工程中 DRY原則。 Python 提供了 函數(shù)功能，可以將我們這部分功能抽象成一個(gè)函數(shù)以方便程序調(diào)用，或者提供給其他模塊使用。

基本使用

def function_name(parameters):
    expressions

Python 使用 def 開始函數(shù)定義，緊接著是函數(shù)名，括號內(nèi)部為函數(shù)的參數(shù)，內(nèi)部為函數(shù)的 具體功能實(shí)現(xiàn)代碼，如果想要函數(shù)有返回值, 在 expressions 中的邏輯代碼中用 return 返回。

實(shí)例

def function():
    print('This is a function')
    a = 1+2
    print(a)

上面我們定義了一個(gè)名字為 function的函數(shù)，函數(shù)沒有接收參數(shù)，所以括號內(nèi)部為空，緊接著就是 函數(shù)的功能代碼。如果執(zhí)行該腳本，發(fā)現(xiàn)并沒有輸出任何輸出，因?yàn)槲覀冎欢x了函數(shù)，而并沒有執(zhí)行函數(shù)。 這時(shí)我們在 Python 命令提示符中輸入函數(shù)調(diào)用 function(), 注意這里調(diào)用函數(shù)的括號不能省略。那么 函數(shù)內(nèi)部的功能代碼將會執(zhí)行，輸出結(jié)果：

This is a function
3

如果我們想要在腳本中調(diào)用的腳本，只需要在腳本中最后添加函數(shù)調(diào)用語句

function()

那么在執(zhí)行腳本的時(shí)候，將會執(zhí)行函數(shù)。

函數(shù)參數(shù)

我們在使用的調(diào)用函數(shù)的時(shí)候，想要指定一些變量的值在函數(shù)中使用，那么這些變量就是函數(shù)的參數(shù)，函數(shù)調(diào)用的時(shí)候， 傳入即可。

基本使用

def function_name(parameters):
    expressions

parameters 的位置就是函數(shù)的參數(shù)，在調(diào)用的時(shí)候傳入即可。

實(shí)例

def func(a, b):
    c = a+b
    print('the c is ', c)

在這里定義的一個(gè)函數(shù)，其參數(shù)就是兩個(gè)數(shù)值，函數(shù)的功能就是把兩個(gè)參數(shù)加起來。運(yùn)行腳本后，在 Python 提示符內(nèi)調(diào)用函數(shù) func, 如果不指定參數(shù) func(), 那么將會出錯(cuò); 輸出 func(1, 2)，將 a=1, b=2 傳入函數(shù)，輸出 the c is 3 。所以在調(diào)用函數(shù)時(shí)候，參數(shù)個(gè)數(shù)和位置一定要按照函數(shù)定義。如果我們忘記了函數(shù)的參數(shù)的位置，只知道各個(gè)參數(shù)的名字，可以在 函數(shù)調(diào)用的過程中給指明特定的參數(shù) func(a=1, b=2), 這樣的話，參數(shù)的位置將不受影響，所以 func(b=2,a=1)是同樣的 的效果。

函數(shù)默認(rèn)參數(shù)

我們在定義函數(shù)時(shí)有時(shí)候有些參數(shù)在大部分情況下是相同的，只不過為了提高函數(shù)的適用性，提供了一些備選的參數(shù)， 為了方便函數(shù)調(diào)用，我們可以將這些參數(shù)設(shè)置為默認(rèn)參數(shù)，那么該參數(shù)在函數(shù)調(diào)用過程中可以不需要明確給出。

基本使用

def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):
    expressions

函數(shù)聲明只需要在需要默認(rèn)參數(shù)的地方用 = 號給定即可, 但是要注意所有的默認(rèn)參數(shù)都不能出現(xiàn)在非默認(rèn)參數(shù)的前面。

實(shí)例

def sale_car(price, color='red', brand='carmy', is_second_hand=True):
    print('price', price,
          'color', color,
          'brand', brand,
          'is_second_hand', is_second_hand,)

在這里定義了一個(gè) sale_car 函數(shù)，參數(shù)為車的屬性，但除了 price 之外，像 color, brand 和 is_second_hand 都是有默認(rèn)值的，如果我們調(diào)用函數(shù) sale_car(1000), 那么與 sale_car(1000, 'red', 'carmy', True) 是一樣的效果。當(dāng)然也可以在函數(shù)調(diào)用過程中傳入特定的參數(shù)用來修改默認(rèn)參數(shù)。通過默認(rèn)參數(shù)可以減輕我們函數(shù)調(diào)用的復(fù)雜度。

進(jìn)階

3.1 自調(diào)用

如果想要在執(zhí)行腳本的時(shí)候執(zhí)行一些代碼，比如單元測試，可以在腳本最后加上單元測試 代碼，但是該腳本作為一個(gè)模塊對外提供功能的時(shí)候單元測試代碼也會執(zhí)行，這些往往我們不想要的，我們可以把這些代碼放入腳本最后：

if __name__ == '__main__':
    #code_here

如果執(zhí)行該腳本的時(shí)候，該 if 判斷語句將會是 True,那么內(nèi)部的代碼將會執(zhí)行。 如果外部調(diào)用該腳本，if 判斷語句則為 False,內(nèi)部代碼將不會執(zhí)行。

3.2 可變參數(shù)

顧名思義，函數(shù)的可變參數(shù)是傳入的參數(shù)可以變化的，1個(gè)，2個(gè)到任意個(gè)。當(dāng)然可以將這些 參數(shù)封裝成一個(gè) list 或者 tuple 傳入，但不夠 pythonic。使用可變參數(shù)可以很好解決該問題，注意可變參數(shù)在函數(shù)定義不能出現(xiàn)在特定參數(shù)和默認(rèn)參數(shù)前面，因?yàn)榭勺儏?shù)會吞噬掉這些參數(shù)。

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    print(name, 'total grade is ', total_grade)

定義了一個(gè)函數(shù)，傳入一個(gè)參數(shù)為 name, 后面的參數(shù) *grades 使用了 * 修飾，表明該參數(shù)是一個(gè)可變參數(shù)，這是一個(gè)可迭代的對象。該函數(shù)輸入姓名和各科的成績，輸出姓名和總共成績。所以可以這樣調(diào)用函數(shù) report('Mike', 8, 9)，輸出的結(jié)果為 Mike total grade is 17, 也可以這樣調(diào)用 report('Mike', 8, 9, 10)，輸出的結(jié)果為 Mike total grade is 27

3.3 關(guān)鍵字參數(shù)

關(guān)鍵字參數(shù)可以傳入0個(gè)或者任意個(gè)含參數(shù)名的參數(shù)，這些參數(shù)名在函數(shù)定義中并沒有出現(xiàn)，這些參數(shù)在函數(shù)內(nèi)部自動封裝成一個(gè)字典(dict).

def portrait(name, **kw):
    print('name is', name)
    for k,v in kw.items():
        print(k, v)

定義了一個(gè)函數(shù)，傳入一個(gè)參數(shù) name, 和關(guān)鍵字參數(shù) kw，使用了 ** 修飾。表明該參數(shù)是關(guān)鍵字參數(shù)，通常來講關(guān)鍵字參數(shù)是放在函數(shù)參數(shù)列表的最后。如果調(diào)用參數(shù) portrait('Mike', age=24, country='China', education='bachelor') 輸出:

name is Mike
age 24
country China
education bachelor

通過可變參數(shù)和關(guān)鍵字參數(shù)，任何函數(shù)都可以用 universal_func(*args, **kw) 表達(dá)。

變量形式

局部變量

在 def 中, 我們可以定義一個(gè)局部變量, 這個(gè)變量a只能在這個(gè)功能 fun中有效, 出了這個(gè)功能, a這個(gè)變量就不是那個(gè)局部的a.

def fun():
    a = 10
    print(a)
    return a+100

print(fun())

"""
10
110
"""

下面這個(gè)例子就驗(yàn)證了如果在 fun 外面調(diào)用 a, 會報(bào)錯(cuò), 這表明外面的這個(gè) print(a)不能找到那個(gè)局部的 a, 只有全局變量再能在外面被調(diào)用, 比如 APPLE.全局變量一般大寫

APPLY = 100 # 全局變量
def fun():
    a = 10  # 局部變量
    return a+100

print(APPLE)    # 100
print(a)    # 報(bào)錯(cuò), 不能拿到一個(gè)局部變量的值

全局變量

那如何在外部也能調(diào)用一個(gè)在局部里修改了的全局變量呢. 首先我們在外部定義一個(gè)全局變量 a=None, 然后再fun()中聲明 這個(gè)a是來自外部的 a. 聲明方式就是 global a. 然后對這個(gè)外部的 a修改后, 修改的效果會被施加到外部的 a 上. 所以我們將能看到運(yùn)行完 fun(), a 的值從 None 變成了 20.

APPLE = 100 # 全局變量
a = None
def fun():
    global a    # 使用之前在全局里定義的 a
    a = 20      # 現(xiàn)在的 a 是全局變量了
    return a+100

print(APPLE)    # 100
print('a past:', a)  # None
print(fun()) #120
print('a now:', a)   # 20

模塊安裝

安裝外部的模塊有很多種方式, 不同的系統(tǒng)安裝形式也不同. 比如在 Windows 上安裝 Python 的一些包, 可能還會要了你的老命. 哈哈.

什么是外部模塊

外部模塊就是在你 import 什么東西去python 腳本的時(shí)候會用到的.

import numpy as np
import matplotlib.pyplot as plt

這里的 Numpy 和 matplotlib 都是外部模塊, 需要安裝以后才會有的. 他不屬于 python 自帶的模塊.

安裝 Numpy

這里我們舉例說明, 對于一些科學(xué)運(yùn)算的模塊, 比如 numpy, 他的安裝方式就有很多。 在 Windows 上, 最簡單的方式就安裝 Anaconda 這種平臺, 他會自帶很多必要的外部模塊. 安裝一個(gè), 省去安裝其它的煩惱。
不過我這里要講的是下載安裝包的方式在 Windows 安裝. 比如 在 Numpy 安裝包的網(wǎng)站中, 你能找到 numpy 的各種版本的安裝包。
在 NumPy 1.10.2 這個(gè)版本中, 我們能找到適合 Windows 的安裝包, 新版中目前還沒添加 Windows 的安裝包. 然后根據(jù)你的系統(tǒng)和 python 版本選擇合適的 “exe” 安裝包.。下載安裝。
如果你是 MacOS 或者 Linux, 這種外部模塊, 安裝起來就方便多了。在你的電腦 Terminal 上輸入一句話, 就能輕松安裝.。Windows 好像要經(jīng)過特殊設(shè)置才能實(shí)現(xiàn)一樣的功能, 具體忘記了… 你可能要查一下. 在我電腦中, Terminal 長這樣。

然后只要你在里面輸入這種形式就可以安裝了.

$ pip install 你要的模塊名

比如

$ pip install numpy   # 這是 python2+ 版本的用法
$ pip3 install numpy   # 這是 python3+ 版本的用法

更新外部模塊

使用 pip 更新外部模塊會十分簡單. 主需要在 Terminal 中輸入下面的指令就行. 這里的 -U 就是 update 意思.

$ pip install -U numpy   # 這是 python2+ 版本的用法
$ pip3 install -U numpy   # 這是 python3+ 版本的用法

pycharm 模塊安裝與更新

File->Settings->Project Interpreter

pycharm安裝模塊

文件讀取

\n 換行命令

定義 text為字符串, 并查看使用 \n和不適用\n的區(qū)別:

text='This is my first test. This is the second line. This the third '
print(text)  # 無換行命令

"""
This is my first test. This is the second line. This the third
"""

text='This is my first test.\nThis is the second line.\nThis the third line'
print(text)   # 輸入換行命令\n，要注意斜桿的方向。注意換行的格式和c++一樣

"""
This is my first test.
This is the second line.
This the third line
"""

open 讀文件方式

使用open 能夠打開一個(gè)文件,open 的第一個(gè)參數(shù)為文件名和路徑 ‘my file.txt’, 第二個(gè)參數(shù)為將要以什么方式打開它, 比如 w為可寫方式. 如果計(jì)算機(jī)沒有找到 ‘my file.txt’ 這個(gè)文件, w方式能夠創(chuàng)建一個(gè)新的文件, 并命名為 my file.txt
完整的語法格式為：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

參數(shù)說明:
file: 必需，文件路徑（相對或者絕對路徑）。
mode: 可選，文件打開模式
buffering: 設(shè)置緩沖
encoding: 一般使用utf8
errors: 報(bào)錯(cuò)級別
newline: 區(qū)分換行符
closefd: 傳入的file參數(shù)類型
opener:

file

my_file=open('my file.txt','w')   #用法: open('文件名','形式'), 其中形式有'w':write;'r':read.
my_file.write(text)               #該語句會寫入先前定義好的 text
my_file.close()                   #關(guān)閉文件

open一個(gè)同py文件同一個(gè)目錄的文件的時(shí)候，用以下：

txt = open('filtered_words.txt','rb')

也可利用絕對路徑

txt = open('E:\\python_project\\test\github\\filtered_words.txt','rb')

用反斜杠

txt = open('E:/python_project/test/github/filtered_words.txt','rb')

mode

t 文本模式 (默認(rèn))。
x 寫模式，新建一個(gè)文件，如果該文件已存在則會報(bào)錯(cuò)。
b 二進(jìn)制模式。
+ 打開一個(gè)文件進(jìn)行更新(可讀可寫)。
U 通用換行模式（不推薦）。
r 以只讀方式打開文件（帶r的文件必須先存在）。文件的指針將會放在文件的開頭。這是默認(rèn)模式。
r+ 可讀可寫,不會創(chuàng)建不存在的文件。如果直接寫文件，則從頂部開始寫，覆蓋之前此位置的內(nèi)容，如果先讀后寫，則會在文件最后追加內(nèi)容。

(每當(dāng)你open一個(gè)文件的時(shí)候，都會產(chǎn)生一個(gè)文件"指針",這個(gè)指針會隨你的讀寫操作而向后移動。初始這個(gè)指針是指向文件內(nèi)容的起始位置，當(dāng)你運(yùn)行指令f.read（）時(shí)，它會讀取文件的所有內(nèi)容，并將指針從文件起始位置一直移到文件末尾。當(dāng)你運(yùn)行指令f.write("你好")前，這個(gè)指針是指向當(dāng)前文件末尾，所以會將“你好”添加在文件末尾，此時(shí)指針又移動到“你好”的后面，此時(shí)你又輸入“世界”，則在指針指向的文件當(dāng)前位置寫入“世界”，此時(shí)指針又移動到“世界”的后面。此時(shí)，你又運(yùn)行f.read(),由于此時(shí)指針指向的是當(dāng)前文件的末尾，即指向“世界”的后面，而“世界”后面當(dāng)然什么內(nèi)容都沒了，故你什么都讀取不了，空白)

w+ 可讀可寫 如果文件存在 則覆蓋整個(gè)文件不存在則創(chuàng)建 //要close 之后才算完成寫入
w 只能寫 覆蓋整個(gè)文件 不存在則創(chuàng)建
a 只能寫 從文件底部添加內(nèi)容 不存在則創(chuàng)建
a+ 可讀可寫 從文件頂部讀取內(nèi)容 從文件底部添加內(nèi)容 不存在則創(chuàng)建

encoding 編碼方式

1.win系統(tǒng)默認(rèn)是gbk編碼的，所以桌面生成的TXT之類的都是gbk編碼的。
2.出現(xiàn)亂碼正常都是原文件的編碼方式和打開指定的編碼不一致所致

\t tab 對齊

使用 \t 能夠添加一個(gè)tab間隔：

text='\tThis is my first test.\nThis is the \tsecond line.\n\t\tThis is the third line'
print(text) 
"""
    This is my first test.
This is the     second line.
        This is the third line

"""

給文件增加內(nèi)容

我們先保存一個(gè)已經(jīng)有3行文字的 “my file.txt” 文件, 文件的內(nèi)容如下:

This is my first test. 
This is the second line.
This the third

然后使用添加文字的方式給這個(gè)文件添加一行 “This is appended file.”, 并將這行文字儲存在 append_file 里，注意\n的適用性:

append_text='\nThis is appended file.'  # 為這行文字提前空行 "\n"
my_file=open('my file.txt','a')   # 'a'=append 以增加內(nèi)容的形式打開
my_file.write(append_text)
my_file.close()
""""
This is my first test.
This is the second line.
This the third line.
This is appended file.
""""
#運(yùn)行后再去打開文件，會發(fā)現(xiàn)會增加一行代碼中定義的字符串

總結(jié)

掌握 append 的用法 ：open('my file.txt','a') 打開類型為 a ，a 即表示 append

讀取文件內(nèi)容 file.read()

使用 file.read() 能夠讀取到文本的所有內(nèi)容.

file= open('my file.txt','r') 
content=file.read()  
print(content)

""""
This is my first test.
This is the second line.
This the third line.
This is appended file.    
""""

按行讀取 file.readline()

如果想在文本中一行行的讀取文本,帶換行符, 可以使用 file.readline(), file.readline() 讀取的內(nèi)容和你使用的次數(shù)有關(guān), 使用第二次的時(shí)候, 讀取到的是文本的第二行, 并可以以此類推:

file= open('my file.txt','r') 
content=file.readline()  # 讀取第一行
print(content)
""""
This is my first test.
""""
second_read_time=file.readline()  # 讀取第二行
print(second_read_time)
"""
This is the second line.
"""

讀取所有行 file.readlines()

如果想要讀取所有行, 并可以使用像 for 一樣的迭代器迭代這些行結(jié)果, 我們可以使用 file.readlines(), 將每一行的結(jié)果存儲在 list 中, 方便以后迭代，注意換行符是包含在字符串的內(nèi)容中。

file= open('my file.txt','r') 
content=file.readlines() # python_list 形式
print(content)
""""
['This is my first test.\n', 'This is the second line.\n', 'This the third line.\n', 'This is appended file.']
""""
# 之后如果使用 for 來迭代輸出:
for item in content:
    print(item)   
"""
This is my first test.
This is the second line.
This the third line.
This is appended file.
"""

去除換行符\n

使用strip()函數(shù)去掉每行結(jié)束的\n

for line in file.readlines():
    line=line.strip('\n')

strip()函數(shù)原型

聲明：s為字符串，rm為要刪除的字符序列

s.strip(rm) 刪除s字符串中開頭、結(jié)尾處，位于 rm刪除序列的字符

s.lstrip(rm) 刪除s字符串中開頭處，位于 rm刪除序列的字符

s.rstrip(rm) 刪除s字符串中結(jié)尾處，位于 rm刪除序列的字符

注意：當(dāng)rm為空時(shí)，默認(rèn)刪除空白符（包括'\n', '\r', '\t', ' ')

class 類

class 類

class 定義一個(gè)類

class 定義一個(gè)類,類似于定義一個(gè)函數(shù), 后面的類別首字母推薦以大寫的形式定義，比如Calculator. class可以先定義自己的屬性，比如該屬性的名稱可以寫為 name='Good Calculator'. class后面還可以跟def, 定義一個(gè)函數(shù). 比如def add(self,x,y): 加法, 輸出print(x+y). 其他的函數(shù)定義方法一樣，注意這里的self 是默認(rèn)值.

class Calculator:       #首字母要大寫，冒號不能缺
    name='Good Calculator'  #該行為class的屬性
    price=18
    def add(self,x,y):
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(result)
    def times(self,x,y):
        print(x*y)
    def divide(self,x,y):
        print(x/y)

""""
>>> cal=Calculator()  #注意這里運(yùn)行class的時(shí)候要加"()",否則調(diào)用下面函數(shù)的時(shí)候會出現(xiàn)錯(cuò)誤,導(dǎo)致無法調(diào)用.
>>> cal.name
'Good Calculator'
>>> cal.price
18
>>> cal.add(10,20)
Good Calculator
30
>>> cal.minus(10,20)
-10
>>> cal.times(10,20)
200
>>> cal.divide(10,20)
0.5
>>>
""""

總結(jié)

注意定義自變量cal等于Calculator要加括號“()” ,cal=Calculator()否則運(yùn)行下面函數(shù)的時(shí)候會出現(xiàn)錯(cuò)誤,導(dǎo)致無法調(diào)用.

class 類 init 功能

init

init可以理解成初始化class的變量，取自英文中initial 最初的意思.可以在運(yùn)行時(shí)，給初始值附值，

運(yùn)行c=Calculator('bad calculator',18,17,16,15),然后調(diào)出每個(gè)初始值的值。看如下代碼。

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height,width,weight):   # 注意，這里的下劃線是雙下劃線
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight
""""
>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15
>>>
""""

如何設(shè)置屬性的默認(rèn)值, 直接在def里輸入即可，如下:

def __init__(self,name,price,height=10,width=14,weight=16):查看運(yùn)行結(jié)果， 三個(gè)有默認(rèn)值的屬性，可以直接輸出默認(rèn)值，這些默認(rèn)值可以在code中更改, 比如c.wi=17再輸出c.wi就會把wi屬性值更改為17.同理可推其他屬性的更改方法。

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height=10,width=14,weight=16): #后面三個(gè)屬性設(shè)置默認(rèn)值,查看運(yùn)行
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight

 """"
>>> c=Calculator('bad calculator',18)
>>> c.h
10
>>> c.wi
14
>>> c.we
16
>>> c.we=17
>>> c.we
17
""""

總結(jié)

def __init__(self,name,price,height,width,weight):注意，這里的下劃線是雙下劃線

input 輸入

input

variable=input()表示運(yùn)行后，可以在屏幕中輸入一個(gè)數(shù)字，該數(shù)字會賦值給自變量。看代碼：

a_input=input('please input a number:')
print('this number is:',a_input)
''''
please input a number:12 #12 是我在硬盤中輸入的數(shù)字
this number is: 12
''''

input()應(yīng)用在if語句中.
在下面代碼中，需要將input() 定義成整型，因?yàn)樵?code>if語句中自變量 a_input對應(yīng)的是1 and 2 整數(shù)型。輸入的內(nèi)容和判斷句中對應(yīng)的內(nèi)容格式應(yīng)該一致。
也可以將if語句中的1and2定義成字符串，其中區(qū)別請讀者自定寫入代碼查看。

a_input=int(input('please input a number:'))#注意這里要定義一個(gè)整數(shù)型
if a_input==1:
    print('This is a good one')
elif a_input==2:
    print('See you next time')
else:
    print('Good luck')
""""
please input a number:1   #input 1
This is a good one
please input a number:2   #input 2
See you next time
please input a number:3   #input 3 or other number
Good luck
""""

input擴(kuò)展

用input()來判斷成績

score=int(input('Please input your score: \n'))
if score>=90:
   print('Congradulation, you get an A')
elif score >=80:
    print('You get a B')
elif score >=70:
    print('You get a C')
elif score >=60:
    print('You get a D')
else:
    print('Sorry, You are failed ')

""""
Please input your score:
100   #手動輸入
Congradulation, you get an A
""""

元組、列表、字典

元組 列表

Tuple

叫做tuple，用小括號、或者無括號來表述，是一連串有順序的數(shù)字。

a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6

List

而list是以中括號來命名的:

a_list = [12, 3, 67, 7, 82]

兩者對比

他們的元素可以一個(gè)一個(gè)地被迭代、輸出、運(yùn)用、定位取值:

for content in a_list:
    print(content)
"""
12
3
67
7
82
"""

for content_tuple in a_tuple:
    print(content_tuple)
"""
12
3
5
15
6
"""

下一個(gè)例子，依次輸出a_tuple和a_list中的各個(gè)元素：

for index in range(len(a_list)):
    print("index = ", index, ", number in list = ", a_list[index])
"""
index =  0 , number in list =  12
index =  1 , number in list =  3
index =  2 , number in list =  67
index =  3 , number in list =  7
index =  4 , number in list =  82
"""

for index in range(len(a_tuple)):
    print("index = ", index, ", number in tuple = ", a_tuple[index])
"""
index =  0 , number in tuple =  12
index =  1 , number in tuple =  3
index =  2 , number in tuple =  5
index =  3 , number in tuple =  15
index =  4 , number in tuple =  6
"""

list 列表

List 添加

列表是一系列有序的數(shù)列，有一系列自帶的功能， 例如：

a = [1,2,3,4,1,1,-1]
a.append(0)  # 在a的最后面追加一個(gè)0
print(a)
# [1, 2, 3, 4, 1, 1, -1, 0]

在指定的地方添加項(xiàng)：

a = [1,2,3,4,1,1,-1]
a.insert(1,0) # 在位置1處添加0
print(a)
# [1, 0, 2, 3, 4, 1, 1, -1]

List 移除

刪除項(xiàng)：

a = [1,2,3,4,1,1,-1]
a.remove(2) # 刪除列表中第一個(gè)出現(xiàn)的值為2的項(xiàng)
print(a)
# [1, 3, 4, 1, 1, -1]

List 索引

顯示特定位：

a = [1,2,3,4,1,1,-1]
print(a[0])  # 顯示列表a的第0位的值
# 1

print(a[-1]) # 顯示列表a的最末位的值
# -1

print(a[0:3]) # 顯示列表a的從第0位 到 第2位(第3位之前) 的所有項(xiàng)的值
# [1, 2, 3]

print(a[5:])  # 顯示列表a的第5位及以后的所有項(xiàng)的值
# [1, -1]

print(a[-3:]) # 顯示列表a的倒數(shù)第3位及以后的所有項(xiàng)的值
# [1, 1, -1]

打印列表中的某個(gè)值的索引(index):

a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 顯示列表a中第一次出現(xiàn)的值為2的項(xiàng)的索引
# 1

統(tǒng)計(jì)列表中某值出現(xiàn)的次數(shù)：

a = [4,1,2,3,4,1,1,-1]
print(a.count(-1))
# 1

List 排序

對列表的項(xiàng)排序：

a = [4,1,2,3,4,1,1,-1]
a.sort() # 默認(rèn)從小到大排序
print(a)
# [-1, 1, 1, 1, 2, 3, 4, 4]

a.sort(reverse=True) # 從大到小排序
print(a)
# [4, 4, 3, 2, 1, 1, 1, -1]

元組的基本操作與列表相同，但元組本身是不可變的，不能隨意插入刪除元素，但可利用切片的方式對元組進(jìn)行拷貝，從而間接實(shí)現(xiàn)添加刪除元素

多維列表

創(chuàng)建二維列表

一個(gè)一維的List是線性的List，多維List是一個(gè)平面的List：

a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
               [2,3,4],
               [3,4,5]] # 三行三列

索引

在上面定義的List中進(jìn)行搜索：

print(a[1])
# 2

print(multi_dim_a[0][1])
# 2

用行數(shù)和列數(shù)來定位list中的值。這里用的是二維的列表，但可以有更多的維度。

dictionary 字典

創(chuàng)建字典

如果說List是有順序地輸出輸入的話，那么字典的存檔形式則是無需順序的， 我們來看一個(gè)例子：
在字典中，有key和 value兩種元素，每一個(gè)key對應(yīng)一個(gè)value, key是名字, value是內(nèi)容。數(shù)字和字符串都可以當(dāng)做key或者value， 在同一個(gè)字典中, 并不需要所有的key或value有相同的形式。 這樣說, List可以說是一種key為有序數(shù)列的字典。

a_list = [1,2,3,4,5,6,7,8]

d1 = {'apple':1, 'pear':2, 'orange':3}
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

print(d1['apple'])  # 1
print(a_list[0])    # 1

del d1['pear']
print(d1)   # {'orange': 3, 'apple': 1}

d1['b'] = 20
print(d1)   # {'orange': 3, 'b': 20, 'pear': 2, 'apple': 1}

字典存儲類型

以上的例子可以對列表中的元素進(jìn)行增減。在打印出整個(gè)列表時(shí)，可以發(fā)現(xiàn)各個(gè)元素并沒有按規(guī)律打印出來，進(jìn)一步驗(yàn)證了字典是一個(gè)無序的容器。

def func():
    return 0

d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
print(d4['pear'][3])    # a

字典還可以以更多樣的形式出現(xiàn)，例如字典的元素可以是一個(gè)List，或者再是一個(gè)列表，再或者是一個(gè)function。索引需要的項(xiàng)目時(shí)，只需要正確指定對應(yīng)的key就可以了。

模塊

import 模塊

import 的各種方法

import time 指 import time 模塊，這個(gè)模塊可以python自帶，也可以是自己安裝的，比如以后會用到numpy這些模塊,需要自己安裝。

import time
print(time.localtime())  #這樣就可以print 當(dāng)?shù)貢r(shí)間了
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

方法二：import time as ____下劃線縮寫部分可以自己定義，在代碼中把time定義成t.設(shè)置別名調(diào)用更簡潔

import time as t
print(t.localtime()) # 需要加t.前綴來引出功能
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=12, tm_sec=48, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

方法三：from time import time,localtime,只import自己想要的功能.

from time import time, localtime
print(localtime())
print(time())
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)

1482475298.709855
""""

方法四：from time import * 輸入模塊的所有功能

from time import *
print(localtime())
""""
time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=14, tm_min=41, tm_sec=38, tm_wday=4, tm_yday=358, tm_isdst=0)
""""

自建一個(gè)模塊

這里和視頻有點(diǎn)差別，我自己寫了另外一個(gè)模塊，是計(jì)算五年復(fù)利本息的模塊,代碼如下：模塊寫好后保存在默認(rèn)文件夾：balance.py

d=float(input('Please enter what is your initial balance: \n'))
p=float(input('Please input what is the interest rate (as a number): \n'))
d=float(d+d*(p/100))
year=1
while year<=5:
    d=float(d+d*p/100)
    print('Your new balance after year:',year,'is',d)
    year=year+1
print('your final year is',d)

調(diào)用自己的模塊
新開一個(gè)腳本，import balance

import balance

""""
Please enter what is your initial balance:
50000  # 手動輸入我的本金
Please input what is the interest rate (as a number):
2.3  #手動輸入我的銀行利息
Your new balance after year: 1 is 52326.45
Your new balance after year: 2 is 53529.95834999999
Your new balance after year: 3 is 54761.14739204999
Your new balance after year: 4 is 56020.653782067144
Your new balance after year: 5 is 57309.12881905469
your final year is 57309.12881905469
""""

模塊存儲路徑說明

在Mac系統(tǒng)中，下載的python模塊會被存儲到外部路徑site-packages，同樣，我們自己建的模塊也可以放到這個(gè)路徑，最后不會影響到自建模塊的調(diào)用。

class類、模塊、包關(guān)系

在這里插入圖片描述

• 類： 它將數(shù)據(jù)和操作進(jìn)行封裝，以便將來的復(fù)用。幾乎是最小的封裝單元了，方便更高的復(fù)用
• 模塊：在Python可理解為對應(yīng)于一個(gè)文件。在創(chuàng)建了一個(gè)腳本文件后，定義了某些函數(shù)和變量。你在其他需要這些功能的文件中，導(dǎo)入這模塊，就可重用這些函數(shù)和變量。
• 包：在創(chuàng)建許許多多模塊后，我們可能希望將某些功能相近的文件組織在同一文件夾下，這里就需要運(yùn)用包的概念了。包對應(yīng)于文件夾，使用包的方式跟模塊也類似，唯一需要注意的是，當(dāng)文件夾當(dāng)作包使用時(shí)，文件夾需要包含init.py文件，主要是為了避免將文件夾名當(dāng)作普通的字符串。init.py的內(nèi)容可以為空，一般用來進(jìn)行包的某些初始化工作或者設(shè)置all值，all是在from package-name import *這語句使用的，全部導(dǎo)出定義過的模塊。通常包總是一個(gè)目錄， 可以是對模塊的聚集，包裹在同一個(gè)文件夾內(nèi)。可以使用import導(dǎo)入包，或者from + import來導(dǎo)入包中的部分模塊。包目錄下為首的一個(gè)文件便是 init.py。然后是一些模塊文件和子目錄，假如子目錄中也有 init.py 那么它就是這個(gè)包的子包了。

其他

continue & break

True and False 跳出循環(huán)

當(dāng)輸入1時(shí)，a=False時(shí)，會執(zhí)行接下來的語句后再跳出這個(gè)循環(huán)。

a=True
while a:
    b= input('type somesthing')
    if b=='1':
        a= False
        print('still in a while')
    else:
        pass #什么都不做跳過
print ('finish run')

''''
type somesthing 2
type somesthing3
type somesthing1
still in a while #會執(zhí)行下面的語句再跳出
finish run
''''

break

break用法，在循環(huán)語句中，使用break, 當(dāng)符合跳出條件時(shí)，會直接結(jié)束循環(huán)，這是 break和 True False的區(qū)別。

while True:
    b= input('type somesthing:')
    if b=='1':
        break
    else:
        pass
    print('still in while')
print ('finish run')

"""
type somesthing:4
still in while
type somesthing:5
still in while
type somesthing:1
finish run
"""

continue

在代碼中，滿足b=1的條件時(shí)，因?yàn)槭褂昧?code>continue , python 不會執(zhí)行 else 后面的代碼，而會直接進(jìn)入下一次循環(huán)。

while True:
    b=input('input somesthing:')
    if b=='1':
       continue
    else:
        pass
    print('still in while' )

print ('finish run')
"""
input somesthing:3
still in while
input somesthing:1  # 沒有"still in while"。直接進(jìn)入下一次循環(huán)
input somesthing:4
still in while
input somesthing:
"""

總結(jié)

break直接跳出循環(huán)；
continue跳過后面的，從頭開始下一個(gè)循環(huán)’
flag(True->False)執(zhí)行完當(dāng)前一輪循環(huán)再退出

try 錯(cuò)誤處理

錯(cuò)誤處理

輸出錯(cuò)誤：try:, except ... as ...: 看如下代碼

try:
    file=open('eeee.txt','r')  #會報(bào)錯(cuò)的代碼
except Exception as e:  # 將報(bào)錯(cuò)存儲在 e 中
    print(e)
"""
[Errno 2] No such file or directory: 'eeee.txt'
"""

處理錯(cuò)誤：會使用到循環(huán)語句。首先報(bào)錯(cuò)：沒有這樣的文件No such file or directory. 然后決定是否輸入y, 輸入y以后，系統(tǒng)就會新建一個(gè)文件（要用寫入的類型），再次運(yùn)行后，文件中就會寫入ssss

try:
    file=open('eeee.txt','r+')
except Exception as e:
    print(e)
    response = input('do you want to create a new file:')
    if response=='y':
        file=open('eeee.txt','w')
    else:
        pass
else:
    file.write('ssss')
    file.close()
"""
[Errno 2] No such file or directory: 'eeee.txt'
do you want to create a new file:y

ssss  #eeee.txt中會寫入'ssss'

zip lambda map

zip

• zip()函數(shù)的定義
  從參數(shù)中的多個(gè)迭代器取元素組合成一個(gè)新的迭代器；
• 返回：返回一個(gè)zip對象，其內(nèi)部元素為元組；可以轉(zhuǎn)化為列表或元組；
• 傳入?yún)?shù)：元組、列表、字典等迭代器。
• 注意：zip(a,b)要求a與b的維數(shù)相同，當(dāng)兩者具有相同的行數(shù)與列數(shù)時(shí)，正常組合對應(yīng)位置元素即可；
  當(dāng)a與b的行數(shù)或列數(shù)不同時(shí)，取兩者結(jié)構(gòu)中最小的行數(shù)和列數(shù)，依照最小的行數(shù)和列數(shù)將對應(yīng)位置的元素進(jìn)行組合；這時(shí)相當(dāng)于調(diào)用itertools.zip_longest(*iterables)函數(shù)。

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)#當(dāng)zip()函數(shù)有兩個(gè)參數(shù)時(shí),zip()函數(shù)分別從a和b依次各取出一個(gè)元素組成元組，再將依次組成的元組組合成一個(gè)新的迭代器
aa=zip(a)#當(dāng)zip()函數(shù)中只有一個(gè)參數(shù)時(shí),從a中依次取一個(gè)元組，組成一個(gè)元組。
print(list(ab))
print(list(aa))  #需要加list來可視化這個(gè)功能
m = [[1,2,3], [4,5,6], [7,8,9]]
n = [[2,2,2], [3,3,3], [4,4,4]]
p = [[2,2,2], [3,3,3]]
print(list(zip(m,n)))
print(list(zip(m,p)))
"""
[(1, 4), (2, 5), (3, 6)]
[(1,), (2,), (3,)]
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3]), ([7, 8, 9], [4, 4, 4])]
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3])]
"""

zip 中的運(yùn)算

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))
for i,j in zip(a,b):
     print(i/2,j*2)
"""
0.5 8
1.0 10
1.5 12
"""

zip(*)函數(shù)

zip(*)函數(shù)是zip()函數(shù)的逆過程，將zip對象變成原先組合前的數(shù)據(jù)。

a = [1,2,3]
b = [4,5,6]
zipped =list(zip(a,b))   # 打包為元組的列表
print(zipped)
aa=zip(*zipped)
print(list(aa)) # 與 zip 相反，*zipped 可理解為解壓，返回二維矩陣式
"""
[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]
"""

lambda

• lambda表達(dá)式，通常是在需要一個(gè)函數(shù)，但是又不想費(fèi)神去命名一個(gè)函數(shù)的場合下使用，也就是指匿名函數(shù)。
• lambda所表示的匿名函數(shù)的內(nèi)容應(yīng)該是很簡單的，如果復(fù)雜的話，干脆就重新定義一個(gè)函數(shù)了，使用lambda就有點(diǎn)過于執(zhí)拗了。
• lambda就是用來定義一個(gè)匿名函數(shù)的，如果還要給他綁定一個(gè)名字的話，就會顯得有點(diǎn)畫蛇添足，通常是直接使用lambda函數(shù)。如下所示：

lambda x,y : x+y, 冒號前的x,y為自變量，冒號后x+y為具體運(yùn)算。

add = lambda x, y : x+y
print(add(1,2))  # 結(jié)果為3

1. 應(yīng)用在函數(shù)式編程中
   Python提供了很多函數(shù)式編程的特性，如：map、reduce、filter、sorted等這些函數(shù)都支持函數(shù)作為參數(shù)，lambda函數(shù)就可以應(yīng)用在函數(shù)式編程中。如下：
   ** 需求：將列表中的元素按照絕對值大小進(jìn)行升序排列 **

list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))

當(dāng)然，也可以如下：

list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):
    return abs(x)
sorted(list1,key=get_abs)

只不過這種方式的代碼看起來不夠Pythonic

2. 應(yīng)用在閉包中

def get_y(a,b):
     return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 結(jié)果為2

當(dāng)然，也可以用常規(guī)函數(shù)實(shí)現(xiàn)閉包，如下：

def get_y(a,b):
    def func(x):
        return ax+b
    return func
y1 = get_y(1,1)
y1(1) # 結(jié)果為2

只不過這種方式顯得有點(diǎn)啰嗦。

map

map接收一個(gè)函數(shù) f 和一個(gè) list，并通過把函數(shù) f 依次作用在 list 的每個(gè)元素上，得到一個(gè)新的 list 并返回。

def fun(x,y):
    return (x+y)
print(list(map(fun,[1],[2])))
print(list(map(fun,[1,2],[3,4])))
print(list(map(fun,[1,2],[3])))
"""
[3]
[4, 6]
[4]
"""

copy & deepcopy 淺復(fù)制 & 深復(fù)制

Python中，對象的賦值，拷貝（深/淺拷貝）之間是有差異的，如果使用的時(shí)候不注意，就可能產(chǎn)生意外的結(jié)果。

id

什么是id？一個(gè)對象的id值在CPython解釋器里就代表它在內(nèi)存中的`地址

>>> import copy
>>> a=[1,2,3]
>>> b=a
>>> id(a)
"""
4382960392
"""
>>> id(b)
"""
4382960392
"""
>>> id(a)==id(b)    #附值后，兩者的id相同，為true。
True
>>> b[0]=222222  #此時(shí)，改變b的第一個(gè)值，也會導(dǎo)致a值改變。
>>> print(a,b)
[222222, 2, 3] [222222, 2, 3] #a,b值同時(shí)改變

淺拷貝

當(dāng)使用淺拷貝時(shí)，python只是拷貝了最外圍的對象本身，內(nèi)部的元素都只是拷貝了一個(gè)引用而已。copy只復(fù)制父對象，而子對象是共用的，deepcopy完全復(fù)制所有的父對象與子對象

>>> import copy
>>> a=[1,2,3]
>>> c=copy.copy(a)  #拷貝了a的外圍對象本身,
>>> id(c)
4383658568
>>> print(id(a)==id(c))  #id 改變 為false
False
>>> c[1]=22222   #此時(shí)，我去改變c的第二個(gè)值時(shí)，a不會被改變。
>>> print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不變,c的第二個(gè)值變了，這就是copy和‘==’的不同

深拷貝

deepcopy對外圍和內(nèi)部元素都進(jìn)行了拷貝對象本身，而不是對象的引用。

#copy.copy()
>>> a=[1,2,[3,4]]  #第三個(gè)值為列表[3,4],即內(nèi)部元素
>>> d=copy.copy(a) #淺拷貝a中的[3，4]內(nèi)部元素的引用，非內(nèi)部元素對象的本身
>>> id(a)==id(d)
False
>>> id(a[2])==id(d[2])
True
>>> a[2][0]=3333  #改變a中內(nèi)部原屬列表中的第一個(gè)值
>>> d             #這時(shí)d中的列表元素也會被改變
[1, 2, [3333, 4]]
#copy.deepcopy()
>>> e=copy.deepcopy(a) #e為深拷貝了a
>>> a[2][0]=333 #改變a中內(nèi)部元素列表第一個(gè)的值
>>> e
[1, 2, [3333, 4]] #因?yàn)闀r(shí)深拷貝，這時(shí)e中內(nèi)部元素[]列表的值不會因?yàn)閍中的值改變而改變

threading 什么是多線程

多線程

多線程 Threading 是一種讓程序擁有分身效果. 能同時(shí)處理多件事情. 一般的程序只能從上到下一行行執(zhí)行代碼, 不過 多線程 (Threading) 就能打破這種限制. 讓你的程序鮮活起來.

multiprocessing 什么是多進(jìn)程

多進(jìn)程

我們在多線程 (Threading) 里提到過, 它是有劣勢的, GIL 讓它沒能更有效率的處理一些分?jǐn)偟娜蝿?wù). 而現(xiàn)在的電腦大部分配備了多核處理器, 多進(jìn)程 Multiprocessing 能讓電腦更有效率的分配任務(wù)給每一個(gè)處理器, 這種做法解決了多線程的弊端. 也能很好的提升效率.

什么是 tkinter 窗口

窗口視窗

Tkinter 是使用 python 進(jìn)行窗口視窗設(shè)計(jì)的模塊. 簡單的構(gòu)造, 多平臺, 多系統(tǒng)的兼容性, 能讓它成為讓你快速入門定制窗口文件的好助手. 它在 python 窗口視窗模塊中是一款簡單型的. 所以用來入門, 熟悉 窗口視窗的使用, 非常有必要.

pickle 保存數(shù)據(jù)

pickle 保存

pickle 是一個(gè) python 中, 壓縮/保存/提取 文件的模塊. 最一般的使用方式非常簡單. 比如下面就是壓縮并保存一個(gè)字典的方式. 字典和列表都是能被保存的.

import pickle
a_dict = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}
# pickle a variable to a file
file = open('pickle_example.pickle', 'wb')
pickle.dump(a_dict, file)
file.close()

wb 是以寫的形式打開 ‘pickle_example.pickle’ 這個(gè)文件, 然后 pickle.dump 你要保存的東西去這個(gè)打開的 file. 最后關(guān)閉 file 你就會發(fā)現(xiàn)你的文件目錄里多了一個(gè) ‘pickle_example.pickle’ 文件, 這就是那個(gè)字典了.

pickle 提取

提取的時(shí)候相對簡單點(diǎn), 同樣我們以讀的形式打開那個(gè)文件, 然后 load 進(jìn)一個(gè) python 的變量.

# reload a file to a variable 
#使用with避免忘記關(guān)file
with open('pickle_example.pickle', 'rb') as file:
    a_dict1 =pickle.load(file)
print(a_dict1)

set 找不同

set 基本

Set 最主要的功能就是尋找一個(gè)句子或者一個(gè) list 當(dāng)中不同的元素.

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
sentence = 'Welcome Back to This Tutorial'
print(set(char_list))
# {'b', 'd', 'a', 'c'}
print(set(sentence))
# {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'o', 'W', 'T', 'B', 'i', 'e', 'u', 'h', 'k'}
print(set(char_list+ list(sentence)))
# {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'd', 'o', 'W', 'T', 'B', 'i', 'e', 'k', 'h', 'u', 'b'}

添加元素

定義好一個(gè) set 之后我們還可以對其添加需要的元素, 使用 add 就能添加某個(gè)元素. 但是不是每一個(gè)東西都能添加, 比如一個(gè)列表.原本存在的元素不會被添加。

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)
print(type(unique_char))
unique_char.add('x')
#unique_char.add(['y', 'z']) this is wrong
print(type(unique_char))
print(char_list)
print(unique_char)
char_list.append('x')#list用append，set用add
print(char_list)
"""
<class 'set'>
<class 'set'>
['a', 'b', 'c', 'c', 'd', 'd', 'd']
{'x', 'b', 'a', 'd', 'c'}
['a', 'b', 'c', 'c', 'd', 'd', 'd', 'x']
"""

清除元素或 set

清除一個(gè)元素可以用 remove或者 discard, 而清除全部可以用 clear.

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
unique_char = set(char_list)
# unique_char.remove('x') 移除不存在的值會報(bào)錯(cuò)
print(unique_char.remove('a')) #直接打印返回的都是none，需要重新print這個(gè)set才能看到剩余值
print(unique_char)

unique_char.discard('x')#不報(bào)錯(cuò)，返回原有數(shù)據(jù)
print(unique_char)
unique_char.discard('d')
print(unique_char)
print(unique_char.discard('c'))#直接打印同樣返回none

unique_char.clear()#清除所有
print(unique_char)
"""
None
{'c', 'b', 'd'}
{'c', 'b', 'd'}
{'c', 'b'}
None
set()
"""

篩選操作 /對比 （交集&差集）

我們還能進(jìn)行一些篩選操作, 比如對比另一個(gè)東西, 看看原來的 set 里有沒有和他不同的 (difference). 或者對比另一個(gè)東西, 看看 set 里有沒有相同的 (intersection).

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
A= set(char_list)
print(A)
B={'a', 'e', 'i'}
print(B)
print(A.difference(B))#A-B
print(A.intersection(B))#A∩B
"""
{'b', 'c', 'd', 'a'}
{'e', 'i', 'a'}
{'b', 'c', 'd'}
{'a'}
"""