此筆記僅適用于有任一編程語言基礎(chǔ)，且對面向?qū)ο笥幸欢私庹哂^看

數(shù)據(jù)類型

字面量

字面量就是非變量，直接以值的方式存在于程序中

數(shù)字類型

• 整數(shù)
• 浮點
• 復(fù)數(shù)
• 布爾

數(shù)據(jù)容器

字符串

三種定義方式

str1 = 'str1'
str2 = "str2"
str3 = """str3"""

列表

在后面列一個章節(jié)介紹

元組

在后面列一個章節(jié)介紹

type()方法

將變量 or 自變量放入“()”內(nèi)，type()的返回值就是對應(yīng)數(shù)據(jù)類型

數(shù)據(jù)類型強轉(zhuǎn)

str = "123"# 這時str是字符串類型
str = (int)str# 這句話執(zhí)行完str就成了int類型

注釋

單行注釋

# 這是單行注釋
# #號和注釋間一般用一個空格隔開

多行注釋

"""這是多行注釋這是多行注釋這是多行注釋
"""

輸出

基本輸出

連續(xù)輸出，中間用“,”分隔

print(1,2,"3",4,5)#輸出逗號默認為空格

更復(fù)雜的輸出格式

• 輸出多個結(jié)果時，使用“,”分隔符

  print(1,2,3,sep=",")# 用分隔符“,”區(qū)分輸出結(jié)果
  

• 輸出不換行

  print(x,end="")
  print(y)
  

• %d、%s、%e的格式化輸出

  print('%d'%3.1415926)# 僅輸出整數(shù)部分
  print('%10s'%'Monday')# Monday右對齊,取十位，不夠則補位
  print('%.3e'%3.1415926)# 3.1415926取3位小數(shù)，用科學(xué)計數(shù)法計數(shù)
  print('%.2f'%4.1415)# 保留兩位小數(shù)
  

• format的輸出格式

  print('{}{}{}'.format
  ('Monday','Tuesday','Wednesday'))
  # 帶關(guān)鍵字
  # "and"拼接
  

• 自動格式化輸出

  a = 180
  b = "roland"
  print(f"{b}的身高{a}")
  

變量

定義

變量名 = 變量值

bianliang = 1

del方法

使一個變量恢復(fù)到未定義狀態(tài)

標識符

python中只支持：

• 英文
• 中文
• 數(shù)字
• 下劃線 “_”

這四類元素

且，

• 不推薦中文
• 數(shù)字不能在開頭
• 區(qū)分大小寫

運算符

加：+
減：-
乘：*
除：/ (計算完自動轉(zhuǎn)化成浮點型)
整除：//
取余：%
指數(shù)：**

比較運算符

運算符	作用
>	大于
<	小于
==	等于
!=	不等于
>=	大于等于
<=	小于等于

邏輯運算符

邏輯運算符	功能
and	與運算
or	或運算
not	非運算

輸入

input()

傳參是字符串，此函數(shù)執(zhí)行時會打印括號內(nèi)的內(nèi)容，并等待鍵盤的輸入。接收完輸入后會以字符串的形式返回程序

正常輸入

x = int (input("請輸入梯形的上底長度"))

連續(xù)輸入

