張導(dǎo)博客：[https://www.cnblogs.com/Neeo/articles/11204572.html]

1.安裝python和pycharm

image

1.1 安裝PyCharm

image

image

image

注冊(cè)碼:http://idea.lanyus.com/

添加hosts解析
C:\Windows\System32\drivers\etc

image

image

image

image

image

1.2 安裝python

image

1.3 添加環(huán)境變量

image

C:\Program Files\Python37
C:\Program Files\Python37\Scripts

image

image

image

cmd查看版本

image

第一句python

image

2. python起源

官方文檔:https://docs.python.org/zh-cn/3/tutorial/index.html

image

1. pip 錯(cuò)誤記錄

相關(guān)鏈接:https://blog.csdn.net/cashcat2004/article/details/50664744

ERROR: Could not install packages due to an EnvironmentError: [WinError 5] 拒絕訪問(wèn)。: 'c:\\program files\\python37\\lib\\site-packages\\pip-10.0.1.dist-info\\entry_points.txt'
Consider using the `--user` option or check the permissions.

image

image

python -m pip uninstall pip #卸載原有的pip

下載get-pip.py文件亡资，并將此文件保存在Python的安裝目錄下

網(wǎng)址：https://pypi.org/project/pip/

image

# 再次安裝get-pip.py
python C:\Program Files\Python37\get-pip.py

博客資料鏈接:
https://www.cnblogs.com/Neeo/articles/10522363.html

image

2. python的基礎(chǔ)數(shù)值類(lèi)型

https://www.cnblogs.com/Neeo/articles/10562348.html

整型：int

整型數(shù)就是不包括小數(shù)部分的數(shù)值，分為整數(shù)铐达、0和負(fù)數(shù)

浮點(diǎn)型：float

float類(lèi)型的數(shù)值與數(shù)學(xué)中的寫(xiě)法基本一致轰胁，但允許小數(shù)點(diǎn)后面沒(méi)有任何數(shù)字（小數(shù)部分為0）,在Python 3.x中，運(yùn)算符/用于浮點(diǎn)數(shù)時(shí)活喊，是保留小數(shù)部分的云头，而Python 2.x版本解釋器則返回int類(lèi)型

布爾類(lèi)型：bool

判斷兩個(gè)數(shù)是否相等時(shí),可以判斷命題真假的語(yǔ)句,將真假兩個(gè)值組成了一個(gè)類(lèi)型捐友，即布爾類(lèi)型，真假值也稱(chēng)為布爾值盘寡，以真假為值的表達(dá)式稱(chēng)為布爾表達(dá)式

- bool
- python中,元素自帶布爾值
有三個(gè)(類(lèi))元素布爾值為假,其余為真
  - 0
  - 空,包括:
    - 空的字符串 ''
    - 空的列表 []
    - 空的字典 {}
    - 空的元組 ()
- None

3. 變量

我們通過(guò)一個(gè)名字楚殿，指向一個(gè)人，或者指向一個(gè)具體的事物。這在Python中是同樣適用脆粥。Python中砌溺，這個(gè)名字稱(chēng)為變量，而指向的對(duì)象為一串字符串变隔，一個(gè)具體的數(shù)值等等规伐。變量也是可變狀態(tài)的、對(duì)內(nèi)存地址一種抽象匣缘。

變量賦值

變量賦值是指將一個(gè)數(shù)字或者字符串等具體的數(shù)值數(shù)據(jù)賦值給一個(gè)變量猖闪，在后面的編程中我們可以通過(guò)這個(gè)變量來(lái)指向所要引用的數(shù)據(jù)對(duì)象

>>> v = 100
>>> v
100
>>> v+20
120
>>>

3.1 變量標(biāo)準(zhǔn)數(shù)據(jù)類(lèi)型

在內(nèi)存中存儲(chǔ)的數(shù)據(jù)可以有多種類(lèi)型。

例如肌厨，一個(gè)人的年齡可以用數(shù)字來(lái)存儲(chǔ)培慌，他的名字可以用字符來(lái)存儲(chǔ)。

Python 定義了一些標(biāo)準(zhǔn)類(lèi)型柑爸，用于存儲(chǔ)各種類(lèi)型的數(shù)據(jù)吵护。

Python有五個(gè)標(biāo)準(zhǔn)的數(shù)據(jù)類(lèi)型：

• Numbers（數(shù)字）
• String（字符串）
• List（列表）
• Tuple（元組）
• Dictionary（字典）

3.2 變量的規(guī)則

• 第一個(gè)字符必須是字母（大寫(xiě)或小寫(xiě)）或者一個(gè)下劃線（_）
• 變量的其他部分可以是字母（大寫(xiě)或小寫(xiě)）、下劃線（_）表鳍、數(shù)字（0-9）組成
• 變量是對(duì)大小寫(xiě)敏感的馅而。如，oldboy和oldBoy不是一個(gè)變量
• 變量命名時(shí)注意避開(kāi)關(guān)鍵字和內(nèi)置的函數(shù)名譬圣，以免發(fā)生沖突
• 變量的第一個(gè)字符不能是數(shù)字
• 命名要見(jiàn)名知意
• 推薦寫(xiě)法：下劃線(user_name) 駝峰體(userName)

#比較規(guī)范
name = "oldboy"
age = 18

而不是這種：

mingzi = "oldboy"
nianling = 18
a = "male"
b = "不詳"

我們還應(yīng)該避免：

• 單字符名稱(chēng)
• 包/模塊名中的連接符避免用中橫線-
• 避免雙下劃線開(kāi)頭并結(jié)尾的名稱(chēng)瓮恭，因?yàn)檫@是Python保留的，比如__init__

3.3 內(nèi)存管理

垃圾回收機(jī)制

image

int整形

image

float整形
計(jì)算小數(shù)

image

計(jì)算加減乘除

image

3.5 輸入輸出

input：接收的輸入都轉(zhuǎn)為字符串形式

print()：可以接收多個(gè)參數(shù)

end='\n'

sep=' '

file=文件句柄

4. 運(yùn)算符

知識(shí)鏈接:
https://www.cnblogs.com/Neeo/articles/10522370.html

表達(dá)式：由操作數(shù)和操作符組成的表達(dá)式

4.1 算數(shù)運(yùn)算符

image

>>> 1 + 1       # 運(yùn)算符 +  
2  
>>> 1 - 1       # 運(yùn)算符 -  
0  
>>> 1 * 1       # 運(yùn)算符 *  
1  
>>> 1 / 1       # 運(yùn)算符 /  
1.0  
>>> 4 // 3      # 取整除 //  
1  
>>> 10 % 3      # 取模 %  
1  
>>> 2 ** 2      # 冪 **  
4  

4.2 比較運(yùn)算符

image

>>> 2 == 2      # 比較運(yùn)算符 ==  
True  
>>> 2 != 2      # 比較運(yùn)算符 !=  
False  
>>> 2 > 2       # 比較運(yùn)算符 >  
False  
>>> 2 < 2       # 比較運(yùn)算符 <  
False  
>>> 2 >= 2      # 比較運(yùn)算符 >=  
True  
>>> 2 <= 2      # 比較運(yùn)算符 <=  
True  

4.3 賦值運(yùn)算符

image

>>> a = 5  
>>> b = 3  
>>> c = a + b   # 賦值運(yùn)算符 =  
>>> c  
8  
>>> b += a      # 賦值運(yùn)算符 +=  
>>> b  
8  
>>> b -= a      # 賦值運(yùn)算符 -=  
>>> b  
3  
>>> b *= a      # 賦值運(yùn)算符 *=  
>>> b  
15  
>>> b /= a      # 賦值運(yùn)算符 /=  
>>> b  
3.0  
>>> b %= a      # 賦值運(yùn)算符 %=  
>>> b  
3.0  
>>> b **= a     # 賦值運(yùn)算符 **=  
>>> b  
243.0  
>>> b //= a     # 賦值運(yùn)算符 //=  
>>> b  
48.0  

4.4 邏輯運(yùn)算符

image

>>> 2 < 3 and 3 == 3    # 邏輯運(yùn)算符 and  
True  
>>> 2 < 3 or 3 != 3     # 邏輯運(yùn)算符 or  
True  
>>> not 1 > 2           # 邏輯運(yùn)算符 not  
True  

登錄驗(yàn)證

image

4.5 成員運(yùn)算符

image

image

4.6 身份運(yùn)算符

image

>>> a = 'abcd'  
>>> b = a  
>>> c = a  
>>> b is a         # 身份運(yùn)算符 is  
True  
>>> b is c  
True  
>>> c is not a     # 身份運(yùn)算符 is not  
False 

image

4.7 位運(yùn)算符(了解)

image

>>> a = 8  
>>> b = 5  
>>> a & b       # 按位與  
0  
>>> a ^ b       # 按位異或  
13  
>>> a | b       # 按位或  
13  
>>> a << b      # 左移  
256  
>>> a >> b      # 右移  
0  

4.8 運(yùn)算符的優(yōu)先級(jí)

image

image

5. 流程控制語(yǔ)句

知識(shí)鏈接：
https://www.cnblogs.com/Neeo/articles/10522374.html

image

5.1 條件語(yǔ)句

if 判斷條件:  
    執(zhí)行的代碼塊1  
else:  
    執(zhí)行的代碼塊2  

Python條件語(yǔ)句是通過(guò)一條或多條語(yǔ)句的執(zhí)行結(jié)果（True或者False）來(lái)決定執(zhí)行的代碼塊

s = input('輸入一個(gè)成績(jī): ')
s_int = int(s)
s_int = int('s')    #錯(cuò)誤的厘熟，如果輸入單引號(hào)屯蹦，變量值

#條件語(yǔ)句 if/elif/else

s = input('輸入一個(gè)成績(jī): ')
s_int = int(s)

if 90 <= s_int <= 100:
    print('成績(jī)優(yōu)秀!')
elif 80 <= s_int < 90:
    print('成績(jī)良好')
elif 60 <= s_int <80:
    print('成績(jī)一般')
elif 0 <= s_int < 60:
    print('成績(jī)不合格')
else:
    print('輸入成績(jī)錯(cuò)誤')

image

if 嵌套

image

python中，元素自帶布爾值

有三個(gè)元素布爾值為空

print(bool(0))  # 0
print(bool('')) 
#空字符串 ‘’
#空的列表 []
#空的字典 {}
#空的元組 ()
print(bool(None)) #空

5.2 while循環(huán)

https://www.runoob.com/python/python-loops.html

條件一：while循環(huán)成立的條件

條件二：

# while循環(huán)

a = 0
b = 0
while a < 100:
    a += 1
    b += a
print(b)

#第二種顯示過(guò)程的方法

count = 0   #用于循環(huán)出0-100的值
sum = 0 #用于求和的變量
s = '0'
while count < 100:
    print(count, sum)
    count += 1
    sum += count
    s += '+' + str(count)
    print('%s = %s'% (s, sum))
 #   print(sum)

while True:
    input('你劃呀')
    print('給你十位小姐姐')

5.3 for循環(huán)

# 序列類(lèi)型
for loop in '12345':    
    print("The value is: %s" % loop)

%s 整型
%f 小數(shù)

image

while嵌套循環(huán)

count = 0
while count < 3:
    num = 0
    while num <= 3:
        print('*' * num)
        num += 1
    count += 1

#執(zhí)行結(jié)果
*
**
***

*
**
***

*
**
***

6.1 break: 終止循環(huán)

break: 終止整個(gè)循環(huán),后續(xù)循環(huán)不會(huì)執(zhí)行盯漂，并且break后面的代碼也不執(zhí)行

count = 0
while count <= 10:
    print(count)
    if count == 6:
        break
        print(222222)
    count += 1
#執(zhí)行結(jié)果
0
1
2
3
4
5
6

6.2 continue

continue 語(yǔ)句跳過(guò)本次循環(huán)颇玷，continue語(yǔ)句用在while和for循環(huán)中。

continue 語(yǔ)句用來(lái)告訴Python跳過(guò)當(dāng)前循環(huán)的剩余語(yǔ)句就缆，然后繼續(xù)進(jìn)行下一輪循環(huán)，continue語(yǔ)句后面的代碼也不會(huì)執(zhí)行

