看到這位頭發(fā)濃密大叔了嗎！1989年，為了打發(fā)圣誕節(jié)假期，龜叔(吉多·范·羅蘇姆)開始寫Python語言的編譯器 。
1991年，第一個Python編譯器誕生

Python這個名字，來自龜叔所摯愛的電視劇Monty Python’s Flying Circus (蒙蒂·蟒蛇的飛行馬戲團(tuán)）

我們?yōu)槭裁匆獙W(xué)習(xí)這一項(xiàng)語言，Python有以下幾個優(yōu)點(diǎn)

• 技術(shù)趨勢：Python自帶明星屬性多年穩(wěn)居編程語言前三

• 簡單：Python開發(fā)代碼少，閱讀一個良好的Python程序就感覺像是在讀英語一樣，Python的這種代碼本質(zhì)是它最大的優(yōu)點(diǎn)之一。它使你能夠?qū)Ｗ⒂诮鉀Q問題而不是去搞明白語言本身。

• 易學(xué)：就如同你即將看到的一樣，Python極其容易上手。前面已經(jīng)提到了，Python有極其簡單的語法，在開發(fā)同等業(yè)務(wù)下，相比C語言、java語言，Python語言開發(fā)的代碼精簡的多。

• 免費(fèi)、開源：Python開源的。簡單地說，你可以自由地閱讀它的源代碼、對它做改動、這是為什么Python如此優(yōu)秀的原因之一，它是由一群希望看到一個更加優(yōu)秀的Python的人創(chuàng)造并經(jīng)常改進(jìn)著的。

• 可移植性：由于它的開源本質(zhì)，Python已經(jīng)被移植在許多平臺上（經(jīng)過改動使它能夠工作在不同平臺上），所有Python程序無需修改就可以在下述任何平臺上面運(yùn)行。

• 豐富的庫：Python標(biāo)準(zhǔn)庫確實(shí)很龐大。它可以幫助你處理各種工作，包括正則表達(dá)式、文檔生成、單元測試、線程、數(shù)據(jù)庫、網(wǎng)頁瀏覽器、CGI、FTP、電子郵件、XML、XML-RPC、HTML、WAV文件、密碼系統(tǒng)、GUI（圖形用戶界面）、Tk和其他與系統(tǒng)有關(guān)的操作。記住，只要安裝了Python，所有這些功能都是可用的。這被稱作Python的“功能齊全”理念。

• 解釋性：Python編程語言不需要編譯，直接運(yùn)行

• 規(guī)范的代碼：Python采用強(qiáng)制縮進(jìn)的方式，使代碼具有良好的閱讀性。

缺點(diǎn)：

• 執(zhí)行效率較慢（相比于C和C++而言）若有速度要求，可使用C/C++來改寫關(guān)鍵部分！當(dāng)然了，這個缺點(diǎn)也被計(jì)算機(jī)越來越強(qiáng)大的性能所彌補(bǔ)。
• Python第三方庫超多比如requests、PySpark、PyFlink、Django、Flask等等，不過，這也從側(cè)面說明：Python語言優(yōu)秀，吸引的人才多，開發(fā)的項(xiàng)目庫也多。

每個人對Python語言都有不同的看番，接下來我們開始我們python的學(xué)習(xí)吧！

目前，Python有兩個大版本，分別是 Python2 和 Python3，我們本次教程主要為Python3大版本
Python官網(wǎng)：python.org

第一章 Python安裝

1.1 Python環(huán)境的安裝

在學(xué)習(xí)一項(xiàng)語言之前，我們必須下載相關(guān)的安裝包并配置相關(guān)環(huán)境，然而在生產(chǎn)環(huán)境中，我們?般不會選擇最新版本的Python，因?yàn)榭赡軙嬖谖粗狟ug，所以?般強(qiáng)烈建議大家在選擇軟件版本時(shí)，向前推1 ~ 2個版本。本節(jié)內(nèi)容我們將來配置Python環(huán)境。

安裝Python注意事項(xiàng)：

• 不要將Python安裝在中文目錄下
• 安裝時(shí)記得勾選【將Python解釋器安裝路徑添加到Path環(huán)境變量】選項(xiàng)
• 安裝完成后，在cmd窗口輸入python命令查看是否安裝成功，若沒出現(xiàn)python版本號，則需要去Path環(huán)境變量中去查看是否有Python內(nèi)容

• Python官網(wǎng)：python.org

?

①下載好Python解釋器后我們可以開始安裝

點(diǎn)擊 Next



出現(xiàn)這個頁面就完事啦！

②驗(yàn)證是否安裝完成
調(diào)出cmd窗口命令，并輸入python，若出現(xiàn)版本號，則成功！

?

1.2 用python輸出“Hello，World”

作為程序員學(xué)習(xí)一項(xiàng)語言的例行公事，怎么能不對世界說你好呢！

?

1.3 Python解釋器以及開發(fā)工具

• 前面我們下載的python其實(shí)包含了python解釋器，我們在運(yùn)用python時(shí)需要通過python解釋器，因此要在窗口命令行輸入 python，但在Python的開發(fā)領(lǐng)域，其開發(fā)工具非常非常多，EditPlus、Notepad++、Sublime Text3、Visual Studio Code、PyCharm（目前功能最強(qiáng)大的IDE）接下來我們要下載python開發(fā)工具，當(dāng)下全球Pyhon開發(fā)者我使用最頻繁的工具軟件PyCharm繼承開發(fā)工具（IDE）
• Pycharm下載網(wǎng)站
  下載配置完后市這樣子的，各式各樣開發(fā)工具千奇百態(tài)，選擇自己喜歡的工具就行了哦，這里就不多贅述了！

1.2.1 Pycharm常用快捷鍵
1、代碼補(bǔ)全：回車、換行
2、代碼保存：CTRL+S
3、快速復(fù)制一行：CTRL+D
4、代碼格式化：CTRL+ALT+L

?

第二章 Python基礎(chǔ)

2.1 Python基礎(chǔ)-注釋

注釋指的是：在程序，對代碼進(jìn)行解釋說明的文字
首先強(qiáng)調(diào)一件事：Python代碼 => Python解析器 => 機(jī)器語言，但是注釋經(jīng)過了Python的解釋器并不會解析與執(zhí)行。
注釋對代碼有解釋說明，這樣可以讓別然可以看得懂代碼的作用，增強(qiáng)了程序的可讀性。

在Python中，注釋分為兩類

• 單行注釋：對一小行代碼做局部注釋說明
  語法: # 內(nèi)容

• 多行注釋： 1、定義類、模塊，要做多行注釋，能讓讀者知道含義；2、定義函數(shù):在函數(shù)名的第1行代碼處做多行注釋。
  語法："""內(nèi)容"""

演示效果

Tip：快速注釋快捷鍵：ctrl+/（先將需要注釋的內(nèi)容括起來）

?

2.2 Python基礎(chǔ)-關(guān)鍵字和標(biāo)識符

標(biāo)識符
標(biāo)識符，相當(dāng)于調(diào)用內(nèi)存地址的一個映像外號。

標(biāo)識符要遵守五個命名規(guī)范：

1. 精簡、見名知意
2. 由數(shù)字、字母、下劃線組成，且開頭不為數(shù)字
3. 區(qū)分大小寫
4. 不能和關(guān)鍵字同名

常見的命名方法

（1）小駝峰命名法
（2）大駝峰命名法
（3）下劃線來_來鏈接所有詞語

注意：這里的常見命名方法屬于編程【道德】，就是在標(biāo)識符命名規(guī)范的基礎(chǔ)上，增加了額外要求。

為了給Python標(biāo)識符新增一些額外的要求，常見的有

1. 變量名/函數(shù)名/方法名：所有字母都小寫，且單詞之間用下環(huán)線_連接
2. 模塊名：所有字母均小寫；
3. 類名：遵循大駝峰命名法
4. 常量：都大寫
   關(guān)鍵字是指的是在Python語言中，已經(jīng)使用的一些詞語，具有特殊意義。在創(chuàng)建名字時(shí)，不能創(chuàng)建與關(guān)鍵字同名！
   我們可以使用keywork庫中的.kwlist進(jìn)行查看Python中的關(guān)鍵字

# 1.導(dǎo)入庫
import keyword

