第七篇Python基本數據類型之數字&字符串&布爾值

數字

寫在最前，必需要會的：int()

整型

Python3裏不管數字多長都用int表示，Python2裏有int和Long表示，Long表示長整型

有關數字的經常使用方法，方法調用後面都必須帶括號()

int()：將字符串轉換爲整型，且字符串內容只能是數字

a = "123" b = "123a" c = int(a) d = int(b)       # ValueError: invalid literal for int() with base 10: '123a'
print(type(c)) print(type(d))

int(x,[base])：將x轉換爲整型，base指定轉換的基數，base=2, 8, 16,表示以2,8,16進制轉換，默認是10進制

e = "a" f = int(e, base=16) print(type(f)) print(f) #結果
<class 'int'>
10

bit_length()：當前數字用二進制表示時，至少有幾位

age1 = 1 age2 = 2 age3 = 3 age4 = 4 age5 = 5 age6 = 6 age7 = 30
print(age1.bit_length()) print(age2.bit_length()) print(age3.bit_length()) print(age4.bit_length()) print(age5.bit_length()) print(age6.bit_length()) print(age7.bit_length()) #結果
1
2
2
3
3
3
5

字符串

寫在最前，必需要會的：replace(),find(),join(),strip(),stratwith(),endwith(),split(),upper(),lower(),format()

format(self, *args, **kwargs)：格式化字符串

temp = "I am {name},age: {age}" v = temp.format(name = "alex",age = 19) print(v) # 若是方法的定義裏有**kwargs,就表示 他能夠寫成name = x,也能夠寫成字典形式
v1 = temp.format(**{"name":"alex2","age":20}) print(v1) #結果
I am alex,age: 19 I am alex2,age: 20

 

總結

一、經常使用須要記住的字符串的基本魔法（7個）

join()、split()、find()、strip()、upper()、lower()、replace()

 

二、灰魔法（4個）

（1）、索引（下表）：從0開始的，也就是某個字符串的第一個字符的索引是0

test = "alex"
print(test[0]) #結果
a

（2） 切片

test = "alex"
print(test[0:2])   # 範圍 0<=test[0:2]<2

#結果
al

（3）、len():獲取當前字符串的長度，即由幾個字符組成

print(len(test))

# 結果
4

test1 = "你好世界"
print(len(test1))

# 結果
4    （Python3）
9    （Python2.7）

# 若是len()的對象是列表，是以逗號爲標記，得到有幾個元素

li = ["adf","dfad","fadf","fad","re"]
print(len(li))

# 結果
5

（4）、將字符串裏的每一個字符單獨拿出來的兩種方法

test = "他說妹子衝我來"
# 方法1：while 循環實現
 index = 0 while index < len(test): v = test[index] print(v) index = index + 1

# 方法2：for 循環實現
for count in test: print(count)

