1.1. Python的誕生

Python的作者是著名的“龜叔”Guido van Rossum,，1989年，龜叔為了打發(fā)無聊的圣誕節(jié),，開始編寫Python語言,。1991年，第一個Python編譯器誕生,。它是用C語言實現(xiàn)的,，并能夠調(diào)用C語言的庫文件。

榮登2018年TIOBE年度最佳編程語言,，很多大公司,，包括google、Yahoo都大量的使用Python,。

1.1.1. 提升自己的逼格,，你需要了解

Python的發(fā)音與拼寫
Python的意思是蟒蛇，是取自英國20世紀70年代首播的電視喜劇《蒙提.派森干的飛行馬戲團》（Monty Python’s Flying Circus）
Python的作者是Guido van Rossum（龜叔）

Python是龜叔在1989年圣誕節(jié)期間,，為了打發(fā)無聊的圣誕節(jié)而用C編寫的一個編程語言

Python第一個公開發(fā)行版發(fā)行于1991年
Python目前有兩個主要版本,，Python2和Python3，最新版分別為2.7.12和3.7.2
Life is short, you need Python. 人生苦短,，我用Python,。

1）官 網(wǎng)：https://www./ 2）中文社區(qū)：http://www./

面向?qū)ο蟮慕忉屝驼Z言
簡單易學
豐富的庫
強制使用制表符作為語句縮進(white space)

1.1.2. Python各個版本發(fā)布時間

1989年由荷蘭人Guido van Rossum于1989年發(fā)明，第一個公開發(fā)行版發(fā)行于1991年

Python 1.0 - January 1994 增加了 lambda, map, filter and reduce.
Python 2.0 - October 16, 2000,，加入了內(nèi)存回收機制,，構(gòu)成了現(xiàn)在Python語言框架的基礎(chǔ)
Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 誕生
Python 2.5 - September 19, 2006
Python 2.6 - October 1, 2008
Python 2.7 - July 3, 2010
Python 3.0 - December 3, 2008
Python 3.1 - June 27, 2009
Python 3.2 - February 20, 2011
Python 3.3 - September 29, 2012
Python 3.4 - March 16, 2014
Python 3.5 - September 13, 2015

1.1.3. Python主要應(yīng)用領(lǐng)域

人工智能: 典型庫NumPy, SciPy, Matplotlib, TensorFlow
云計算: 云計算最火的語言， 典型應(yīng)用OpenStack
WEB開發(fā): 眾多優(yōu)秀的WEB框架,，眾多大型網(wǎng)站均為Python開發(fā),，Youtube, Dropbox, 豆瓣,。。,。,， 典型WEB框架有Django，F(xiàn)lask
系統(tǒng)運維: 運維人員必備語言
金融：量化交易,，金融分析,，在金融工程領(lǐng)域，Python不但在用,，且用的最多,，而且重要性逐年提高。
圖形GUI: PyQT, WxPython,TkInter

1.1.4. Python在一些公司的應(yīng)用

谷歌：Google App Engine ,、code.google.com ,、Google earth 、谷歌爬蟲,、Google廣告等項目都在大量使用Python開發(fā)
CIA: 美國中情局網(wǎng)站就是用Python開發(fā)的
NASA: 美國航天局(NASA)大量使用Python進行數(shù)據(jù)分析和運算
YouTube:世界上最大的視頻網(wǎng)站YouTube就是用Python開發(fā)的
Dropbox:美國最大的在線云存儲網(wǎng)站,，全部用Python實現(xiàn)，每天網(wǎng)站處理10億個文件的上傳和下載
Instagram:美國最大的圖片分享社交網(wǎng)站,，每天超過3千萬張照片被分享,，全部用python開發(fā)
Facebook:大量的基礎(chǔ)庫均通過Python實現(xiàn)的
Redhat: 世界上最流行的Linux發(fā)行版本中的yum包管理工具就是用python開發(fā)的
豆瓣: 公司幾乎所有的業(yè)務(wù)均是通過Python開發(fā)的
知乎: 國內(nèi)最大的問答社區(qū)，通過Python開發(fā)(國外Quora)
除上面之外,，還有搜狐,、金山、騰訊,、盛大,、網(wǎng)易、百度,、阿里,、淘寶 、土豆,、新浪,、果殼等公司都在使用Python完成各種各樣的任務(wù)。

1.2. Python 的安裝

因為 Python 是跨平臺的,，它可以運行在 Windows,、Mac 和各種 Linux/Unix 系統(tǒng)上。目前,，Python 有兩個版本,，一個是 2.x 版，一個是 3.x版，這兩個版本是不兼容的,。安裝的是 3.6.1 版本的。

官網(wǎng)地址：https://www./

是 windows 系統(tǒng),，下載完后,，直接安裝，不過這里記得勾上Add Python 3.6 to PATH,，然后點 “Install Now” 即可完成安裝,。

Python安裝.png

安裝完成后，打開命令提示符窗口,，敲入 python 后,，出現(xiàn)下面的情況，證明 Python 安裝成功了,。你看到提示符 >>> 就表示我們已經(jīng)在 Python交互式環(huán)境中了,，可以輸入任何 Python 代碼，回車后會立刻得到執(zhí)行結(jié)果,。

運行python.png

1.3. Python中文文檔

https://docs./zh-cn/3/

1.4. 集成開發(fā)環(huán)境 IDE

我們使用Pycharm 下載地址：http://www./pycharm

1.4.1. 在Pycharm上運行第一個Python應(yīng)用程序

1.4.2. 1新建項目

打開PyCharm,，單擊“file”，然后選中“New Project…'

選擇項目要保存的位置,，選擇python.exe,點擊create

3,、彈出的窗口里點擊ok，項目就創(chuàng)建好了

1.4.3. 2,、新建python文件

1,、右擊項目，點擊New ,，再點擊Python File

2,、輸入要創(chuàng)建的python文件的名稱，點擊ok

1.4.4. 3,、寫代碼,，運行

1、輸入代碼 print(“Hello world!”)

image

2,、右擊空白處,，選擇Run 'PrintHello’

1.4.5. 4、運行結(jié)果

運行成功,，控制臺打印出了“Hello world!”

2.1. 變量定義

在 Python 中,，每個變量 在使用前都必須賦值，變量 賦值以后 該變量 才會被創(chuàng)建
等號（=）用來給變量賦值
= 左邊是一個變量名
= 右邊是存儲在變量中的值

變量名 = 值

2.1.1. 實例1—— 學生注冊

# 定義變量---學生學號
studentNo = '9527'

# 定義變量---學生密碼
stuentPassword = '123'

# 在程序中,，如果要輸出變量的內(nèi)容,，需要使用 print 函數(shù)
print(studentNo)
print(stuentPassword)
說明#是代碼注釋，快捷鍵是Ctrl+/

Python的代碼縮進

Python語言通過縮進來組織代碼塊,，這是Python的強制要求,。 下面的代碼有誤：

# 定義變量---學生學號
    studentNo = '9527'

# 定義變量---學生密碼
stuentPassword = '123'

# 在程序中,，如果要輸出變量的內(nèi)容，需要使用 print 函數(shù)
print(studentNo)
print(stuentPassword)

這樣也不行

# 定義變量---學生學號
studentNo = '9527'

# 定義變量---學生密碼
stuentPassword = '123'