#多數(shù)據(jù)輸入中間用空格間隔
x,y,z=map(int,input(“請輸入梯形的上下底長和
高“).split())
#多數(shù)據(jù)輸入中間用逗號間隔
x,y,z=map(int,input(“請輸入梯形的上下底長和
高”).split(”,"))

控制語句

縮進為四個空格！！！

自上而下的控制語句

if條件語句

特點：if后條件不需要用空格包住，
用:代替{}
else if 變成elif

if 1>2:print("數(shù)學(xué)崩塌了")
elif 1>3:print("數(shù)學(xué)真崩塌了")
else:print("數(shù)學(xué)還是正常的")

循環(huán)語句

for循環(huán)

for 臨時變量 in 序列類型：
執(zhí)行語句

序列類型指，其內(nèi)容可以一個個依次取出的一種類型，包括【字符串 列表 元組 ……】

Python的for循環(huán)是一個輪詢的機制，輪詢 in 后的列表

name = "Roland"
for x in name:print(x)"""輸出結(jié)果如下：
R
o
l
a
n
d
"""

理論上Python中的for循環(huán)無法構(gòu)成無限循環(huán)（序列類型(被處理的數(shù)據(jù)集)不可能無限大）

range()

• 語法1

  range(5)# 獲得一個從0到5（不含5）的數(shù)字序列（0,1,2,3,4）
  

• 語法2

  range(1,5)# 獲得一個從1到5（不含5）的數(shù)字序列（1,2,3,4）
  

• 語法3

  range(1,10,2)# 獲得一個從1到10（不含10）,步長為2的數(shù)字序列（1,3,5,7,9）
  

將range融合進for循環(huán)

for i in range(1,10,2):print (i)

for循環(huán)臨時變量作用域

實際上可以在外部訪問

但在編程規(guī)范上，不允許

while循環(huán)

i = 6
while(i > 0):print("i = ",i)i--

break

跳出循環(huán)

continue

中斷本次循環(huán)，進入下次循環(huán)

如果沒有下次了，那就跳出循環(huán)

else

在 python 中，while … else 在循環(huán)條件為 false 時執(zhí)行 else 語句塊：

count = 0
while count < 5:print count, " is  less than 5"count = count + 1
else:print count, " is not less than 5"'''----------------------------------------------'''
# 注意，break退出循環(huán)不會觸發(fā)else
count = 0
while count < 5:print count, " is  less than 5"count = count + 1break
else:print count, " is not less than 5"

函數(shù)

定義函數(shù)

def 函數(shù)名 (參數(shù)列表):
函數(shù)體
return 返回值

# 此函數(shù)根據(jù)傳參大小，打印Hello n次，并返回"Over"
def SayHello(n):# 傳參列表可以空著for i in range(n):print("Hello")return "Over" #可以不寫return，不寫return就是等于寫了一個 return None

調(diào)用函數(shù)

print(SayHello(3))# 打印三次Hello

傳參

位置參數(shù)

就是c語言的傳參機制

關(guān)鍵字參數(shù)

即函數(shù)調(diào)用時通過 “鍵 = 值”形式傳遞參數(shù)

作用：可以讓函數(shù)更加清晰、更容易使用，同時也清除了參數(shù)的順序需求

def user_info(name,age,gender):print(f"您的名字為{name},年齡為{age},性別是{gender}")user_info(name = "Roland", age = 3, gender = "男")
user_info(name = "Roland", gender = "男", age = 3)
user_info(age = 3, gender = "男", name = "Roland") 
#上面三次調(diào)用都是一樣的傳參效果

位置參數(shù)和關(guān)鍵字參數(shù)混用

def user_info(name,age,gender):print(f"您的名字為{name},年齡為{age},性別是{gender}")user_info(name = "Roland", age = 3, gender = "男")
user_info("Roland", gender = "男", age = 3)
#上面三次調(diào)用都是一樣的傳參效果

缺省參數(shù)

也叫默認參數(shù)，意思就是為參數(shù)提供默認值，如果傳參沒有傳該參數(shù)，則函數(shù)自己使用默認的參數(shù)，如果有傳，則使用傳參

def user_info(name,age,gender = "男"):print(f"您的名字為{name},年齡為{age},性別是{gender}")user_info("Roland",age = 3)
user_info("Rose",18,"女")

可變參數(shù)（不定長）

位置傳遞不定長

def user_info(*args):# 這里注意下，args是一個默認的慣例，可以叫別的，但最好叫這個

傳進的參數(shù)都會被 *args接收，作為一個元組存儲，這也叫做位置傳遞

關(guān)鍵字傳遞不定長

def user_info(**kwargs):# 這里注意下，kwargs是一個默認的慣例，可以叫別的，但最好叫這個

傳進的參數(shù)都會被 **kwargs接收，作為一個字典存儲，這也叫做關(guān)鍵字傳遞，所以傳遞的參數(shù)得以字典的形式

多個返回值

# 此函數(shù)根據(jù)傳參大小，打印Hello n次，并返回"Over"
def SayHello(n):# 傳參列表可以空著for i in range(n):print("Hello")return "Over",6 # 多個返回值之間用逗號分隔a,b = SayHello(3)# 接收多個返回值也是用逗號分隔
print(a,b)

函數(shù)作為傳參

函數(shù)1作為參數(shù)傳遞給函數(shù)2，其實函數(shù)2寫來就是為了讓使用者傳遞一個函數(shù)1，然后有函數(shù)2來調(diào)用。

當(dāng)然，函數(shù)1所賦予的傳參是由函數(shù)2給的，并不是使用者

這算是傳入計算邏輯，而非傳入數(shù)據(jù)

挺繞的，自己寫了就清楚了

# 對1和2進行計算，至于怎么計算，根據(jù)傳入的函數(shù)決定
def calc_1_and_2(Handle):x = Handle(1,2)return x#計算a+b
def math_plus(a,b):return a+b#計算a-b
def math_minus(a,b):return a-bprint(calc_1_and_2(math_plus))
print(calc_1_and_2(math_minus))

匿名函數(shù)

介紹

函數(shù)的定義中

• def關(guān)鍵字，可以定義帶有名稱的函數(shù)，可重復(fù)使用
• lambda關(guān)鍵字，可以定義匿名函數(shù)（無名稱），只可臨時使用一次
• 可以用來測試某個參數(shù)是函數(shù)的函數(shù)的功能

基本語法

lambda 傳入?yún)?shù):函數(shù)體 # 注意函數(shù)體內(nèi)只能寫一行

演示案例

def test_func(computer):result = computer(1,2)print(result)test_func(lambda x,y: x + y)# 在這里就是把新定義的匿名函數(shù)的邏輯傳給了test_func

數(shù)據(jù)容器

概述

一種可以同時存儲多個(種)元素的python數(shù)據(jù)類型

根據(jù)是否支持重復(fù)元素、是否可以修改、是否有序等，分為5類：

• 列表(list)
• 元組(tuple)
• 字符串(str)
• 集合(set)
• 字典(dict)

數(shù)據(jù)容器變量名是指針：也就是先定義了list1，然后list2=list1，則修改list1后，list2內(nèi)容也是同步變化的

列表(list)

介紹

列表內(nèi)的每一個數(shù)據(jù)稱為元素

列表中可以存儲不同的數(shù)據(jù)類型

列表中可以存儲相同的數(shù)據(jù)

說白了就是數(shù)組Pro

基本語法

# 字面量
# [元素1，元素2，元素……]# 定義變量
# 第一種
myList = [1, 2, 3, 4, 5]
# 第二種
myList = [i for i in range(1, 6)]
# 上面兩個結(jié)果一致# 定義空列表
myList = []
myList = list()# 列表嵌套
myList = [列表1,列表2]

案例演示

my_list = ["Roland", 3, True]
print(type(my_list))
print(my_list)
my_list_list = [my_list,["Roland", 3, False]]
print(my_list_list)

列表下標(索引)

my_list = ["Roland", 3, True]
# 正向索引
print(my_list[0],my_list[1],my_list[2])
# 反向索引(-1是倒數(shù)第一個，-2是倒數(shù)第二)
print(my_list[-1],my_list[-2],my_list[-3])

列表方法

查詢某元素下標

列表對象.index(元素)

案例演示

my_list = ["Roland", 3, True]
print(my_list.index(3))

修改對應(yīng)下標的元素值

同數(shù)組的修改元素方式，我覺得不應(yīng)該叫方法

在指定下標插入新元素

列表對象.insert(下標,元素)

案例演示

my_list = ["Roland", 3, True]
my_list.insert(1,2)
print(my_list)

追加元素

列表對象.append(元素)# 將新元素追加到列表尾部
列表對象.extend(其他數(shù)據(jù)容器)# 將其他數(shù)據(jù)容器內(nèi)容取出，依次追加到列表尾部

案例演示

my_list = ["Roland", 3, True]
my_list.append(2)
print(my_list)
my_list2 = ["Steve", 2, False]
my_list.extend(my_list2)
print(my_list)

刪除指定下標元素

del 列表[下標]
列表對象.pop(下標)

案例演示

my_list = ["Roland", 3, True]
my_list.pop(2)
print(my_list)my_list2 = ["Steve", 2, False]
del my_list2[0]
print(my_list2)

刪除某元素在列表的第一個匹配項

列表對象.remove(元素)

案例演示

my_list = ["Roland", 3, True]
my_list.remove(3)
print(my_list)

清空列表

列表對象.clear()

案例演示

my_list = ["Roland", 3, True]
my_list.clear()
print(my_list)

統(tǒng)計某元素在列表中數(shù)量

列表對象.count(元素)

案例演示

my_list = ["Roland", 3, True]
print(my_list.count(True))

統(tǒng)計列表中所有元素數(shù)量

len(列表對象)

案例演示

my_list = ["Roland", 3, True]
print(len(my_list))

排序

list.sort(cmp=None, key=None, reverse=False) # reverse=true:降序

列表拼接

元組(tuple)

介紹

元組與列表的唯一區(qū)別——不可修改

基本語法

# 定義元組字面量
(元素,元素,……)# 定義元組變量
變量名稱 = (元組,元組,……)# 定義單元素元組變量(要寫個逗號)
變量名稱 = (元組,)# 定義空元組
變量名稱 = ()
變量名稱 = tuple() # 元組嵌套

元組方法

• index
• count
• len

字符串(str)

簡介

字符串時字符的數(shù)據(jù)容器，只能存字符

不可修改的

基本語法

# 通過下標取值
mystr = "Roland"
print(mystr[3])

字符串方法

• .index 這里注意下，index不只是只能查單個字符的位置，也可以查一個小字符串出現(xiàn)的起始下標

• .replace(字符串1，字符串2) 將調(diào)用此方法的字符串中的字符串1替換成字符串2，并以返回值的方式返回(需要一個新的變量來接收)

• .split(“分隔符字符串”) 將調(diào)用此方法的字符串用分割字符串分割成多個元素，并存入一個列表，并以返回值的方式返回(需要一個新的變量來接收)

  # 這個方法不好描述，直接上代碼
  myStr = "Hello this is Roland"
  mylist = myStr.split(" ")
  print(mylist)
  

• .strip() 字符串規(guī)整操作，去除字符串的前后空格。傳參還可以傳入字符串，意思就是去除原字符串的前后被傳入的字符串，當(dāng)然還是將新字符串以返回值的方式返回

• .count

• len

數(shù)據(jù)容器的切片

序列

內(nèi)容連續(xù)、有序，可使用下標索引的一類數(shù)據(jù)容器(列表、元組、字符串)

切片

從一個序列中取出一個子序列

語法：序列[起始下標:結(jié)束下標]
序列[起始下標:結(jié)束下標:步長]

arr[::-1] # 將數(shù)據(jù)容器內(nèi)容倒序

注意：

• 不含結(jié)束下標
• 步長為負數(shù)表示反向取，呢么起始下標和結(jié)束下標也要反向標記
• 是以返回值的方式返回新的序列
• 傳參不傳步長的話就是默認步長為1

集合(set)

介紹

• 無序、無下標
• 不可重復(fù)
• 可不同數(shù)據(jù)類型
• 可修改
• 支持for循環(huán)不支持while循環(huán)遍歷

基本語法

# 定義集合字面量
{元素,元素,……}# 定義集合變量
變量名稱 = {元素,元素,……}# 定義空集合
變量名稱 = set()

集合方法

• .add(元素) 將指定元素添加到自身集合內(nèi)
• .remove(元素) 刪除指定元素
• .pop()隨機取一個元素通過返回值返回，同時刪除此元素
• .clear()
• 集合1.difference(集合2) 取兩個集合的差集，將新集合返回，原集合不發(fā)生變化
• 集合1.difference_update(集合2) 在集合1內(nèi)，刪除和集合2相同的元素。集合1可能發(fā)生變化，集合2不變
• 集合1.union(集合2) 將集合1和集合2合并，并以返回值的方式返回新集合
• len(集合) 統(tǒng)計集合元素數(shù)量

遍歷集合

由于集合沒有下標，所以不能用while()遍歷

可以用for循環(huán)遍歷，但不能保證遍歷順序

myset = {1,2,5,6}
for i in myset:print(i)

字典(dict)

介紹

生活中的字典：【字】：含義

Python中的字典：【Key】：value

• 無序、無下標
• Key 不可重復(fù)(重復(fù)添加等于覆蓋原有數(shù)據(jù))
• 值可以取任何數(shù)據(jù)類型，但鍵必須是不可變的，如字符串，數(shù)字或元組。
• 可修改
• 支持for循環(huán)，不支持while循環(huán)遍歷

基本語法

# 字面量
{key:value, key:value, ……}
# 變量
mydict = {key:value, key:value, ……}
# 空字典
my_dict = {}
my_dict = dict()# 從字典中基于Key獲取Value
my_dict = {"Roland":180,3:170,"Rola":160}
print(my_dict["Roland"])# 字典的嵌套(Key不可為字典)
score = {"高數(shù)":100,"大英":99,"離散":100}
student = {"Roland":score}
print(student)
print(student["Roland"])
print(student["Roland"]["高數(shù)"])

常用操作

• 新增/更新元素

  my_dict = {	"Roland":180,"Steve":170}
  my_dict["Rola"] = 160 # 第一次使用表示新增Rola這個Key，Value為160
  print(my_dict)
  my_dict["Rola"] = 150 # 第二次使用表示修改Rola這個Key，Value為150 
  print(my_dict)
  

• .pop(key) 獲得指定Key的Value，通過返回值返回，同時刪除這個key和對應(yīng)的value

• .clear() 清空字典

• .keys() 獲取所有的key（不含value）

• len(字典) 獲取字典中key的數(shù)量

• .get(key) 獲取key的值

遍歷字典

my_dict = {	"Roland":180,"Steve":170,"Rola":160}
keys = my_dict.keys()
for key in keys:print(key)
for key in my_dict:# 其實這種寫法和上面的的for一樣，都是拿出my_dict中的所有keyprint(key)

容器通用函數(shù)

• len
• max
• min

迭代器和生成器

迭代器

簡介

迭代器（interation）是一個可以記住遍歷的位置的對象。

迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結(jié)束。迭代器只能往前不會后退。

創(chuàng)建迭代器

# 使用iter方法創(chuàng)建
myList = [0, 1, 2, 3, 4]
myIter = iter(myList) # 等效下一行代碼
myIter = iter([i for i in range(5)]) # 等效上一行代碼

迭代迭代器

# 先創(chuàng)建一個迭代器
myIter = iter([i for i in range(5)])# 使用next方法進行迭代，每執(zhí)行一次next，迭代一次，當(dāng)超出了迭代返回，會由一個 StopIteration 異常結(jié)束程序
print (next(myIter))
print (next(myIter))
print (next(myIter))
print (next(myIter))
print (next(myIter))
print (next(myIter))

生成器

簡介

生成器（generator）是使用了 yield 的函數(shù) 或是 由循環(huán)表達式生成的。

沒錯，所有函數(shù)都能成為生成器，只需要在函數(shù)內(nèi)部寫到 yield 關(guān)鍵字

生成器函數(shù)還包括以下內(nèi)容：

• 通用生成器
• 協(xié)程生成器
• 委托生成器
• 子生成器

創(chuàng)建生成器

生成器有兩種創(chuàng)建方式表示：

• 生成器表達式

  # 生成器表達式是用圓括號來創(chuàng)建生成器
  myGenerator = (i for i in range(5)) # 與列表的創(chuàng)建很想，是把方括號改成圓括號
  

• 生成器函數(shù)

  # 創(chuàng)建 生成器函數(shù)
  def countdown(n):while n > 0:yield nn -= 1# 創(chuàng)建生成器對象
  generator = countdown(5)
  

迭代生成器

 # 創(chuàng)建 生成器函數(shù)
def countdown(n):while n > 0:yield nn -= 1# 創(chuàng)建生成器對象
generator = countdown(5)# 通過迭代生成器獲取值
print(next(generator))  # 輸出: 5
print(next(generator))  # 輸出: 4
print(next(generator))  # 輸出: 3# 使用 for 循環(huán)迭代生成器
for value in generator:print(value)  # 輸出: 2 1

Python3 內(nèi)置函數(shù)

zip

zip() 函數(shù)用于將可迭代的對象作為參數(shù)，將對象中對應(yīng)的元素打包成一個個元組，然后返回由這些元組組成的對象

我們可以使用 list() 轉(zhuǎn)換來輸出列表。

enumerate

enumerate() 函數(shù)用于將一個可遍歷的數(shù)據(jù)對象(如列表、元組或字符串)組合為一個索引序列，同時列出數(shù)據(jù)和數(shù)據(jù)下標，一般用在 for 循環(huán)當(dāng)中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
print(list(enumerate(seasons, start=1)))# 下標從 1 開始

文件操作

文件編碼

編碼技術(shù)即翻譯的規(guī)則

如：

• UTF-8

• GBK

• Gig5

文件基礎(chǔ)操作

打開文件

"""name：要打開的目標文件名的字符串mode:設(shè)置打開文件的模式(訪問模式)：只讀、寫入、追加等r:只讀w:只寫，清空文件，從頭開始編輯；如果文件不存在，則創(chuàng)建新文件a:追加新內(nèi)容寫到已有內(nèi)容之后；如果文件不存在，則創(chuàng)建新文件encoding：編碼格式(字符串)
"""
open（name, mode, encoding）# 打開一個已存在的文件，或者創(chuàng)建一個新文件；并返回一個文件對象，可以理解成C語言中的FILE類型變量#示例
f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")# 這里要注意，encoding在函數(shù)定義處不是第三位傳參，所以要用關(guān)鍵字傳參

關(guān)閉文件

• .close()方式

  f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
  f.close()# 解除文件占用
  

• with open語法

  with open("F:\Pyworks\Demo1\demo.txt","r") as f:print(f.readlines())
  # 通過在with open的語句塊中對文件進行操作
  # 可以在操作完成后自動close文件，避免遺忘掉close方法
  

讀操作

• 文件對象.read(num) 從文件對象中讀取指定長度的內(nèi)容(num的單位是字符個數(shù)，如果不寫num，則效果等于readlines() )(這里注意，讀取的時候是有個指針的概念的，一開始指針指向第一個字符，假設(shè)第一次讀取到第4個字符(第4未讀出)，則下次讀取是從第4個字符開始)
• 文件對象.readline() # 按照行的方式對文件內(nèi)容讀取一行，并返回一個字符串
• 文件對象.readlines() # 按照行的方式對文件內(nèi)容進行一次性讀取，并返回一個列表，文件中每行數(shù)據(jù)作為一個元素

# 示例1
f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
print(f.read(10))# 示例2
f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
print(f.readlines())

for循環(huán)遍歷文件內(nèi)容

f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
for line in f: # 每次循環(huán)會從文件中拿一行數(shù)據(jù)以字符串形式給到lineprint(line)

寫操作

# 只寫的方式打開文件
f = open("F:\Pyworks\Demo1\demo.txt","w",encoding="UTF-8")
# 寫入文件
f.write("你好世界")# 寫入Python程序緩沖區(qū)
# 內(nèi)容刷新（即Ctrl-S保存操作），可以不要這個內(nèi)存刷新，當(dāng)f.close被執(zhí)行后或者程序關(guān)閉了，也是會自動刷新的
f.flush()# 真正寫入文件中

# 追加的方式打開文件
f = open("F:\Pyworks\Demo1\demo.txt","a",encoding="UTF-8")
# 寫入文件
f.write("你好世界")# 寫入Python程序緩沖區(qū)
# 內(nèi)容刷新（即Ctrl-S保存操作），可以不要這個內(nèi)存刷新，當(dāng)f.close被執(zhí)行后或者程序關(guān)閉了，也是會自動刷新的
f.flush()# 真正寫入文件中

CSV文件

import csvfilename='C:\\Users\\lenovo\\Desktop\\parttest.csv'
data = []
with open(filename) as csvfile:csv_reader = csv.reader(csvfile)  # 使用csv.reader讀取csvfile中的文件#header = next(csv_reader)        # 讀取第一行每一列的標題for row in csv_reader:            # 將csv 文件中的數(shù)據(jù)保存到data中data.append(row[5])           # 選擇某一列加入到data數(shù)組中

異常

介紹

即bug，程序跑到某個位置時，編譯器無法繼續(xù)運行下去

捕獲異常

是什么

世上沒有完美的程序

我們要做的，不是力求程序完美運行，而是在力所能及的范圍內(nèi)，對可能出現(xiàn)的bug進行提前準備、提前處理

這種行為稱為：異常處理：（捕獲異常）

為什么

當(dāng)程序遇到BUG時，接下來有兩種情況：

1. 整個程序停止
2. 對BUG進行提醒，整個程序繼續(xù)運行

沒有捕獲異常的時候，程序是以 情況1 的方式處理bug的

但是在真實應(yīng)用場景時，不可能因為一個bug就讓程序停了，所以我們就需要捕獲異常來實現(xiàn) 情況2

怎么做

• 基本捕獲語法

  try:可能發(fā)生錯誤的代碼
  except：如果出現(xiàn)異常 執(zhí)行的代碼
  

• 捕獲指定的異常

  try:print(a)
  except NameError as e:# 這個e就是異常的對象，也就是系統(tǒng)自帶的異常解釋信息；可以不寫as e，就是不接收異常對象罷了print("出現(xiàn)了變量未定義的異常")print(e)
  

• 捕獲多個異常

  try:print(1/0)
  except(NameError,ZeroDivisionError):print("ZeroDivision錯誤…")
  

• 捕獲所有異常并獲取異常信息

  try:print(1/0)
  except Exception as e:print(e)
  

異常else

else表示沒有異常的話要執(zhí)行的代碼

try:print(1/0)
except Exception as e:print(e)
else:print("沒有異常~")

異常finally

finally表示無論有沒有異常都要執(zhí)行里面的代碼

try:print(1/0)
except Exception as e:print(e)
else:print("沒有異常~")
finally:print("離開異常判斷區(qū)域")

異常傳遞

介紹

異常是具有傳遞性的

看看代碼

def func1():return 1/0def func2():return func1()try:print(func2())
except:print("發(fā)現(xiàn)異常")

上述代碼中func1中 0 作為除數(shù)會報異常，如果func1中沒有處理這個異常的話，異常會傳遞到func2；如果func2也沒有捕獲異常的話，異常最終會傳遞到主程序中，如果主程序也沒有捕獲，那程序就停止了

模塊

介紹

就是C語言的.c文件，在python中是一個.python文件，里面有定義好的函數(shù)，類，變量。

就是個工具包，直接拿過來用

導(dǎo)入模塊

[from 模塊名] import [模塊 | 類 | 變量 | 函數(shù) | *|] [as 別名]
“[]”括起來的是可選的意思 “|” 是選其一的意思

常見的組合形式：

• import 模塊名
• import 模塊名1,模塊名2
• import 模塊名 as 別名
• from 模塊名 import 類|變量|方法
• form 模塊名 import *
• form 模塊名 import 類|變量|方法 as 別名

使用import導(dǎo)入需要通過 . 才能使用全部功能，比如time.sleep()