https://www.runoob.com/python/python-continue-statement.html

# 打印1,2谒亦，3,4,5,6竭宰，7,8,9,10

count = 0
while count < 10:
    count += 1
    if count == 7:
        continue
        print(23333333)
    print(count)
#執(zhí)行結(jié)果
1
2
3
4
5
6
8
9
10

6.3 pass語(yǔ)句

pass 是空語(yǔ)句，是為了保持程序結(jié)構(gòu)的完整性份招。

pass不做任何事情切揭，一般用做占位語(yǔ)句

7.簡(jiǎn)述變量命名規(guī)范

1.不能以數(shù)字開(kāi)頭，第一個(gè)字符必須是字母或者下劃線

2.變量由字母锁摔，下劃線廓旬，數(shù)字組成

3.變量要注意大小寫(xiě)的區(qū)別，例如abc不等于ABC

4.變量名要避免與關(guān)鍵字和函數(shù)名發(fā)生沖突

5.變量第一個(gè)字母不能是數(shù)字

8.name = input(“>>>”) name變量是什么數(shù)據(jù)類(lèi)型谐腰？

字符串類(lèi)型 （String）

9.if條件語(yǔ)句的基本結(jié)構(gòu)孕豹？

if 判斷條件:
   執(zhí)行語(yǔ)句...
else:
   執(zhí)行語(yǔ)句...

10.用print打印出下面內(nèi)容：only one print

用一個(gè)print

?能提筆安天下, 
武能上馬定乾坤涩盾。
?存謀略何?勝, 
古今英雄唯是君。

no_1 = '?能提筆安天下,'
no_2 = '武能上馬定乾坤励背。'
no_3 = '?存謀略何?勝,'
no_4 = '古今英雄唯是君春霍。'
print('\r', no_1, '\n', no_2, '\n',no_3, '\n',no_4)

image

11.利用if語(yǔ)句寫(xiě)出猜大小的游戲：

設(shè)定一個(gè)理想數(shù)字比如：66，讓用戶(hù)輸入數(shù)字叶眉，如果比66大址儒，則顯示猜測(cè)的結(jié)果大了；如果比66小衅疙，則顯示猜測(cè)的結(jié)果小了;只有等于66莲趣，顯示猜測(cè)結(jié)果正確。

# 定義一個(gè)變量并輸出
num = 66
speck = int(input('請(qǐng)輸入您要猜的數(shù)字(須是整數(shù)): '))
# 條件語(yǔ)句 if/elif/else
if speck > num:
  print('您猜大了哦!再猜一次')
elif speck < num:
  print('您猜小了哦!再猜一次')
elif speck == num:
  print('恭喜您猜對(duì)了饱溢！獎(jiǎng)勵(lì)老婆一車(chē)!')

注意妖爷，為什么input函數(shù)要放在int函數(shù)內(nèi)，還記得之前講input的時(shí)候理朋，說(shuō)過(guò)input函數(shù)返回的是str類(lèi)型么絮识？因此，這里要轉(zhuǎn)換為int類(lèi)型嗽上，不然無(wú)法和int類(lèi)型的成績(jī)做判斷次舌。但這就限制了input的輸入類(lèi)型了，比如你輸入你的名字就不行了兽愤，因?yàn)閕nt函數(shù)無(wú)法轉(zhuǎn)換彼念。
if語(yǔ)句支持很多運(yùn)算符來(lái)豐富條件語(yǔ)句，如比較運(yùn)算符浅萧、成員運(yùn)算符逐沙、邏輯運(yùn)算符、算數(shù)運(yùn)算符等洼畅。

12.提??戶(hù)輸入他的年齡, 程序進(jìn)?判斷.

如果?于10, 提??屁孩, 如果?于10, ?于 20, 提?青春期叛逆的?屁孩. 如果?于20, ?于30. 提?開(kāi)始定性, 開(kāi)始混社會(huì)的? 屁孩?, 如果?于30, ?于40. 提?看老?不?了, 趕緊結(jié)婚?屁孩?. 如果?于40, ? 于50. 提?家?有個(gè)不聽(tīng)話的?屁孩?. 如果?于50, ?于60. 提????上變成不聽(tīng) 話的老屁孩?.如果?于60, ?于70. 提?活著還不錯(cuò)的老屁孩?. 如果?于70, ?于 90. 提???就快結(jié)束了的?個(gè)老屁孩?. 如果?于90以上. 提?. 再見(jiàn)了這個(gè)世界.

while True:
  age = int(input('請(qǐng)輸入您的年齡:'))
  if 0 <= age < 10:
      print('?屁孩!')
  elif 10 <= age < 20:
      print('青春期叛逆的?屁孩')
  elif 20 <= age <30:
      print('開(kāi)始定性, 開(kāi)始混社會(huì)的? 屁孩?')
  elif 30 <= age < 40:
      print('看老?不?了, 趕緊結(jié)婚?屁孩?')
  elif 40 <= age < 50:
      print('家?有個(gè)不聽(tīng)話的?屁孩?')
  elif 50 <= age < 60:
      print('???上變成不聽(tīng) 話的老屁孩?')
  elif 60 <= age < 70:
      print('活著還不錯(cuò)的老屁孩?')
  elif 70 <= age < 90:
      print('??就快結(jié)束了的?個(gè)老屁孩?')
  elif 90 < age:
      print('再見(jiàn)了這個(gè)世界')
  else:
      print('年齡輸入有誤!')
      exit()

13.單行注釋以及多行注釋?zhuān)?/h3>

#單行注釋
井號(hào)'#'單行注釋

#三引號(hào)包含內(nèi)容進(jìn)行注釋
''' 
內(nèi)容
'''

ctrl+?  選擇多行注釋
ctrl+a ctrl+?   選擇全文注釋

14.提??戶(hù)輸入?花藤. 判斷?戶(hù)輸入的對(duì)不對(duì). 如果對(duì), 提?真聰明, 如果不對(duì), 提?輸入有誤

name = input('你知道王者農(nóng)藥的爸爸是誰(shuí)嗎?請(qǐng)告訴我: ')
a = '麻花藤'
if name == a:
  print('真棒吩案！兒子')
else:
  print('猜錯(cuò)了哦！太low了')

#娛樂(lè)版

# 定義選項(xiàng)帝簇，B為正確
A = 'A.我不愛(ài)錢(qián)的杰克馬'
B = 'B.你充錢(qián)了嗎麻花藤'
C = 'C.愛(ài)妻如命的劉強(qiáng)東'
D = 'D.百度賣(mài)藥的李彥宏'
# 顯示問(wèn)題與選擇
print('你知道王者農(nóng)藥的爸爸是誰(shuí)嗎?''\n', A, '\n', B, '\n', C, '\n',D)
while True:
    name = input('\t\t\t\t''請(qǐng)告訴我答案: ')
    # if/elif/else判斷
    if name == 'A':
        print('真棒徘郭！猜錯(cuò)了龜孫兒')
    elif name == 'B':
        print('恭喜你!麻花藤為你沖了10個(gè)Q幣\n并贈(zèng)送老婆一車(chē)!')
        exit()
    elif name == 'C':
        print('真棒！你猜錯(cuò)了龜孫兒')
    elif name  == 'D':
        print('真棒丧肴！你猜錯(cuò)了龜孫兒')
    else:
        print('蠢嗎豬残揉！給你選項(xiàng)都不填！')

image

15.?戶(hù)輸??個(gè)分?jǐn)?shù). 根據(jù)分?jǐn)?shù)來(lái)判斷?戶(hù)考試成績(jī)的檔次

>=90        A     
>=80        B  
>=70        C  
>=60        D           
< 60        不及格 

# ?戶(hù)輸??個(gè)分?jǐn)?shù). 根據(jù)分?jǐn)?shù)來(lái)判斷?戶(hù)考試成績(jī)的檔次
while True:
   print('=====考試成績(jī)查詢(xún)====\n[666]exit')
   num = int(input('請(qǐng)輸入您要查詢(xún)的成績(jī)[1-100]: '))
   if num == 100:
       print('該生成績(jī)[A+] 滿(mǎn)分\n送老婆一車(chē)!')
   elif 90 <= num < 100:
       print('該生成績(jī)[A] 優(yōu)秀')
   elif 80 <= num < 90:
       print('該生成績(jī)[B] 良好')
   elif 70 <= num < 80:
       print('該生成績(jī)[C] 一般')
   elif 60 <= num < 70:
       print('該生成績(jī)[D] 及格')
   elif 0 <= num < 60:
       print('該生成績(jī)不及格! 待補(bǔ)考')
   elif num == 666:
       print('歡迎使用...')
       exit()
   else:
       print('輸入成績(jī)有誤!請(qǐng)重新輸入')

image

16. 字符串基本操作

image

# 按索引取值

s = 'abcdef'
print(s[0])
print(s[-2])
print(s[0:2])   # 取范圍
print(s[0:6])
print(s[0:6:1])
print(s[0:6:2])   # 取a c e
print(s[0:3:1])
#輸出結(jié)果
a
e
ab
abcdef
abcdef
ace # 取a c e
abc

image.png

str1 = 'http://www.xxxxxx.com/'
print(str1[-3])        # 取倒數(shù)第三個(gè)
print(str1[0:6])       # 取前六個(gè)字符
print(str1[5:-1])      # 從第六個(gè)字符開(kāi)始取到末尾
print(str1[3:7])       # 從3到8個(gè)字符之前取值
print(str1[0:-1:2])    # 兩者之間 每2個(gè)字符取一個(gè)
print(str1[0:-1:4])    # 所有字符中每4個(gè)取一個(gè)
print(str1[::-1])      # 反轉(zhuǎn)字符串 通過(guò)負(fù)數(shù)的步進(jìn) 實(shí)現(xiàn)反轉(zhuǎn)

注意：

字符串反轉(zhuǎn) print(s[::-1])

17. 字符串的拼接

字符串的拼接（合并） +
字符串的合并操作芋浮，也叫字符串的拼接抱环，此操作應(yīng)用十分廣泛

>>> '100' + '-' + '1800' + '-' + '18000'  
'100-1800-18000' 

**字符串的復(fù)制 **

>>> name = 'oldboy'  
>>> name * 5  
'oldboyoldboyoldboyoldboyoldboy' 

相當(dāng)于將元字符復(fù)制5份，組成新的字符串。

字符串成員測(cè)試：in镇草，not in

>>> 'o' in 'oldboy'  
True  
>>> 'ol' in 'oldboy'  
True  
>>> 'od' in 'oldboy'  
False  
>>> 'od' not in 'oldboy'  
True  

字符串格式化運(yùn)算符： %系列

字符串的格式化輸出眶痰。格式化輸出就是按照某種固定的格式進(jìn)行字符串輸出眼虱，這個(gè)字符串稱(chēng)為模板字符串拳喻，我們?cè)谀０謇镉酶袷蕉x符%占住一個(gè)空位儿子，然后我們把運(yùn)算得出的數(shù)據(jù)再放到這個(gè)空位里怪瓶，字符串格式化運(yùn)算符%的基本用法如下：

<模板字符串> % (<數(shù)據(jù)1>窥岩， …冀偶，數(shù)據(jù)n>)  

%s這個(gè)字符串格式化運(yùn)算符就是說(shuō)我要往字符串中放入的數(shù)據(jù)是字符串類(lèi)型的值帽哑，這也是最常用的用法溯祸，但僅憑%s不足以包打天下羽嫡，所以本姥，這一節(jié)我們?cè)趯W(xué)習(xí)幾個(gè)其他常用的與%搭配的其他的字符，以實(shí)現(xiàn)不同的功能杭棵，比如商店消費(fèi)的小票上婚惫，或者銀行等涉及到金錢(qián)的輸出都有固定格式，比如我們?cè)趺从酶袷交敵?code>￥1.50呢魂爪？你可能會(huì)說(shuō)先舷，簡(jiǎn)單，這樣干：

>>> "金額：￥%s 元" % 1.50  
'金額：￥1.5 元'  

最后一位沒(méi)顯示出來(lái)滓侍，很明顯蒋川，%s在這種情況下并不好使，所以我們面對(duì)類(lèi)似的情況就要用別的格式化運(yùn)算符了——浮點(diǎn)型%f撩笆。

