碼上快樂

相關內容    簡體    繁體

Python極簡詳細入門教程，新手必看！

本文轉載自   查看原文   2020-03-28 14:21   8496 

文章目錄


大家先看看有多長，想想要不要 點贊，😄

Python

​ 自從20世紀90年代初Python語言誕生至今，它已被逐漸廣泛應用於系統管理任務的處理和Web編程。

Python的創始人為荷蘭人吉多·范羅蘇姆 [3] （Guido van Rossum）。1989年聖誕節期間，在阿姆斯
特丹，Guido為了打發聖誕節的無趣，決心開發一個新的腳本解釋程序，作為ABC 語言的一種繼承。之所
以選中Python（大蟒蛇的意思）作為該編程語言的名字，是取自英國20世紀70年代首播的電視喜劇
《蒙提.派森的飛行馬戲團》（Monty Python’s Flying Circus）。

Python排行榜

Python誕生已經有20多年了，到現在仍然是一門非常熱門的語言

TIOBE社區發布的2017年3月和2018年3月的編程語言熱度榜（部分）

變化 編程語言 評級/%
- Java 14.639
- C 7.002
- C++ 4.751
↑ Python 3.548
↓↓ C# 3.457
↑↑↑ Visual Basic .Net 3.391
- JavaScript 3.071

Python之禪

Python語言有的設計理念和哲學，稱為“Python之禪”。Python之禪是Python的靈魂，理解Python之禪能幫助開發人員編寫出優秀的Python程序。在Python交互式方式運行工具IDLE（也稱為Python shell）中輸入import this命令，如圖所示，顯示的內容就是Python之禪。

