Python中不需要先聲明變量名及其類型，直接賦值即可
字符串前面加字母r或R表示原始字符串，其中的特殊字符不進行轉義，但字符串的最後一個字符不能是\符號
在選擇和循環結構中，條件表達式的值只要不是False、0（或0.0、0j等）、空值None、空列表、空元組、空集合、空字典、空字符串、空range對象或其他空迭代對象，Python解釋器均認爲與True等價。
變量類型：
數字：int，flat，complex
字符串：str 字符串支持使用+運算符進行合併以生成新的字符串
列表：list
字典：dict
元組：tuple
集合：set
布爾型：bool
空類型：None
x=3
print(type(x)) #int
x=3.5
print(type(x)) #float
x=3+5j
print(type(x)) #complex
x='hello world'
print(type(x)) #str
x=[1,2,3]
print(type(x)) #list
x=True
print(type(x)) #bool
x=(2,5,6)
print(type(x)) #tuple
x=None
print(type(x)) #NoneType
條件表達式
算術運算符：+、-、*、/、//、%、**
關係運算符：>、<、==、<=、>=、!=，可以連續使用
測試運算符：in、not in、is、is not
邏輯運算符：and、or、not，注意短路求值
位運算符：~、&、|、 ^、 <<、>>
矩陣乘法運算符：@
短路求值：當進行與運算時（a&&b），當a的值爲False時，則直接跳過b值的判斷
當進行或運算時（a||b）,當a的值爲True時，則直接跳過b值的判斷
x=3
y=4
z=x+y #7
z=x-y #-1
z=x*y #12
z=x/y #0.75
z=x//y #整除運算 0
z=x%y #3
z=x**y #平方運算 81
z=x and y #4
z=x or y #3
z=not y #False
單分支結構
if x :
print("OK")
雙分支結構
if x :
print("Ok")
else :
print("No")
# value1 if condition else value2
print("True") if x else print("False")
多分支結構
#多分支
if x==1:
print("1")
elif x==2 :
print("2")
else :
print("3")
Python中縮進代表代碼塊，取消括號
循環結構
#while
while x:
break
#for
list=(1,2,3)
for x in list:
print(x)
else: #如果沒有break則執行else語句
print("ok")
#局部變量訪問比全局變量快
例題
#編寫一個程序，完成以下功能。假設由變量a，判斷變量a是否爲偶數，若爲偶數，則輸出a爲偶數。無論變量a是否爲偶數，都把其值輸出出來。編寫函數：函數功能是將學生成績從百分制變換到等級制：
def prin():
if (a % 2 == 0):
print(a)
print("a爲偶數")
else:
print(a)
#90分及以上 A
#80分-90分之間 B
#70分-80分之間 C
#60分-70分之間 D
#60分以下 E
def score(grade):
if (grade >= 90):
return "A"
elif (grade >= 80 and a < 90):
return "B"
elif (grade >= 70 and a < 80):
return "C"
elif (grade >= 60 and a < 70):
return "D"
else:
return "E"
#修改猜一猜小遊戲：（ 使用random.randint(0, 10) ）要求：可以不停猜，並提示猜大了還是猜小了，直到猜中爲止。
def game():
ans = random.randint(0, 10)
while True:
num = input()
num = int(num)
if (num > ans):
print("big")
elif (num < ans):
print("small")
else:
print("bingo")
break
#主函數調用
if __name__=="__main__": #相當於C的main函數接口
a = input()
a=int(a)
prin()
grade=input()
grade=int(grade)
print(score(grade))
game()
Python序列：列表、元組、字典、字符串、集合等
列表是Python中內置有序、可變序列，列表的所有元素放在一對中括號“[]”中，並使用逗號分隔開
在Python中，一個列表中的數據類型可以各不相同，可以同時分別爲整數、實數、字符串等基本類型，甚至是列表、元組、字典、集合以及其他自定義類型的對象
[10, 20, 30, 40]
['crunchy frog', 'ram bladder', 'lark vomit']
['spam', 2.0, 5, [10, 20]]
[['file1', 200,7], ['file2', 260,9]]
列表創建
使用“=”直接將一個列表賦值給變量即可創建列表對象
a_list = ['a', 'b', 'mpilgrim', 'z', 'example']
a_list = [] //空列表
也可以使用list()函數將元組、range對象、字符串或其他類型的可迭代對象類型的數據轉換爲列表
a_list = list((3,5,7,9,11))
a_list
//[3, 5, 7, 9, 11]
list(range(1,10,2))
//[1, 3, 5, 7, 9]
list('hello world')
//['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
x = list() //創建空列表
列表訪問
索引訪問方式：下標從0開始（可以逆向訪問，從尾開始爲-1）
切片訪問：[起始位置，最終位置，步長]
list_a = list[1:4:2] #起始位置爲1，終止位置爲4，步長爲2
列表運算符
列表之間可以使用 + 號和 * 號進行運算。這就意味着他們可以組合和複製，運算後會生成一個新的列表
|
表達式 |
結果 |
描述 |
|
[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 |
遍歷 |
列表常用方法
|
方法 |
說明 |
|
lst.append(obj) |
在列表尾部添加新的元素 |
|
lst.extend(L) |
將列表L中所有元素添加至列表lst尾部 |
|
lst.insert(index, obj) |
在列表lst指定位置index處添加元素 |
|
lst.remove(x) |
在列表lst中刪除首次出現的指定元素 |
|
lst.pop([index]) |
刪除並返回列表lst中下標爲index（默認爲-1）的元素 |
|
lst.clear() |
清空列表，但保留對象 |
|
lst.index(obj) |
從列表中找出某個值第一個匹配項的索引位置 |
|
lst.count(obj) |
統計某元素在列表的出現次數 |
|
lst.reverse() |
對列表lst所有元素進行逆序 |
|
lst.sort(key=None, reverse=False) |
對列表lst中的元素進行排序，key用來指定排序依據，reverse決定升序（False）還是降序（True） |
|
lst.copy() |
複製列表 |
列表元素增加
（1）“+”運算符
aList = [3,4,5]
aList = aList + [7]
#[3, 4, 5, 7]
嚴格意義上來講，這並不是真的爲列表添加元素，而是創建了一個新列表，並將原列表中的元素和新元素依次複製到新列表的內存空間。操作速度較慢，在涉及大量元素添加時不建議使用該方法。
（2）append()方法
aList.append(9)
aList
#[3, 4, 5, 7, 9]
在當前列表尾部追加元素，原地修改列表，是真正意義上的在列表尾部添加元素，速度較快
所謂“原地”，是指不改變列表在內存中的首地址。
id(aList)前後地址是不變的。
（3）extend()方法
a = [1,2,3]
id(a)
#25289752
a.extend([7,8,9])
a
#[1, 2, 3, 7, 8, 9]
>>> id(a)
#25289752
a.extend((15,17))
a
[1, 2, 3, 7, 8, 9, 15, 17]
可以將另一個迭代對象的所有元素添加至該列表對象尾部。通過extend()方法來增加列表元素也不改變其內存首地址，屬於原地操作
（4）insert()方法
aList=[3, 4, 5, 7, 9, 11, 13, 15, 17]
aList.insert(3, 6) #在下標爲3的位置插入元素6
aList
#[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
將元素添加至列表的指定位置
注意： 會引發數據的移動！
列表元素的刪除
（1）del命令
刪除列表中的指定位置上的元素
a_list = [3,5,7,9,11]
del a_list[1]
a_list
#[3, 7, 9, 11]
（2）pop()方法
a_list = list((3,5,7,9,11))
a_list.pop()
#11
a_list
#[3, 5, 7, 9]
a_list.pop(1)
#5
a_list
#[3, 7, 9]
刪除並返回指定位置（默認爲最後一個）上的元素，如果給定的索引超出了列表的範圍則拋出異常。
（3）remove()方法
a_list = [3,5,7,9,7,11]
a_list.remove(7)
a_list
#[3, 5, 9, 7, 11]
刪除首次出現的指定元素，如果列表中不存在要刪除的元素，則拋出異常
（4）clear()方法
a_list = [3,5,7,9,7,11]
a_list.clear()
清空列表裏所有元素
列表計數
aList
#[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
aList.count(7)
#1
aList.count(0)
#0
aList.count(8)
#0
使用列表對象的count()方法統計指定元素在列表對象中出現的次數。
列表內置函數
|
函數 |
說明 |
|
len(list) |
列表長度，即元素個數 |
|
max(list) |
返回列表元素最大值 |
|
min(list) |
返回列表元素最小值 |
|
list(seq) |
將元組轉成列表 |
#請用索引取出下面list的指定元素
#L = [['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
if __name__=="__main__":
L = [['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
for index in range(len(L)):
print(L[index])
#遍歷下面的列表
#lst=['Apple','Google','Microsoft','Java','Python','Ruby','PHP']
LST = ['Apple','Google','Microsoft','Java','Python','Ruby','PHP']
for index in range(len(LST)):
print(LST[index])
x = [1,2,1,2,1,1,1]
for i in range(len(x)-1,-1,-1): # range（起始位置，終止位置，每次操作）
if x[i]==1:
del x[i]
x = [1,2,1,2,1,1,1]
for i in x[::]: #x[::] : 拷貝副本 #切片
if i == 1:
x.remove(i)
列表排序
使用列表對象的sort()方法進行原地排序，支持多種不同的排序方法。
list.sort(key=None, reverse=False)
>>> aList = [3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
>>> aList.sort() #默認升序排序
>>> aList.sort(reverse = True) #降序排序
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
關鍵字問題
list.sort(key=None, reverse=False)
key=函數名，該函數的返回值作爲元素的權值大小
reverse -- 排序規則，reverse = True 降序， reverse = False 升序
#按轉換成字符串的長度排序
>>> aList.sort(key = lambda x:len(str(x))) #lambda ： 匿名函數 返回值爲表達式
>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
列表排序
使用內置函數sorted()對列表進行排序並返回新列表
>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
>>> sorted(aList) #升序排序
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> sorted(aList,reverse = True) #降序排序
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
列表逆序
使用列表對象的reverse()方法將元素原地逆序
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList.reverse()
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
序列操作的常用內置函數1
len(列表)：返回列表中的元素個數，同樣適用於元組、字典、集合、字符串等
max(列表)、 min(列表)：返回列表中的最大或最小元素，同樣適用於元組、字典、集合、range對象等
sum(列表)：對列表的元素進行求和運算，對非數值型列表運算需要指定start參數，同樣適用於元組、range
>>> sum(range(1, 11)) #sum()函數的start參數默認爲0
55
>>> sum(range(1, 11), 5) #指定start參數爲5，等價於5+sum(range(1,11))
60
>>> sum([[1, 2], [3], [4]], []) #這個操作佔用空間較大，慎用
[1, 2, 3, 4]
序列操作常用內置函數2：zip()
zip()函數返回可迭代的zip對象
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(aList, bList) #返回zip對象
>>> cList
#<zip object at 0x0000000003728908>
>>> list(cList) #把zip對象轉換成列表
#[(1, 4), (2, 5), (3, 6)]
序列操作常用內置函數3: enumerate()
enumerate()函數用來枚舉可迭代對象中的元素，返回可迭代的enumerate枚舉對象，其中每個元素爲包含下標和值的元組。該函數對元組、字符串同樣有效
>>> for item in enumerate('abcdef'):
print(item)
'''
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
'''
列表推導式
列表推導式使用非常簡潔的方式來快速生成滿足特定需求的列表，代碼具有非常強的可讀性
列表推導式語法形式爲
[expression for expr1 in sequence1 if condition1
for expr2 in sequence2 if condition2
for expr3 in sequence3 if condition3
...
for exprN in sequenceN if conditionN]
列表推導式在內部實際上是一個循環結構，只是形式更加簡潔，例如：
>>> aList = [x*x for x in range(10)]
#等價於
>>> aList = []
>>> for x in range(10):
aList.append(x*x)
使用列表推導式實現嵌套列表的平鋪
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
#等價於
>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
for num in elem:
result.append(num)
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]
例題
#使用random模塊，隨機生成一個每個數據元素都小於100且列表長度爲20的列表。並調整列表元素順序，把所有奇數都放到前面，偶數都放到後面。（注意：布爾類型可以比較大小）
>>>result = [random.randint(0,100) for i in range(20)]
>>>result.sort(key=lambda x:x%2==0,reverse = False)
>>> print(result)
#aList = [-1,-4,6,7.5,-2.3,9,-11]，採用列表推導式過濾掉負數並且將正數的值求平方組成一個列表。
>>>alist = [-1,-4,6,7.5,-2.3,9,-11]
>>>l=[i**2 for i in alist if i > 0]
>>> print(l)