Python學習筆記:第3天 字串的操作

Chocolate、M發表於2018-10-21

1. python的資料型別

int     整數
str     字串。一般不會用字串儲存大量的資料
bool    布林值:True和False
list    可以存放大量的資料(可以任意的資料型別)
dict    字典 =>  key: value  查詢資料的速度快
set     集合,特點:無序、不能重複
bytes   位元組數,程式能夠處理
tuple   元組:不可變的列表  

2. int型別的操作

bit_lenght() 計算這個數字二進位制的長度

  • 二進位制: 0和1,逢二進一
  • 八進位制: 0到7,逢八進一
  • 十六進位制: 0到F,逢十六進一
In [1]: a = 12              # 12的二進位制形式為:1100
In [2]: a.bit_length()
Out[2]: 4

3. bool型別

大部分物件都可以參與布林運算:

4. 字串的操作

字串是Python中最常用的資料型別,我們可以使用引號(‘或”)來建立字串。

s1 = `abc`
s2 = "def"
s3 = ```        # 三引號可以建立多行字串
aaaa
bbbb
```

4.1 索引和切片

索引:索引就是下標,下標是從0開始的

In [1]: s = `012345678`
                       
In [2]: s[2]           
Out[2]: `2`            
                       
In [3]: s[-2]                     # 也可以使用負數從後面開始索引 
Out[3]: `7`            

切片

使用方法:s1[startIndex:endIndex:step]

  • 從starIndex切片到endIndex,但是不包括endIndex
  • step引數為切片的步長,如果是正數則從左到右;如果是負數則從右到左(不寫則預設為1)
In [4]: s[4:]           # startIndex不填預設是切片到最後
Out[4]: `45678`      
                     
In [5]: s[::]           # startIndex和endIndex都不填預設是整個字串        
Out[5]: `012345678`  
                     
In [6]: s[::-1]         # 如果step的值為負數的時是把整個字元順序倒過來處理
Out[6]: `876543210`  
                     
In [7]: s[-1: -5]       # 如果step的值不填(預設為1),這樣取不到想要的字元,從-1再往右已經沒有字元了
Out[7]: ``           
                     
In [8]: s[-1: -5:-1]    # 把step的值設為-1後就可以從右往左切片
Out[8]: `8765`       
                  
In [9]: s[:-1]    
Out[9]: `01234567`           

In [11]: s[2::2]        # step設為2時,每隔2個取一個值
Out[11]: `2468`

In [12]: s[-2::-2]      # 設定為-2時,從後面往前面切片,每2個取一個
Out[12]: `7531`

4.2 字串的相關操作方法

切記, 字串是不可變的物件, 所以任何操作對原字串是不會有任何影響的

1. 字串重要的幾個方法

upper()                         # 把字串全部轉換成大寫
lower()                         # 把字串全部轉換成小寫
strip([chars])                  # 去掉字元兩邊的空白字元,製表符	和回車符
等,如果給了指定的引數xx,就去掉字串兩邊的xx字元
lstrip([chars])                 # 去掉左邊指定的字元
rstrip([chars])                 # 去掉右邊指定的字元
replace(old, new[, count])      # 用new字元替換掉old字元,count值沒有指定預設時替換所有的字元
split(sep=None, maxsplit=-1)    # 以指定的符號分割字串,用於分割的字元不會在分割後的結果中,並且返回一個列表
rsplit(sep=None, maxsplit=-1)   # 從右邊起分割字串,maxsplit可以指定最大分割次數
lsplit(sep=None, maxsplit=-1)   # 從左邊起開始分割
index(sub[, start[, end]])      # 獲取指定字串第一次出現的位置(即索引),start和end可以指定範圍,如果找不到會出ValueError的異常
find(sub[, start[, end]])       # 跟index的作用一樣,但當找不到結果時或返回-1而不會報錯
startswith(prefix[, start[, end]])  # 判斷字串是不是以指定的字元開頭,返回的時布林值True和False
endswith((suffix[, start[, end]])   # 判斷字串是不是以指定的字元結尾
In [1]: s = `__abCDef    `                                              
                                                                                
In [2]: s.upper()                           # 字元全部轉換成大寫                                                               
Out[2]: `__ABCDEF    `                                                          
                                                                                
In [3]: s.lower()                           # 字元全部轉換成大寫                
Out[3]: `__abcdef    `                                                          
                                                                                
In [4]: s.strip()                           # 預設是除去兩邊的空白字元                                                               
Out[4]: `__abCDef`                                                              
                                                                                
In [5]: s.strip(`_`)                        # 可以指定刪除字元兩邊指定的字元                                                            
Out[5]: `abCDef    `                                                            
                                                                                
In [6]: s.lstrip(`_`)                       # lstrip只刪除左邊指定的字元                                                           
Out[6]: `abCDef    `                                                            
                                                                                
In [7]: s.replace(` `, `-`)                 # 查詢對應的字元並替換成新的字元                                                     
Out[7]: `__abCDef----`                                                                                                                 
                                                                                
In [10]: s.replace(`_`, `*`, 1)             # 指定count引數可以設定要替換的次數,預設是全部替換                                                
Out[10]: `*_abCDef    `                                                         
                                                                                
In [11]: s2 = `遊戲abc籃球`                                                         
                                                                                
In [12]: s2.split(`abc`)                    # 以指定字元分割字串,返回的資料型別是列表                                                        
Out[12]: [`遊戲`, `籃球`]                                                           
                                                                                
In [13]: s2.split(`遊戲abc籃球`)            # 如果分割後為空字元也會返回一個列表,列表裡面是2個空字串元素
Out[13]: [``, ``]                                                               
                                                                                
In [14]: s2.index(`籃球`)                   # 查詢對應字串所在的索引位置                                                         
Out[14]: 5                                                                      
                                                                                
In [15]: s2.index(`d`)                      # 找不到時會丟擲ValueError異常                                                    
---------------------------------------------------------------------------     
ValueError                                Traceback (most recent call last)     
<ipython-input-15-46668276bfcb> in <module>                                     
----> 1 s2.index(`d`)                                                           
                                                                                
ValueError: substring not found                                                 
                                                                                
In [16]: s2.find(`d`)                       # 跟index一樣查詢字元所在的索引,但是找不到時會返回-1而不是報錯                                              
Out[16]: -1                                                                     
                                                                                
In [17]: s2.startswith(`遊戲`)              # 判斷字串是否以‘遊戲’開頭,返回布林值                                                    
Out[17]: True                                                                   
                                                                                
In [18]: s2.endswith(`籃球`)                # 判斷字串是否以‘籃球結尾’                                                      
Out[18]: True                                                                   

2. 大小寫轉換

capitalize()                    # 首字母大寫
swapcase()                      # 大小寫互相轉換
title()                         # 每個被特殊字元隔開的字⺟⾸字⺟⼤寫
casefold()                      # 轉換成⼩寫,但是這個最所有的字元都有效(如東歐的等)

3. 格式化輸出

使用字串的format可以更直觀的輸出

In [19]: print(`我是{}來自{},我喜歡{}`.format(`Jerry`, `南方`, `打籃球`))
我是Jerry來自南方,我喜歡打籃球

In [20]: print(`我是{2}來自{0},我喜歡{1}`.format(`Jerry`, `南方`, `打籃球`))
我是打籃球來自Jerry,我喜歡南方

In [21]: print(`我是{name}來自{place},我喜歡{hobby}`.format(name=`Jerry`, hobby=`打籃球`, place=`南方`))
我是Jerry來自南方,我喜歡打籃球

In [22]: print(`{:5d}  {:2.3f}`.format(12, 12.143233234))       # 5d
   12  12.143
# {:5d} 的意思是替換為5個字元寬度的整數,寬度不足則使用空格填充
# {:7.3f}的意思是替換為為7個字元寬度的保留兩位的小數,小數點也算一個寬度,寬度不足則使用空格填充。其中7指寬度為7,.2f指保留兩位小數。

4. 條件判斷

isalpha()               # 是否由字元組成
isdigit()               # 是否由數字組成
isalnum()               # 是否由數字和字元組成
isdecimal()             # 是否由小陣列成
isnumeric()             # 是否由數字組成(中文形式的數字也能識別)

5. 計算字串的⻓度

使用len可以計算字串的長度

len([資料]) # 使用len函式可以計算字串,列表、元組和字典等也都可以使用

6. 其他方法

center(10, "*")                 # 拉⻓成10, 把原字串放中間.其餘位置補*
count("a")                      # 查詢"a"出現的次數 

5. for迴圈

使⽤for迴圈可以遍歷(獲取)字串中的每⼀個字元,使用語法:

for 變數 in 可迭代物件:
    迴圈語句

可迭代物件:可以理解為能⼀個⼀個往外取值的物件

使用while遍歷一個字串的方法:

s = "⼤家好, 我是VUE, 前端的⼩朋友們. 你們好麼?"
index = 0
while index < len(s19):
 print(s[index])          # 利⽤索引切⽚來完成字元的查詢
 index = index + 1

但是如果使用for迴圈:

s = "⼤家好, 我是VUE, 前端的⼩朋友們. 你們好麼?"
for c in s19:
 print(c)

相關文章