# 在程序中,，如果要輸出變量的內(nèi)容,，需要使用 print 函數(shù)
    print(studentNo)
print(stuentPassword)

和其他編程語言不同，Python代碼對格式要求非常嚴格,。代碼寫的里出外進,，無法通過編譯。后面我們在分支,，循環(huán),，函數(shù)，類等知識點時還會多次看到這種情況,。

2.1.2. 實例2—— 超市買菜

需求
柿子的價格是 8.5 元/斤
買了 7.5 斤 柿子
計算付款金額

# 定義柿子價格變量
price = 8.5

# 定義購買重量
weight = 7.5

# 計算金額
money = price * weight

print(money)

2.2. 變量的類型

變量的四要素：
變量的名稱
變量保存的數(shù)據(jù)
變量存儲數(shù)據(jù)的類型
變量的內(nèi)存地址（標識）

2.2.1. 變量類型的演練 —— 表達個人信息

需求
定義變量保存小強的個人信息
姓名：小強
年齡：22 歲
性別：是男生
身高：1.80 米
體重：77.0 公斤
利用 單步調(diào)試 確認變量中保存數(shù)據(jù)的類型

提問
在演練中,，一共有幾種數(shù)據(jù)類型？
4 種
str —— 字符串
bool —— 布爾（真假）
int —— 整數(shù)
float —— 浮點數(shù)（小數(shù)）
在 Python 中定義變量時需要指定類型嗎,？
不需要
Python 可以根據(jù) = 等號右側(cè)的值,，自動推導(dǎo)出變量中存儲數(shù)據(jù)的類型

2.2.2. 變量的類型

在 Python 中定義變量是 不需要指定類型（在其他很多高級語言中都需要）
數(shù)據(jù)類型可以分為 數(shù)字型 和 非數(shù)字型
數(shù)字型
整型 (int)
浮點型（float）
布爾型（bool）
真 True 非 0 數(shù) —— 非零即真
假 False 0
非數(shù)字型
字符串
列表
元組
字典
使用 type 函數(shù)可以查看一個變量的類型

type(name)

2.2.3. 不同類型變量之間的計算

1) 數(shù)字型變量 之間可以直接計算
在 Python 中，兩個數(shù)字型變量是可以直接進行 算數(shù)運算的
如果變量是 bool 型,，在計算時
True 對應(yīng)的數(shù)字是 1
False 對應(yīng)的數(shù)字是 0
演練步驟
定義整數(shù) i = 10
定義浮點數(shù) f = 10.5
定義布爾型 b = True
在PyCharm中,，使用上述三個變量相互進行算術(shù)運算

i = 10
f = 10.5
b = True

print(i+f+b)

21.5

發(fā)生了自動類型轉(zhuǎn)換，全部轉(zhuǎn)換成了浮點數(shù),。
2) 字符串變量 之間使用 + 拼接字符串
在 Python 中,，字符串之間可以使用 + 拼接生成新的字符串

first_name = '三'
last_name = '張'
print(first_name + last_name)

3) 字符串變量 可以和 整數(shù) 使用 * 重復(fù)拼接相同的字符串

print('-' * 50)

輸出

 '--------------------------------------------------'

4) 數(shù)字型變量 和 字符串 之間 不能進行其他計算

first_name = 'zhang'
x = 10

print( x + first_name)
---------------------------------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
類型錯誤：`+` 不支持的操作類型：`int` 和 `str`

解決辦法：使用str(x)將x的類型強制轉(zhuǎn)換成字符串類型

first_name = 'zhang'
x = 10
print(str(x)+first_name)

2.2.4. 變量的輸入

所謂 輸入，就是 用代碼 獲取 用戶通過 鍵盤 輸入的信息
例如：去銀行取錢,，在 ATM 上輸入密碼
在 Python 中,，如果要獲取用戶在 鍵盤 上的輸入信息，需要使用到 input 函數(shù)
1) 關(guān)于函數(shù)
一個 提前準備好的功能(別人或者自己寫的代碼),，可以直接使用,，而 不用關(guān)心內(nèi)部的細節(jié)
目前已經(jīng)學習過的函數(shù)

2) input 函數(shù)實現(xiàn)鍵盤輸入
在 Python 中可以使用 input 函數(shù)從鍵盤等待用戶的輸入
用戶輸入的 任何內(nèi)容 Python 都認為是一個 字符串
語法如下：

字符串變量 = input('提示信息：')

3) 其他類型轉(zhuǎn)換函數(shù)

4) 變量輸入演練 —— 超市買蘋果
需求
收銀員輸入 蘋果的價格，單位：元／斤
收銀員輸入 用戶購買蘋果的重量,，單位：斤
計算并且 輸出 付款金額
代碼

# 1. 輸入蘋果單價
price_str = input('請輸入蘋果價格：')

# 2. 要求蘋果重量
weight_str = input('請輸入蘋果重量：')

# 3. 計算金額
# 1> 將蘋果單價轉(zhuǎn)換成小數(shù)
price = float(price_str)

# 2> 將蘋果重量轉(zhuǎn)換成小數(shù)
weight = float(weight_str)

# 3> 計算付款金額
money = price * weight

print(money)

2.2.5. 變量的格式化輸出

使用%

蘋果單價 9.00 元／斤,，購買了 5.00 斤，需要支付 45.00 元

在 Python 中可以使用 print 函數(shù)將信息輸出到控制臺
如果希望輸出文字信息的同時,，一起輸出 數(shù)據(jù),，就需要使用到 格式化操作符
% 被稱為 格式化操作符，專門用于處理字符串中的格式
包含 % 的字符串,，被稱為 格式化字符串
% 和不同的 字符 連用,，不同類型的數(shù)據(jù) 需要使用 不同的格式化字符

語法格式如下：

print('格式化字符串' % 變量1)

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

舉個栗子
需求

定義字符串變量 name，輸出 我的名字叫 小明，請多多關(guān)照,！
定義整數(shù)變量 student_no,，輸出 我的學號是 000001
定義小數(shù) price、weight,、money,，輸出 蘋果單價 9.00 元／斤，購買了 5.00 斤,，需要支付 45.00 元
定義一個小數(shù) scale，輸出 數(shù)據(jù)比例是 10.00%

print('我的名字叫 %s,，請多多關(guān)照,！' % name)
print('我的學號是 %06d' % student_no)
print('蘋果單價 %.02f 元／斤，購買 %.02f 斤,，需要支付 %.02f 元' % (price, weight, money))
print('數(shù)據(jù)比例是 %.02f%%' % (scale * 100))

使用format
用法：
它通過{}和:來代替?zhèn)鹘y(tǒng)%方式
字符串format()方法的基本使用格式是：
<模板字符串>.format(<逗號分隔的參數(shù)>)
其中,，模板字符串是一個由字符串和槽組成的字符串，用來控制字符串和變量的顯示效果,。槽用大括號({})表示,，對應(yīng)format()方法中逗號分隔的參數(shù)。

str = '{}曰：學而時習之,，不亦說乎,。'.format('孔子')
print(str)

'孔子曰：學而時習之，不亦說乎,。'

如果模板字符串有多個槽,，且槽內(nèi)沒有指定序號，則按照槽出現(xiàn)的順序分別對應(yīng).format()方法中的不同參數(shù),。

'{}曰：學而時習之,，不亦{}。'.format('孔子','說乎')

'孔子曰：學而時習之,，不亦說乎,。'

