第二部分 python基礎 day10\11\12 運算符與基本數據類型

python開發IDE：pycharm、elipse

專業版、不要漢化（不然不少好用的功能用不了）

1、運算符

一、算數運算：結果爲數值

count = count + 1          count += 1

count = count - 1          count -= 1

count = count * 1          count *= 1

count = count / 1          count /= 1

二、比較運算：結果爲真假（布爾型）

not   取反：如not true = false

三、賦值運算：結果爲數值

四、邏輯運算：結果爲真假（布爾型）

運算參數優先級：有括號先算括號的；從前日後依次計算。

u = A and B or C and D

（1）若是and前面的A假，A and B的結果直接輸出假；若是A真看and後面的B決定A and B真假

（2）若是or前面真，A and B or C直接輸出真；若是or前爲假，繼續看or後面的C決定A and B or C真假

總結：True OR =======》True

　　　 False AND =====》False

五、成員運算：結果爲真假（布爾型）

name = "鄭建文"

if "建" in name:　　#判斷是否包含
    print('OK')
else:
    print('error')

多行加註釋：選中多行後，ctrl+？便可

2、基本數據類型

一、數字    int（整型）

　　在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647
　　在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807

#int（）將字符串a轉換爲字符b
a = "123"
print(type(a),a)　　　　　　#打印a的類型<class 'str'> 123
num = int(a)　　　　　　　　　#不加base默認直接脫去引號
print(type(num)，num)　　　　#打印num的類型<class 'int'> 123
c = "123a"
d = int(c)　　　　　　　　　　#會報錯，由於轉換不了
e = "0011"
f = int(e,base=2)　　　　　　#將e以二進制轉換爲十進制

e = "a"
f = int(e,base=16)　　　　　　#將e以十六進制轉換爲十進制，輸出結果爲10
print(f)

#bit_length（）

age = 10　　　　　　　　　　#該數字的二進制至少須要幾位：1,01,10,11,100,101,110,111.。。。。
v = age.bit_length()
print(v)

 

Python3中數字無論多大，都是int，不存在long（長整型）。

看介紹，按住Ctrl鍵，會有小手連接，打開就至關於help。此法就能夠看int類型能幹嗎，有哪些函數。

二、布爾值bool

　　真True或假False

　　1 或 0

三、字符串str

7個基本魔法：join(), split(), find(), strip(), upper(), lower()，replace()

灰魔法5個：適用於全部數據類型
#1.索引，下標，獲取字符串中某一個字符或者下標
test =  "tjvjlxmo"
v = test[3]    
print(v)              #j

#2. 切片
v=test[0:3]         #左閉右開取出012
v= test[0:-1]       #-1表示直接到字符串末尾,可是此時取不到最後一位，依舊知足左閉右開；負幾就表明倒着數幾個
 　　　　　　　　　　　　
#3.  len()求數據類型長度，獲取字符串由多少個字符組成
#對於中文字符串而言，在python3中中文直接對應漢字個數。
#在python2.7中頭部有utf8，一個漢字由三個字節組成，從而一個漢字算三個
v = len[test]
print(v)
v1 = test.split('v')
print(v1)                    #['tj','jlxm']
#列表就是用中括號括起來，裏面元素見用逗號分隔開，split獲得的結果就是列表[11,2,2,58,'asjilnv']。用len求列表長度，就是求列表中逗號分隔出來了幾個元素，不是列表具體元素長度相加

#將原字符串一個個輸出，用while實現
test = "東南大學位於江蘇省南京市"
index = 0
while index < len(test)：
     v = test[index]
    print(v)
    index +=1
print('========')

#4. 用for語句實現,對應每一個變量名item至關於index，每次循環自增一次，指向test中對應位置的字符

#4. for語句中仍然支持break和continue

 for item in test: print(item)

# 4. range()默認建立連續的整數。range(100)=range(0,100)
# range(0,100,5)每五個建立一個，即第三個參數表明步長。經過設置步長從而建立不連續的整數
# 在python2.7中會直接在內存中建立range指定個數的數字；
# 但在python3當中range執行完不會馬上建立，只有開始調用for循環以後纔會開始一個個按照循環次數需求建立
test = range(100)    #默認建立0-99
for item in test:
    print(item)

# 將文字對應的索引打印出來,而不是原字符串
test = input(">>>")
print(test)         #qwe
g = len(test)　　　　#測長度3
print(g)
r = range(0,g)      #(0,3)
for item in r:
　　print(item,test[item])   
0 q   
1 w   
2 e
#將以上代碼簡化爲：

  test = input(">>>")

  for item in range(0,len(test)):

　　print(item,test[item]) 

 1 test = "alex"
 2 
 3 #首字母大寫
 4 v = test.capitaliza()
 5 print(v)                      #結果Alex
 6 
 7 #將字符串中全部字符所有大寫
 8 v7 = test.upper()
 9 print(v7)  
10 
11 #全體變小寫
12 v1 = test.casefold()    #更厲害，某些國家的也能變
13 print(v1)
14 v2 = test.lower()
15 print(v2)
16 
17 #一共n=20個位置，將test字符串放中間
18 test. center(20)    #空白處爲空格填充
19 test. center(20,"*")    #空白處爲*填充
20 test. center(20,"中")    #空白處爲"中"填充
21 test. center(20,"9")    #空白處爲9填充，但只能寫一個字符。如99就不行
22 
23 #計算某字符/或者字符子序列在原字符串中出現的次數
24 #count(self, sub, start=None, end=None)
25 #將原字符串從0開始編號
26 t = "alexalexrjs"
27 v3 = t.count('e')   
28 v4 = t.count('ex')    
29 v5 = t.count('ex',5,6)    #從編號5位起，編號6位中止.計算ex出現次數
30 print(v3)
31 print(v4)
32 print(v5)
33 
34 #查看字符串是否是以某字符/或字符子序列結尾ends，開頭startswith
35 #結果返回True/False
36 #endswith(self, suffix, start=None, end=None)
37 #startswith(self, suffix, start=None, end=None)
38 v6 = test.endswith('e')
39 print(v6)
40 
41 #在原字符串開始找相應字符子序列，找到後獲取位置（從0開始編號）
42 #若沒找到，返回-1
43 #find(self, sub, start=None, end=None)
44 v8 = test.find('ex'，5,7)
45 print(v8)
46 
47 #格式化1：將字符串中的佔位符替換爲相應數值
48 #format(*arg,**kwargs)
49 t2 = 'i am {name}, age {a}'
50 print(t2)                              #i am {name}, age {a}
51 v9 = test.format(name='alex', a=19)        #'i am alex, age 19
52 
53 t3 = 'i am {0}, age {1}'               #從0編號依次開始替換佔位符
54 v10 = test.format('alex', 19)         #'i am alex, age 19
55 
56 #格式化2：傳一個字典，格式上與format不同了，但效果本質同樣
57 #format_map(self,mapping)
58 v11 = test.format_map({"name":'alex', "a":19})
59 #若是中括號內是name，就把alex替換
60 
61 #index找不到就直接報錯。找到了就返回位置
62 #find比index更好用，index語句能夠忽略
63 v12 = test.index('ex')
64 print('v12')
65 
66 #isalnum(self)
67 #檢測字符串中只有數字、字母時爲True，還有別的返回False
68 t4 = "uasf890_+"
69 v13 = t4.isalnum()
70 print('v13')                                                      