>>> "金額：￥%.2f 元" % 1.50  
'金額：￥1.50 元'  

<模板字符> %[flags][width].[precision]<模板字符> % (數(shù)據(jù)1, … 數(shù)據(jù)n)

上例各參數(shù)說(shuō)明如下：

• 模板字符就是普通的字符串捺球。
• flags可以是+、-或0夕冲，+表示右對(duì)齊（默認(rèn)右對(duì)齊氮兵，加號(hào)不寫(xiě)，寫(xiě)上會(huì)顯示出來(lái)）歹鱼，-表示左對(duì)齊泣栈。
• width表示顯示寬度。
• precision表示小數(shù)的位數(shù)醉冤。

print("金額：￥%+9.2f 元" % 1.50000) 
print("金額：￥%-9.2f 元" % 1.50000)  
print("金額：￥%09.2f 元" % 1.50000) 

#輸出結(jié)果
金額：￥    +1.50 元
金額：￥1.50      元
金額：￥000001.50 元

上例中：

• %+9.2f表示格式化字符右對(duì)齊（一般加號(hào)可以省略不寫(xiě)秩霍，寫(xiě)上的話，會(huì)當(dāng)成格式化字符填充進(jìn)去）蚁阳、寬度是9，小數(shù)位保留2位鸽照，需要填充的是浮點(diǎn)型的數(shù)據(jù)螺捐。
• %-9.2f表示格式化字符左對(duì)齊，寬度是9，小數(shù)位保留2位定血，需要填充的是浮點(diǎn)型的數(shù)據(jù)赔癌。
• %09.2f表示格式化字符填充0，寬度是9澜沟，需要填充的是浮點(diǎn)型的數(shù)據(jù)灾票。

要注意的是，如果使用的是浮點(diǎn)型的格式定義符茫虽，那么數(shù)據(jù)也必須是浮點(diǎn)型數(shù)據(jù)或int類(lèi)型刊苍。

>>> "金額：￥%f 元" % 4  
'金額：￥4.000000 元'  
>>> "金額：￥%.2f 元" % 4  
'金額：￥4.00 元'  
>>> "金額：￥%.2f 元" % 'str'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: a float is required   

這同樣適用于其他的格式定義符，比如說(shuō)如果是你用int類(lèi)型的格式定義符“%d”,而你的數(shù)據(jù)是str類(lèi)型濒析，那就會(huì)報(bào)錯(cuò)正什。

>>> "金額：￥%d 元" % '1'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: %d format: a number is required, not str  
>>> "金額：￥%d 元" % 1  
'金額：￥1 元'  

18. 字符串的常用方法

Python為字符串提供了很多方法爽哎，也有很多的內(nèi)置函數(shù)和聲明可以應(yīng)用于字符串，比如說(shuō)使用len(str)方法獲取字符串的長(zhǎng)度器一。這里我們僅介紹最常用的字符串方法课锌。

18.1 str.strip('obj')

去除字符串兩邊的指定字符，默認(rèn)去除字符串兩邊的空格或者換行符祈秕，沒(méi)有指定字符則略過(guò)渺贤。返回去除指定字符后的新字符串。

s2 = '****oldb***oy*******'
print(s2.strip())  # ****oldb***oy*******
print(s2.strip('*'))  # oldb***oy

s = '*a*b  *'
print(s.strip('*'))
print(s.replace('*', ''))
print(s.replace('*', '', 2))

#執(zhí)行結(jié)果
a*b  
ab  
ab  *

如上例所示请毛，strip方法只能去除字符串兩邊的指定字符志鞍，那想把中間的星號(hào)去掉怎么辦？

s2 = '****oldb***oy*******'
print(s2.replace('*', ''))  # oldboy

問(wèn)題解決方仿，但是replace是什么固棚？

18.2 str.replace

str.replace(old, new, [max])

將字符串中指定字符替換成新的字符统翩，替換次數(shù)最多不超過(guò)max次。返回替換后的新的字符串此洲。

s1 = "'python是最美的語(yǔ)言', python said"
new_str = s1.replace('p', 'P')
print(new_str)  # 'Python是最美的語(yǔ)言', Python said
print(s1.replace('p', 'P', 1))  # 'Python是最美的語(yǔ)言', python said

18.3 str.split & str.rsplit

str.split(obj='', num) & str.rsplit(obj='', num)

以指定的字符分割字符串厂汗，可以指定分割次數(shù)，默認(rèn)是全部分割呜师，并以列表的形式返回娶桦。

s3 = "hello python"
print(s3.split('o'))  # ['hell', ' pyth', 'n']
print(s3.split('o', 1))  # ['hell', ' python']

分割字符串也就是說(shuō)遇到指定的分割字符就以指定字符把字符串分兩半！通過(guò)返回結(jié)果可以看到汁汗，這種分割順序是從左到右開(kāi)始的衷畦。對(duì)應(yīng)的，我們也可以從右到左分割碰酝，我們可以用str.rsplit(obj='', num)完成：

s4 = "hello python"
print(s4.rsplit('o'))  # ['hell', ' pyth', 'n']
print(s4.rsplit('o', 1))  # ['hello pyth', 'n']

一般的霎匈，除了分割，包括替換在內(nèi)的順序都是從左到右地順序送爸，這是默認(rèn)的铛嘱。

18.4 str.join(sequence)

返回以指定字符將sequence連接后的新字符串。

s = 'abc' # a_b_c
print('_'.join(s))

#執(zhí)行結(jié)果
a_b_c

需要注意的是袭厂，sequence中的元素必須是字符串類(lèi)型墨吓，否則報(bào)錯(cuò)。

s6 = ['1', '2', '3']
s7 = [1, 2, 3]
print('-'.join(s6))  # 1-2-3
print('-'.join(s7))  # TypeError: sequence item 0: expected str instance, int found

上例中纹磺，s6和s7同為列表帖烘，但其內(nèi)的元素類(lèi)型不同，可以看到橄杨，如果其中的對(duì)象是int類(lèi)型秘症，就會(huì)報(bào)錯(cuò)。

18.5 str.upper() & str.lower()

返回字符串中英文字母大寫(xiě)形式的新字符串式矫，非英文字母乡摹、本身就是大寫(xiě)形式的英文字母略過(guò)。

s8 = '張開(kāi)說(shuō)Python就像1+1等于2那么簡(jiǎn)單'
print(s8.upper())  # 張開(kāi)說(shuō)PYTHON就像1+1等于2那么簡(jiǎn)單

與之對(duì)應(yīng)的是就是返回字符串中英文字母小寫(xiě)形式的新字符串采转，非英文字母聪廉、本身就是小寫(xiě)形式的英文字母略過(guò)。

s9 = '張開(kāi)說(shuō)Python就像1+1等于2那么簡(jiǎn)單'
print(s9.lower())  # 張開(kāi)說(shuō)python就像1+1等于2那么簡(jiǎn)單

這兩個(gè)方法用處很多故慈，比如我們?cè)诘卿涷?yàn)證碼的判斷這里就可以用到板熊，因?yàn)轵?yàn)證碼是隨機(jī)的，并且含有大小寫(xiě)和特殊字符的一串字符串察绷，那么怎么判斷呢棒厘，其中就可以通過(guò)upper()和lower()這兩個(gè)方法來(lái)判斷续镇。

verification_code = '12n%C'
result = input('輸入驗(yàn)證碼: ')
if verification_code.upper() == result.upper():  # 也可以將驗(yàn)證碼都以小寫(xiě)形式來(lái)判斷
    print('驗(yàn)證碼正確')
else:
    print('驗(yàn)證碼輸入錯(cuò)誤')

18.6 str.index & str.find

str.index(obj) & str.find(obj)

返回字符串中指定字符的索引位置坯沪，順序是從左到右的順序，找到就返回丹泉。

s1 = 'abcd'
print(s1.find('a'))  # 0
print(s1.find('w'))  # -1

s2 = 'abcd'
print(s2.index('a'))  # 0
print(s2.index('w'))  # ValueError: substring not found

找到就返回這沒(méi)錯(cuò)情萤，但需要我們注意的是鸭蛙，如果字符串中不存在指定的字符，兩個(gè)方法的返回結(jié)果也是不一樣的筋岛，如果字符串沒(méi)有指定字符娶视，str.find返回-1，而str.index則報(bào)錯(cuò)睁宰。

18.7 str.startswith & str.endswith

str.startswith(obj) & str.endswith(obj)

判斷字符串是否已指定字符開(kāi)頭或者結(jié)尾肪获，并以布爾值的形式返回。

s = 'abcd'
print(s.startswith('a'))  # True
print(s.startswith('ab'))  # True
print(s.startswith('acb'))  # False

print(s.endswith('d'))  # True
print(s.endswith('cd'))  # True
print(s.endswith('cbd'))  # False

通過(guò)結(jié)果可以看到柒傻，指定字符如果是多個(gè)孝赫，必須是連續(xù)的。

18.8 str.count

str.count(obj, start=0, end=len(str))

返回字符串中红符，指定索引范圍內(nèi)的指定元素出現(xiàn)的次數(shù)青柄，如果指定字符不在字符串中，則返回0预侯。開(kāi)始位置默認(rèn)為0致开，結(jié)束位置為字符串結(jié)束的位置。

s = 'https://www.cnblogs.com/Neeo/'
print(s.count('w'))  # 3
print(s.count('w', 1, 10))  # 2
print(s.count('1'))  # 0

18.9 str.center

str.center( width萎馅， filler)

返回一個(gè)指定寬度的字符串双戳，如果width的寬度小于字符串本身的寬度，就直接返回該字符串糜芳，否則字符串兩邊填充filler字符飒货，filler默認(rèn)是空格，且filler必須是單個(gè)字符峭竣，否則報(bào)錯(cuò)塘辅。

print('welcome to Linux111'.center(30, '☆'))

#執(zhí)行結(jié)果
☆☆☆☆☆☆welcome to Linux111☆☆☆☆☆☆

18.10 str.format()

自Python 2.6版本開(kāi)始，就增加了format函數(shù)邪驮，它增強(qiáng)了字符串格式化的功能莫辨，基本語(yǔ)法是通過(guò)“{}”和“:”來(lái)代替“%”。format函數(shù)可以接受不限個(gè)數(shù)的參數(shù)毅访，位置也可不按順序沮榜。下面通過(guò)示例來(lái)學(xué)習(xí) 一下format函數(shù)的用法：

• 按照默認(rèn)順序傳參：

print('{} {}'.format('hello', 'Anthony'))  # hello Anthony

默認(rèn)的，format將“hello”填充到第一個(gè)花括號(hào)內(nèi)喻粹，將“oldboy”填充到第二個(gè)花括號(hào)內(nèi)蟆融。相當(dāng)于平行賦值。

• 按照指定位置傳遞參數(shù)：

print('{0} {1}'.format('hello', 'Anthony'))  # hello Anthony
print('{0} {0}'.format('hello', 'Anthony'))  # hello hello
print('{1} {0}'.format('hello', 'Anthony'))  # Anthony hello
print('{1} {1}'.format('hello', 'Anthony'))  # Anthony Anthony

上例中守呜，我們可以這樣理解型酥，format內(nèi)兩個(gè)參數(shù)都有自己的位置序號(hào)山憨。然后根據(jù)序號(hào)填充字符串。

• 設(shè)置參數(shù)：

s = 'name: {name} | url:{url}'
print(s.format(name='Anthony', url='https://www.cnblogs.com/Neeo/'))  # name: Anthony | url:https://www.cnblogs.com/Neeo/

上例中弥喉，我們?yōu)閒ormat中的參數(shù)起個(gè)別名郁竟，然后字符串根據(jù)別名填充對(duì)應(yīng)的內(nèi)容。

求字符串的長(zhǎng)度

s = 'abcdefg'
print(len(s))

7

for i in s:
    print(i, s.index(i))

# 執(zhí)行結(jié)果
a 0
b 1
c 2
d 3
e 4
f 5
g 6    

s = 'abcd'
print(max(s))  # d
print(min(s))  # a
print(len(s))  # 4

19. 字符集和編碼詳解

相關(guān)知識(shí)：https://blog.csdn.net/qq_42068856/article/details/83792174
https://www.cnblogs.com/Neeo/articles/11215938.html

