Python基礎教程-菜鳥教程學習筆記1

文章目錄

• • Python基礎教程-菜鳥教程學習筆記1
  • • 前言 Python 簡介
    • 1. 第一個Python程序
    • 2. Python 中文編碼
    • 3. 基本語法
    • • 1）Python 標識符：
      • 2）Python 保留字符
      • 3）行和縮進
      • 4）一條語句多行顯示
      • 5）Python引號
      • 6）Python注釋
      • 7）print輸出
      • 8）多個語句構(gòu)成代碼組
      • 9）Python書寫基本規(guī)范
    • 4. Python變量類型
    • • 1）變量賦值
      • 2）多個變量賦值
      • 3）標準數(shù)據(jù)類型
      • 4）Python 數(shù)字
      • 5）Python字符串
      • 6）Python列表
      • 7）Python元組
      • 8）Python字典
    • 5. Python運算符
    • • 1）Python算術(shù)運算符
      • 2）Python比較運算符
      • 3）Python賦值運算符
      • 4）Python位運算符
      • 5）Python邏輯運算符
      • 6）Python成員運算符
      • 7）Python身份運算符
      • **8）Python運算符優(yōu)先級**
    • 6. Python語句
    • • **1）條件語句**
      • **2）循環(huán)語句**
      • 3）循環(huán)控制語句
      • 3）循環(huán)控制語句

前言 Python 簡介

Python 是一個高層次的結(jié)合了解釋性、編譯性、互動性和面向?qū)ο蟮哪_本語言。

Python 的設計具有很強的可讀性，相比其他語言經(jīng)常使用英文關(guān)鍵字，其他語言的一些標點符號，它具有比其他語言更有特色語法結(jié)構(gòu)。

• Python 是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
• Python 是交互式語言： 這意味著，您可以在一個 Python 提示符 >>> 后直接執(zhí)行代碼。
• Python 是面向?qū)ο笳Z言: 這意味著Python支持面向?qū)ο蟮娘L格或代碼封裝在對象的編程技術(shù)。
• **Python 是初學者的語言：**Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)，從簡單的文字處理到 WWW 瀏覽器再到游戲。

1. 第一個Python程序

對于大多數(shù)程序語言，第一個入門編程代碼便是 “Hello World！”，以下代碼為使用 Python 輸出 “Hello World！”：

#!/usr/bin/pythonprint("Hello, World!")

關(guān)于腳本第一行的 #!/usr/bin/python 的解釋，相信很多不熟悉 Linux 系統(tǒng)的同學需要普及這個知識，腳本語言的第一行，只對 Linux/Unix 用戶適用，用來指定本腳本用什么解釋器來執(zhí)行。

有這句的，加上執(zhí)行權(quán)限后，可以直接用 ./ 執(zhí)行，不然會出錯，因為找不到 python 解釋器。

#!/usr/bin/python 是告訴操作系統(tǒng)執(zhí)行這個腳本的時候，調(diào)用 /usr/bin 下的 python 解釋器。

#!/usr/bin/env python 這種用法是為了防止操作系統(tǒng)用戶沒有將 python 裝在默認的 /usr/bin 路徑里。當系統(tǒng)看到這一行的時候，首先會到 env 設置里查找 python 的安裝路徑，再調(diào)用對應路徑下的解釋器程序完成操作。

#!/usr/bin/python 相當于寫死了 python 路徑。

#!/usr/bin/env python 會去環(huán)境設置尋找 python 目錄，可以增強代碼的可移植性，推薦這種寫法。

分成兩種情況：

（1）如果調(diào)用 python 腳本時，使用:

python script.py

#!/usr/bin/python 被忽略，等同于注釋

（2）如果調(diào)用python腳本時，使用:

./script.py

#!/usr/bin/python 指定解釋器的路徑

PS： shell 腳本中在第一行也有類似的聲明。

2. Python 中文編碼

Python 文件中如果未指定編碼，在執(zhí)行過程會出現(xiàn)報錯：

#!/usr/bin/pythonprint ("你好，世界")

Python中默認的編碼格式是 ASCII 格式，在沒修改編碼格式時無法正確打印漢字，所以在讀取中文時會報錯。

解決方法為只要在文件開頭加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 就行了

注意：****# coding=utf-8 的 = 號兩邊不要空格。

**注意：**Python3.X 源碼文件默認使用utf-8編碼，所以可以正常解析中文，無需指定 UTF-8 編碼。

**注意：**如果你使用編輯器，同時需要設置 py 文件存儲的格式為 UTF-8，否則會出現(xiàn)類似以下錯誤信息：

SyntaxError: (unicode error) ‘utf-8’ codec can’t decode byte 0xc4 in position 0: invalid continuation byte

Pycharm 設置步驟：

