Python中的注釋有以下三種
# 注釋1
'''多行注釋1'''
"""多行注釋2""
# 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。
# 創建元組並直接賦值
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_data = [1, 2, 3]
# 創建空列表
list_data = list()
list_data = []
# 使用可迭代對象創建列表
list_data = list((1, 2, 3))
# 列表可以嵌套
list_data = [[1, 2], 3]
字典是以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的值
常用方法
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)
返回值是boolean類型
and ------ 與 且 一假則假 or --------- 或 一真則真 not ------- 非 一般與in關鍵字連用
python裡沒有自加自減
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("")
答:當在有這個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。
[]
改成()
,就創建了一個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)
如果一個函數定義中包含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。