Python學習心路歷程-day2
Python學習之路次日html
學習內容：java
1.模塊初識python
2.pyc是什麼git
3.python數據類型編程
4.數據運算windows
5.bytes/str之別api
6.列表數據結構
7.元組app
8.字典ide
9.字符串經常使用操做
10.程序練習
1.模塊初識
在前面腳本上是用 python 解釋器來編程，若是你從 Python 解釋器退出再進入，那麼你定義的全部的方法和變量就都消失了。
爲此 Python 提供了一個辦法，把這些定義存放在文件中，爲一些腳本或者交互式的解釋器實例使用，這個文件被稱爲模塊。
模塊是一個包含全部你定義的函數和變量的文件，其後綴名是.py。模塊能夠被別的程序引入，以使用該模塊中的函數等功能。這也是使用 python 標準庫的方法。
下面是一個使用 python 標準庫中模塊的例子。
1 #!/user/bin/env python 2 # -*- coding: UTF-8 -*- 3 # Author: cs 4 5 import sys 6 7 print('命令行參數以下:') 8 for i in sys.argv: 9 print(i) 10 11 print('\n\nPython 路徑爲：', sys.path, '\n')
- 一、import sys 引入 python 標準庫中的 sys.py 模塊；這是引入某一模塊的方法。
- 二、sys.argv 是一個包含命令行參數的列表。
- 三、sys.path 包含了一個 Python 解釋器自動查找所需模塊的路徑的列表。
import 語句
想使用 Python 源文件，只需在另外一個源文件裏執行 import 語句，語法以下：
1 import module1[, module2[,... moduleN]
當解釋器遇到 import 語句，若是模塊在當前的搜索路徑就會被導入。
搜索路徑是一個解釋器會先進行搜索的全部目錄的列表。如想要導入模塊 ，須要把命令放在腳本的頂端。
from…import 語句
Python的from語句讓你從模塊中導入一個指定的部分到當前命名空間中，語法以下：
1 from modname import name1[, name2[, ... nameN]]
例如，要導入模塊 fibo 的 fib 函數，使用以下語句：
1 >>> from fibo import fib, fib2 2 >>> fib(500) 3 1 1 2 3 5 8 13 21 34 55 89 144 233 377
這個聲明不會把整個fibo模塊導入到當前的命名空間中，它只會將fibo裏的fib函數引入進來。
2.pyc是什麼
1. Python是一門解釋型語言？
我初學Python時，聽到的關於Python的第一句話就是，Python是一門解釋性語言，我就這樣一直相信下去，直到發現了*.pyc文件的存在。若是是解釋型語言，那麼生成的*.pyc文件是什麼呢？c應該是compiled的縮寫纔對啊！
爲了防止其餘學習Python的人也被這句話誤解，那麼咱們就在文中來澄清下這個問題，而且把一些基礎概念給理清。
2. 解釋型語言和編譯型語言
計算機是不可以識別高級語言的，因此當咱們運行一個高級語言程序的時候，就須要一個「翻譯機」來從事把高級語言轉變成計算機能讀懂的機器語言的過程。這個過程分紅兩類，第一種是編譯，第二種是解釋。
編譯型語言在程序執行以前，先會經過編譯器對程序執行一個編譯的過程，把程序轉變成機器語言。運行時就不須要翻譯，而直接執行就能夠了。最典型的例子就是C語言。
解釋型語言就沒有這個編譯的過程，而是在程序運行的時候，經過解釋器對程序逐行做出解釋，而後直接運行，最典型的例子是Ruby。
經過以上的例子，咱們能夠來總結一下解釋型語言和編譯型語言的優缺點，由於編譯型語言在程序運行以前就已經對程序作出了「翻譯」，因此在運行時就少掉了「翻譯」的過程，因此效率比較高。可是咱們也不能一律而論，一些解釋型語言也能夠經過解釋器的優化來在對程序作出翻譯時對整個程序作出優化，從而在效率上超過編譯型語言。
此外，隨着Java等基於虛擬機的語言的興起，咱們又不能把語言純粹地分紅解釋型和編譯型這兩種。
用Java來舉例，Java首先是經過編譯器編譯成字節碼文件，而後在運行時經過解釋器給解釋成機器文件。因此咱們說Java是一種先編譯後解釋的語言。
3. Python究竟是什麼
其實Python和Java/C#同樣，也是一門基於虛擬機的語言，咱們先來從表面上簡單地瞭解一下Python程序的運行過程吧。
當咱們在命令行中輸入python hello.py時，實際上是激活了Python的「解釋器」，告訴「解釋器」：你要開始工做了。但是在「解釋」以前，其實執行的第一項工做和Java同樣，是編譯。
熟悉Java的同窗能夠想一下咱們在命令行中如何執行一個Java的程序：
javac hello.java
java hello
只是咱們在用Eclipse之類的IDE時，將這兩部給融合成了一部而已。其實Python也同樣，當咱們執行python hello.py時，他也同樣執行了這麼一個過程，因此咱們應該這樣來描述Python，Python是一門先編譯後解釋的語言。
4. 簡述Python的運行過程
在說這個問題以前，咱們先來講兩個概念，PyCodeObject和pyc文件。
咱們在硬盤上看到的pyc天然沒必要多說，而其實PyCodeObject則是Python編譯器真正編譯成的結果。咱們先簡單知道就能夠了，繼續向下看。
當python程序運行時，編譯的結果則是保存在位於內存中的PyCodeObject中，當Python程序運行結束時，Python解釋器則將PyCodeObject寫回到pyc文件中。
當python程序第二次運行時，首先程序會在硬盤中尋找pyc文件，若是找到，則直接載入，不然就重複上面的過程。
因此咱們應該這樣來定位PyCodeObject和pyc文件，咱們說pyc文件實際上是PyCodeObject的一種持久化保存方式。
3.python數據類型
1.數字
Python 數字數據類型用於存儲數值。
數據類型是不容許改變的,這就意味着若是改變數字數據類型得值，將從新分配內存空間。
Python 支持三種不一樣的數值類型：
- 整型(Int) - 一般被稱爲是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，能夠看成 Long 類型使用，因此 Python3 沒有 Python2 的 Long 類型。
- 浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
- 複數( (complex)) - 複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。
Python 數字類型轉換
有時候，咱們須要對數據內置的類型進行轉換，數據類型的轉換，你只須要將數據類型做爲函數名便可。
-
int(x) 將x轉換爲一個整數。
-
float(x) 將x轉換到一個浮點數。
-
complex(x) 將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
-
complex(x, y) 將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。
如下實例將浮點數變量 a 轉換爲整數：
>>> a = 1.0 >>> int(a) 1
2.布爾值
真或假
1 或 0
3.字符串
字符串是 Python 中最經常使用的數據類型。咱們可使用引號('或")來建立字符串。
建立字符串很簡單，只要爲變量分配一個值便可。例如：
var1 = 'Hello World!'
var2 = "Runoob"
4.數據運算
算數運算：
比較運算：
賦值運算：
邏輯運算：
成員運算：
身份運算：
位運算：
運算符優先級：
計算機中能表示的最小單位，是一個二進制位
計算機中能存儲的最小單位，是一個二進制位（bit）
8bit = byte(字節)
1024byte = 1Kbyte
1024Kbyte = 1Mbyte
1024Mb = 1Gb
1024Gb= 1T
5.bytes/str之別
Python 3最重要的新特性大概要算是對文本和二進制數據做了更爲清晰的區分。文本老是Unicode，由str類型表示，二進制數據則由bytes類型表示。Python 3不會以任意隱式的方式混用str和bytes，正是這使得二者的區分特別清晰。你不能拼接字符串和字節包，也沒法在字節包裏搜索字符串（反之亦然），也不能將字符串傳入參數爲字節包的函數（反之亦然）。這是件好事。
無論怎樣，字符串和字節包之間的界線是必然的，下面的圖解很是重要，務請牢記於心：
字符串能夠編碼成字節包，而字節包能夠解碼成字符串。
>>>'€20'.encode('utf-8') b'\xe2\x82\xac20' >>> b'\xe2\x82\xac20'.decode('utf-8') '€20'
這個問題要這麼來看：字符串是文本的抽象表示。字符串由字符組成，字符則是與任何特定二進制表示無關的抽象實體。在操做字符串時，咱們生活在幸福的無知之中。咱們能夠對字符串進行分割和分片，能夠拼接和搜索字符串。咱們並不關心它們內部是怎麼表示的，字符串裏的每一個字符要用幾個字節保存。只有在將字符串編碼成字節包（例如，爲了在信道上發送它們）或從字節包解碼字符串（反向操做）時，咱們纔會開始關注這點。
傳入encode和decode的參數是編碼（或codec）。編碼是一種用二進制數據表示抽象字符的方式。目前有不少種編碼。上面給出的UTF-8是其中一種，下面是另外一種：
>>'€20'.encode('iso-8859-15') b'\xa420' >>> b'\xa420'.decode('iso-8859-15') '€20'
編碼是這個轉換過程當中相當重要的一部分。離了編碼，bytes對象b'\xa420'只是一堆比特位而已。編碼賦予其含義。採用不一樣的編碼，這堆比特位的含義就會大不一樣：
>>> b'\xa420'.decode('windows-1255')
'₪20'
6.列表
序列是Python中最基本的數據結構。序列中的每一個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
Python有6個序列的內置類型，但最多見的是列表和元組。
序列均可以進行的操做包括索引，切片，加，乘，檢查成員。
此外，Python已經內置肯定序列的長度以及肯定最大和最小的元素的方法。
列表是最經常使用的Python數據類型，它能夠做爲一個方括號內的逗號分隔值出現。
列表的數據項不須要具備相同的類型
定義列表
names = ['Alex',"Tenglan",'Eric']
經過下標訪問列表中的元素，下標從0開始計數
>>> names[0]
'Alex'
>>> names[2]
'Eric'
>>> names[-1]
'Eric'
>>> names[-2] #還能夠倒着取
'Tenglan'
切片:取多個元素
>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"] >>> names[1:4] #取下標1至下標4之間的數字，包括1，不包括4 ['Tenglan', 'Eric', 'Rain'] >>> names[1:-1] #取下標1至-1的值，不包括-1 ['Tenglan', 'Eric', 'Rain', 'Tom'] >>> names[0:3] ['Alex', 'Tenglan', 'Eric'] >>> names[:3] #若是是從頭開始取，0能夠忽略，跟上句效果同樣 ['Alex', 'Tenglan', 'Eric'] >>> names[3:] #若是想取最後一個，必須不能寫-1，只能這麼寫 ['Rain', 'Tom', 'Amy'] >>> names[3:-1] #這樣-1就不會被包含了 ['Rain', 'Tom'] >>> names[0::2] #後面的2是表明，每隔一個元素，就取一個 ['Alex', 'Eric', 'Tom'] >>> names[::2] #和上句效果同樣 ['Alex', 'Eric', 'Tom']
追加
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新來的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新來的']
修改
>>> names
['Alex', 'Tenglan', '強行從Eric前面插入', 'Eric', 'Rain', '從eric後面插入試試新姿式', 'Tom', 'Amy', '我是新來的']
>>> names[2] = "該換人了"
>>> names
['Alex', 'Tenglan', '該換人了', 'Eric', 'Rain', '從eric後面插入試試新姿式', 'Tom', 'Amy', '我是新來的']
刪除
>>> del names[2]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '從eric後面插入試試新姿式', 'Tom', 'Amy', '我是新來的']
>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新來的']
>>>
>>> names.remove("Eric") #刪除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新來的']
>>> names.pop() #刪除列表最後一個值
'我是新來的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
擴展
>>> names ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy'] >>> b = [1,2,3] >>> names.extend(b) >>> names ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
拷貝
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
>>> name_copy = names.copy()
>>> name_copy
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
PS：copy分爲淺copy和深copy，更多的請點擊下面的連接
http://www.cnblogs.com/danielStudy/p/6561741.html
統計
>>> names ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3] >>> names.count("Amy") 2
排序&翻轉
>>> names ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3] >>> names.sort() #排序 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: int() < str() #3.0裏不一樣數據類型不能放在一塊兒排序了，擦 >>> names[-3] = '1' >>> names[-2] = '2' >>> names[-1] = '3' >>> names ['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3'] >>> names.sort() >>> names ['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom'] >>> names.reverse() #反轉 >>> names ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
獲取下標
>>> names ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1'] >>> names.index("Amy") 2 #只返回找到的第一個下標
7.元組
元組其實跟列表差很少，也是存一組數，只不是它一旦建立，便不能再修改，因此又叫只讀列表
語法：
names = ("alex","jack","eric")
它只有2個方法，一個是count,一個是index。
8.字典
字典是另外一種可變容器模型，且可存儲任意類型對象。
字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }
鍵必須是惟一的，但值則沒必要。
值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
一個簡單的字典實例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此建立字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
功能：
1 class dict(object): 2 """ 3 dict() -> new empty dictionary 4 dict(mapping) -> new dictionary initialized from a mapping object's 5 (key, value) pairs 6 dict(iterable) -> new dictionary initialized as if via: 7 d = {} 8 for k, v in iterable: 9 d[k] = v 10 dict(**kwargs) -> new dictionary initialized with the name=value pairs 11 in the keyword argument list. For example: dict(one=1, two=2) 12 """ 13 14 def clear(self): # real signature unknown; restored from __doc__ 15 """ 清除內容 """ 16 """ D.clear() -> None. Remove all items from D. """ 17 pass 18 19 def copy(self): # real signature unknown; restored from __doc__ 20 """ 淺拷貝 """ 21 """ D.copy() -> a shallow copy of D """ 22 pass 23 24 @staticmethod # known case 25 def fromkeys(S, v=None): # real signature unknown; restored from __doc__ 26 """ 27 dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. 28 v defaults to None. 29 """ 30 pass 31 32 def get(self, k, d=None): # real signature unknown; restored from __doc__ 33 """ 根據key獲取值，d是默認值 """ 34 """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ 35 pass 36 37 def has_key(self, k): # real signature unknown; restored from __doc__ 38 """ 是否有key """ 39 """ D.has_key(k) -> True if D has a key k, else False """ 40 return False 41 42 def items(self): # real signature unknown; restored from __doc__ 43 """ 全部項的列表形式 """ 44 """ D.items() -> list of D's (key, value) pairs, as 2-tuples """ 45 return [] 46 47 def iteritems(self): # real signature unknown; restored from __doc__ 48 """ 項可迭代 """ 49 """ D.iteritems() -> an iterator over the (key, value) items of D """ 50 pass 51 52 def iterkeys(self): # real signature unknown; restored from __doc__ 53 """ key可迭代 """ 54 """ D.iterkeys() -> an iterator over the keys of D """ 55 pass 56 57 def itervalues(self): # real signature unknown; restored from __doc__ 58 """ value可迭代 """ 59 """ D.itervalues() -> an iterator over the values of D """ 60 pass 61 62 def keys(self): # real signature unknown; restored from __doc__ 63 """ 全部的key列表 """ 64 """ D.keys() -> list of D's keys """ 65 return [] 66 67 def pop(self, k, d=None): # real signature unknown; restored from __doc__ 68 """ 獲取並在字典中移除 """ 69 """ 70 D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 71 If key is not found, d is returned if given, otherwise KeyError is raised 72 """ 73 pass 74 75 def popitem(self): # real signature unknown; restored from __doc__ 76 """ 獲取並在字典中移除 """ 77 """ 78 D.popitem() -> (k, v), remove and return some (key, value) pair as a 79 2-tuple; but raise KeyError if D is empty. 80 """ 81 pass 82 83 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ 84 """ 若是key不存在，則建立，若是存在，則返回已存在的值且不修改 """ 85 """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ 86 pass 87 88 def update(self, E=None, **F): # known special case of dict.update 89 """ 更新 90 {'name':'alex', 'age': 18000} 91 [('name','sbsbsb'),] 92 """ 93 """ 94 D.update([E, ]**F) -> None. Update D from dict/iterable E and F. 95 If E present and has a .keys() method, does: for k in E: D[k] = E[k] 96 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v 97 In either case, this is followed by: for k in F: D[k] = F[k] 98 """ 99 pass 100 101 def values(self): # real signature unknown; restored from __doc__ 102 """ 全部的值 """ 103 """ D.values() -> list of D's values """ 104 return [] 105 106 def viewitems(self): # real signature unknown; restored from __doc__ 107 """ 全部項，只是將內容保存至view對象中 """ 108 """ D.viewitems() -> a set-like object providing a view on D's items """ 109 pass 110 111 def viewkeys(self): # real signature unknown; restored from __doc__ 112 """ D.viewkeys() -> a set-like object providing a view on D's keys """ 113 pass 114 115 def viewvalues(self): # real signature unknown; restored from __doc__ 116 """ D.viewvalues() -> an object providing a view on D's values """ 117 pass 118 119 def __cmp__(self, y): # real signature unknown; restored from __doc__ 120 """ x.__cmp__(y) <==> cmp(x,y) """ 121 pass 122 123 def __contains__(self, k): # real signature unknown; restored from __doc__ 124 """ D.__contains__(k) -> True if D has a key k, else False """ 125 return False 126 127 def __delitem__(self, y): # real signature unknown; restored from __doc__ 128 """ x.__delitem__(y) <==> del x[y] """ 129 pass 130 131 def __eq__(self, y): # real signature unknown; restored from __doc__ 132 """ x.__eq__(y) <==> x==y """ 133 pass 134 135 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 136 """ x.__getattribute__('name') <==> x.name """ 137 pass 138 139 def __getitem__(self, y): # real signature unknown; restored from __doc__ 140 """ x.__getitem__(y) <==> x[y] """ 141 pass 142 143 def __ge__(self, y): # real signature unknown; restored from __doc__ 144 """ x.__ge__(y) <==> x>=y """ 145 pass 146 147 def __gt__(self, y): # real signature unknown; restored from __doc__ 148 """ x.__gt__(y) <==> x>y """ 149 pass 150 151 def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ 152 """ 153 dict() -> new empty dictionary 154 dict(mapping) -> new dictionary initialized from a mapping object's 155 (key, value) pairs 156 dict(iterable) -> new dictionary initialized as if via: 157 d = {} 158 for k, v in iterable: 159 d[k] = v 160 dict(**kwargs) -> new dictionary initialized with the name=value pairs 161 in the keyword argument list. For example: dict(one=1, two=2) 162 # (copied from class doc) 163 """ 164 pass 165 166 def __iter__(self): # real signature unknown; restored from __doc__ 167 """ x.__iter__() <==> iter(x) """ 168 pass 169 170 def __len__(self): # real signature unknown; restored from __doc__ 171 """ x.__len__() <==> len(x) """ 172 pass 173 174 def __le__(self, y): # real signature unknown; restored from __doc__ 175 """ x.__le__(y) <==> x<=y """ 176 pass 177 178 def __lt__(self, y): # real signature unknown; restored from __doc__ 179 """ x.__lt__(y) <==> x<y """ 180 pass 181 182 @staticmethod # known case of __new__ 183 def __new__(S, *more): # real signature unknown; restored from __doc__ 184 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 185 pass 186 187 def __ne__(self, y): # real signature unknown; restored from __doc__ 188 """ x.__ne__(y) <==> x!=y """ 189 pass 190 191 def __repr__(self): # real signature unknown; restored from __doc__ 192 """ x.__repr__() <==> repr(x) """ 193 pass 194 195 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 196 """ x.__setitem__(i, y) <==> x[i]=y """ 197 pass 198 199 def __sizeof__(self): # real signature unknown; restored from __doc__ 200 """ D.__sizeof__() -> size of D in memory, in bytes """ 201 pass 202 203 __hash__ = None 204 205 dict
字典鍵的特性
字典值能夠沒有限制地取任何python對象，既能夠是標準的對象，也能夠是用戶定義的，但鍵不行。
兩個重要的點須要記住：
1）不容許同一個鍵出現兩次。建立時若是同一個鍵被賦值兩次，後一個值會被記住，以下實例：
1 #!/usr/bin/python3 2 dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鳥'} 3 print ("dict['Name']: ", dict['Name'])
以上實例輸出結果：
1 dict['Name']: 小菜鳥
2）鍵必須不可變，因此能夠用數字，字符串或元組充當，而用列表就不行，以下實例：
1 #!/usr/bin/python3 2 dict = {['Name']: 'Runoob', 'Age': 7} 3 print ("dict['Name']: ", dict['Name'])
以上實例輸出結果：
1 Traceback (most recent call last): 2 File "test.py", line 3, in <module> 3 dict = {['Name']: 'Runoob', 'Age': 7} 4 TypeError: unhashable type: 'list'
9.字符串經常使用操做
特性：不可修改
name.capitalize() 首字母大寫 name.casefold() 大寫所有變小寫 name.center(50,"-") 輸出 '---------------------Alex Li----------------------' name.count('lex') 統計 lex出現次數 name.encode() 將字符串編碼成bytes格式 name.endswith("Li") 判斷字符串是否以 Li結尾 "Alex\tLi".expandtabs(10) 輸出'Alex Li'， 將\t轉換成多長的空格 name.find('A') 查找A,找到返回其索引， 找不到返回-1 format : >>> msg = "my name is {}, and age is {}" >>> msg.format("alex",22) 'my name is alex, and age is 22' >>> msg = "my name is {1}, and age is {0}" >>> msg.format("alex",22) 'my name is 22, and age is alex' >>> msg = "my name is {name}, and age is {age}" >>> msg.format(age=22,name="ale") 'my name is ale, and age is 22' format_map >>> msg.format_map({'name':'alex','age':22}) 'my name is alex, and age is 22' msg.index('a') 返回a所在字符串的索引 '9aA'.isalnum() True '9'.isdigit() 是否整數 name.isnumeric name.isprintable name.isspace name.istitle name.isupper "|".join(['alex','jack','rain']) 'alex|jack|rain' maketrans >>> intab = "aeiou" #This is the string having actual characters. >>> outtab = "12345" #This is the string having corresponding mapping character >>> trantab = str.maketrans(intab, outtab) >>> >>> str = "this is string example....wow!!!" >>> str.translate(trantab) 'th3s 3s str3ng 2x1mpl2....w4w!!!' msg.partition('is') 輸出 ('my name ', 'is', ' {name}, and age is {age}') >>> "alex li, chinese name is lijie".replace("li","LI",1) 'alex LI, chinese name is lijie' msg.swapcase 大小寫互換 >>> msg.zfill(40) '00000my name is {name}, and age is {age}' >>> n4.ljust(40,"-") 'Hello 2orld-----------------------------' >>> n4.rjust(40,"-") '-----------------------------Hello 2orld' >>> b="ddefdsdff_哈哈" >>> b.isidentifier() #檢測一段字符串能否被看成標誌符，便是否符合變量命名規則 True
10.程序練習
程序: 三級菜單
要求:
- 打印省、市、縣三級菜單
- 可返回上一級
- 可隨時退出程序
1 menu = { 2 '北京':{ 3 '海淀':{ 4 '五道口':{ 5 'soho':{}, 6 '網易':{}, 7 'google':{} 8 }, 9 '中關村':{ 10 '愛奇藝':{}, 11 '汽車之家':{}, 12 'youku':{}, 13 }, 14 '上地':{ 15 '百度':{}, 16 }, 17 }, 18 '昌平':{ 19 '沙河':{ 20 '老男孩':{}, 21 '北航':{}, 22 }, 23 '天通苑':{}, 24 '回龍觀':{}, 25 }, 26 '朝陽':{}, 27 '東城':{}, 28 }, 29 '上海':{ 30 '閔行':{ 31 "人民廣場":{ 32 '炸雞店':{} 33 } 34 }, 35 '閘北':{ 36 '火車戰':{ 37 '攜程':{} 38 } 39 }, 40 '浦東':{}, 41 }, 42 '山東':{}, 43 } 44 45 46 exit_flag = False 47 current_layer = menu 48 49 layers = [menu] 50 51 while not exit_flag: 52 for k in current_layer: 53 print(k) 54 choice = input(">>:").strip() 55 if choice == "b": 56 current_layer = layers[-1] 57 #print("change to laster", current_layer) 58 layers.pop() 59 elif choice not in current_layer:continue 60 else: 61 layers.append(current_layer) 62 current_layer = current_layer[choice] 63
- 1. 學習python心路歷程
- 2. 學習Python的心路歷程
- 3. Python學習心路歷程-day6
- 4. Python學習心路歷程-day7
- 5. Python學習心路歷程-day5
- 6. Python學習心路歷程-day3
- 7. Python學習心路歷程-day1
- 8. Python學習心路歷程-day4
- 9. 學習的心路歷程
- 10. Python心路歷程
- 更多相關文章...
- • 您已經學習了 XML Schema，下一步學習什麼呢？ - XML Schema 教程
- • 我們已經學習了 SQL，下一步學習什麼呢？ - SQL 教程
- • 適用於PHP初學者的學習線路和建議
- • Tomcat學習筆記（史上最全tomcat學習筆記）
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. python的安裝和Hello，World編寫
- 2. 重磅解讀：K8s Cluster Autoscaler模塊及對應華爲雲插件Deep Dive
- 3. 鴻蒙學習筆記2（永不斷更）
- 4. static關鍵字 和構造代碼塊
- 5. JVM筆記
- 6. 無法啓動 C/C++ 語言服務器。IntelliSense 功能將被禁用。錯誤: Missing binary at c:\Users\MSI-NB\.vscode\extensions\ms-vsc
- 7. 【Hive】Hive返回碼狀態含義
- 8. Java樹形結構遞歸（以時間換空間）和非遞歸（以空間換時間）
- 9. 數據預處理---缺失值
- 10. 都要2021年了，現代C++有什麼值得我們學習的？
- 1. 學習python心路歷程
- 2. 學習Python的心路歷程
- 3. Python學習心路歷程-day6
- 4. Python學習心路歷程-day7
- 5. Python學習心路歷程-day5
- 6. Python學習心路歷程-day3
- 7. Python學習心路歷程-day1
- 8. Python學習心路歷程-day4
- 9. 學習的心路歷程
- 10. Python心路歷程