[[397059]]

Python(英國發(fā)音：/ˈpaɪθən/ 美國發(fā)音：/ˈpaɪθɑːn/)是一種廣泛使用的解釋型、高級和通用的編程語言。Python支持多種編程范型，包括函數式、指令式、結構化、面向對象和反射式編程。它擁有動態(tài)類型系統(tǒng)和垃圾回收功能，能夠自動管理內存使用，并且其本身擁有一個巨大而廣泛的標準庫。

Python有著范圍廣泛的基本數據類型。Python的一個非常有用方面就是容器類型的概念，容器有二種基本形式：序列和映射。有次序的序列類型是列表(動態(tài)數組)、元組和字符串。所有序列類型都是位置索引的(從0到長度?1)，并且除了字符串，都可以包含任意類型的對象，在同一個序列中包括多種類型的對象。字符串和元組是不可變的，使得它們成為字典的鍵的完美候選者。在另一方面，列表是可變的，元素可以被插入、刪除、修改、添加或就地排序。

本篇內容總結包括從變量、輸入輸出到數據類型的基本介紹和常用方法。

一、變量與類型轉換

變量賦值

>>> x=5 
>>> x 
5 

變量計算

>>> x+2  # 兩個變量的和 
7 
>>> x-2  # 兩個變量的減法 
3 
>>> x*2  # 兩個變量相乘 
10 
>>> x**2 # 求變量的冪 
25 
>>> x%2  # 變量的余數 
1 
>>> x/float(2) # 變量的除法 
2.5 

類型和類型轉換

方法	例	說明
str()	5', '3.45', 'True'	字符串
int()	5, 3, 1	整數
float()	5.0, 1.0	浮點數
bool()	True, True, True	布爾值

二、獲取幫助

>>> help(str) 

三、輸入與輸出

print

>>> print("Hello world!") 
 
>>> msg = "Hello world!" 
>>> print(msg) 

Input

Input程序可以提示用戶輸入。所有輸入都存儲為字符串。

• 提示輸入值

>>> name = input("What's your name? ")  
>>> print("Hello, " + name + "!") 

• 提示輸入數字

>>> age = input("How old are you? ") 
>>> age = int(age) 
>>> pi = input("What's the value of pi? ") 
>>> pi = float(pi) 

四、字符串