str函數列舉

#expandtabs()
t1 = "12345678\t9"
v1 = t1.expandtabs(6)
print(v,len(v))         
#12345678    9  13 （其實78以後補4個空格，一塊兒爲6個位置）    
#每六個一組，找裏面有沒有\t，一旦出現\t，則不看\t以後的，把\t和它以前的一組一塊兒總佔位6個。例如：若某一組爲hsj\t，則「hsj   」\t補三個空格，再從\t以後從新開始新的組繼續找。
#用途:製成一個表格,從而按列對齊
t2 = "username\temail\tpassword\nJosie\tJosie@qq.com\t124555\nJosie\tJosie@qq.com\t124555\nJosie\tJosie@qq.com\t124555\nJosie\tJosie@qq.com\t124555\n"      
v2 = t2.expandtabs(20)

#isalpha(self)只含字母、漢字
#isalnum(self)只含數字
#isdecimal()斷定是否爲數字（十進制小數），但這個用的多 
#isdigit()斷定是否爲數字（還支持一些特殊形式的數字判別，如圈1）
#isnumeric()斷定是否爲數字,支持中文‘二’
#isidentifier()是否爲標識符，只要知足由字母數字下劃線組成就爲True
#islower(self)判斷是否是全小寫
#lower()將字符串所有變成小寫
#isupper(self)判斷是否是全大寫
#upper()將字符串所有變成大寫
#isprintable(self)在打印字符串的時候，是否存在不可顯示的字符（如\t,\n等）
#isspace(self)判斷是否全是空格
#istitle(self)標題中每一個單詞首字母大寫，title()可將字符串改爲首字母全大寫的形式，即變成標題

#join()加字符串，在原來字符串中每一個字符中加t對應字符串（t至關於分隔符）函數內部就是加循環
test = "你是風兒我是沙"
print(test)
t = '   '
v = t.join(test)
print(v) 


# ljust()與center（字符串放中間）對比，左邊是原字符串，右邊添加指定字符
# rjust()右邊是原字符串，左邊添加指定字符
# zfill()右邊是原字符串，左邊添加0
test = "alex"
v = test.1just(20,'*')
print(v)
v = t.join(test)
print(v) 

#lstrip()去掉左邊空格，\t ，\n，
#rstrp()去掉右邊空格，\t ，\n，
#strip()去掉左右空格，\t ，\n，
#在括號內能夠自行添加別的想去除的字符串，找能匹配的最大子序列(正則匹配)
test = "xalex"
v = test.rstrip('9lexex')  #從右邊開始
print(v)

 1 #maketrans與translate一塊兒用，maketrans先建立對應關係
 2 #translate進行對應關係的替換
 3 v1 = "jsdbvli;zxcjvo;jaeiouasu;igdvhb;9psdio"
 4 new_v1 = v1.maketrans("aeiou","12345")
 5 print(v1.translate(new_v1))  
 6  
 7 #partition()在test中找到括號內的字符（只算第一個）後，將原字符串以該字符分割成三份，從左邊開始匹配。括號內只能傳待匹配的字符參數。匹配分割後結果中仍有原字符，單獨成一個字符串  

 8 #test.rpartition()從右邊開始匹配  
 9 #test.split()只填字符默認把全部匹配的字符都劃分開。若傳匹配次數，則按匹配次數進行相應次數的分割。但原匹配字符(分隔符)會消失，即z不見了 
 10 #test.rsplit() 
 11 test = "dujhnvjzxnonlmzkd" 
 12 v2 = test.partition('z') 
 13 v3 = test.rpartition('z') 
 14 v4 = test.split('z') 
 15 v5 = test.rsplit('z') 
 16 print(v2) #["dujhnvj","z","xnonlmzkd"] 
 17 print(v3) #["dujhnvjzxnonlm","z","kd"] 
 18 print(v4) #["dujhnvj","xnonlm","kd"]
 19 print(v5) #["dujhnvj","xnonlm","kd"]
 20 #用途：計算字符算數表達式："1*2/3+5/7",經過partition分割提取到數字和運算表達式 
 21
 22 #splitlines()只根據換行符\n進行分割,根據True/False決定是否保留換行\n若不寫默認False，不保留換行符
 23 test = "dujh\nvjzx\no\nlmzkd"
 24 v7 = test.splitlines() #['dujh','vjzx','o','lmzkd']
 25 v8 = test.splitlines(True) #['dujh\n','vjzx\n','o\n','lmzkd']
 26 v2 = test.splitlines(False) #['dujh','vjzx','o','lmzkd']
 27
 28 #startwith()以某個字符開頭
 29 #endswith()以某個字符結尾
 30 #swapcase()大小寫轉換

  1 class str(basestring):
  2     """
  3     str(object='') -> string
  4     
  5     Return a nice string representation of the object.
  6     If the argument is a string, the return value is the same object.
  7     """
  8     def capitalize(self):  
  9         """ 首字母變大寫 """
 10         """
 11         S.capitalize() -> string
 12         
 13         Return a copy of the string S with only its first character
 14         capitalized.
 15         """
 16         return ""
 17 
 18     def center(self, width, fillchar=None):  
 19         """ 內容居中，width：總長度；fillchar：空白處填充內容，默認無 """
 20         """
 21         S.center(width[, fillchar]) -> string
 22         
 23         Return S centered in a string of length width. Padding is
 24         done using the specified fill character (default is a space)
 25         """
 26         return ""
 27 
 28     def count(self, sub, start=None, end=None):  
 29         """ 子序列個數 """
 30         """
 31         S.count(sub[, start[, end]]) -> int
 32         
 33         Return the number of non-overlapping occurrences of substring sub in
 34         string S[start:end].  Optional arguments start and end are interpreted
 35         as in slice notation.
 36         """
 37         return 0
 38 
 39     def decode(self, encoding=None, errors=None):  
 40         """ 解碼 """
 41         """
 42         S.decode([encoding[,errors]]) -> object
 43         
 44         Decodes S using the codec registered for encoding. encoding defaults
 45         to the default encoding. errors may be given to set a different error
 46         handling scheme. Default is 'strict' meaning that encoding errors raise
 47         a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 48         as well as any other name registered with codecs.register_error that is
 49         able to handle UnicodeDecodeErrors.
 50         """
 51         return object()
 52 
 53     def encode(self, encoding=None, errors=None):  
 54         """ 編碼，針對unicode """
 55         """
 56         S.encode([encoding[,errors]]) -> object
 57         
 58         Encodes S using the codec registered for encoding. encoding defaults
 59         to the default encoding. errors may be given to set a different error
 60         handling scheme. Default is 'strict' meaning that encoding errors raise
 61         a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 62         'xmlcharrefreplace' as well as any other name registered with
 63         codecs.register_error that is able to handle UnicodeEncodeErrors.
 64         """
 65         return object()
 66 
 67     def endswith(self, suffix, start=None, end=None):  
 68         """ 是否以 xxx 結束 """
 69         """
 70         S.endswith(suffix[, start[, end]]) -> bool
 71         
 72         Return True if S ends with the specified suffix, False otherwise.
 73         With optional start, test S beginning at that position.
 74         With optional end, stop comparing S at that position.
 75         suffix can also be a tuple of strings to try.
 76         """
 77         return False
 78 
 79     def expandtabs(self, tabsize=None):  
 80         """ 將tab轉換成空格，默認一個tab轉換成8個空格 """
 81         """
 82         S.expandtabs([tabsize]) -> string
 83         
 84         Return a copy of S where all tab characters are expanded using spaces.
 85         If tabsize is not given, a tab size of 8 characters is assumed.
 86         """
 87         return ""
 88 
 89     def find(self, sub, start=None, end=None):  
 90         """ 尋找子序列位置，若是沒找到，返回 -1 """
 91         """
 92         S.find(sub [,start [,end]]) -> int
 93         
 94         Return the lowest index in S where substring sub is found,
 95         such that sub is contained within S[start:end].  Optional
 96         arguments start and end are interpreted as in slice notation.
 97         
 98         Return -1 on failure.
 99         """