• 進入 file > Settings，在輸入框搜索 encoding。
• 找到 Editor > File encodings，將 IDE Encoding 和 Project Encoding 設置為utf-8。
• 或者pycharm 右下角也可以切換編碼。

3. 基本語法

1）Python 標識符：

在 Python 里，標識符由字母、數(shù)字、下劃線組成。

在 Python 中，所有標識符可以包括英文、數(shù)字以及下劃線(_)，但不能以數(shù)字開頭。

Python 中的標識符是區(qū)分大小寫的。

以下劃線開頭的標識符是有特殊意義的。以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用 from xxx import * 而導入。

以雙下劃線開頭的 __foo 代表類的私有成員，以雙下劃線開頭和結(jié)尾的 __foo__代表 Python 里特殊方法專用的標識，如 init() 代表類的構(gòu)造函數(shù)。

Python 可以同一行顯示多條語句，方法是用分號 ; 分開，如：

>>> print ('hello');print ('runoob'); hello runoob

2）Python 保留字符

下面的列表顯示了在Python中的保留字。這些保留字不能用作常數(shù)或變數(shù)，或任何其他標識符名稱。

所有 Python 的關(guān)鍵字只包含小寫字母。

andexecnot

assert 斷言	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

3）行和縮進

python 對格式要求非常嚴格，學習 Python 與其他語言最大的區(qū)別就是，Python 的代碼塊不使用大括號 {} 來控制類，函數(shù)以及其他邏輯判斷。python 最具特色的就是用縮進來寫模塊。

縮進的空白數(shù)量是可變的，但是所有代碼塊語句必須包含相同的縮進空白數(shù)量，這個必須嚴格執(zhí)行。

因此，在 Python 的代碼塊中必須使用相同數(shù)目的行首縮進空格數(shù)。

python的基本規(guī)范：python要求我們的代碼縮進是4個空格或者4的倍數(shù)；

**錯誤提示：**PEP 8: E111 indentation is not a multiple of four

4）一條語句多行顯示

Python語句中一般以新行作為語句的結(jié)束符。

但是我們可以使用**斜杠（ \）**將一行的語句分為多行顯示，如下所示：

total = item_one + \item_two + \item_three

語句中包含 [], {} 或 () 括號就不需要使用多行連接符。如下實例：

days = ['Monday', 'Tuesday', 'Wednesday','Thursday', 'Friday']

5）Python引號

Python 可以使用引號( ’ )、雙引號( " )、三引號( ‘’’ 或 “”" ) 來表示字符串，引號的開始與結(jié)束必須是相同類型的。

其中三引號可以由多行組成，編寫多行文本的快捷語法，常用于文檔字符串，在文件的特定地點，被當做注釋。

6）Python注釋

python中單行注釋采用 # 開頭。