字符串是 Python 中最常用的數據類型。我們可以使用引號('或")來創(chuàng)建字符串。創(chuàng)建字符串很簡單，只要為變量分配一個值即可。

>>> my_string = 'thisStringIsAwesome'  
>>> my_string 
'thisStringIsAwesome' 

字符串運算

>>> my_string * 2   # 乘法 
'thisStringIsAwesomethisStringIsAwesome'  
>>> my_string + 'Innit' # 拼接 
'thisStringIsAwesomeInnit'  
>>> 'm' in my_string # 是否存在 
True 
# 索引從零開始  
>>> my_string[3] 
>>> my_string[4:9] 

字符串方法

>>> my_string.upper()    # 字符串大寫 
>>> my_string.lower()    # 字符串小寫 
>>> my_string.count('w') # 計算字符串的元素 
>>> my_string.replace('e', 'i') # 替換字符串元素 
>>> my_string.strip()    # 去空格 

五、列表

列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現。

列表的數據項不需要具有相同的類型。

列表以特定的順序存儲一系列項目。列表允許將信息集存儲在一個地方，無論只有幾個項還是數百萬項。列表是Python最強大的特性之一，新程序員可以很容易地訪問它，它們將編程中的許多重要概念聯(lián)系在一起。

使用方括號定義列表，使用逗號分隔列表中的各個項目。使用列表的復數名稱，使您的代碼更容易閱讀。

>>> a = 'is' 
>>> b = 'nice' 
>>> my_list = ['my', 'list', a, b] 
>>> my_list2 = [[4,5,6,7], [3,4,5,6]] 
 
>>> users = ['val', 'bob', 'mia', 'ron', 'ned'] 

更改列表值

一旦定義了列表，就可以更改列表中的單個元素。這可以通過引用要修改的項的索引來實現。

>>> users[0] = 'valerie' 
>>> users[-2] = 'ronald' 

列表切片與索引

可以使用列表中的任何一組元素。根據列表中的元素的位置(稱為索引)來訪問它們,列表的一部分稱為片。要切片列表，首先從您想要的第一個項目的索引開始，然后添加冒號和您想要的最后一個項目之后的索引。去掉列表開始處的第一個索引，去掉列表結束處的最后一個索引。

第一個元素的索引是0，第二個元素的索引是1，以此類推。

負索引指的是列表末尾的項。要獲得特定的元素，請先寫出列表的名稱，然后在方括號中寫出元素的索引。

# 子集 
>>> my_list[1]   # 選擇索引1的項 
>>> my_list[-3]  # 最后選擇第三項 
# 切片 
>>> my_list[1:3] # 選擇索引1和索引2上的項 
>>> my_list[1:]  # 選擇索引0之后的項 
>>> my_list[:3]  # 選擇索引3之前的項 
>>> my_list[:]   # 復制my_list 
# 子集的子集 
>>> my_list2[1][0] 
>>> my_list2[1][:2] 

列表運算

>>> my_list + my_list 
['my', 'list', 'is', 'nice', 'my', 'list', 'is', 'nice']  
>>> my_list * 2 
['my', 'list', 'is', 'nice', 'my', 'list', 'is', 'nice']  
>>> my_list2 > 4 
True 

列表方法

>>> my_list.index(a)     # 獲取項目的索引 
>>> my_list.count(a)     # 計算一個項目 
>>> my_list.append('!')  # 每次追加一個項 
>>> my_list.remove('!')  # 刪除一個項目 
>>> del(my_list[0:1])    # 刪除一個項目 
>>> my_list.reverse()    # 反向列表 
>>> my_list.extend('!')  # 添加一個項目 
>>> my_list.pop(-1)      # 刪除一個項目 
>>> my_list.insert(0,'!')# 插入一個項目 
>>> my_list.sort()       # 排序的列表 

• 遍歷列表

列表可以包含數百萬個項，因此Python提供了一種有效的方法來遍歷列表中的所有項。當設置一個循環(huán)時，Python每次從列表中取出一項，并將其存儲在一個臨時變量中，為該臨時變量提供了一個名稱。這個名稱應該是列表名稱的單數版本。

縮進的代碼塊構成循環(huán)體，在循環(huán)體中可以處理每個單獨的項。任何沒有縮進的行在循環(huán)結束后運行。

>>> for bike in bikes: 
...     print(bike) 

• 向列表中添加元素

可以將元素添加到列表的末尾。

>>> bikes = []  
>>> bikes.append('trek')  
>>> bikes.append('redline') 
>>> bikes.append('giant') 

• 在特定位置插入元素

可以將它們插入到列表中的任何位置。

>>> users.insert(0, 'joe') 
>>> users.insert(3, 'bea') 

• 刪除元素

可以根據元素在列表中的位置或項的值刪除元素。如果你通過一個項的值來移除它，Python只移除第一個具有該值的項。

# 通過位置刪除 
>>> del users[-1] 
# 通過值刪除  
>>> users.remove('mia') 

• 列表排序

方法的作用是永久地改變列表的順序。sorted()函數返回列表的副本，保持原始列表不變。可以按字母順序或反字母順序對列表中的項目進行排序。還可以顛倒列表的原始順序。

# 永久地對列表進行排序 
>>> users.sort() 
 
# 以反字母順序永久地對列表進行排序 
>>> users.sort(reverse=True) 
 
# 臨時排序 
>>> print(sorted(users)) 
>>> print(sorted(users, reverse=True)) 
 
# 反向排序 
>>> users.reverse() 

• 列表推導式

>>> squares = [x**2 for x in range(1, 11)] 

range()函數

可以使用range()函數有效地處理一組數字。range()函數默認從0開始，停止傳遞給它的數字下面的一個數字。可以使用list()函數來有效地生成大量的數字列表。

• 打印數字0-1000

>>> for number in range(1001): 
...    print(number) 

• 打印數字1-1001

>>> for number in range(1, 1001): 
...    print(number) 

• 列出從1到100萬的數字

>>> numbers = list(range(1, 1000001)) 

簡單統(tǒng)計

您可以在包含數字數據的列表上運行許多簡單的統(tǒng)計數據。

最小值

>>> ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] 
>>> youngest = min(ages) 