rnage(）：用來建立連續的數字

v = range(100) print(v)      # range(0, 100)

# 在python2.7裏,range(100)在內存裏當即就建立了，命令行裏立馬就打出0~99個數 # 在python3裏，range(100)是在循環開始的時候才一個一個的建立內存 # 其實這是python3的一個優化，試想，若是又10000萬個數，若是當即建立，內存佔用會馬上升高

range(0,100,step):能夠經過設置步長，來建立不連續的數字

v = range(0, 100, 30)   #0 到100個數裏，步長30，每一個30個數取一個
for i in v: print(i) #結果
30
60
90

#練習： 將test對應的字符串的索引和對應的字符打印出來
test = input(">>>") l= len(test) for item in range(l): print(item,test[item])

 

字符串一旦建立，就不能修改；可是一旦修改或者拼接，都會形成從新生成字符串，開闢新的內存

字符串的表示方法：經過引號表示

1 # 下面對字符串的表示都是正確的
2 str1 = '單引號'
3 str2 = "雙引號"
4 str3 = '''三個單引號'''
5 str4 = """三個雙引號"""
6 
7 # 注意：引號不能混用，好比
8 str5 = "引號不能混用，會報錯'

 字符串的方法太多了，兩種方式能夠得到字符串都有哪些方法：

1. Pycharm等帶有自動提示功能的編譯器，寫一個字符串，後面 點一下，就會提示它可用的方法

2. Pycharm裏，安裝Ctrl，鼠標光標移到 str()上，點擊左鍵就會進入str()的方法，裏面能夠看到每種方法的具體定義

字符串的方法：

由於太多了，因此練一個寫一個。

capitalize()：首字母大寫

str1 = "alex" v = str1.capitalize() print(v) #結果
Alex

casefold():將字母變成小寫
lower():將字母變成小寫

test = "alex" v1 = test.casefold()   # 更牛逼，不少未知的對應關係也能夠變小寫
print(v1) v2 = test.lower()     # 對普通的，咱們能想到的變小寫
print(v2)

#結果

　alex
　alex

center(self, width, fillchar=None):設置寬度，並將內容居中，width表示總長度，fillchar表示空白位置填充，能夠用不填，要填只能填一個字符，表示空白位置用該字符填充。

對於方法裏有參數的，調用的時候必須帶參數，此方法裏width對應的必須帶個參數，而fillchar後面有=，默認值是None，對應這種參數有默認值的能夠不帶，

若是帶了參數，fillchar就取寫的值

test = "ALex" v3 = test.center(20) v4 = test.center(20,"國") print(v3) print(v4) #結果
 ALex  國國國國國國國國ALex國國國國國國國國

ljust():字符串左對齊，其他寬度用指定字符填充

rjust():字符串右對齊，其他寬度用指定字符填充

zfill():默認只能用0填充，不能指定填充字符

test = "alex" v = test.ljust(20,"*")  # 字符串左對齊，其他寬度用指定字符填充
print(v) v1 = test.rjust(20,"￥")   # 字符串右對齊，其他寬度用指定字符填充
print(v1) v2 = test.zfill(20)   # 默認只能用0填充
print(v2) # 結果
alex**************** ￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥alex 0000000000000000alex

count(self, sub, start=None, end=None)：去字符串中尋找子序列（子字符）出現的次數，start:表示開始查找的位置，end:表示查找結束的位置

 1 test = "ALexalexr"
 2 v = test.count("ex")  3 print(v)  4 
 5 v1 = test.count("ex",5,6)  6 print(v1)  7 
 8 #結果
 9 2
10 0

string.encode(encoding='UTF-8', errors='strict')：以 encoding 指定的編碼格式編碼 string，若是出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'

 

endswith(self, suffix, start=None, end=None)：表示以什麼什麼結尾，返回值是布爾值

test = "ALexalexr" v1 = test.endswith("r") v2 = test.endswith("xr",4,6) print(v1) print(v2) #結果
True False

startswith(self, suffix, start=None, end=None)：表示以什麼什麼開始，返回值是布爾值

test = "ALexalexr" v1 = test.startswith("ALe") v2 = test.startswith("a",4,6) print(v1) print(v2) #結果
True True

 find()：從開始日後尋找，找到第一個匹配字符後，返回它的索引位置

test = "alexalex" v = test.find("ex") print(v) #結果
2

find(self, suffix, start=None, end=None)：start表示起始尋找的位置，end表示結束尋找的位置  [start,end)

v1 = test.find("ex", 5, 7) print(v1) v2 = test.find("ex", 5, 8) print(v2) #結果
-1 表示沒有找到 6 結論：[start, end) 左閉右開區間

index():尋找字符在字符串中是否存在，並返回位置索引值

test = "alexalex" v = test.index("ex") print(v) v1 = test.index("8") print(v1)      # 沒有找到，直接就程序報錯了。

# 結論
find()找到後返回的也是位置索引，index()也是返回位置索引，可是find()找到不到的時候返回-1，index()找不到的時候程序報錯，因此，實踐中經常使用find()

format(): 格式化，將一個字符串中的佔位符替換爲指定的值，有兩種方式：

1. format()裏經過指定name 和 a 的對應的具體的值進行格式化

test = "I am {name}, age {a}"   # {name},{a}是佔位符
print(test) v = test.format(name = "alex", a = 19) print(v) #結果
I am {name}, age {a} I am alex, age 19

2. format()裏不指定具體的佔位符對應的值，就會按照佔位符的順序進行替換

test = "I am {0}, age {1}"
print(test) #結果
I am {0}, age {1} v = test.format("alex", 19) print(v) #結果
I am alex, age 19

format()三種方法更直觀的示例：
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

format_map()：格式化，傳入的值是按字典的鍵值對方式傳入的，其功能與format同樣

test = "I am {name}, age {a}" v3 = test.format_map({"name":"alex", "a":19}) print(v3) #結果
I am alex, age 19

 isalnum()：判斷字符串中是否只包含 字母和數字，若是還包含其餘字符，返回FALSE，只有數字或字母，返回TURE

test = "alexalex898_+"
print(test.isalnum()) test = "alexalex898_"
print(test.isalnum()) test = "alexalex898"
print(test.isalnum()) #結果
False False True

 isalpha()：判斷字符串中是否只包含 字母，若是還包含其餘字符，返回FALSE，只有字母，返回TURE

test = "adfad"
print(test.isalpha()) test1 = "adfad2"
print(test1.isalpha()) #結果
True False

 expandtabs():斷句，能夠製做表格，以下示例：

以20個字符爲一組進行斷句，若是沒有滿20個字符，就遇到了\t, 剩下的字符\t自動會以空格補齊。

好比，username是8個字符，就遇到了\t, 還差12個字符纔夠20個一組，因此剩下12個字符就以12個空格補齊

test = "username\temail\tpassword\nlaiying\tlaying@163.com\t78749798\nlaiying\tlaying@163.com\t1234567"

print(test.expandtabs(20)) #結果
username email password laiying laying@163.com      78749798 laiying laying@163.com      1234567

isdecimal()：判斷當前字符串輸入的是否爲數字
isdigit()：判斷當前字符串輸入的是否爲數字，也能夠判斷其餘形式的數字，而isdecimal()則不能夠

isnumeric()：判斷字符串是不是數字，能夠判斷中文，特殊符號的數字

test = "123"
print(test.isdecimal())  # True
print(test.isdigit())    # True
print(test.isnumeric())  # True
 test1 = "②"
print(test1.isdecimal())  # False
print(test1.isdigit())    # True
print(test1.isnumeric())  # True
 test2 = "二"
print(test2.isdecimal())  # False
print(test2.isdigit())    # False
print(test2.isnumeric())  # True

swapcase()：大小寫字母轉換

test = "alex" print(test.swapcase()) # ALEX  test1 = "AlsdR" print(test1.swapcase()) # aLSDr

isidentifier()：判斷標識符的起名是否符合規範，符合返回TRUE，不符合返回FALSE

標識符起名，以字母，數字，下劃線組成，可是開通不能是數字

a1 = "jakd_87943" a2 = "87943jakd_"
print(a1.isidentifier())  # True
print(a2.isidentifier())  # False

isprintable()：是否存在不可顯示的字符

\t:表示製表符

\n:表示換行

test = "fadjajk"
print(test.isprintable())  # True
 test1 = "fadjajk\nfjakdjf" test2 = "fadjajk\tadfd"
print(test1.isprintable())  #False
print(test2.isprintable())  #False

isspace()：判斷是否所有字符串都是空格。 即判斷是否爲空字符串

test = "fadjajk"
print(test.isspace())     # False
test1 = "      " 
print(test1.isspace())    # True

istitle()：判斷是否爲標題

title()：將字符串變成標題

# 標題的首字母都是大寫的
test = "Return True if all cased chakd"
print(test.istitle())  # False

#將字符串變成標題，全部首字母都大寫
print(test.title())    # Return True If All Cased Chakd

join()： 將字符串中的每個元素按照指定分割符進行拼接  ※※※※※重要※※※※※

Join()的內部原理實際上是循環字符串，找到一個字符串就加上指定的分隔符，再去循環下一個

test = "你是風兒我是沙"
# 想把上面的字符串都用空格隔開
t = " " v = t.join(test) print(v)    # 你 是 風 兒 我 是 沙
print("++".join(test))  # 你++是++風++兒++我++是++沙

a = "hello" c = " " b = "world"

print("888".join([a,b]))             # hello888world
print("888".join([a,b, "新家"]))      # hello888world888新家

islower()：判斷字符串是否所有爲小寫

lower()：將全部字母轉換成小寫

用法：不區分大小寫能夠用的方法

test = "Alex"
print(test.islower())   # False
print(test.lower())     # alex

isupper()：判斷字符串是否所有爲大寫

upper()：將全部字母轉換成大寫

v1 = test.isupper() v2 = test.upper() print(v1)    # False
print(v2)    # ALEX

swapcase()：大小寫字母轉換

test = "dajlkjdfakdDSFSSWDSdlfja;ldkfjfajdkfja"
print(test.swapcase()) #結果 DAJLKJDFAKDdsfsswdsDLFJA;LDKFJFAJDKFJA

lstrip() ：默認去除字符串左邊的空白、去除\n , \t ，若是指定去除字符的時候，連左邊的全部空白和指定字符都去除掉了

rstrip() ：去除字符串左邊的空白

strip() ：去除字符串左右兩邊的空白

test = " Alex " v1 = test.lstrip()  # 去除字符串左邊的空白
v2 = test.rstrip()  # 去除字符串左邊的空白
v3 = test.strip()   # 去除字符串左右兩邊的空白
print(v1) print(v2) print(v3) # 結果
Alex Alex Alex

test1 = " \nalex " test2 = " alex\t "

print(test1.lstrip())          # 去除\n
print(test2.rstrip())         # 去除 \t
 test3 = "alexed"
print(test3.lstrip("al"))    # 指定字符去除

test = "xaexlex" v = test.rstrip('9lexxexa') print(v) # 移除指定字符 # 遵循最多匹配 # 上面用的是從右開始往左找
1. lex有，test裏就移除掉lex,而後ex也有，test就再移除ex,一樣還有xa，也能夠移除

maketrans():建立對應關係

translate()：執行替換

maketrans()老是與translate()一塊兒用

# test 和 test1 字符個數必須上下對應 # 而後將v裏的字符進行替換，即v裏若是發現你，就用1替換，返現是就用2替換
 test = "你是風兒我是沙" test1 ="1234567" v = "你是風兒我是沙，纏纏綿綿去你家" m = str.maketrans("你是風兒我是沙","1234567")  # 1. 先建立對應關係
new_v = v.translate(m)  # 2. 再根據對應關係進行替換
print(new_v) #結果
1634567，纏纏綿綿去1家

字符串分割的方法：

partition()：指定分割字符，永遠只能分割三份

rpartition()：指定分割字符，永遠只能分割三份，從右邊開始找並進行分割

partition()分割後，指定的分割字符本身能夠拿獲得，而split()指定的分割字符本身是拿不到的

split(self, sep=None, maxsplit=-1)：指定分割字符，maxsplit默認爲不指定分割次數，有幾個分割字符就分割幾回。 指定3，就最大分割三次

rsplit(self, sep=None, maxsplit=-1)：同上，只是從右邊開始查找分割

後面還會介紹一個正則表達式，也能進行字符串分割

# 字符串分割
test = "testasdfjfadssddfd"
# 按自定字符串進行分割，找到第一個匹配字符就能夠進行分割 # 若是能分割，永遠只能分割爲三份
print(test.partition("s"))    # ('te', 's', 'tasdfjfadssddfd')

# 從右邊開始找，找到第一個指定字符後，開始分割，永遠只能分割爲三份
print(test.rpartition("s"))  # ('testasdfjfads', 's', 'ddfd')

# 根據指定字符進行分割，並且能夠指定分割的個數，想分幾個分幾個 # split()有個弊端, 指定的分割字符匹配到後，本身拿不到
print(test.split("s"))  # ['te', 'ta', 'dfjfad', '', 'ddfd']
print(test.split('s',1))   # ['te', 'tasdfjfadssddfd']
print(test.split('s',2))   # ['te', 'ta', 'dfjfadssddfd']

# 從右開始找
print(test.rsplit('s',3))  # ['testa', 'dfjfad', '', 'ddfd']

splitlines(self, keepends=None)：按照換行符\n進行分割，默認不保留換行符

test = "dajlkjdfakdjfa\nfjadlfja;ldkfj\nfajdkfja"
print(test.splitlines()) print(test.splitlines(True)) # True 表示 分割後保留換行符 print(test.splitlines(False)) # False 表示 分割後不保留換行符 # 結果
['dajlkjdfakdjfa', 'fjadlfja;ldkfj', 'fajdkfja'] ['dajlkjdfakdjfa\n', 'fjadlfja;ldkfj\n', 'fajdkfja'] ['dajlkjdfakdjfa', 'fjadlfja;ldkfj', 'fajdkfja']

startswith(self, prefix, start=None, end=None)：判斷字符串是否以某某字符開頭，start 和 end 參數表示開始和結束的位置

endswith(self, suffix, start=None, end=None)：判斷字符串是否以某某字符結尾，start 和 end 參數表示開始和結束的位置

test = "dajlkjdfakdjfa\nfjadlfja;ldkfj\nfajdkfja"

print(test.startswith("da")) print(test.startswith("a")) print(test.endswith("ja")) print(test.endswith("j")) # 結果：
True False True False

 replace(self, old, new, count=None)：替換字符串，old是要被替換的字符，new是替換字符， count是幾，表示就替換前面幾個

test = "alexalexalexalex"
print(test.replace("ex","bbbb")) print(test.replace("ex","bbbbb", 2)) #結果
albbbbalbbbbalbbbbalbbbb albbbbbalbbbbbalexalex

關於字符串兩個練習

# 1. 將輸入的下劃線風格轉駝峯風格
 data = input("請輸入一個帶有下劃線風格的變量名： ") words = data.split("_")  # 首先，以_進行分割，獲得一個個獨立的單詞，是個列表
result =""
for word in words： result += word.capitalize() # 而後將每一個單詞的首字母大寫，再利用字符串運算符+拼接字符串
print(result) # 2. # 寫一個腳本解析url http://localhost:8080/test/data?abc=def&test=debug，獲得協議，host,端口號，路徑。參數

# 首先解析要注意，兩個冒號解析的話，可能會越解析越亂，因此，先以?來分割
a = url1.split("?") # 直接就能夠獲得參數了 # print(a) # ['http://localhost:8080/test/data', 'abc=def&test=debug']

# 而後再以:來分割
b = a[0].split(":") # print(b) # ['http', '//localhost', '8080/test/data'] # 能夠獲得協議了
print("protal:{}".format(b[0])) # 再處理獲得host
print("host:{}".format(b[1].split("//")[1])) # 以"/"分割，拿到端口，並拼接path
c=b[-1].split("/") # 注意，有些url是沒有端口的，因此就須要有異常處理或者判斷
try: d = int(c[0]) print("port:{}".format(d)) except Exception as error: print("port:{}".format("not port in this url")) print("path:{}{}".format("/", "/".join(c[1:]))) print("parameter: {}".format(a[-1]))

View Code

Python字符串運算符

 

操做符	描述	實例
+	字符串鏈接	>>>a + b 'HelloPython'
*	重複輸出字符串	>>>a * 2 'HelloHello'
[]	經過索引獲取字符串中字符	>>>a[1] 'e'
[ : ]	截取字符串中的一部分	>>>a[1:4] 'ell'
in	成員運算符 - 若是字符串中包含給定的字符返回 True	>>>"H" in a True
not in	成員運算符 - 若是字符串中不包含給定的字符返回 True	>>>"M" not in a True
%	格式字符串	請看下一章節

# 示例
 a = "hello" c = " " b = "world"

print(a+c+b) # hello world 
print(50 * "=") # ==================================================
print(len(a)) # 5

print(a[2]) # l

print(a[1:-1]) # ell

print(a[:]) # hello

print("l" in a) # True

print("a" not in a) # True

 

Python字符串轉義

在須要在字符中使用特殊字符時，python用反斜槓(\)轉義字符。以下表： 

轉義字符	描述
\(在行尾時)	續行符
\\	反斜槓符號
\'	單引號
\"	雙引號
\a	響鈴
\b	退格(Backspace)
\e	轉義
\000	空
\n	換行
\v	縱向製表符
\t	橫向製表符
\r	回車
\f	換頁
\oyy	八進制數，yy表明的字符，例如：\o12表明換行
\xyy	十六進制數，yy表明的字符，例如：\x0a表明換行
\other	其它的字符以普通格式輸出

布爾值

後面還有，12以前的某個課程裏講的，要補課

 寫在最前：

1. 轉換： bool([])

2. 布爾值自己就是0 和 1

3.特殊狀況，哪些是假？

None，空字符串，空字典，空列表，空元組，0，空集合  這幾個用布爾值判斷的時候都是False，其餘都是真

print(bool(["dfjdak","fad"])) print(bool([])) #結果
True False