可以通過format()參數(shù)的序號在模板字符串槽中指定參數(shù)的使用，參數(shù)從0開始編號

'{1}曰：學而時習之,，不亦{0},。'.format('說乎','孔子')

'孔子曰：學而時習之，不亦說乎,。'

f-字符串
f-string是 Python 3.6 中定義的一種參數(shù)化字符串的方式,，主要是讓格式化字符串更加便捷。 在 f-string 中,，不要再使用 %-格式化 或者 format 函數(shù)中的復(fù)雜寫法,，可以直接在字符串中寫入變量名。f-string 用 {} 標識變量，區(qū)別在于 {} 不再是用來占位的,，而是直接寫入變量名,。 修改上面的格式化例子：

name = input('請輸入姓名：')
fondness = input('請輸入愛好：')
print(f'{name} 的愛好是 {fondness}！')    # 字符串前面的 f 大小寫均可

課上實踐 —— 個人名片

需求
在控制臺依次提示用戶輸入：姓名,、公司,、職位、電話,、郵箱
按照以下格式輸出：

**************************************************
公司名稱

姓名 (職位)

電話：電話
郵箱：郵箱
**************************************************

'''
在控制臺依次提示用戶輸入：姓名,、公司、職位,、電話,、電子郵箱
'''
name = input('請輸入姓名：')
company = input('請輸入公司：')
title = input('請輸入職位：')
phone = input('請輸入電話：')
email = input('請輸入郵箱：')

print('*' * 50)
print(company)
print()
print('%s (%s)' % (name, title))
print()
print('電話：%s' % phone)
print('郵箱：%s' % email)
print('*' * 50)

課后作業(yè) 使用f-string方法實現(xiàn)上述需求。

2.3. 變量的命名

2.3.1. 標識符和關(guān)鍵字

1.1 標識符

標識符就是程序員自己命名的 變量名,。 名字 需要有 見名知義 的效果,，不要隨意起名。
不好的變量命名

c1 = '小朱學長'
n = 1500

好的變量命名

company = '小朱學長'
employeeNum = 1500

標示符可以由 字母,、下劃線 和 數(shù)字 組成
不能以數(shù)字開頭
不能與關(guān)鍵字重名

1.2 關(guān)鍵字

關(guān)鍵字 就是在 Python 內(nèi)部已經(jīng)使用的標識符
關(guān)鍵字 具有特殊的功能和含義
開發(fā)者 不允許定義和關(guān)鍵字相同的名字的標示符
通過以下命令可以查看 Python 中的關(guān)鍵字

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', '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']

關(guān)鍵字的學習及使用,，會在后面的課程中介紹

import 關(guān)鍵字 可以導(dǎo)入一個 “工具包”

在 Python 中不同的工具包，提供有不同的工具

2.3.2. 變量的命名規(guī)則

命名規(guī)則 可以被視為一種 慣例,，并無絕對與強制 目的是為了 增加代碼的識別和可讀性

注意 Python 中的 標識符 是 區(qū)分大小寫的

userName = 'zhangsan'
print(username)

Traceback (most recent call last):
  File 'C:/Users/Administrator/PycharmProjects/hellopython/test.py', line 2, in <module>
    print(username)
NameError: name 'username' is not defined

在定義變量時,，為了保證代碼格式，= 的左右應(yīng)該各保留一個空格
在 Python 中,，如果 變量名 需要由 二個 或 多個單詞 組成時,，可以按照以下方式命名
每個單詞都使用小寫字母
單詞與單詞之間使用 _下劃線 連接
例如：first_name、last_name,、qq_number,、qq_password

2.4駝峰命名法

當 變量名 是由二個或多個單詞組成時，還可以利用駝峰命名法來命名
小駝峰式命名法
第一個單詞以小寫字母開始,，后續(xù)單詞的首字母大寫
例如：firstName,、lastName
大駝峰式命名法
每一個單詞的首字母都采用大寫字母
例如：FirstName、LastName,、CamelCase

3.1運算符

3.1.1. 算數(shù)運算符

是完成基本的算術(shù)運算使用的符號,，用來處理四則運算

