Python中的注釋有以下三種

# 注釋1
'''多行注釋1'''
"""多行注釋2""

一、數據類型

1.Python中基本數據類型及變量的定義

# int 整形
a = 1
#float 浮點型
a = 1.0
#str 字符型
a = 'str'
# bytes 二進制
a = b'6'
# bool 布爾值
a = True
# None 空值
a = None
# complex 復數
a = 1 + 5j 

Python語法比較松散，語句的最後不強制要求加’;’，在定義變量時，不需要聲明變量的數據類型，Python會根據變量的賦值自動給定數據類型。如果在定義一個變量時不確定他的類型，可以使用None來進行賦值，此時的類型也是None Type。

2.python中復雜數據類型及變量的定義

• 元組 tuple

# 創建元組並直接賦值
tuple_data = (1, '2', b'2', True, 2.2, 2 + 3j)
# 創建空元組
tuple_data = tuple()
tuple_data = ()
'''
使用可迭代對象創建元組
會將可迭代對象中的內容，按照下標拆分，然後依次放入元組
如"hello"會創建一個('h','e','l','l','o')
'''
tuple_data = tuple("hello")
# tuple可以進行嵌套,此時tuple_data[0] = (1, 2) tuple_data[0][0] = 1
tuple_data = tuple((1, 2), (3, 4))

元組類似其他語言中的數組，但是元組一經定義就是不可更改的序列，且元組中的不同數據的數據類型不受限定。我們可以像數組一樣，使用下標來訪問元組，但不能夠使用下標來改變元組內的數據

列表 list

# 創建一個給定數據的列表
list_data = [1, 2, 3]
# 創建空列表
list_data = list()
list_data = []
# 使用可迭代對象創建列表
list_data = list((1, 2, 3))
# 列表可以嵌套
list_data = [[1, 2], 3]

常用方法：

• append() -------- 向列表的尾部添加元素
• insert(index，object) -------- 向指定的下標處添加元素
• sort（）-------- 進行排序（從下到大 int類型）可以對字母進行排序（ASCII值）類型不能混
• index（）-------- 返回的是元素在列表中的第一個位置
• reverse（）------------ 將列表進行翻轉
• remove（）---- 刪除某個元素，如果有重復則刪除的是第一次出現的元素，如果元素不存在會報錯
• count（）-------- 返回的是某個元素在列表裡面的個數
• clear（）--------- 清除元素
• copy（）-------- 淺拷貝對象 不等價與 =
• extend（）-------- 合並列表
• pop（）-------刪除列表尾部的元素（與append相反）,返回刪除的元素，pop(i) i指的是下標

字典 dict

字典是以key:value形式存儲數據的數據類型，要求key是唯一且不可變的可以是以下數據類型（tuple,int,float,complex,bytes,str,bool）

# 用給定的數據創建
dict_data = {'sport': 'football', 'food': 'fried chicken'}
# 新建一個空字典
dict_data = {}
dict_data = dict()
# 使用可迭代對象創建字典，要求必須是成對的可迭代對象
dict_data = {[('a', 'b'), ('c', 'd')]}
# 注意：如果有這樣一個字典，將會出現錯誤
dict_data = {True: 1, 1: 2}
# 因為在Python中True是等於1，此時雖然沒有1:1 和 1:2 同時存在，但實際上已經出現了重復的key值，此時dict_data[1] = 2，因為後面一個定義的1:2覆蓋掉了True:1的值

常用方法

• get -------- 通過key獲取value的值，注意：如果獲取不存在的key，返回的是None items
• tems--------- 獲取所有的鍵值對
• keys ---------- 獲取所有的鍵
• values ------- 獲取所有的值
• setdefault ---------- 設置默認值
• pop --------通過key值刪除鍵值對，如果沒有則拋出異常
• popitem ------ 刪除鍵值對，返回的是刪除的鍵值對，遵循的規則先進後出

集合 set

set是無序且不重復的數據類型，可以用於去重,因為set是無序的，所以無法直接訪問到當中的數據，一般需要轉換成其他數據類型來進行訪問

# 給定數據創建set
set_data = {1, 2}
# 創建空set，不能使用{}創建空set，因為{}只能用於創建空字典
set_data2 = set()
# 使用可迭代對象創建set，這個set為{'u', 'a', 'r', 'e', 'b', 'x', 's', 't'}
s = "uuuuaaaarrrreeeebbxssssttttt"
set_data = set(s)

常用方法：

• clear ---------- 清除
•  remove ------ 如果元素不存在會報錯
• add ------ 添加 ，添加重復的元素的時候不會報錯，但是不能成功添加，因為集合元素不能重復 difference ------- 差集
• intersection------- 交集 u
• union ---------------並集
• update ----- 更新意思 更新集合（合並集合）
• discard-------- 移除元素，移除不存在的元素的時候，不會報錯

二、常見運算符

1.算數運算符

• 加--------- +
• 減--------  -
• 乘 --------  *
• 冪次方 ------- **  
• 除 --------  /       Java C c++ 作為整除運算
• 整除 ------- //    地板除  只取整數的部分
• 求余------ %    取余數 模

2.比較（關系）運算符

返回值是boolean類型

• 大於 -------- >
• 小於--------- <
• 大於等於 -------- >=
• 小於等於 --------- <=
• 等於 ------ ==
• 不等於 -------!=

3.邏輯運算符

and ------ 與 且 一假則假              or --------- 或 一真則真            not ------- 非 一般與in關鍵字連用

4.賦值運算符

python裡沒有自加自減

• = 等於 a =10           
• a += 10 --------a = a + 10 
• a-=10  -----------a= a-10 
• a*=10-------------   a=a*10
• a/=10 ---------------a=a/10

5.位運算符

$a&$b按位與，$a和$b同為1的二進制位為1，有0的二進制位為0$a|$b按位或，$a和$b有1的二進制位為1，全0的二進制位為0$a^$b按位異或，$a和$b值不同的二進制位為1，值相同的二進制位為0~$a按位取反，$a為1的二進制位為0，為0的二進制位為1$a<<$b$a向左位移$b位，取決與操作系統的位數，位移後補零$a>>$b$a向右位移$b位，取決與操作系統的位數，位移後補零

 三、    for循環結構

for in ----- 遍歷容器  主要用於遍歷可迭代對象（python是一種數據類型------容器

for 變量 in 容器：

#縮進

#循環體

range()函數用法

range() ---------- 范圍的意思 ------ 前閉後開

range(參數) ---------------表示從0開始到參數結束打印此區間所有的整數，前閉後開

range(參數1，參數2)-------------表示打印參數1到參數2區間內的整數,前閉後開

range(參數1，參數2，step)------表示打印參數1到參數2區間內的整數,數據的變化隨step                                                            變化而 變化，默認的step的值為1,前閉後開     

break ------- ------跳出循環        continue ---------- ---------繼續循環

練習：

#0~100以內所有偶數和
sum = 0
# for i in range(101):
# if i % 2 == 0:
# sum += i
for i in range(0,101,2):
sum += i
print("0~100內偶數和是：",sum)

#打印菱形
layer = int(input("請輸入你要打印的行數："))
while layer % 2 == 0:
layer = int(input("對不起，您輸入的行數不正確，請輸入奇數："))
#上半部分
for i in range(1,layer//2+2): #前閉後開
#計算空格的個數
space_num = layer - i
for j in range(0,space_num):
print(" ",end="")
#計算*個數
star_num = 2*i-1
for j in range(0,star_num):
#判斷是不是第一個和最後一個位置或者最後一行
if j == 0 or j == star_num-1 or i == layer//2+1:
print("*",end="")
else:
print(" ",end="")
print("")
#下半部分
for i in range(layer//2,0,-1):
#計算空格的個數
space_num = layer - i
for j in range(0,space_num):
print(" ",end="")
#計算*個數
star_num = 2*i-1
for j in range(0,star_num):
#判斷是不是第一個和最後一個位置
if j == 0 or j == star_num-1:
print("*",end="")
else:
print(" ",end="")
print("")

思考：   __name__在Python中的作用?

答：當在有這個if條件句的模塊中時，該程序會作為程序的入口，__name__會強制改為__main__

當在其他模塊調用該模塊時，__name__的值是該模塊的文件名

Python中類的定義以及實例化過程如下：

class student(object):
__private = 1
def __init__(self, id, name, age, classnum):
self.id = id
self.name = name
self.age = age
self.classnum = classnum
print(self.__class__.__private)
@classmethod
def getprivate():
print(student.__private)
stu = student()
stu.__dict__
'''
上述代碼中，__init__()方法是Python中的構造方法，在實例化對象時會自動創建，不需要使用new關鍵字；
構造方法自帶參數self指針，指向所創建的對象，使得每個對象可以通過self指針創建自己的特征屬性；
student(object)，括號內的是class所繼承的父類，可以不寫，默認為object；
__private是類屬性，給定了值為1，不推薦在類中直接給定屬性值（實例化對象時，對象的屬性會從構造函數中開始，向類屬性查找，所以會影響性能），Python的封裝性不由private protected public關鍵字提現，Python中沒有這三個關鍵字，由__開頭的變量就是Python中的私有屬性；
類的構造函數可以顯示調用，即student.__init__(slef, id, name, age, classnum)，構造函數被顯示調用時會作為普通函數調用；
構造函數不能，也不需要有返回值；
stu.__dict__是以字典類型存儲的對象的屬性以及值，可以使用這個類型看到私有屬性在對象實例化之後的名字，可以通過這個名字修改私有屬性的值，但不推薦；
self.__class__.__private,在方法中獲得類屬性可以通過__class__關鍵字，每個對象的self指針都可以訪問；
@classmethod裝飾器，用這個注釋標明的方法是類方法，只有通過類名才能調用，不能通過對象來調用；
如果需要繼承父類的屬性，調用父類的構造函數，則需要使用super()方法，以super().__init__()的方式調用；
'''

四 、高階函數

1）匿名函數

使用lambda關鍵字修飾的簡單函數

lambda x,y: x>y?x:y

2）map(__func, __iter1)

使用__iter1迭代器執行__func函數

3）reduce(__func, __iter1)

使用__iter1迭代器執行__func函數，將上一次計算的結果作為下一次計算的參數

4）filter(__function,__iterable)

用__function函數過濾，__iterable中的元素

5）sorted(__iterable,key,reverse)

依據key的值排序__iterable中的元素，reverse決定是否逆序

五、迭代器和可迭代對象

迭代器是一個可迭代對象，可以循環遍歷其中的數據

可迭代對象是可迭代的容器，可以從中獲取迭代器

iterable可以使用iter(iterable)函數來獲取成迭代器

優先級genarator>iter>iterable

可迭代對象有：string list tuple dict set

六、閉包 

定義了函數和外部環境變量的結構為閉包，環境變量必須在函數外，且不可是全局變量，且外面一個函數的返回值是裡面一個函數 ，而不是調用參數 

# 如下格式的函數，都叫閉包
def demo1():
a = 3
def demo2(x):
return a*x
return demo2
aa = 10
a = demo1()
print(a)
# 查看是否是閉包，還可以通過a.__closure__[index].cell_contents查看閉包中每個元組的值
print(a.__closure__)
print(a(10))
# 閉包中引用循環變量，會先執行循環，當調用demo4()時，循環變量i已經變為了3，所以會返回999，而非1，4，9
def demo3():
fs = []
for i in range(1,4):
def demo4():
return i*i
fs.append(demo4)
return fs
a, b, c = demo3()
print(a())
print(b())
print(c())
# 結果都是9

七、生成器

介紹

通過列表生成式，我們可以直接創建一個列表。但是，受到內存限制，列表容量肯定是有限的。而且，創建一個包含100萬個元素的列表，不僅占用很大的存儲空間，如果我們僅僅需要訪問前面幾個元素，那後面絕大多數元素占用的空間都白白浪費了。

所以，如果列表元素可以按照某種算法推算出來，那我們是否可以在循環的過程中不斷推算出後續的元素呢？這樣就不必創建完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱為生成器：generator。

1.要創建一個generator，有很多種方法。第一種方法很簡單，只要把一個列表生成式的[]改成()，就創建了一個generator：

>>> L = [x * x for x in range(5)]
>>> L
[0, 1, 4, 9, 16]
>>> g = (x * x for x in range(5))
>>> g
<generator object <genexpr> at 0x1022ef630>

創建L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。

我們可以直接打印出list的每一個元素，但我們怎麼打印出generator的每一個元素呢？

如果要一個一個打印出來，可以通過next()函數獲得generator的下一個返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
Traceback (most recent call last):
File "<st

我們講過，generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤。但是由於一直調用next()過於麻煩，所以我們通過for循環來迭代它，這樣以一來就不需要關心StopIteration的錯誤。for循環無法實現的時候，還可以用函數來實現。

g = (x * x for x in range(10))
>>> for n in g:
... print(n)

2.將普通函數變成generator函數

如果一個函數定義中包含yield關鍵字，那麼這個函數就不再是一個普通函數，而是一個generator函數，調用一個generator函數將返回一個generator：

generator函數和普通函數的執行流程不一樣。普通函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

我們以斐波拉契數列 為例子如下：

普通寫法：

#斐波拉契數列
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'

改進寫法：

def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'

注意：調用generator函數會創建一個generator對象，多次調用generator函數會創建多個相互獨立的generator。