Python總結

一、注釋

單行注釋 #
多行注釋 """ """

二、運算符
1，算術運算符：

 + 加法運算符
- 減法運算符
* 乘法運算符
/ 除法運算符
% 求模（余）運算符
// 整除運算（地板除法）
** 冪次方

2，關系（比較）運算符

 >
<
>=
<=
==
!=

3，邏輯運算符

 與（並且） and
或（或者） or
非（取反） not

4，所屬運算符

in # 變量 in 容器
not in

5，賦值運算符

=
+= # a += 10 <==> a = a + 10
-=
*=
/=
//=
%=
**=

6，三目運算符：

表達式? 變量1 : 變量2
# 其他編程語言中的三目運算符
int a = 10 < 8 ? 20 : 40;
# python中
變量1 if 表達式 else 變量2

三、選擇結構

單分支
if 條件:
# 如果條件成立，則執行縮進後的代碼 
雙分支
if 條件:
# 如果條件成立，則執行if中的代碼
else:
# 如果條件不成立，則執行這兒（else）的代碼
多（三）分支
if 條件1:
# 如果條件1成立，則執行if中的代碼
elif 條件2:
# 如果條件1成立，則執行這兒的代碼
elif 條件3:
# 如果條件1成立，則執行這兒的代碼
……
[else:
# 剩余情況，執行這兒的代碼

四，循環結構

while循環
while 條件:
# 執行循環體
for循環
python的for循環，本質是一種for in結構的foreach循環，也就是是一種迭代結構
python提供的for循環，想法就是用來迭代可迭代對象（Iterable）的數據的遍歷的。
for 臨時變量 in Iterable:
# 每一次迭代的結果會保存在這個臨時變量中
print(臨時變量)

五、常見容器

列表（list）：
列表的定義：
有兩種方式：通過弱數據類型語言的特點完成
ls = [12,34,45,88,99]
第二種，就是調用一個全局函數
list()
list([元素1, 元素2, ……, 元素n])
set：
一般集合都是使用hash表實現，
無序且不重復！！！！
定義集合
s = {
值1, 值2,…… 值n} # set定義是，不能為空，為空表示一個空字典
ssss = set([1,2,3,4,45,5]) # 使用set函數完成list轉換為set
同樣的道理
list({
1,3,2,43,44,4,5}) # 將set轉換為list
元組（tuple）
固定的值，不可變數據類型，類似於java、C這些中枚舉類型
字典（dict）：
注意，python中的字段也是一個{
}形式，只是裡面的元素，不是一個個的值
而是一對鍵值對
d = {
"name": "張三", "age": 34, "nickname": "法外狂徒"}

六、函數

什麼是函數：
就是具有名稱的一個功能代碼的集合
python如何定義函數：
函數名稱的命名規范，遵循變量命名規范！！！！
def 函數名稱([參數列表]): # define function 定義函數
函數體
如果有返回值，則使用return關鍵字返回函數結果
return 返回值
調用函數：
函數名稱([實參列表]
局部變量（本地變量）：
定義在函數內部的變量叫做局部變量，作用域是當前函數
全局變量：
直接定義模塊（py文件）中的變量，叫做全局變量
return關鍵字：
值存在於函數內部，函數如果訪問到return關鍵字，則立刻返回

遞歸（recursion）：
本質是一種解決問題的方案。

七、切片：
切片是python提供，用來切割字符串的一種方式
切片不僅僅是針對字符串，有序序列（list、tuple、字符串）

字符串[下標]
字符串[start:end] # 切割字符串，注意：[start, end)，默認步長是1
字符串[start:end:step] # 切片操作時，指定步長
注意：注意，切片不會下標越界；
默認步長是1，可以指定，如果指定為正數，則表示從左向右切
但是如果指定為負數，表示從右向左切
如：s[::-1]，表示翻轉字符串的順序，類似於s.reverse()

八、內置模塊

 - math - random - os
- sys - datetime - date
- calendar - hashlib - hmac
等等

九、對象序列化
對象序列化：
對象：抽象概念
如果我們要傳輸對象，就需要將對象由邏輯概念轉換為真實存在的數據（字符串、字節）
對象反序列化：
將物理狀態的數據轉換為邏輯狀態

python提供了兩個對象序列化和反序列化的模塊
pickle：對象 <> 字節數據
json： 對象 <> json

pickle：
pickle.dump(obj, file)：對象持久化（先序列化，在持久化）
pickle.load(file)：反持久化，將數據從磁盤重新讀成對象

picke.dumps(obj)：對象序列化
pickle.loads(bytes)：反序列化對象

json模塊：
ison.dump(obj, file)：對象持久化（先序列化，在持久化）
ison.load(file)：反持久化，將數據從磁盤重新讀成對象

ison.dumps(obj)：對象序列化
ison.loads(bytes)：反序列化對象

十、面向對象
類（class）：對一些相似特性的事物的抽象總結，抽象概念。
對象（object）：一類事物的一個具體案例，實實在在的案例（實例）
定義類：
python定義類使用，class關鍵定義。

class 類名稱: # 類名稱的命名規范遵循大駝峰法
class 類名稱(父類):
class 類名稱(Object):

面向對象的三大特征：
封裝：

在面向對象中：
1、所有的面向對象相關功能，封裝在一個類裡面
2、在一個類中，將屬性私有化，外界不允許訪問屬性，
一般通過提供公開的方法（getter、setter）來訪問和設置
封裝的本質：就是對類中屬性的數據的保護，不允許外界非法訪問
只允許，通過提供的公開的方式來訪問數據！！！
將屬性私有化之後，如何在外界訪問該屬性？
1、直接提供get和set方法
2、將get和set再次包裝一把，之後使用類似於屬性的方法私有的屬性
3、使用@property的裝飾器完成封裝

class User(object):
def __init__(self):
# python中，在屬性名稱或者方法名稱前面加上__,表示私有化該屬性或者方法
# 此時在該類的外部，將無法訪問到私有的屬性和方法
self.__name = "劉建宏"
self.__age = 16
self.__gender = "男"
self.__email = "[email protected]"
self.__tel_phone = "110"
def get_name(self):
return self.__name
def set_name(self, name):
self.__name = name
def get_age(self):
return self.__age
def set_age(self, age):
self.__age = age
def say(self):
print("我叫{}，我說了句話".format(self.__name))
print("這句話，我不愛聽，所以我難過")
self.__cry()
def __cry(self):
"""該方法私有，私有的方法，就是在類內部使用的"""
print("我哭了，我很難過")
if __name__ == '__main__':
u1 = User()
# u1.say()
# print(u1.__name)
# u1.name = "劉帥哥"
# print(u1.name)
# 通過getter、setter訪問和設置屬性
print(u1.get_name())
u1.set_name("張秋碩")
u1.set_age(19)
print(u1.get_name())
print(u1.get_age())
# Python的封裝並不算特別完美
# print(u1._User__age)

繼承

後代會繼承先代的特征或者特征
子類會繼承父類的一些方法（父類允許繼承的方法）

class RichMan(object):
def __init__(self):
# 私有屬性無法繼承
self.__name = "阿爸"
self.money = 40000000
self.company = "alibaba"
def say(self):
print("哎，生意不好做啊，我對錢不感興趣，我最後悔的事，就是創建了公司")
def __tell(self):
print("這些是我的悄悄話，我不想任何人知道")
# python允許多繼承
class Son(RichMan, object):
pass
if __name__ == '__main__':
s = Son()
print(s.money)
print(s.company)
# print(s.__name)
s.say()
# s.__tell()

多態

面向對象中，多態：父類引用指向子類實例的現象！
ArrayList al = new ArrayList(); // 創建一個ArrayList對象
List list = new ArrayList(); // 父類引用指向子類實例的現象！！！

十一、python高級
生成器（generator）：
列表推導式，
優點：可以通過一段代碼，生成我們想要的列表數據，非常強大
缺點：如果數據量多的時候，直接生成數據，內存太大
因此python提供了新的列表生成方式，這個方式就是列表生成器

ls = []
def get_prime():
for i in range(2, 101):
flag = is_prime(i)
if flag:
# ls.append(i)
yield i # yield雖然看起來和return很像，但是注意，不一樣
def is_prime(num):
for j in range(2, num):
if num % j == 0:
# 不可能是質數
return False
return True
# res = get_prime()
# print(ls)
# print(res)
# print(next(res))
# print(next(res))
# for i in res:
# print(i)

生成器的遍歷：
使用for循環可以遍歷生成器
for 變量 in generator:
print(該變量每一次循環就是一個生成器的值)
第二種列表生成器的寫法：
如果列表推導式過於復雜，想使用這種方式[表達式]非常困難
針對於這種情況，一般使用函數來完成該列表的初始化

將函數轉換為列表生成，使用關鍵字yield
注意：當函數轉換為列表生成器時，函數的執行順序

迭代器（Iterator）：
可以通過next函數調用，並且返回下一個值的對象
可迭代對象（Iterable）：
能夠被循環調用，返回下一個值的，可迭代對象
字符串、列表、元組、字典、集合
閉包（closure）：
能夠方法函數內部的變量的函數，被稱為閉包

閉包：導致函數常駐內存，無法被釋放！！！！
局部變量全局化：避免了全局污染！！！

裝飾器：
裝飾者設計模式的體現，當我們對原有功能不能滿足的時候，
我們可以通過裝飾原有代碼，來實現代碼增強

 python提供的裝飾器（Decorator），就是強化和裝飾原有函數功能，
將函數功能加強的一種語法
python的裝飾器，它運行流程

十二、異常處理
非正常的一種軟件奔潰的現象，稱為異常
異常進行處理，本質是一種軟件的容錯性

抓捕異常：

 判斷代碼可能會出現異常
try:
可能出異常的代碼
except:
可能出現的異常

def main():
y_o_n = input("是否退出程序(y/n)?")
while y_o_n != "y":
print("請輸入一下信息，用空格分開")
input_str = input("性別 體重(kg) 身高(cm) 年齡： ")
str_list = input_str.split(" ")
try:
gender = str_list[0]
weight = float(str_list[1])
height = float(str_list[2])
age = int(str_list[3])
if gender == "男":
bmr = (13.7*weight)+(5.0*height)-(6.8*age)+66
elif gender == "女":
bmr = (9.6*weight)+(1.8*height)-(4.7*age)+655
else:
bmr= -1
if bmr!= -1:
print("你的性別：{}，體重：{}公斤，身高：{}厘米，年齡：{}歲".format(gender,weight,height,age))
print("你的基礎代謝率：{}大卡".format(bmr))
else:
print("暫時不支持該性別")
except ValueError:
print("請輸入正確信息")
except IndexError:
print("輸入信息量過少！")
except:
print("程序異常！")
print()
y_o_n=input("是否退出程序(y/n)?")
if __name__ == '__main__':
main()