20. 作業(yè)

1.有變量name = "aleX leNb" 完成如下操作：

# 1.有變量name = " aleX leNb " 完成如下操作：
name = "aleX leNb"

# 移除 name 變量對(duì)應(yīng)的值兩邊的空格,并輸出處理結(jié)果
print(name.strip()) # aleX leNb

# 移除name變量左邊的"al"并輸出處理結(jié)果
print(name[2:-1])   # eX leN

# 移除name變量右面的"Nb",并輸出處理結(jié)果
print(name[0:-2])   # aleX le

# 移除name變量開(kāi)頭的a"與最后的"b",并輸出處理結(jié)果
print(name[1:-1])   # leX leN

# 判斷 name 變量是否以 "al" 開(kāi)頭,并輸出結(jié)果
print(name.startswith('al'))    # True

# 判斷name變量是否以"Nb"結(jié)尾,并輸出結(jié)果
print(name.endswith('Nb'))  # True

# 將 name 變量對(duì)應(yīng)的值中的 所有的"l" 替換為 "p",并輸出結(jié)果
print(name.replace('l', 'p'))   # apeX peNb

# 將name變量對(duì)應(yīng)的值中的第一個(gè)"l"替換成"p",并輸出結(jié)果
print(name.replace('l', 'p', 1))    # apeX leNb

# 將 name 變量對(duì)應(yīng)的值根據(jù) 所有的"l" 分割,并輸出結(jié)果由境。
print(name.split('l'))  # ['a', 'eX ', 'eNb']

# 將name變量對(duì)應(yīng)的值根據(jù)第一個(gè)"l"分割,并輸出結(jié)果棚亩。
print(name.split('l', 1))   # ['a', 'eX leNb']

# 將 name 變量對(duì)應(yīng)的值變大寫(xiě),并輸出結(jié)果
print(name.upper())  # ALEX LENB

# 將 name 變量對(duì)應(yīng)的值變小寫(xiě),并輸出結(jié)果
print(name.lower())  # alex lenb

# 將name變量對(duì)應(yīng)的值首字母"a"大寫(xiě),并輸出結(jié)果
print(name.title())  # Alex Lenb

# 判斷name變量對(duì)應(yīng)的值字母"l"出現(xiàn)幾次，并輸出結(jié)果
print(name.count('l'))  # 2

# 如果判斷name變量對(duì)應(yīng)的值前四位"l"出現(xiàn)幾次,并輸出結(jié)果
print(name.count('l', 0, 4))    # 1

# 從name變量對(duì)應(yīng)的值中找到"N"對(duì)應(yīng)的索引(如果找不到則報(bào)錯(cuò))虏杰，并輸出結(jié)果
print(name.index('N'))  # 7

# 從name變量對(duì)應(yīng)的值中找到"N"對(duì)應(yīng)的索引(如果找不到則返回-1)輸出結(jié)果
print(name.find('N'))   # 7

# 從name變量對(duì)應(yīng)的值中找到"X le"對(duì)應(yīng)的索引,并輸出結(jié)果
print(name.count('X le'))   # 1

# 請(qǐng)輸出 name 變量對(duì)應(yīng)的值的第 2 個(gè)字符?
print(name[1:2])    # l

# 請(qǐng)輸出 name 變量對(duì)應(yīng)的值的前 3 個(gè)字符?
print(name[:3])  # ale

# 請(qǐng)輸出 name 變量對(duì)應(yīng)的值的后 2 個(gè)字符?
print(name[-2:])    # Nb

# 請(qǐng)輸出 name 變量對(duì)應(yīng)的值中 "e" 所在索引位置（兩個(gè)e都找）?
#此題解法：https://zhidao.baidu.com/question/425671789131374252.html
find = 'e'
print([i for i,v in enumerate(name) if v==find])    # [2, 6]

20.2 有字符串s = "123a4b5c"

通過(guò)對(duì)s切片形成新的字符串s1,s1 = "123"
s1 = s[:3]
print(s1)   # 123

通過(guò)對(duì)s切片形成新的字符串s2,s2 = "a4b"
s2 = s[3:6]
print(s2)   # a4b

通過(guò)對(duì)s切片形成新的字符串s3,s3 = "1345"
s3 = s[0:-1:2]
print(s3)   # 1345

通過(guò)對(duì)s切片形成字符串s4,s4 = "2ab"
s4 = s[1:-1:2]
print(s4)   # 2ab

通過(guò)對(duì)s切片形成字符串s5,s5 = "c"
s5 = s[-1]
print(s5)   # c

通過(guò)對(duì)s切片形成字符串s6,s6 = "ba2"
s6 = s[-3::-2]
print(s6)   # ba2

20.3 使用while和for循環(huán)分別打印字符串s="asdfer"中每個(gè)元素

# while循環(huán)
s = "asdfer"
num = 0
while True:
    print(s[num])
    num += 1
    if num == len(s):
        break

# for循環(huán)
s = "asdfer"
for i in s:
    print(i)

20.4 使用for循環(huán)對(duì)s="asdfer"進(jìn)行循環(huán)讥蟆，但是每次打印的內(nèi)容都是"asdfer"。

s = "asdfer"
for i in s:
    print(s)

20.5 使用for循環(huán)對(duì)s="abcdefg"進(jìn)行循環(huán)纺阔，每次打印的內(nèi)容是每個(gè)字符加上sb瘸彤，

例如：asb, bsb，csb,...gsb笛钝。

s = "asdfer"
for i in s:
    print(i + 'sb')

#執(zhí)行結(jié)果
asb
ssb
dsb
fsb
esb
rsb

20.6 使用for循環(huán)對(duì)s="321"進(jìn)行循環(huán)质况，打印的內(nèi)容依次是："倒計(jì)時(shí)3秒"，"倒計(jì)時(shí)2秒"婆翔，"倒計(jì)時(shí)1秒"拯杠，"出發(fā)！"啃奴。

s = "321"
for i in s:
    # print('倒計(jì)時(shí)'+i+'秒')
    print('倒計(jì)時(shí){}秒'.format(i))
print('出發(fā)!')

#執(zhí)行結(jié)果
倒計(jì)時(shí)3秒
倒計(jì)時(shí)2秒
倒計(jì)時(shí)1秒
出發(fā)!

20.7 實(shí)現(xiàn)一個(gè)整數(shù)加法計(jì)算器(兩個(gè)數(shù)相加)：

如：content = input("請(qǐng)輸入內(nèi)容:") 用戶(hù)輸入：5+9或5+ 9或5 + 9潭陪，然后進(jìn)行分割再進(jìn)行計(jì)算。

# 思路：將輸入的空格可以替換為空最蕾，利用str.replace
# 分割'+'號(hào)
content = input("請(qǐng)輸入相加的整數(shù);格式[x+y]: ").replace(' ', '')
num = content.split('+')
print(int(num[0] + num[1]))

20.8 升級(jí)題：實(shí)現(xiàn)一個(gè)整數(shù)加法計(jì)算器（多個(gè)數(shù)相加）：

如：content = input("請(qǐng)輸入內(nèi)容:") 用戶(hù)輸入：5+9+6 +12+ 13依溯，然后進(jìn)行分割再進(jìn)行計(jì)算。

# 使用for循環(huán)瘟则，先將'+'號(hào)分割定義變量黎炉，然后再利用int整型計(jì)算相加

content = input("請(qǐng)輸入相加的整數(shù);格式[x+y]: ").replace('', '')
num = content.split('+')
s = 0
for i in num:
    s += int(i.strip())
print(s)

# 使用for循環(huán)，直接分割后利用int整型計(jì)算相加

content = input("請(qǐng)輸入相加的整數(shù);格式[x+y]: ").replace('', '')
s = 0
for i in content.split('+'):
    s += int(i.strip())
print(s)

image

20.9 計(jì)算用戶(hù)輸入的內(nèi)容中有幾個(gè)整數(shù)（以個(gè)位數(shù)為單位）醋拧。

如：content = input("請(qǐng)輸入內(nèi)容：") # 如fhdal234slfh98769fjdla

str.isdigit()方法：https://www.runoob.com/python/att-string-isdigit.html

content = input("請(qǐng)輸入內(nèi)容: ").replace('', '')
s = 0
# 利用str.isdigit 如果字符串只包含數(shù)字則返回True的方法來(lái)統(tǒng)計(jì)輸了多少個(gè)數(shù)字
for i in content.strip('+'):
    if i.isdigit():
        s += 1
print('您一共輸入了[', s, ']個(gè)整數(shù)')

image

# 對(duì)照第八題的思路
# 使用for循環(huán)慷嗜，直接分割后利用int整型計(jì)算相加計(jì)算整數(shù)的和
# 使用了倆個(gè)for循環(huán)，第一個(gè)實(shí)現(xiàn)和的計(jì)算丹壕，第二個(gè)實(shí)現(xiàn)輸入整數(shù)的統(tǒng)計(jì)

content = input("請(qǐng)輸入相加的整數(shù);格式[x+y]: ").replace('', '')
# 定義兩個(gè)變量
n = 0
s = 0
for j in content.split('+'):
    n += int(j.strip())
print('和為:', n)

# 利用str.isdigit 如果字符串只包含數(shù)字則返回True的方法來(lái)統(tǒng)計(jì)輸了多少個(gè)數(shù)字
for i in content.strip('+'):
    if i.isdigit():
        s += 1
print('您一共輸入了[', s, ']個(gè)整數(shù)')

image

20.10 寫(xiě)代碼庆械，完成下列需求：(升級(jí)題)

用戶(hù)可持續(xù)輸入（用while循環(huán)），用戶(hù)使用的情況：
輸入A菌赖，則顯示走大路回家缭乘，然后在讓用戶(hù)進(jìn)一步選擇：
是選擇公交車(chē)，還是步行琉用？
選擇公交車(chē)堕绩，顯示10分鐘到家策幼，并退出整個(gè)程序。
選擇步行奴紧，顯示20分鐘到家特姐，并退出整個(gè)程序。
輸入B绰寞，則顯示走小路回家到逊，并退出整個(gè)程序。
輸入C滤钱，則顯示繞道回家，然后在讓用戶(hù)進(jìn)一步選擇：
是選擇游戲廳玩會(huì)脑题，還是網(wǎng)吧件缸？
選擇游戲廳，則顯示 ‘一個(gè)半小時(shí)到家叔遂，爸爸在家他炊，拿棍等你∫鸭瑁’并讓其重新輸入A痊末，B, C選項(xiàng)。
選擇網(wǎng)吧哩掺，則顯示‘兩個(gè)小時(shí)到家凿叠，媽媽已做好了戰(zhàn)斗準(zhǔn)備〗劳蹋’并讓其重新輸入A盒件，B, C選項(xiàng)。

while True:
    print('☆耶 下課了舱禽！你打算去做什么呢炒刁？''\n\t', 'A.走大路回家☆', '\n\t', 'B.走小路回家☆', '\n\t', 'C.繞遠(yuǎn)道回家☆')
    xz = input('請(qǐng)告訴你的選擇[A|B|C]: ')
    # xz = input('>>>:').strip()
    if xz.upper() == 'A':
        print('你選擇了走大路回家')
        xz = input('☆是選擇\n\tA.公交車(chē)\n\tB.還是步行？')
        if xz.upper() == 'A':
            print('10分鐘后到家...')
            break
        elif xz.upper() == 'B':
            print('20分鐘后到家...')
            break
    elif xz.upper() == 'B':
        print('你選擇了走小路回家\n路上要小心色狼')
        break
    elif xz.upper() == 'C':
        print('你選擇了繞遠(yuǎn)道回家')
        xz = input('☆是選擇\n\tA.游戲廳玩會(huì)\n\tB.還是網(wǎng)吧誊稚？')
        if xz.upper() == 'A':
            print('一個(gè)半小時(shí)到家翔始，爸爸在家，拿棍等你里伯。')
        elif xz.upper() == 'B':
            print('兩個(gè)小時(shí)到家城瞎，媽媽已做好了戰(zhàn)斗準(zhǔn)備。')
        else:
            print('輸入錯(cuò)誤')
    else:
        print('輸入錯(cuò)誤')