最大值

>>> ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] 
>>> oldest = max(ages) 

求和

>>> ages = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77] 
>>> total_years = sum(ages) 
>>> total_years 
557 

六、元組

元組與列表類似，但元組中的項不能被修改，即不可變數據類型。

>>> dimensions = (1920, 1080) 

七、字典

字典存儲在片段信息之間的建立聯(lián)系。字典中的每一個項都是一個鍵-值對。當提供一個鍵時，Python將返回與該鍵相關聯(lián)的值。可以循環(huán)遍歷所有鍵-值對、所有鍵或所有值。

使用花括號來定義字典。使用冒號連接鍵和值，并使用逗號分隔單個鍵-值對。

>>> alien = {'color': 'green', 'points': 5} 

獲取字典值(查)

要獲取單個鍵關聯(lián)的值，需提供字典的名稱，然后將鍵放在一組方括號中。如果需要的鍵不在字典中，就會出現錯誤。

還可以使用get()方法，如果鍵不存在，該方法將返回None，而不是錯誤。如果鍵不在字典中，還可以指定要使用的默認值。

>>> print("The alien's color is " + alien['color']) 
"The alien's color is green" 
>>> alien_0 = {'color': 'green', 'points': 5} 
>>> alien_color = alien_0.get('color') 
>>> alien_points = alien_0.get('points', 0) 
>>> print(alien_color) 
'green' 
>>> print(alien_points) 
None 

添加一個新鍵值對(增)

可以在字典中存儲任意數量的鍵值對，直到計算機內存耗盡為止。要向現有字典添加新的鍵-值對，請在方括號中給出字典的名稱和新鍵，并將其設置為新值。

這還允許您從一個空字典開始，并在它們變得相關時添加鍵-值對。

>>> alien_0 = {'color': 'green', 'points': 5} 
>>> alien_0['x'] = 0 
>>> alien_0['y'] = 25 
>>> alien_0['speed'] = 1.5 
 
# 向空字典中添加新鍵值對 
>>> alien_0 = {} 
>>> alien_0['color'] = 'green' 
>>> alien_0['points'] = 5 

修改字典值(改)

可以修改與字典中任何鍵相關聯(lián)的值。為此，給出字典的名稱并將鍵括在方括號中，然后為該鍵提供新值。

>>> alien_0 = {'color': 'green', 'points': 5} 
>>> print(alien_0) 
  
>>> alien_0['color'] = 'yellow'  
>>> alien_0['points'] = 10 
>>> print(alien_0) 

刪除字典鍵值對(刪)

您可以從字典中刪除任何想要的鍵-值對。為此，請使用del關鍵字和字典名稱，后跟方括號中的鍵。這將刪除鍵及其關聯(lián)值。

>>> alien_0 = {'color': 'green', 'points': 5} 
>>> print(alien_0) 
>>> del alien_0['points'] 
>>> print(alien_0) 

循環(huán)遍歷字典

可以用三種方式循環(huán)遍歷字典：可以循環(huán)遍歷所有鍵-值對、所有鍵或所有值。字典只跟蹤鍵和值之間的連接，它不跟蹤字典中條目的順序。如果希望按順序處理信息，可以對循環(huán)中的鍵進行排序。

• 循環(huán)變量所有鍵值對

>>> fav_numbers = {'eric': 17, 'ever': 4} 
>>> for name, number in fav_numbers.items(): 
...    print(name + ' loves ' + str(number)) 

• 循環(huán)變量所有鍵

>>> av_numbers = {'eric': 17, 'ever': 4} 
>>> for name in fav_numbers.keys(): 
...     print(name + ' loves a number') 

• 循環(huán)變量所有值

