??作者簡(jiǎn)介：練習(xí)時(shí)長(zhǎng)兩年半的Java up主
??個(gè)人主頁：程序員老茶
?? ps:點(diǎn)贊??是免費(fèi)的，卻可以讓寫博客的作者開興好久好久??
??系列專欄：Java全棧，計(jì)算機(jī)系列（火速更新中）
?? 格言：種一棵樹最好的時(shí)間是十年前，其次是現(xiàn)在
??動(dòng)動(dòng)小手，點(diǎn)個(gè)關(guān)注不迷路，感謝寶子們一鍵三連

課程名：Python

內(nèi)容/作用：知識(shí)點(diǎn)/設(shè)計(jì)/實(shí)驗(yàn)/作業(yè)/練習(xí)

學(xué)習(xí)：Python入門知識(shí)

課程：python

一、python介紹

1、基本介紹

? 吉多范羅蘇姆----荷蘭科學(xué)家
ABC語言：
? 優(yōu)點(diǎn)：
? 語言簡(jiǎn)潔、代碼量少（C語言的1/4）、專為程序員設(shè)計(jì)等
? 缺點(diǎn)：
? 不開放
?
1989年 圣誕節(jié) python（由來）
Python語言：
? 優(yōu)點(diǎn)：
? 語言簡(jiǎn)潔、代碼量少（C語言的1/4），開放等

2、python的執(zhí)行方式

（1）非交互式解釋器（python2.x python3.x）
在python的終端運(yùn)行Python文件
$ python python文件
$ python3 python文件
（2）交互式解釋器—ipython
用戶編寫一行代碼，機(jī)器識(shí)別一行代碼
（3）集成開發(fā)環(huán)境—IDE
繼承了用戶所需要的環(huán)境與軟件

二、環(huán)境的安裝

1、解釋器

? 將用戶編寫的代碼解釋成二進(jìn)制語言，便于機(jī)器識(shí)別（機(jī)器能讀懂的語言）
流程：
? 用戶編寫python代碼-------解釋器解釋Python代碼-------操作系統(tǒng)------cpu執(zhí)行

2、環(huán)境的安裝

? 集成開發(fā)環(huán)境—Pycharm

三、版本的介紹

1、python2.x版本：

08年以前是python2.x版本，08年以后python3.x版本，python2.7和python2.8版本（向上兼容）
python2.x版本：

（1）保留了cmp函數(shù)

? 用于兩個(gè)對(duì)象進(jìn)行比較
cmp（a,b） #如果a>b，返回為1，a<b，返回-1，a=b，返回為0

（2）True、False是全局變量

True=10
False=“hello”

（3）python2版本默認(rèn)是ASCII編碼

a=50
b=“hello”
中國(guó)=“hello” #不支持

（4）print是作為一條語句，進(jìn)行輸出（打印）

print “hello” #控制臺(tái)輸出字符串hello
print（“hello”） #不支持
（5）保留了不等于符號(hào)：!=、<>
2!=3
3<>3
…

2、python3.x版本：

（1）增加了operator模塊

lt（a,b）函數(shù)： less than，小于，如果a<b，返回為真，否則返回假
le（a,b）函數(shù)： less equal ，小于等于，如果a<=b，返回為真，否則返回為假
eq（a,b）函數(shù)：equal，等于，如果a=b，返回為真，否則返回為假
gt（a,b）函數(shù)：greater than ，大于，如果a>b，返回為真，否則返回為假
ge（a,b）函數(shù)：greater equal ，大于等于，如果a>=b，返回真，否則返回為假

（2）True、False是關(guān)鍵字

True=“world” #報(bào)錯(cuò)
False=50 #報(bào)錯(cuò)

（3）python3解釋器是UTF-8編碼

a=“hello”
中國(guó)=“hello”

（4）print作為一個(gè)函數(shù)，進(jìn)行輸出（打?。?/h4>

print（“hello world”） #輸出hello world
print “hello " #不支持

（5）保留了不等于符號(hào)：!=，舍棄了<>

2!=3
2<>3 #不支持
…
#win+r------cmd-----python（進(jìn)入到Python的解釋器）

四、python的優(yōu)缺點(diǎn)

優(yōu)點(diǎn)：

1、python作為一種面向?qū)ο蟮囊婚T語言
2、python社區(qū)集成了很多模塊，數(shù)據(jù)庫、tcp/ip、UDP、圖像處理、文本處理等等
3、語言簡(jiǎn)潔優(yōu)美
4、易擴(kuò)展性
5、易學(xué)習(xí)

缺點(diǎn)（特點(diǎn)）：

1、單行語句（沒有分號(hào)“；”）
2、執(zhí)行速度慢
3、強(qiáng)制縮進(jìn)（沒有大括號(hào)“{}”）

五、第一個(gè)python程序

? print（“hello world”） #this is first python code

1、print（）

? 將print函數(shù)里的帶的實(shí)參輸出到控制臺(tái)，輸出

2、print函數(shù)帶的參數(shù)

? 參數(shù)是Python支持的數(shù)據(jù)類型（int、str、list、tuple、float等等）
例如：
? print（50）#輸出50
? print（“hello world”）
? print（12.356）
? print（num） #報(bào)錯(cuò)

3、注釋

（1）行注釋

? 意思就是注釋單行代碼，其他行代碼沒有注釋（將#后面的內(nèi)容全部注釋，其他行沒有注釋）
符號(hào)：#
例如：

	#  hello world

（2）塊注釋