#選擇A 執(zhí)行過(guò)程
☆耶 下課了俏脊！你打算去做什么呢全谤？
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.繞遠(yuǎn)道回家☆
請(qǐng)告訴你的選擇[A|B|C]: a
你選擇了走大路回家
☆是選擇
    A.公交車(chē)
    B.還是步行订晌？a
10分鐘后到家...
Process finished with exit code 0

#選擇B 執(zhí)行過(guò)程
☆耶 下課了颓帝！你打算去做什么呢房匆？
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.繞遠(yuǎn)道回家☆
請(qǐng)告訴你的選擇[A|B|C]: b
你選擇了走小路回家
路上要小心色狼

Process finished with exit code 0

#選擇C 執(zhí)行過(guò)程
☆耶 下課了酌伊！你打算去做什么呢？
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.繞遠(yuǎn)道回家☆
請(qǐng)告訴你的選擇[A|B|C]: C
你選擇了繞遠(yuǎn)道回家
☆是選擇
    A.游戲廳玩會(huì)
    B.還是網(wǎng)吧卷员？A
一個(gè)半小時(shí)到家盈匾，爸爸在家，拿棍等你毕骡。
☆耶 下課了削饵！你打算去做什么呢？    # 返回未巫，重新輸入
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.繞遠(yuǎn)道回家☆
請(qǐng)告訴你的選擇[A|B|C]: C
你選擇了繞遠(yuǎn)道回家
☆是選擇
    A.游戲廳玩會(huì)
    B.還是網(wǎng)吧窿撬？B
兩個(gè)小時(shí)到家，媽媽已做好了戰(zhàn)斗準(zhǔn)備叙凡。  
☆耶 下課了劈伴！你打算去做什么呢？    # 返回握爷，重新輸入
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.繞遠(yuǎn)道回家☆
請(qǐng)告訴你的選擇[A|B|C]: 

20.11 寫(xiě)代碼跛璧，有如下列表，按照要求實(shí)現(xiàn)每一個(gè)功能

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
計(jì)算列表的長(zhǎng)度并輸出
列表中追加元素"seven",并輸出添加后的列表
請(qǐng)?jiān)诹斜淼牡?個(gè)位置插入元素"Tony",并輸出添加后的列表
請(qǐng)修改列表第2個(gè)位置的元素為"Kelly",并輸出修改后的列表
請(qǐng)將列表l2=[1,"a",3,4,"heart"]的每一個(gè)元素添加到列表li中新啼，一行代碼實(shí)現(xiàn)追城，不允許循環(huán)添加。
請(qǐng)將字符串s = "qwert"的每一個(gè)元素添加到列表li中燥撞，一行代碼實(shí)現(xiàn)座柱，不允許循環(huán)添加。
請(qǐng)刪除列表中的元素"ritian",并輸出添加后的列表
請(qǐng)刪除列表中的第2個(gè)元素叨吮，并輸出刪除的元素和刪除元素后的列表
請(qǐng)刪除列表中的第2至4個(gè)元素辆布，并輸出刪除元素后的列表
請(qǐng)將列表所有得元素反轉(zhuǎn)，并輸出反轉(zhuǎn)后的列表
請(qǐng)計(jì)算出"alex"元素在列表li中出現(xiàn)的次數(shù)茶鉴，并輸出該次數(shù)锋玲。

20.12 寫(xiě)代碼，有如下列表涵叮，利用切片實(shí)現(xiàn)每一個(gè)功能

li = [1, 3, 2, "a", 4, "b", 5,"c"]
通過(guò)對(duì)li列表的切片形成新的列表l1,l1 = [1,3,2]
通過(guò)對(duì)li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通過(guò)對(duì)li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
通過(guò)對(duì)li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通過(guò)對(duì)li列表的切片形成新的列表l5,l5 = ["c"]
通過(guò)對(duì)li列表的切片形成新的列表l6,l6 = ["b","a",3]

20.13 寫(xiě)代碼惭蹂，有如下列表，按照要求實(shí)現(xiàn)每一個(gè)功能割粮。

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
將列表lis中的"tt"變成大寫(xiě)盾碗。
將列表中的數(shù)字3變成字符串"100"。
將列表中的字符串"1"變成數(shù)字101舀瓢。

20.14 請(qǐng)用代碼實(shí)現(xiàn)：

li = ["alex", "wusir", "taibai"]
利用下劃線將列表的每一個(gè)元素拼接成字符串"alex_wusir_taibai"

21.列表

資料連接：https://www.cnblogs.com/Neeo/articles/11212368.html

列表是Python中最常用的數(shù)據(jù)類(lèi)型之一廷雅，也是最靈活的數(shù)據(jù)類(lèi)型之一，其可以包含任何種類(lèi)的對(duì)象：數(shù)字、字符串航缀、元組商架、字典，也可以嵌套的包含列表芥玉。當(dāng)然與字符串不同的是蛇摸，列表是可變的，可變指的是我們?cè)谠幮薷钠渲械膬?nèi)容灿巧，如刪除或增加一個(gè)元素赶袄，則列表中的其他元素自動(dòng)縮短或者增長(zhǎng)，也正是如此抠藕，在列表元素個(gè)數(shù)過(guò)多時(shí)饿肺，如果你刪除靠前的（如第一個(gè)）元素，其他的元素都要向前移動(dòng)幢痘，會(huì)導(dǎo)致性能有所下降唬格，這是在開(kāi)發(fā)中需要注意的。

21.1 創(chuàng)建列表

在Python中颜说，用一對(duì)中括號(hào)[]來(lái)表示列表（list），用,分割列表內(nèi)的每個(gè)元素汰聋。

l = []
print(l)  # []
print(type(l))  # <class 'list'>
print(list('abcdefg'))  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list(range(-1, 4)))  # [-1, 0, 1, 2, 3]
print(list(range(1, 11)))   # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(range(1, 11, 3))) # [1, 4, 7, 10]

21.2 列表合并（拼接）： +

l1 = [1, 2, 3]
l2 = ['a', 'b', 'c']
l3 = l1 + l2
print(l3)  # [1, 2, 3, 'a', 'b', 'c']

合并（拼接）就是將兩個(gè)列表合為一個(gè)新列表门粪，原有列表不變。

21.3 列表的重復(fù)：*

l1 = [1, 2, 3]
l2 = l1 * 3
print(l2)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

重復(fù)可以理解為將原列表復(fù)制指定次數(shù)烹困，然后相加得到一個(gè)新的列表玄妈。

21.4 列表成員資格判斷：in，not in

l = ['a', 'b', 'we']
print('a' in l)  # True
print('w' not in l)  # True
print('we' in l)  # True

成員資格測(cè)試就是判斷指定元素是否存在于列表中髓梅，存在則返回True拟蜻，不存在則返回False。

21.5 通過(guò)索引取值

l = ['a', 'b', 1, 2]
print(l[0])  # a
print(l[6])  # IndexError: list index out of range

列表中每一個(gè)元素都有自己的索引（從0開(kāi)始）位置枯饿，這也是為什么說(shuō)列表是有序的原因酝锅。我們可以通過(guò)索引取對(duì)應(yīng)的值。
注意奢方，當(dāng)通過(guò)索引取值時(shí)搔扁，索引范圍超過(guò)列表索引長(zhǎng)度時(shí)，會(huì)報(bào)錯(cuò)蟋字，因?yàn)闆](méi)有這個(gè)索引位置稿蹲。

21.6 切片

l = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# 從指定索引位置開(kāi)始取值
print(l[3:])  # ['d', 'e', 'f', 'g']
# 取列表內(nèi)的一段元素
print(l[3:6])  # ['d', 'e', 'f']
# 每隔兩個(gè)取一個(gè)
print(l[1:6:2])  # ['b', 'd', 'f']
# 取索引為-2的元素
print(l[-2])  # f
# 從左向右取，從0開(kāi)始鹊奖，取到倒數(shù)第二個(gè)之前的
print(l[:-2])  # ['a', 'b', 'c', 'd', 'e']
# 反轉(zhuǎn)列表
print(l[::-1])  # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

切片是根據(jù)列表的索引來(lái)取值（取范圍內(nèi)的值）苛聘，需要說(shuō)明的是，只要是序列類(lèi)型（字符串，列表设哗，元組）唱捣，其內(nèi)的元素都有自己的索引位置，我們可以根據(jù)索引位置取值熬拒，切片爷光。

21.7 for循環(huán)取值

l = ['a', 'b', 'c', 'd']
for i in l:
    print(i)
'''
a
b
c
d
'''

for循環(huán)取值時(shí)，每次循環(huán)取出一個(gè)元素澎粟，然后將這個(gè)元素賦值給i蛀序，我們就可以通過(guò)操作i來(lái)操作取出的元素。

21.8 列表元素更新

l = ['a', 'b', 'c', 'd']
print(l, id(l))  # ['a', 'b', 'c', 'd'] 128337600
l[1] = 'w'
print(l, id(l))  # ['a', 'w', 'c', 'd'] 128337600

通過(guò)指定的索引修改列表中對(duì)應(yīng)的元素活烙，并且通過(guò)打印結(jié)果發(fā)現(xiàn)徐裸，當(dāng)列表內(nèi)的元素被修改后，列表的內(nèi)存地址不變啸盏。

21.9 刪除列表（元素）

l = ['a', 'b', 'c', 'd']
del l[0]
print(l)  # ['b', 'c', 'd']
del l[0], l[1]
print(l)  # ['c']
del l
print(l)  # NameError: name 'l' is not defined

使用del關(guān)鍵字進(jìn)行列表元素的刪除重贺，del支持刪除多個(gè)元素。但要注意的是回懦，刪除多個(gè)元素的時(shí)候气笙，需要牢記，要?jiǎng)h除的第一個(gè)元素后面的元素此時(shí)還在索引范圍內(nèi)怯晕。
另外潜圃，當(dāng)刪除列表中的指定索引后，如果該索引后面還有元素舟茶，則后面所有的元素都會(huì)往前位移谭期，或者稱(chēng)為補(bǔ)位。
當(dāng)使用del刪除整個(gè)列表后吧凉，這個(gè)列表就不存在了隧出，也就是最后的報(bào)錯(cuò)。
還有一點(diǎn)需要注意：

l = ['a', 'b', 'c', 'd']
del l[1], l[2]
print(l, len(l))  # ['a', 'c'] 2
del l[3]  # IndexError: list assignment index out of range

原列表的最大索引為3阀捅，刪除兩個(gè)元素后胀瞪，此時(shí)列表最大的索引為2，此時(shí)卻要?jiǎng)h除索引為3的元素也搓，就拋出錯(cuò)誤了赏廓。

21.10 總結(jié)，列表中的常用操作符：

列表中的常用方法：

同樣的幔摸，還有其他置函數(shù)或者聲明語(yǔ)句可以應(yīng)用于列表：

需要注意的，max()和min()函數(shù)都需要列表內(nèi)的元素類(lèi)型保持一致颤练，不然沒(méi)法比較凹纫洹！
另外，cmp()函數(shù)在Python 3.x中不存在了患雇，如果要使用類(lèi)似功能跃脊，可以使用operator代替，它適合任何對(duì)象：

import operator
print(operator.eq([1, 2], [2, 1]))  # False

或者使用更簡(jiǎn)單的方式：

print([1, 2] > [2, 1])  # False
print([1, 2] == [2, 1])  # False
print([1, 2] != [2, 1])  # True

22. 列表的常用方法

22.1 list.append(obj)

將一個(gè)對(duì)象（元素）追加到列表的末尾苛吱。這只是一個(gè)追加操作酪术，并且是原地操作列表景图，所以該方法沒(méi)有返回值窍荧。

l = ['a', 'b', 'c', 'd']
l.append(1)
print(l)  # ['a', 'b', 'c', 'd', 1]
l.append('w')
print(l)  # ['a', 'b', 'c', 'd', 1, 'w']

由打印結(jié)果可以看到钞艇，兩個(gè)元素都已追加的形式被存放在列表的尾部晓折。

22.2 list.insert(index, obj)

將一個(gè)對(duì)象（元素）插入到列表的指定索引的前面。這只是一個(gè)插入操作蝙云，并且是原地操作列表猪半，所以該方法沒(méi)有返回值色冀。