python 中多行注釋使用三個單引號(’’’)或三個雙引號(""")。

7）print輸出

print 默認輸出換行，python3中，print 是一個函數(shù)，可以使用 print(x, end="") ，end="" 可使輸出不換行。

# 換行輸出 print("hello") print("world") print('---------') # 不換行輸出 print("hello", end="") print("world")print("hello", end=" ") print("world")

8）多個語句構(gòu)成代碼組

縮進相同的一組語句構(gòu)成一個代碼塊，我們稱之代碼組。

像if、while、def和class這樣的復合語句，首行以關(guān)鍵字開始，以冒號( : )結(jié)束，該行之后的一行或多行代碼構(gòu)成代碼組。

我們將首行及后面的代碼組稱為一個子句(clause)。

9）Python書寫基本規(guī)范

命名類：

• Class names should use CamelCase convention，類名稱需要使用駝峰命名

  當我們定義python類時，應該使用駝峰命名——CamelCase，即單詞組合中首字母需要大寫。

• Variable in function should be lowercase，函數(shù)中的變量需要使用小寫

• Shadows name ‘use_a’ from outer scope，外部作用域的重復命名

  出現(xiàn)這個提示，表示當前代碼不同作用域中重復使用了同樣的變量名。最常出現(xiàn)的情況就就是方法中的函數(shù)變量和__main__下面的變量出現(xiàn)重名。

排版類：

• PEP 8: W292 no newline at end of file，文件末尾沒有新的行：

  要求我們在代碼的最后在空出一行，一個回車加一行搞定

• PEP 8: E303 too many blank lines (2)，太多的空行：

• 函數(shù)之間，類之間一般要空2行

• 類方法之間一般空1行

• 函數(shù)/方法代碼內(nèi)部每行間隔不超過1行

• PEP 8: E501 line too long (166 > 150 characters)，單行代碼長度過長，這個長度可以在Pycharm中設置

• PEP 8: E111 indentation is not a multiple of four，代碼縮進不是4的倍數(shù)，要求代碼縮進是4個空格或者4的倍數(shù)

• PEP 8: E225 missing whitespace around operator，操作符前后未留空白

4. Python變量類型

1）變量賦值

Python 中的變量賦值不需要類型聲明，在使用變量前必須要賦值。

每個變量在內(nèi)存中創(chuàng)建，都包括變量的標識，名稱和數(shù)據(jù)這些信息。

每個變量在使用前都必須賦值，變量賦值以后該變量才會被創(chuàng)建。

等號 = 用來給變量賦值。

等號 = 運算符左邊是一個變量名，等號 = 運算符右邊是存儲在變量中的值。例如：

counter = 100 # 賦值整型變量 miles = 1000.0 # 浮點型 name = "John" # 字符串 print counter print miles print name

2）多個變量賦值

Python允許你同時為多個變量賦值。例如：

a = b = c = 1

也可以為多個對象指定多個變量。例如：

a, b, c = 1, 2, "john"

3）標準數(shù)據(jù)類型

Python 定義了一些標準類型，用于存儲各種類型的數(shù)據(jù)。

Python有五個標準的數(shù)據(jù)類型：

• Numbers（數(shù)字）
• String（字符串）
• List（列表）
• Tuple（元組）
• Dictionary（字典）

查看數(shù)據(jù)類型，python 的所有數(shù)據(jù)類型都是類,可以通過 type() 查看該變量的數(shù)據(jù)類型:

n = "runoob" print(type(n)) # 輸出結(jié)果 <class 'str'>

4）Python 數(shù)字

數(shù)字數(shù)據(jù)類型用于存儲數(shù)值。

數(shù)據(jù)類型是不允許改變的,這就意味著如果改變 Number 數(shù)據(jù)類型的值，將重新分配內(nèi)存空間。

當你指定一個值時，Number 對象就會被創(chuàng)建：

var1 = 1 var2 = 10

您也可以使用del語句刪除一些對象的引用。

del語句的語法是：

del var1[,var2[,var3[....,varN]]]

您可以通過使用del語句刪除單個或多個對象的引用。例如：

del var del var_a, var_b

Python支持四種不同的數(shù)字類型：

• int（有符號整型）
• long（長整型[也可以代表八進制和十六進制]）
• float（浮點型）
• complex（復數(shù)）

實例

一些數(shù)值類型的實例：

intlongfloatcomplex

10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3e+18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2E-12	4.53e-7j

• 長整型也可以使用小寫 l，但是還是建議您使用大寫 L，避免與數(shù)字 1 混淆。Python使用 L 來顯示長整型。
• Python 還支持復數(shù)，復數(shù)由實數(shù)部分和虛數(shù)部分構(gòu)成，可以用 a + bj,或者 complex(a,b) 表示， 復數(shù)的實部 a 和虛部 b 都是浮點型。

**注意：**long 類型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 類型數(shù)據(jù)溢出后會自動轉(zhuǎn)為long類型。在 Python3.X 版本中 long 類型被移除，使用 int 替代。

Python數(shù)學函數(shù)

函數(shù)返回值 ( 描述 )

abs(x)	返回數(shù)字的絕對值，如abs(-10) 返回 10
ceil(x)	返回數(shù)字的上入整數(shù)，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1，在Python3.x中不可用，用其他函數(shù)代替
exp(x)	返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回數(shù)字的絕對值，如math.fabs(-10) 返回10.0
floor(x)	返回數(shù)字的下舍整數(shù)，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10為基數(shù)的x的對數(shù)，如math.log10(100)返回 2.0
max(x1, x2,…)	返回給定參數(shù)的最大值，參數(shù)可以為序列。
min(x1, x2,…)	返回給定參數(shù)的最小值，參數(shù)可以為序列。
modf(x)	返回x的整數(shù)部分與小數(shù)部分，兩部分的數(shù)值符號與x相同，整數(shù)部分以浮點型表示。
pow(x, y)	x**y 運算后的值。
round(x [,n])	返回浮點數(shù)x的四舍五入值，如給出n值，則代表舍入到小數(shù)點后的位數(shù)。
sqrt(x)	返回數(shù)字x的平方根

range()函數(shù)

>>> range(1,5) # 代表從1到5(不包含5) [1, 2, 3, 4] >>> range(1,5,2) # 代表從1到5，間隔2(不包含5) [1, 3] >>> range(5) # 代表從0到5(不包含5) [0, 1, 2, 3, 4]

注意：默認情況下，range() 的起始值是 0。

數(shù)字轉(zhuǎn)化為 對應ASCII：

ord('b') # convert char to int 98 chr(100) # convert int to char 'd'

abs() 和 fabs() 區(qū)別

• 1、abs()是一個內(nèi)置函數(shù)，而fabs()在math模塊中定義的。
• 2、fabs()函數(shù)只適用于float和integer類型，而 abs() 也適用于復數(shù)。

abs(-10) 10import math math.fabs(-10) 10.0

5）Python字符串

字符串或串(String)是由數(shù)字、字母、下劃線組成的一串字符。

python的字串列表有2種取值順序:

• 從左到右索引默認0開始的，最大范圍是字符串長度少1
• 從右到左索引默認-1開始的，最大范圍是字符串開頭

如果你要實現(xiàn)從字符串中獲取一段子字符串的話，可以使用 [頭下標:尾下標] 來截取相應的字符串，其中下標是從 0 開始算起，可以是正數(shù)或負數(shù)，下標可以為空表示取到頭或尾。

[頭下標:尾下標] 獲取的子字符串包含頭下標的字符，但不包含尾下標的字符。

s = 'abcdef' print(s[1:5]) # 輸出結(jié)果 'bcde'

加號（+）是字符串連接運算符，星號（*）是重復操作。如下實例：

str = 'Hello World!'print(str) # 輸出完整字符串 print(str[0]) # 輸出字符串中的第一個字符 print(str[2:5]) # 輸出字符串中第三個至第六個之間的字符串 print(str[2:]) # 輸出從第三個字符開始的字符串 print(str * 2) # 輸出字符串兩次 print(str + "TEST") # 輸出連接的字符串 # 實際輸出結(jié)果 Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST

Python 列表截取可以接收第三個參數(shù)，參數(shù)作用是截取的步長，以下實例在索引 1 到索引 4 的位置并設置為步長為 2（間隔一個位置）來截取字符串：

Python字符串運算符

下表實例變量 a 值為字符串 “Hello”，b 變量值為 “Python”：

操作符描述實例

+	字符串連接	>>>a + b ‘HelloPython’
*	重復輸出字符串	>>>a * 2 ‘HelloHello’
[]	通過索引獲取字符串中字符	>>>a[1] ‘e’
[ : ]	截取字符串中的一部分	>>>a[1:4] ‘ell’
in	成員運算符 - 如果字符串中包含給定的字符返回 True	>>>“H” in a True
not in	成員運算符 - 如果字符串中不包含給定的字符返回 True	>“M” not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思來使用， 沒有轉(zhuǎn)義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前 加上字母"r"（可以大小寫）以外，與普通字符串有著幾乎完全相同的語法。	>>>print r’\n’ \n >>> printR’\n’ \n
%	格式字符串	請看下一章節(jié)

Python 支持格式化字符串的輸出

print("My name is %s and weight is %d kg!" % ('Zara', 21))

轉(zhuǎn)義字符 \

print('Let\'s go!')

6）Python列表

列表的數(shù)據(jù)項不需要具有相同的類型，創(chuàng)建一個列表，只要把逗號分隔的不同的數(shù)據(jù)項使用方括號括起來即可。

訪問列表中的值使用下標索引來訪問列表中的值，同樣你也可以使用方括號的形式截取字符，如下所示：

list1 = ['physics', 'chemistry', 1997, 2000] list2 = [1, 2, 3, 4, 5, 6, 7 ] print "list1[0]: ", list1[0] print "list2[1:5]: ", list2[1:5] # 輸出結(jié)果： list1[0]: physics list2[1:5]: [2, 3, 4, 5]

更新列表對列表的數(shù)據(jù)項進行修改或更新，可以使用append()方法在列表尾部添加列表項，如下所示：

更新列表含義用法

append()	在列表尾部添加單個列表項	list.append(‘Google’)
extend()	在列表尾部添加多個列表項	list.extend([‘Google’, ‘Runoob’])
insert()	在某個位置添加列表項	list.insert(1, ‘Runoob’)

list = [] # 空列表 list.append('Google') # 使用 append() 添加元素 list.extend(['Rab', 'hat']) list.insert(1, 'tube') print(list) # 輸出結(jié)果： ['Google', 'tube', 'Rab', 'hat']

**刪除列表元素：**可以使用 del 語句來刪除列表的元素，如下實例：

list1 = ['physics', 'chemistry', 1997, 2000] print(list1) del list1[2] print "After deleting value at index 2 : " print(list1) # 輸出結(jié)果： ['physics', 'chemistry', 1997, 2000] After deleting value at index 2 : ['physics', 'chemistry', 2000]

remove 和 del 之間的區(qū)別：

remove不是一個函數(shù)，remove()方法刪除列表中值為 x 的第一個元素。如果沒有這樣的元素，會返回一個錯誤；

del語句按照索引位置刪除元素

pop()方法接受的是元素的下標，在原列表中彈出這個元素，并返回，當（）內(nèi)無索引數(shù)時默認彈出最后一個元素。

a = [1, 2, 3, 5, 4, 2, 6] a.remove(3) # 直接刪掉某個元素， del(a[3]) # del是一個函數(shù)，刪除帶下表的元素 number.pop() # 無索引彈出最后一個元素 number.pop(1) # 彈出索引為1的元素

Python列表腳本操作符

列表對 + 和 * 的操作符與字符串相似。+ 號用于組合列表，* 號用于重復列表。

如下所示：

Python 表達式結(jié)果描述

len([1, 2, 3])	3	長度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	組合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重復
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

---

Python列表截取

Python 的列表截取實例如下：

L = ['Google', 'Runoob', 'Taobao'] L[2] # 讀取列表中第三個元素 'Taobao' L[-2] # 讀取列表中倒數(shù)第二個元素 'Runoob' L[1:] # 從第二個元素開始截取列表 ['Runoob', 'Taobao']

7）Python元組

元組是另一個數(shù)據(jù)類型，類似于 List（列表）。

元組用 () 標識。內(nèi)部元素用逗號隔開。但是元組不能二次賦值，相當于只讀列表。

以下是元組無效的，因為元組是不允許更新的。而列表是允許更新的：

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) # 元組 list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] # 列表 tuple[2] = 1000 # 元組中是非法應用 list[2] = 1000 # 列表中是合法應用

元組的一級元素不可被修改增加刪除但可以修改二級后的。如修改元祖中列表，字典等內(nèi)容:

tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]) tu[1][2]["k2"].append("seven") print(tu[1][2]["k2"]) # 輸出結(jié)果 ['age', 'name', 'seven']

元組中只包含一個元素時，需要在元素后面添加逗號，否則被當做括號運算

tup1 = (50,)

元組與字符串類似，下標索引從0開始，可以進行截取，組合等。

tup1 = (12, 34.56) tup2 = ('abc', 'xyz')# 以下修改元組元素操作是非法的。 # tup1[0] = 100# 創(chuàng)建一個新的元組 tup3 = tup1 + tup2 print tup3 # 輸出結(jié)果 (12, 34.56, 'abc', 'xyz')

==注意：==切片雖然可以重新組成新的元組，但是要注意截取一個元素時候不能和新的元組相 ＋：

a=(1,2,3,4,5,6) c=a[1:4]+a[5] # 報錯, a[5] 被當成了整型c=a[1:4]+a[2:4] # 這樣可以 c (2, 3, 4, 3, 4) # 如果截取的是一個元素，則可以寫成： c=a[1:4]+a[5:] # a[5] 得到的是整型量 6, 而 a[5:] 得到的是新元組 (6,)，所以元組拼接時用 a[5] 會報錯

任意無符號的對象，以逗號隔開，默認為元組。

Python元組包含內(nèi)置函數(shù)：

序號方法及描述

1	cmp(tuple1, tuple2) 比較兩個元組元素。
2	len(tuple) 計算元組元素個數(shù)。
3	max(tuple) 返回元組中元素最大值。
4	min(tuple) 返回元組中元素最小值。
5	tuple(seq) 將列表轉(zhuǎn)換為元組。

8）Python字典

字典(dictionary)是除列表以外最靈活的內(nèi)置數(shù)據(jù)結(jié)構(gòu)類型。列表是有序的對象集合，字典是無序的對象集合。兩者之間的區(qū)別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

• 字典的每個鍵值 key=>value 對用冒號 : 分割，每個鍵值對之間用逗號分割，整個字典包括在花括號 {} 中 ,格式如下所示：

  d = {key1 : value1, key2 : value2 }

• 鍵一般是唯一的，如果重復最后的一個鍵值對會替換前面的，值不需要唯一。

• 值可以取任何數(shù)據(jù)類型，但鍵必須是不可變的，如字符串，數(shù)字或元組，可以混用，不能用列表[]表示。

dict = {} dict['one'] = "This is one" dict[2] = "This is two" tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'} print(dict['one'] ) # 輸出鍵為'one' 的值 print(dict[2]) # 輸出鍵為 2 的值 print(tinydict) # 輸出完整的字典 print(tinydict.keys()) # 輸出所有鍵 print(tinydict.values()) # 輸出所有值# 輸出結(jié)果為： This is one This is two {'dept': 'sales', 'code': 6734, 'name': 'runoob'} dict_keys(['name', 'code', 'dept']) dict_values(['runoob', 6734, 'sales'])

向字典添加新內(nèi)容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例:

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}dict['Age'] = 8 # 更新 dict['School'] = "RUNOOB" # 添加print "dict['Age']: ", dict['Age'] print "dict['School']: ", dict['School']dict.clear() # 刪除字典內(nèi)所有元素

字典的鍵可以使用布爾類型的，True 默認代表 1，False 默認代表 0，如果包含 0 或 1 就無法使用布爾類型：

# 包含 0 或 1 的情況下： test = {0:"1", 1:"2", True:"3", False:"4"} print(test) {0: '4', 1: '3'}# 沒有 0 或 1 的情況下： test = {"a":"1", "b" :"2", True:"3", False:"4"} print(test) {'a': '1', True: '3', 'b': '2', False: '4'}

訪問字典里的值的時候，如果直接用 [] 訪問，在沒有找到對應鍵的情況下會報錯，一個更好的替代方案是用內(nèi)置的 get 方法來取鍵值，這時候如果不存在也不會報錯。

test = {'key1':'value1','key2':'value2'} test['key3'] 報錯：KeyError:'key3' test.get('key3') 無輸出 test.get('key3','default') 輸出'default'

5. Python運算符

1）Python算術(shù)運算符

以下假設變量： a=10，b=20：

運算符描述實例

+	加 - 兩個對象相加	a + b 輸出結(jié)果 30
-	減 - 得到負數(shù)或是一個數(shù)減去另一個數(shù)	a - b 輸出結(jié)果 -10
*	乘 - 兩個數(shù)相乘或是返回一個被重復若干次的字符串	a * b 輸出結(jié)果 200
/	除 - x除以y	b / a 輸出結(jié)果 2，取整數(shù)
%	取模 - 返回除法的余數(shù)	b % a 輸出結(jié)果 0
**	冪 - 返回x的y次冪	a**b 為10的20次方， 輸出結(jié)果 100000000000000000000
//	取整除 - 返回商的整數(shù)部分（向下取整）	>>> 9//2=4 >>> -9//2=-5

2）Python比較運算符

以下假設變量a=10，變量b=20：

運算符描述實例

==	等于 - 比較對象是否相等	(a == b) 返回 False。
!=	不等于 - 比較兩個對象是否不相等	(a != b) 返回 true.
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

3）Python賦值運算符

以下假設變量a為10，變量b為20：

運算符描述實例

=	簡單的賦值運算符	c = a + b 將 a + b 的運算結(jié)果賦值為 c
+=	加法賦值運算符	c += a 等效于 c = c + a
-=	減法賦值運算符	c -= a 等效于 c = c - a
*=	乘法賦值運算符	c *= a 等效于 c = c * a
/=	除法賦值運算符	c /= a 等效于 c = c / a
%=	取模賦值運算符	c %= a 等效于 c = c % a
**=	冪賦值運算符	c **= a 等效于 c = c ** a
//=	取整除賦值運算符	c //= a 等效于 c = c // a

4）Python位運算符

按位運算符是把數(shù)字看作二進制來進行計算的。Python中的按位運算法則如下：

運算符描述實例

&	按位與運算符：參與運算的兩個值,如果兩個相應位都為1,則該位的結(jié)果為1,否則為0	(a & b) 輸出結(jié)果 12 ，二進制解釋： 0000 1100
|	按位或運算符：只要對應的二個二進位有一個為1時，結(jié)果位就為1。	(a | b) 輸出結(jié)果 61 ，二進制解釋： 0011 1101
^	按位異或運算符：當兩對應的二進位相異時，結(jié)果為1	(a ^ b) 輸出結(jié)果 49 ，二進制解釋： 0011 0001
~	按位取反運算符：對數(shù)據(jù)的每個二進制位取反,即把1變?yōu)?,把0變?yōu)? 。~x 類似于 -x-1	(~a ) 輸出結(jié)果 -61 ，二進制解釋： 1100 0011，在一個有符號二進制數(shù)的補碼形式。
<<	左移動運算符：運算數(shù)的各二進位全部左移若干位，由 << 右邊的數(shù)字指定了移動的位數(shù)，高位丟棄，低位補0。	a << 2 輸出結(jié)果 240 ，二進制解釋： 1111 0000
>>	右移動運算符：把">>"左邊的運算數(shù)的各二進位全部右移若干位，>> 右邊的數(shù)字指定了移動的位數(shù)	a >> 2 輸出結(jié)果 15 ，二進制解釋： 0000 1111

程序示例

a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0c = a & b # 12 = 0000 1100 print("1 - c 的值為：", c)c = a | b # 61 = 0011 1101 print("2 - c 的值為：", c)c = a ^ b # 49 = 0011 0001 print("3 - c 的值為：", c)c = ~a # -61 = 1100 0011 print("4 - c 的值為：", c)c = a << 2 # 240 = 1111 0000 print("5 - c 的值為：", c)c = a >> 2 # 15 = 0000 1111 print("6 - c 的值為：", c)

5）Python邏輯運算符

Python語言支持邏輯運算符，以下假設變量 a 為 10, b為 20:

運算符邏輯表達式描述實例

and	x and y	布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。	(a and b) 返回 20。
or	x or y	布爾"或" - 如果 x 是非 0，它返回 x 的計算值，否則它返回 y 的計算值。	(a or b) 返回 10。
not	not x	布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。	not(a and b) 返回 False

6）Python成員運算符

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

運算符描述實例

in	如果在指定的序列中找到值返回 True，否則返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中沒有找到值返回 True，否則返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

以下實例演示了Python所有成員運算符的操作：

a = 10 b = 20 list = [1, 2, 3, 4, 5 ];if a in list:print("1 - 變量 a 在給定的列表中 list 中") else:print("1 - 變量 a 不在給定的列表中 list 中")if b not in list:print("2 - 變量 b 不在給定的列表中 list 中") else:print("2 - 變量 b 在給定的列表中 list 中")

7）Python身份運算符

身份運算符用于比較兩個對象的存儲單元

運算符描述實例

is	is 是判斷兩個標識符是不是引用自一個對象	x is y, 類似 id(x) == id(y) , 如果引用的是同一個對象則返回 True，否則返回 False
is not	is not 是判斷兩個標識符是不是引用自不同對象	x is not y ， 類似 id(a) != id(b)。如果引用的不是同一個對象則返回結(jié)果 True，否則返回 False。

8）Python運算符優(yōu)先級

以下表格列出了從最高到最低優(yōu)先級的所有運算符：

運算符描述

**	指數(shù) (最高優(yōu)先級)
~ + -	按位翻轉(zhuǎn), 一元加號和減號 (最后兩個的方法名為 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法減法
>> <<	右移，左移運算符
&	位 ‘AND’
^ |	位運算符
<= < > >=	比較運算符
<> == !=	等于運算符
= %= /= //= -= += *= **=	賦值運算符
is， is not	身份運算符
in， not in	成員運算符
not， and， or	邏輯運算符

is 與 == 區(qū)別 ：

is 用于判斷兩個變量引用對象是否為同一個， == 用于判斷引用變量的值是否相等。

a is b 相當于 id(a)==id(b)，id() 能夠獲取對象的內(nèi)存地址。

如果 a=10;b=a; 則此時 a 和 b 的內(nèi)存地址一樣的;

但當 a=[1,2,3]; 另 b=a[:] 時，雖然 a 和 b 的值一樣，但內(nèi)存地址不一樣。

6. Python語句

1）條件語句

Python 編程中 if 語句用于控制程序的執(zhí)行，基本形式為：

if 判斷條件：執(zhí)行語句…… else：執(zhí)行語句……

if 語句的判斷條件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）來表示其關(guān)系。

當判斷條件為多個值時，可以使用以下形式：

if 判斷條件1:執(zhí)行語句1…… elif 判斷條件2:執(zhí)行語句2…… elif 判斷條件3:執(zhí)行語句3…… else:執(zhí)行語句4……

由于 python 并不支持 switch 語句，所以多個條件判斷，只能用 elif 來實現(xiàn)，如果判斷需要多個條件需同時判斷時，可以使用 or （或），表示兩個條件有一個成立時判斷條件成功；使用 and （與）時，表示只有兩個條件同時成立的情況下，判斷條件才成功。

當if有多個條件時可使用括號來區(qū)分判斷的先后順序，括號中的判斷優(yōu)先執(zhí)行，此外 and 和 or 的優(yōu)先級低于>（大于）、<（小于）等判斷符號，即大于和小于在沒有括號的情況下會比與或要優(yōu)先判斷。

**python 復合布爾表達式計算采用短路規(guī)則，即如果通過前面的部分已經(jīng)計算出整個表達式的值，則后面的部分不再計算。**如下面的代碼將正常執(zhí)行不會報除零錯誤：

a = 0 b = 1 if ( a > 0 ) and ( b / a > 2 ): # a>0條件已經(jīng)不滿足，不用再執(zhí)行b/a>2，所以不會報錯print("yes") else:print("no")

而下面的代碼就會報錯：

a = 0 b = 1 if ( a > 0 ) or ( b / a > 2 ):print("yes") else:print("no")

三元操作符：

small = x if x < y else y

2）循環(huán)語句

Python 提供了 for 循環(huán)和 while 循環(huán)（在 Python 中沒有 do…while 循環(huán)）:

循環(huán)類型描述

while 循環(huán)	在給定的判斷條件為 true 時執(zhí)行循環(huán)體，否則退出循環(huán)體。
for 循環(huán)	重復執(zhí)行語句
嵌套循環(huán)	你可以在while循環(huán)體中嵌套for循環(huán)

• while 循環(huán)語句

基本形式為：

while 判斷條件(condition)：執(zhí)行語句(statements)……循環(huán)體

Gif 演示 Python while 語句執(zhí)行過程：

復雜一點：

在 python 中，while … else 在循環(huán)條件為 false 時執(zhí)行 else 語句塊：

count = 0 while count < 5: print(count, " is less than 5") count = count + 1 else: print(count, " is not less than 5")

如果 while 循環(huán)體中只有一條語句，你可以將該語句與while寫在同一行中.

• for 循環(huán)語句

Python for循環(huán)可以遍歷任何序列的項目，如一個列表或者一個字符串。

for循環(huán)的語法格式如下：

for iterating_var in sequence:statements(s) for 目標 in 表達式：循環(huán)體

流程圖：

for letter in 'Python':print('當前字母：', letter) # 輸出結(jié)果 當前字母： P 當前字母： y 當前字母： t 當前字母： h 當前字母： o 當前字母： n

通過序列索引迭代：

fruits = ['banana', 'apple', 'mango'] for index in range(len(fruits)):print('當前水果:', fruits[index])

內(nèi)置函數(shù) len() 和 range()，函數(shù) len() 返回列表的長度，即元素的個數(shù)。

range返回一個序列的數(shù)，即(0,3)，不包括3。

for num in range(10, 20):for i in range(2, num):if num % i == 0:j = num / iprint('%d 等于 %d * %d' % (num, i, j))breakelse:print(num, '是一個質(zhì)數(shù)')

range()用法：不包括下標

range(4) # 打印0,1,2,3 （下標） range(1:5) # 打印1,2,3,4 （上標：下標） range(2:10:3) # 打印2,5,8 (上標：下標：步長)

• 循環(huán)嵌套

  Python 語言允許在一個循環(huán)體里面嵌入另一個循環(huán)。

  Python for 循環(huán)嵌套語法：

  for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)

  Python while 循環(huán)嵌套語法：

  while expression: while expression: statement(s) statement(s)

  你可以在循環(huán)體內(nèi)嵌入其他的循環(huán)體，如在while循環(huán)中可以嵌入for循環(huán)， 反之，你可以在for循環(huán)中嵌入while循環(huán)。

  實例：

  以下實例使用了嵌套循環(huán)輸出2~100之間的素數(shù)：素數(shù)：（質(zhì)數(shù)prime number）定義為在大于1的自然數(shù)中，除了1和它本身以外不再有其他因數(shù)。

  i = 2 while i < 100:j = 2while j <= i / j:if not(i % j):breakj = j + 1if j > i / j:print(i, "是素數(shù)")i = i + 1 print("Good bye!") # 冒泡排序，從最后一個數(shù)跟倒數(shù)第二個數(shù)比較大小，再重新排，最后輸出新的列表 array = [9, 2, 7, 4, 5, 6, 3, 8, 1, 10] L = len(array) for i in range(L):for j in range(L-i):if array[L-j-1] < array[L-j-2]:array[L-j-1], array[L-j-2] = array[L-j-2], array[L-j-1] for i in range(L):print(array[i])

3）循環(huán)控制語句

循環(huán)控制語句可以更改語句執(zhí)行的順序。Python支持以下循環(huán)控制語句：

控制語句描述

break 語句	在語句塊執(zhí)行過程中終止循環(huán)，并且跳出整個循環(huán)。
continue 語句	在語句塊執(zhí)行過程中終止當前循環(huán)，跳出該次循環(huán)，執(zhí)行下一次循環(huán)。
pass 語句	pass是空語句，是為了保持程序結(jié)構(gòu)的完整性。

f j > i / j:
print(i, “是素數(shù)”)
i = i + 1
print(“Good bye!”)

```python # 冒泡排序，從最后一個數(shù)跟倒數(shù)第二個數(shù)比較大小，再重新排，最后輸出新的列表 array = [9, 2, 7, 4, 5, 6, 3, 8, 1, 10] L = len(array) for i in range(L):for j in range(L-i):if array[L-j-1] < array[L-j-2]:array[L-j-1], array[L-j-2] = array[L-j-2], array[L-j-1] for i in range(L):print(array[i])

3）循環(huán)控制語句

循環(huán)控制語句可以更改語句執(zhí)行的順序。Python支持以下循環(huán)控制語句：

控制語句描述

break 語句	在語句塊執(zhí)行過程中終止循環(huán)，并且跳出整個循環(huán)。
continue 語句	在語句塊執(zhí)行過程中終止當前循環(huán)，跳出該次循環(huán)，執(zhí)行下一次循環(huán)。
pass 語句	pass是空語句，是為了保持程序結(jié)構(gòu)的完整性。

總結(jié)

以上是生活随笔為你收集整理的Python基础教程-菜鸟教程学习笔记1的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。