# 2. 列出關(guān)鍵字
print(keyword.kwlist)

?

2.5 Python基礎(chǔ)-數(shù)據(jù)類型

常量與變量

常量： 在程序運(yùn)行過程中不會變化的量
變量： 在程序運(yùn)行過程中發(fā)生變化的量
無論是變量還是常量，在創(chuàng)建時(shí)都會在內(nèi)存開辟一塊控件，用于保存它的值

1、變量不需要聲明類型
Python的變量和常量不需要事先聲明類型，這是個根據(jù)Python的動態(tài)語言特性而來的

2、賦值比較
這個知識點(diǎn)最重要的就是區(qū)分賦值和比較，在Python==是比較，=為賦值，比如下列的表達(dá)式

age = 18
name = "ziwu"

3、先創(chuàng)建再使用
每個變量在使用前都必須賦值，變量賦值后在會被創(chuàng)建。若是直接引用未定義的變量，會包以下錯誤

age # 直接執(zhí)行
NameError: name 'age' is not defined

4、賦值背后的原理
在Python中，一切都是對象，變量就是對象的引用
當(dāng)我們寫代碼age = 18時(shí)，Python解釋器干了兩件事

• 在內(nèi)存中創(chuàng)建了一個18的對象
• 在內(nèi)存中創(chuàng)建了名為age的變量，并把它指向18

我們可以通過id查看這些原理

# 內(nèi)存中創(chuàng)建了'ziwu'的字符串對象
# 將'ziwu'的地址賦予給a
# a的地址賦予給b
a = 'ziwu'
b = a
print(id('ziwu'))
print(id(a))
print(id(b))
# 結(jié)果為 'ziwu'、a、b的三個地址值都相同

字符串類型

1、如何定義字符串
可以使用 單引號、雙引號、三引號來創(chuàng)建字符串

a = 'ziwu'
a1 = "ziwu"
a2 = """ziwu"""
a3 = '''ziwu'''
print(a==a1==a2==a3)
# 輸出結(jié)果為true

2、字符串常用的方法
對象有很多實(shí)用的方法，這里舉例產(chǎn)假概念的幾個，后面第五章會詳細(xì)講解字符串的一些方法！

• 分割字符串:指定分隔符分割字符串

a = 'ziwu,sumi,xixiha'
b = a.split(',')
print(b)
print(type(b))
# ['ziwu', 'sumi', 'xixiha']
# <class 'list'>

整數(shù)和浮點(diǎn)數(shù)

整數(shù)
通常被稱整型，表示數(shù)字時(shí)我們有時(shí)會用十六進(jìn)制和八進(jìn)制表時(shí)，他們的類型也為整型
浮點(diǎn)數(shù)
浮點(diǎn)數(shù)也就是小數(shù)，例如1.1，3.14，1.2
對于一些過大的小數(shù)我們會用科學(xué)計(jì)數(shù)法去表示
例如：3.14e2為314.00，e2相當(dāng)于x100，或則小數(shù)點(diǎn)向右移兩位

a = 1.2e10
print(a)
# 12000000000.0

布爾值

在Python中布爾值有倆：True、False（首字母大寫）
Python內(nèi)置的bool()函數(shù)可以來測試一個表達(dá)式的布爾結(jié)果

print(bool(1>2))

變量的定義非常的簡單，Python定義變量和常量不用實(shí)現(xiàn)聲明類型，但必須賦值后才能調(diào)用，我們在學(xué)習(xí)其他編程語言的時(shí)候已經(jīng)接觸過一些數(shù)據(jù)類型，當(dāng)然在python也不例外，為了應(yīng)對不同的業(yè)務(wù)需求，也

會把數(shù)據(jù)分為不同的類型，如下圖所示：

面試題：請手寫出Python中的7種數(shù)據(jù)類型？

答：數(shù)值類型、布爾類型、字符串類型、列表類型、元組類型、集合類型、字典類型

問題：如何判斷一個變量到底是什么類型？

答：① 使用type(變量名稱)方法，返回變量的數(shù)據(jù)類型 ② isinstance(變量名稱,數(shù)據(jù)類型)，只能返回True或False（真的還是假的）

• 上述我們問題二中提到了如何獲取該數(shù)據(jù)的數(shù)據(jù)類型語句：type(變量名稱)

例題：

# 方式1：使用print直接輸出類型信息
name = 'Tom'
age = 18
print(type(age))
name = '大白菜'
price = 3.5
print(type(price))

# 方式2：使用變量存儲type（）語句的結(jié)果
string_type = type("ziwu")
print(string_type)

# 方式3：使用type（）語句，查看變量存儲的數(shù)據(jù)類型信息
name = 666
name_type = type(name)
print(name_type)

?

2.6 Python基礎(chǔ)-print輸出函數(shù)

print函數(shù)我們其實(shí)已經(jīng)不陌生了，前前后后也用了不少次，多少有點(diǎn)經(jīng)驗(yàn)，明白點(diǎn)它的用法了。

print函數(shù)用于將內(nèi)容格式化顯示在標(biāo)準(zhǔn)輸出上，主要指的是屏幕顯示器。

print可以接受多個字符串，字符串類型的變量或者可print的對象。每個字符串用逗號“,”隔開，連成一串輸出。print會依次打印每個字符串，同時(shí)，每遇到一個逗號","就輸出一個空格。

print是一個函數(shù)，用于輸出信息內(nèi)容

另外的，如果想要讓print()輸出更美觀些，也可以使用轉(zhuǎn)義字符來處理。
轉(zhuǎn)義字符，指的是無法直接表達(dá)本身含義，就需要轉(zhuǎn)化含義來顯示。
轉(zhuǎn)義字符有：

若要給一個字符轉(zhuǎn)義，通常要加入轉(zhuǎn)義符 \

**tip:快速上下移動代碼：**ctrl+shift+↑/↓

?

2.7 Python基礎(chǔ)-格式化輸出

目前為止，我們所有的輸出都是直接通過print(變量名稱)形式直接打印的。但是實(shí)際工作中，我們可能需要對變量的輸出進(jìn)行格式化操作（按照一定格式進(jìn)行輸出）。
基本語法:

...
print(變量名稱)
print('字符串%格式' % (變量名稱))
print('字符串%格式 %格式 %格式' % (變量名稱1, 變量名稱2, 	變量名稱3))

荔枝（以下例子是不是簡潔多了呢）：

name = "ziwu"
age= 18
print("IT大牛是%s" %(name))
print("我的名字是%s,我的年齡僅僅%d" %(name,age))

其中的，%s
% 表示：我要占位
s 表示：將變量變成字符串放入占位的地方
d 表示：將變量變成整數(shù)放入占位的地方

所以，綜合起來的意思就是：我先占個位置，等一會有個變量過來，我把它變成字符串放到占位的位置
當(dāng)多個表變量占位，變量要用括號括起來，并按照占位符順序填入

當(dāng)然不僅僅只有%s可以使用，下列表格列出了 python 中常見%格式。

更多格式化符號不再過多文章節(jié)是，下圖參考

?

2.7.1 Python基礎(chǔ)-格式化輸出拓展-格式化精度控制

在%d、%f中我們可以使用輔助符號"m.n"來控制數(shù)據(jù)的寬度和精度

m，控制寬度，要求是數(shù)字（很少使用）,設(shè)置的寬度小于數(shù)字自身，不生效
.n，控制小數(shù)點(diǎn)精度，要求是數(shù)字，會進(jìn)行小數(shù)的四舍五入，而整形不考慮小數(shù)位置，因此%d不考慮控制精度

示例：
%5d：表示將整數(shù)的寬度控制在5位，如數(shù)字11，被設(shè)置為5d，就會變成：[空格][空格][空格]11，用三個空格補(bǔ)足寬度。
%5.2f：表示將寬度控制為5，將小數(shù)點(diǎn)精度設(shè)置為2
小數(shù)點(diǎn)和小數(shù)部分也算入寬度計(jì)算。如，對11.345設(shè)置了%7.2f 后，結(jié)果是：[空格][空格]11.35。2個空格補(bǔ)足寬度，小數(shù)部分限制2位精度后，四舍五入為 .35
%.2f：表示不限制寬度，只設(shè)置小數(shù)點(diǎn)精度為2，如11.345設(shè)置%.2f后，結(jié)果是11.35

多值一起案例：

name = "ziwu"
year = 3
money = 100000.56
print("我的名字是%s,工作%d年了，工資%.2f元了" % (name, year, money))

?

2.8 Python基礎(chǔ)-format方法簡化輸出

除了上述格式化輸出方式外，也可以使用format()函數(shù)處理
format格式：

print('字符串{}'.format(變量名稱1))
print('{}字符串{}'.format(變量名稱1, 變量名稱2))

原來的 format 格式輸出比較繁瑣，在Python3.6以后版本，為了簡化format輸出操作，引入了一個簡寫形式：
語法：f"內(nèi)容{變量}"

name = "ziwu"
age= 18
print("IT大牛是{},年齡為{}".format(name,age))
print(f"IT大牛是{name}，年齡為{age}")

特點(diǎn)：

• 不理會類型直接插入
• 不做精度控
• 適合對精度沒有要求的時(shí)候快速使用

當(dāng)然，你也可以對format做精度控制：

a = 132.456
print(f"這個數(shù)字是{a:.2f}")

還有一種方法，用字符串切片的方式，我們會在第五章講解：

a = 132.456
result = str(a)
result = result[:result.index(".")+3]
print(result)

?

2.9 Python基礎(chǔ)-字符串拓展-格式化輸出中的轉(zhuǎn)義符號

在字符串中，如果出現(xiàn)了\t和\n，其代表的含義就是兩個轉(zhuǎn)義字符

\t ：制表符，一個tab鍵（4個空格）的距離
\n ：換行符

案例：

print('*\t*\t*')
print('hello\nworld')

特別說明：默認(rèn)情況下，每個print()方法執(zhí)行完畢后，都會輸出一個\n換行符。如果不想讓print()方法換行，可以添加一個end參數(shù)

print('*', end='')

?

2.10 Python基礎(chǔ)-數(shù)據(jù)輸入

到目前為止，我們所有的程序都只能把數(shù)據(jù)輸出給用戶。但是實(shí)際工作中，我們經(jīng)常輸入獲取用戶的輸入信息，如銀行系統(tǒng)中的密碼輸入、淘寶中的用戶登錄驗(yàn)證，以下介紹Python中怎么進(jìn)行數(shù)據(jù)輸入。

語法：input()

也可以在input（）的括號中輸入內(nèi)容，寓意為在前面print一串內(nèi)容

input()默認(rèn)接收的都是字符串，如果想接受數(shù)據(jù)，請自行進(jìn)行類型轉(zhuǎn)換！

小結(jié)：
① input()可以用于接收由外部設(shè)備輸入的信息，但是如果用戶沒有輸入任何內(nèi)容，則input()函數(shù)會中止當(dāng)前代碼的繼續(xù)執(zhí)行，處于等待狀態(tài)，直到用戶輸入結(jié)束。
② 所有由input()方法獲取的數(shù)據(jù)都是字符串類型，如果要使用，則要進(jìn)行類型轉(zhuǎn)換，下列是類型轉(zhuǎn)換表。

?

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

在Python中，若要把某數(shù)據(jù)轉(zhuǎn)換為指定數(shù)據(jù)類型的結(jié)果，語法：指定數(shù)據(jù)類型(變量名)
數(shù)據(jù)轉(zhuǎn)換的類型有:

③eval(str) 用來將已轉(zhuǎn)換后的數(shù)據(jù)結(jié)果，重新轉(zhuǎn)換為原始數(shù)據(jù)類型。

a = "True"
b = "3.14"
print(type(eval(a)))
print(type(eval(b)))

?

2.12 Python基礎(chǔ)-運(yùn)算符

所謂的算數(shù)運(yùn)算符就是我們?nèi)粘Ｉ钪械募訙p乘除等待。
①算數(shù)運(yùn)算符

②賦值運(yùn)算符

③復(fù)合賦值運(yùn)算符

?
?

第三章 判斷

3.1 Python判斷語句-布爾值和比較運(yùn)算符

布爾值字面量：

• True 表示真
• False 表示假

定義變量存儲布爾值類型數(shù)據(jù)：
變量名稱 = 布爾值字面量在定義時(shí)需要注意True、False開頭字母為大寫

比較運(yùn)算符

邏輯運(yùn)算符（與或非）

not：就是取反，只有一個表達(dá)式not 表達(dá)式，如果表達(dá)式為True，則not以后就返回False。反之，則返回True。
and ：邏輯與，只有當(dāng)兩邊的表達(dá)式全部為真，則最終結(jié)果返回為真，否則返回為假。
or ：邏輯或，只要有一方為真，則整個表達(dá)式的返回結(jié)果就為真。除非兩邊的表達(dá)式都為假，則整個結(jié)果返回為假。

擴(kuò)展：短路運(yùn)算(邏輯運(yùn)算符)
在Python代碼中，邏輯運(yùn)算符的運(yùn)算，要遵循短路運(yùn)算原則。
① 表達(dá)式1 and 表達(dá)式2，如果表達(dá)式1條件為真，則最終的運(yùn)算結(jié)果由右邊的表達(dá)式2來決定。如果表達(dá)式1條件為假，則最終結(jié)果為假。其右邊的表達(dá)式2不需要在進(jìn)行運(yùn)算。
② 表達(dá)式1 or 表達(dá)式2，如果表達(dá)式1為真，則最終的運(yùn)算結(jié)果由表達(dá)式1來決定，為真。如果表達(dá)式1為假，則最終結(jié)果由表達(dá)式2來決定。如果表達(dá)式2為真，則最終結(jié)果為真，如果表達(dá)式2為假，則最終結(jié)果為假。

在邏輯運(yùn)算中，不一定邏輯運(yùn)算符的兩邊都是純表達(dá)式，也可以是數(shù)值類型的數(shù)據(jù)或字符串類型的數(shù)據(jù)。
Python把0、空字符串和None看成 False，其他數(shù)值和非空字符串都看成 True，所以： 空字符串就是只有一對引號的字符串，''或""

[了解]運(yùn)算符優(yōu)先級：

?

3.2 Python判斷語句-if語句的基本格式

這是java中的條件判斷語句:

if (條件判斷) {
    則執(zhí)行某段代碼...
}

但是Python中，不需要使用這么多復(fù)雜的符號，直接可以編寫條件判斷及執(zhí)行某段代碼

Python：

if 判斷條件:
	(Tab縮進(jìn))條件成立時(shí)，要進(jìn)行的語句
# 例題
age = 18
if age >= 18
	print("我是老八，我已過18！")

if單分支語句選擇原理圖：學(xué)編程除了會寫代碼還不行，還要回畫圖（流程圖）

（1）條件的結(jié)果總是布爾型的；
（2）注意：if語句后記得使用Tab進(jìn)行強(qiáng)制縮進(jìn)。

?

3.3 Python判斷語句-if else語句的基本格式

相比3.2，此條件語句可以列舉出條件不成立時(shí)執(zhí)行的語句

if 要判斷的條件:
	條件成立時(shí)，要進(jìn)行的語句
else：
	條件不成立時(shí)執(zhí)行的語句
# 例題
age = 18
if age >= 18
	print("我是老八，我已過18！")
else：
	print("我未成年")

else關(guān)鍵字不能單獨(dú)使用，使用時(shí)要注意好格式

if…else…雙分支語句結(jié)構(gòu)原理圖：

?

3.4 Python判斷語句-if elif else語句的基本格式

相比3.3，此條件語句可以列舉出多條件成立時(shí)執(zhí)行的語句

if 要判斷的條件:
	條件成立時(shí)，要進(jìn)行的語句
elif 要判斷的條件
	條件成立時(shí)的語句
else：
	條件不成立時(shí)執(zhí)行的語句
# 例題
age = int(input("動物園門票購買，請輸入你的身高"))
if age < 120:
	print("免費(fèi)")
elif age >= 120:
	print("繳費(fèi)60元")
else:
	print("神秘代碼，系統(tǒng)出錯")

if多分支語句多重條件判斷原理圖：

?

3.5 Python判斷語句-判斷語句的嵌套

if 外層條件判斷:
    # 如果條件為True，則執(zhí)行以下語句段
    if 內(nèi)層條件判斷:
        # 如果內(nèi)層條件為True，則執(zhí)行以下語句段