l = ['a', 'b', 'c', 'd']
l.insert(1, 1)
print(l)  # ['a', 1, 'b', 'c', 'd']

可以看到住拭，我們通過(guò)insert操作在列表索引為1的元素前面插入一個(gè)新元素1挪略。
需要注意的是，就如插隊(duì)一樣滔岳，前面插入一個(gè)人杠娱，后面的人都要往后移動(dòng)一位，如果列表長(zhǎng)度很長(zhǎng)的話谱煤，會(huì)對(duì)性能有所影響墨辛。

In [2]: %timeit list(range(100000)).append('a')
3.25 ms ± 22.9 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [3]: %timeit list(range(100000)).insert(0, 'a')
3.36 ms ± 99.5 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

上例，我們通過(guò)ipython測(cè)試同樣是十萬(wàn)個(gè)元素的列表趴俘，一個(gè)執(zhí)行將元素追加到列表的尾部，一個(gè)執(zhí)行將元素插入到列表的頭部奏赘，可以看到寥闪，追加操作需要耗費(fèi)3.25ms，而插入操作需要3.36ms磨淌。

22.3 list.pop([obj])

移除列表中的指定索引位置的元素疲憋，若不指定索引，默認(rèn)移除列表尾部的元素梁只，并且將列表返回（返不返回是我的事兒缚柳，接不接收是你的事兒）。

l = ['a', 'b', 'c', 'd']
print(l.pop(1))  # b
print(l.pop())  # d
print(l.pop(9))  # IndexError: pop index out of range
print(l.pop('d'))  # TypeError: 'str' object cannot be interpreted as an integer

前三個(gè)打印好解釋?zhuān)詈笠粋€(gè)打告訴我們字符串無(wú)法解釋為整型搪锣，也就是說(shuō)秋忙，list.pop(obj)移除操作要么是指定元素下標(biāo)，要么什么都不指定构舟，按照人家默認(rèn)的來(lái)灰追，而不能指定刪除某個(gè)元素。

22.4 list.remove(obj)

刪除列表中的指定元素，不指定或指定元素不存在報(bào)錯(cuò)弹澎，而且僅是刪除操作朴下，沒(méi)有返回值。

image

l = ['a', 'b', 'c', 'd']

l.remove('a')
l.remove('c')
print(l)  # ['b', 'd']
l.remove(1)  # ValueError: list.remove(x): x not in list

最后報(bào)錯(cuò)說(shuō)刪除的指定元素不存在苦蒿。

22.5 list.reverse()

反轉(zhuǎn)列表殴胧，并沒(méi)有參數(shù)和返回值，只是在原地對(duì)列表中的元素進(jìn)行反轉(zhuǎn)佩迟。

l = ['a', 'b', 'c', 'd']
l.reverse()
print(l)  # ['d', 'c', 'b', 'a']

22.6 list.sort(key=None, reverse=False)

原地對(duì)列表進(jìn)行排序团滥，key是自定義的排序算法，此函數(shù)在每次元素比較時(shí)被調(diào)用音五，reverse表示排序方式惫撰，默認(rèn)的false是按照升序進(jìn)行排序的，當(dāng)reverse=True時(shí)躺涝，排序結(jié)果為降序厨钻。

image

l = ['a', 'c', 'b', 'd']
l.sort()
print(l)  # ['a', 'b', 'c', 'd']
l.sort(reverse=True)
print(l)  # ['d', 'c', 'b', 'a']

我們來(lái)看看key參數(shù)怎么使用：

l = ['abc', 'cae', 'edg', 'ffh']
l.sort(key=lambda x: x[1])
print(l)  # ['cae', 'abc', 'edg', 'ffh']

通過(guò)key指定以每個(gè)元素中的索引為1的元素排序。
需要補(bǔ)充的是sorted(key=None, reverse=False)函數(shù)坚嗜，它是Python內(nèi)置的對(duì)于所有序列類(lèi)型進(jìn)行排序的函數(shù)夯膀，而不像sort()方法是列表獨(dú)有的排序方法。
二者區(qū)別是：

• sort方法僅能對(duì)列表進(jìn)行原地排序苍蔬，沒(méi)有返回值诱建。
• sorted函數(shù)對(duì)所有序列類(lèi)型進(jìn)行排序，并且并不是原地排序碟绑，它會(huì)返回排序結(jié)果俺猿，也就是說(shuō)我們可以通過(guò)一個(gè)變量接收排序結(jié)果。

需要注意的是格仲，無(wú)論使用哪種排序方式押袍，排序?qū)ο蟊仨毷峭?lèi)型的，也就是說(shuō)凯肋，如果排序?qū)ο笫橇斜硪瓴眩敲戳斜韮?nèi)的元素都為同一類(lèi)型，因?yàn)椴煌?lèi)型無(wú)法比較侮东。

轉(zhuǎn)換為字符串

image

image

image

23. 列表的嵌套

image

如果嵌套層數(shù)過(guò)多圈盔，可以使用遞歸的方法，擴(kuò)展項(xiàng)

前文介紹列表時(shí)說(shuō)的元素類(lèi)型豐富悄雅，就是說(shuō)列表不僅能存儲(chǔ)數(shù)字驱敲、字符串，還能存儲(chǔ)列表煤伟。

>>> l = [1, 2, [3, 4]]    
>>> for i in l:    
...     print(i)    
...    
1    
2    
[3, 4]    
>>> l[2]    
[3, 4]    
>>> l[2].pop()    
4    
>>> l    
[1, 2, [3]]    
>>> l[2].insert(0,'a')    
>>> l    
[1, 2, ['a', 3]]    

可以看到癌佩，列表對(duì)嵌套部分處理也同樣的簡(jiǎn)單木缝，可以使用我們學(xué)過(guò)的方法， 不僅如此围辙，列表還可以存儲(chǔ)別的數(shù)據(jù)結(jié)構(gòu)我碟，如字典、元組姚建、集合矫俺。

>>> l = [1,(2, 3), [4,[5, 6]], {'a':'b'}, {7, 8}]    
>>> for i in l:    
...     print(i)    
...    
1    
(2, 3)    
[4, [5, 6]]    
{'a': 'b'}    
{8, 7}    
>>> l[1][1]    
3    
>>> l[2][1][1] = 'c'    
>>> l[3]['a']    
'b'    
>>> l[-1]    
{8, 7}    
>>> l    
[1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7}]    

先不管元組、字典掸冤、集合的是什么厘托。但并不推薦這么用，因?yàn)檫@樣操作起來(lái)太不方便稿湿，只是演示列表可以各種嵌套铅匹，一般使用中，更多的是嵌套一種數(shù)據(jù)類(lèi)型饺藤，如列表嵌套元組包斑，列表嵌套字典，但很少有同時(shí)嵌套元組和字典的涕俗。
那么罗丰，我們?nèi)绾握故玖斜碇械乃性啬兀窟@里我們可以使用嵌套循環(huán)完成再姑。

>>> for i in [1, [2, 3], 4]:  
...     if isinstance(i, list):  
...         for j in i:  
...             print(j)  
...     else:  
...         print(i)  
...  
1  
2  
3  
4  

上例中萌抵，第1行for循環(huán)列表，第2行判斷每次循環(huán)中的元素是否為列表元镀，如果是列表绍填，那么就再用for循環(huán)循環(huán)打印其內(nèi)的列表中的元素。否則執(zhí)行第5行的else語(yǔ)句直接打印列表內(nèi)的元素栖疑。

需要強(qiáng)調(diào)的是沐兰，Python中并沒(méi)有二維數(shù)組的概念，但是列表嵌套列表同樣能夠達(dá)到相同的目的

24.元組tuple

資料鏈接：https://www.cnblogs.com/Neeo/articles/11212374.html

Python的元組與列表類(lèi)似蔽挠，不同之處在于元組的元素不能修改。

元組使用小括號(hào)瓜浸，列表使用方括號(hào)澳淑。

元組創(chuàng)建很簡(jiǎn)單，只需要在括號(hào)中添加元素插佛，并使用逗號(hào)隔開(kāi)即可杠巡。

創(chuàng)建空元組

tup1 = ()

元組中只包含一個(gè)元素時(shí)，需要在元素后面添加逗號(hào)

tup1 = (50,)

元組與字符串類(lèi)似雇寇，下標(biāo)索引從0開(kāi)始氢拥，可以進(jìn)行截取蚌铜，組合等。

24.1 元組的基本操作

創(chuàng)建元組

Python中嫩海，元組（tuple）用一對(duì)小括號(hào)()表示冬殃，元組內(nèi)的各元素以逗號(hào)分隔。

t = ()
print(type(t))  # <type 'tuple'>
t1 = ('name', )
print(t1)  # ('name',)
print(type(t1))  # <type 'tuple'>

元組中特別注意逗號(hào)的使用叁怪，一不小心創(chuàng)建的元組就會(huì)成為字符串审葬。

t = ('name')
print(t, type(t))  # ('name', <type 'str'>)
t1 = ('name', )
print(t1, type(t1))  # (('name',), <type 'tuple'>)

索引和切片

元組中索引和切片的用法跟列表和字符串類(lèi)似，或者取范圍內(nèi)的值奕谭，或者可以指定在一段范圍內(nèi)涣觉，每幾個(gè)取一個(gè)：

t = ('a', 'b', 'c', 'd', 'e')
# 按照索引取值
print(t[1])  # b
print(t[-1]) # e

# 取兩者之間（范圍）的值
print(t[0:4])  # ('a', 'b', 'c', 'd')
print(t[0:5:2])  # ('a', 'c', 'e')

# 反轉(zhuǎn)元組，返回反轉(zhuǎn)后的新的元組血柳，原本的元組不變
print(t[::-1])  # ('e', 'd', 'c', 'b', 'a')

# for循環(huán)取值
for i in t:
    print(i)
'''
a
b
c
d
e
'''

但與列表不同的是官册，元組身為不可變類(lèi)型，無(wú)法原地修改其中的值难捌。

t = ('a', 'b', 'c', 'd', 'e')
t[2] = 'w'

'''
TypeError: 'tuple' object does not support item assignment
'''

拼接： +

雖然元組無(wú)法原地修改其中的元素膝宁，但是，通過(guò)+號(hào)可以把兩個(gè)元組合并為一個(gè)新的元組栖榨。

t1 = ('a', 'b')
t2 = ('c', 'd', 'e')
t3 = t1 + t2
print(t3)  # ('a', 'b', 'c', 'd', 'e')

元組的重復(fù)：*

簡(jiǎn)單來(lái)說(shuō)昆汹，正如字符串的重復(fù)一樣，當(dāng)對(duì)元組使用*時(shí)，復(fù)制指定次數(shù)后合并為一個(gè)新的元組荷并。

t1 = ('a', 'b')
t2 = t1 * 2
print(t2)  # ('a', 'b', 'a', 'b')

成員資格測(cè)試： in沟使，not in
與字符串、列表的成員資格測(cè)試在元組中同樣適用：

t1 = ('a', 'b', 'abc')
print('a' in t1)  # True
print('b' not in t1)  # False

需要注意的是映皆，成員資格判斷，只是會(huì)判斷某個(gè)元素是否存是元組的一級(jí)元素轰枝，比如上例中的a是元組的一級(jí)元素捅彻。而c不是元組的一級(jí)元素。在元組中鞍陨，c是元組一級(jí)元素字符串abc的子串步淹。所以判斷結(jié)果為False。

序列（元組）類(lèi)型的打包與解包

t = 1, 2, 3
x, y, z = t
print(x, y, z)  # 1 2 3

上例第1行诚撵，將1缭裆、2、3打包賦值給變量t寿烟，相當(dāng)于將3個(gè)蘋(píng)果打包到一個(gè)盒子內(nèi)澈驼。第2行，從盒子t中將3個(gè)蘋(píng)果取出來(lái)筛武，分別交給x缝其、y挎塌、z，我們稱(chēng)為解包内边。解包這里需要注意的是榴都，盒子里有幾個(gè)蘋(píng)果，必須有幾個(gè)對(duì)應(yīng)的變量接收假残。多了不行缭贡，少了也不行。

平行賦值