>>> a=10
>>> b=5
>>> print(a+b)
15
>>> print(a-b)
5
>>> print(a*b)
50
>>> print(a/b)
2.0
>>> print(a**b)
100000
>>> print(a//b)
2
>>> print(a%b)
0

3.1.2. 比較（關(guān)系）運算符

>>> a=10
>>> b=20
>>> a==b
False
>>> a!=b
True
>>> a>b
False
>>> a<b
True
>>> a>=b
False
>>> a<=b
True

3.1.3. 邏輯運算符

>>> a=True
>>> b=False
>>> a and b
False
>>> a or b
True
>>> not a
False
>>> not -1
False
>>> not 0
True

3.1.4. 賦值運算符

在 Python 中，使用 = 可以給變量賦值
在算術(shù)運算時,，為了簡化代碼的編寫,，Python 還提供了一系列的 與 算術(shù)運算符 對應(yīng)的 賦值運算符
注意：賦值運算符中間不能使用空格

>>> a=10
>>> b=20
>>> c=0
>>> c=a+b
>>> print(c)
30
>>> c+=10
>>> print(c)
40
>>> c-=a
>>> print(c)
30
>>> c*=a
>>> print(c)
300
>>> c/=a
>>> print(c)
30.0
>>> c%=a
>>> print(c)
0.0
>>> c=a**5
>>> print(c)
100000
>>> c//=b
>>> print(c)
5000
>>> print(b)
20

3.1.5. 運算符的優(yōu)先級

以下表格的算數(shù)優(yōu)先級由高到最低順序排列

4.1. 條件語句

Python 條件語句跟其他語言基本一致的，都是通過一條或多條語句的執(zhí)行結(jié)果（ True 或者 False ）來決定執(zhí)行的代碼塊,。

Python 程序語言指定任何非 0 和非空（None）值為 True,，0 或者 None為 False,。

4.1.1. if 語句的基本形式

Python 中，if 語句的基本形式如下：

if 判斷條件：
    執(zhí)行語句……
else：
    執(zhí)行語句……

前面也提到過,，Python 語言有著嚴格的縮進要求,，因此這里也需要注意縮進，也不要少寫了冒號 : ,。

if 語句的判斷條件可以用>（大于）,、<(小于)、==（等于）,、>=（大于等于）,、<=（小于等于）來表示其關(guān)系。

例如：

# -*-coding:utf-8-*-

results=59

if results>=60:
    print ('及格')
else :
    print ('不及格')

輸出的結(jié)果為：

不及格

上面也說道,，非零數(shù)值,、非空字符串、非空 list 等,，判斷為True，否則為False,。因此也可以這樣寫：

num = 6
if num :
    print('Hello Python')

4.1.2. if 語句多個判斷條件的形式

有些時候,，我們的判斷語句不可能只有兩個，有些時候需要多個,，比如上面的例子中大于 60 的為及格,，那我們還要判斷大于 90 的為優(yōu)秀，在 80 到 90 之間的良好呢,？

這時候需要用到 if 語句多個判斷條件,，

用偽代碼來表示：

if 判斷條件1:
    執(zhí)行語句1……
elif 判斷條件2:
    執(zhí)行語句2……
elif 判斷條件3:
    執(zhí)行語句3……
else:
    執(zhí)行語句4……

實例：

# -*-coding:utf-8-*-

results = 89

if results > 90:
    print('優(yōu)秀')
elif results > 80:
    print('良好')
elif results > 60:
    print ('及格')
else :
    print ('不及格')

輸出的結(jié)果：

良好

4.1.3. if 語句多個條件同時判斷

Python 不像 Java 有 switch 語句，所以多個條件判斷,，只能用 elif 來實現(xiàn),，但是有時候需要多個條件需同時判斷時，可以使用 or （或）,，表示兩個條件有一個成立時判斷條件成功,；使用 and （與）時，表示只有兩個條件同時成立的情況下,，判斷條件才成功,。

# -*-coding:utf-8-*-

java = 86
python = 68

if java > 80 and  python > 80:
    print('優(yōu)秀')
else :
    print('不優(yōu)秀')

輸出結(jié)果：

不優(yōu)秀

注意：if 有多個條件時可使用括號來區(qū)分判斷的先后順序，括號中的判斷優(yōu)先執(zhí)行,，此外 and 和 or 的優(yōu)先級低于 >（大于）,、<（小于）等判斷符號，即大于和小于在沒有括號的情況下會比與或要優(yōu)先判斷,。

java = 86
python = 68

if (80 <= java < 90) or (80 <= python < 90):
    print('良好')

輸出結(jié)果：

良好

課上練習1

我想買車,，買什么車決定于我在銀行有多少存款
如果我的存款超過500萬,，我就買路虎
否則，如果我的存款超過100萬,，我就買寶馬
否則,， 如果我的存款超過50萬，我就買邁騰
否則,， 如果我的存款超過10萬,，我就買福特
否則， 如果我的存款10萬以下 ,，我買比亞迪

課上練習2

輸入小明的考試成績,，顯示所獲獎勵
成績==100分，爸爸給他買輛車
成績>=90分,，媽媽給他買MP4
90分>成績>=60分,，媽媽給他買本參考書
成績<60分，什么都不買

4.2. 循環(huán)語句

一般編程語言都有循環(huán)語句,，循環(huán)語句允許我們執(zhí)行一個語句或語句組多次,。

循環(huán)語句的一般形式如下：

Python 提供了 for 循環(huán)和 while 循環(huán)，當然還有一些控制循環(huán)的語句：

4.2.1. While 循環(huán)語句

count = 1
sum = 0
while count <= 100:
    sum = sum + count
    count = count + 1
print(sum)

輸出的結(jié)果：

5050

當然 while 語句時還有另外兩個重要的命令 continue,，break 來跳過循環(huán),，continue 用于跳過該次循環(huán)，break 則是用于跳出本層循環(huán)

比如,，上面的例子是計算 1 到 100 所有整數(shù)的和,，當我們需要判斷 sum 大于 1000 的時候，不在相加時,，可以用到 break ,，退出整個循環(huán)

count = 1
sum = 0
while  count <= 100:
    sum = sum + count
    if  sum > 1000:  #當 sum 大于 1000 的時候退出循環(huán)
        break
    count = count + 1
print(sum)

輸出的結(jié)果：

1035

有時候，我們只想統(tǒng)計 1 到 100 之間的奇數(shù)和,，那么也就是說當 count 是偶數(shù),，也就是雙數(shù)的時候，我們需要跳出當次的循環(huán),，不想加,，這時候可以用到 continue

count = 1
sum = 0
while  count <= 100:
    if count % 2 == 0:  # 雙數(shù)時跳過輸出
        count = count + 1
        continue
    sum = sum + count
    count = count + 1
print(sum)

輸出的語句：

2500

在 Python 的 while 循環(huán)中，還可以使用 else 語句,，while … else 在循環(huán)條件為 false 時執(zhí)行 else 語句塊

比如：

count = 0
while count < 5:
   print (count)
   count = count + 1
else:
   print (count)

輸出的結(jié)果：

0
1
2
3
4
5

4.2.2. for 循環(huán)語句

for循環(huán)可以遍歷任何序列的項目,，如一個字符串
它的流程圖基本如下：

基本的語法格式：

for iterating_var in sequence:
   statements(s)

實例：

for letter in 'www.neuedu.com':
    print(letter)

輸出的結(jié)果如下：

w
w
w
.
n
e
u
e
d
u
.
c
o
m

range()函數(shù)

Python函數(shù)range()讓你能夠輕松地生成一系列的數(shù)字。例如,，可以像下面這樣使用函數(shù)range()來打印一系列的數(shù)字：

for value in range(1,5):
    print(value)

上述代碼好像應(yīng)該打印數(shù)字1~5,，但實際上它不會打印數(shù)字5：

1
2
3
4

在這個示例中，range()只是打印數(shù)字1~4,，這是你在編程語言中經(jīng)?？吹降牟钜恍袨榈慕Y(jié)果,。函數(shù)range()讓Python從你指定的第一個值開始數(shù)，并在到達你指定的第二個值后停止,，因此輸出不包含第二個值（這里為5）,。

要打印數(shù)字1~5，需要使用range(1,6)：

for value in range(1,6):
    print(value)

這樣,，輸出將從1開始,，到5結(jié)束：

    1
    2
    3
    4
    5

4.2.3. 嵌套循環(huán)

Python 語言允許在一個循環(huán)體里面嵌入另一個循環(huán)。上面的實例也是使用了嵌套循環(huán)的,。
具體的語法如下：
for 循環(huán)嵌套語法

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

while 循環(huán)嵌套語法

while expression:
   while expression:
      statement(s)
   statement(s)

除此之外,，你也可以在循環(huán)體內(nèi)嵌入其他的循環(huán)體，如在 while 循環(huán)中可以嵌入 for 循環(huán),， 反之,，你可以在 for 循環(huán)中嵌入 while 循環(huán)

有 while … else 語句，當然也有 for … else 語句啦,，for 中的語句和普通的沒有區(qū)別,，else 中的語句會在循環(huán)正常執(zhí)行完（即 for 不是通過 break 跳出而中斷的）的情況下執(zhí)行，while … else 也是一樣,。

for num in range(10,20):  # 迭代 10 到 20 之間的數(shù)字
   for i in range(2,num): # 根據(jù)因子迭代
      if num%i == 0:      # 確定第一個因子
         j=num/i          # 計算第二個因子
         print ('%d 是一個合數(shù)' % num)
         break            # 跳出當前循環(huán)
   else:                  # 循環(huán)的 else 部分
      print ('%d 是一個質(zhì)數(shù)' % num)

輸出的結(jié)果：

10 是一個合數(shù)
11 是一個質(zhì)數(shù)
12 是一個合數(shù)
13 是一個質(zhì)數(shù)
14 是一個合數(shù)
15 是一個合數(shù)
16 是一個合數(shù)
17 是一個質(zhì)數(shù)
18 是一個合數(shù)
19 是一個質(zhì)數(shù)

課上案例 打印九九乘法表

# 打印九九乘法表
for i in range(1, 10):
        for j in range(1, i+1):
            print('{}x{}={}\t'.format(i, j, i*j), end='')
        print()

1x1=1   
2x1=2   2x2=4   
3x1=3   3x2=6   3x3=9   
4x1=4   4x2=8   4x3=12  4x4=16  
5x1=5   5x2=10  5x3=15  5x4=20  5x5=25  
6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36  
7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49  
8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64  
9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81

4.3. 隨機數(shù)的處理

在 Python 中,，要使用隨機數(shù)，首先需要導(dǎo)入 隨機數(shù) 的 模塊 —— “工具包”

import random

導(dǎo)入模塊后,，可以直接在 模塊名稱 后面敲一個 . ，會提示該模塊中包含的所有函數(shù)

random.randint(a, b) ,，返回 [a, b] 之間的整數(shù),，包含 a 和 b

例如：

random.randint(12, 20)  # 生成的隨機數(shù)n: 12 <= n <= 20   
random.randint(20, 20)  # 結(jié)果永遠是 20   
random.randint(20, 10)  # 該語句是錯誤的，下限必須小于上限

綜合練習—猜數(shù)字

計算機要求用戶輸入數(shù)值范圍的最小值和最大值,。計算機隨后“思考”出在這個范圍之內(nèi)的一個隨機數(shù),，并且重復(fù)地要求用戶猜測這個數(shù)，直到用戶猜對了,。在用戶每次進行猜測之后,，計算機都會給出一個提示，并且會在這個過程的最后顯示出總的猜測次數(shù),。這個程序包含了幾種類型的我們學過的 Python 語句,，例如，輸入語句,、輸出語句,、賦值語句、循環(huán)和條件語句,。
一個可能的游戲過程如下：

Enter the smaller number: 1
Enter the larger number: 20
Enter your guess: 5
Too small
Enter your guess: 9
Too small
Enter your guess: 15
Too small
Enter your guess: 17
Too large
Enter your guess: 16
You've got it in 5 tries!

import random

smaller = int(input('Enter the smaller number: '))
larger = int(input('Enter the larger number: '))
myNumber = random.randint(smaller, larger)
count = 0
while True:
    count += 1
    userNumber = int(input('Enter your guess: '))
    if userNumber < myNumber:
        print('Too small')
    elif userNumber > myNumber:
        print('Too large')
    else:
        print('You've got it in', count, 'tries!')
        break

5.1. 列表定義

列表是Python中內(nèi)置有序可變序列,，列表的所有元素放在一對中括號“[]”中,，并使用逗號分隔開；
一個列表中的數(shù)據(jù)類型可以各不相同,，可以同時分別為整數(shù),、實數(shù)、字符串等基本類型,，甚至是列表,、字典以及其他自定義類型的對象。
例如：

[1,2,3,2.4,5]
[0.01,'zhangsan',[1,2,3]]

創(chuàng)建
使用“=”直接將一個列表賦值給變量即可創(chuàng)建列表對象,。例如：a_list = [],，b_list = [1，2,3]
使用list()函數(shù)將元組,、range對象,、字符串或其他類型的可迭代對象類型的數(shù)據(jù)轉(zhuǎn)換為列表。
例如：a_list = list(“Hello”) 將字符串 “hello” 轉(zhuǎn)換成列表 ['H’,，'e’,，'l’，'l’,，'o’]
刪除 當不再使用時,，使用del命令刪除整個列表 例如：

>>>x =[1,2,3]

>>>del  x[1]                    #刪除指定位置元素

>>>x

[1，3]

>>>del x                        #刪除整個列表

>>>x

Traceback (most recent call last):

  File '<pyshell#6>', line 1, in <module>

      x

NameError: name 'x' is not defined

5.2. 列表元素的增加

5.2.1. append()

向列表尾部追加一個元素,，不改變其內(nèi)存首地址,，屬于原地操作。 例如：

>>>x = [1,2,3]

>>>x.append(4)

>>>x

[1,2,3,4]

5.2.2. insert()

向列表任意位置插入一個元素,，不改變其內(nèi)存首地址,，屬于原地操作,。
例如：

>>>x = [1,3,4]
>>>x.insert(1,2)
>>>x
[1,2,3,4]

5.2.3. extend()

將另一個迭代對象的所有元素添加至該列表對象尾部，不改變其內(nèi)存首地址，屬于原地操作,。
例如：

>>>x = [1,2]

>>>x.extend([3,4])

>>>x

[1,2,3,4]

5.3. 運算符' + ' 和' * '

并不是真的為列表添加元素,，而是創(chuàng)建一個新列表,不屬于原地操作,，而是返回新列表,。

>>> x = [1,2,3]
>>>y = x + [4]
>>>y
[1,2,3,4]
>>>y = x*2
>>>y
[1,2,3,4,1,2,3,4]

此時x保持不變，依舊是[1,2,3]

5.4. 列表元素的刪除

5.4.1. pop()

使用列表的pop()方法刪除并返回指定（默認為最后一個）位置上的元素,，如果給定的索引超出了列表的范圍則拋出異常,。

>>>x = [1,2,3,4]
>>>x.pop()                        #彈出并返回尾部元素
4
>>>x.pop(1)                     #彈出并返回指定位置的元素
>>>2

5.4.2. remove()

刪除首次出現(xiàn)的指定元素，如果列表中不存在要刪除的元素,，則拋出異常,。
例如：

>>>x = [1,2,2,3,4]

>>>x.remove(2)

>>>x

[1,2,3,4]

5.4.3. clear()

清空列表。
例如：

>>>x = [1,2,3,4]

>>>x.clear()

>>>x

[ ]

5.4.4. del

刪除列表中的指定位置上的元素,。
例如：

>>>x = [1,2,3,4]

>>>del x[1]

>>>x

[1,3,4]

5.5. 列表元素訪問與計數(shù)

5.5.1. count()

統(tǒng)計指定元素在列表對象中出現(xiàn)的次數(shù),。
例如：

>>> x =[1,2,3,3,4,5]

>>>x.count(3)

2

>>>x.count(0)

0

1.5.2. index()

獲取指定元素首次出現(xiàn)的下標,，若列表對象中不存在指定元素，則拋出異常,。
例如：

>>>x = [1,2,3,2,2,4]

>>>x.index(2)

1

5.5.3. in

測試列表中是否存在某元素
例如：

>>>x = [1,2,3,4]

>>>3 in x

True

>>>5 in x

False

5.6. 列表排序

5.6.1. sort()

按照指定規(guī)則對所有元素進行排序,，默認規(guī)則是直接比較規(guī)則大小。
例如：

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> import random

>>> random.shuffle(aList)                              #隨機降序

>>> aList

[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]

>>> aList.sort()                                              #默認是升序排序

>>> aList.sort(reverse = True)                       #降序排序

>>> aList

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

5.6.2. reverse()

將列表中所有元素原地逆序排列,。

例如：

>>>x = [1,3,2,4,6,5]

>>>x.reverse()

>>>x

[5,6,4,2,3,1]

5.6.3. sorted()

使用內(nèi)置函數(shù)sorted對列表進行排序并返回新列表,，不對原列表做任何修改。
例如：

>>>x = [6,4,2,4,1]

>>> sorted(x)                                     #升序排序

[1,2,4,4,6]

>>> sorted(aList,reverse = True)             #降序排序

[6,4,4,2,1]

>>>x

[6,4,2,4,1]

5.6.4. reversed()

返回一個逆序排列后的迭代對象,，不對原列表做任何修改,。

>>>x =[1,5,3,6,2]

>>>list(reversed(x))

[2,6,3,5,1]

>>>x

[1,5,3,6,2]

5.7. 用于序列操作的常用內(nèi)置函數(shù)

5.7.1. len()

返回列表中的元素個數(shù)，同樣適用于元組,、字典,、集合、字符串等,。

5.7.2. max(),、 min()

返回列表中的最大或最小元素，同樣適用于元組,、字典,、集合、range對象等,。

5.7.3. sum()

對列表的元素進行求和運算,。

5.7.4. zip()

返回可迭代的zip對象。
例如：

>>> aList = [1, 2, 3]

>>> bList = [4, 5, 6]

>>> cList = zip(a, b)                               #返回zip對象

>>> cList

<zip object at 0x0000000003728908>

>>> list(cList)                                         #把zip對象轉(zhuǎn)換成列表

[(1, 4), (2, 5), (3, 6)]

5.7.5. enumerate()

枚舉列表元素,，返回枚舉對象,，其中每個元素為包含下標和值的元組。該函數(shù)對元組,、字符串同樣有效,。

例如：

>>> for item in enumerate('abcdef'):
print(item)
(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

(5, 'f')

5.8. 遍歷列表的三種方式

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

for i in range(len(a)):
    print(i,a[i])
for i,ele in enumerate(a):
    print(i,ele)

5.9. 列表推導(dǎo)式

列表推導(dǎo)式使用非常簡潔的方式來快速生成滿足特定需求的列表,，代碼具有非常強的可讀性,。

語法形式：[表達式 for 變量 in 序列或迭代對象]

列表推導(dǎo)式在邏輯上相當于一個循環(huán)，只是形式更加簡潔,。

lis = [i for i in range(100)]
print(lis)

使用列表推導(dǎo)式實現(xiàn)嵌套列表的平鋪

>>> vec = [[1,2,3], [4,5,6], [7,8,9]]

>>> [num for elem in vec for num in elem]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

相當于：

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> result = []

>>> for elem in vec:

    for num in elem:

  result.append(num)

>>> result

[1, 2, 3, 4, 5, 6, 7, 8, 9]

過濾不符合條件的元素 從列表中選擇符合條件的元素組成新的列表

>>> aList = [-1,-4,6,7.5,-2.3,9,-11]

>>> [i for i in aList if i>0]

[6, 7.5, 9]

在列表推導(dǎo)式中使用多個循環(huán),，實現(xiàn)多序列元素的任意組合，并且可以結(jié)合條件語句過濾特定元素

>>> [(x, y) for x in range(3) for y in range(3)]

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表綜合練習
寫一個循環(huán),，不斷的問用戶想買什么,，用戶選擇一個商品編號，就把對應(yīng)的商品添加到購物車里,，最終用戶輸入q退出時,，打印購物車里的商品列表

products = [['iphone',6888],['三星',3000],['小米',2500]]
shopping_car = []
flag = True
while flag:
    print('******商品列表******')
    for index,i in enumerate(products):
        print('%s.  %s|  %s' %(index,i[0],i[1]))
    choice = input('請輸入您想購買的商品的編號：')
    if choice.isdigit():#isdigit()判斷變量是什么類型
        choice = int(choice)
        if choice>=0 and choice<len(products):
            shopping_car.append(products[choice])
            print('已經(jīng)將%s加入購物車' %(products[choice]))
        else:
            print('該商品不存在')
    elif choice == 'q':
        if len(shopping_car)>0:
            print('您打算購買以下商品：')
            for index,i in enumerate(shopping_car):
                print('%s. %s|  %s' %(index,i[0],i[1]))
        else:
            print('您的購物車中沒有添加商品')
        flag = False

5.10. 列表切片

使用索引獲取列表的元素（隨機讀?。?/p>

列表元素支持用索引訪問，正向索引從0開始

  colors=['red','blue','green']

  colors[0] =='red'

  colors[1]=='blue'

同時,，也可以使用負向索引(python中有序序列都支持負向索引)

 colors[-1]=='green'

5.10.1. 列表的切片操作

切片操作不是列表特有的,，python中的有序序列都支持切片，如字符串,，元組,。
切片的返回結(jié)果類型和切片對象類型一致，返回的是切片對象的子序列,，如：對一個列表切片返回一個列表,，字符串切片返回字符串。

  li=['A','B','C','D']

格式： li[start : end : step]

start是切片起點索引,，end是切片終點索引,，但切片結(jié)果不包括終點索引的值。step是步長默認是1,。

     t=li[0:3]        ['A','B','C']        #起點的0索引可以省略,，t=li[:3]

      t=li[2: ]        ['C','D']           #省略end，則切到末尾

      t=li[1:3]        ['B','C']

      t=li[0:4:2]       ['A','C']       #從li[0]到li[3],設(shè)定步長為2,。

如何確定start和end,，他們是什么關(guān)系？ 在step的符號一定的情況下,，start和end可以混合使用正向和反向索引,，無論怎樣，你都要保證 start和end之間有和step方向一致元素 間隔,，否則會切出空列表

            t=li[0:2]

            t=li[0:-2]

            t=li[-4:-2]

            t=li[-4:2]

上面的結(jié)果都是一樣的,；t為[“A”,“B”]

         t=li[-1:-3:-1]

         t=li[-1:1:-1]

         t=li[3:1:-1]

         t=li[3:-3:-1]

上面的結(jié)果都是一樣的；t為[“D”,“C”]

         t=li[-1:-3]

         t=li[-1:1]

         t=li[3:1]

         t=li[3:-3]

都切出空列表

同時,，step的正負決定了切片結(jié)果的元素采集的先后

省略start 和 end表示以原列表全部為目標

t=li[::-1]     t--->['C','B','A']     #反向切,，切出全部 

t=li[:]        t--->['A','B','C','D']   #正向切全部

5.10.2. 使用切片來原地修改列表內(nèi)容

>>> aList = [3, 5, 7]

>>> aList[len(aList):] = [9]               #在尾部追加元素

>>> aList

[3, 5, 7, 9]

>>> aList[:3] = [1, 2, 3]                  #替換前3個元素

>>> aList

[1, 2, 3, 9]

>>> aList[:3] = []                         #刪除前3個元素

>>> aList

[9]

5.10.3. 使用del與切片結(jié)合來刪除列表元素

>>> aList = [3,5,7,9,11]

>>> del aList[:3]                          #刪除前3個元素

>>> aList

[9, 11]



>>> aList = [3,5,7,9,11]

>>> del aList[::2]                         #刪除偶數(shù)位置上的元素

>>> aList

[5, 9]

5.10.4. 切片返回的是列表元素的淺復(fù)制

所謂淺復(fù)制，是指生成一個新的列表,，并且把原列表中所有元素的引用都復(fù)制到新列表中,。

例如：

>>> aList = [3, 5, 7]

>>> bList = aList              #bList與aList指向同一個內(nèi)存

>>> bList

[3, 5, 7]

>>> bList[1] = 8                #修改其中一個對象會影響另一個

>>> aList

[3, 8, 7]

>>> aList == bList             #兩個列表的元素完全一樣

True

>>> aList is bList              #兩個列表是同一個對象

True

>>> id(aList)                     #內(nèi)存地址相同

19061816

>>> id(bList)

19061816

>>> aList = [3, 5, 7]

>>> bList = aList[::]                 #切片，淺復(fù)制

>>> aList == bList                    #兩個列表的元素完全一樣

True

>>> aList is bList                    #但不是同一個對象

False

>>> id(aList) == id(bList)            #內(nèi)存地址不一樣

False

>>> bList[1] = 8                      #修改其中一個不會影響另一個

>>> bList

[3, 8, 7]

>>> aList

[3, 5, 7]

5.11. 元組

元組屬于不可變序列（元素集合）,，一旦創(chuàng)建,，用任何方法都不可以修改其元素。從形式上,，元組的所有元素放在一對圓括號中,，元素之間用逗號分隔。

5.11.1. 元組的創(chuàng)建與刪除

創(chuàng)建 使用“=”將一個元組賦值給變量
例如：

>>>x = (1,2,3)                               #直接把元組賦值給一個變量
>>>x
(1,2,3)

創(chuàng)建只有一個元素的元組

x =(3)
print(type(x))
x =(3,)
print(type(x))

輸出

<class 'int'>
<class 'tuple'>

創(chuàng)建空元組的方法

>>>x = ()                                       #空元組

>>>x

()

>>>x = tuple()                              #空元組

>>>x

()

使用tuple函數(shù)將其他序列轉(zhuǎn)換為元組

>>>tuple(range(5))                   

(0,1,2,3,4)

>>> tuple('abcdefg')                          #把字符串轉(zhuǎn)換為元組

('a', 'b', 'c', 'd', 'e', 'f', 'g')

>>> aList

[-1, -4, 6, 7.5, -2.3, 9, -11]

>>> tuple(aList)                                #把列表轉(zhuǎn)換為元組

(-1, -4, 6, 7.5, -2.3, 9, -11)

刪除 使用del可以刪除元組對象，不能刪除元組中的元素

5.11.2. 元組與列表的區(qū)別

1.元組中的數(shù)據(jù)一旦定義就不允許更改,。
2.元組沒有append(),、extend()和insert()等方法，無法向元組中添加元素,。
3.元組沒有remove()或pop()方法,，也無法對元組元素進行del操作，不能從元組中刪除元素,。
4.從效果上看,，tuple( )凍結(jié)列表，而list( )融化元組,。

5.12. 元組的優(yōu)點

1.元組的速度比列表更快,。
2.元組對不需要改變的數(shù)據(jù)進行“寫保護”將使得代碼更加安全。
3.元組可用作字典鍵（特別是包含字符串,、數(shù)值和其它元組這樣的不可變數(shù)據(jù)的元組）,。元組有時還作為函數(shù)的返回值返回（返回多個值）。

6.1. 字符串的常用操作方法

6.1.1. 字符串切片

獲取Python字符串中的某字符可以使用索引：

lang = '小朱學長'
print(lang[0])
print(lang[3])

小
學

截取字符串中的一段字符串可以使用切片,，切片在方括號中使用冒號:來分隔需要截取的首尾字符串的索引,，方式是包括開頭，不包括結(jié)尾

lang[2:4]
# 學長

當尾索引沒有給出時,，默認截取到字符串的末尾

lang[2:]
# 學長

當頭索引沒有給出的時候默認從字符串開頭開始截取

lang[:3]
# 小朱學

當尾索引和頭索引都沒有給出的時候,，默認返回整個字符串，不過這只是一個淺拷貝

    lang[:]
    # 小朱學長

當尾索引大于總的字符串長度時,，默認只截取到字符串末尾,，很明顯使用這種方法來截取一段到字符串末尾的子字符串是非常不明智的，應(yīng)該是不給出尾索引才是最佳實踐

    lang[3:100]
    # 長

當頭索引為負數(shù)時,，則是指從字符串的尾部開始計數(shù),，最末尾的字符記為-1，以此類推,，因此此時應(yīng)該注意尾索引的值,，尾索引同樣可以為負數(shù)，如果尾索引的值指明的字符串位置小于或等于頭索引,，此時返回的就是空字符串

    lang[-2:]
    # 學長
    lang[-2,2]
    # ''

切片的第三個參數(shù)是步長

s = 'www.neuedu.com'
#### 切片取出來的字符串與原字符串無關(guān),，原字符串不變
print(s[6: 10])
print(s[7:: 2])

uedu
eucm

反向取數(shù)字需要加上反向步長

print(s[-1: -4: -1])
print(s[-1: 2]) #### 取不到數(shù)據(jù)，因為步長默認-1
print(s[-1: 2: -1])#### 可以

moc

moc.udeuen.

6.1.2. 把字符串全部大寫或小寫upper,， lower

s = 'www.NEUEDU.com'
print(s.upper())    #### 全部大寫
print(s.lower())    #### 全部小寫

6.1.3. 判讀以xx開頭或結(jié)尾startswith,，endswith

s = 'www.neuedu.com'
print(s.startswith('www'))    #### 判斷是否以www開頭
print(s.endswith('com'))    #### 判斷是否以com結(jié)尾

True
True

6.1.4. 查找元素find ,，index

s = 'chhengt'
print(s.find('h'))  #### 通過元素找索引找到第一個就返回（可切片）
print(s.find('b'))  #### 找不到返回 -1
print(s.index('b'))   #### 找不到會報錯

Traceback (most recent call last):
1
  File 'C:/Users/Administrator/PycharmProjects/textgame/tests/test_bag.py', line 4, in <module>
-1
    print(s.index('b'))   #### 找不到會報錯
ValueError: substring not found

6.1.5. strip 默認去除字符前后兩端的空格,， 換行符， tab

s = 'qqwalex qqwusir barryy'
print(s.strip('qqw'))
print(s.strip(''))
print(s.lstrip('yy'))
print(s.rstrip('yy'))

alex qqwusir barryy
qqwalex qqwusir barryy
qqwalex qqwusir barryy
qqwalex qqwusir barr

6.1.6. split 把字符串分割成列表

#### 分割出的元素比分隔符數(shù)+1  ***
#### 字符串變成->>>列表
s = 'qqwalex qqwusir barryy'
s1 = 'qqwale;x qqwu;sir bar;ryy'
print(s.split())    #### 默認以空格分割
print(s1.split(';'))    #### 以指定字符分割
print(s1.split(';', 1)) #### 指定分割多少個

['qqwalex', 'qqwusir', 'barryy']
['qqwale', 'x qqwu', 'sir bar', 'ryy']
['qqwale', 'x qqwu', 'sir bar;ryy']

6.1.7. join把列表轉(zhuǎn)化成字符串

#### 列表轉(zhuǎn)化成字符串 list --> str
s = 'alex'####看成字符列表
li = ['aa', 'ddj', 'kk']    #### 必須全是字符串
s1 = '_'.join(s)
print(s1)
s2 = ' '.join(li)
print(s2)

a_l_e_x
aa ddj kk

6.1.8. is系列

#### 字符串.isalnum()    所有字符都是數(shù)字或者字母,，為真返回 Ture,，否則返回 False,。
#### 字符串.isalpha()     所有字符都是字母，為真返回 Ture,，否則返回 False,。
#### 字符串.isdigit()     所有字符都是數(shù)字，為真返回 Ture,，否則返回 False,。
#### 字符串.islower()    所有字符都是小寫，為真返回 Ture,，否則返回 False,。
#### 字符串.isupper()    所有字符都是大寫，為真返回 Ture,，否則返回 False,。
#### 字符串.istitle()            所有單詞都是首字母大寫，為真返回 Ture,，否則返回 False,。
#### 字符串.isspace()    所有字符都是空白字符，為真返回 Ture,，否則返回 False,。    

#### is 系列
name = 'taibai123'
print(name.isalnum())   #### 字符串由數(shù)字或字母組成時返回真
print(name.isalpha())   #### 字符只由字母組成時返回真
print(name.isdigit())   #### 字符只由數(shù)字組成時返回真

6.1.9. count 計算字符串中某個字符出現(xiàn)的次數(shù) *

#### count 計算字符串中某個字符出現(xiàn)的次數(shù)  ***
s = 'www.neuedu.com'
print(s.count('u'))
print(s.count('u', 7))

2
1

6.1.10. replace 替換字符串中指定的字符

s = 'asdf 之一，asdf也,，asdf'
#### replace  ***
s1 = s.replace('asdf', '日天')
print(s1)
s1 = s.replace('asdf', '日天', 1)
print(s1)

日天 之一,，日天也，日天
日天 之一,，asdf也,，asdf

6.1.11. format格式化輸出

#### format 格式化輸出  ***
#### 第一種方式：
s = '我叫{}, 今年{}， 性別{}'.format('小五', 25, '女')
print(s)
#### 第二種方式
s1 = '我叫{0}, 今年{1},， 性別{2},，我依然叫{0}'.format('小五', 25, '女')
print(s1)
#### 第三種方式
s2 = '我叫{name}, 今年{age}， 性別{sex},，我依然叫{name}'.format(age=25, sex='女',name='小五')
print(s2)

我叫小五, 今年25,， 性別女
我叫小五, 今年25， 性別女,，我依然叫小五
我叫小五, 今年25,， 性別女，我依然叫小五

6.1.12. capitalize() 首字母大寫

s = 'chen wuang4fhsa￥fh,。f'
#### capitalize() 首字母大寫 **
s1 = s.capitalize()
print(s1)

Chen wuang4fhsa￥fh,。f

6.1.13. center() 將字符串居中可以設(shè)置總長度，可以設(shè)置填充物

#### center() 將字符串居中可以設(shè)置總長度，可以設(shè)置填充物 *
s = 'chenziwu'
s2 = s.center(50)
s2 = s.center(50, '*')
print(s2) 

*********************chenziwu*********************

6.1.14. title 非字母隔開的每個單詞的首字母大寫 *

s = 'chen wuang4fhsa￥fh,。f'
#### title  非字母隔開的每個單詞的首字母大寫 *
s4 = s.title()
print(s4)

Chen Wuang4Fhsa￥Fh,。F

6.1.15. 字符串是不可變變量，不支持直接通過下標修改

msg = 'abcdefg'
# msg[2] = 'z'

msg = msg[:2] + 'z' + msg[3:]

print(msg)

6.2. 綜合練習 龜兔賽跑

(模擬龜兔賽跑)本練習中要模擬龜兔賽跑的寓言故事,。用隨機數(shù)產(chǎn)生器建立模擬龜兔賽跑的程序,。 對手從70個方格的第1格開始起跑，每格表示跑道上的一個可能位置,，終點線在第70格處,。 第一個到達終點的選手獎勵一個新鮮蘿卜和萵苣。兔子要在山坡上睡一覺,，因此可能失去冠軍,。 有一個每秒鐘滴答一次的鐘，程序應(yīng)按下列規(guī)則調(diào)整動物的位置：

用變量跟蹤動物的位置(即位置號1到70),。每個動物從位置1開始,，如果動物跌到第1格以外，則移回第1格,。 產(chǎn)生隨機整數(shù)1≤i≤10),，以得到上表中的百分比。對于烏龜,，1≤i≤5時快走,，6≤i≤7時跌跤，8≤i≤10時慢走,，兔子也用相似的方法,。 起跑時，打?。?BANG !!! AND THEY’ RE OFF !!! 時鐘每次滴答一下(即每個重復(fù)循環(huán)),，打印第70格位置的一條線，顯示烏龜?shù)奈恢肨和兔子的位置H,。 如果兩者占用一格,，則烏龜會咬兔子，程序從該位置開始打印 OUCH!!!,。除T,、H和OUCH!!!以外的其他打印位置都是空的。 打印每一行之后,，測試某個動物是否超過了第70格,，如果是,則打印獲勝者，停止模擬,。 如果烏龜贏,，則打印TORTOISE WINS!!!YAY!!!,。如果兔子贏，則打印Hare wins．Yush,。 如果兩個動物同時贏，則可以同情弱者,，讓烏龜贏,，或者打印It’s a tie。如果兩者都沒有贏,，則再次循環(huán),，模擬下一個時鐘滴答。 準備運行程序時,，讓一組拉拉隊看比賽,，你會發(fā)現(xiàn)觀眾有多么投入。

from random import randint
import time

print('begin')
hPos = 0
tPos = 0

while True:
    paodao = '_' * 70
    n = randint(0,10) + 1
    if n <= 5:
        tPos += 3
    elif 5 < n <= 7:
        tPos -= 6
    else:
        tPos += 1

    if n <= 2:
        hPos = hPos
    elif 3 <= n <= 4:
        hPos += 9
    elif n == 5:
        hPos -= 12
    elif 6 <= n <= 8:
        hPos += 1
    else:
        hPos -= 2

    if tPos >= 70 or hPos >= 70:
        break

    if tPos == hPos:
        paodao = paodao[:tPos] + '咬' + paodao[tPos:]
    else:
        paodao = paodao[:tPos] + '龜' + paodao[tPos:]
        paodao = paodao[:hPos] + '兔' + paodao[hPos:]

    print(paodao)
    time.sleep(0.5)

if tPos > 70:
    print('龜贏')
else:
    print('兔贏')

6.3. 綜合練習 猜單詞游戲

任務(wù)目的

1.掌握字符串常用操作 2.掌握隨機數(shù)的用法 3.掌握控制臺基本輸入輸出 4.掌握循環(huán),，分支條件的用法 5.培養(yǎng)編程思維,，提高分析問題能力`

任務(wù)描述

需求

給定單詞數(shù)組（不少于10個），程序隨機選擇其中的一個,，并顯示單詞字符長度個橫線（-）,，用戶有5次猜測機會，用戶每次猜一個字母,，如果正確,，則將在相應(yīng)的位置上顯示出來；如錯誤則猜測機會減一,，重復(fù)該過程,，直至單詞的全部字母全部猜出或者猜測次數(shù)用完，最后宣布用戶勝利或失敗,。

實例

例如隨機選出的單詞是apple,，程序先打印- - - - - 用戶輸入p，程序打印 -pp-- 用戶輸入e,，程序打印 -pp-e 用戶輸入t,，程序打印 -pp-e 您還有4次機會 用戶輸入a，程序打印 app-e 用戶輸入l,，程序打印 apple 恭喜您,，取得勝利。

任務(wù)注意事項

請注意代碼風格的整齊,、優(yōu)雅 代碼中含有必要的注釋 代碼

import random
words = ['program','banana','tiger','policeman','interface']
index = random.randint(0,len(words) - 1)
word = words[index]
print(word)
wordbak = '-' * len(word)
print(wordbak)
guessTimes = 5
wordlst = list(wordbak)

while True:

    if guessTimes <= 0:
        break
    if '-' not in wordlst:
        break
    char = input('請輸入一個字符：')
    if char in word:
        for i,c in enumerate(word):
            if c == char:
                wordlst[i] = char
    else:
        guessTimes -= 1
        print('你還剩下{}次機會'.format(guessTimes))

    print(''.join(wordlst))

if guessTimes > 0:
    print('you win')
else:
    print('you lose')