else:
    # 如果條件為False，則執(zhí)行以下語句段

嵌套結(jié)構(gòu)看起來異常復(fù)雜，但是我們在編寫時(shí)要遵循一個原則：先編寫外層判斷，所有語句編寫完成后，在編寫內(nèi)層條件判斷結(jié)構(gòu)。
第二個if，屬于第一個if里面，只有第一個if執(zhí)行成功，第二個if才開始執(zhí)行
接下來寫一段猜數(shù)字代碼

# 構(gòu)建一個隨機(jī)的變量
import random
num = random.randint(1,10)

guess_num = int(input("輸入你想要猜測的數(shù)據(jù)："))

# 判斷語句
if guess_num == num:
    print("真厲害，一次猜中")
else:
    if guess_num > num:
        print("你猜測的數(shù)字大了")
    else:
        print("你猜測的數(shù)字小了")

    guess_num = int(input("請?jiān)俅屋斎肽阆胍聹y的數(shù)據(jù)："))

    if guess_num == num:
        print("第二次就猜中了，好厲害呀！")
        exit(0)
    else:
        if guess_num > num:
            print("你猜測的數(shù)字大了")
        else:
            print("你猜測的數(shù)字小了")

        guess_num = int(input("請最后輸入你想要猜測的數(shù)據(jù)："))

        if guess_num == num:
            print("第三次就猜中了，好厲害呀！")
        else:
            print("沒有機(jī)會了，告辭")

綜合案例：剪刀石頭布
參與游戲的角色有兩個（玩家 與 電腦），玩家手工出拳，電腦隨機(jī)出拳，根據(jù)石頭剪刀布判斷輸贏。

玩家：player（玩家手工輸入石頭0、剪刀1、布2）

電腦：computer（隨機(jī)出拳）

輸贏結(jié)果很重要，有三種情況：

① 玩家贏

☆ player：石頭 贏 computer：剪刀

☆ player：剪刀 贏 computer：布

☆ player：布 贏 computer：石頭

② 平局

只要player 與 computer出拳相等，就代表平局

③ 電腦贏

如果不滿足以上兩個條件，則電腦獲勝！

未知知識點(diǎn)：如何讓計(jì)算機(jī)隨機(jī)出拳 => 隨機(jī)(random)

# 1.導(dǎo)入庫
import random

# 2.顯示操作界面
# 6.多次重復(fù)操作
while True:
    print("================================")
    print("猜拳小游戲操作有:")
    print("\t（1）石頭")
    print("\t（2）剪刀")
    print("\t（3）布")
    print("================================")
    # 3.玩家出拳
    player = int(input("請輸入出拳方式:"))
    # 4.電腦出拳（動態(tài)）
    computer = random.randint(1,3)
    # 5.判斷
    if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
        print("恭喜您, 勝利了!!!")
    elif player == computer:
        print("==========平局.")
    else:
        print("你輸了, 不要走, 洗洗手再來一把!!")

# 擴(kuò)展
# 需求1: 改進(jìn)程序, 在輸出時(shí)把電腦和玩家的出拳方式顯示出來
# 需求2: 可以讓用戶退出玩游戲
# 【思考】需求3: 用戶就不輸入1/2/3、輸入非數(shù)字(程序出錯? 如何改進(jìn)解決?)

?

3.6 Python判斷語句-三目運(yùn)算符

1、什么是三目運(yùn)算符

在Python中三目運(yùn)算符也叫三元運(yùn)算符，其主要作用：就是用于簡化if…else…語句。

if 條件判斷:
    # 語句段1
else:
    # 語句段2

轉(zhuǎn)換為三目運(yùn)算符

語句段1 if 條件判斷 else 語句段2

?

第四章 循環(huán)

在Python中，循環(huán)一共分為兩大類：while循環(huán)與for循環(huán)

思考問題：while循環(huán)和for循環(huán)如何選擇呢？

① 對于循環(huán)次數(shù)已知的情況，建議使用while循環(huán)

② 對于循環(huán)次數(shù)未知的情況，建議使用for循環(huán)
但是有了 range 關(guān)鍵字的加入，for循環(huán)更加精簡！在后期使用時(shí)，優(yōu)先推薦for循環(huán)

4.1 Python循環(huán)語句-while循環(huán)的基礎(chǔ)

基本語法：

# ① 定義一個計(jì)數(shù)器（初始化一個計(jì)數(shù)器）
i = 0或1
# ② 編寫while循環(huán)結(jié)構(gòu)
while 循環(huán)條件(判斷 計(jì)數(shù)器 是否達(dá)到了目標(biāo)位置):
	循環(huán)體1
	循環(huán)體2
	...
	# ③ 在循環(huán)內(nèi)部更新計(jì)數(shù)器
	i = i + 1 或 i += 1

# 例題
i = 0
while i < 100
	print("喵喵喵")
	i += 1

# 1~100的和
i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

# 猜數(shù)字
#定義隨機(jī)數(shù)
import random
num = random.randint(1,100)

input_num = int(input("請輸入數(shù)字"))
count = 0
while input_num != num:
    if input_num<num:
        print("小了")
        input_num = int(input("請輸入數(shù)字："))
        count += 1
    else:
        print("大了")
        input_num = int(input("請輸入數(shù)字:"))
        count += 1

print(f"猜對了,你一共猜了{count}次")

while循環(huán)流程圖：

?

4.2 Python循環(huán)語句-while循環(huán)的嵌套運(yùn)用

我們運(yùn)用案例來了解while的嵌套運(yùn)用

# 我們小明每天表白100天，且要送10朵玫瑰
# 外層： 表白100天
# 內(nèi)層： 送玫瑰花
i = 1
# 外層
while i <= 100:
    print(f"今天時(shí)第{i}天，準(zhǔn)備表白")

    #內(nèi)層
    j = 0
    while j < 10:
        print(f"送給小妹第{j}朵玫瑰花")
        j += 1

    print("小妹我喜歡你！")
    i += 1

# 九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f"{j}*{i}={i * j}\t", end='')
        j += 1

    i += 1
    print()

常見錯誤：

i = 1
result = 0
while i <= 100:
    if i % 2 == 0:
        result += i
        i += 1 ##這里語句是在 if內(nèi)的，不在while外循環(huán)內(nèi)
print(f'1~100之間所有偶數(shù)的和：{result}')

問題的原因：在于i += 1縮進(jìn)了2次，導(dǎo)致其和if形成了一個整體。while循環(huán)中計(jì)數(shù)器無法更新，最終導(dǎo)致以上代碼出現(xiàn)了死循環(huán)。

?

4.3 Python循環(huán)語句-for循環(huán)的基礎(chǔ)語法

for循環(huán)時(shí)一種“輪詢”機(jī)制，是對一批內(nèi)容進(jìn)行“逐個處理”！for循環(huán)也被稱為遍歷循環(huán)
另外當(dāng)循環(huán)次數(shù)未知的情況，建議使用for循環(huán)。

for 臨時(shí)變量 in 序列:
    循環(huán)滿足條件時(shí)執(zhí)行的代碼

Python中的for尋魂與其他高級語言中的for循環(huán)用法不一致，Python中的for循環(huán)時(shí)無法定義循環(huán)條件的，只能從處理數(shù)據(jù)集中，依次取出內(nèi)容進(jìn)行處理

# 數(shù)字符中一共有多少個i
name = 'itziwu is brand of itcast'
flag = 0
for x in name:
    if x == 'i':
        flag += 1

print(f"式子中一共有{flag}個i")

拓展1:
for與else搭配使用：

for 零時(shí)變量 in 序列:
	循環(huán)滿足條件時(shí)執(zhí)行的代碼
else：
	當(dāng)for循環(huán)[正常]執(zhí)行結(jié)束后，再執(zhí)行此代碼
	
# 例子
for temp in "itziwu"
	print(temp)
else:
	print("代碼遍歷完畢")

拓展2:
for死循環(huán)（沒意義這樣寫）:

lists = [1,2,2,3,4]
# 使 for 循環(huán)條件的序列范圍無限
for temp in lists:
	lists.append(temp)

?

4.4 Python循環(huán)語句-for循環(huán)-range語句、randint語句

Python2 range() 函數(shù)返回的是列表，而在Python3中 range() 函數(shù)返回的是一個可迭代對象（類型是對象），而不是列表類型， 所以打印的時(shí)候不會打印列表。（由于我們還未學(xué)習(xí)面向?qū)ο?，為了方便大家理解，你可以簡單的將其理解為一個序列結(jié)構(gòu)）

主要作用：獲取一個簡單的數(shù)字序列

語法1：range(num)獲取一個從0開始，到num的一個數(shù)字序列，不包括num本身，例如range（5）取得的數(shù)字序列為【0，1，2，3，4】
語法2：range(num1，num2)獲取一個從num1開始，到num2的一個數(shù)字序列，不包括num本身,例如range（1,5）取得的數(shù)字序列為【1，2，3，4】
語法2：range(num1，num2,step)獲取一個從num1開始，到num2的一個數(shù)字序列，不包括num本身,數(shù)字之間的差值為step,例如range（1,6,2）取得的數(shù)字序列為【1，3，5】

#1~100（不包含100）的偶數(shù)有多少個
count = 0
for x in range(1,100):
    if x % 2 == 0:
        count += 1

print(f"偶數(shù)有{count}個")

range有一個口訣：只顧頭不顧尾，包含頭部信息，但是不包含尾部信息，如range(10)，則返回0~9之間的序列，又比如range(0, 5)代表返回0 ~ 4之間的序列。

在Python中，要使用要隨機(jī)數(shù)，首先先要導(dǎo)入隨機(jī)數(shù) random 包

import random

random 包中產(chǎn)生隨機(jī)數(shù)的函數(shù):

與 range 不同， 括號內(nèi)的兩個數(shù)分別都能取到它本身

例題猜數(shù)字：
?

4.5 Python循環(huán)語句-for循環(huán)嵌套運(yùn)用

for循環(huán)之間的嵌套與while嵌套一致

# 表白100天，每天送10朵花

for i in range(1,101):
    print(f"今天是u第{i}天！")
    for x in range(1,11):
        print(f"送第{x}只玫瑰花，妹妹我愛你")
print("表白成功")

# 九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j} * {i} = {j * i}\t",end='')
    print()

?

4.6 Python循環(huán)語句-循環(huán)中斷continue、break

在python循環(huán)中，經(jīng)常會遇到兩個常見的關(guān)鍵詞：break 與 continue , 這兩個語句都是都能改變流程控制。

# 某公司，賬戶余額有1W元，給20名員工發(fā)工資。
# 員工編號從1到20，從編號1開始，依次領(lǐng)取工資，每人可領(lǐng)取1000元
# 領(lǐng)工資時(shí)，財(cái)務(wù)判斷員工的績效分（1-10）（隨機(jī)生成），如果低于5，不發(fā)工資，換下一位
# 如果工資發(fā)完了，結(jié)束發(fā)工資。
import random
money = 10000
#外循環(huán)員工
for x in range(1,21):
    if money <= 0:
        break
    else:
        point = random.randint(1, 10)
        if point < 5:
            print(f"員工{x}的績效為{point},低于5，不發(fā)工資")
        else:
            print(f"員工{x}的績效為{point},發(fā)工資1000元")
            money -= 1000

?

4.6 Python循環(huán)語句-死循環(huán)

在編程中一個無法自我停止的循環(huán)被稱為”死循環(huán)“
在Python中，我們也可以使用while True來模擬死循環(huán)

while True
	print("我停不下來啦！")

?

第五章

在現(xiàn)實(shí)生活中，我們知道容器是用來存放東西的，比如實(shí)驗(yàn)室里的燒杯等。

類似的，在Python中的容器是用來存放數(shù)據(jù)的。

與此同時(shí)，為了操作方便，Python給我們提供了對容器中數(shù)據(jù)處理的方法，例如增加、刪除、修改、查詢等。

變量名.函數(shù)(x)

在Python中，常見容器有：

5.1 字符串

字符串表示文本內(nèi)容，例如中文文字、學(xué)生姓名、一段英文等。

通俗地說，字符串就是使用雙引號引起來的內(nèi)容。

創(chuàng)建字符串語法：

變量名 = "內(nèi)容"

說明：

• 字符串可以使用雙引號或單引號表示，較常見的是雙引號表示

字符串可以使用雙引號或單引號表示，較常見的是雙引號表示。

5.1.1 字符串索引下標(biāo)

如果有字符串: name = 'abcdef' ，在內(nèi)存中的實(shí)際存儲如下: 【要定義了變量，就會在電腦內(nèi)存中開辟一塊空間(內(nèi)存地址值)，用于表示變量?！?br>
例如，我們要獲取name中的b和c，要怎么獲取(變量名[索引])，**若查看字符串的長度，可以使用如下函數(shù)：

# 定義
name = "abcdef"
# 取第一個和最后一個字符
print(name[0])
print(name[5])
print(name[len(name)-1])

不可變類型的內(nèi)存變化：不可變類型的變量內(nèi)容變化了，地址值也變化了；而可變類型無論內(nèi)容變化，都用的是同一個地址值。而我們的字符串是不可變類型（id(變量名)查看地址值）

strs = "Hello"
print(id(strs))
# 2405697181680

strs2 = strs + "World"
print(id(strs))
# 2405697543664

字符串的While循環(huán)
我們字符串的while遍歷是基于len()函數(shù)的基礎(chǔ)上去遍歷的，代碼:
（1）定義一個字符串變量，內(nèi)容為：ABCDEF；

（2）使用while循環(huán)來遍歷元素；

（3）執(zhí)行程序，觀察效果。

# 1.定義變量
strs = "ABCDEF"
# 2.遍歷   0-最大索引值
i = 0
# while i <= (len(strs)-1):
while i < len(strs):
    print(strs[i])
    i += 1

# 3.擴(kuò)展: 反轉(zhuǎn)??
# result = ""
# name = "itheima"
# # a  逆向
# i = len(name)-1
# while i >= 0:
#     # result = result + name[i]
#     result += name[i]
#     i -= 1
# print(f"反轉(zhuǎn)字符串結(jié)果為:{result}")

# b
# name = "itheima"
# print(name[::-1])  # 記住

字符串的for循環(huán)
（1）定義一個字符串變量，內(nèi)容為：ABCDEF；

（2）使用for循環(huán)來遍歷元素；

（3）執(zhí)行程序，觀察效果。

# 對齊
# 1.當(dāng)明確知道循環(huán)的次數(shù)時(shí) ,可以考慮使用while循環(huán)
# 2.當(dāng)不清楚要循環(huán)幾次時(shí), 優(yōu)先考慮使用for  -->優(yōu)先考慮使用for循環(huán)，更簡單

# 1.定義字符串
strs = "ABCDEF"
# 2.for遍歷
# for temp in strs:
#     print(temp)

# 3.擴(kuò)展: range()? -0，xx
# 變量名[索引值]
for index in range(0,len(strs)):
    print(strs[index])

?

5.1.2 字符串切片

字符串切片，就是將字符串一部分內(nèi)容截取，同樣與range()相同，左閉右開。
語法:

變量名[起始下標(biāo):結(jié)束下標(biāo)(:步長)]
# 括號內(nèi)容為附加，沒括號內(nèi)容默認(rèn)步長為1

注意：選取的區(qū)間屬于左閉右開型，即從“起始”位開始，到“結(jié)束”位的前一位結(jié)束(注意：不包含結(jié)束位本身)；注意：截取內(nèi)容時(shí)，包含起始位，但不包含結(jié)束位。
逆向排序：[::-1]

strs = "heyPython"

# 1、遍歷
temp = ""
for i in range(len(strs)):
    temp += strs[len(strs) - i - 1]
print(temp)

# 2、方法
temp1 = list(strs)
temp1.reverse()
print("".join(temp1))

# 3、切片
print(strs[::-1])

?

5.1.3 字符串常用的函數(shù)

Python容器為字符串提供了很多方法變量名.函數(shù)名（參數(shù)），接下來我們分別一一分析。

?

5.1.4 查找元素：find(),index(),count()

所謂字符串查找的方法即是查找子串（元素）在字符串中的位置或者出現(xiàn)次數(shù)

srs = "hello world and itcast and itziwu and Python"
#查找字符
print(srs.find("orld"))	#輸出為7
print(srs.index("orld"))	#輸出為7
print(srs.count("i"))	#輸出為2

5.1.5 修改元素：replace(),split()

src = srs.replace("itziwu", "itheima")
print(srs.replace("itziwu", "itheima"))
print(src)

srr = "java#11116#6742#ziwu"
print(srr.split("#"))
# 輸出結(jié)果為['java', '11116', '6742', 'ziwu']

5.1.6 居中center()

# 定義
name = "abcdef"

print(name.center(20))
print(name.center(20, '#'))

5.1.7 字母操作-大小寫操作

name = "abcdef"
new_name = name.upper()
print(new_name)
# ABCDEF

new_name = name.lower()
print(new_name)
# abcdef

new_name = name.capitalize()
print(new_name)
# Abcdef

new_name = name.swapcase()
print(new_name)
# ABCDEF

5.1.8 特殊語句

# 定義
name = 'abc&)#de#$ffs@#dffbd'
new_name = name.title()
print(new_name)
# 輸出為：Abc&)#De#$Ffs@#Dffbd

s = '  alexW%Usir  %2%  '
s9_1 = s.strip()   
#刪除字符串前后的空格
?
print(s9_1)   
#alexW%Usir  %2%
?
ss = '% alexW%Usir  %2%  %%%%'
s9_2 = ss.strip('%')   
#刪除字符串前后的%
?
print(s9_2)  
# alexW%Usir  %2%　

應(yīng)用例子：
在沒輸入數(shù)據(jù)前，或輸入完數(shù)據(jù)后，屏蔽空格，大大加高用戶體驗(yàn)！

username = input('請輸入名字：').strip()
if username == '小明':
    print('你好呀 主人')

5.1.9 is系列

5.1.10 連接

5.2 Python數(shù)據(jù)容器-列表的語法定義

一種可以容納多份數(shù)據(jù)的數(shù)據(jù)類型，每容納的一個容器稱之為一個元素，可以是任意數(shù)據(jù)類型。
語法：

# 定義變量
變量名稱 = [元素1, 元素2，元素3……]	# 多個元素之間使用,分割

# 定義空列表
變量名稱 = []
變量名稱 = list()

# 例子
name_list = ['itziwu','itcase', 'python']
my_list = ['itziwu',666,True]
new_list = [['itziwu',666,True],['itziwu','itcase', 'python']]

上述例子我們可以看到，數(shù)據(jù)容器內(nèi)可以同時(shí)存放多個不同類型的數(shù)據(jù)，數(shù)據(jù)容器之間也可以相互嵌套！接下來我們就學(xué)習(xí)如何利用列表的下標(biāo)取出數(shù)值！

列表中每個元素的下標(biāo)索引從前到后，從0開始，依次遞增；也可以反向取元素從-1開始，依次遞減，對應(yīng)元素從后向前；嵌套列表也同理，先取第一個列表，在從中取其中的元素（[0][1]）如下文例子

name_list = ['itziwu','itcase', 'python']
print(name_list[0])
# 輸出結(jié)果為itziwu
print(name_list[-1])
# 輸出結(jié)果為python

new_list = [['itziwu',666,True],['itziwu','itcase', 'python']]
print(new_list[0][1])
# 輸出結(jié)果為666
print(new_list[1][2])
# 輸出結(jié)果為python

此外我們可以用len（）查看列表有多少函數(shù)！

lists = ["深圳大學(xué)","深圳理工大學(xué)","南方科技大學(xué)"]
print(len(lists))

遍歷列表

• 使用while循環(huán)遍歷
• 使用for循環(huán)遍歷

lists = ["西瓜", "香蕉", "火龍果"]
# for循環(huán)
for temp in lists:
    print(temp)

# while循環(huán)
i = 0
while i < len(lists):
    print(lists[i])
    i += 1

?

5.2 Python數(shù)據(jù)容器-列表的常用操作

列表-增操作

new_list = ['itziwu',666,True]
new_list.append("新插入位置1")
print(new_list)
# 輸出值為 ['itziwu', 666, True , '新插入位置1']

new_list = ['itziwu',666,True]
old_list = ['ziwu',888,False]
new_list.extend(old_list)
print(new_list)
# 輸出值為 ['itziwu', 666, True, 'ziwu', 888, False]

new_list = ['itziwu',666,True]
new_list.insert(1,"新插入位置1")
print(new_list)
# 輸出值為 ['itziwu', '新插入位置1', 666, True]

列表-刪操作

new_list = ['itziwu',666,True,888]
del new_list[0]
new_list.pop(1)
new_list.remove(888)
print(new_list)
# 輸出值為 666

列表-改操作

new_list = ['itziwu',666,True]
new_list[1]= 888
print(new_list[1])
# 輸出為 888

列表-查操作

new_list = ['itziwu',666,True]
# 訪問下標(biāo)
index = new_list.index("itziwu")
print(index)
# 輸出為" 0 "

lists = ["192.168.1.15","172.168.46.128","177.32.25.44"]
# 訪問長度
print(f"現(xiàn)在黑名單一共：{len(lists)}")
ip = input("輸入你的ip")

# 是否存在
if ip in lists:
    print("黑名單")
else:
    print("訪問成功")

列表-其他操作

例題：動態(tài)驗(yàn)證碼：

import random

strs = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
code = ""
for temp in range(0, 6):
    index = random.randint(0, len(strs) - 1)
    text = strs[index]	# 隨機(jī)抽取元素
    code += text
print(f"當(dāng)前驗(yàn)證碼為：{code}")

?

5.3 Python數(shù)據(jù)容器-元組

元組也與列表一樣，可以存儲不同類型的數(shù)據(jù)，但是與列表不同的時(shí)，元組的數(shù)據(jù)不可以修改、不可以刪除、不可以添加，只可以查詢。
語法:元組變量名 = (元素1,元素2,元素3,...)

元組的語法和用法都和列表類似，但元組只可以查詢，所以元組能使用：變量名【索引】、index()、len()、in()

city = ("北京","天津","南京")

print(city)
#   ('北京', '天津', '南京')

print(city[0])
#   北京

print(city.index("北京"))
#   0-為北京的索引

print(len(city))
#   3-有三個元素

if "南京" in city:
    print("在")
else:
    print("否")

元組的遍歷與列表一致，這里就不多贅述了
?

5.4 Python數(shù)據(jù)容器-字典

5.4.1 字典的基本使用

如何訪問已經(jīng)定義字典的值？變量名[鍵]，若訪問不存在的鍵，則會報(bào)錯。

ziwu_message = {"name":"ziwu","age":"18","hobby":"永劫無間"}
print(ziwu_message["name"])

注意：

• 字典元素的key是唯一的，否則所對應(yīng)value的值只會保留最后賦值的那一個，位置在第一個key的書寫位置，且key值為不可變類型數(shù)據(jù)：字符串、數(shù)字、元組
• value值可以重復(fù)
• 一般的定義鍵的類型是字符串
• 字典的元素所在的位置沒有先后順序之分

字典-增操作：

例子：

ziwu_message = {"name":"ziwu","age":"18","hobby":"永劫無間"}
ziwu_message["number"] = "119"
print(ziwu_message)
# {'name': 'ziwu', 'age': '18', 'hobby': '永劫無間', 'number': '119'}

字典-刪操作：

message = {"name": "ziwu", "age": "18", "hobby:": "打電動"}
del message["hobby:"]
print(message)
# {'name': 'ziwu', 'age': '18'}
message.clear()
print(message)
# {}
    

字典-改操作：

message = {"name": "ziwu", "age": "18", "hobby:": "打電動"}
message["hobby:"] = "打kun球"
print(message)
# {'name': 'ziwu', 'age': '18', 'hobby:': '打kun球'}

字典-查操作：

message = {"name": "ziwu", "age": "18", "hobby:": "打電動"}

print(len(message))
# 3
print(message.keys())
# dict_keys(['name', 'age', 'hobby:'])
print(message.values())
# dict_values(['ziwu', '18', '打電動'])
print(message.items())
# dict_items([('name', 'ziwu'), ('age', '18'), ('hobby:', '打電動')])

字典的遍歷

鍵（key）的遍歷：直接對字典變量進(jìn)行for遍歷，默認(rèn)遍歷的是鍵，但代碼不好閱讀，我們統(tǒng)一以字典名.key()的方式書寫！

message = {"name": "ziwu", "age": "18", "hobby:": "打電動"}

for temp in message:
	print(temp)

容器知識補(bǔ)充

容器：在 python 中，容器是用來存儲多個對象的數(shù)據(jù)類型，比如列表、元組、字典等。

公共運(yùn)算符

# 1. 字符串
str1 = "Hello"
str2 = str1 + "WORLD"
print(str2)	# HelloWORLD
print(str1 * 3) # HelloHelloHello

# 列表
lists1 = [1, 2]
lists2 = [3, 4]
result = lists1 + lists2
print(result)	# [1, 2, 3, 4]
print(1 in result)	# True
print(100 in result)	# False

公共方法

我們以以下例子充分了解公共方法：
（1）定義一個列表變量，內(nèi)容為：10、300、20、200、30、100、999；

（2）獲取列表變量的總長度；

（3）獲取列表的最大值和最小值；

# 1、定義一個列表變量
datas = [10,300,20,200,30,100,0,999]
# 2.總長度
print(len(datas))
# 3.最大最小值
# 先排序
# datas.sort()
# print(f"最大值:{datas[6]}")  # 硬編碼
# print(f"最大值:{datas[len(datas)-1]}")
# print(f"====最小值:{datas[0]}")
# 簡便方法
print(f"最大值:{max(datas)}")
print(f"====最小值:{min(datas)}")

?

第六章

6.1 函數(shù)的基礎(chǔ)定義

函數(shù)是組織封裝好的，可以重復(fù)使用的，因此可以使用函數(shù)解決重復(fù)代碼的問題。
在Python中，有幾個重要的概念：
（1）函數(shù)名
（2）參數(shù)
（3）返回值
語法：

def 函數(shù)名(參數(shù)):
    函數(shù)體
    [return 返回值]
函數(shù)名()

例子：

# 參數(shù)可以為空
def say_hi():
    print("hi!我是ziwu.")

say_hi()

# 帶參數(shù)例子
# 參數(shù)之間用逗號分隔
def add(x,y):
    result = x + y
    print(f"x+y的結(jié)果是{result}")

add(4,10)

#帶返回值例子
def add(a,b):
    result = a + b
    return result
# return后，再接任何語句都不執(zhí)行
r = add(4,7)
print(r)
# 11

定義函數(shù)小技巧
a. 要對函數(shù)命名，需要遵循標(biāo)識符的五條命名規(guī)范 : –道德：所有字母均小寫，且單詞之間使用下劃線連接
b. 對函數(shù)命名，一般指的是一個動作、行為： -->動詞、動詞_名詞 如：play() play_baskball()
c.先封裝，后調(diào)用
d.會改變的量盡量不要放到函數(shù)內(nèi)

6.2 函數(shù)的基礎(chǔ)定義-函數(shù)的參數(shù)

我們上文提及了函數(shù)的基本定義，在定義函數(shù)時(shí)，設(shè)定了參數(shù)，則可稱這函數(shù)為：有參函數(shù)。反之，沒有參數(shù)的函數(shù)被稱為無參函數(shù)。

def 函數(shù)名(參數(shù)1，參數(shù)2……) 	# 形參
	函數(shù)體
	……

函數(shù)名(參數(shù)1，參數(shù)2……) 	#實(shí)參

(1) 形參是指形式參數(shù)，在定義函數(shù)時(shí)參數(shù)；
(2)實(shí)參是實(shí)際參數(shù)，表示在調(diào)用函數(shù)時(shí)傳遞的參數(shù)值，具有實(shí)際意義

變量在函數(shù)體內(nèi)的作用域：
主要分為兩類：局部變量和全局變量

• 局部變量： 定義在函數(shù)體內(nèi)部，只可以在函數(shù)內(nèi)部生效，當(dāng)函數(shù)調(diào)用完成后，銷毀局部變量
• 全局變量： 所謂全局變量，是指在函數(shù)體內(nèi)外都能生效的變量

num = 200 

def test_a():
	num = 500

test_a()
print(num) # 輸出為200,如果硬想要修改，則在test_a函數(shù)內(nèi)語法為
"""
def test_a():
	global num #設(shè)置內(nèi)部定義的變量為全局變量
	num = 500
"""

global 變量名：當(dāng)在函數(shù)內(nèi)想將變量視為全局變量
就近原則

6.1.1 [掌握]缺省參數(shù)

缺省參數(shù)指的是：在定義函數(shù)的時(shí)候，就為參數(shù)提供默認(rèn)值，與此同時(shí)，在調(diào)用函數(shù)的時(shí)候，可以不傳遞默認(rèn)參數(shù)的值，如果給缺省參數(shù)傳遞了數(shù)值，以傳遞的值為準(zhǔn)
缺省參數(shù)語法：

def 函數(shù)名(參數(shù)1，參數(shù)2……，參數(shù)n=值) 	
	函數(shù)體
	……

函數(shù)名(參數(shù)1，參數(shù)2……[值n])

例題：

#（1）定義一個顯示姓名、年齡、性別的函數(shù)，且默認(rèn)性別為男；
def show_infos(name,age,sex="男"):
	print("=========================")
    print("個人信息顯示如下:")
    print(f"姓名:{name}")
    print(f"年齡:{age}")
    print(f"性別:{sex}")
    print("=========================")

show_infos("ziwu", 18, "女")
show_infos("ziwu", 18)

[掌握]不定長參數(shù)

通常情況下，不定長參數(shù)在不確定調(diào)用函數(shù)時(shí)，要傳遞多少個參數(shù)的場景當(dāng)然也可以不傳遞參數(shù)
語法：

def 函數(shù)名(參數(shù)1,..,*args,**kwargs):
	代碼
	...
	
函數(shù)名(值1, 值2, 值3, ... 參數(shù)1=值, 參數(shù)2=值,...)

注意：

• *args:前面一個*號的，傳入值時(shí)不用指明參數(shù)名，直接傳入?yún)?shù)即可，傳入的參數(shù)以列表的方式存儲
• **kwargs:前面兩個**的，傳入值需要指明參數(shù)名，傳入的參數(shù)以字典的方式存儲。

#第一個是元組形式，第二個是字典形式
def sun(*a, **b):
    print(a)
    print(b)
 
sun(1, 22, x=11, y=22)

結(jié)果：

(1, 22)
{'x': 11, 'y': 22}

?

6.2 函數(shù)的基礎(chǔ)定義-函數(shù)返回值

return 作用：①、返回函數(shù)；②、結(jié)束函數(shù)；
如果函數(shù)沒有使用return語句返回?cái)?shù)據(jù)，實(shí)際上是返回了None這個字面量

def check_age(age):
    """
    check_a函數(shù)對比年齡
    :param age:年齡
    :return:返回真假
    """
    if age > 18:
        return "SUCCESS"
    else：
    	pass
    	print("未成年！")
        

print(check_age(16))
#未成年！ None

?

6.3 函數(shù)的基礎(chǔ)定義-函數(shù)的嵌套調(diào)用

函數(shù)之間也可以嵌套運(yùn)用！嵌套調(diào)用的意思是：在一個函數(shù)內(nèi)調(diào)用了另一個函數(shù)。

#例子
def func_b():
    print("內(nèi)容b")

def func_a():
    print("內(nèi)容a")
    func_b()

def func_c():
    print("內(nèi)容c")
    func_a()

func_c()

#ATM機(jī)例子
# 全局變量
money = 500000
name = input("請輸入你的姓名：")
# 主菜單
def main():
    print("--------主菜單--------")
    print(f"{name}，您好，歡迎來到ziwuATM自助存儲機(jī)器")
    print("查詢余額\t【請輸入1】")
    print("存款\t\t【請輸入2】")
    print("取款\t\t【請輸入3】")
    print("退出\t\t【請輸入4】")
    return input("請輸入你的選擇：")
# 查詢
def query(show_header):
    if show_header:
        print("--------查詢余額--------")
    print(f"你的余額還剩下：{money}元")

# 存款
def saving(num):
    global money
    money += num
    query(False)

# 取款
def get_money(num):
    global money
    money -= num
    query(False)