在這里插入圖片描述

Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 22:39:24) [MSC v.1916 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

翻譯：

《Python之禪》(The Zen of Python)，蒂姆·彼得斯(Tim Peters)著
美麗總比丑陋好。
顯式的比隱式的好。
簡單總比復雜好。
復雜總比復雜好。
平鋪總比嵌套好。
稀疏總比稠密好。
可讀性。
特殊情況並不特別到足以違反規則。
盡管實用性勝過純潔性。
錯誤不應該悄無聲息地過去。
除非顯式地沉默。
面對模棱兩可的情況，拒絕猜測的誘惑。
應該有一種——最好是只有一種——顯而易見的方法。
盡管這種方式一開始可能並不明顯，除非你是荷蘭人。
現在總比沒有好。
盡管“從不”常常比“現在”更好。
如果實現很難解釋，那就是個壞主意。
如果實現很容易解釋，這可能是一個好主意。
名稱空間是一個偉大的想法——讓我們做更多這樣的事情!

第一個Python程序

1.程序運行方法：
程序編寫結束就可以運行了，可以使用快捷鍵Ctrl+F5運行程序。
在visual studio code里面打開終端就可以找到調試控制台查看運行。

2.編寫代碼：
首先使用visual studio code或者任何編輯器創建一個文件，然后將文件保存為*.py的格式，
接着在文件中編寫代碼。

3.第一個python代碼——Hello World!——hello.py
輸入如下代碼：

""" Created on 2020/1/9 編寫者 : Thomas """
string = "Hello World"
print (string)

fun main(args : Array <String>){
    println ("Hello World")
}

或

""" Created on 2020/1/9 編寫者 : Thomas """

string = "Hello World"
print(string)
print("Hello World")

使用Python Shell 實現

（1） 點擊Python **。Lnk快捷方式啟動

（2） 在windows命令提示符中輸入Python（不區分大小寫，如果你的電腦里有Python2和Python3，那么啟動Python2用“Python”，啟動Python 3用“Python3”）

（3） 通過Python IDLE 啟動Python Shell，Python IDLE提供了簡單的文本編輯功能，如剪切、復制、粘貼、撤銷和重做等，且支持語法高亮顯示。

無論采用哪一種方式啟動Python Shell，其命令提示符都是“>>>”，在該命令提示符后可以輸入Python語句，然后按下Enter鍵就可以運行Python語句，Python Shell馬上輸出結果。

在這里插入圖片描述

代碼解釋：

到現在只介紹了如何編寫程序和運行Helloworld，並沒有進行解釋

""" ① Created on 2020.1.9 制作人 : Thomas """                                                 ②

string = "Hello World"                              ③
print(string)                                       ④

從代碼中可見，Python實現HelloWorld的方式比java、C和C++等語言要簡單得多，而
且沒有main主函數。
代碼①到②使用一對三重雙引號包裹起來，起到做注釋的作用。三重雙引號也可以替換成
三重單引號。
代碼③是聲明字符串變量string(定義)，並使用"Hello World"為他賦值。
代碼④是通過print函數將字符輸出到控制台，類似於C中的printf函數
print(*objects, sep = ’ ', end = ‘\n’, file = sys.stdout, flush = False)
print語句有5個參數：
1.*object是可變長度的對象參數
2.sep是分隔符參數，默認值是一個空格
3.end是輸出字符串之后的結束符號，默認值是換號符
4.file是輸出文件參數，默認值sys.stdout是標准輸出，即控制台
5.flush為是否刷新文件輸出流緩沖區，如果刷新
字符串會馬上打印輸出默認值不刷新

實例詳見書P33頁

注釋

注釋:

Python注釋使用井號"#"，使用時"#"位於注釋行的開頭，#后面

有一個空格，接着寫注釋內容。

在第三章中介紹過文檔字符串，它也是一種注釋，只是用來注釋文檔的，可以多行注釋。

print("hello world")
#print("hello world")
''' 這是Python文檔注釋 '''

編譯器不處理注釋

標識符和關鍵字

1標識符

標識符就是變量、常量、函數、屬性、類、模塊、包等由程序員指定的名字。構成標識符的字符均有一定的規范，Python語言中標識符的命名規則如下：

（1） 區分大小寫，Myname和myname是兩個不同的標識符

（2） 首字母可以試試下划線“_”或字母，但不能是數字

（3） 除首字符外其他字符，可以是下划線、字母和數字

（4） 關鍵字不能作為標識符

（5） 不能使用Python內置函數作為自己的標識符

2關鍵字

​ 關鍵字是類似於標識符的字符序列，由語言本身定義好。Python語言中有33個關鍵字，只有False、None、True首字母大寫，其他的全部小寫。具體內容見表。

Python關鍵字
False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass

變量：

在Python中聲明變量時不需要指定它的類型，只是給一個標識符賦值就聲明了變

量，實例代碼如下：


\# 代碼文件: chapter4/src/ch4.2.1.kt

_hello = "Hello World"

score_for_student = 0.0

y = 20

x = True

b = False

b = 20

print(_hello, score_for_student, y, x, b)

變量聲明不需要指定數據類型，你賦給它什么數值，它就是該類型的變量了

注意b這個變量，雖然已經賦值False(bool)，但是它也可以接受其他類型

python保留字

保留字即關鍵字，我們不能把它們用作任何標識符名稱。Python 的標准庫提供了一個 keyword 模塊，可以輸出當前版本的所有關鍵字：

Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 22:39:24) [MSC v.1916 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>>

Python命名規范

​ 程序代碼中到處都是標識符，因此取一個一致並且符合規范的名字非常重要。Python中命名規范采用多種不同方式。不同的代碼元素命名不同，下面將分類說明。

  • 包名：全部小寫字母，中間可以由點分隔開，不推薦使用下划線。作為命名空間，包名應該具有唯一性，推薦采用公司或組織域名的倒置，如com.apple.quicktime.v2
  • 模塊名：全部小寫字母，如果是多個單詞構成，可以用下划線隔開，如dummy_threading。
  • 類名：采用大駝峰法命名，如SplitViewController。
  • 異常名：異常屬於類，應該使用類名，但是要以Error為后綴
  • 變量名：全部小寫字母，如果由多個單詞構成，可以使用下划線隔開。如果變量應用於模塊或函數內部，則變量名可以由單下划線開頭。
  • 函數名和方法名：命名如變量名，如balance_account、_push_cm_exit。
  • 常量名：全部大寫字母，其他如同變量名

駝峰命名法：

​ 1.大駝峰，每一個單詞的首字母都大寫，例如：AnamialZoo，JavaScript中構造函數用的是大駝峰式寫法。

​ 2.小駝峰，第一個單詞的首字母小寫，后面的單詞的首字母全部大寫，例如：fontSize、backgroundColor。

python3基本數據類型

Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創建。

在 Python 中，變量就是變量，它沒有類型，我們所說的"類型"是變量所指的內存中對象的類型。

等號（=）用來給變量賦值。

等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。

#!/usr/bin/python3
 
counter = 100          # 整型變量
miles   = 1000.0       # 浮點型變量
name    = "nowcoder"     # 字符串
 
print (counter)
print (miles)
print (name)

輸出

100
1000.0
nowcoder

數字類型

Python數字類型有4種：整數類型、浮點數類型、復數類型和布爾類型。

整數類型

​ Python整數類型稱為int，整數類型的范圍可以很大（Python2里有long類型，Python3中沒有long類型），只受所在計算機硬件的限制。

​ 整數類型默認為十進制數，但是也可以表示十六進制、八進制和二進制，表示方法如下。

  • 二進制數：以0b或0B為前綴，注意0是阿拉伯數字，不要誤以為是字母‘o’
  • 八進制數：以0o或0O為前綴，注意是O，注意！
  • 十六進制：以0x或0X為前綴

例子（在Python Shell中運行）

>>>28
28
>>>0b11100
28
>>>0o34
28
>>>0O34
28
>>>0x1c
28

浮點數類型

​ Python的浮點類型為float，float類型用於存儲小數類型，只支持雙精度浮點數。大小寫e可以表示10的指數。e2表示10^2.

Python Shell 實例：

>>>1.0
1.0
>>>0.0
0.0
>>>3.36e2
336.0
>>>1.56e-2
0.0156

復數類型

​ 很多計算機語言都不支持復數類型，但是Python語言支持復數。

Python中復數類型為complex。例如1+2j表示實部為1、虛部為2的復數。

Python Shell中運行如下

>>>(1+2j)
(1+2j)
>>>(1+2j) + (1+2j)
(2+4j)

布爾類型

​ 布爾值為bool，bool是int的子類，它只有兩個值：True和False（第一個字母必須大寫）

實例：

>>>bool(0)
False
>>>bool(2)
True
>>>bool(1)
True
>>>bool('')
False
>>>bool(' ')
True

Python中的字符串類型Unicode字符

'Hello World'
"Hello World"
'\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\uoo64'
"\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\uoo64"

​ Python中的字符不同於c++字符，Python使用Unicode編碼，所以字符串可以包含中文等亞洲字符。

代碼第①行和第②行的字符串使用Unicode編碼表示的字符串，事實上它表示的也是Hello World字符串，

可通過print（）函數將Unicode編碼表示的字符串輸出到控制台上，就會看到Hello World字符串。

Python Shell運行實例：

>>>s = 'Hello World'
>>>print(s)
Hello World
>>>s = "Hello World"
>>>print(s)
Hello World
>>>s = '\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\uoo64'
>>>print(s)
Hello World
>>>s = "\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\uoo64"
>>>print(s)
Hello World

數字類型的轉換

隱式類型轉換

​ 多個數字類型之間可以進行數學計算，由於參與運算的數字類型可能不同，此時會發生隱式類型轉換，如表

操作數1類型 操作數2類型 轉換后的類型
布爾 整數 整數
布爾、整數 浮點 浮點

Python Shell實例：

>>>a = 1 + True
>>>print(a)
2
>>> a = 1.0 + 1
>>>type(a)
<class 'float'>
>>>print(a)
2.0
>>>a = 1.0 + True
>>>print(a)
2.0
>>>a = 1.0 + 1 + True
>>>print(a)
3.0

顯式類型轉換

​ 再不能隱式類型轉換的情況下，就只能用顯式類型轉換了。除了復數之外，三種數字類型（整數，浮點，布爾）都有自己的轉換函數，分別是int（），float（），bool（）

  • int（）函數可以將布爾、浮點、字符串數據轉化成整數。
  • float（）函數可以將布爾、整數、字符串類型轉化成浮點數。

Python Shell實例：

>>>int(False)
0
>>>int(True)
1
>>>int (19.6)
19
>>>float(5)
5.0
>>>float(False)
0.0
>>>float(True)
1.0

字符串類型

​ Python中字符串類型是str，不是string。Python中有3種字符串表示方法

  • 普通字符串：采用一對單引號‘’或一對雙引號“”包裹起來
  • 原始字符串：在普通字符串前面加r，字符串特殊字符不會發生轉義
  • 長字符串：字符串中包含了換行符縮進符等排版字符，可以使用三對雙引號"""或三對單引號’’'包裹起來。

python運算符。

Python語言支持以下類型的運算符:

  • 算術運算符
  • 比較（關系）運算符
  • 賦值運算符
  • 邏輯運算符
  • 位運算符
  • 成員運算符
  • 身份運算符
  • 運算符優先級

接下來讓我們一個個來學習Python的運算符。
以下假設變量a為10，變量b為21:

運算符 描述 實例
+ 加-兩個對象相加 a+b輸出結果31
- 減-得到負數或是一個數減去另一個數 a-b輸出結果-11
* 乘-兩個數相乘或是返回一個被重復若干次的字符串 a*b 輸出結果 210
/ 除-x除以y b/a輸出結果2.1
% 取模-返回除法的余數 b%a輸出結果 2.1
** 冪-返回x的y次冪 a ** b 為10的21次方
// 取整除-向下取接近除數的整數 9//2輸出結果4， -9//2輸出結果-5

其他見實驗程序……

# coding = UTF-8
a = 10
b = 21
print("a + b = ", a + b)
print("a - b = ", a - b)
print("a * b = ", a * b)
print("a / b = ", a / b)
print("a % b = ", a % b)
print("a ** b = ", a ** b)
print("9 // 2 = ", 9 // 2)
print("-9 // 2 = ", -9 / 2)

關系、邏輯運算符

​ 擴展：‘+’號還可以把兩個字符串連接起來，‘*’號可以倍增！Python Shell實例

>>> 'hello' + 'world'
'helloworld'
>>>'hello' * 2
'hellohello'

關系運算符

​ 關系運算符無需多說，Python中有6種，和c++一模一樣：==、!=、>、<、>=、<=。具體說明見下表

運算符 名稱 例子 說明
== 等於 a == b a等於b時返回True，否則返回False
!= 不等於 a != b 與==相反
> 大於 a > b a大於b時返回True，否則返回False
< 小於 a < b a小於b時返回True，否則返回False
>= 大於等於 a >= b a大於或等於b時返回True，否則返回False
<= 小於等於 a <= b a小於或等於b時返回True，否則返回False

在Python Shell運行實例：

""" Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 22:39:24) [MSC v.1916 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license()" for more information. """
#所以注釋
>>> a = 1
>>> b = 2
>>> a > b
False
>>> a < b
True
>>> a <= b
True
>>> a >= b
False
>>> a == b
False
>>> a != b
True
>>>

​ Python中關系運算符可用於比較序列或數字，整數、浮點數都是對象，可以使用關系運算符進行比較。

Python Shell 運行實例：

>>> a = 'Hello'
>>> b = 'Hello'
>>> a == b
True
>>> a = 'World"
SyntaxError: EOL while scanning string literal
>>> a = 'world'
>>> a > b
True
>>> a < b
False
>>> a = []
>>> b = [1, 2]
>>> a == b
False
>>> a < b
True
>>> a = [1, 2]
>>> a == b
True
>>>

[]是一個列表，列表也可以比較

邏輯運算符

​ 邏輯運算符也不用多說原理，直接開干！

運算符 名稱 例子 說明
not 邏輯非 not a 1->0 0->1
and 邏輯與 a and b a&btrue1 else 0
or 邏輯或 a or b a&bflase0 else 1

說明學過c的人都會。

賦值運算符

​ 賦值運算符還是無需多說，只看下面Python賦值運算符內容表

運算符 名稱 例子 說明
= 直接賦值 a = b 把b的值直接給a
+= 加賦值 a += b 等價於a = a + b
-= 減賦值 a -= b 等價於a = a - b
*= 乘賦值 a *= b 等價於a = a * b
/= 除賦值 a /= b 等價於a = a / b
%= 取余賦值 a %= b 等價於a = a % b
**= 冪賦值 a **= b 等價於a = a ** b
//= 整除賦值 a //= b 等價於a = a // b

其他運算符

​ Python還有其他的一些運算符，先介紹兩個“測試”運算符，同一性測試運算符和成員測試運算符。

同一性測試運算符

​ 這種運算符就是測試兩個對象是否同一個對象，類似運算符，不同之處在於是測試兩個對象的內容，而同一性測試運算符只測試對象。

​ 同一性測試運算符有兩個：is和is not，is是判斷同一，is not 是判斷不是同一。

成員測試運算符

​ 成員測試運算符可以測試在一個序列對象中是否包含某一個元素（所謂成員），成員測試運算符有兩個：in和not in。

#!/usr/bin/python3
#coding = UTF-8

字符串 = 'hello'
string_a = 'Hello'
print('e' in 字符串)  #True
print('ell' not in string_a) #False

a = [0, 3]
print(type(a))

print('--')

list_a = [1, 2]
print(2 in list_a)     #True
print(1 not in list_a) #False

#!/usr/bin/python3
#coding = UTF-8

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person('Tony', 18)
p2 = Person('Tony', 18)

print(p1 == p2)     #False
print(p1 is p2)     #False

print(p1 != p2)     #True
print(p1 is not p2) #True

控制語句

​ 程序設計中的控制語句有三種，即順序、分支和循環結構，Python中的控制語句有以下幾類

  • 分支語句：if
  • 循環語句：while和for
  • 跳轉語句：break、continue和return

分支語句

Python中分支語句只有if語句，這個if語句使得程序具有了“判斷能力”，能夠像人類的大腦一樣分析問題。if語句有if結構、if-else結構和elif結構三種。

if結構

例題：輸入分數，計算優秀、中等、差。

if語句結構如下：

if 條件:
	語句組
	……

代碼：

#coding = utf-8
#!/usr/bin/python3

import sys

score = int(sys.argv[1])

if score >= 85:
    print("您真優秀")
if score < 60:
    print("您需要加倍努力")
if score >= 60:
    print("您的成績還可以，仍要繼續努力！")

if-else結構

幾乎所有的計算機語言都有這個結構，先判斷條件，如果返回值為True，那么執行語句，否則執行else內的語句。

if-else 結構如下：
if 條件：
	語句組1
else：
	語句組2

elif結構

elif結構就是c++語言中的else if結構，elif實際上是if-else的多重嵌套，不用多說

if-else結構實例

#coding = utf-8
#!/usr/bin/python3

import sys

score = int(sys.argc[1])

if score >= 60:
    print("及格")
    if score >= 90:
        print("優秀")
else:
    print("不及格")

elif結構實例

#coding = utf-8
#!/usr/bin/python3

import sys

score = int(sys.argv[1])

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
	grade = 'F'

print("Grade = " + grade)

循環語句

​ 循環語句能夠使程序代碼重復執行。Python支持while和for兩種循環語句。

while語句

​ while語句是一種先判斷后執行的循環語句，格式如下：

while 循環條件:
	語句組
[else:
	語句組
]

​ while循環沒有初始化語句，循環次數是不可知的，只要循環條件滿足，循環就會一直執行循環體。while循環中可以帶有else語句，else語句將在后面介紹。

for語句

​ for語句是應用最廣泛、功能最強的一種循環語句。Python語言中沒有c語言風格的for語句，它的for語句相等於Java中增強for循環語句，只用於序列，序列包括字符串、列表和元組。

for語句格式如下：

for 迭代變量 in 序列:
	語句組
[else:
	語句組]

while語句實例：

#coding = utf-8
#!/usr/bin/python3

i = 0

while i * i < 100_000:
    i += 1

print("i = {0}".format[i])
print("i * i = {0}".format(i * i))

輸出結果如下：

i = 317
i * i = 100489

for語句實例：

#coding - utf-8
#!/usr/bin/python3

print("------范圍------")
for num in range(1, 10):
    print("{0} x {0} = {1}".format(num, num * num))
print("------字符串------")
for item in 'Hello':
    print(item)
    
numbers = [43, 32, 53, 54, 75, 7, 10]

print("------整數列表------")
for item in numbers:
    print("Count is : {0}".format(item))

輸出結果：

------范圍------
1 x 1 = 1
2 x 2 = 4
3 x 3 = 9
4 x 4 = 8
5 x 5 = 25
6 x 6 = 36
7 x 7 = 49
8 x 8 = 64
9 x 9 = 81
------字符串------
H
e
l
l
o
------整數列表------
Count is : 43
Count is : 32
Count is : 53
Count is : 54
Count is : 75
Count is : 7
Count is : 10

for語句的range()函數是創建一個范圍對象，它的取值范圍是1≤range(1, 10)<10,步長默認為1，總共10個整數

Python跳轉語句

​ 跳轉語句能夠改變程序的執行順序，可以實現程序的跳轉。Python有3種跳轉語句：break、continue和return。本章重點介紹break和continue的使用。return將在后面章節介紹。

Break語句

​ break語句可用於while語句和for語句，它的作用是強行退出循環體，不再執行循環中剩余的語句。

下面是一個實例，代碼如下：

#coding = utf-8
#!/usr/bin/python3

for item in range(10):
    if item == 3:
        #跳出循環
        break
    print("Count is : {0}".format(item))

上述代碼item變量默認從0開始迭代。運行結果如下：

Count is : 0
Count is : 1
Count is : 2

Continue 語句

​ Continue語句用來結束本次循環，跳過循環體中尚未執行的語句，接着進行終止條件的判斷，已決定是否繼續循環。

​ 實例，代碼如下:

#coding = utf-8
#!/usr/bin/python3

for item in range(10):
    if item == 3:
        continue
    print("Count is : {0}".format(item))

​ 上述代碼中，當條件item==3的時候執行continue語句，continue語句會終止本次循環，循環體中continue之后的語句將不再執行，進行下次循環，所以輸出結果中沒有3

ans:

Count is : 0
Count is : 1
Count is : 2
Count is : 4
Count is : 5
Count is : 6
Count is : 7
Count is : 8
Count is : 9

While和For中的else語句

​ while和for語句的else和if中的else語句不同，這里的else是在循環體正常結束時才運行的代碼，當循環被中斷時不執行，break、return和異常拋出都會中斷循環。

while、for加else實例：(if-break被注釋掉)

#coding = utf-8
#!/usr/bin/python3

i = 0
while i * i < 10:
    i += 1
    #if == 3:
    # break
    print("{0} * {0} = {1}".format(i, i * i))
else:
    print('While Over!')
    
#------------------------------

for item in range(5):
    if item == 3:
        break
    print("Count is : {0}".format(item))
else:
    print("For Over!")

結果：

1 * 1 == 1
2 * 2 == 4
3 * 3 == 9
4 * 4 == 16
While Over!
Count is : 0
Count is : 1
Count is : 2

使用范圍

​ for語句在使用時需要用范圍函數，范圍在Python中是range函數，表示一個整數序列，創建范圍對象需要使用range()函數，range()函數語法如下：

range([start,] stop[,step])

range函數也可以使用復數范圍，創建一個遞減范圍，示例如下：

#coding = utf-8
#!/usr/bin/python3

for item in range(1, 10, 2):
    print("Count is : {0}".format(item))
    
print("-------")

for item in range(1, -10, -3):
    print("Count is : {0}".format(item))

輸出結果如下：

Count is : 1
Count is : 3
Count is : 5
Count is : 7
Count is : 9
-------
Count is : 0
Count is : -3
Count is : -6
Count is : -9

​ 忘了說了，在Python中，整數為了表示清晰可以用下划線隔開，比如100_000和100000是一樣的，小數在小數點前面可以有多個0，比如003.1415926等於3.1415926

本章結束

Python數據結構！結構！

當你有很多書的時候，你會考慮買一個書櫃，將你的書分門別類地擺放進去。使用了書櫃不僅使房間變得整潔，也便於以后使用書時查找。在計算機程序中會有很多數據，這些數據也需要容器將它們管理起來，這就是__數據結構__

常見的有數組（Array）、集合（Set）、列表（list）、隊列（queue）、鏈表（linkedlist）、樹（tree）、堆（heap）、棧（stack）和字典（dictionary）等結構。

Python中數據結構主要有序列、集合和字典

​ 注意:Python中並沒有數組結構，因為數組要求元素類型是一致的。而Python作為動態類型語言，不強制聲明變量的數據類型，也不強制​​檢查元素的數據類型，不能保證元素的數據類型一致，所以Python中沒有數組結構。

元組

​ 元組（tuple）是一種序列（sequence）結構

序列

​ 序列包括的結構有列表（list）、字符串（string）、元組、范圍（range）和字節序列（bytes）。序列可以進行的操作有索引、分片、加和乘。

1）索引操作

​ 序列中第一個元素的索引是0，其他元素的索引是第一個元素的偏移量。可以有正偏移量，稱為正值索引；也可以有負偏移量，稱為負值索引。正值索引的最后一個元素索引是“序列長度-1”，負值索引最后一個元素索引是“-1”。例如Hello字符串，它的正值索引如表

索引 0 1 2 3 4
字符串 H e l l o
索引 0 -4 -3 -2 -1
字符串 H e l l o

正值索引和負值索引表⬆️

PythonShell實例：

Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 22:39:24) [MSC v.1916 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> a = "Hello"
>>> a[0]
'H'
>>> a[1]
'e'
>>> a[4]
'o'
>>> a[-1]
'o'
>>> a[-2]
'l'
>>> a[5]
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    a[5]
IndexError: string index out of range
>>> max(a)
'o'
>>> min(a)
'H'
>>> len(a)
5
>>> #max函數返回最后一個函數
>>> #min函數返回第一個元素
>>> #len返回長度

2）序列和加和乘

PythonShell實例：

>>> a = "Hello"
>>> a * 3
'HelloHelloHello'
>>> print(a)
Hello
>>> a += ' '
>>> a += 'World'
>>> print(a)
Hello World
>>>

3)序列分片

​ 序列的分片（slicing）就是從序列中切出小的子序列。分片使用分片運算符，分片運算符有兩種形式。

  • [start : end] :start是開始索引，end是結束索引
  • [start: end : stop] :step是步長，步長可以為正數，也可以為負數

實例：

>>>a = 'Hello'
>>>a[1:3]
'el'
>>>a[:3]
'Hel'
>>>a[0:3]
'Hel'
>>>a[0:]
'Hello'
>>>a[0:5]
'Hello'
>>>a[:]
'Hello'
>>>a[1:-1]
'ell'

附加程序：

創建元組

​ 元組是一種不可變的序列，一旦創建就不能修改。創建元組可以使用tuple([iterable])函數或直接用逗號“，”將元素分隔。

Python Shell實例代碼

>>>21,32,43,45                         ①
(21,32,43,45)
>>>(21,32,43,45)                       ②
(21,32,43,45)
>>>a = (21,32,43,45)
>>>print(a)
(21,32,43,45)
>>>('Hello', 'World')                  ③
('Hello', 'World')
>>>('Hello', 'World', 1, 2, 3)         ④
('Hello', 'World', 1, 2, 3)
>>>tuple([21,32,43,45])                ⑤
(21,32,43,45)

代碼第①行創建了一個有4個元素的元組，創建元組時使用小括號把元素括起來不是必須的；

代碼第②行使用小括號將元素括起來，這只是為了提高程序的可讀性

代碼第③行創建了一個字符型元組

代碼第④行創建了一個字符串和整數混合的元組。Python中沒有強制聲明數據類型，因此元組中的元素可以是任何數據類型

另外，元組還可以使用tuple([iterable])函數創建，參數iterable可以是任何可迭代對象。代碼第⑤行使用了tuple函數創建元組對象，實參[21, 32, 43, 45]是一個列表，列表是可迭代對象，可以作為tuple()函數參數創建元組對象。

創建元組還需注意極端情況：❗️

>>> a = (21)
>>> type(a)
<class 'int'>
>>> a = (21, )
>>> type(a)
<class 'tuple'>
>>> a = ()
>>> type(a)
<class 'tuple'>

訪問元組

元組作為序列可以通過下標索引訪問其中的元素，也可以對其進行分片

PythonShell實例：

>>>a = ('Hello', 'World', 1, 2, 3)      ①
>>>a[1]
'World'
>>>a[1:3]
('World', 1)
>>>a[2:]
(1, 2, 3)
>>>a[:2]
('Hello', 'World')

上述代碼第①行是元組a，a[1]是訪問元組的第二個元素，表達式a[1:3]、a[2:]和a[:2]都是分片操作

元組還可以進行拆包(Unpack)操作，就是將元組的元素取出給不同變量

PythonShell實例：

>>> a = ('Hello', 'World', 1, 2, 3)
>>> str1, str2, n1, n2, n3 = a
>>> str1
'Hello'
>>> str2
'World'
>>> n1
1
>>> n2
2
>>> n3
3
>>> str1, str2, *n = a
>>> str1
'Hello'
>>> str2
'World'
>>> n
[1, 2, 3]

*n可以直接獲取剩余的元素

遍歷元組

一般用for語句遍歷元組，實例代碼

#coding=utf-8
#!/usr/bin/python3


a = {21, 32, 43, 45}

for item in a:
    print(item)

print('--------')

for i, item in enumerate(a):
    print('{0} - {1}'.format(i, item))

運行結果：

21
32
43
45
--------
0 - 21
1 - 32
2 - 43
3 - 45

其中enumerate(a)函數可以獲取元組對象

附加程序

#coding = utf-8

a = (20)
print(type(a))

a = (20,)
print(type(a))
#tuple

a = (20, 30, 40, 50, 60)
print(a)
print(a[1])
print(a[1:3])

a = ('Hello', 'World', 1, 2, 3)
str1, str2, n1, n2, n3 = a
print(str1)
print(str2)
print(n1, "", n2, "", n3)

str1, str2, *n = a
print(n)

列表

​ 列表（List）也是一種序列結構，和元組不一樣，列表具有可變性，可以追加、插入、刪除和替換列表中的元素。

列表創建

​ 創建列表可以使用list([iterable])函數，或者用中括號[]將元素括起來，元素之間用逗號分隔。在Python Shell中運行實例代碼如下：

在這里插入圖片描述

​ 為什么今天的交互要發一張截圖呢？原因我發現visual studio2019安裝上Python插件之后，點擊視圖，也有Python交互解釋器，還有代碼高亮，自動補全，比IDLE好用多了！

#同一個代碼片
>>> [20, 10, 50, 40, 30]        ①
[20, 10, 50, 40, 30]
>>> []
[]
>>> ['Hello', 'World', 1, 3, 3] ②
['Hello', 'World', 1, 3, 3]
>>> a = [10]                    ③
>>> type(a)
<class 'list'>
>>> a = [10, ]                  ④
>>> type(a)
<class 'list'>
>>> list((20, 10, 50, 40, 30))  ⑤
[20, 10, 50, 40, 30]
>>>

​ 接着說，代碼第①行創建了一個有五個元素的列表，注意和元組不一樣，中括號不能省略，如果省略就變成元組了。代碼第②行創建了一個字符串和整數混合的列表。代碼第③行創建一個只有一個元素的列表，中括號不能省略。

​ 另外，代碼第⑤行用list([iterable])函數創建列表。

追加元素

​ 列表中追加單個元素可以使用append()方法。如果想追加另一列表，可以使用+運算符或者extend()方法

​ append()方法語法：
list.append(x)

其中x參數是要追加的單個元素值

​ extend()方法語法：
list.extend(t)

其中t參數是追加的另外一個列表

Python Shell實例：

>>> student_list = ['張三', '李四', '王五']
>>> student_list.append('董六')
>>> student_list
['張三', '李四', '王五', '董六']
>>> student_list += ['劉備', '關羽']
>>> student_list
['張三', '李四', '王五', '董六', '劉備', '關羽']
>>> student_list_extend(['張飛', '趙雲'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'student_list_extend' is not defined
>>> #一下子輸錯了
...
>>> student_list.extend(['張飛', '趙雲'])
>>> student_list
['張三', '李四', '王五', '董六', '劉備', '關羽', '張飛', '趙雲']
>>>

插入元素

插入元素可以用insert()方法。該方法可以指定索引位置插入一個元素

insert()方法語法

list.insert(i, x)

其中參數i是要插入的序列，參數x是要插入的元素數值

Python Shell實例

>>> student_list = ['張三', '李四', '王五']
>>> student_list
['張三', '李四', '王五']
>>> student_list.insert(2, '劉備')
>>> student_list
['張三', '李四', '劉備', '王五']

替換元素

​ 這一點和c++的數組很像，直接修改下標中元素

實例：

>>> student_list = ['張三', '李四', '王五']
>>> student_list[0] = "諸葛亮"
>>> student_list
['諸葛亮', '李四', '王五']

刪除元素

​ 一種放法是remove()方法，另一種是pop()

1）remove

​ remove方法從左到右查找列表中的元素，如果找到匹配元素則刪除，注意如果找到多個匹配元素，只是刪除第一個，如果沒有找到會拋出錯誤。

實例：

>>> student_list = ['張三', '李四', '王五']
>>> student_list[0] = "諸葛亮"
>>> student_list
['諸葛亮', '李四', '王五']
>>> 
>>> 
>>> 
>>> student_list = ['張三', '李四', '王五', '王五']
>>> student_list.remove('王五')
>>> student_list
['張三', '李四', '王五']
>>> student_list.remove('王五')
>>> student_list
['張三', '李四']
>>> student_list.remove('王五')
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    student_list.remove('王五')
ValueError: list.remove(x): x not in list
>>> student_list.append('王五')
>>> student_list
['張三', '李四', '王五']
>>> student_list.pop()
'王五'
>>> student_list
['張三', '李四']
>>>

pop是彈出列表最后一個元素

列表的其他常用方法

​ 前面介紹列表的追加、插入和刪除時，已經介紹了一些方法。事實上列表還有很多方法，下面再來介紹一些常用方法。

  • reverse()：倒置列表
  • copy()：復制列表
  • clear()：清除列表中的所有元素
  • index(x, i, j)：返回查找x第一次出現的索引，i是開始查找索引，j是結束查找索引，該方法繼承自序列，元組和字符串也可以使用該方法
  • count(x)：返回x出現的次數，該方法繼承自序列，元組與字符串也可以使用該方法

Python Shell中運行實例：

>>> a = [21, 32, 43, 45]
>>> a.reverse()
>>> a
[45, 43, 32, 21]
>>> b = a.copy()
>>> b
[45, 43, 32, 21]
>>> a.clear()
>>> a
[]
>>> b
[45, 43, 32, 21]
>>> a = [45, 43, 32, 21, 32]
>>> a.count(32)
2
>>> student_list = ['張三', '李四', '王五']
>>> student_list.index('王五')
2
>>> student_tuple = ('張三', '李四', '王五')
>>> student_tuple.index('王五')
2
>>> student_tuple.index('李四', 1, 2)
1

列表推導式

​ Python中有一種特殊表達式——推導式，它可以將一種數據結構作為輸入，經過過濾、計算等處理，最后輸出另一種數據結構。根據數據結構的不同可分為列表推導式、集合推導式和字典推導式

​ 如果想獲得0~9中偶數的平方數列，可以通過for循環實現

n_list = []
for x in range(10):
	if x % 2 == 0:
		n_list.append(x ** 2)
        
print(n_list)

輸出結果：

[0, 4, 16, 36, 64]

也可以用列表推導式實現，代碼如下：

n_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(n_list)

​ 列表推導式格式：

n_list = [x ** x1 for x2 in range(10)3 if x % 2 == 04]

1.集合

​ 集合（set）是一種可迭代的、無序的、不能包含重復元素的數據結構。圖中是一個班級的集合，其中包含一些學生，這些學生是無序的，不能通過序號訪問，而且不能重復。在這里插入圖片描述

​ 提示：與序列比較，序列中的元素是有序的，可以__重復出現__，而且集合中的元素是無序的，且不能有重復的元素。

序列強調的是有序，集合強調的是不重復，而且當沒有重復的元素時，序列和集合可以互相替換。

​ 集合又分為**可變集合和不可變集合**

1.1創建可變集合

​ 可變集合類型是set，創建可變集合可以使用set([iterable])函數，或者用大括號{ }將元素括起來，元素之間用逗號分隔

Python Shell實例：

>>> a = {'張三', '李四', '王五'}
>>> a
{'張三', '李四', '王五'}
>>> a = {'張三', '李四', '王五', '王五'}
>>> a
{'張三', '李四', '王五'}
>>> #集合中如果有重復元素，創建時會自動刪除重復元素↑
... 
>>> len(a)
3
>>> b = { }
>>> type(a)
<class 'set'>
>>> type(b)
<class 'dict'>

空的集合會變成字典，代碼中b不是集合，是字典dict，如果要創建空集合，要使用set()函數。

1.2修改可變集合

​ 可變集合類似於列表，可變集合的內容可被修改，可以插入和刪除元素。修改可變集合有幾個常用的方法。

  • add(elem)：添加元素，如果元素已經存在，則不能添加，不會拋出錯誤
  • remove(elem)：刪除元素，如果元素不存在，則會拋出錯誤
  • discard(elem)：刪除元素，如果元素不存在，不會拋出錯誤
  • pop()：刪除返回集合中任意一個元素，返回值是刪除的元素
  • clear()：清空

Python Shell實例：

>>> student_set = {'張三', '李四', '王五'}
>>> student_set.add('董六')         # 隨機添加元素，因為集合沒有順序
>>> student_set
{'張三', '董六', '李四', '王五'}
>>> student_set.remove('董六')
>>> student_set
{'張三', '李四', '王五'}
>>> student_set.remove('董六')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '董六'
>>> #報錯，沒有董六
... 
>>> student_set.discard('董六')
>>> student_set
{'張三', '李四', '王五'}
>>> #discard()不會拋出錯誤
... 
>>> student_set.pop()
'張三'
>>> student_set
{'李四', '王五'}
>>> student_set.pop()
'李四'
>>> student_set
{'王五'}
>>> student_set.clear()
>>> student_set
set()

1.3遍歷集合

​ 集合是無序的，沒有索引，不能通過下標訪問。但可以遍歷集合，訪問集合的每一個元素。

實例代碼：

#coding = utf-8

student_set = {'張三', '李四', '王五'}

for item in student_set:
    print(item)

print('-----------')
for i, item in enumerate(student_set):
    print('{0} - {1}'.format(i, item))

輸出結果

張三
李四
王五
----------
0 - 張三
1 - 李四
2 - 王五

函數式編程

函數

​ 程序中反復執行的代碼可以封裝到一個代碼塊中，這個代碼塊模仿了數學中的函數，具有函數名、參數和返回值，這就是程序中的函數。

​ Python中的函數很靈活，它可以在模塊中、但是在類之外定義，即函數，其作用域是當前模塊；也可以在別的函數中定義，即嵌套函數；還可以在類中定義，即方法。

定義函數

​ 在前面的學習過程中用到了一些函數，如len()、min()和max()，這些函數都是由Python官方提供的，稱為內置函數( B u i l t − i n F u n c t i o n s , B I F Built-in Functions, BIF )

自定義函數

​ 本節介紹自定義函數，自定義函數的語法如下

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

​ 在Python中定義函數時，關鍵字是def，函數名需要符合標識符命名規范見以前博客—Python命名規范。多個參數列表之間可以使用逗號“，”分隔，當然函數也可以沒有參數。如果函數有返回數據，就需要在函數體最后使用return語句將數據返回；如果沒有返回數據，則函數體中可以使用return None或者省略return語句。

函數定義實例如下：

# coding = utf-8
#!/usr/bin/python3

def rectangle_area(width, height):
    area = width * height
    return area

r_area = rectangle_area(320.0, 480.0)
print("320 x 480的長方形的面積:{0:.2f}".format(r_area))

函數參數

​ Python中的函數參數很靈活，具體體現在傳遞參數有都中形式上。本節介紹幾種不同形式的參數和調用方式。

使用關鍵字參數調用函數

​ 為了提高函數調用的可讀性，在函數調用時可以使用關鍵字參數調用。采用關鍵字參數調用函數，在函數定義時不需要做額外工作。

​ 實例代碼如下：

#-*- coding = utf-8 -*-

def print_area(width, height):
    area = width * height
    print("{0} x {1} 長方形的面積:{2}".format(width, height, area))

print_area(320.0, 48.0)     # 沒有采用關鍵字參數函數調用
print_area(width = 320.0, height = 480.0)     # 采用關鍵字參數函數調用
print_area(320.0, height = 480.0)     # 采用關鍵字參數函數調用
# print_area(width = 32.0, height) #發生錯誤
#原因--height沒有數值,系統就會認為是一個變量,而這個變量沒有定義聲明
print_area(height = 480.0, width = 320.0)     #采用關鍵字參數函數調用

代碼很簡單，就不用了多說了

參數默認值

​ 在定義函數的時候可以為參數設置一個默認值，調用函數時可以忽略該參數。

​ 實例：(下面兩段代碼是一體的)

# -*- coding = utf-8 -*-

def make_coffee(name = "卡布奇諾"):
    return "制作一杯{0}咖啡".format(name)

​ 上述代碼定義了makeCoffee()函數，其中把卡布奇諾😋挺好喝的​設置為了默認值。在參數列表中，默認值可以跟在參數類型后面。在調用的時候，如果調用者沒有傳遞參數，則使用默認值，調用代碼如下：

coffee1 = make_coffee("拿鐵")
coffee2 = make_coffee()

print(coffee1)
print(coffee2)

​ 其中coffee1 = make_coffee("拿鐵")代碼是傳遞“拿鐵”，沒有使用默認值。coffee2 = make_coffee()這一行沒有傳遞參數，因此使用默認值。

StdOut:

制作一杯拿鐵咖啡
制作一杯卡布奇諾咖啡

​ **提示（新手可以不看）：**Java語言中make_coffee()函數可以采用重載實現多個版本。Python不支持函數重載，而是使用參數默認值的方式提供類似的重載功能。

函數返回值

​ Python函數的返回值也是比較靈活的（Python的東西都比較靈活），主要有三種形式：無返回值、單一返回值和多返回值。

無返回值函數

​ 有的函數只是為了處理某個過程，此時可以將函數設計為無返回值的。所謂無返回值，事實上是返回None，None表示沒有實際意義的數據。

#-*- coding = utf-8 -*-

def show_info(sep = ':', **info):    #可變參數,下面講一下
    """定義**可變參數函數, dict"""
    print('-----info-----')
    for key, value in info.items():
        print('{0} {2} {1}'.format(key, value, sep))
        return                  #return None

result = show_info('->', name = 'Tony', age = 18, sex = True)
print(result)


def sum(*numbers, multiple = 1):
    """定義*可變參數函數, tuple"""
    if len(numbers) == 0:
        return
    total = 0.0
    for number in numbers:
        total += number
    return total * multiple

print(sum(30.0, 80.0))
print(sum(multiple = 2))

StdOut:

-----info-----
name -> Tony
None
110.0
None

  1. 上述代碼show_info()函數中有一個**info的參數，這是一個可變參數，下面詳細解釋一下。Python中函數的參數個數可以變化，這種參數稱為可變參數。Python中的可變參數有兩種，即參數前加*或**形式，*可變參數被組裝成一個元組，**可變參數在函數中被組裝成一個字典。

    1. *可變參數

      下面看一個實例：（部分代碼）

      def sum(*numbers, multiple = 1):
    total = 0.0
    for number in numbers:
        total += number
    return total * multiple

print(sum(100.0, 20.0, 30.0))
print(sum(30.0, 80.0))
print(sum(30.0, 80.0, multiple = 2))

double_tuple = (50.0, 60.0, 0.0)
print(sum(30.0, 80.0, *double_tuple))


        > StdOut:
        >
        > > 150.0
        > >
        > > 110.0
        > >
        > > 220.0
        > >
        > > 220.0

        不用說都懂了吧:smirk:

2. `**`__可變參數__

下面看一個實例：（部分代碼）
```python
def show_info(sep = ':', **info):
print('-----info-----')
for key, value in info.items():
print('{0} {2} {1}'.format(key, value, sep))

show_info('->', name = 'Tony', age = 18, sex = True)
show_info(student_name = 'Tony', sex = True, sep = '=')

都不用說吧？挺簡單的
2. 返回值為空的時候可以用return或return None都可以。

多返回值函數

​ 有時候需要函數返回多個值，實現返回多個值的方式有很多，簡單的方式是使用元組返回多個值，因為元組可以容納多個數據，另外元組是不可變的，使用起來比較安全。

實例：

#coding=utf-8

def position(dt, speed):
    posx = speed[0] * dt #speed[0] 是X軸上的速度
    posy = speed[1] * dt #speed[1] 是Y軸上的速度
    return (posx, posy)

move = position(60.0, (10, -5)) #move是一個元組，用來存儲多個返回值

print("物體位移：({0}, {1})".format(move[0], move[1]))

【Python入門自學筆記專輯】——函數嵌套-Lambda表達式

函數嵌套

前言

 Python的函數有很多地方不同於c++，它的函數可以嵌套！c++程序員：望塵莫及，太可怕了！不過Python主要是基於c語言開發的，c工程師還是可以自豪的，c語言是要自己做功能，而python自帶功能。學哪個各有好處。

正題

 好了扯遠了，繼續說Python函數，python的一個函數可以嵌套多個函數，多個函數還可以嵌套。

def func():
    def func1():
        print("func1")
    def func2():
        print("func2")
        def func2_1():
            print("func2.1")
print("hello world")

比如上面的這個程序，func函數中嵌套了兩個函數——func1和func2，func2又嵌套了func2_1，Python是支持這種情況的。
比如：

def func():
    def func1():
        print("func1")
    def func2():
        print("func2")
        def func2_1():
            print("func2.1")
    print("func")
func()

那么輸出結果是：

func

先來一個溫馨提示：如果要調用函數，必須把函數放在調用的那行上面！
再看代碼：

def func():
    choose = int(input("> "))
    def func1():
        print("func1")
    def func2():
        print("func2")
        def func2_1():
            print("func2.1")
    if choose == 1:
        func1()
    elif choose == 2:
        func2()
    print("func")
func()
func()

運行結果：

> 1
func1
func
> 2
func2
func

分析：
 先調用進func函數，然后定義兩個函數func1、func2然后選擇，函數必須在選擇的上面，不信大伙可以試試。

可能出現的錯誤

1
def func():
    if choose == 1:
        func1()
    elif choose == 2:
        func2()
    choose = int(input("> "))
    def func1():
        print("func1")
    def func2():
        print("func2")
        def func2_1():
            print("func2.1")
    print("func")
func()
報錯信息：
UnboundLocalError: local variable 'func1' referenced before assignment
原因

 語句在函數上面，無法調用

解決辦法

 把調用語句和函數換位置

2
def func():
    choose = int(input("> "))
    def func1():
        print("func1")
    def func2():
        print("func2")
        def func2_1():
            print("func2.1")
    if choose == 1:
        func1()
    elif choose == 2:
        func2()
    print("func")
func1()
報錯信息
NameError: name 'func1' is not defined
原因

 調用函數最多一層，比如在函數外面，不可能跨越兩層調用func1函數，跨級太多😸。

解決辦法

 先調用進func函數，再調用func1，更高級的辦法我也不知道😄呵呵o(￣︶￣)o

Lambda表達式

前言

 理解了函數類型和函數對象😀，學習Lambda就簡單了，就是一種函數吧，准確的說，是個解決一兩步的方法，小方法。😆

正題

 Lambda是一種匿名函數，匿名函數也是函數，有函數類型，也可以創建函數對象。
 定義Lambda表達式格式如下：
lambda 參數列表 : Lambda體
 Lambda是關鍵字聲明，這是一個Lambda表達式，“參數列表”與函數的參數列表是一樣的，但不需要小括號括起來，冒號后面是“Lambda體”，Lambda表達式的主要代碼在此處編寫，類似於函數體😏。

 **注意：**Lambda體部分不能是一個代碼塊，不能包含多余語句，只能有一條語句，語句會計算一個結果返回給Lambda表達式，但是與函數不同的是，不需要使用return語句返回。與其他語言中的Lambda表達式相比，Python中提供的Lambda表達式只能處理一些簡單的運算。

實例：

#-*- coding = utf-8 -*-

def calculate_fun(opr):
    ''' #定義相加函數 def add(a, b): return a + b #定義相減函數 def sub(a, b): return a - b '''
    if opr == '+':
        # return add
        return lambda a, b : (a + b)
    else:
        # return sub
        return lambda a, b : (a - b)
    
f1 = calculate_fun('+')
f2 = calculate_fun('-')

print(type(f1))

print("10 + 5 = {0}".format(f1(10, 5)))
print("10 - 5 = {0}".format(f2(10, 5)))

運行結果：

<class 'function'>
10 + 5 = 15
10 - 5 = 5

這個Lambda返回看來是“function”？
 上面的程序注釋部分原本是一個舊程序，大家可以把Lambda部分去掉，把注釋部分恢復，可以再試試。😄
 上面代碼return lambda a, b : (a + b)替代了add()函數，return lambda a, b : (a - b)替代了sub()函數，使得函數更快。

The END

幕后

 今天我又學習python了😎，哈哈，本人努力為大家寫了一篇好文，也是給自己這個Python小白寫的整理，Lambda這些東東還是有難度的，在VScode上忙碌2小時，弄明白了！😄，所以麻煩點一個贊，謝謝！😋

在這里插入圖片描述

THE END幕后

相信很多人看出來了，這個博客是我把多期的筆記融合在了一起，呵呵

  1. x ** x 輸出表達式 ↩︎

  2. x 元素變量 ↩︎

  3. range(10) 輸入序列 ↩︎

  4. if x % 2 == 0 ↩︎


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 python 爬蟲新手入門教程 spoon新手入門教程 axure新手入門教程 python入門教程(非常詳細)_Python自學 Nginx 極簡入門教程！ 油猴腳本管理器的超詳細下載安裝使用教程——新手必看 Python基礎教程，Python入門教程（非常詳細） Python基礎教程，Python入門教程（非常詳細） Modelsim仿真新手入門最詳細教程 Anaconda創建python虛擬環境（使用conda創建）新手小白入門必看
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM