1 、數據類型

　　數字（整形，長整形，浮點型，復數）

　　字符串

　　字節串：在介紹字符編碼時介紹字節bytes類型

　　列表

　　元組

　　字典

　　集合

2、數字

整型與浮點型

#整型int
　　作用：年紀，等級，身份證號，qq號等整型數字相關
　　定義：
　　　　age=10 #本質age=int(10)

#浮點型float
　　作用：薪資，身高，體重，體質參數等浮點數相關

    salary=3000.3 #本質salary=float(3000.3)

#二進制，十進制，八進制，十六進制 

3、

字符串

#作用：名字，性別，國籍，地址等描述信息

#定義：在單引號\雙引號\三引號內，由一串字符組成
name=‘egon‘

#優先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顧頭不顧尾，步長)
#3、長度len
#4、成員運算in和not in

#5、移除空白strip
#6、切分split
#7、循環
 

　　需要掌握的操作

#1、strip,lstrip,rstrip 
#2、lower,upper
#3、startswith,endswith
#4、format的三種玩法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit

#strip
name=‘*egon**‘
print(name.strip(‘*‘))去*
print(name.lstrip(‘*‘))去左邊*
print(name.rstrip(‘*‘))去右邊*

#lower,upper
name=‘egon‘
print(name.lower())把字符串變成全小寫
print(name.upper())把字符串變成全大寫

#startswith,endswith
name=‘alex_SB‘
print(name.endswith(‘SB‘))#判斷是不是以SB結尾的print一個返回值True或False
print(name.startswith(‘alex‘))#判斷是不是以alex開始的print一個返回值True或False
 


#format的三種玩法

res=‘{} {} {}‘.format(‘egon‘,18,‘male‘) #按照位置一個對一個
print(res)
egon 18 male
res=‘{1} {0} {1}‘.format(‘egon‘,18,‘male‘) #根據元素的下標對應
print(res)
18 egon 18
res=‘{name} {age} {sex}‘.format(sex=‘male‘,name=‘egon‘,age=18)#根據key值對應
print(res)
egon 18 male

#split name=‘root:x:0:0::/root:/bin/bash‘ print(name.split(‘:‘)) #默認分隔符為空格 name=‘C:/a/b/c/d.txt‘ #只想拿到頂級目錄 print(name.split(‘/‘,1)) name=‘a|b|c‘ print(name.rsplit(‘|‘,1)) #從右開始切分 #join tag=‘ ‘ print(tag.join([‘egon‘,‘say‘,‘hello‘,‘world‘])) #可叠代對象必須都是字符串 #replace name=‘alex say :i have one tesla,my name is alex‘ print(name.replace(‘alex‘,‘SB‘,1)) #isdigit：可以判斷bytes和unicode類型,是最常用的用於於判斷字符是否為"數字"的方法 age=input(‘>>: ‘) print(age.isdigit())
 

　其他操作（了解即可）

#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is數字系列
#6、is其他

#find,rfind,index,rindex,count
name=‘egon say hello‘
print(name.find(‘o‘,1,3)) #顧頭不顧尾,找不到則返回-1不會報錯,找到了則顯示索引
# print(name.index(‘e‘,2,4)) #同上,但是找不到會報錯
print(name.count(‘e‘,1,3)) #顧頭不顧尾,如果不指定範圍則查找所有

#center,ljust,rjust,zfill
name=‘egon‘
print(name.center(30,‘-‘))
print(name.ljust(30,‘*‘))
print(name.rjust(30,‘*‘))
print(name.zfill(50)) #用0填充

#expandtabs
name=‘egon\thello‘
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大寫
print(name.swapcase()) #大小寫翻轉
msg=‘egon say hi‘
print(msg.title()) #每個單詞的首字母大寫

#is數字系列
#在python3中
num1=b‘4‘ #bytes
num2=u‘4‘ #unicode,python3中無需加u就是unicode
num3=‘四‘ #中文數字
num4=‘Ⅳ‘ #羅馬數字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes類型無isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文數字,羅馬數字
#bytes類型無isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判斷浮點數
num5=‘4.3‘
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
‘‘‘
總結:
    最常用的是isdigit,可以判斷bytes和unicode類型,這也是最常見的數字應用場景
    如果要判斷中文數字或羅馬數字,則需要用到isnumeric
‘‘‘

#is其他
print(‘===>‘)
name=‘egon123‘
print(name.isalnum()) #字符串由字母或數字組成
print(name.isalpha()) #字符串只由字母組成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

列表

#作用：多個裝備，多個愛好，多門課程，多個女朋友等

#定義：[]內可以有多個任意類型的值，逗號分隔
my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本質my_girl_friends=list([...])
或
l=list(‘abc‘)

#優先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取      
#2、切片(顧頭不顧尾，步長)
#3、長度
#4、成員運算in和not in

#5、追加
#6、刪除
#7、循環

#ps:反向步長
l=[1,2,3,4,5,6]

#正向步長
l[0:3:1] #[1, 2, 3]
#反向步長
l[2::-1] #[3, 2, 1]
#列表翻轉
l[::-1] #[6, 5, 4, 3, 2, 1]

列表

#作用：多個裝備，多個愛好，多門課程，多個女朋友等

#定義：[]內可以有多個任意類型的值，逗號分隔
my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本質my_girl_friends=list([...])
或
l=list(‘abc‘)

#優先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取      
#2、切片(顧頭不顧尾，步長)
#3、長度
#4、成員運算in和not in

#5、追加
#6、刪除
#7、循環

#ps:反向步長
l=[1,2,3,4,5,6]

#正向步長
l[0:3:1] #[1, 2, 3]
#反向步長
l[2::-1] #[3, 2, 1]
#列表翻轉
l[::-1] #[6, 5, 4, 3, 2, 1]

字典

#作用：存多個值,key-value存取，取值速度快

#定義：key必須是不可變類型，value可以是任意類型
info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘} #本質info=dict({....})
或
info=dict(name=‘egon‘,age=18,sex=‘male‘)
或
info=dict([[‘name‘,‘egon‘],(‘age‘,18)])
或
{}.fromkeys((‘name‘,‘age‘,‘sex‘),None)

#優先掌握的操作：
#1、按key存取值：可存可取
#2、長度len
#3、成員運算in和not in

#4、刪除
#5、鍵keys()，值values()，鍵值對items()
#6、循環

集合

#作用：去重，關系運算，

#定義：
            知識點回顧
            可變類型是不可hash類型
            不可變類型是可hash類型

#定義集合:
            集合：可以包含多個元素，用逗號分割，
            集合的元素遵循三個原則：
             1：每個元素必須是不可變類型(可hash，可作為字典的key)
             2:沒有重復的元素
             3：無序

註意集合的目的是將不同的值存放到一起，不同的集合間用來做關系運算，無需糾結於集合中單個值
 

#優先掌握的操作：
#1、長度len
#2、成員運算in和not in

#3、|合集
#4、&交集
#5、-差集
#6、^對稱差集
#7、==
#8、父集：>,>= 
#9、子集：<,<=    

運算符

#身份運算（is ，is not）
is比較的是id，而雙等號比較的是值
毫無疑問，id若相同則值肯定相同，而值相同id則不一定相同
>>> x=1234567890
>>> y=1234567890
>>> x == y
True
>>> id(x),id(y)
(3581040, 31550448)
>>> x is y
False

！！！總結非常重要的兩點！！！

#1、保證不亂嗎的核心法則就是，字符按照什麽標準而編碼的，就要按照什麽標準解碼，此處的標準指的就是字符編碼

#2、在內存中寫的所有字符，一視同仁，都是unicode編碼，比如我們打開編輯器，輸入一個“你”，我們並不能說“你”就是一個漢字，此時它僅僅只是一個符號，該符號可能很多國家都在使用，根據我們使用的輸入法不同這個字的樣式可能也不太一樣。只有在我們往硬盤保存或者基於網絡傳輸時，才能確定”你“到底是一個漢字，還是一個日本字，這就是unicode轉換成其他編碼格式的過程了

unicode----->encode-------->utf-8

utf-8-------->decode---------->unicode

#補充：

瀏覽網頁的時候，服務器會把動態生成的Unicode內容轉換為UTF-8再傳輸到瀏覽器

如果服務端encode的編碼格式是utf-8， 客戶端內存中收到的也是utf-8編碼的結果。

字符編碼應用之python

執行python程序的三個階段

階段一：啟動python解釋器

階段二：python解釋器此時就是一個文本編輯器，負責打開文件test.py,即從硬盤中讀取test.py的內容到內存中

階段三：讀取已經加載到內存的代碼（unicode編碼格式），然後執行，執行過程中可能會開辟新的內存空間，比如x="egon"

在python3 中有兩種字符串類型str和bytes

str是unicode

#coding:gbk
x=‘上‘ #當程序執行時，無需加u，‘上‘也會被以unicode形式保存新的內存空間中,

print(type(x)) #<class ‘str‘>

#x可以直接encode成任意編碼格式
print(x.encode(‘gbk‘)) #b‘\xc9\xcf‘
print(type(x.encode(‘gbk‘))) #<class ‘bytes‘>

很重要的一點是：看到python3中x.encode(‘gbk‘) 的結果\xc9\xcf正是python2中的str類型的值,而在python3是bytes類型，在python2中則是str類型

於是我有一個大膽的推測：python2中的str類型就是python3的bytes類型，於是我查看python2的str()源碼，發現

在python中

#1. 打開文件，得到文件句柄並賦值給一個變量
f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘) #默認打開模式就為r

#2. 通過句柄對文件進行操作
data=f.read()

#3. 關閉文件
f.close()

三 f=open(‘a.txt‘,‘r‘)的過程分析

#1、由應用程序向操作系統發起系統調用open(...)

#2、操作系統打開該文件，並返回一個文件句柄給應用程序

#3、應用程序將文件句柄賦值給變量f

四 強調！！！

#強調第一點：
打開一個文件包含兩部分資源：操作系統級打開的文件+應用程序的變量。在操作完畢一個文件時，必須把與該文件的這兩部分資源一個不落地回收，回收方法為：
1、f.close() #回收操作系統級打開的文件
2、del f #回收應用程序級的變量

其中del f一定要發生在f.close()之後，否則就會導致操作系統打開的文件還沒有關閉，白白占用資源，
而python自動的垃圾回收機制決定了我們無需考慮del f，這就要求我們，在操作完畢文件後，一定要記住f.close()

雖然我這麽說，但是很多同學還是會很不要臉地忘記f.close(),對於這些不長腦子的同學，我們推薦傻瓜式操作方式：使用with關鍵字來幫我們管理上下文
with open(‘a.txt‘,‘w‘) as f:
    pass
 
with open(‘a.txt‘,‘r‘) as read_f,open(‘b.txt‘,‘w‘) as write_f:
    data=read_f.read()
    write_f.write(data)

#強調第二點：
f=open(...)是由操作系統打開文件，那麽如果我們沒有為open指定編碼，那麽打開文件的默認編碼很明顯是操作系統說了算了，操作系統會用自己的默認編碼去打開文件，在windows下是gbk，在linux下是utf-8。
這就用到了上節課講的字符編碼的知識：若要保證不亂碼，文件以什麽方式存的，就要以什麽方式打開。

f=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)

五、打開文件的模式

文件句柄 = open(‘文件路徑‘, ‘模式‘)

模式可以是以下方式以及他們之間的組合：

#1. 打開文件的模式有(默認為文本模式)：
r ，只讀模式【默認模式，文件必須存在，不存在則拋出異常】
w，只寫模式【不可讀；不存在則創建；存在則清空內容】
a， 之追加寫模式【不可讀；不存在則創建；存在則只追加內容】

#2. 對於非文本文件，我們只能使用b模式，"b"表示以字節的方式操作（而所有文件也都是以字節的形式存儲的，使用這種模式無需考慮文本文件的字符編碼、圖片文件的jgp格式、視頻文件的avi格式）
rb 
wb
ab
註：以b方式打開時，讀取到的內容是字節類型，寫入時也需要提供字節類型，不能指定編碼

#3. 了解部分
"+" 表示可以同時讀寫某個文件
r+， 讀寫【可讀，可寫】
w+，寫讀【可讀，可寫】
a+， 寫讀【可讀，可寫】


x， 只寫模式【不可讀；不存在則創建，存在則報錯】
x+ ，寫讀【可讀，可寫】
xb

六、 操作文件的方法

#掌握
f.read() #讀取所有內容,光標移動到文件末尾
f.readline() #讀取一行內容,光標移動到第二行首部
f.readlines() #讀取每一行內容,存放於列表中

f.write(‘1111\n222\n‘) #針對文本模式的寫,需要自己寫換行符
f.write(‘1111\n222\n‘.encode(‘utf-8‘)) #針對b模式的寫,需要自己寫換行符
f.writelines([‘333\n‘,‘444\n‘]) #文件模式
f.writelines([bytes(‘333\n‘,encoding=‘utf-8‘),‘444\n‘.encode(‘utf-8‘)]) #b模式

#了解
f.readable() #文件是否可讀
f.writable() #文件是否可讀
f.closed #文件是否關閉
f.encoding #如果文件打開模式為b,則沒有該屬性
f.flush() #立刻將文件內容從內存刷到硬盤
f.name

七：文件內光標移動

一: read(3)：

　　1. 文件打開方式為文本模式時，代表讀取3個字符

　　2. 文件打開方式為b模式時，代表讀取3個字節

二: 其余的文件內光標移動都是以字節為單位如seek，tell，truncate

註意：

　　1. seek有三種移動方式0，1，2，其中1和2必須在b模式下進行，但無論哪種模式，都是以bytes為單位移動的

　　2. truncate是截斷文件，所以文件的打開方式必須可寫，但是不能用w或w+等方式打開，因為那樣直接清空文件了，所以truncate要在r+或a或a+等模式下測試效果

五 文件的修改

文件的數據是存放於硬盤上的，因而只存在覆蓋、不存在修改這麽一說，我們平時看到的修改文件，都是模擬出來的效果，具體的說有兩種實現方式：

方式一：將硬盤存放的該文件的內容全部加載到內存，在內存中是可以修改的，修改完畢後，再由內存覆蓋到硬盤（word，vim，nodpad++等編輯器）

import os

with open(‘a.txt‘) as read_f,open(‘.a.txt.swap‘,‘w‘) as write_f:
    data=read_f.read() #全部讀入內存,如果文件很大,會很卡
    data=data.replace(‘alex‘,‘SB‘) #在內存中完成修改

    write_f.write(data) #一次性寫入新文件

os.remove(‘a.txt‘)
os.rename(‘.a.txt.swap‘,‘a.txt‘) 

方式二：將硬盤存放的該文件的內容一行一行地讀入內存，修改完畢就寫入新文件，最後用新文件覆蓋源文件

import os

with open(‘a.txt‘) as read_f,open(‘.a.txt.swap‘,‘w‘) as write_f:
    for line in read_f:
        line=line.replace(‘alex‘,‘SB‘)
        write_f.write(line)

os.remove(‘a.txt‘)
os.rename(‘.a.txt.swap‘,‘a.txt‘) 

python入門第二天