使用from導(dǎo)入直接就能使用全部功能，比如sleep()

當(dāng)導(dǎo)入不同模塊的時候，如果有重名的函數(shù)之類的，程序會優(yōu)先調(diào)用最后一次導(dǎo)入的

name變量

如果導(dǎo)入的模塊內(nèi)有可立即執(zhí)行代碼，則程序運行import的時候就會直接執(zhí)行模塊內(nèi)的代碼，如下

"""這是模塊文件.python"""
def test(a,b):return a+btest(a+b)

"""主程序文件.python"""
import 這是模塊文件print("主程序")

如果不想執(zhí)行模塊內(nèi)的代碼呢？

這里就需要在模塊內(nèi)部的可執(zhí)行代碼前加?xùn)|西了

"""這是模塊文件.python"""
def test(a,b):return a+bif __name__ == '__main__': # __name__ 是一個Python內(nèi)置變量，當(dāng)我們運行某個.python文件是，該.python文件內(nèi)的 __name__ 就會被賦值為 '__main__' 可以理解成Python的入口文件，很類似c語言的int main(){}test(a+b)

"""主程序文件.python"""
import 這是模塊文件print("主程序")

all變量

如果一個模塊文件中有 all 變量，當(dāng)使用 from xxx import * 導(dǎo)入的時候，只能導(dǎo)入在這個列表中的元素

"""這是模塊文件.python"""
__all__ = ['test_a'] # 這時候如果 from 這是模塊文件 import * 的話，只能使用test_a函數(shù),用其他導(dǎo)入語句的話就沒關(guān)系，不用看這個all
def test_a(a,b):return a+bdef test_b(a,b):return a-b

"""主程序文件.python"""
import 這是模塊文件print("主程序")
test_a(1,2)
test_b(1,2)

自定義模塊

創(chuàng)建

只需要新建.python文件，定義對應(yīng)函數(shù)，就可以了

導(dǎo)入

在同一個文件夾直接import或者from文件名就可以

包

介紹

模塊可以理解成文件，包就是文件夾

相較于文件夾，包還多了一個叫 __init__.python 的文件，有了這個文件，文件夾才叫做包

創(chuàng)建包

1. 新建文件夾
2. 新建文件 __init__.python
3. 好了

導(dǎo)入包

• 方式一

  import 包名.模塊名# 導(dǎo)入
  包名.模塊名.目標 # 使用
  

• 方式二

  from 包名 import 模塊名# 導(dǎo)入
  模塊名.目標# 使用
  

init.python文件

 __all__  = ['my_module1']#此時如果使用import *這個包時，就只能使用my_module1這個模塊

第三方包

如何安裝第三方包

1. 進入cmd
2. 輸入pip install 包名
   也可以pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
   沒有科學(xué)上網(wǎng)的話第二個可以改善下載速度

pyecharts模塊

介紹

可以做出數(shù)據(jù)可視化效果圖的一個模塊

本體是 Echarts 框架，Echarts是百度開源的數(shù)據(jù)可視化框架，而pyecharts模塊是專為Python設(shè)計的模塊

官方網(wǎng)站

安裝：pip install pyecharts

快速入門

簡單的畫一個圖

# 導(dǎo)包，導(dǎo)入Line功能構(gòu)建折線圖對象
from pyecharts.charts import Line# 得到折線圖對象
line = Line()# 添加x軸數(shù)據(jù)
line.add_xaxis(["中國","美國","日本"])# 添加y軸數(shù)據(jù)
line.add_yaxis("GDP",[30,20,10])#生成圖標
line.render()

全局配置

set_global_opts()

該方法可配置的基礎(chǔ)配置(所謂基礎(chǔ)配置即無論是什么圖都會有的配置)如下：

不學(xué)了，沒用

Numpy模塊

[官方鏈接](NumPy 介紹 | NumPy)

基礎(chǔ)知識

NumPy的主要對象是同構(gòu)多維數(shù)組。它是一個元素表（通常是數(shù)字），所有類型都相同，由非負整數(shù)元組索引。在NumPy維度中稱為軸 。

NumPy的數(shù)組類ndarray被調(diào)用。它也被別名 array所知。請注意，numpy.array這與標準Python庫array.array類不同，后者只處理一維數(shù)組并提供較少的功能。ndarray對象更重要的屬性是：

• ndarray.ndim - 數(shù)組的軸（維度）的個數(shù)。在Python世界中，維度的數(shù)量被稱為rank
• ndarray.shape - 數(shù)組的維度。這是一個整數(shù)的元組，表示每個維度中數(shù)組的大小。對于有 n 行和 m 列的矩陣，shape 將是 (n,m)。因此，shape 元組的長度就是rank或維度的個數(shù) ndim
• ndarray.size - 數(shù)組元素的總數(shù)。這等于 shape 的元素的乘積
• ndarray.dtype - 一個描述數(shù)組中元素類型的對象?？梢允褂脴藴实腜ython類型創(chuàng)建或指定dtype。另外NumPy提供它自己的類型。例如numpy.int32、numpy.int16和numpy.float64。
• ndarray.itemsize - 數(shù)組中每個元素的字節(jié)大小。例如，元素為 float64 類型的數(shù)組的 itemsize 為8（=64/8），而 complex32 類型的數(shù)組的 itemsize 為4（=32/8）。它等于 ndarray.dtype.itemsize 。
• ndarray.data - 該緩沖區(qū)包含數(shù)組的實際元素。通常，我們不需要使用此屬性，因為我們將使用索引訪問數(shù)組中的元素

創(chuàng)建數(shù)組

# 使用array函數(shù)從常規(guī)Python列表或元組中創(chuàng)建數(shù)組
import numpy as npy# 一維數(shù)組
a = npy.array([2,3,4]) 
print(a)# 二維數(shù)組
b = npy.array([[1,2,3],[4,5,6],[7,8,9]])
print(b)# 在創(chuàng)建時顯示指定數(shù)組的類型
c = npy.array([6,6,6], dtype=complex)# complex是虛數(shù)
print(c)# 創(chuàng)建一個全是0的數(shù)組
d = npy.zeros([3,4])
print(d)# 創(chuàng)建一個全是1的數(shù)組
e = npy.ones([3,4], dtype=npy.int16)
print(e)# 創(chuàng)建一個數(shù)組，其初始內(nèi)容是隨機的，取決于內(nèi)存的狀態(tài)。(dtype默認是float64)
f = npy.empty([3,4])
print(f)# 創(chuàng)建整數(shù)組成的數(shù)組
g = npy.arange(10,100,20) #從10到100，步長為20
print(g)# 創(chuàng)建浮點數(shù)組成的數(shù)組
h = npy.linspace(0,2,9) # 獲取0到2之間的9個數(shù)# 根據(jù)π做一些操作
from numpy import pi
i = npy.linspace(0,2*pi,100) # 獲取0到2π間的100個數(shù)
print(i)
j = npy.sin(i) # 將數(shù)組i中的所有元素進行正弦轉(zhuǎn)化
print(j)

打印數(shù)組

numpy中的數(shù)組有一定的固定布局：

• 最后一個軸從左到右打印，
• 倒數(shù)第二個軸從上到下打印，
• 其余軸也從上到下打印，每個切片用空行分隔

即

[[[ 0  1  2  3][ 4  5  6  7][ 8  9 10 11]][[12 13 14 15][16 17 18 19][20 21 22 23]]]

如果數(shù)組太大而無法打印，NumPy會自動跳過數(shù)組的中心部分并僅打印角點：

>>> print(np.arange(10000))
[   0    1    2 ..., 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100,100))
[[   0    1    2 ...,   97   98   99][ 100  101  102 ...,  197  198  199][ 200  201  202 ...,  297  298  299]...,[9700 9701 9702 ..., 9797 9798 9799][9800 9801 9802 ..., 9897 9898 9899][9900 9901 9902 ..., 9997 9998 9999]]

要禁用此行為并強制NumPy打印整個數(shù)組，可以使用更改打印選項set_printoptions。

>>> np.set_printoptions(threshold=sys.maxsize)     

基本操作

數(shù)組上的算術(shù)運算符會應(yīng)用到 元素 級別。即所有的元素都會收到運算符的影響

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a < 35 # 比較運算符都可以
array([ True, True, False, False])>>> A = np.array( [[1,1],
...             [0,1]] )
>>> B = np.array( [[2,0],
...             [3,4]] )
>>> A * B                       # 乘積運算符
array([[2, 0],[0, 4]])

與許多矩陣語言不同，乘積運算符*在NumPy數(shù)組中按元素進行運算。即 a_ij * b_ij

而矩陣乘積是使用@或者 dot函數(shù)

>>> A = np.array( [[1,1],
...             [0,1]] )
>>> B = np.array( [[2,0],
...             [3,4]] )>>> A @ B                       # matrix product
array([[5, 4],[3, 4]])
>>> A.dot(B)                    # another matrix product
array([[5, 4],[3, 4]])                       

當(dāng)使用不同類型的數(shù)組進行操作時，結(jié)果數(shù)組的類型對應(yīng)于更一般或更精確的數(shù)組（稱為向上轉(zhuǎn)換的行為）。

許多一元操作，例如計算數(shù)組中所有元素的總和，都是作為ndarray類的方法實現(xiàn)的。

• 注意，以下幾個方法有個傳參叫axis，axis = 0表示對列進行操作，axis = 1表示對行進行操作
• .sum
• .min
• .cumsum
• 等……

通函數(shù)

如sin，cos，exp……這些函數(shù)也都是在數(shù)組上按元素進行運算，產(chǎn)生一個數(shù)組作為輸出

索引、切片和迭代

一維的數(shù)組可以進行索引、切片和迭代操作的，就像 列表 和其他Python數(shù)據(jù)容器類型一樣

多維的數(shù)組每個軸可以有一個索引。這些索引以逗號分隔的元組給出：

array([[ 0,  1,  2,  3],[10, 11, 12, 13],[20, 21, 22, 23],[30, 31, 32, 33],[40, 41, 42, 43]])
>>> b[2,3]
23

當(dāng)提供的索引少于軸的數(shù)量時，缺失的索引被認為是完整的切片 :

>>> b[-1]                                  # the last row. Equivalent to b[-1,:]
array([40, 41, 42, 43])

如果想要對數(shù)組中的每個元素執(zhí)行操作，可以使用flat屬性，該屬性是數(shù)組的所有元素的迭代器

for element in b.flat:print(i)

datetime包

示例代碼

import numpy as np
import pandas as pd
from datetime import *# 輸入2個日期
date1 = "2022.05.11 13:30:00"
date2 = "2022.05.10 12:00:00"# 創(chuàng)建時間點對象(不能進行減法運算)
realTime = datetime.time(10, 30, 0) # 10:30:00# 創(chuàng)建具體時間對象(可以進行減法運算)
realTime_dt = datetime.datetime(2021, 1, 1, realTime.hour, realTime.minute, realTime.second)# 將輸入的日期轉(zhuǎn)換為“datetime.datetime”類型
# 由于日期的類型是字符串，因此不能直接進行計算，會報錯
date1 = datetime.strptime(date1, "%Y.%m.%d %H:%M:%S")
date2 = datetime.strptime(date2, "%Y.%m.%d %H:%M:%S")
print(" date1:", date1, "\n" ,"date2:", date2)
print(" 2個日期的類型分別是:\n", type(date1), type(date2))# 計算時間差：時間差的類型為“datetime.timedelta”類型
duration = date1 - date2
duration# 對計算差值進行天數(shù)（days）和秒數(shù)(seconds)的提取，并將秒數(shù)轉(zhuǎn)換為小時數(shù)
day = duration.days
hour = duration.seconds/3600
print("days:", day)
print("hours:", hour)

類與對象

基本操作

主要要了解self

"""設(shè)計類"""
class Student:"""類的屬性(變量)"""name = Noneage = None"""類的行為(方法)"""def say_hi(self,myname):# self關(guān)鍵字必須存在，其余定義方式和普通的函數(shù)一樣print(f"hi，大家好，我是{self.name}")# 如果成員方法要直接使用成員變量，也需要在變量前加上self.print(f"hi，大家好，主人也叫我{myname}")"""創(chuàng)建對象"""    
stu1 = Student()
stu2 = Student()"""為對象賦值"""
stu1.name = "Roland"
stu2.name = "Rola""""獲取對象信息"""
print(stu1.name)"""調(diào)用成員方法"""
stu1.say_hi("Steve")# self雖然是定義法時的形參，但是調(diào)用方法時完全可以忽略這個形參

構(gòu)造方法（構(gòu)造器）

類中如果有了構(gòu)造方法，那么可以實現(xiàn)：

• 在創(chuàng)建類對象 (構(gòu)造類) 的時候，會自動執(zhí)行
• 在創(chuàng)建類對象(構(gòu)造類) 的時候——new，將傳入?yún)?shù)自動傳遞給構(gòu)造方法使用

# 在Python中，__init__()就是構(gòu)造方法也就是java中的構(gòu)造器
class Student:"""類的屬性(變量)"""name = Noneage = None"""構(gòu)造方法"""def __init__(self,name,age):self.name = nameself.age = age"""類的行為(方法)"""def say_hi(self,myname):# self關(guān)鍵字必須存在，其余定義方式和普通的函數(shù)一樣print(f"hi，大家好，我是{self.name}")# 如果成員方法要直接使用成員變量，也需要在變量前加上self.print(f"hi，大家好，主人也叫我{myname}")"""創(chuàng)建對象"""    
stu1 = Student("Roland",18)
# stu2 = Student()"""獲取對象信息"""
print(stu1.name)
stu1.say_hi("Steve")

魔術(shù)方法

介紹

Python類中有很多內(nèi)置方法，即無論是什么類，都會有的方法，上面所說的 init 構(gòu)造方法就是魔術(shù)方法

魔術(shù)方法的命名規(guī)范：方法單詞前后都有兩個 “_”

有：

• init——構(gòu)造方法
• str——字符串方法
• lt——小于、大于符號比較
• le——小于等于、大于等于符號比較
• eq——==符號比較
• 等等……

str方法

字符串方法

當(dāng)類對象需要被轉(zhuǎn)換為字符串時，會調(diào)用str方法，而str方法實際上就是返回一串字符串。

如果沒有重寫方法的話，Python內(nèi)置的是返回對象的內(nèi)存地址，如果重寫了，那么會返回重寫方法中return 的值

"""這是沒有重寫str方法時"""
class Student:"""類的屬性(變量)"""name = Noneage = None"""構(gòu)造方法"""def __init__(self,name,age):self.name = nameself.age = age"""創(chuàng)建對象"""    
stu1 = Student("Roland",18)"""輸出對象信息（兩個語句等價）"""
print(stu1)
print(str(stu1))

"""這是重寫str方法時"""
class Student:"""類的屬性(變量)"""name = Noneage = None"""構(gòu)造方法"""def __init__(self,name,age):self.name = nameself.age = agedef __str__(self):return f"這個對象的name={self.name},age={self.age}"
"""創(chuàng)建對象"""    
stu1 = Student("Roland",18)"""輸出對象信息"""
print(stu1)
print(str(stu1))

lt方法

支持小于或大于符號( “<、>” )比較方法

即使兩個對象可以進行比較，這個是需要我們自己寫的，程序內(nèi)沒有內(nèi)置。如果沒有寫這個方法，但是還是使用小于號比較了兩個對象，則會報錯

"""案例演示"""
class Student:"""類的屬性(變量)"""name = Noneage = None"""構(gòu)造方法"""def __init__(self,name,age):self.name = nameself.age = agedef __lt__(self,other):# 這里other代表著另一個對象return self.age < other.agestu1 = Student("Roland",18)
stu2 = Student("Steve",19)print(stu1 < stu2)

le方法

將我對lt方法的描述中的“小于或大于”替換成“小于等于或大于等于”

eq方法

將我對lt方法的描述中的“小于或大于”替換成“等于”

封裝

封裝是一個思想，就是下列代碼

class Student:"""類的屬性(變量)"""name = Noneage = None"""構(gòu)造方法"""def __init__(self,name,age):self.name = nameself.age = agedef __lt__(self,other):# 這里other代表著另一個對象return self.age < other.age

私有成員

封裝一個類時，有時會有一些變量，不公開給外部使用，只給內(nèi)部的方法自己調(diào)用，這時就需要私有成員的形式