# 設(shè)置無限循環(huán)，保證程序不會退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue
    elif keyboard_input == "2":
        saving(int(input("您想要存多少錢，請輸入：")))
        continue
    elif keyboard_input == "3":
        get_money(int(input("您想要存多少錢，請輸入：")))
        continue
    else:
        break

?

6.4 函數(shù)-說明文檔的使用

函數(shù)說明文檔就是通過注釋內(nèi)容對這個函數(shù)進(jìn)行解釋說名，下圖是python中print函數(shù)中的說明文檔

在PyCharm中在函數(shù)體內(nèi)第一行通過三次雙引號回車即可以對函數(shù)使用文檔進(jìn)行編輯：

def test(a,b,c):
    """
    
    :param a: 
    :param b: 
    :param c: 
    :return: 
    """
    pass

①說明文檔第一空行內(nèi)填寫函數(shù)的作用；
②param：填寫參數(shù)說明

拆包和交換變量值

拆包：

1:組包 1 2 3 —> (1,2,3)
2:拆包 (66,67,68,69) —> 66 67 68 69

在生活中，我們會把我們需要的物品一個個裝進(jìn)背包中攜帶到工作地，當(dāng)我們需要用到物品時(shí)，會將背包中的物品都取出；這就好比我們組包、拆包的過程。

• 程序中的拆包

把組合形成的[元組形式]的數(shù)據(jù)拆分出單個元素內(nèi)容，這個過程就是程序中的拆包

例如，在一個函數(shù)中使用return返回值的時(shí)候，我們可以使用字典、元組來存儲各個鍵和值

def get_sum_deff(a, b):
    # 求和
    c1 = a + b
    # 求差
    c2 = a - b
    # 組包
    return c1, c2  # 可以省略括號不寫


# 拆包
sums, deff = get_sum_deff(66, 79)
print(f"他們的和為：{sums}")
print(f"他們的差為：{deff}")

student = {"name": "ziwu", "gender": "女", "age": 18}

#   拆包
for key, value in student.items():
    print(f"{key}:----->{value}")

交換變量值

在其它語言我們相交換兩個變量的值需要引用到第三個變量，但是在Python中我們可以直接進(jìn)行交換!

• 例如，現(xiàn)在有變量a = 20和b = 45，請嘗試用拆包的方式來交換兩個變量的值

a = 20
b = 45

# 引入第三變量方法
# temp = a
# a = b
# b = temp

# 拆包
(a, b) = (b, a)
print(f"a = {a};b = {b}")
#	a = 45;b = 20

引用
在Python中，值是考引用來傳遞的，我們在給函數(shù)傳遞參數(shù)時(shí)，本質(zhì)上就iu是把引用當(dāng)成參數(shù)進(jìn)行傳遞

1:電腦內(nèi)存中的內(nèi)存地址值(引用)是唯一的;
2:如果兩個變量的內(nèi)存地址值是一樣的,表示同一個內(nèi)容.

代碼（用id()查看地址值，is 判斷地址值是否相同）：

def sum(a,b):
    print(f"傳入的a的地址為：{id(a)}")
    print(f"傳入的b的地址為：{id(b)}")


a = 20
b = 45
print(f"未傳入的a的地址為：{id(a)}")
print(f"未傳入的b的地址為：{id(b)}")
print(a is b)
sum(a,b)

結(jié)果：

未傳入的a的地址為：140712958656160
未傳入的b的地址為：140712958656960
False
傳入的a的地址為：140712958656160
傳入的b的地址為：140712958656960

6.5 Python函數(shù)、異常處理

異常就是Python程序發(fā)送不正常時(shí)間，有的時(shí)候異?？煞Q為錯誤。
當(dāng)檢測到一個錯誤時(shí)，Python解釋器無法繼續(xù)執(zhí)行，反而出現(xiàn)了一些錯誤提示，這就是異常，也就是我們常常說的BUG
Python中常見的異常:

6.5.1 異常常見處理方式

異常處理語法:

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

其中typ、except都是處理異常的關(guān)鍵字

我們來制造一個IndexError異常

print("Hello")
try:
    strs = "hello"
    print(strs[100])
except:
    print("發(fā)生了異常")
print("666")

結(jié)果為：

Hello
發(fā)生了異常
666

當(dāng)我們不進(jìn)行異常處理時(shí)，程序?qū)?bào)錯不再繼續(xù)往下運(yùn)行。而異常處理代碼，能夠讓程序不崩潰！

第七章

7.1 python文件的基礎(chǔ)定義

我們不管其他教程操作文件的過程多復(fù)雜，在俺這就分三步（1. 打開文件；2. 讀寫文件 3. 關(guān)閉文件）
（1）打開文件
在操作一個文件之前，首先需要打開文件

常見的mode訪問模式有：

說明
（1）訪問模式r表示read，即讀
（2）訪問模式w表示write，即寫
（3）當(dāng)讀取內(nèi)容有中文的文件時(shí)，需要設(shè)定文件編碼格式為utf-8

（2）讀寫數(shù)據(jù)
讀數(shù)據(jù)：

當(dāng)為訪問模式r的時(shí)候，可以讀取數(shù)據(jù)

寫數(shù)據(jù)：

當(dāng)訪問模式為w的時(shí)候，可以讀取數(shù)據(jù);
當(dāng)訪問模式為a時(shí)，用于追加數(shù)據(jù)！

（3）關(guān)閉文件
每次打開文件后，都需要關(guān)閉文件，用于釋放系統(tǒng)內(nèi)存

（4）實(shí)戰(zhàn)練習(xí)

1. 在當(dāng)前目錄創(chuàng)建test.txt文件且分別寫入數(shù)據(jù)：Hello World且追加內(nèi)容至ziwu Love
2. 將此文件拷貝至新文件test[備份].txt上

# 寫入Hello World
file = open("test.txt","w")
file.write("Hello World")
file.close()

# 追加ziwu Love
file = open("test.txt","a")
file.write("ziwu Love")
file.close()

# 上兩行先運(yùn)行，輸出內(nèi)容
file = open("test.txt","r")
print(file.read())
file.close()

# 拷貝源文件
file = open("test.txt","r")
copy_file = file.read()
file.close()

#寫入新文件
file = open("test[備份].txt","w")
new_file= file.write(copy_file)
file.close()

# 上兩行先運(yùn)行，輸出內(nèi)容
with open("test[備份].txt","r") as file:
    print(file.read())

7.1.1 python文件-快捷讀取數(shù)據(jù)

上一個拷貝例子最后我們用到了with…as語法，這個語法不需要我們手動close文件，現(xiàn)在我們來細(xì)講⑧！
語法：

with open(name,mode,encoding) as 變量名:
	變量名.read()
	# 變量名.write()

7.1.2 python文件-os模塊

Pyton中的文件操控大部分功能都存儲在os模塊中，如查看路徑、創(chuàng)建目錄、顯示文件列表等
os模塊時(shí)Python標(biāo)準(zhǔn)庫，直接導(dǎo)入使用即可

# 導(dǎo)入os包
import os

在Python中，os模塊的常用函數(shù)分為兩類：

(a) 通過os.path調(diào)用的函數(shù)
(b) 通過os.直接調(diào)用的函數(shù)

• op.path常用函數(shù)（需要用os.path調(diào)用）：

import os

path_name = "./file/test.txt"   #相對路徑

# 是否存在
print(os.path.exists(path_name))
# 是否為文件
print(os.path.isfile(path_name))
# 是否為目錄
print(os.path.isdir(path_name))
# 絕對路徑
print(os.path.abspath(path_name))
# 單獨(dú)文件名
print(os.path.basename(path_name))
# 切片
print(path_name[path_name.rfind("/")+1:])

輸出結(jié)果：

F:\Python\pythonProject_test\day08\02-test.py 
True
True
False
F:\Python\pythonProject_test\day08\file\test.txt
test.txt
test.txt

• os.常用函數(shù)

例題：
（1）獲取當(dāng)前工作目錄
（2）獲取file目錄下的所有文件或目錄列表信息
（3）在當(dāng)前目錄下創(chuàng)建day10/file目錄文章來源地址http://www.zghlxwxcb.cn/news/detail-689867.html

import os

print(os.getcwd())

print(os.listdir("file"))

os.makedirs("./day10/file")

到了這里，關(guān)于大學(xué)生精通Python從由淺入深（Python基礎(chǔ)篇）的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！