A. python其實很簡單 第九章 列表與元組（一）
在前面，我們要保存一個數據，需要先定義一個變數，而且一個變數中只能保存一個數據。譬如，語句：a1=1，值「1」就被保存了，但要保存「2」，就還需要再定義一個變數：a2=2......這樣以來，隨著數據的增多，豈不是要定義更多的變數嗎？
可以使用一個新的數據類型，它記錄很多數據，並且將它們按照順序存儲在連續的內存空間中，這便是序列。Python中有5種常用的序列結構，分別是列表、元組、集合、字典和字元串。
9.1列表
語法格式：
listname=[element1,element2,element3,......,elementn]
其中，listname為列表名，element1,element2,element3,......,elementn表示列表中的元素。各個元素的數據類型可以相同，也可以不同，但通常元素的類型都是相同的，含義也是相同的。
如：
list1=[『風』,』馬『,』牛』,1,2,3,』a』,』b』,』c』]就沒有太多的實際用途。
list2=['張三','男',18,�']雖然元素的類型不同，但表示了同一個人的信息。
1、訪問列表元素
列表中元素的索引號從0開始標記，訪問列表元素時，可以直接按照索引號讀取。
如：
list2=['張三','男',18,�']
print(list2[1]) #輸出列表中索引號為1的元素
輸出結果：男
和字元串一樣，序列都是可以使用切片操作的。
如：
print(list2[:2])
輸出結果：['張三', '男']
print(list2[2:])
輸出結果：[18, �']
2、使用range()函數創建數值列表
格式：range(start, stop [,step]) ；start 指的是計數起始值，默認是 0；stop 指的是計數結束值，但不包括 stop ；step 是步長，默認為 1，不可以為 0 。range() 方法生成一段左閉右開的整數范圍。
可以使用range()函數創建數值列表，如：
list1=list(range(10,20,2))
print(list1)
運行結果：[10, 12, 14, 16, 18]
3、刪除列表
語法格式如下：
del listname
其中，listname為要刪除列表的名稱。
刪除列表與刪除變數的方法是完全一樣的，前面已經介紹過了。
4、遍歷列表
常用的遍歷列表的方法有是利用for語句，舉例如下：
list1=list(range(10))
for item in list1:
print(item,end=' ') # end=』 『表示以空格結束，如果不寫這個參數，相當於默認值end=』 』
輸出結果：0 1 2 3 4 5 6 7 8 9
為了獲取列表元素的索引值，就需要使用enumerate()函數。
list1=list(range(10,20,2))
for index,item in enumerate(list1):
print(index,'-',item,end=' ')
輸出結果：0 - 10 1 - 12 2 - 14 3 - 16 4 - 18
5、追加、修改和刪除列表元素
追加元素
>>> list1=['春','夏','秋']
>>> list1.append('冬')
>>> list1
['春', '夏', '秋', '冬']
還有一種方法，就是使用「+」號將兩個序列連接起來。如：
list1=['春','夏','秋']
list1=list1+['冬']
print(list1)
輸出結果為：['春', '夏', '秋', '冬']
注意，下面的做法是錯誤的：
>>> list1=['春','夏','秋']
>>> list1=list1+'冬'
Traceback (most recent call last):
File " ", line 1, in
list1=list1+'冬'
TypeError: can only concatenate list (not "str") to list
從這個提示可知，列表只能與列表連接，而不能與字元串連接。
修改元素
>>> list1[2]='autumn' #通過索引對元素直接賦值
>>> print(list1)
['春', '夏', 'autumn', '冬']
刪除元素
>>> del list1[2] #通過索引直接刪除元素
>>> print(list1)
['春', '夏', '冬']
6、列表元素排序
在討論列表元素排序時，為了將有序列表變成無序列表，這里用到了shuffle()函數，但它不是Python的內置函數，需要先使用import語句將random模塊包含進來，這樣才能像使用內置函數那樣使用擴展模塊中的函數。
>>> import random #導入random模塊
>>> list1=list(range(10)) #生成列表，元素為0到9的整數。
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(list1) #用random包中的shuffle()函數將list1中元素次序打亂
>>> list1
[8, 6, 3, 5, 0, 7, 1, 9, 2, 4]
>>> list1.sort() #對list1升序排列
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(list1) #將list1順序重新打亂
>>> list1
[5, 9, 7, 8, 4, 3, 2, 0, 6, 1]
>>> list1.sort(reverse=True) #對list1降序排列
>>> list1
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
方法sort()的語法格式：
listname.sort(key=None,reverse=False)
其中，listname表示要排序的列表；key表示指定一個鍵，如」key=str.lower」表示排序時不區分字母大小寫；reverse為True表示降序排列（為默認值，可省缺），為False表示升序排列。
還有一個函數sorted()，功能與方法sort()相似。格式如下：
sorted(listname,key=None,reverse=False)
7、 利用列表推導式快速生成一個列表
例1：生成指定范圍的數值列表。
>>> import random
>>> list1=[random.randint(0,20) for i in range(10)]
>>> list1
[16, 20, 19, 6, 5, 7, 10, 5, 12, 5] #生成了包含10個值在0到20之間的元素構成的列表。
例2：根據現有列表生成新的列表。
>>> radius=list(range(1,6)) #生成列表 radius保存半徑的值
>>> radius
[1, 2, 3, 4, 5]
>>> s=[round(2*3.14*r,2) for r in radius]
#生成列表s，將計算得到的周長值保存起來，其中round（）可以保留指定小數位，格式 round(var, n)，var為變數名，n為指定保留小數位。
>>> s
[6.28, 12.56, 18.84, 25.12, 31.4]
例3：從列表中選擇符合條件的元素組成新的列表。
>>> score=[98,65,77,56,82,89] #列表score用來存儲成績
>>> good=[x for x in score if x>=80]
#從列表score中選取>=80的元素存入新列表good中
>>> good
[98, 82, 89]
count()、index()和sum()方法
count()方法
用於統計指定元素在列表中出現的次數。
例：
>>> list1=['a','b','c','d','e','f','c','d','e','a','b','c','d']
>>> num=list1.count('c') #統計列表list1中'c'的個數
>>> num
3
index()方法
用於獲取指定元素在列表中第一次出現的索引值。
>>> list1=['a','b','c','d','e','f','c','d','e','a','b','c','d']
>>> position=list1.index('c')
>>> position
2
sum()方法
用於計算數值列表中全部或指定元素的和。
>>> list1=[1,2,3,4,5]
>>> total=sum(list1) #計算列表list1中全部元素的和
>>> total
15
>>> total=sum(list1,1) #在列表list1全部元素的和後，在加上參數（「1」）的值
>>> total
16
>>> total=sum(list1[:2]) #計算切片list1[:2]中各元素的和
>>> total
3
二維列表
格式：listname[下標1][下標2]
其中，listname表示列表的名稱，下標1表示列表中的行號，下標2表示列表中的列號。對於n行m列的二維列表，第一個元素的行號和列號都是0，最後一個元素的行號和列號都是n-1。如下所示：
list[0][0] list[0][1] list[0][2] ............ list[0][m-1]
list[1][0] list[1][1] list[1][2] ............ list[1][m-1]
......
......
list[n-1][0] list[n-1][1] list[n-1][2] ............ list[n-1][m-1]
通俗地講，如果一個列表中的元素本身就是一個列表，則這個列表就是一個二維列表。
如：
>>> list1=['a1','b1','c1','d1']
>>> list2=['a2','b2','c2','d2']
>>> list3=['a3','b3','c3','d3']
>>> listtwo=[list1,list2,list3]
>>> listtwo
[['a1', 'b1', 'c1', 'd1'], ['a2', 'b2', 'c2', 'd2'], ['a3', 'b3', 'c3', 'd3']]
如果要查看二維列表listtwo按照行、列的排列，可以運行如下代碼：
for i in range(3):
for j in range(4):
print(listtwo[i][j],end=' ')
print()
運行結果：
a1 b1 c1 d1
a2 b2 c2 d2
a3 b3 c3 d3
如果要讀取二維列表中的某一行，可以使用如下方法：
>>> listtwo[2] #讀取第3行的元素（注意索引號都是從0開始的）
['a3', 'b3', 'c3', 'd3']
如果要讀取某一個元素的值，可以使用如下方法：
>>> listtwo[2][2] #讀取第3行第3列的元素
'c3'
B. Python學習小技巧之列表項的排序
Python學習小技巧之列表項的排序
本文介紹的是關於Python列表項排序的相關內容，分享出來供大家參考學習，下面來看看詳細的介紹：
典型代碼1：
data_list = [6, 9, 1, 3, 0, 10, 100, -100]
data_list.sort()
print(data_list)
輸出1:
[-100, 0, 1, 3, 6, 9, 10, 100]
典型代碼2:
data_list = [6, 9, 1, 3, 0, 10, 100, -100]
data_list_ = sorted(data_list)
print(data_list)
print(data_list_)
輸出2:
[6, 9, 1, 3, 0, 10, 100, -100]
[-100, 0, 1, 3, 6, 9, 10, 100]
應用場景
需要對列表中的項進行排序時使用。其中典型代碼1是使用的列表自身的一個排序方法sort，這個方法自動按照升序排序，並且是原地排序，被排序的列表本身會被修改；典型代碼2是調用的內置函數sort，會產生一個新的經過排序後的列表對象，原列表不受影響。這兩種方式接受的參數幾乎是一樣的，他們都接受一個key參數，這個參數用來指定用對象的哪一部分為排序的依據：
data_list = [(0, 100), (77, 34), (55, 97)]
data_list.sort(key=lambda x: x[1]) # 我們想要基於列表項的第二個數進行排序
print(data_list)
>>> [(77, 34), (55, 97), (0, 100)]
另外一個經常使用的參數是reverse，用來指定是否按照倒序排序，默認為False：
data_list = [(0, 100), (77, 34), (55, 97)]
data_list.sort(key=lambda x: x[1], reverse=True) # 我們想要基於列表項的第二個數進行排序，並倒序
print(data_list)
>>> [(0, 100), (55, 97), (77, 34)]
帶來的好處
1. 內置的排序方法，執行效率高，表達能力強，使代碼更加緊湊，已讀
2. 靈活的參數，用於指定排序的基準，比在類似於java的語言中需要寫一個comparator要方便很多
其它說明
1. sorted內置函數比列表的sort方法要適用范圍更廣泛，它可以對除列表之外的可迭代數據結構進行排序；
2. list內置的sort方法，屬於原地排序，理論上能夠節省內存的消耗；
總結
好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作能帶來一定的幫助
C. Python的程序結構是如何體現的
在Python中，程序的結構反映在代碼的組織和編寫方式上。
Python 程序由一系列語句組成，這些語句按順序執行。這些語句可以包括賦值、函數調用、控制語句（如 if 語句和 for 循環）和其他構造。
縮進用於指示代碼的結構。例如，只有在滿足特定條件時才執行的代碼塊將在 if 語句下縮進。這有助於使代碼更具可讀性和更易於理解。
除了 Python 程序的基本結構之外，還可以遵循各種設計模式和最佳實踐，以使代碼更易於維護和高效。其中包括使用函數將代碼組織到邏輯單元中、使用類定義可重用對象以及使用模塊將代碼組織到單獨的文件中。
總體而言，Python 程序的結構反映了代碼的組織和編寫方式，並遵循可維護性和效率的最佳實踐。
D. python的程序結構有哪幾種
①順序結構：即語句從上到下按順序執行
②分支結構：一條大路，會有很多分支路口。在python常用if..elif..else判斷語句
③循環結構：例如像放歌一樣，歌單循環播放。在python常用while循環或是for循環
E. 一文搞懂python數據類型和結構
每次python從入門到精通都是從頭開始看，做這個學習筆記主要是為了讓自己可以省去學習數據類型和結構那幾章的時間，所以「偷懶」可以促進生產力發展......
分別是： 整數型、浮點型、復數、常量、布爾型、字元串 。其中復數基本不會使用到，可以不用太關注
分別是 列表、字典、集合和元組 ，其中最常見並且工作中經常使用到的就是列表和欄位，其他兩個不常見。
02、字典
列表之外，字典可能是python中用的也比較多的數據結構了，由於字典的底層應用哈希映射，所以要求字典的所有key必須是不可變元素（可哈希對象），增刪改查操作一般都能實現O(1)復雜度，是低復雜度的必備數據結構。
03、集合
集合（set）是一個無序的不重復元素序列。
可以使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
集合操作可能最常見於用於對列表去重，它的最大特性是各元素僅保留1次，底層也是應用了哈希函數，所以在集合中查找元素一般也可實現O(1)復雜度，同時集合的嵌套元素也要求是不可變類型（可哈希對象）
add：在集合中增加一個元素，如果元素已存在，則無實際操作
pop：不接受任何參數，堪稱是最神秘的操作，不同於列表的從尾端刪除、字典的指定鍵刪除，集合的pop操作看似是"隨機"刪除。但實際上是按照加入集合的先後順序，刪除"最早"加入的元素
除了與列表和字典中類似的增刪改操作外，集合還支持數學概念下的集合操作，如交集、並集、差集等。
04、元組
如果說列表、字典和集合都有其各自擅長應用場景的話，那麼元組可能是最沒有存在感的數據結構：它介面有限、功能單一，而且是不可變類型。一般而言，用元組解決的問題都可以用列表實現。但使用用元組時，更多在於暗示該序列為不可變類型。當然，當元組內嵌套子列表時實際上是可以對嵌套的子列表進行更改操作的。
https://github.com/zqkyy/py_basic_structure
有問題可以私信我，歡迎交流！
F. 順序結構、循環結構、分支結構的流程示意圖
-------�����,-------��������,
|語句1|�����,|語句1|��������,
-------�����,-------����������,
�,|��������,|������������
�,V��������/�\����������
-------������/判定\�,NO�-------���
|語句2|������\��/�----,|語句3|��,
-------������,\�/����-------�,
���������YES|���������,
���������,-------��������,
���������,|語句2|��������,
���������,--------�������,
---------------
|語句1�,i,=,1|
---------------
�����,|
����,/�\
����/i<n,\�,NO���,-------
�|--->,\��/-----------|,exit,|
�|���\�/������,-------
�|���,|,YES����
�|�------------��
�---|語句2�i+1|
��,------------
G. python基礎數據結構：序列、映射、集合
參考資料：http://www.cnblogs.com/jeffwongishandsome/archive/2012/08/05/2623660.html
Python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
一、序列（列表、元組和字元串）
序列中的每個元素都有自己的編號。Python中有6種內建的序列。其中列表和元組是最常見的類型。其他包括字元串、Unicode字元串、buffer對象和xrange對象。下面重點介紹下列表、元組和字元串。
1、列表
列表是可變的，這是它區別於字元串和元組的最重要的特點，一句話概括即：列表可以修改，而字元串和元組不能。
（1）、創建
通過下面的方式即可創建一個列表：
輸出：
['hello', 'world']
[1, 2, 3]
可以看到，這中創建方式非常類似於javascript中的數組。
（2）、list函數
通過list函數（其實list是一種類型而不是函數）對字元串創建列表非常有效：
輸出：
['h', 'e', 'l', 'l', 'o']
2、元組
元組與列表一樣，也是一種序列，唯一不同的是元組不能被修改（字元串其實也有這種特點）。
（1） 、創建
輸出：
(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)
從上面我們可以分析得出：
a、逗號分隔一些值，元組自動創建完成；
b、元組大部分時候是通過圓括弧括起來的；
c、空元組可以用沒有包含內容的圓括弧來表示；
d、只含一個值的元組，必須加個逗號（,）；
（2）、tuple函數
tuple函數和序列的list函數幾乎一樣：以一個序列（注意是序列）作為參數並把它轉換為元組。如果參數就算元組，那麼該參數就會原樣返回：
輸出：
(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
t4=tuple(123)
TypeError: 'int' object is not iterable
3、字元串
（1）創建
輸出：
Hello world
H
H
e
l
l
o
w
o
r
l
d
（2）、格式化
format（）：
print(『{0} was {1} years old when he wrote this book』. format(name,age) )
print(『{} was {} years old when he wrote this book』. format(name,age) )
print(『{name} was {age} years old when he wrote this book』. format(name=』Lily』,age=』22』) )
#對於浮點數「0.333」保留小數點後三位
print(『{0 : .3f}』.format(1.0/3) )
結果：0.333
#使用下劃線填充文本，並保持文字處於中間位置
#使用^定義『_____hello_____』字元串長度為11
print(『{0 : ^_11}』.format(『hello』) )
結果：_____hello_____
% :
格式化操作符的右操作數可以是任何東西，如果是元組或者映射類型（如字典），那麼字元串格式化將會有所不同。
輸出：
Hello,world
Hello,World
注意：如果需要轉換的元組作為轉換表達式的一部分存在，那麼必須將它用圓括弧括起來：
輸出：
Traceback (most recent call last):
File "F:\Python\test.py", line 2, in
str1='%s,%s' % 'Hello','world'
TypeError: not enough arguments for format string
如果需要輸出%這個特殊字元，毫無疑問，我們會想到轉義，但是Python中正確的處理方式如下：
輸出：100%
對數字進行格式化處理，通常需要控制輸出的寬度和精度：
輸出：
3.14
3.141593
3.14
字元串格式化還包含很多其他豐富的轉換類型，可參考官方文檔。
4、通用序列操作（方法）
從列表、元組以及字元串可以「抽象」出序列的一些公共通用方法（不是你想像中的CRUD），這些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及檢查某個元素是否屬於序列的成員。除此之外，還有計算序列長度、最大最小元素等內置函數。
（1）索引
輸出
H
2
345
索引從0（從左向右）開始，所有序列可通過這種方式進行索引。神奇的是，索引可以從最後一個位置（從右向左）開始，編號是-1：
輸出：
o
3
123
（2）分片
分片操作用來訪問一定范圍內的元素。分片通過冒號相隔的兩個索引來實現：
輸出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4]
[6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 8]
[7, 8, 9]
不同的步長，有不同的輸出：
輸出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[0, 3, 6, 9]
[]
（3）序列相加
輸出：
Hello world
[1, 2, 3, 2, 3, 4]
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
print str1+num1
TypeError: cannot concatenate 'str' and 'list' objects
（4）乘法
輸出：
[None, None, None, None, None, None, None, None, None, None]
HelloHello
[1, 2, 1, 2]
Traceback (most recent call last):
File "F:\Python\test.py", line 5, in
print str1*num1
TypeError: can't multiply sequence by non-int of type 'list'
（5）成員資格
in運算符會用來檢查一個對象是否為某個序列（或者其他類型）的成員（即元素）：
輸出：
False
True
True
（6）長度、最大最小值
通過內建函數len、max和min可以返回序列中所包含元素的數量、最大和最小元素。
輸出：
5
o
H
5
123
1
二、映射（字典）
映射中的每個元素都有一個名字，如你所知，這個名字專業的名稱叫鍵。字典（也叫散列表）是Python中唯一內建的映射類型。
1、鍵類型
字典的鍵可以是數字、字元串或者是元組，鍵必須唯一。在Python中，數字、字元串和元組都被設計成不可變類型，而常見的列表以及集合（set）都是可變的，所以列表和集合不能作為字典的鍵。鍵可以為任何不可變類型，這正是Python中的字典最強大的地方。
輸出：
{1: 1}
Traceback (most recent call last):
File "F:\Python\test.py", line 6, in
d[list1]="Hello world."
TypeError: unhashable type: 'list'
2、自動添加
即使鍵在字典中並不存在，也可以為它分配一個值，這樣字典就會建立新的項。
3、成員資格
表達式item in d（d為字典）查找的是鍵（containskey），而不是值（containsvalue）。
三、集合
集合（Set）在Python 2.3引入，通常使用較新版Python可直接創建，如下所示：
strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))
看上去，集合就是由序列（或者其他可迭代的對象）構建的。集合的幾個重要特點和方法如下：
1、副本是被忽略的
集合主要用於檢查成員資格，因此副本是被忽略的，如下示例所示,輸出的集合內容是一樣的。
輸出如下：
set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])
2、集合元素的順序是隨意的
這一點和字典非常像，可以簡單理解集合為沒有value的字典。
輸出如下：
set(['wong', 'cnblogs', 'jeff'])
3、集合常用方法
a、並集union
輸出：
set([1, 2, 3])
set([2, 3, 4])
set([1, 2, 3, 4])
union操作返回兩個集合的並集，不改變原有集合。使用按位與（OR）運算符「|」可以得到一樣的結果：
輸出和上面union操作一模一樣的結果。
其他常見操作包括&（交集）,<=,>=,-,()等等，這里不再列舉。
輸出如下：
set([1, 2, 3])
set([2, 3, 4])
set([2, 3])
True
set([1, 2, 3])
False
b、add和remove
和序列添加和移除的方法非常類似，可參考官方文檔：
輸出：
set([1])
set([1, 2])
set([1])
set([1])
False
Traceback (most recent call last):
File "F:\Python\test.py", line 9, in
set1.remove(29) #移除不存在的項
KeyError: 29
4、frozenset
集合是可變的，所以不能用做字典的鍵。集合本身只能包含不可變值，所以也就不能包含其他集合：
輸出如下：
Traceback (most recent call last):
File "F:\Python\test.py", line 3, in
set1.add(set2)
TypeError: unhashable type: 'set'
可以使用frozenset類型用於代表不可變（可散列）的集合：
輸出：
set([1, frozenset([2])])