100         return 0
101 
102     def format(*args, **kwargs): # known special case of str.format
103         """ 字符串格式化，動態參數，將函數式編程時細說 """
104         """
105         S.format(*args, **kwargs) -> string
106         
107         Return a formatted version of S, using substitutions from args and kwargs.
108         The substitutions are identified by braces ('{' and '}').
109         """
110         pass
111 
112     def index(self, sub, start=None, end=None):  
113         """ 子序列位置，若是沒找到，報錯 """
114         S.index(sub [,start [,end]]) -> int
115         
116         Like S.find() but raise ValueError when the substring is not found.
117         """
118         return 0
119 
120     def isalnum(self):  
121         """ 是不是字母和數字 """
122         """
123         S.isalnum() -> bool
124         
125         Return True if all characters in S are alphanumeric
126         and there is at least one character in S, False otherwise.
127         """
128         return False
129 
130     def isalpha(self):  
131         """ 是不是字母 """
132         """
133         S.isalpha() -> bool
134         
135         Return True if all characters in S are alphabetic
136         and there is at least one character in S, False otherwise.
137         """
138         return False
139 
140     def isdigit(self):  
141         """ 是不是數字 """
142         """
143         S.isdigit() -> bool
144         
145         Return True if all characters in S are digits
146         and there is at least one character in S, False otherwise.
147         """
148         return False
149 
150     def islower(self):  
151         """ 是否小寫 """
152         """
153         S.islower() -> bool
154         
155         Return True if all cased characters in S are lowercase and there is
156         at least one cased character in S, False otherwise.
157         """
158         return False
159 
160     def isspace(self):  
161         """
162         S.isspace() -> bool
163         
164         Return True if all characters in S are whitespace
165         and there is at least one character in S, False otherwise.
166         """
167         return False
168 
169     def istitle(self):  
170         """
171         S.istitle() -> bool
172         
173         Return True if S is a titlecased string and there is at least one
174         character in S, i.e. uppercase characters may only follow uncased
175         characters and lowercase characters only cased ones. Return False
176         otherwise.
177         """
178         return False
179 
180     def isupper(self):  
181         """
182         S.isupper() -> bool
183         
184         Return True if all cased characters in S are uppercase and there is
185         at least one cased character in S, False otherwise.
186         """
187         return False
188 
189     def join(self, iterable):  
190         """ 鏈接 """
191         """
192         S.join(iterable) -> string
193         
194         Return a string which is the concatenation of the strings in the
195         iterable.  The separator between elements is S.
196         """
197         return ""
198 
199     def ljust(self, width, fillchar=None):  
200         """ 內容左對齊，右側填充 """
201         """
202         S.ljust(width[, fillchar]) -> string
203         
204         Return S left-justified in a string of length width. Padding is
205         done using the specified fill character (default is a space).
206         """
207         return ""
208 
209     def lower(self):  
210         """ 變小寫 """
211         """
212         S.lower() -> string
213         
214         Return a copy of the string S converted to lowercase.
215         """
216         return ""
217 
218     def lstrip(self, chars=None):  
219         """ 移除左側空白 """
220         """
221         S.lstrip([chars]) -> string or unicode
222         
223         Return a copy of the string S with leading whitespace removed.
224         If chars is given and not None, remove characters in chars instead.
225         If chars is unicode, S will be converted to unicode before stripping
226         """
227         return ""
228 
229     def partition(self, sep):  
230         """ 分割，前，中，後三部分 """
231         """
232         S.partition(sep) -> (head, sep, tail)
233         
234         Search for the separator sep in S, and return the part before it,
235         the separator itself, and the part after it.  If the separator is not
236         found, return S and two empty strings.
237         """
238         pass
239 
240     def replace(self, old, new, count=None):  
241         """ 替換 """
242         """
243         S.replace(old, new[, count]) -> string
244         
245         Return a copy of string S with all occurrences of substring
246         old replaced by new.  If the optional argument count is
247         given, only the first count occurrences are replaced.
248         """
249         return ""
250 
251     def rfind(self, sub, start=None, end=None):  
252         """
253         S.rfind(sub [,start [,end]]) -> int
254         
255         Return the highest index in S where substring sub is found,
256         such that sub is contained within S[start:end].  Optional
257         arguments start and end are interpreted as in slice notation.
258         
259         Return -1 on failure.
260         """
261         return 0
262 
263     def rindex(self, sub, start=None, end=None):  
264         """
265         S.rindex(sub [,start [,end]]) -> int
266         
267         Like S.rfind() but raise ValueError when the substring is not found.
268         """
269         return 0
270 
271     def rjust(self, width, fillchar=None):  
272         """
273         S.rjust(width[, fillchar]) -> string
274         
275         Return S right-justified in a string of length width. Padding is
276         done using the specified fill character (default is a space)
277         """
278         return ""
279 
280     def rpartition(self, sep):  
281         """
282         S.rpartition(sep) -> (head, sep, tail)
283         
284         Search for the separator sep in S, starting at the end of S, and return
285         the part before it, the separator itself, and the part after it.  If the
286         separator is not found, return two empty strings and S.
287         """
288         pass
289 
290     def rsplit(self, sep=None, maxsplit=None):  
291         """
292         S.rsplit([sep [,maxsplit]]) -> list of strings
293         
294         Return a list of the words in the string S, using sep as the
295         delimiter string, starting at the end of the string and working
296         to the front.  If maxsplit is given, at most maxsplit splits are
297         done. If sep is not specified or is None, any whitespace string
298         is a separator.
299         """
300         return []
301 
302     def rstrip(self, chars=None):  
303         """
304         S.rstrip([chars]) -> string or unicode
305         
306         Return a copy of the string S with trailing whitespace removed.
307         If chars is given and not None, remove characters in chars instead.
308         If chars is unicode, S will be converted to unicode before stripping
309         """
310         return ""
311 
312     def split(self, sep=None, maxsplit=None):  
313         """ 分割， maxsplit最多分割幾回 """
314         """
315         S.split([sep [,maxsplit]]) -> list of strings
316         
317         Return a list of the words in the string S, using sep as the
318         delimiter string.  If maxsplit is given, at most maxsplit
319         splits are done. If sep is not specified or is None, any
320         whitespace string is a separator and empty strings are removed
321         from the result.
322         """
323         return []
324 
325     def splitlines(self, keepends=False):  
326         """ 根據換行分割 """
327         """
328         S.splitlines(keepends=False) -> list of strings
329         
330         Return a list of the lines in S, breaking at line boundaries.
331         Line breaks are not included in the resulting list unless keepends
332         is given and true.
333         """
334         return []
335 
336     def startswith(self, prefix, start=None, end=None):  
337         """ 是否起始 """
338         """
339         S.startswith(prefix[, start[, end]]) -> bool
340         
341         Return True if S starts with the specified prefix, False otherwise.
342         With optional start, test S beginning at that position.
343         With optional end, stop comparing S at that position.
344         prefix can also be a tuple of strings to try.
345         """
346         return False
347 
348     def strip(self, chars=None):  
349         """ 移除兩段空白 """
350         """
351         S.strip([chars]) -> string or unicode
352         
353         Return a copy of the string S with leading and trailing
354         whitespace removed.
355         If chars is given and not None, remove characters in chars instead.
356         If chars is unicode, S will be converted to unicode before stripping
357         """
358         return ""
359 
360     def swapcase(self):  
361         """ 大寫變小寫，小寫變大寫 """
362         """
363         S.swapcase() -> string
364         
365         Return a copy of the string S with uppercase characters
366         converted to lowercase and vice versa.
367         """
368         return ""
369 
370     def title(self):  
371         """
372         S.title() -> string
373         
374         Return a titlecased version of S, i.e. words start with uppercase
375         characters, all remaining cased characters have lowercase.
376         """
377         return ""
378 
379     def translate(self, table, deletechars=None):  
380         """
381         轉換，須要先作一個對應表，最後一個表示刪除字符集合
382         intab = "aeiou"
383         outtab = "12345"
384         trantab = maketrans(intab, outtab)
385         str = "this is string example....wow!!!"
386         print str.translate(trantab, 'xm')
387         """
388 
389         """
390         S.translate(table [,deletechars]) -> string
391         
392         Return a copy of the string S, where all characters occurring
393         in the optional argument deletechars are removed, and the
394         remaining characters have been mapped through the given
395         translation table, which must be a string of length 256 or None.
396         If the table argument is None, no translation is applied and
397         the operation simply removes the characters in deletechars.
398         """
399         return ""
400 
401     def upper(self):  
402         """
403         S.upper() -> string
404         
405         Return a copy of the string S converted to uppercase.
406         """
407         return ""
408 
409     def zfill(self, width):  
410         """方法返回指定長度的字符串，原字符串右對齊，前面填充0。"""
411         """
412         S.zfill(width) -> string
413         
414         Pad a numeric string S with zeros on the left, to fill a field
415         of the specified width.  The string S is never truncated.
416         """
417         return ""
418 
419     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
420         pass
421 
422     def _formatter_parser(self, *args, **kwargs): # real signature unknown
423         pass
424 
425     def __add__(self, y):  
426         """ x.__add__(y) <==> x+y """
427         pass
428 
429     def __contains__(self, y):  
430         """ x.__contains__(y) <==> y in x """
431         pass
432 
433     def __eq__(self, y):  
434         """ x.__eq__(y) <==> x==y """
435         pass
436 
437     def __format__(self, format_spec):  
438         """
439         S.__format__(format_spec) -> string
440         
441         Return a formatted version of S as described by format_spec.
442         """
443         return ""
444 
445     def __getattribute__(self, name):  
446         """ x.__getattribute__('name') <==> x.name """
447         pass
448 
449     def __getitem__(self, y):  
450         """ x.__getitem__(y) <==> x[y] """
451         pass
452 
453     def __getnewargs__(self, *args, **kwargs): # real signature unknown
454         pass
455 
456     def __getslice__(self, i, j):  
457         """
458         x.__getslice__(i, j) <==> x[i:j]
459                    
460                    Use of negative indices is not supported.
461         """
462         pass
463 
464     def __ge__(self, y):  
465         """ x.__ge__(y) <==> x>=y """
466         pass
467 
468     def __gt__(self, y):  
469         """ x.__gt__(y) <==> x>y """
470         pass
471 
472     def __hash__(self):  
473         """ x.__hash__() <==> hash(x) """
474         pass
475 
476     def __init__(self, string=''): # known special case of str.__init__
477         """
478         str(object='') -> string
479         
480         Return a nice string representation of the object.
481         If the argument is a string, the return value is the same object.
482         # (copied from class doc)
483         """
484         pass
485 
486     def __len__(self):  
487         """ x.__len__() <==> len(x) """
488         pass
489 
490     def __le__(self, y):  
491         """ x.__le__(y) <==> x<=y """
492         pass
493 
494     def __lt__(self, y):  
495         """ x.__lt__(y) <==> x<y """
496         pass
497 
498     def __mod__(self, y):  
499         """ x.__mod__(y) <==> x%y """
500         pass
501 
502     def __mul__(self, n):  
503         """ x.__mul__(n) <==> x*n """
504         pass
505 
506     @staticmethod # known case of __new__
507     def __new__(S, *more):  
508         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
509         pass
510 
511     def __ne__(self, y):  
512         """ x.__ne__(y) <==> x!=y """
513         pass
514 
515     def __repr__(self):  
516         """ x.__repr__() <==> repr(x) """
517         pass
518 
519     def __rmod__(self, y):  
520         """ x.__rmod__(y) <==> y%x """
521         pass
522 
523     def __rmul__(self, n):  
524         """ x.__rmul__(n) <==> n*x """
525         pass
526 
527     def __sizeof__(self):  
528         """ S.__sizeof__() -> size of S in memory, in bytes """
529         pass
530 
531     def __str__(self):  
532         """ x.__str__() <==> str(x) """
533         pass
534 
535 str

Str函數定義

字符串經常使用功能：

• 移除空白
• 分割
• 長度
• 索引
• 切片

注意：字符串一旦建立就不可修改，若是修改將會建立一個新的字符串。例如字符串作加法時，將新開闢一個內存來存放新的和字符串。

內存中空間是連續的。

#replace()替換指定字符串，並能夠加上替換次數
test =  "aljjalbdalhalikal"
v = test.replace("al",'ixjhznasj')
v = test.replace("al",'ixjhznasj',2)
print(v)
print(v1)

# formate
template = "i am {name}, age : {age}"
v = template.formate(name = ‘alex’, 'age' = 19)  #正確傳值法
print(v)

#v = template.formate({'name' : ‘alex’, 'age' : 19)   #formate中參數傳字典，不能直接這麼寫會報錯，加兩個**在字典前面

v = template.formate(**{'name' : ‘alex’, 'age' : 19)
print(v)

#補充：在查閱這些函數的def時，若是看到參數列表中**kwargs，表示能夠經過在字典前加兩個**的方式傳入字典做爲參數

四、列表list

建立列表對象name_list：

name_list = ['alex', 'seven', 'eric']

name_list ＝ list(['alex', 'seven', 'eric'])

1). 列表裏還能嵌套列表，能夠無限嵌套。列表至關於集合，其中元素能夠是任意數據類型

2). 逗號分割，[  ]括起來

3). 能夠經過切片取值list[3:5]結果爲列表、索引取值 li[3]

     尋找嵌套內列表的值   li[4][1][0]會獲得19；若是再加一個[1]，將獲得9 。即 li[4][1][0][1] = 9

4). 支持for   while循環  break continue   

5). 列表能夠被刪除（能夠經過索引、切片刪 del li[1]   del li[1:6]）、修改：能夠經過索引修改，也能夠經過切片修改：li[1:3] = [120,190]）

列表內並不是連續存，以 鏈表形式存：存本元素及下一元素的地址，不用從新開闢內存。從而能夠修改他的數值，同時修改它其中的元素地址值就能夠了。

li[1] = 120
print(li)
li[1] = [11,22,33,44]
print(li)

li[1:3] = [120,90]
print(li)
#對比字符串：
    s = ’alex‘     
    s[0] = 'e'    #直接報錯
# 字符串修改：
    s = ’alex‘
    s = s.replace('l','el')     #此時變量名s就是一個指向    
### 補充：字符串建立後，不可修改。指的是不可用索引方式修改
# replace方法看似是修改了，實質：在建立了一個內存，讓v從新指向新的字符串

6). 用in判斷在不在字符串中，看list中總體在不在，以下例子中‘abc’就不能算是一個列表元素，逗號分隔開的纔是一個總體元素

["abc", [19,28], 89, "hhjjkk"]這個總體纔算是一個元素

li = [1,12,13,"age",["abc", [19,28], 89, "hhjjkk"], "alex", True]
v = 「age」 in li

7). 字符串轉列表：直接默認一個個字符輸出來。實質就是進行屢次循環

name = "alexfdvsdgsrgrsfg"
l = list(name)
print(l)

# 輸出結果：['a', 'l', 'e', 'x', 'f', 'd', 'v', 's', 'd', 'g', 's', 'r', 'g', 'r', 's', 'f', 'g']

8). 當l 爲一個數字的時候不能循環：   所以數字也不能轉換爲列表。

　　能夠推測出，在轉化爲列表時，實質進行的是for循環，每次把待轉換數據的一個元素做爲列表的一個元素，而數字不能進行for循環，天然也不能轉化爲列表了

s = 123
for i in s:
    print(i)    #會報錯

 9). 將列表轉化爲字符串

li = ["abc", [19,28], 89, "hhjjkk"]
#思路1：
l = str(li)
print(l)                    #結果["abc", [19,28], 89, "hhjjkk"]，不管給str一個什麼樣的數值，Str都直接把此變量加上引號變字符串了，不能達到咱們想要的效果
#思路2：（列表中既有數字又有字符串）利用for循環一個個處理,且只能解鎖一次。即裏面若是還有列表則還需進一步處理

for i in li:
　　s = s + str(i)
print(s)

#思路3：（列表中只有字符串）直接使用字符串獨有的join, join()內部實質也是在作for循環，幫你把他們拼接起來

li = ["123","456"]
v = "".join(li)
print(v)

基本操做：

• 索引
• 切片
• 追加
• 刪除
• 長度
• 切片
• 循環
• 包含 

list的魔法

#######################################灰魔法: list類中提供的方法 #######################################
li = [11, 22, 33, 22, 44]
1. append()原來值最後追加
# 對象.方法(..)    li對象調用append方法，括號內能夠傳參數
li.append(5)     #直接在原值後面追加，無需找一個變量來接收它，即   li = [11, 22, 33, 22, 44, 5]
v = li.append(5) #打印v的值爲None。與字符串中方法作區別。根本緣由：list能修改，而字符串不能修改
li.append("alex")        #python中None表示空值，什麼都不是
li.append([1234,2323])
print(li)

2 清空列表
li.clear()
print(li)

3 拷貝，淺拷貝
v = li.copy()
print(v)

4. 計算元素出現的次數count(self,value)
v = li.count(22)
print(v)

5. extend()擴展原列表，參數：可迭代對象
li = [11, 22, 33, 22, 44]
li.append([9898,"不得了"])        #[11, 22, 33, 22, 44, [9898, '不得了']]

li.extend([9898,"不得了"])      #[11, 22, 33, 22, 44,9898,'不得了']
#extend中至關於執行了如下循環
for i in [9898,"不得了"]:
    li.append(i)
#[11, 22, 33, 22, 44, 9898, '不得了']
#append()直接把字符串當成一個列表元素附在原列表的最後

li.extend("不得了")            
print(li)
#[11, 22, 33, 22, 44, 9898, '不','得','了']
#extend()會將傳入的字符串也進行for循環拆成三個字符分別做爲列表的一個元素

6. index根據值獲取當前值索引位置（左邊優先）
li = [11, 22, 33, 22, 44]
v= li.index(22)             #1
print(v)

7. insert在指定索引位置插入元素
li = [11, 22, 33, 22, 44]
li.insert(0,99)                #在第0個位置插入99
print(li)
#[99, 11, 22, 33, 22, 44]

8. pop()刪除某個值(1.指定索引；2. 默認最後一個)，並獲取刪除的值
li = [11, 22, 33, 22, 44]
v = li.pop()    #pop刪除li中的數值，並獲取到被刪除的的只
print(li)
print(v)
#[11, 22, 33, 22]          44

li = [11, 22, 33, 22, 44]
v = li.pop(1)
print(li)
print(v)
#[11, 33, 22, 44]        22

9. remove()刪除列表中的指定值，左邊優先
li = [11, 22, 33, 22, 44]
li.remove(22)
print(li)
# [11, 33, 22, 44]

PS:有關刪除的指令 pop remove    del li[0]    del li[7:9]   clear

10. reverse()將當前列表進行翻轉
li = [11, 22, 33, 22, 44]
li.reverse()
print(li)
#[44, 22, 33, 22, 11]

11 sort()列表的排序
li = [11,44, 22, 33, 22]
li.sort()                 #[11, 22, 22, 33, 44]  不寫參數，默認從小到大排序
li.sort(reverse=True)   #[44, 33, 22, 22，11]   從大到小排
print(li)

# 函數的排序方法
cmp
key
sorted

####################dict功能方法###########################################################################

clear(), copy(), keys, 
dic = {
    "k1": 'v1',            #鍵值對
    "k2": 'v2'
}
# 1 fromkeys()根據序列，建立字典，並指定統一的值
v = dict.fromkeys(["k1",123,"999"])         #生成字典序列，key分別爲"k1",123,"999",不指定默認爲None
print(v)                                    #{"k1": None,123: None,"999": None}
v = dict.fromkeys(["k1",123,"999"],456)     #{"k1": 456,123: 456,"999": 456}

# 2 get()根據Key獲取值，key不存在時，能夠指定默認值（None）
v = dic['k1']
print(v)                    #v1
v = dic['k11111']
print(v)                    #直接報錯，沒有這個key
v = dic.get('k1')    
print(v)                    #v1
v = dic.get('k11111')
print(v)                    #None   不會尷尬地報錯
v = dic.get('k11111',meiyou)
print(v)                    #若是key不存在，則直接返回你指定的參數meiyou

# 3 pop()刪除並獲取值
dic = {
    "k1": 'v1',
    "k2": 'v2'
}
v = dic.pop('k1')       #直接刪對應鍵值對，並利用v獲得移除的數值
v = dic.pop('k1',90)    #若是key不存在，則直接返回你指定的參數值90
print(dic,v)
k,v = dic.popitem()        #隨機刪鍵值對
print(dic,k,v)            

# 4 setdefault()設置值，
dic = {
    "k1": 'v1',
    "k2": 'v2'
}
v = dic.setdefault('k1','123')        #已存在，不設置，獲取當前key對應的值
print(dic,v)                        #{"k1": 'v1',"k2": 'v2'}   v1
v = dic.setdefault('k1111','123')    #不存在，設置，獲取當前key對應的新值
print(dic,v)                        #{"k1": 'v1',"k2": 'v2','k1111','123'}   123

# 5 update()更新
dic = {
    "k1": 'v1',
    "k2": 'v2'
}
dic.update({'k1': '111111','k3': 123})        #k1原本有，將原來的k1對應的值更新；k3原本沒有，將k3鍵值對添加進來
print(dic)                                    #{"k2": 'v2','k1': '111111','k3': 123}
dic.update(k1=123,k3=345,k5="asdf")            #參數寫成這種形式，python默認將其轉化爲一個字典，自行更新。
print(dic)                                    ##{"k2": 'v2','k1': 123,'k3': 345, 'k5': 'asdf'}

# 最經常使用的：6 keys()  7 values()   8 items()   get   update
##########

五、元祖tuple

建立元祖：

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

基本操做：

• 索引
• 切片
• 循環
• 長度
• 包含

####################################### 深灰魔法 #######################################
# 1. 書寫格式
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
# 通常寫元組的時候，推薦在最後加入一個逗號,爲了與方法函數相區別。加在元祖中不報錯也不影響元祖參數個數，函數中會報錯。
# 元素不可被（索引）修改，不能被增長或者刪除 
  tu[0] = 123   #直接報錯

# 2. 能夠索引取值
    v = tu[0]
    print(v)

# 3. 能夠切片取值
    v = tu[0:2]
    print(v)

# 4. 能夠被for循環，可迭代對象（列表、元祖、字符串）
    for item in tu:
        print(item)

# 5. 轉換
    s = "asdfasdf0"
    li = ["asdf","asdfasdf"]
    tu = ("asdf","asdf")
#字符串可轉元祖，列表能夠和元祖相互轉化
    v = tuple(s)
    print(v)
    v = tuple(li)
    print(v)
    v = list(tu)
    print(v)
# 將元祖轉化爲字符串，當元祖裏只有字符串的時候才能夠利用join，不然得本身寫for循環並在每一個元祖元素之間用下劃線分割
    v = "_".join(tu)
    print(v)                #asdf_asdf
# extend()對列表/元祖進行拓展
    li = ["asdf","asdfasdf"]
    li.extend((11,22,33,))
    print(li)                            
#["asdf","asdfasdf",11,22,33,]    直接將元祖中的元素加入到列表當中

# 6.元組的一級元素不可修改/刪除/增長，下一級看下一級是什麼數據類型
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
# 元組，有序。
    v = tu[3][0][0]    
    print(v)            #獲得33
    v=tu[3]                
    print(v)            #獲得[(33,44)]爲一個列表，而列表能夠被修改
tu[3][0] = 567            #tu[3][0]爲列表能夠改
print(tu)                #直接寫tu就能輸出上行的指定值
tu[3][0][0] = (55,466)            #報錯，tu[3][0][0]=(33,44)爲元祖不能夠改

#元祖中提供的只有兩種方法
#    count(self,value)獲取指定元素在元組中出現的次數
   tu.count(22)
# index(self,value)獲取指定元素在元組中的索引值，左邊優先
   tu.index(22)

三種數據類型之間對比：
字符串：只能保存一個總體，難以分類。除非在存的時候能夠用分隔符先分隔好，而後用split來劃分開。修改時還須要把特定的改了以後存到一個新的裏面。
列表：便於修改，改動某一元素以後，其餘元素依舊不會受到影響
元祖：若是建立的元素不容許修改，歸到一類中。內部不能直接操做，若是想改轉換爲列表

 六、字典（無序）dict

建立字典：鍵值對

person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})

經常使用操做：

• 索引
• 新增
• 刪除
• 鍵、值、鍵值對
• 循環
• 長度

# 一、基本結構
info = {
    "k1": "v1", # 鍵值對   "key": "value"
    "k2": "v2"
}
#### 2 字典的value能夠是任何值，且能夠嵌套
info = {
    "k1": 18,
    "k2": True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
}
print(info)                 #能夠成功打印

####  3 列表、字典不能做爲字典的key，即冒號前面的
info ={
    1: 'asdf',                #數字能夠
    "k1": 'asdf',            #字符串能夠（字符串不可被修改）
    True: "123",            #bool能夠，可是因爲True爲1與第一個key重複了，這樣會隨機出現字典中對應。
    # [11,22]: 123            #報錯，列表不能夠（列表能夠被修改）
    (11,22): 123,            #元祖能夠（元祖不可被修改）
    # {'k1':'v1'}: 123
}
print(info)
# 本質緣由：字典在保存的時候是按照hash表去保存的。內存中生成的全變爲hash數值。而列表不支持直接轉化爲hash值

True 1  False 0
info ={
    "k1": 'asdf',
    True: "123",     #這樣就不會有1的key，沒有任何問題
    # [11,22]: 123
    (11,22): 123,
    # {'k1':' v1'}: 123

}
print(info)

# 4 字典無序

info = {
    "k1": 18,
    "k2": True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
}
print(info)                    # 每次打印出來的順序都隨機，說明無序

# 五、索引（本身定義的key來找）方式找到指定元素; 可是不能經過切片的方式來尋找，由於無順序
info = {
    "k1": 18,
    2: True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (55,66),
        }
    ],
    "k4": (77,88,99,00)
}
v = info['k1']
print(v)        #18
v = info[2]
print(v)        #True
v = info['k3'][5]['kk3'][0]
print(v)        #55

# 6 字典支持 del 刪除，刪鍵值對（與key和索引結合）
info = {
    "k1": 18,
    2: True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
}
del info['k1']

del info['k3'][5]['kk1']
print(info)

# 7 for循環能夠，while是一個個遞增遞減，但字典不是有序地
info = {
    "k1": 18,
    2: True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
}
for item in info:
    print(item)                        #k3 k4 k1 2    #默認for循環輸出只有key且依舊亂序

for item in info.keys():            #k1 k4 k3 2    #默認for循環輸出只有key且依舊亂序，與默認的同樣
    print(item)

for item in info.values():            #只輸出values，並且每行輸出一字典元素的value
    print(item)

for item in info.keys():            #item 爲每次獲得的key，則info[item]對應此key的value值
    print(item,info[item])            #輸出完整鍵值對

for k,v in info.items():            #輸出鍵值對，k對應key，v對應value
    print(k,v)

 7.集合

定義：由 不一樣元素組成的，集合中是一組 無序排列的可hash值 （ 不可變類型），能夠做爲字典的key

特性：目的是爲了將不一樣值存放到一塊兒，不一樣集合間用

 

#集合的定義[1,2,3,4]或者用set 
s=set('hello')        #set中寫可迭代類型
print(s)              #{'o','h','l','e'}    set將自動刪去重複字符生成集合

s=set(['alex','alex','sb'])    
print(s)                        #{'alex','sb'}

# s={1,2,3,4,5,6}

######集合內置方法
#add()添加
s.add('s')    #{1,2,3,'s',4,5,6}
s.add('3')    #字符串類型的'3'能夠加進來{1,2,3,'3',4,5,'s',6}
s.add(3)        #重複的數字3，能夠運行，但集合中只有一個元素
print(s)

# 清空clear()
s.clear()
print(s)    #set()      #表示s被清空了

# 拷貝copy()
s1=s.copy()               #s1和s如出一轍

#隨機刪pop()
s={'sb',1,2,3,4,5,6}
s.pop()                    #隨機出現刪除一個元素

#指定刪除remove()   discard()
s.remove('sb')
s.remove('hellol')    #刪除元素不存在會報錯
s.discard('sbbbb')    #刪除元素不存在不會報錯
print(s)

# 利用集合完成關係測試
#Q :統計出既在python_l，又在linux_l中的元素
python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)

#若是不用集合，用循環語句輸出交集部分
python_linux = []
for p_name in python_l:
    if p_name in linux_l:
        python_linux.append(p_name)
print(python_linux)

#求交集  intersection()
print(p_s,l_s)      #分別打印兩個集合{'lcg','szw','zjw'} {'lcg','szw','sb'}
print(p_s.intersection(l_s))    #{'lcg','szw'}
print(p_s&l_s)                    #{'lcg','szw'}
#求並集   union()
print(p_s.union(l_s))            #{'lcg','szw','zjw','sb'}
print(p_s|l_s)                    #{'lcg','szw','zjw','sb'}
#差集    difference()  被
print('差集',p_s-l_s)
print(p_s.difference(l_s))      #{'zjw','lcg'}
print('差集',l_s-p_s)
print(l_s.difference(p_s))        #{'sb'}
#交叉補集：先把兩個集合放在一塊兒而後去掉相同部分,兩集合的剩下部分
print('交叉補集',p_s.symmetric_difference(l_s))        #{'sb','zjw'}
print('交叉補集',p_s^l_s)


python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)                #{'lcg','szw','zjw'} {'lcg','szw','sb'}
print('差集',p_s-l_s)        #{'zjw','lcg'}

#difference_update()求差集並更新
p_s=p_s-l_s                    #若是不從新賦值回p_s，p_s和l_s的數值不會變化
p_s.difference_update(l_s) #等價於p_s=p_s-l_s    
print(p_s)

#isdisjoint()若是s1和s2沒有交集
s1={1,2}
s2={2,3,5}
print(s1.isdisjoint(s2))   #若是s1和s2沒有交集，則返回True

#issubset()子sub集    issuperset()父super集
s1={1,2}
s2={1,2,3}
print(s1.issubset(s2)) #True    s1 是s2 的子集
print(s2.issubset(s1)) #False

print(s2.issuperset(s1))#s1 是s2 的父集

#update()可迭代的數據類型均可以更新
s1={1,2}
s2={1,2,3}
s1.update(s2)       #更新多個值s1={1,2,3}

#add()附加
s1.add(1,2,3,4)     #更新一個值
s1.union(s2)         #不更新s1,整個表達式產生了一個數據結果，須要一個新變量去接收它
print(s1)

#print()
s=frozenset('hello')
print(s)
names=['alex','alex','wupeiqi']

names=list(set(names))
print(names)

 

 

PS：循環，range，continue 和 break

#######################　整理 #################

1、數字      int(..)

2、字符串
最經常使用的：replace/find/join/strip去空白/startswith/endswith/split/upper/lower/format模板佔位符

tempalte = "i am {name}, age : {age}"
v = tempalte.format(name='alex',age=19) 一般是這樣傳兩個賦值表達式
v = tempalte.format(**{"name": 'alex','age': 19})  但若是想要傳字典，應該在字典前面加入兩個*
print(v)

3、列表
最經常使用的append、extend、insert
索引、切片、循環、in

4、元組
忽略
索引、切片、循環，in         以及元素不能被修改

5、字典
get/update/keys/values/items
for,索引

dic = {"k1": 'v1}
v = "k1" in dic            #默認循環key，若是寫v1會報錯，須要用值判斷時，用下面的dic.values()
print(v)

v = "v1" in dic.values()
print(v)

6、布爾值
True 1  False 0
bool(...)
None ""  () []  {} 0 ==> False    其餘全是真

 1 ###類型可變（id不變）：列表、字典
 2 ###不可變（id變了）：數字、字符串、元祖
 3 
 4 #對於字符串
 5 name = 'alex'                   #開闢內存空間來存放變量值‘alex’，變量名name用來取變量的值
 6 id(name)          #18107672
 7 name = 'sb'                          #開闢新的內存空間來存放變量值‘sb’，
 8 id(name)　　    #18107784     id號不一樣表示name指向了不一樣的內存   
 9 
10 #對於列表
11 hobby = ['coding', ' play']
12 id(hobby)                         #18113928
13 hobby{0} = 'sb'              #修改列表的第一個值
14 id(hobby)                        #18113928    id值不變，說明原來內存位置的數值已經更改了
15 
16 #對於字典
17 dic = ['name' : 'alex']
18 id(dic)                         #4568008
19 dic['name'] = 'sb'
20 id(dic)                         #4568008

###訪問數據
1.順序訪問：字符串、列表、元祖
2.映射：字典
3. 直接訪問：數字（變量名直接全體一次性訪問）
字典查詢速度比列表快，但字典佔的內存比列表大

####存放元素個數：
1.容器類型：列表、元祖、字典
2.原子類型：數字、字符串

 

 

其餘

一、for循環

用戶按照順序循環可迭代對象中的內容，

PS：break、continue

1 2 3

li  =  [ 11 , 22 , 33 , 44 ] for  item  in  li:      print  item

二、enumrate

爲可迭代的對象添加序號

1 2 3

li  =  [ 11 , 22 , 33 ] for  k,v  in  enumerate (li,  1 ):      print (k,v)

三、range和xrange

指定範圍，生成指定的數字

1 2 3 4 5 6 7 8

print  range ( 1 ,  10 ) # 結果：[1, 2, 3, 4, 5, 6, 7, 8, 9]   print  range ( 1 ,  10 ,  2 ) # 結果：[1, 3, 5, 7, 9]   print  range ( 30 ,  0 ,  - 2 ) # 結果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

練習題

1、元素分類

有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。
即： {'k1': 大於66的全部值, 'k2': 小於66的全部值}

2、查找

查找列表中元素，移除每一個元素的空格，並查找以 a或A開頭 而且以 c 結尾的全部元素。

    li = ["alec", " aric", "Alex", "Tony", "rain"]

    tu = ("alec", " aric", "Alex", "Tony", "rain") 

    dic = {'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"}

 

3、輸出商品列表，用戶輸入序號，顯示用戶選中的商品

    商品 li = ["手機", "電腦", '鼠標墊', '遊艇']

 

4、購物車

功能要求：

• 要求用戶輸入總資產，例如：2000
• 顯示商品列表，讓用戶根據序號選擇商品，加入購物車
• 購買，若是商品總額大於總資產，提示帳戶餘額不足，不然，購買成功。
• 附加：可充值、某商品移除購物車

1 2 3 4 5 6

goods  =  [      { "name" :  "電腦" ,  "price" :  1999 },      { "name" :  "鼠標" ,  "price" :  10 },      { "name" :  "遊艇" ,  "price" :  20 },      { "name" :  "美女" ,  "price" :  998 }, ]

 5、用戶交互，顯示省市縣三級聯動的選擇

1 2 3 4 5 6 7 8 9 10 11 12 13

dic  =  {      "河北" : {          "石家莊" : [ "鹿泉" ,  "藁城" ,  "元氏" ],          "邯鄲" : [ "永年" ,  "涉縣" ,  "磁縣" ],      }      "河南" : {          ...      }      "山西" : {          ...      }   }