>>> x, y = 1, 2  
>>> x,y  
(1, 2)  
>>> x  
1  
>>> type(x)  
<class 'int'>  
>>> a = x,y  
>>> a  
(1, 2)  
>>> type(a)  
<class 'tuple'>  

如上例第1行所示辉懒，平行賦值就是等號(hào)右邊的1阳惹，2分別賦值給等號(hào)左邊的x，y眶俩。第2行就是打包了（只是打包莹汤，并沒(méi)有賦值給某個(gè)變量），并且打包后的結(jié)果是元組類(lèi)型颠印。而在第8行將x纲岭，y打包并賦值給變量a。此時(shí)a就是打包后的元組了线罕。

通過(guò)打印斐波那契序列來(lái)練習(xí)平行賦值：

x, y = 0, 1
while x < 8:
    x, y = y, x + y
    print(x)
'''
1
1
2
3
5
8
'''

首先定義x止潮，y兩個(gè)變量并賦值。在每次循環(huán)中钞楼，x和y值都會(huì)重新賦值喇闸。

刪除元組

注意，這里說(shuō)的刪除僅是刪除整個(gè)元組询件，而不是刪除元組中某個(gè)元素燃乍。

>>> t = (1, 2, 3)  
>>> del t[1]  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: 'tuple' object doesn't support item deletion  
>>> del t  
>>> t  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
NameError: name 't' is not defined  

上例第2行，通過(guò)刪除元組內(nèi)的元素導(dǎo)致報(bào)錯(cuò)宛琅，又一次的證明元組為不可變類(lèi)型刻蟹。但我們可以刪除整個(gè)元組(第6行)。

24.1.1 總結(jié)嘿辟，元組中常用的操作符：

另外，還有幾個(gè)內(nèi)置的函數(shù)可以應(yīng)用于元組：

24.2 元組的嵌套

與列表一樣红伦，元組也能嵌套存儲(chǔ)數(shù)據(jù)：

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
for item in t:
    print(item)
'''
1
(2, 3)
[4, [5, 'c']]
{'a': 'b'}
{8, 7}
'''

元組內(nèi)可以存儲(chǔ)的數(shù)據(jù)類(lèi)型相當(dāng)豐富介陶，也可以發(fā)現(xiàn)，嵌套元素也會(huì)當(dāng)成一個(gè)整體稱(chēng)為元組的子元素色建。但是我們說(shuō)元組是不可更改的，但我們發(fā)現(xiàn)其中是由列表的舌缤，這是怎么回事箕戳？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[0] = 'x'  # TypeError: 'tuple' object does not support item assignment

通過(guò)上例某残，可以發(fā)現(xiàn)，元組內(nèi)的普通元素不允許修改陵吸，但是列表是可變玻墅，我們能否把列表替換為別的元素呢？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
print(t[2])  # [4, [5, 'c']]
t[2] = 'w'  # TypeError: 'tuple' object does not support item assignment

通過(guò)上例也可以發(fā)現(xiàn)壮虫，如果列表被當(dāng)成了元組的普通元素澳厢，那么它也是不可以修改的，遵循元組不可變特性囚似。但是我們?nèi)绻噲D修改列表中的子元素呢剩拢？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[2][0] = 'w'
print(t)  # (1, (2, 3), ['w', [5, 'c']], {'a': 'b'}, {8, 7})

上例，可以發(fā)現(xiàn)饶唤，t[2][0]指的是列表中的第一個(gè)元素徐伐，我們?cè)诘?行修改它，然后發(fā)現(xiàn)是可以修改成功的募狂。這是為什么呢办素？元組內(nèi)的普通元素不允許修改，嵌套的子元素是否能夠修改取決于這個(gè)子元素本身屬于什么數(shù)據(jù)類(lèi)型祸穷，如這個(gè)子元素是列表性穿，那就可以修改，如果是元組雷滚，就可不以修改需曾。

那么，了解完元組揭措，你可能更有疑問(wèn)了胯舷，除了不可變之外，元組跟列表沒(méi)啥區(qū)別么绊含？我們通過(guò)與列表的對(duì)比桑嘶，來(lái)證明存在即是真理！

需要注意的是躬充，元組并沒(méi)有增逃顶、刪功能。那么元組如此設(shè)計(jì)充甚，以放棄增以政、刪為代價(jià)換來(lái)了什么呢？

性能伴找！是的盈蛮，換來(lái)了性能！不信請(qǐng)看技矮，以下演示代碼由IPython（Python的另一個(gè)發(fā)行版本）完成抖誉。

24.3 list列表與元組tuple的對(duì)比

24.3.1 list VS tuple：創(chuàng)建（生成）速度

我們通過(guò)創(chuàng)建同樣大小的list和tuple殊轴，來(lái)觀察有什么變化：

In [1]: % timeit [1, 2, 3, 4, 5]
139 ns ± 2.34 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [2]: % timeit (1, 2, 3, 4, 5)
17.3 ns ± 0.161 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

上例的意思是說(shuō)我們創(chuàng)建一個(gè)長(zhǎng)度為5的列表，大概執(zhí)行了7次大循環(huán)袒炉，每次大循環(huán)中進(jìn)行10000000次小循環(huán)旁理。這個(gè)7次大循環(huán)，每次耗時(shí)（平均值）139 ns我磁，每次（標(biāo)準(zhǔn)）偏差2.34 ns孽文。而創(chuàng)建同樣長(zhǎng)度的元組，每次僅耗時(shí)17.3 ns夺艰，對(duì)比創(chuàng)建列表的耗時(shí)139 ns芋哭，可以看到創(chuàng)建元組的速度快很多。

24.3.2 list VS tuple：存儲(chǔ)開(kāi)銷(xiāo)

再來(lái)看他們的存儲(chǔ)開(kāi)銷(xiāo)：

from sys import getsizeof
l = [1, 2, 3, 4, 5]
t = (1, 2, 3, 4, 5)
print(getsizeof(l))  # 56
print(getsizeof(t))  # 48

可以看到劲适，元組在存儲(chǔ)空間上面也占優(yōu)勢(shì)楷掉。

24.3.3 list VS tuple：遍歷速度

元組的遍歷性能相比列表也是快很多了

image

24.3.4 list VS tuple：哈希比較

l = [1, 2, 3, 4, 5]
t = (1, 2, 3, 4, 5)
print(hash(t))  # -1883319094
print(hash(l))  # TypeError: unhashable type: 'list'

簡(jiǎn)單來(lái)說(shuō)，Hash霞势，一般翻譯做“散列”烹植，也有直接音譯為“哈希”的愕贡，就是把任意長(zhǎng)度的輸入（又叫做預(yù)映射草雕， pre-image），通過(guò)散列算法固以，變換成固定長(zhǎng)度的輸出墩虹，該輸出就是散列值。這種轉(zhuǎn)換是一種壓縮映射憨琳，也就是诫钓，散列值的空間通常遠(yuǎn)小于輸入的空間，不同的輸入可能會(huì)散列成相同的輸出篙螟，所以不可能從散列值來(lái)確定唯一的輸入值菌湃。簡(jiǎn)單的說(shuō)就是一種將任意長(zhǎng)度的消息壓縮到某一固定長(zhǎng)度的消息摘要的函數(shù)。

Python中可哈希（hashable）類(lèi)型：字符串遍略、元組惧所、對(duì)象⌒餍樱可哈希類(lèi)型就是我們常說(shuō)的不可變類(lèi)型下愈，優(yōu)點(diǎn)是性能經(jīng)過(guò)優(yōu)化，多線程安全蕾久，不需要鎖势似，不擔(dān)心被惡意篡改或者不小心修改了。

不可哈希類(lèi)型：字典、列表履因、集合辖佣。相對(duì)于可哈希類(lèi)型，使用起來(lái)相對(duì)靈活。

image

24.4 為數(shù)組添加元組

image

25. 字典dict

資料鏈接：https://www.cnblogs.com/Neeo/articles/11212385.html

我們知道，無(wú)論字符串师枣、列表血巍、元組都是將數(shù)據(jù)組織到一個(gè)有序的結(jié)構(gòu)中，然后通過(guò)下標(biāo)索引處理數(shù)據(jù)端逼，這幾種數(shù)據(jù)結(jié)構(gòu)雖然已經(jīng)滿(mǎn)足大多數(shù)場(chǎng)景了朗兵，但是依然不夠豐滿(mǎn)，現(xiàn)在了解一種通過(guò)名字（key）來(lái)處理數(shù)據(jù)的數(shù)據(jù)類(lèi)型顶滩，這種名字對(duì)應(yīng)數(shù)值的關(guān)系我們稱(chēng)之為映射關(guān)系余掖，而這種數(shù)據(jù)類(lèi)型就是前文或多或少的了解過(guò)的——字典（dict）。字典是目前為止礁鲁，Python唯一的內(nèi)建的映射類(lèi)型的數(shù)據(jù)類(lèi)型盐欺。需要說(shuō)明的是，從Python 3.6開(kāi)始仅醇，字典元素的存儲(chǔ)順序由各鍵值對(duì)根據(jù)存儲(chǔ)時(shí)的順序而定（但依然不支持索引取值）冗美，并優(yōu)化了空間上的開(kāi)銷(xiāo)，更節(jié)省內(nèi)存占用析二。

通過(guò)存儲(chǔ)同樣的數(shù)據(jù)粉洼，利用列表和字典的不同之處來(lái)學(xué)習(xí)字典。比如存儲(chǔ)商品的名稱(chēng)和編號(hào)叶摄，可以用列表來(lái)存属韧。

有三個(gè)商品，對(duì)應(yīng)三個(gè)價(jià)錢(qián)蛤吓，那想要知道banana的價(jià)錢(qián)怎么辦宵喂？

goods = ['apple', 'orange', 'banana']
price = ['20', '24', '32']
banana = price[goods.index('banana')]
print(banana)  # 32

如上例這樣取值很麻煩，而且柱衔，你可能要問(wèn)為什么價(jià)錢(qián)要存成字符串類(lèi)型樊破？

goods = ['apple', 'orange', 'banana']
price = [20, 24, 32]
banana = price[goods.index('banana')]
print(banana)  # 32

上例雖然可以存儲(chǔ)為int類(lèi)型。但要是存?zhèn)€電話號(hào)碼呢唆铐？比如存010998998這樣的數(shù)字怎么存哲戚？

number = [010, 998, 998]  # SyntaxError: invalid token

這個(gè)問(wèn)題告訴我們，碰到類(lèi)似的數(shù)據(jù)艾岂，或者是0開(kāi)頭的數(shù)據(jù)顺少，盡量存儲(chǔ)為字符串類(lèi)型，而不是整型。另外脆炎，雖然列表能存儲(chǔ)多種數(shù)據(jù)類(lèi)型梅猿，但是通過(guò)上面的商品和價(jià)錢(qián)的例子，在用列表的時(shí)候秒裕，應(yīng)該盡量存儲(chǔ)數(shù)據(jù)為單一的類(lèi)型袱蚓。
好，言歸正傳几蜻，再來(lái)看看更好的選擇喇潘。

goods = {'apple': '20', 'orange': '24', 'banana': '32'}
print(goods['banana'])  # 20

上例采用了字典來(lái)存儲(chǔ)數(shù)據(jù)，接下來(lái)就學(xué)習(xí)一下字典的用法梭稚。

25.1 字典基本操作

字典詳細(xì)講解：https://www.cnblogs.com/Neeo/articles/11212385.html

字典是無(wú)序（Python 3.6版本之前）的可變類(lèi)型數(shù)據(jù)類(lèi)型颖低。我們通過(guò)一對(duì){}來(lái)創(chuàng)建字典（dict），字典內(nèi)的值是通過(guò):來(lái)存儲(chǔ)的弧烤，也就是key:value的格式忱屑。

d1 = {}
d2 = dict()
print(d1, d2)  # {} {}
d3 = {'apple': 20}
print(d3)  # {'apple': 20}
print(d3['apple'])  # 20

25.1.1 使用內(nèi)建函數(shù)dict()來(lái)創(chuàng)建字典

d = dict(apple='20', orange='24')
print(d)  # {'apple': '20', 'orange': '24'}

25.1.2 字典的增刪改查