>>> av_numbers = {'eric': 17, 'ever': 4} 
>>> for number in fav_numbers.values(): 
...     print(str(number) + ' is a favorite') 

• 按順序循環(huán)遍歷所有鍵

>>> av_numbers = {'eric': 17, 'ever': 4} 
>>> for name in sorted(fav_languages.keys()): 
...   print(name + ": " + language) 

列表中嵌套字典

• 通過append()將字典嵌入列表

# 建立一個空列表 
>>> users = [] 
# 創(chuàng)建一個字典，并將其嵌入到列表中 
>>> new_user = { 
...     'last': 'fermi', 
...     'first': 'enrico', 
...     'username': 'efermi', 
...     } 
>>> users.append(new_user) 
# 再創(chuàng)建另一個字典，并將其嵌入到列表中 
>>> new_user = { 
...     'last': 'curie', 
...     'first': 'marie', 
...     'username': 'mcurie', 
...     } 
>>> users.append(new_user) 
# 打印出列表中所有的信息 
>>> for user_dict in users: 
...     for k, v in user_dict.items(): 
...         print(k + ": " + v) 
...   print("\n") 

• 直接定義一個字典列表

>>> users = [ 
...     { 
...        'last': 'fermi', 
...        'first': 'enrico', 
...        'username': 'efermi', 
...   },  
...   { 
...        'last': 'curie', 
...        'first': 'marie', 
...        'username': 'mcurie', 
...   },  
... ] 
# 打印所有users的信息 
>>> for user_dict in users: 
...     for k, v in user_dict.items(): 
...         print(k + ": " + v) 
...   print("\n") 

字典內嵌套列表

在字典中存儲列表，允許將多個值與同一個鍵關聯(lián)。

# 為每個人存儲多種語言。 
>>> fav_languages = { 
...     'jen': ['python', 'ruby'], 
...     'sarah': ['c'], 
...     'edward': ['ruby', 'go'], 
...     'phil': ['python', 'haskell'], 
... } 
# 顯示每個人的所有回答。 
>>> for name, langs in fav_languages.items(): 
...     print(name + ": ") 
>>> for lang in langs: 
...     print("- " + lang) 

字典內嵌套字典

可以將一個字典存儲在另一個字典中。在這種情況下，與鍵相關聯(lián)的每個值本身就是一個字典。

>>> users = { 
...     'aeinstein': { 
...         'first': 'albert', 
...         'last': 'einstein', 
...         'location': 'princeton', 
...         }, 
...     'mcurie': { 
...         'first': 'marie', 
...         'last': 'curie', 
...         'location': 'paris', 
...         }, 
... } 
>>> for username, user_dict in users.items(): 
...     print("\nUsername: " + username) 
...     full_name = user_dict['first'] + " " 
...     full_name += user_dict['last'] 
...     location = user_dict['location'] 
...     print("\tFull name: " + full_name.title()) 
...     print("\tLocation: " + location.title()) 
 
Username: aeinstein 
 Full name: Albert Einstein 
 Location: Princeton 
 
Username: mcurie 
 Full name: Marie Curie 
 Location: Paris 

順序字典 OrderedDict

標準的Python字典不會跟蹤鍵和值的添加順序，它們只保留每個鍵及其值之間的關聯(lián)。使用OrderedDict可以保持鍵和值的添加順序。

>>> from collections import OrderedDict 
# 存儲每個人的語言。 
# 跟蹤最先響應的人。 
>>> fav_languages = OrderedDict() 
>>> fav_languages['jen'] = ['python', 'ruby'] 
>>> fav_languages['sarah'] = ['c'] 
>>> fav_languages['edward'] = ['ruby', 'go'] 
>>> fav_languages['phil'] = ['python', 'haskell'] 
# 按照輸入的順序顯示結果 
>>> for name, langs in fav_languages.items(): 
>>>     print(name + ":") 
>>>     for lang in langs: 
>>>         print("- " + lang) 
 
jen: 
- python 
- ruby 
sarah: 
- c 
edward: 
- ruby 
- go 
phil: 
- python 
- haskell