? 塊注釋是注釋多行代碼
符號(hào)：三個(gè)雙引號(hào)"""或者是三個(gè)單引號(hào)
例如：

"""
print("hello world") #this is first python code
print("你好世界")
"""
'''
print("hello world") #this is first python code
print("你好世界")
'''

六、標(biāo)識(shí)符

? 標(biāo)識(shí)符一般是作為變量來使用
1、標(biāo)識(shí)符由字母、數(shù)字、下劃線組成
2、標(biāo)識(shí)符不能是關(guān)鍵字（避免使用關(guān)鍵字）
3、標(biāo)識(shí)符不能是以數(shù)字開頭
例如：
? _hello、5hjl（錯(cuò)誤）、@hj5（錯(cuò)誤）、shfiosfho、dgd5awe、￥sfsg（錯(cuò)誤）、ssg#949（錯(cuò)誤）

七、關(guān)鍵字

? 關(guān)鍵字是python內(nèi)部保留的一些字符，特定場(chǎng)景使用的字符
關(guān)鍵字如下：
? 查詢關(guān)鍵字的方式：win+r----cmd----python—help（）----keywords
? 查詢關(guān)鍵字詳細(xì)介紹的方式：win+r----cmd----python—help（）----keywords------break
離開幫助：
? help>quit

八、變量

? 變量的實(shí)質(zhì)就是標(biāo)識(shí)符，變量的內(nèi)容是可變的
例如：
? num、sum、shifhi、ncsfweg等等
注意：
? 變量不能獨(dú)立存在

1、整型：int

例如：
50、15、45、-15、-40等等
整型數(shù)據(jù)的存儲(chǔ)：

格式：
	標(biāo)識(shí)符 =  整型值
例如：
	num=50
	num=40

2、字符串類型：str

? 用雙引號(hào)或者是單引號(hào)括起來的字符，稱之為字符串，嚴(yán)格來說稱之為字符序列
例如：
? “hello” ‘hello’ “1245” ‘你好，世界’ ‘a(chǎn)’ 等等
字符串的存儲(chǔ)：

格式：
?	標(biāo)識(shí)符=字符串值
例如：
?	num="hello"
?	num='a'

后面會(huì)講：字符串的復(fù)制、拼接、截取或切片等等

3、浮點(diǎn)型：float

? 浮點(diǎn)型在數(shù)學(xué)中就是小數(shù)
例如：
? 1.2 1.355 1.4646 5.15
浮點(diǎn)型的存儲(chǔ)：

格式：
?	標(biāo)識(shí)符=浮點(diǎn)型值
例如：
?	num=1.56
?	num=4.564

4、bool類型

關(guān)鍵字：True（真）、False（假）
一般用于條件判斷或者是循環(huán)條件判斷

5、列表、元組、詞典（字典）

6、全局變量與局部變量

（1）全局變量

? 存在于函數(shù)體外部的變量，稱之為全局變量，那么對(duì)于整個(gè)py文件都是可見的，沒有任何的作用域的限制；注意，在函數(shù)體內(nèi)部更新全局變量的值需要有關(guān)鍵字global來聲明
global：針對(duì)局部去修改全局變量的值

（2）局部變量

? 存在于函數(shù)體內(nèi)部的變量，稱之為局部變量，局部變量只對(duì)函數(shù)體內(nèi)有效（它的生命周期只存在于函數(shù)體內(nèi)）；注意，在函數(shù)體內(nèi)部的函數(shù)體內(nèi)部更新第一個(gè)函數(shù)體變量的值需要有關(guān)鍵字nonlocal來聲明
nonlocal：針對(duì)局部的局部去修改局部變量的值

7、工廠函數(shù)

? 工廠函數(shù)實(shí)質(zhì)就是：類型轉(zhuǎn)換（相當(dāng)于c語言中強(qiáng)制類型轉(zhuǎn)換）類似于與工廠生產(chǎn)產(chǎn)品一樣

（1）int(對(duì)象，基數(shù))

? 參數(shù)：一定要是數(shù)字類型或者數(shù)字字符串類型，如20，“20”，
? 基數(shù)：可有可無，如果沒有該基數(shù)，默認(rèn)是十進(jìn)制，如
? 例如：
?

	int("20") #將字符串“20”轉(zhuǎn)換為整型的20
	int("20",8)#20是八進(jìn)制形式的，通過int轉(zhuǎn)換整形（十進(jìn)制）

（2）type（對(duì)象）

? 該函數(shù)時(shí)查看參數(shù)的數(shù)據(jù)類型
? 例如：?

	num=int("20")
	print(type(num))

（3）str（對(duì)象）

? 該函數(shù)就是將對(duì)象轉(zhuǎn)換為字符類型進(jìn)行輸出
? 例如：?

	num=20
	str(num) #將整形的num轉(zhuǎn)換為字符類型進(jìn)行輸出
	num=15.6
	str(num) #將浮點(diǎn)型的num轉(zhuǎn)換為字符類型進(jìn)行輸出

（4）float（對(duì)象）

? 該函數(shù)就是將對(duì)象轉(zhuǎn)換為浮點(diǎn)型進(jìn)輸出
? 例如：
?

	num=50
	print(float(num))

（5）list(對(duì)象)

? 該函數(shù)就是將對(duì)象轉(zhuǎn)換為列表類型進(jìn)行輸出，注意，對(duì)象是序列

（6）tuple(對(duì)象)

? 該函數(shù)將對(duì)象轉(zhuǎn)換為元組類型進(jìn)行輸出，注意，對(duì)象是序列

（7）dict（對(duì)象）

? 該函數(shù)將對(duì)象轉(zhuǎn)換為字典類型進(jìn)行輸出

（8）set（對(duì)象）

? 該函數(shù)將對(duì)象轉(zhuǎn)換為無序不重復(fù)的元素集，注意，對(duì)象是序列
? 例如：
?

	num="hello"
	counter="world"
	x=set(num) #將"hello"生存無序不重復(fù)的集合存入到x中
	y=set(counter) #將"world"生存無序不重復(fù)的集合存入到y(tǒng)中

符號(hào)：&
該符號(hào)是求兩個(gè)集合的交集
格式：

集合1 & 集合2

? 例如：
?

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x & y
	print(z)

符號(hào)：|
該符號(hào)是求兩個(gè)集合的并集
格式：

集合1 | 集合2

? 例如：
?

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x | y
	print(z)

符號(hào)：-（減號(hào)）
該符號(hào)是求兩個(gè)集合的差集
包含集合x中的元素，但不包含集合y中的元素
格式：

集合1 - 集合2

? 例如：

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x - y
	print(z)

符號(hào)：^
該符號(hào)是求兩個(gè)集合的補(bǔ)集
包含集合x和集合y中的非共同元素
格式：

集合1 ^ 集合2

例如：

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x ^ y
	print(z)

九、print函數(shù)與input函數(shù)

1、print函數(shù)

? 該函數(shù)的作用將print所帶的參數(shù)輸出到控制臺(tái)
? print帶的參數(shù);
? 參數(shù)是python所支持的數(shù)據(jù)類型（int,str,float,list,tuple,ste,dict等）

（1）使用print函數(shù)直接進(jìn)行輸出

? 例如：

    num=50
    print（num）
    print（50）
    num=“hello”
    print（num） #直接進(jìn)行輸出
    print（"hello"）

? 注意：
? 使用直接進(jìn)行輸出的方式可以連續(xù)輸出多個(gè)數(shù)據(jù)
? 格式：

print（數(shù)據(jù)1，數(shù)據(jù)2，...........）  #數(shù)據(jù)可以是具體的數(shù)據(jù)，也可以是變量（注：變量一定要提前賦初始值）

? 例如：

	print（50，“hello”）
    num=45
    counter="hello world"
    print（num , counter）

（2）使用%格式化進(jìn)行輸出

? 格式：

	print（“%格式控制符”%標(biāo)識(shí)符） #注：標(biāo)識(shí)符就是變量
	print（“%格式控制符1   ，%格式控制符2 ，........ ” %(標(biāo)識(shí)符1 ， 標(biāo)識(shí)符2 ，............)）

? 格式控制符：
? d（整形）、o（八進(jìn)制）、x（十六進(jìn)制）、f（浮點(diǎn)型）、s（字符串型）等等
? 注意：
? a、print函數(shù)里一個(gè)格式控制符前必須要有一個(gè)%
? b、%格式控制符與后面的標(biāo)識(shí)符是一一對(duì)應(yīng)
? c、print函數(shù)里的雙引號(hào)后面沒有逗號(hào)
? d、格式控制符要與%結(jié)合使用
? e、標(biāo)識(shí)符與標(biāo)識(shí)符之間使用逗號(hào)隔開，并且逗號(hào)是英文格式
? 例如：

	num=52
    num2=20
    counter="hello world"
    print（“%d ， %d”%(num,num2)）
    print（“num=%d，counter=%s”%(num,counter)）
	>>d（整形，十進(jìn)制）

? 例如：

	num=34
	print（“num=%d”%num） #輸出num=34

格式：

print（“{0}  ,  {1}  ，...........”.format（標(biāo)識(shí)符1，標(biāo)識(shí)符2，............））

例如：

	num=10
	counter=20
	print（“num={0} , counter={1} ”.format（num,counter））

（6）format高級(jí)用法

左對(duì)齊輸出x位
格式：

{ ： <  x}   #如果沒有x，那么輸出就直接是左對(duì)齊，如果有x，控制輸出左對(duì)齊為x位，不足的補(bǔ)空格
print（“{：< x}”.format（標(biāo)識(shí)符））

例如：

num="hello"
print（“{：< 10}”.format（num）） #輸出左對(duì)齊為10位，不足的補(bǔ)空格

右對(duì)齊輸出x位
格式：

{：>  x}   #如果沒有x，那么輸出就直接是右對(duì)齊，如果有x，控制輸出右對(duì)齊為x位，不足的補(bǔ)空格
print（“{：> x}”.format（標(biāo)識(shí)符））

例如：

num="hello"
print（“{：> 10}”.format（num）） #輸出右對(duì)齊為10位，不足的補(bǔ)空格	

中央對(duì)齊輸出x位
格式：

{：^ x}   #中央對(duì)齊輸出x位
print（“{：^ x}”.format（標(biāo)識(shí)符））

例如：

num="hello"
print（“{：^ 10}”.format（num）） #輸出中央對(duì)齊為10位，不足的補(bǔ)空格

輸出十進(jìn)制
格式：

{：d}   
print（“{：d}”.format（標(biāo)識(shí)符））  #將標(biāo)識(shí)符以10進(jìn)制形式輸出

例如：

num=50
print（“{：d}”.format（num））

輸出八進(jìn)制
格式：

{：o}   
print（“{：o}”.format（標(biāo)識(shí)符））  #將標(biāo)識(shí)符以八進(jìn)制形式輸出

例如：

num=50
print（“{：o}”.format（num））

輸出十六進(jìn)制
格式：

{：x}   
print（“{：x}”.format（標(biāo)識(shí)符））  #將標(biāo)識(shí)符以十六進(jìn)制形式輸出

例如：

num=50
print（“{：x}”.format（num））
輸出浮點(diǎn)型數(shù)據(jù)

格式1：

{：. x f}  #控制數(shù)據(jù)輸出小數(shù)點(diǎn)后x位	
print（“{：.x f}”.format（標(biāo)識(shí)符））

例如：

num=3.1415926
print（“{：.2 f}”.format（num））

格式2：

{：x.yf}  #控制數(shù)據(jù)輸出x位，并且保留小數(shù)點(diǎn)后y位 ，不足的補(bǔ)空格，默認(rèn)右對(duì)齊
	print（“{：x.y f}”.format（標(biāo)識(shí)符））

例如：

	num=3.1415926
	print（“{：10.2 f}”.format（num））
	print（“{：<10.2 f}”.format（num））

（7）帶關(guān)鍵字format格式進(jìn)行輸出

格式：

print（“{a} ,  {b} ，...........”.format（a=初始值 ， b=初始值，............）） #a和b就是關(guān)鍵字

例如：

print（“num={num}  , counter={counter}”.format（num=50 , counter="hello world"））

2、input函數(shù)

? 該函數(shù)用于從控制臺(tái)獲取用戶輸入的內(nèi)容，并存入到內(nèi)存中
格式：
?

input（字符串） 
或
input（）

注意：
a、input函數(shù)帶的參數(shù)字符串可有可無，該字符串的作用僅僅只是提示，并且會(huì)在控制臺(tái)輸出該字符串
b、使用input函數(shù)獲取的用戶的輸入的內(nèi)容，就自動(dòng)轉(zhuǎn)換為字符串類型

十、運(yùn)算符

1、基本運(yùn)算符

（1）賦值運(yùn)算符：=

格式：

標(biāo)識(shí)符（變量）=初始值

使用：
將初始值存入到標(biāo)識(shí)符（變量）里
例如：

	num=50
	counter="hello"
	.............

（2）乘法運(yùn)算符：*

格式：
對(duì)象1 * 對(duì)象2
使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“”就表示對(duì)象1乘以對(duì)象2；如果對(duì)象1是字符串序列，對(duì)象2是整形的數(shù)字，那么符號(hào)“”就表示將對(duì)象1復(fù)制對(duì)象2次（參考字符串）
例如：

	num=50
	counter=15
	num * counter  #計(jì)算num和counter的乘積

（3）除法運(yùn)算符：/

格式：

對(duì)象1 / 對(duì)象2

使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“/”就表示對(duì)象1除以對(duì)象2，注，與C語言的符號(hào)“/”要區(qū)分開
例如：

	num=50
	counter=15
	num / counter  #計(jì)算num和counter的除法

（4）取整符號(hào)：//

格式：
對(duì)象1 // 對(duì)象2
使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“//”就表示取對(duì)象1除以對(duì)象2的整數(shù)部分
例如：

	num=50
	counter=15
	num // counter  #計(jì)算num和counter相除的整數(shù)部分

（5）取余符號(hào)：%

格式：

對(duì)象1  %  對(duì)象2

使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“%”就表示取對(duì)象1除以對(duì)象2的余數(shù)部分
例如：

	num=50
	counter=15
	num % counter  #計(jì)算num和counter相除的余數(shù)部分

（6）加法運(yùn)算符：+

格式：
對(duì)象1 + 對(duì)象2

使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“+”就表示計(jì)算對(duì)象1和對(duì)象2的和；如果對(duì)象1和對(duì)象2都是序列，那么符號(hào)“+”就表示對(duì)象1和對(duì)象2的拼接
例如：

	num=50
	counter=15
	num + counter  #計(jì)算num和counter的和

（7）減法運(yùn)算符：-

格式：

對(duì)象1 -  對(duì)象2

使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“-”就表示計(jì)算對(duì)象1和對(duì)象2的差；如果對(duì)象1和對(duì)象2都是集合，那么符號(hào)“-”就表示求對(duì)象1和對(duì)象2的差集
例如：

	num=50
	counter=15
	num - counter  #計(jì)算num和counter的差

（8）冪運(yùn)算符：**

格式：

對(duì)象1  **  對(duì)象2

使用：
如果對(duì)象1和對(duì)象2都是數(shù)字，那么符號(hào)“**”就表示求對(duì)象1的對(duì)象2次方
例如：

	num=50
	counter=15
	num ** counter  #計(jì)算num的counter次方

2、增強(qiáng)型運(yùn)算符

? 增強(qiáng)型運(yùn)算符就是結(jié)合了賦值運(yùn)算符和基本運(yùn)算符，稱之為增強(qiáng)型運(yùn)算符

（1）+=

格式：

對(duì)象1 +=對(duì)象2    #  對(duì)象1=對(duì)象1+對(duì)象2

使用：
將對(duì)象1加上對(duì)象2之后的結(jié)果再存入到對(duì)象1里
例如：

	num=50
	counter=40
	num+=counter  #num=num+counter

（2）-=

格式：

對(duì)象1 -=對(duì)象2   #對(duì)象1 = 對(duì)象1-對(duì)象2

使用：
將對(duì)象1減去對(duì)象2之后的結(jié)果再存入到對(duì)象1里
例如：

	num=50
	counter=40
	num-=counter  #num=num-counter	

（3）*=

（4）/=

（5）//=

（6）%=

（7）**=

參考加等于“+=”

（8）同步賦值運(yùn)算符

格式：

標(biāo)識(shí)符1  ，  標(biāo)識(shí)符2  =   初始值1  ，  初始值2

例如：

num ,  counter  =  10  ,  20   #將10賦值給num的同時(shí)將20賦值給counter

3、比較運(yùn)算符

（1）>：大于運(yùn)算符

格式：

對(duì)象1 > 對(duì)象2

使用：
如果對(duì)象1大于對(duì)象2，那么該表達(dá)式返回為真，否則，返回為假
例如：

10>20   #假----False

（2）<:小于運(yùn)算符

格式：

對(duì)象1 < 對(duì)象2

使用：
如果對(duì)象1小于對(duì)象2，那么該表達(dá)式返回為真，否則，返回為假
例如：

10<20   #真---True

（3）>=:大于等于運(yùn)算符

格式：

對(duì)象1  >= 對(duì)象2

使用：
如果對(duì)象1大于等于對(duì)象2，那么該表達(dá)式返回為真，否則，返回為假

（4）<=：小于等于運(yùn)算符

格式：

對(duì)象1  <= 對(duì)象2

使用：
如果對(duì)象1小于等于對(duì)象2，那么該表達(dá)式返回為真，否則，返回為假
例如：

10<=20   #True

（5）==：等于運(yùn)算符

格式：

對(duì)象1  == 對(duì)象2

使用：
如果對(duì)象1等于對(duì)象2，那么該表達(dá)式返回為真，否則，返回為假
例如：

10==20  #False

（6）注意的點(diǎn)

? python里的比較運(yùn)算符可以相互的結(jié)合使用，跟C語言區(qū)分開
例如：?

2>4>5   #python
2>4  && 4>5   #C 

4、同一性運(yùn)算符

? 是指兩個(gè)對(duì)象是否是指向同一塊內(nèi)存空間，如果是，那么就是同一性，否則就不是同一性

（1）is運(yùn)算符

格式：

標(biāo)識(shí)符1   is  標(biāo)識(shí)符2 

使用：
如果標(biāo)識(shí)符1和標(biāo)識(shí)符2都是指向同一塊內(nèi)存空間，那么該表達(dá)式就輸出為真（True），否則，輸出為假（False）
例如：

num=50
counter=50
num is counter   #True
num=500
counter=500
num is counter  #False

注：
解釋器里預(yù)留了-5-256數(shù)據(jù)

（2）is not

格式：

標(biāo)識(shí)符1  is not  標(biāo)識(shí)符2

使用：
如果標(biāo)識(shí)符1和標(biāo)識(shí)符2不是指向同一塊內(nèi)存空間，那么該表達(dá)式就輸出為真（True），否則，輸出為假（False）

例如：

	num=50
	counter=50
	num is not counter   #False
	num=50
	counter=60
	num is not counter   #True

5、邏輯運(yùn)算符

（1）and：邏輯與運(yùn)算符

格式：

對(duì)象1  and 對(duì)象2  #對(duì)象1和對(duì)象2可以是表達(dá)式

使用：
如果對(duì)象1和對(duì)象2同時(shí)成立（同時(shí)為真），那么該表達(dá)式才成立（返回為真）；只要對(duì)象1和對(duì)象2任意一個(gè)不成立（為假），那么整個(gè)表達(dá)式不成立（為假）
例如：

3>2  and  5>4   #一般該表達(dá)式存在于if或則while中

注意：
如果對(duì)象1 and 對(duì)象2獨(dú)立存在，該表達(dá)式從左往右執(zhí)行，如果遇到對(duì)象不成立，那么就輸出對(duì)象不成立的結(jié)果；只要對(duì)象1和對(duì)象2同時(shí)成立，那么就輸出對(duì)象2的結(jié)果（一般認(rèn)為0就表示假，大于0就表示真）

（2）or：邏輯或運(yùn)算符

格式：

對(duì)象1  or  對(duì)象2   #對(duì)象1和對(duì)象2可以是表達(dá)式

使用：
如果對(duì)象1和對(duì)象2任意一個(gè)成立（為真），那么該表達(dá)式就成立（返回為真）；只要對(duì)象1和對(duì)象2同時(shí)不成立（為假），那么整個(gè)表達(dá)式不成立（為假）
例如：

5>4  or  4<3  #True

注意：
如果對(duì)象1 and 對(duì)象2獨(dú)立存在，該表達(dá)式從左往右執(zhí)行，如果遇到對(duì)象成立，那么就輸出對(duì)象成立的結(jié)果；只要對(duì)象2和對(duì)象2同時(shí)不成立，那么就輸出對(duì)象2的結(jié)果（一般認(rèn)為0就表示假，大于0就表示真）

（3）not：邏輯非運(yùn)算符

格式：

not 對(duì)象

使用：
如果對(duì)象成立，那么整個(gè)表達(dá)式不成立（為假），反之，整個(gè)表達(dá)式成立（為真）
例如：

not 3>4  #True

（4）邏輯運(yùn)算符的優(yōu)先級(jí)

not>and>or

6、位運(yùn)算

? 位運(yùn)算是針對(duì)二進(jìn)制的每一位對(duì)應(yīng)進(jìn)行運(yùn)算

（1）按位與運(yùn)算：&

? 格式：

對(duì)象1   &  對(duì)象2

? 使用：
? 將對(duì)象1和對(duì)象2轉(zhuǎn)換為二進(jìn)制，然后讓對(duì)象1和對(duì)象2的二進(jìn)制的每一位對(duì)應(yīng)進(jìn)行相與
例如：
?

50二進(jìn)制：   0  1  1  0  0  1  0
85二進(jìn)制：   1  0  1  0  1  0  1  
50 & 85=   0  0  1  0  0  0  0  = 16

（2）按位或運(yùn)算：|

格式：

對(duì)象1  |   對(duì)象2

使用：
將對(duì)象1和對(duì)象2轉(zhuǎn)換為二進(jìn)制，然后讓對(duì)象1和對(duì)象2的二進(jìn)制的每一位對(duì)應(yīng)進(jìn)行相或

例如：

50二進(jìn)制：   0  1  1  0  0  1  0
85二進(jìn)制：   1  0  1  0  1  0  1 
50 | 85=    1  1  1   0  1  1  1  = 119

（3）按位異或運(yùn)算：^

格式：

對(duì)象1  ^  對(duì)象2

使用：
將對(duì)象1和對(duì)象2轉(zhuǎn)換為二進(jìn)制，然后讓對(duì)象1和對(duì)象2的二進(jìn)制的每一位對(duì)應(yīng)進(jìn)行異或
異或：
相同為0，不同為1
例如：

50二進(jìn)制：   0  1  1  0  0  1  0
85二進(jìn)制：   1  0  1  0  1  0  1 
50 ^ 85 = 1  1  0  0  1  1  1  = 103
50 ^ 85 = 1  1  0  0  1  1  1  ^ 50  
		=1  1  0  0  1  1  1  ^
		 0  1  1  0  0  1  0
		 0  1  1  0  0  1  0

練習(xí)：實(shí)現(xiàn)兩個(gè)數(shù)的交換

（4）按位取反：~

格式：

~ 對(duì)象

使用：
將對(duì)象轉(zhuǎn)為二進(jìn)制，然后讓對(duì)象的二進(jìn)制的每一位進(jìn)行取反（0-1，1-0）

例如：

50二進(jìn)制：1  1  0  0  1  0
	~50       ：0   0  1  1  0  1

（5）左移位運(yùn)算：<<

格式：

對(duì)象  << n

使用：
將對(duì)象轉(zhuǎn)為二進(jìn)制，然后讓對(duì)象的二進(jìn)制的每一位左移n位，右補(bǔ)n個(gè)0
例如：

10的二進(jìn)制：1010
	10  << 2   #將10的二進(jìn)制左移2位，右補(bǔ)2個(gè)0

（6）右移位運(yùn)算：>>

格式：

對(duì)象  >>  n

使用：
將對(duì)象轉(zhuǎn)為二進(jìn)制，然后讓對(duì)象的二進(jìn)制的每一位右移n位，左補(bǔ)n個(gè)0，同時(shí)去掉n個(gè)位置的數(shù)據(jù)
例如：

10的二進(jìn)制：1010
	10  >> 2   ：0010    =2

十一、常用基礎(chǔ)語句

1、if條件語句

? 該語句是用于判斷條件是否成立，如果條件成立，則執(zhí)行相應(yīng)的語句塊，否則就不執(zhí)行
關(guān)鍵字：if
格式：

if  判斷條件  ：
        語句1
        語句2
        .............

注意：
（1）if語句中的關(guān)鍵字if不能省略
（2）判斷條件的結(jié)果是真（條件成立）假（條件不成立）類型（比較運(yùn)算等），判斷條件可以用括號(hào)括起來，但一般省略
（3）判斷條件后的冒號(hào)“：”不能省略
（4）if條件語句里的內(nèi)容一定要縮進(jìn)
（5）關(guān)鍵字if后面的判斷條件如果沒有用括號(hào)括起來那么if和判斷條件之間需要加上空格，反之不用加上空格
例如：

if 2>1:   #2>1條件成立
    print("2大于1")   #執(zhí)行
    print("hello world")  #執(zhí)行
print("你好，世界")

(1)if語句的嵌套

格式：

if   條件1  ：
	      語句1
	      語句2
          ......
         if   條件2   ：
                語句3
                語句4
                ......
                if       條件3  ：
                         語句5
                          .............

使用：
當(dāng)條件1滿足的前提下，執(zhí)行語句1、2，再判斷條件2，當(dāng)條件2滿足的條件下，執(zhí)行語句3、4，再判斷條件3，當(dāng)條件3滿足的情況下，執(zhí)行語句5…；如果當(dāng)條件1不滿足的情況下，之后的內(nèi)容都不執(zhí)行

例如：

num=int(input("請(qǐng)輸入一個(gè)數(shù)字："))
if num>10:
    print("%d數(shù)字是大于10的"%num)
    if num>40:
        print("%d數(shù)字是大于40的" % num)
        if num>80:
            print("%d數(shù)字是大于80的" % num)

2、if…else語句

? 判斷if后面的條件是否成立，如果成立，則執(zhí)行if語句塊里的內(nèi)容，不執(zhí)行else語句塊里的內(nèi)容；如果不成立，則執(zhí)行else語句塊里的內(nèi)容
關(guān)鍵字：if、else
格式：

if   條件  ：
	      語句1
	      語句2
	      ...........
else  :
       語句3
                  語句4
                  ............

例如：

num=int(input("請(qǐng)輸入一個(gè)年齡："))
if num>50:
    print("你太老了，快去享受退休生活")
else:
    print("你還太年輕，抓緊學(xué)習(xí)")

注意事項(xiàng)：
（1）else是和if語句成對(duì)出現(xiàn)（只要有else，必定會(huì)有if）
（2）if判斷條件后面的冒號(hào)“：”不能省略
（3）else語句后面沒有判斷條件
（4）else語句后面的冒號(hào)“：”不能省略

(1)if…else語句的嵌套

格式：

if    條件1  ：
		語句1
		if  條件2   ：
			語句5
		else :
			語句6
else：
    語句2
    if   條件3  ：
           語句3
    else：
           語句4

例如：

num=int(input("請(qǐng)輸入一個(gè)年齡："))
if num>50:
    print("你太老了，快去享受退休生活")
    if num>60:
        print("年齡也老")
        if num>75:
            print("你75歲")
    else:
        print("你還好")
else:
    print("你還太年輕，抓緊學(xué)習(xí)")
    if num>20:
        print("你才20歲")
    else:
        print("你太小了")

?

3、if …elif…elif…

格式：

if  條件1  ：
		語句1
	elif  條件2：
		語句2
	elif 條件3 ：
		語句3
	.......

解釋：
如果條件1滿足，那么就執(zhí)行語句1，如果條件2滿足，則執(zhí)行語句2，如果條件3滿足，則執(zhí)行語句3，…；在任意時(shí)刻只滿足一個(gè)條件或則是所有條件都不滿足
例如：

num=9
if 0<num<10:
    print("num是屬于0-10之間的數(shù)")
elif 10<num<20:
    print("num是屬于10-20之間的數(shù)")
elif 20<=num<30:
    print("num是屬于20-30之間的數(shù)")

4、if …elif…elif…else

格式：

if  條件1  ：
		語句1
	elif  條件2：
		語句2
	elif 條件3 ：
		語句3
	.......
	else：
		語句n

解釋：
如果條件1滿足，那么就執(zhí)行語句1，如果條件2滿足，則執(zhí)行語句2，如果條件3滿足，則執(zhí)行語句3，…；在任意時(shí)刻只滿足一個(gè)條件

注意：（1）if和elif的條件避免交叉

5、for循環(huán)

該循環(huán)一直去判斷用戶給定的條件，如果條件一直成立，那么就一直執(zhí)行for循環(huán)里的內(nèi)容，否則跳出該循環(huán)
關(guān)鍵字：for、in
格式：

	for  標(biāo)識(shí)符（變量）   in   序列  ：
		語句1
		語句2
		...............

解釋：
該循環(huán)每循環(huán)一次就從序列里面取一個(gè)值出來存入到標(biāo)識(shí)符里，如果序列是無限的，那么該for循環(huán)就是死循環(huán)
注意：
（1）關(guān)鍵字for和in不能省略
（2）序列可以是字符串、列表、元組、集合等等
（3）for語句塊里的語句注意縮進(jìn)

例如：

num="hello world"
for i in num:
    print("取的值：",i,"類型：",type(i))

(1) range函數(shù)

》》range函數(shù)
該函數(shù)的作用是生成一個(gè)有序不重復(fù)的整型數(shù)據(jù)序列
原型：

range（start，end，step）

參數(shù)：
（1）start：生成從start開始的整型數(shù)據(jù)序列，如果start參數(shù)不寫，那么默認(rèn)是從0開始生成整型數(shù)據(jù)序列
（2）end：生成一個(gè)整型的數(shù)據(jù)序列直到end-1結(jié)束
（3）step：生成的整型數(shù)據(jù)序列的步進(jìn)值（步長(zhǎng)），如果step參數(shù)不寫，默認(rèn)step的值為1

例如：

for i in range(2,8,1):
    print("取得值：",i,"類型：",type(i)) #生成2-7的序列
for i in range(8):
    print("取得值：",i,"類型：",type(i))  #生成0-7的序列

練習(xí)：#計(jì)算任意兩個(gè)數(shù)之間的數(shù)字和，100 250 ：100+101+…+250
#1、計(jì)算500-1000的和
#2、計(jì)算1-100的偶數(shù)和（奇數(shù)和）

(2)for循環(huán)的嵌套

格式：

for  標(biāo)識(shí)符1  in   序列1 ：  #序列1里面有4個(gè)數(shù)
		for 標(biāo)識(shí)符2  in 序列2 ： #序列2里面有5個(gè)數(shù)
			for 標(biāo)識(shí)符3  in  序列3：  #序列3里面有6個(gè)數(shù)
				語句3
				................. 

解釋：
第一個(gè)for循環(huán)循環(huán)1次，第二個(gè)for循環(huán)就循環(huán)5次，第三個(gè)for循環(huán)循環(huán)56次；對(duì)于上面的格式來說，總共循環(huán)45*6=120次
例如：

for i in "he":  #2次
    for j in "hel":   #3次
        for k in "hell":  #4次
            print("hello") #hello打印多少次？答案：24次	

6、while循環(huán)

? 該循環(huán)是指只要循環(huán)條件一直成立，那么就一直執(zhí)行while循環(huán)體里的內(nèi)容，稱之為死循環(huán)，只要循環(huán)條件不成立，那么就跳出該while循環(huán)
格式：

	while  條件  ：  #條件一般是由比較運(yùn)算符組成（具體根據(jù)實(shí)際情況而定）
		語句1
		......

例如：

	while  2>1  :
		print("hello world")

注意：
如果需要控制while循環(huán)的次數(shù)，就通過修改while循環(huán)后的條件（僅限此處）

7、break語句

? 該語句用于打破循環(huán)（跳出循環(huán)），只要程序一旦執(zhí)行到break語句，那么整個(gè)循環(huán)就結(jié)束，break后面的代碼也不會(huì)執(zhí)行（break語句放在循環(huán)內(nèi)）
格式：

	break   #終止循環(huán)

例如：

while  True：
		print("hello world")
		break
		print（“你好，世界！”）
	print（“世界，你好”）

8、continue語句

? 該語句用于循環(huán)中，作用是終止本次循環(huán)，只要程序一旦執(zhí)行到continue語句，那么當(dāng)次循環(huán)就結(jié)束，continue語句后面的代碼也不會(huì)執(zhí)行（continue放在循環(huán)內(nèi)）
格式：
?

continue  #終止本次循環(huán)

例如：

i=0
while i<10:
    i+=1
    if i==5:
        continue
    print("i=",i)

9、pass語句

? 該語句是一個(gè)空語句，為了增加程序的可讀性
格式：

pass   #放在程序的任意位置

十二、字符串

? Python里的字符串是基本的數(shù)據(jù)類型，是由單引號(hào)或者是雙引號(hào)括起來的數(shù)據(jù)，稱之為字符串，或者是字符序列
例如：
? “hello ” “中國(guó)” ‘world’ “hello ‘world’” "hello “hello"world”
注意：
（1）字符串里可以是中文、英文、數(shù)字等等
（2）字符串里可以包含子字符串，外層字符串的符號(hào)和內(nèi)層字符串的符號(hào)不能相同（如果外層用雙引號(hào)，那么內(nèi)層不能用雙引號(hào)，或則外層用單引號(hào)，內(nèi)層不能用單引號(hào)）

1、字符串的賦值

? 相當(dāng)于是給變量賦值一個(gè)字符串
格式：

標(biāo)識(shí)符  =  字符串

例如：

	num ="hello "
	numm="world"

注意：
（1）如果想要?jiǎng)?chuàng)建多行字符串并且將字符串賦值給標(biāo)識(shí)符，那么就將多行字符串用三個(gè)單引號(hào)或者是三個(gè)雙引號(hào)括起來
例如：

	num="""
	hello
	world
	hello world
	......
	"""

（2）python里的字符串支持空字符串或者空格字符串
例如：

	str=''
	str=" "

2、與字符串相關(guān)的函數(shù)

（1）len函數(shù)

? 該函數(shù)求字符串的長(zhǎng)度
格式：

len（“字符串”） #求字符串的長(zhǎng)度

例如：

len（“hello”）  #5

（2）replace函數(shù)

? 該函數(shù)是替換字符串中的數(shù)據(jù)
格式：

字符串 . replace（舊的字符串，新的字符串）

例如：

	str="hello"   #將“hello”中的"h"替換為“w”
	str.replace（“h”，“w”）

3、字符串的復(fù)制

? 是指將字符串復(fù)制n份
符號(hào)：*
格式：
? 字符串 * n
解釋：
? 將字符串復(fù)制n份
例如：
? str=“hello”
? str*3 #將“hello”復(fù)制3份

4、字符串的訪問

? 是指用戶一般需要去訪問或者是獲取字符串里的字符
字符串的編碼：系統(tǒng)會(huì)自動(dòng)給字符串編一個(gè)下標(biāo)碼（類似于數(shù)組）

（1）正向編碼

? 字符串的下標(biāo)是從左往右依次開始從0遞增進(jìn)行編碼
? “ h e l l o w o r l d”
----> 0 1 2 3 4 5 6 7 8 9

（2）反向編碼

? 字符串的下標(biāo)是從右往左依次開始從-1遞減進(jìn)行編碼
? “ h e l l o w o r l d”
? -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 <-------

字符串的訪問：
（1）正向訪問
正向訪問是指通過字符串的正向下標(biāo)對(duì)字符串里的內(nèi)容進(jìn)行訪問
符號(hào)：[]
格式：
字符串 [ 正向下標(biāo) ] #訪問字符串中正向下標(biāo)對(duì)應(yīng)的字符
例如：
str=“hello world”
str [5] #訪問str中下標(biāo)為5對(duì)應(yīng)的元素
str [3] #訪問str中下標(biāo)為3對(duì)應(yīng)的元素
…
（2）反向訪問
反向訪問是指通過字符串的反向下標(biāo)對(duì)字符串里的內(nèi)容進(jìn)行訪問
符號(hào)：[]
格式：
字符串 [ 反向下標(biāo) ] #訪問字符串中反向下標(biāo)對(duì)應(yīng)的字符
例如：
str=“hello world”
str [-6] #訪問str中下標(biāo)為-6對(duì)應(yīng)的元素：’ ’
str [-3] #訪問str中下標(biāo)為-3對(duì)應(yīng)的元素：“r”
…

5、字符串的截取或切片

? 是指從字符串里截取一段子字符串出來

（1）正向截取

（包頭（start）不包尾（end））
前提是字符串的下標(biāo)編碼是正向編碼
符號(hào)：[]
格式：
[start : end : step]
參數(shù)：
a、start：字符串的截取從start位置開始從左往右截取，如果start參數(shù)不寫，那么默認(rèn)是從下表為0開始進(jìn)行截取
b、end：字符串的截取直到end-1結(jié)束，如果end不寫，默認(rèn)是截取到最后一個(gè)數(shù)據(jù)（包含最后一個(gè)數(shù)據(jù)）
c、step：字符串截取的步長(zhǎng)，注意，step的絕對(duì)值表示截取的步長(zhǎng)，step的正負(fù)值表示截取的方向，如果step不寫，默認(rèn)截取的步長(zhǎng)為1，截取的方向從左往右
例如：
str=“hello world”
str[2:4] #ll
str[0:5] #hello
str[:5] #hello
str[1:8:3] #eoo
str[2:0:-1] #截取le #多去練一練
str[::-1] #特殊情況，字符串的反轉(zhuǎn)
str[::1]
str[::]
…

（2）反向截取

（包頭（start）不包尾（end））
前提是字符串的下標(biāo)編碼是反向編碼
符號(hào)：[]
格式：
[start : end : step]
參數(shù)：
a、start：字符串的截取從start位置開始從左往右截取，如果start參數(shù)不寫，那么默認(rèn)是從左邊第一個(gè)數(shù)據(jù)開始進(jìn)行截取
b、end：字符串的截取直到end-1結(jié)束，如果end不寫，默認(rèn)是截取到最后一個(gè)數(shù)據(jù)（包含最后一個(gè)數(shù)據(jù)）
c、step：字符串截取的步長(zhǎng)，注意，step的絕對(duì)值表示截取的步長(zhǎng)，step的正負(fù)值表示截取的方向，如果step不寫，默認(rèn)截取的步長(zhǎng)為1，截取的方向從左往右
例如：
str=“hello world”
str[-11:-9] #he
str[:-9] #he
str[-9:] #“l(fā)lo world”
str[::] #“hello world”
str[-3:-8:-1] # “row o” 特殊情況

6、字符串的拼接

（1）使用加號(hào)“+”來實(shí)現(xiàn)兩個(gè)字符串的拼接
格式：
字符串1 + 字符串2
例如：
str1=“hello”
str2=“world”
str=str1+str2 #“helloworld”
（2）兩個(gè)字符串直接進(jìn)行拼接
格式：
字符串1字符串2
例如：
str1=“hello”
str2=“world”
str=str1str2 #報(bào)錯(cuò)，str1str2標(biāo)識(shí)符沒有被定義
str=“hello”“world” #“helloworld”

十三、列表：list

? 列表也是Python里內(nèi)置的一種基本數(shù)據(jù)類型（列表也是一種序列），它是用于存儲(chǔ)數(shù)據(jù)（與數(shù)組類似），并且數(shù)據(jù)的類型可以不相同（與數(shù)組的區(qū)別）
符號(hào)：[]
格式：
? [數(shù)據(jù)1，數(shù)據(jù)2，[數(shù)據(jù)3，數(shù)據(jù)4,…]]
例如：
? [1，2，3，4] [1,1.2,1.2344] [1,1,566,“hello”] [3,“hello”,“你好”,[1,2,4]]

總結(jié)：
（1）列表中的數(shù)據(jù)元素的類型可以是相同的，也可以是不同的
（2）列表中的元素之間是用逗號(hào)隔開“,”，注意逗號(hào)是英文格式的
（3）列表支持空列表：list=[]

1、列表的初始化

格式：
標(biāo)識(shí)符 = 列表
例如：
list=[1，2，3，4]

2、列表與數(shù)組的區(qū)別

相同點(diǎn)：
（1）數(shù)組和列表都是用于存儲(chǔ)數(shù)據(jù)
（2）數(shù)組和列表中的元素都是以逗號(hào)隔開
（3）數(shù)組和列表都有下標(biāo)，并且下標(biāo)是正向編碼

不同點(diǎn)：
（1）數(shù)組要求存的數(shù)據(jù)的類型必須一致
（2）數(shù)組只能正向編碼，而列表可以反向編碼
（3）數(shù)組一旦聲明大小就固定，而列表聲明了之后，大小不固定

3、列表的訪問

? 與字符串一樣，可以訪問（獲取）列表中的元素
正向編碼：
? 列表中的元素從左往右從0依次開始遞增編碼
反向編碼：
? 列表中的元素從右往左從-1依次開始遞減編碼
列表的訪問：
（1）正向訪問
符號(hào)：[]
格式：
? 列表 [ 下標(biāo) ]
例如：
? list=[ 1 , 2 , 3 , 4 , 5 , 6]
----> 0 1 2 3 4 5
? list[3] #4
? …
（2）反向訪問
符號(hào)：[]
格式：
? 列表 [ 下標(biāo) ]
例如：
? list=[“hello” , “world” , “hello world”]
? -3 -2 -1 <--------------
? list[-1] #“hello world”

4、列表的截取或切片

（1）正向截取（包頭不包尾）
注意：正向截取的下標(biāo)編碼是正向編碼
格式：
[start : end : step]
參數(shù)：
a、start：列表的截取從start開始進(jìn)行截取，如果start不寫，默認(rèn)是從下標(biāo)為0的元素開始進(jìn)行截取
b、end：列表的截取一直到end-1結(jié)束，如果end不寫，默認(rèn)是截取到最后一個(gè)元素
c、step：截取的步長(zhǎng)，絕對(duì)值表示步長(zhǎng)，正負(fù)值代表方向，如果step不寫，默認(rèn)截取的步長(zhǎng)是1，并且截取的方向是從左往右
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list[0:3:1] #[“hello” , “world” , “你好”]
list[:3:1] #[“hello” , “world” , “你好”]
list[0::1] #[“hello” , “world” , “你好” , “世界” ， “1234”]
list[0:3] #[“hello” , “world” , “你好”]
list[::] #[“hello” , “world” , “你好” , “世界” ， “1234”]
…

（2）反向截?。ò^不包尾）
注意：反向截取的下標(biāo)編碼是反向編碼
格式：
[start : end : step]
參數(shù)：
a、start：列表的截取從start開始進(jìn)行截取，如果start不寫，默認(rèn)是從左邊的的第一個(gè)元素開始進(jìn)行截取
b、end：列表的截取一直到end-1結(jié)束，如果end不寫，默認(rèn)是截取到最后一個(gè)元素
c、step：截取的步長(zhǎng)，絕對(duì)值表示步長(zhǎng)，正負(fù)值代表方向，如果step不寫，默認(rèn)截取的步長(zhǎng)是1，并且截取的方向是從左往右
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list[-4??1] #[“world” , “你好” , “世界”]
list[??1] #[“hello” , “world” , “你好” , “世界” ]
list[-4::1] #[ “world” , “你好” , “世界” ， “1234”]
…

5、列表的增、刪、改、查

（1）列表的增加

a、append函數(shù)
向指定列表中添加指定的數(shù)據(jù)元素，并且數(shù)據(jù)元素是單個(gè)進(jìn)行添加，并且是以追加的形式添加
格式：
列表 . append（數(shù)據(jù)元素） #將數(shù)據(jù)元素添加到列表的尾部
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.append（“今天是星期一”）#將今天是星期一”添加到list的尾部
list.append（15） #將15添加到list的尾部
…
b、extend函數(shù)
向指定列表中添加指定的數(shù)據(jù)元素，數(shù)據(jù)元素是多個(gè)進(jìn)行添加，并且是以追加的形式添加
格式：
列表 . extend（列表類型） #將列表類型的數(shù)據(jù)添加到列表的尾部
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.extend（[“123456”,“654321”]）
c、insert函數(shù)
向指定列表中指定的位置插入指定的數(shù)據(jù)元素，原來該位置的元素自動(dòng)往后挪一位
格式：
列表 . insert（下標(biāo) ， 數(shù)據(jù)） #向列表中的下標(biāo)位置插入數(shù)據(jù)
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.insert(0,“boss”) #將boss插入到list的第0個(gè)位置

（2）列表的刪除

a、pop函數(shù)
pop函數(shù)刪除列表中頂部的元素
格式：
列表 . pop（） #刪除列表中的頂部元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.pop() #刪除“1234”
b、pop（下標(biāo)）函數(shù)
pop（下標(biāo)）函數(shù)刪除列表中指定下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素
格式：
列表 . pop（下標(biāo)） #刪除列表中下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.pop(1) #刪除下標(biāo)為1對(duì)應(yīng)的數(shù)據(jù)元素
c、remove函數(shù)
該函數(shù)刪除列表中指定的數(shù)據(jù)元素
格式：
列表 . remove（列表中的數(shù)據(jù)元素） #刪除列表中指定的數(shù)據(jù)元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.remove（“world”） #將“world”從list中移除掉
d、del關(guān)鍵字
該關(guān)鍵字刪除列表及列表中的所有元素
格式：
del 列表 #刪除列表及列表中的數(shù)據(jù)元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
del list

e、clear函數(shù)

清空列表中的數(shù)據(jù)元素

（3）列表的修改

? 可以修改列表中指定下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素
符號(hào)：[]
格式：
? 列表 [ 下標(biāo) ] = 新的數(shù)據(jù)
例如：
? list=[“hello” , “world” , “你好” , “世界” ， “1234”]
? list [1]=“boss” #將list中下標(biāo)為1的數(shù)據(jù)元素更改為“boss”

（4）列表的查詢

? 可以查詢列表中數(shù)據(jù)元素的個(gè)數(shù)、相同數(shù)據(jù)元素出現(xiàn)的個(gè)數(shù)、查詢下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素、查詢數(shù)據(jù)元素對(duì)應(yīng)的下標(biāo)等等
a、len函數(shù)
? len函數(shù)可以查詢列表中元素的個(gè)數(shù)
格式：
? len（列表）
例如：
? list=[“hello” , “world” , “你好” , “世界” ， “1234”]
? len(list) #5
b、count（）函數(shù)
? 該函數(shù)可以查詢列表中相同元素出現(xiàn)的個(gè)數(shù)
格式：
? 列表 . count（數(shù)據(jù)）
例如：
? list=[“hello” , “world” , “你好” , “世界” ， “1234”]
? list.count（“hello”） #查詢“hello”在list中出現(xiàn)的次數(shù)
c、查詢下表對(duì)應(yīng)的數(shù)據(jù)元素
格式：
? 列表 [下標(biāo)] #查詢到下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素
例如：
? list=[“hello” , “world” , “你好” , “世界” ， “1234”]
? print（list[0]） #查詢到下標(biāo)為0對(duì)應(yīng)的數(shù)據(jù)元素：“hello”

d、index函數(shù)
該函數(shù)可以查詢列表中數(shù)據(jù)元素對(duì)應(yīng)的下標(biāo)
格式：
列表 . index（數(shù)據(jù)）
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.index（“world”） #查詢list中“world對(duì)應(yīng)的下標(biāo)”

6、列表的拼接

符號(hào)：+
格式：
列表1 + 列表2
例如：
list1=[10,20]
list2=[30,40]
list=list1+list2

7、列表的賦值

符號(hào)：*
格式：
列表 * n
解釋：
將列表復(fù)制n份
例如：
list=[10]
list * 3 #將list復(fù)制3份

十四、元組：tuple

? 元組也是Python里提供的一種基本數(shù)據(jù)類型，類似于列表，可以存儲(chǔ)數(shù)據(jù)，數(shù)據(jù)的類型也可以不一致

1、元組的初始化

符號(hào)： ( )
格式：
標(biāo)識(shí)符 = （數(shù)據(jù)1 ， 數(shù)據(jù)2 ，…，）
例如：
tuple = (10 ， 20 ， “hello”，“world”，)

注意：
（1）元組的聲明是用括號(hào)“()”進(jìn)行聲明
（2）元組中的數(shù)據(jù)元素之間是用逗號(hào)“,”
（3）元組中的數(shù)據(jù)元素的類型可以不一致
（4）元組一旦聲明，那么就不能隨意更改元組中的內(nèi)容，可以看成是一個(gè)常量
（5）元組里的數(shù)據(jù)后面以逗號(hào)結(jié)尾（注，如果是單個(gè)數(shù)據(jù)必須加逗號(hào)才表示是元組，如果是多個(gè)數(shù)據(jù)，逗號(hào)可以省略）

2、元組的訪問

（1）正向編碼：元組的下標(biāo)從左往右依次從0開始遞增進(jìn)行編碼
例如：
(10 ， 20 ， “hello”，“world”)
0 1 2 3
（2）反向編碼：元組的下標(biāo)從右往左依次從-1開始遞減進(jìn)行編碼
例如：
(10 ， 20 ， “hello”，“world”)

 -4       -3            -2                -1

元組的訪問：
（3）正向訪問
符號(hào)：[]
格式：
元組 [ 下標(biāo) ] #訪問到下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素
例如：
tuple= (10 ， 20 ， “hello”，“world”)
tuple [ 2 ]

（4）反向訪問
符號(hào)：[]
格式：
元組 [ 下標(biāo) ] #訪問到下標(biāo)對(duì)應(yīng)的數(shù)據(jù)元素
例如：
tuple= (10 ， 20 ， “hello”，“world”)
tuple [ -2 ]

3、元組的截取或切片

（參考列表或字符串）
（1）正向截取（包頭不包尾）
注意：正向截取的下標(biāo)編碼是正向編碼
格式：
[start : end : step]
參數(shù)：
a、start：列表的截取從start開始進(jìn)行截取，如果start不寫，默認(rèn)是從下標(biāo)為0的元素開始進(jìn)行截取
b、end：列表的截取一直到end-1結(jié)束，如果end不寫，默認(rèn)是截取到最后一個(gè)元素
c、step：截取的步長(zhǎng)，絕對(duì)值表示步長(zhǎng)，正負(fù)值代表方向，如果step不寫，默認(rèn)截取的步長(zhǎng)是1，并且截取的方向是從左往右
例如：
list=（“hello” , “world” , “你好” , “世界” ， “1234”）
list[0:3:1] #[“hello” , “world” , “你好”]
list[:3:1] #[“hello” , “world” , “你好”]
list[0::1] #[“hello” , “world” , “你好” , “世界” ， “1234”]
list[0:3] #[“hello” , “world” , “你好”]
list[::] #[“hello” , “world” , “你好” , “世界” ， “1234”]
…

（2）反向截取（包頭不包尾）
注意：反向截取的下標(biāo)編碼是反向編碼
格式：
[start : end : step]
參數(shù)：
a、start：列表的截取從start開始進(jìn)行截取，如果start不寫，默認(rèn)是從左邊的的第一個(gè)元素開始進(jìn)行截取
b、end：列表的截取一直到end-1結(jié)束，如果end不寫，默認(rèn)是截取到最后一個(gè)元素
c、step：截取的步長(zhǎng)，絕對(duì)值表示步長(zhǎng)，正負(fù)值代表方向，如果step不寫，默認(rèn)截取的步長(zhǎng)是1，并且截取的方向是從左往右
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list[-4??1] #[“world” , “你好” , “世界”]
list[??1] #[“hello” , “world” , “你好” , “世界” ]
list[-4::1] #[ “world” , “你好” , “世界” ， “1234”]
…

4、元組涉及的函數(shù)

（1）len函數(shù)

? 該函數(shù)求元組的長(zhǎng)度
格式：
? len（元組）
例如：
? tuple=(10,20)
? len(tuple)

（2）max函數(shù)

? 該函數(shù)求元組中的數(shù)據(jù)元素的最大值
格式：
? max（元組）
例如：
? tuple=(10,20)
? max（tuple） #20

（3）min函數(shù)

? 該函數(shù)求元組中的數(shù)據(jù)元素的最小值
格式：
? min（元組）
例如：
? tuple=(10,20)
? min（tuple） #10

5、元組的刪除

關(guān)鍵字：del
格式：
del 元組
例如：
tuple=(10,20)
del tuple

6、元組的拼接

符號(hào)：+
格式：
元組1 + 元組2
例如：
tuple1=(10)
tuple2=(20)
tuple1+tupl2
注：
元組里的數(shù)據(jù)如果是單個(gè)數(shù)字，使用“+”，表示將元組里的內(nèi)容進(jìn)行相加，如果是多個(gè)數(shù)據(jù)，那么就實(shí)現(xiàn)兩個(gè)元組的拼接

十五、字典or詞典：dict

? 字典也是Python里的一種基本數(shù)據(jù)結(jié)構(gòu)，它也是用于存儲(chǔ)數(shù)據(jù)，類似于元組或者是列表，但是存儲(chǔ)的方式有不同，數(shù)據(jù)在字典里的存儲(chǔ)方式是以鍵值對(duì)的形式存儲(chǔ)

1、字典的初始化

符號(hào)：{}
格式：
標(biāo)識(shí)符 = { 鍵1 ：值1 ，鍵2：值2 ，鍵3：值3 ,… }
例如：
dict={“key1” : 1 , “key2” : 2 , “key3” : 3 } #可以
dict={(10,20) : 1 , (20,“10”) : 2 , (4 , 8) : 3} #可以
dict={[10,20] : 1 , [20 ,“10”] : 3 , [4 ,8] :3} #不可以
dict={0 : 1 , 1 : 2 , 2 :3} #可以

注意：
（1）鍵值對(duì)中的鍵必須是不可變的數(shù)據(jù)，如常量、元組等等
（2）鍵值對(duì)中的鍵是唯一標(biāo)識(shí)用戶所存儲(chǔ)的數(shù)據(jù)，意思就是鍵值對(duì)中的鍵不能與其它鍵相同（每個(gè)鍵都是獨(dú)立的并且不相同的）
（3）用戶存儲(chǔ)的數(shù)據(jù)在字典中必須以鍵值對(duì)的形式存在（鍵值對(duì)成對(duì)出現(xiàn)）
（4）鍵值對(duì)之間用逗號(hào)“,”隔開
（5）字典中的鍵值對(duì)中的鍵與值之間使用冒號(hào)“：”隔開
（6）字典中存儲(chǔ)的值可以是任意類型的數(shù)據(jù)

2、字典訪問

? 訪問字典里存儲(chǔ)的數(shù)據(jù)
符號(hào)：[]
格式：
? 字典 [ 鍵 ] #訪問字典里鍵對(duì)應(yīng)的值
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict[“key2”] #2

3、字典的增加、刪除、修改、查詢

（1）增加

? 向字典里增加新的內(nèi)容
符號(hào)：[]
格式：
? 字典 [新的鍵] = 新的值
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict[“key4”] = 4

（2）刪除

? 刪除字典中的數(shù)據(jù)或者是刪除整個(gè)字典
a、關(guān)鍵字：del
格式：
? del 字典 #刪除整個(gè)字典
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? del dict
b、關(guān)鍵字：del
格式：
? del 字典[鍵] #刪除字典中鍵對(duì)應(yīng)的值
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? del dict[“key1”]

（3）修改

? 可以修改鍵值對(duì)中鍵對(duì)應(yīng)的值
格式：
? 字典 [已經(jīng)存在的鍵] = 更新的值 #將字典中之前鍵對(duì)應(yīng)的值更新為新的值
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict[“key2”] = “hello world” #將字典中2更新為“hello world”
（4）查詢
? 可以查詢字典中鍵對(duì)應(yīng)的值
格式：
? 字典 [已經(jīng)存在的鍵]
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict[“key2”]

4、字典常用的函數(shù)

（1）values函數(shù)

? 該函數(shù)用于獲取字典中所有的鍵對(duì)應(yīng)的值
格式：
? 字典 . values（）
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict . values（）

（2）keys函數(shù)

? 該函數(shù)用于獲取字典中所有的鍵
格式：
? 字典 . keys（）
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict.keys（）

（3）items函數(shù)

? 該函數(shù)用于獲取字典中所有的鍵值對(duì)
格式：
? 字典 . items（）
例如：
? dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
? dict.items（）

十六、函數(shù)

? 函數(shù)是對(duì)實(shí)際的一些功能進(jìn)行封裝，封裝的目的是保護(hù)數(shù)據(jù)的安全和為了使用簡(jiǎn)便，它只向用戶暴露接口，不暴露具體的實(shí)現(xiàn)細(xì)節(jié)

1、函數(shù)的聲明

關(guān)鍵字：def
格式：

def   函數(shù)名（參數(shù)1 ，參數(shù)2 ，......）： #注：參數(shù)可有可無
		字符串  #該字符串也是可有可無
		代碼
		....
		return   #return也是可有可無

例如：

def    function   （）：
		“該函數(shù)用于實(shí)現(xiàn)字符串的拼接”
		print（“hello world”）
		return 0    #該函數(shù)返回0

注意：
（1）關(guān)鍵字def不能省略，它用于聲明函數(shù)
（2）函數(shù)名就是標(biāo)識(shí)符，滿足python的標(biāo)識(shí)符規(guī)定
（3）函數(shù)名后面的括號(hào)里參數(shù)可有可無，根據(jù)自身實(shí)際情況而定
（4）函數(shù)參數(shù)括號(hào)后面的冒號(hào)“：”
（5）函數(shù)體內(nèi)部的內(nèi)容需要進(jìn)行縮進(jìn)
（6）函數(shù)體內(nèi)部第一行代碼是字符串，它可有可無，目的是為了提示
（7）函數(shù)體內(nèi)部的關(guān)鍵字return的作用是返回，使用格式：return 內(nèi)容

2、函數(shù)的參數(shù)

（1）函數(shù)傳參的順序不變，根據(jù)函數(shù)內(nèi)部參數(shù)的實(shí)現(xiàn)而定—必備參數(shù)

def   function（x , y ）：
	num=x+10
	str=y+"hello"

（2）函數(shù)傳參是以關(guān)鍵字形式，函數(shù)傳參的順序可以變化

def   function（x , y ）:
	num=x+10
	str=y+"hello"

（3）函數(shù)傳參時(shí)默認(rèn)值傳參

def   function（x, y=“world” ）:
	num=x+10
	str=y+"hello"

3、函數(shù)的調(diào)用

格式：
函數(shù)名 （傳遞實(shí)參） #如果函數(shù)帶了參數(shù)就需要傳遞實(shí)參，如沒有帶，那就不需要傳遞
例如：
（1）

def   function（x , y ）：  #按順序傳參
    num=x+10
    str=y+"hello"
function（10，“world”）	

（2）

def   function（x , y ）：  #按關(guān)鍵字傳參
    num=x+10
    str=y+"hello"
function（y=“world”，x=10）

（3）

def   function（x , y=“world” ）:  #注：帶默認(rèn)值的參數(shù)必須放在不帶默認(rèn)值參數(shù)的后面
    num=x+10   
    str=y+"hello"
function（y="world"）

4、函數(shù)嵌套

格式：
def function1（參數(shù)）：
代碼
…
def function2（參數(shù)）
代碼
…
function2（實(shí)參）
調(diào)用：
function1（實(shí)參）

十七、模塊和包

1、模塊

? 模塊在python里是指一個(gè)python文件（python文件=模塊） ，模塊里可以放置函數(shù)、全局變量、類等等

（1）模塊的導(dǎo)入

? 是指一個(gè)模塊使用另外一個(gè)模塊里的內(nèi)容
關(guān)鍵字：import
格式：
? import 模塊名
例如：
? hello.py #模塊名：hello
? import hello
注：導(dǎo)入模塊時(shí)，同時(shí)取別名
關(guān)鍵字：import、as
格式：
? import 模塊 as 別名
例如：
? hello.py
? import hello as he

（2）使用其他模塊里的內(nèi)容

a、是在import導(dǎo)入其他模塊的前提下，再使用其他模塊里的內(nèi)容
格式：
import 模塊名
模塊名 . 功能或別名 . 功能
例如：
hello.py #模塊名：hello
import hello
hello . num #使用其他模塊里的內(nèi)容

b、導(dǎo)入其他模塊里指定的內(nèi)容
關(guān)鍵字：from、import
格式：
from 模塊 import 功能
例如：
hello.py #模塊名：hello
from hello import num #從hello模塊里導(dǎo)入變量num到當(dāng)前文件
print（“num=”,num）
c、一次性導(dǎo)入其他模塊里的所有內(nèi)容
關(guān)鍵字：from、import
符號(hào)：*
格式：
from 模塊 import *
例如：
hello.py #模塊名：hello
from hello import *
print（“num=”,num）
function（）

2、包

? 包在python里是一個(gè)目錄，包是包含多個(gè)模塊，每一個(gè)包里包含一個(gè)特殊文件，該文件是__init__.py

（1）包的導(dǎo)入

關(guān)鍵字：import
格式：
import 包名 #包名是文件名

注：導(dǎo)入包時(shí)，同時(shí)取別名
關(guān)鍵字：import、as
格式：
import 包 as 別名
例如：
hello #包
import hello as he

（2）使用包里的模塊里的內(nèi)容

格式：

import  包名
包名  .   模塊名  .   功能

例如：

zhang   #包zhang
hello.py   #包zhang里的模塊
import zhang
zhang . hello .num   #使用包zhang里的模塊hello里的變量num（前提條件是注里的內(nèi)容）

注：
需要在__init__.py文件里導(dǎo)入該包里用戶需要使用的模塊
格式：

from  .   import  模塊名

十八、文件操作（I/O技術(shù)）

對(duì)于一個(gè)完整的程序一般都包括數(shù)據(jù)的存儲(chǔ)和讀取。從外部存儲(chǔ)介質(zhì)(硬盤、光盤、軟盤、U盤)讀取數(shù)據(jù)，或?qū)⒊绦蛑?結(jié)果）的數(shù)據(jù)存儲(chǔ)到介質(zhì)(文件)。
文件:按照數(shù)據(jù)的組織形式：

1.文本文件

文本文件存儲(chǔ)的普通”字符"

2.二進(jìn)制文件

二進(jìn)制文件把數(shù)據(jù)內(nèi)容用"字節(jié)"進(jìn)行存儲(chǔ)，無法使用記事本打開，必須使用專用的軟件解碼。常見的有:|MP4、MP3、JPG圖片、exe

3、文件操作相關(guān)模塊

Python標(biāo)準(zhǔn)庫中，提供如下模塊進(jìn)行文件操作：

名稱		 說明
io模塊 ：文件的輸入和輸出操作 input、output
os模塊 ：基本的操作系統(tǒng)功能，包括文件操作
glob模塊 ：查找符合特定規(guī)則的文件路徑名
filecmp模塊： 用于文件的比較

名稱 		說明
cvs模塊： 用于cvs文件處理
xml包 ：用于xml數(shù)據(jù)處理
bz2、gzip、zipfile、zlib、tarlib：用于處理壓縮和解壓文件(分別對(duì)應(yīng)不同的算法)

（1）創(chuàng)建文件對(duì)象

open()函數(shù)用于創(chuàng)建文件對(duì)象，表示—個(gè)在程序中要操作的文件
基本語法格式:

open(文件名[打開方式])

文件名可以是全路徑:表示操作指定目錄下的文件。如:C:\Usersly\Desktop\test.txt。為了減少\的輸入，可以使用原始字符串來示:r"C:\Usersly Desktop\test.txt"
打開方式:

模式：描述
b：二進(jìn)制binary模型，二進(jìn)制文件
r：讀read模式
w：寫write模式。如果文件不存在則創(chuàng)建，如果文件存在，則重新寫內(nèi)容(清空內(nèi)容)
a：寫append模式。文件不存在則創(chuàng)建，如果存在，則在文件末尾追加內(nèi)容
+：在已有的選擇中添加額外的讀、寫。

open()函數(shù)存在返回值，返回值就是打開的文件對(duì)象文件對(duì)象變量名= open(文件路徑，打開方式)

（2）文本文件的寫入

基本的文件寫入操作，文件的寫入一般有三個(gè)步驟:①創(chuàng)建文件對(duì)象(打開文件)，②寫入數(shù)據(jù)，③關(guān)閉文件對(duì)象(關(guān)閉文件)。
write(寫入的內(nèi)容)
用法：

文件對(duì)象.write（內(nèi)容）

writelines(要寫入列表)
用法：

文件對(duì)象.writelines(要寫入列表)

（3）文本文件的讀取

read()函數(shù)，從文本文件中讀取數(shù)據(jù)
read([size])從文件中讀取size個(gè)字符，如果沒有size參數(shù)，則表示讀取整個(gè)文件，返回值就是讀取的字符串。當(dāng)已經(jīng)讀取到文件結(jié)束，再次進(jìn)行讀取時(shí)，返回值為空字符串（讀取到文件末尾，會(huì)返回空字符串）

==readline()==從文件中讀取一行內(nèi)容，返回值就是讀取的數(shù)據(jù)。當(dāng)已經(jīng)讀取到文件結(jié)束，再次進(jìn)行讀取時(shí)，返回值為空字符串（讀取到文件末尾，會(huì)返回空字符串）==readlines()==從文件中讀取每一行，每一行作為一個(gè)字符串存儲(chǔ)列表中，返回該列表。

（4）關(guān)閉文件對(duì)象

關(guān)閉打開的文件close)函數(shù)關(guān)閉文件用法:

文件對(duì)象.close()

對(duì)于文本文件，由于有不同的編碼格式，所以經(jīng)常操作時(shí)會(huì)碰到
亂碼問題。 編碼： ASCII：用7位表示，表示128個(gè)字符
ISO8859-1：又叫做Latin-1，8位字符集，兼容ASCII編碼

GB2312：漢字編碼字符集，兼容ISO8859-1編碼 GBK：漢字內(nèi)碼
擴(kuò)展規(guī)范，擴(kuò)展GB2312，在它的基礎(chǔ)上又增加了更多的漢字
GB18030：它采用單字節(jié)、雙字節(jié)、四字節(jié) UTF-8：不定長(zhǎng)編
碼，每一個(gè)字符長(zhǎng)度1-4字節(jié)不等

（5）文件對(duì)象的常用屬性和方法

屬性 ：說明
name ：返回文件的名字
mode ：返回文件的打開模式
closed ：若文件被關(guān)閉則返回True

常用方法

方法 ：說明
tell()： 返回文件當(dāng)前操作位置
seek()： 把文件當(dāng)前操作位置移動(dòng)到新的位置
truncate()： 不論當(dāng)前位置在哪，只留下當(dāng)前位置指定大小的內(nèi)容，其余全部刪除

seek(偏移大小，基準(zhǔn)位置) 偏移大小： 移動(dòng)多少字節(jié)字符，負(fù)數(shù)向前，正數(shù)向后 基準(zhǔn)位置： 0：從文件開始位置計(jì)算 1：從當(dāng)前位置開始計(jì)算 2：從文件末尾位置開始計(jì)算os和os.path模塊 os模塊可以幫助我們直接對(duì)操作系統(tǒng)進(jìn)行操作，執(zhí)行程序、命令、直接操作文件、目錄等。

函數(shù)： 作用
remove(文件路徑)： 刪除指定的文件
rename(原文件名,目標(biāo)文件名) ：重命名文件或目錄
stat(文件路徑) ：返回文件的所有屬性
listdir(目錄) ：返回目錄下的文件和目錄的列表
rmdir(目錄) ：刪除目錄
mkdir(目錄) ：創(chuàng)建目錄

os.path模塊
os.path模塊提供了目錄相關(guān)的操作

方法：			描述:
isdir(路徑)：判斷路徑是否是目錄
isfile(路徑)：判斷路徑是否是文件
exists(文件路徑)：判斷路徑的文件是否存在
getsize():返回文件大小
getatime():文件訪問時(shí)間
getctime():文件創(chuàng)建時(shí)間
getmtime():文件修改時(shí)間
例如：(os.path.getatime)
isabs(路徑):判斷路徑是否是絕對(duì)路徑

4、CSV文件操作

csv是逗號(hào)分隔符文本格式，常用于數(shù)據(jù)交換、Excel文件和數(shù)據(jù)庫數(shù)據(jù)的導(dǎo)入和導(dǎo)出。

csv文件：
值沒有類型，所有值都是字符串
沒有多個(gè)工作表
在python的標(biāo)準(zhǔn)庫模塊csv提供了讀取和寫入csv格式的對(duì)象

csv.read對(duì)象
#讀取csv文件內(nèi)容
import csv

#打開文件
a = open("C:/Users/y/Desktop/1.csv")
#創(chuàng)建csv對(duì)象讀取文件
csv_a = csv.reader(a)#csv讀取對(duì)象要操作 a 文件，返回值就是csv對(duì)象，是包含了所有數(shù)據(jù)的列表，每一行就是一個(gè)元素

for row in csv_a :
    print(row)

csv.writer對(duì)象
#往csv文件添加（寫入）數(shù)據(jù)
import csv

f = open("C:/Users/y/Desktop/1.csv","w")

csv_a = csv.writer(f)#創(chuàng)建csv對(duì)象，操作 f 文件
csv_a.writerow(["姓名","地址","聯(lián)系方式"])

csv_a.writerows([["張三","xxxx","無"],["李四","無","xxxxxx"]])

5、壓縮與解壓

shutil模塊是python中提供的，主要用來文件和文件夾的拷貝、移動(dòng)、刪除等，也可以用于文件和文件夾的壓縮、解壓操作文件拷貝 copyfile(源文件,目標(biāo)文件)

文件拷貝 目錄拷貝copytree(源目錄,目標(biāo)目錄–不存在)

壓縮： make_archive(壓縮的目標(biāo)文件名，壓縮方式，壓縮源文件目錄)

import shutil
import zipfile

#shutil.copyfile("C:/Users/y/Desktop/1.txt","3.txt")

#shutil.copytree("C:/Users/y/Desktop/one","one")

#shutil.make_archive("C:/Users/y/Desktop/ok","zip","one")

#使用zipfile壓縮
z = zipfile.ZipFile("C:/Users/y/Desktop/a.zip","w")#打開壓縮文件，如果壓縮文件不存在就創(chuàng)建

z.write("1.txt")
z.write("2.txt")
z.write("3.txt")

z.close()

解壓：

import zipfile

z = zipfile.ZipFile("C:/Users/y/Desktop/a.zip","r")

z.extractall("C:/Users/y/Desktop")#設(shè)置解壓文件
z.close()

總結(jié)

好好學(xué)習(xí)，天天向上。文章來源地址http://www.zghlxwxcb.cn/news/detail-428945.html

到了這里，關(guān)于Python入門到高手進(jìn)階|這一篇就夠了（3萬字|超詳細(xì)）的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！