d = dict(apple=20, orange=24)
print(d['apple'])  # 字典取值
d['apple'] = 40  # 為字典的apple鍵重新賦值
print(d)
d['banana'] = 32  # 為字典新添加一對(duì)鍵值對(duì)
print(d)
del d['apple']
del d['orange'], d['banana']
del d

我們可以通過(guò)字典加中括號(hào)的形式，來(lái)對(duì)字典進(jìn)行增刪改查的操作暇昂。但需要注意的是莺戒，通過(guò)中括號(hào)取值的時(shí)候和del聲明刪除字典的key時(shí)，該key必須存在话浇，否則報(bào)錯(cuò)（KeyError）脏毯。

列表的成員資格測(cè)試是不穩(wěn)定的，而字典穩(wěn)定幔崖。這是因?yàn)榱斜淼某蓡T資格判斷取決于判斷元素處于列表的什么位置食店，如果是列表的靠前位置，速度肯定快赏寇，如果是末尾吉嫩，就要從頭到尾挨著判斷，速度就慢下來(lái)了嗅定。
而字典的存儲(chǔ)結(jié)構(gòu)是由key自娩、哈希表、value三部分組成的渠退，字典在創(chuàng)建一個(gè)鍵值對(duì)的時(shí)候忙迁，首先將key通過(guò)哈希得到結(jié)果，結(jié)果的位置上就是value碎乃，然后這個(gè)對(duì)應(yīng)關(guān)系被保存在哈希表上姊扔。查詢(xún)的時(shí)候，無(wú)論該key在何方梅誓，只要哈希后根據(jù)結(jié)果去哈希表上就能找到對(duì)應(yīng)的value恰梢。所以查詢(xún)速度快而且穩(wěn)定佛南，但由于要維護(hù)哈希表，在存儲(chǔ)和修改時(shí)可能會(huì)相對(duì)麻煩些嵌言。

image

不是什么元組都能成為字典的key
需要注意的是嗅回，如果字典的key是元組，那么這個(gè)元組就不能是普通的元組了摧茴。我們知道元組是可哈希的數(shù)據(jù)類(lèi)型绵载，這種說(shuō)法是基于元組內(nèi)的元素都是不可變類(lèi)型才成立的。

print(hash((1, 'a', 2.3, (4, 5))))  # -1680772126
t1 = (1, 'a', 2.3, (4, 5), [6, 7])
print(t1)  # (1, 'a', 2.3, (4, 5), [6, 7])
print(hash(t1))  # TypeError: unhashable type: 'list'

image

25.2 字典的常用操作

遍歷字典

d = {'a': 1, 'b': 2, 'c': 3}
for k in d:
    print(k)
'''
a
b
c
'''

由上例可以看到苛白，遍歷的時(shí)候尘分，字典默認(rèn)返回key，那么怎么分別取key和value呢丸氛？

d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys())  # dict_keys(['a', 'b', 'c'])
for k in d.keys():
    print(k)
'''
a
b
c
'''
print(d.values())  # dict_values([1, 2, 3])
for k in d.values():
    print(k)
'''
1
2
3
'''

上例中，d.keys()取出來(lái)的是字典所有的key著摔，而d.values()取出的是所有的value缓窜。
那怎么同時(shí)取key和value呢：

d = {'a': 1, 'b': 2, 'c': 3}
for k in d.items():
    print(k)
'''
('a', 1)
('b', 2)
('c', 3)
'''

for k, v in d.items():
    print(k, v)
'''
a 1
b 2
c 3
'''

第一個(gè)for循環(huán)，我們通過(guò)d.items()以元組的形式拿到key和value谍咆。第二個(gè)循環(huán)禾锤，相當(dāng)于平行賦值，每次從d.items()中取出一個(gè)元組摹察，然后平行賦值給k v兩個(gè)變量恩掷。

dict.get(key, None)

之前說(shuō)，我們通過(guò)字典加中括號(hào)取值的時(shí)候供嚎，當(dāng)key不存在的時(shí)候黄娘，會(huì)報(bào)錯(cuò)：

d = {'a': 1, 'b': 2, 'c': 3}
print(d['a'])  # 1
print(d['w'])  # KeyError: 'w'

報(bào)錯(cuò)~嗯2333333，很明顯是不行滴克滴，怎么辦呢逼争，我們可以通過(guò)dict.get()方法來(lái)避免這個(gè)問(wèn)題：

d = {'a': 1, 'b': 2, 'c': 3}
print(d['a'])  # 1
print(d.get('a'))  # 1
print(d.get('w'))  # None
print(d.get('w', 'hi man， 你想要的鍵不存在呀'))  # hi man劝赔， 你想要的鍵不存在呀

dict.get()可以獲取指定的key誓焦，當(dāng)key不存在的時(shí)候，默認(rèn)會(huì)返回一個(gè)None着帽，意思是沒(méi)取到key杂伟，而且我們可以修改這個(gè)返回值，更加靈活仍翰。

dict.setdefault(key, None)

d = {'a': 1, 'b': 2, 'c': 3}
print(d.setdefault('a'))  # 1
print(d.setdefault('x', 'y'))  # y
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'x': 'y'}

dict.setdefault()方法跟dict.get()方法類(lèi)似赫粥，獲取字典指定的key，存在則返回對(duì)應(yīng)的value歉备，如果key不存在的話傅是，它會(huì)將我們指定的key添加到字典中，默認(rèn)的value是None，該value也可以自己指定喧笔。

dict.update(obj)

字典可以拼接（+）嗎帽驯？

d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d3 = d1 + d2  # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

顯然是不行的！
但我們可以通過(guò)dict.upate()方法來(lái)完成類(lèi)似的操作：

d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d2.update(d1)
print(d2)  # {'c': 3, 'd': 4, 'a': 1, 'b': 2}

此方法將一個(gè)字典（d1）的鍵值對(duì)一次性的更新到當(dāng)前字典（d2）书闸，如果兩個(gè)字典中存在同樣的鍵尼变，更新的時(shí)候，對(duì)應(yīng)的值以另一個(gè)字典（d1）的值為準(zhǔn)浆劲。
注意嫌术，字典的鍵是唯一的，但是值可以是相同的牌借。

dict.pop() & dict.popitem()

我們?cè)谏厦嬉擦私膺^(guò)了del來(lái)刪除字典以及刪除字典的鍵度气，這里我們?cè)俳榻B兩個(gè)方法刪除字典的鍵。

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(d.pop('a'), d)  # 1 {'b': 2, 'c': 3, 'd': 4}
# print(d.pop('w'))  # KeyError: 'w'
print(d.popitem())  # ('d', 4)

d.pop()方法刪除字典指定的key膨报，返回對(duì)應(yīng)的value磷籍，如果key不存在，則拋出KeyError錯(cuò)誤现柠。
而d.popitem()在Python2.7（Python 2.x的最后一個(gè)版本）和Python3.6（及以上版本）刪除的是最后一個(gè)key院领。而其他版本（如Python2.4和Python3.5版本）則是隨機(jī)刪除一對(duì)鍵值對(duì)。另外够吩，如果字典為空比然，上述兩個(gè)方法都將拋出KeyError的錯(cuò)誤。

dict.clear()

要清空一個(gè)字典周循，使用dict.clear()方法强法，這沒(méi)啥好解釋的：

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
d.clear()
print(d)  # {}

dict.fromkeys()

d = dict.fromkeys(['a', 'b'], None)
print(d)  # {'a': None, 'b': None}
d1 = dict.fromkeys(['a', 'b'], '自定義value')
print(d1)  # {'a': '自定義value', 'b': '自定義value'}

dict.fromkeys(seq, None)用來(lái)生成字典 ，第一個(gè)參數(shù)seq為序列類(lèi)型（如上例中的字符串湾笛，列表）作為字典的key拟烫，第二個(gè)參數(shù)為每一個(gè)key對(duì)應(yīng)的value，如若不設(shè)置則默認(rèn)為None迄本。

dict.contains(key)

dict.__contains__(key)用來(lái)判斷某一個(gè)key是否在字典中硕淑。

d = dict.fromkeys(['a', 'b'], None)
print(d.__contains__('a'))  # True

需要注意的是，dict.__contains__(key)適用于Python2和3中嘉赎，而Python2中置媳，多了一個(gè)d.has_key(key)的方法列敲，同樣用來(lái)判斷key是否在字典中岔擂。但這方法在Python3中取消了坷牛。

d = dict.fromkeys(['a', 'b'], None)
print(d.__contains__('a'))  # True
print(d.has_key('b'))  # True

小結(jié) 字典中的常用方法或函數(shù)或者聲明語(yǔ)句：

26. 漫談爬蟲(chóng)

小實(shí)例：爬取新淠眨花網(wǎng)

image.png

'''
pip install requests    
pip install BeautifulSoup4  # 下載BeautifulSoup4
'''
import requests
from  bs4 import BeautifulSoup
response = requests.get(url='http://www.xiaohuar.com/hua/')
soup_obj = BeautifulSoup(response.text, 'html.parser')
div_obj = soup_obj.find(name='div', attrs={'class': 'demo clearfix'})
img_list = div_obj.find_all(name='img')
for item in img_list:
    item_url = 'http://www.xiaohuar.com' + item.get('src')
    img_path = item.get('alt') + '.' + item_url.rsplit('.')[-1]

    img_response = requests.get(item_url)
    f = open('./腥龆伲花網(wǎng)圖片/{}'.format(img_path), 'wb')
    f.write(img_response.content)
    f.close()
    print('{} 下載完畢...'.format(img_path))

image.png

小坑：下載BeautifulSoup4不成功

image

image

27.練習(xí)

昨日練習(xí)最后的四道題

27.1 寫(xiě)代碼，有如下列表传黄，按照要求實(shí)現(xiàn)每一個(gè)功能

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
計(jì)算列表的長(zhǎng)度并輸出
列表中追加元素"seven",并輸出添加后的列表
請(qǐng)?jiān)诹斜淼牡?個(gè)位置插入元素"Tony",并輸出添加后的列表
請(qǐng)修改列表第2個(gè)位置的元素為"Kelly",并輸出修改后的列表
請(qǐng)將列表l2=[1,"a",3,4,"heart"]的每一個(gè)元素添加到列表li中杰扫，一行代碼實(shí)現(xiàn)，不允許循環(huán)添加膘掰。
請(qǐng)將字符串s = "qwert"的每一個(gè)元素添加到列表li中章姓，一行代碼實(shí)現(xiàn)，不允許循環(huán)添加识埋。
請(qǐng)刪除列表中的元素"ritian",并輸出添加后的列表
請(qǐng)刪除列表中的第2個(gè)元素凡伊，并輸出刪除的元素和刪除元素后的列表
請(qǐng)刪除列表中的第2至4個(gè)元素，并輸出刪除元素后的列表
請(qǐng)將列表所有得元素反轉(zhuǎn)窒舟，并輸出反轉(zhuǎn)后的列表
請(qǐng)計(jì)算出"alex"元素在列表li中出現(xiàn)的次數(shù)系忙，并輸出該次數(shù)。

27.2 寫(xiě)代碼惠豺，有如下列表笨觅，利用切片實(shí)現(xiàn)每一個(gè)功能

li = [1, 3, 2, "a", 4, "b", 5,"c"]
通過(guò)對(duì)li列表的切片形成新的列表l1,l1 = [1,3,2]
通過(guò)對(duì)li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通過(guò)對(duì)li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
通過(guò)對(duì)li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通過(guò)對(duì)li列表的切片形成新的列表l5,l5 = ["c"]
通過(guò)對(duì)li列表的切片形成新的列表l6,l6 = ["b","a",3]

27.3 寫(xiě)代碼，有如下列表耕腾，按照要求實(shí)現(xiàn)每一個(gè)功能。

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
將列表lis中的"tt"變成大寫(xiě)杀糯。
將列表中的數(shù)字3變成字符串"100"扫俺。
將列表中的字符串"1"變成數(shù)字101。

27.4 請(qǐng)用代碼實(shí)現(xiàn)：利用下劃線將列表的每一個(gè)元素拼接成字符串

li = ["alex", "wusir", "taibai"]
利用下劃線將列表的每一個(gè)元素拼接成字符串"alex_wusir_taibai"