亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

python集合、元組、字典

系統 1813 0

主要內容:

2、集合

3、元組

4、字典

復習:

  字符串和元組一樣,只能讀不能寫。列表和字典可以嵌套任何東西,列表可以嵌套列表

  L = list("hello")? # L = ['h', 'e', 'l', 'l', 'o']

  集合、字典是無序的;列表、元組、字符串是有序的

  集合、字典、列表是可以修改的;元組、字符串、數字是不能修改的

  for 語句中的else 語句,意思是for中的循環結束后,再走else中的代碼,字典中的鍵就相當于列表可中索引的數字

集合

集合是 可修改 無序 不重復 的序列,集合使用花括號{}

主要作用

  • 去重,把一個列表變成集合,就自動去重了
  • 關系測試,測試兩組數據之前的交集、差集、并集等關系

創建集合

  語法:set(可迭代對象)

  創建空集合: s = set()

              s = set([3,4,5,6,7])    
              
                #
              
              
                創建一個數字集合{3, 4, 5, 6, 7}
              
              
w = set([2,3,4
              
                ])
t 
              
              = set(
              
                "
              
              
                hello
              
              
                "
              
              )
              
                #
              
              
                 遍歷字符串中的每個字符,拆開成單個字符{'h', 'e', 'l', 'o'}
              
              
                
my_set1 
              
              = set((
              
                "
              
              
                hello
              
              
                "
              
              ,)) 
              
                #
              
              
                 創建含有一個元素的集合,有逗號說明是元組
              
              
my_set2 = set((
              
                "
              
              
                haha
              
              
                "
              
              ,
              
                "
              
              
                wode
              
              
                "
              
              ,
              
                "
              
              
                en
              
              
                "
              
              ))
              
                #
              
              
                創建一個含有多個元素的集合
              
              
                print
              
              (
              
                "
              
              
                s:
              
              
                "
              
              ,s)   
              
                #
              
              
                 s: {3, 4, 5, 6, 7}
              
              
                print
              
              (
              
                "
              
              
                w:
              
              
                "
              
              ,w)   
              
                #
              
              
                 w: {2, 3, 4}
              
              
                print
              
              (
              
                "
              
              
                my_set1:
              
              
                "
              
              ,my_set1) 
              
                #
              
              
                 {'hello'}
              
              
                print
              
              (
              
                "
              
              
                my_set2:
              
              
                "
              
              ,my_set2)   
              
                #
              
              
                 {'en', 'haha', 'wode'}
              
            
View Code

s.add()  #添加集合

s.updata(可迭代對象)  # 添加多項

s.remove(x)  #刪除指定元樹x,如果x不存在則會發生錯誤

s.discard()  #和remove()一樣,但是當刪除指定元素不存在時,不會報錯

s.clear()  #清空集合

s.pop()  #彈出最后一個書或彈出指定數

              s = set([4,5])    
              
                #
              
              
                創建一個數字集合{3, 4, 5}
              
              
                
s.add(
              
              
                '
              
              
                w
              
              
                '
              
              
                )

              
              
                print
              
              (
              
                "
              
              
                添加后的s:
              
              
                "
              
              ,s)   
              
                #
              
              
                 {4, 5, 'w'}
              
              
                
s.update([
              
              
                '
              
              
                ni
              
              
                '
              
              ,
              
                '
              
              
                hao
              
              
                '
              
              ,
              
                '
              
              
                ya
              
              
                '
              
              ])    
              
                #
              
              
                 添加多項
              
              
                print
              
              (
              
                "
              
              
                添加多項后的s:
              
              
                "
              
              ,s)     
              
                #
              
              
                 {'hao', 'ya', 4, 5, 'w', 'ni'}
              
              
                #
              
              
                 我們輸入字符串試試
              
              
s.update(
              
                "
              
              
                hid
              
              
                "
              
              ) 
              
                #
              
              
                 將字符串拆分單個字符后,然后再一個個添加到集合中,有重復的會忽略。,
              
              
                print
              
              (s)        
              
                #
              
              
                 {'hao', 'ya', 4, 5, 'w', 'h', 'ni', 'i', 'd'}
              
              
                
s.remove(
              
              
                "
              
              
                hao
              
              
                "
              
              )         
              
                #
              
              
                 移除元素
              
              
                print
              
              (
              
                "
              
              
                移除元素
              
              
                "
              
              ,s)      
              
                #
              
              
                 {'w', 'e', 'o', 'l', 12, 'h', 23}
              
              
                
s.discard(
              
              
                '
              
              
                ya
              
              
                '
              
              )         
              
                #
              
              
                 移除元素,不存在不會發生錯誤
              
              
                print
              
              (s)                
              
                #
              
              
                 {'d', 4, 5, 'i', 'ni', 'w', 'h'}
              
              
                
s.pop()                
              
              
                #
              
              
                 隨機刪除集合中的元素,這個方法返回值是刪除的數,不是返回None
              
              
                print
              
              (s)                
              
                #
              
              
                 {4, 5, 'i', 'ni', 'w', 'h'}
              
              
                
s.clear()

              
              
                print
              
              (s)                
              
                #
              
              
                 set()
              
            
View Code

|   生成兩個集合的并集

&   生成兩個集合的交集

-   生成兩個集合的補集

^   生成兩個集合的對稱補集(也就是兩個集合的并集減去交集)

>   判斷一個集合是另一個集合的超集

<   判斷一個集合是另一個集合的子集

==, ?!=   判斷集合是否相同

in , not in ?  判斷集合是否在另一個集合中

len(s),  sum(s),  max(s),  min(s),  sum(s),  any(s),  all(s)

              s = set([3,4,5,6,7])    
              
                #
              
              
                創建一個數字集合{3, 4, 5, 6, 7}
              
              
w = set([2,3,4
              
                ])


              
              
                print
              
              (
              
                "
              
              
                求交集:
              
              
                "
              
              ,s&w)      
              
                #
              
              
                 {3, 4}
              
              
                print
              
              (
              
                "
              
              
                求并集:
              
              
                "
              
              ,s | w)    
              
                #
              
              
                 {2, 3, 4, 5, 6, 7}
              
              
                print
              
              (
              
                "
              
              
                求差集:
              
              
                "
              
              ,s-w)      
              
                #
              
              
                 減去相同的元素 {5, 6, 7}
              
              
                print
              
              (
              
                "
              
              
                求差集:
              
              
                "
              
              ,w-s)      
              
                #
              
              
                 減去相同的元素 {2}
              
              
                print
              
              (
              
                "
              
              
                并集減去交集:
              
              
                "
              
              ,s ^ w)    
              
                #
              
              
                 {2, 5, 6, 7}
              
              
                print
              
              (len(s))   
              
                #
              
              
                 5
              
              
                print
              
              (3 
              
                in
              
               s)   
              
                #
              
              
                 True
              
            
View Code

?

固定集合? frozenset

  固定集合是 不可變 無序 ,含有唯一元素的 不可迭代 的集合,

  作用:固定集合可以作為字典的鍵,還可以作為字典的值

固定集合的構造函數

  frozenset()  創建一個空的固定集合

  frozenset(iterable)  用可迭代對象創建一個固定的集合

固定集合的運算和集合的運算完全一樣

集合推導式 :  {表達式? for? 變量? in? 可迭代對象? [if? 真值表達式]} # [ ]可以省略

        集合推導式同樣也可以嵌套

{x for x in range(10)}   #返回集合

元組

  元組是 不可修改 有序 序列,元組使用小括號(),列表使用綜括號[],可以存儲任意的數據類型

  元組只含一個元素時,需要在后面 添加逗號 ,否者會被當做變量來處理

括號可以省略

              
                 1
              
               tuple2 = (1,2,
              
                '
              
              
                wo
              
              
                '
              
              ,4,5
              
                )

              
              
                 2
              
              
                print
              
              (tuple2)   
              
                #
              
              
                 (1, 2, 'wo', 4, 5)
              
              
                 3
              
               tuple3 = 
              
                "
              
              
                wo
              
              
                "
              
              ,
              
                "
              
              
                ai
              
              
                "
              
              ,
              
                "
              
              
                ni
              
              
                "
              
              
                #
              
              
                 不需要括號也可以
              
              
                 4
              
              
                print
              
              (tuple3)   
              
                #
              
              
                 ('wo', 'ai', 'ni')
              
              
                 5
              
              
                print
              
              (type(tuple3)) 
              
                #
              
              
                
                  類型為元組類型
                
              
              
                 6
              
               tup1 = ()       
              
                #
              
              
                ()
              
              
                 7
              
              
                print
              
              
                (tup1)

              
              
                 8
              
               tup2 = (50)     
              
                #
              
              
                 不加逗號,類型為整型
              
              
                 9
              
              
                print
              
              (tup2)     
              
                #
              
              
                50,
              
              
                10
              
               tup3 = (50,)    
              
                #
              
              
                 加逗號,類型為元組
              
              
                11
              
              
                print
              
              (tup3)     
              
                #
              
              
                (50,)
              
            
元組
            
              1
            
             t = tuple()    
            
              #
            
            
              創建一個空元組
            
            
              2
            
             t = ()    
            
              #
            
            
              創建一個空元組
            
            
              3
            
             x, y, z = 100, 200, 300  
            
              #
            
            
               序列賦值1 2 3 x,y,z是整型
            
            
              4
            
             x, y, z = (100, 200, 300)  
            
              #
            
            
               序列賦值 100 200 300整型
            
            
              5
            
             x, y, z = [100, 200, 300]  
            
              #
            
            
               序列賦值
            
            
              6
            
             x, y, z = 
            
              '
            
            
              ABC
            
            
              '
            
            
              #
            
            
               序列賦值 A B C 字符串
            
            
              7
            
             T.index(v[, begin[, end]]) 
            
              #
            
            
              返回對應元素的索引下標
            
            
              8
            
             T.count(x)  
            
              #
            
            
              返回元組中對應的元素個數
            
          

1.訪問元組

              tup1 =(11,2,33
              
                )

              
              
                print
              
              (
              
                "
              
              
                tup1[0]:
              
              
                "
              
              ,tup1[0])       
              
                #
              
              
                 tup1[0]: 11
              
              
                print
              
              (
              
                "
              
              
                tup1[0:2]:
              
              
                "
              
              ,tup1[0:2])   
              
                #
              
              
                 tup1[0:2]: (11, 2)
              
            
訪問元組

2.刪除元組

  元組中的值是不能被刪除的,但我們可以刪除整個元組

              tup = (
              
                '
              
              
                Google
              
              
                '
              
              , 
              
                '
              
              
                Runoob
              
              
                '
              
              , 1997, 2000
              
                )

              
              
                del
              
              
                 tup

              
              
                print
              
               (
              
                "
              
              
                刪除后的元組 tup : 
              
              
                "
              
              ,tup) 
              
                #
              
              
                 name 'tup' is not defined
              
            
刪除整個元組

3.元組運算符

Python 表達式 結果 描述
len((1, 2, 3)) 3 計算元素個數
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 連接
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 復制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3); print (x) 1 2 3 迭代

?

?元組的相加和相乘是創建了一個新的元組,原來的元組并沒有改變,也改變不了

4.元組索引,截取

          
            L 
            
              =
              
                
                  (
                  
                    'Google'
                    
                      ,
                      
                        
                          'Taobao'
                          
                            ,
                            
                              
                                'Runoob'
                                
                                  )
                                  
Python 表達式 結果 描述
L[2] 'Runoob' 讀取第三個元素
L[-2] 'Taobao' 反向讀取;讀取倒數第二個元素
L[1:] ('Taobao', 'Runoob') 截取元素,從第二個開始后的所有元素。

?

5.元組的其他內置函數

  len  max  min  

  tuple(列表)  將列表轉換成元組

            reversed(可迭代對象)  
            
              #
            
            
              返回反向順序的可迭代對象(臨時性的)
            
            
sorted(iterable, key=None, reverse=False)  
            
              #
            
            
              返回已排序的列表
            
          
              t = (4, 8, 6, 2, 7
              
                )
L 
              
              = [x 
              
                for
              
               x 
              
                in
              
              
                 reversed(t)]

              
              
                #
              
              
                 L = [7, 2, 6, 8, 4]  # 原來先后順序的反向
              
              
                for
              
               x 
              
                in
              
              
                 reversed(t):
  
              
              
                print
              
              (x)  
              
                #
              
              
                  打印: 7  2  6  8  4
              
              
                
L2 
              
              = sorted(t)  
              
                #
              
              
                 L2 = [2, 4, 6, 7, 8]
              
              
L3 = sorted(t, reverse=True)  
              
                #
              
              
                 L3 = [8, 7, 6, 4, 2]
              
            
reversed和sorted的使用

字典

  字典是 可修改 無序 序列,字典使用 花括號 {},可以存儲任意類型對象,

  字典由 鍵值對 組成{key:value}

在字典中是 唯一 的,如果重復,后面的鍵值對會替換前面的。

鍵必須是不可變 的類型對象,只能用數字、字符串、元組充當,列表就不行,值可以取任意的數據類型

              d = {
              
                "
              
              
                key1
              
              
                "
              
              :
              
                '
              
              
                value1
              
              
                '
              
              ,
              
                "
              
              
                key2
              
              
                "
              
              :
              
                '
              
              
                value2
              
              
                '
              
              
                }

              
              
                print
              
              (d)      
              
                #
              
              
                 {'key2': 'value2', 'key1': 'value1'}
              
              
dict = {
              
                '
              
              
                a
              
              
                '
              
              :2,
              
                '
              
              
                b
              
              
                '
              
              :1,
              
                '
              
              
                b
              
              
                '
              
              :3}    
              
                #
              
              
                 重復最后的一個鍵值對會替換前面的,值不需要唯一
              
              
                print
              
              (dict)   
              
                #
              
              
                 {'a': 2, 'b': 3}
              
            
鍵值對

創建字典

  當鍵不存在時,創建鍵,并綁定對應的值,當鍵存在時,修改鍵綁定的值

              
                #
              
              
                 創建字典dict
              
              
dict1 = {
              
                '
              
              
                a
              
              
                '
              
              :2,
              
                '
              
              
                b
              
              
                '
              
              :1,
              
                '
              
              
                b
              
              
                '
              
              :3}    
              
                #
              
              
                 重復最后的一個鍵值對會替換前面的,值不需要唯一
              
              
                print
              
              (dict1)   
              
                #
              
              
                 {'a': 2, 'b': 3}
              
              
dict1[
              
                '
              
              
                c
              
              
                '
              
              ] = 4   
              
                #
              
              
                 當鍵不存在時,增加鍵,并綁定對應的值,
              
              
                print
              
              (dict1)     
              
                #
              
              
                 {'a': 2, 'b': 3, 'c': 4}
              
              
dict1[
              
                '
              
              
                c
              
              
                '
              
              ] = 134   
              
                #
              
              
                 當鍵存在時,修改鍵綁定的值
              
              
                print
              
              (dict1)     
              
                #
              
              
                 {'a': 2, 'b': 3, 'c': 134}
              
            
創建字典

訪問字典 ,把鍵放入方括號中進行索引,但是訪問字典中不存在的鍵會出錯

              
                1
              
              
                print
              
              (dict[
              
                '
              
              
                a
              
              
                '
              
              ])
              
                #
              
              
                訪問字典,把鍵放入方括號中進行索引
              
              
                2
              
              
                print
              
              (dict[
              
                "
              
              
                c
              
              
                "
              
              ])
              
                #
              
              
                訪問字典中不存在的鍵會出錯
              
            
訪問字典

 刪除字典、清空字典、刪除字典中的鍵值對

              dict1 = {
              
                '
              
              
                a
              
              
                '
              
              :2,
              
                '
              
              
                b
              
              
                '
              
              :1,
              
                '
              
              
                c
              
              
                '
              
              :3
              
                }


              
              
                del
              
               dict1[
              
                '
              
              
                a
              
              
                '
              
              ]  
              
                #
              
              
                 刪除字典中的鍵"a,就相當于刪除了值2
              
              
                print
              
              (dict1)    
              
                #
              
              
                 {'b': 1, 'c': 3}
              
              
dict1.clear()   
              
                #
              
              
                 清空字典的所有鍵
              
              
                print
              
              (dict1)    
              
                #
              
              
                 {}
              
              
                del
              
               dict1       
              
                #
              
              
                 刪除字典
              
            
刪除字典、清空字典、刪除字典中的鍵值對

?

字典的內置函數

cmp(dict1, dict2)

  # 比較兩個字典元素。如果兩個字典的元素相同返回0,
  # 如果字典dict1大于字典dict2返回1,
  # 如果字典dict1小于字典dict2返回-1。

len(dict)    # 計算字典元素個數,即鍵的總數。
str(dict)   # 輸出字典可打印的字符串表示。
type(variable)   # 返回輸入的變量類型,如果變量是字典就返回字典類型。

?

字典方法

dict.clear()#刪除字典內所有元素
dict.copy()#返回一個字典的淺復制

dict.fromkeys(seq[, val]) #創建一個新字典,以序列 seq 中元素做字典的鍵,val 為字典所有鍵對應的初始值

              
                 1
              
               seq = (
              
                '
              
              
                Google
              
              
                '
              
              , 
              
                '
              
              
                Runoob
              
              
                '
              
              , 
              
                '
              
              
                Taobao
              
              
                '
              
              
                )

              
              
                 2
              
               seq1 = 
              
                '
              
              
                fkjsahf
              
              
                '
              
              
                 3
              
               dict =
              
                 dict.fromkeys(seq)

              
              
                 4
              
              
                print
              
              (
              
                "
              
              
                新字典為 : %s
              
              
                "
              
               %
              
                 str(dict))

              
              
                 5
              
               dict = dict.fromkeys(seq, 10
              
                )

              
              
                 6
              
              
                print
              
              (
              
                "
              
              
                新字典為 : %s
              
              
                "
              
               %
              
                 str(dict))

              
              
                 7
              
               dict = dict.fromkeys(seq1, 10
              
                )

              
              
                 8
              
              
                print
              
              (
              
                "
              
              
                新字典為 : %s
              
              
                "
              
               %
              
                 str(dict))

              
              
                 9
              
              
                10
              
              
                #
              
              
                新字典為 : {'Runoob': None, 'Taobao': None, 'Google': None}
              
              
                11
              
              
                #
              
              
                新字典為 : {'Runoob': 10, 'Taobao': 10, 'Google': 10}
              
              
                12
              
              
                #
              
              
                新字典為 : {'j': 10, 'k': 10, 'h': 10, 'a': 10, 'f': 10, 's': 10
              
            
View Code

? dict.get(key, default=None) #返回指定鍵key的值,如果值不在字典中返回default值,default = None

              
                1
              
               dict = {
              
                '
              
              
                Name
              
              
                '
              
              : 
              
                '
              
              
                Zara
              
              
                '
              
              , 
              
                '
              
              
                Age
              
              
                '
              
              : 27
              
                }

              
              
                2
              
              
                3
              
              
                print
              
              
                "
              
              
                Value : %s
              
              
                "
              
               %  dict.get(
              
                '
              
              
                Age
              
              
                '
              
              )
              
                #
              
              
                Value : 27
              
              
                4
              
              
                print
              
              
                "
              
              
                Value : %s
              
              
                "
              
               %  dict.get(
              
                '
              
              
                Sex
              
              
                '
              
              , 
              
                "
              
              
                Never
              
              
                "
              
              )
              
                #
              
              
                Value : Never
              
            
dict.get

dict.has_key(key) #如果鍵在字典dict里返回true,否則返回false
dict.items() #以列表形式返回可遍歷的(鍵, 值) 元組數組

              
                 1
              
               dict = {
              
                '
              
              
                Google
              
              
                '
              
              : 
              
                '
              
              
                www.google.com
              
              
                '
              
              , 
              
                '
              
              
                Runoob
              
              
                '
              
              : 
              
                '
              
              
                www.runoob.com
              
              
                '
              
              , 
              
                '
              
              
                taobao
              
              
                '
              
              : 
              
                '
              
              
                www.taobao.com
              
              
                '
              
              
                }

              
              
                 2
              
              
                 3
              
              
                print
              
              
                "
              
              
                字典值 : %s
              
              
                "
              
               %
              
                  dict.items()

              
              
                 4
              
              
                 5
              
              
                #
              
              
                 遍歷字典列表
              
              
                 6
              
              
                for
              
               key,values 
              
                in
              
              
                  dict.items():

              
              
                 7
              
              
                print
              
              
                 key,values

              
              
                 8
              
              
                 9
              
              
                #
              
              
                字典值 : [('Google', 'www.google.com'), ('taobao', #'www.taobao.com'), ('Runoob', 'www.runoob.com')]
              
              
                10
              
              
                #
              
              
                Google www.google.com
              
              
                11
              
              
                #
              
              
                taobao www.taobao.com
              
              
                12
              
              
                #
              
              
                Runoob www.runoob.com
              
            
dict.items()

dict.items()返回的是兩個數,一個是字典的鍵,一個是字典的值,

dict.keys() #以列表返回一個字典所有的鍵

              
                1
              
               dict = {
              
                '
              
              
                Name
              
              
                '
              
              : 
              
                '
              
              
                Zara
              
              
                '
              
              , 
              
                '
              
              
                Age
              
              
                '
              
              : 7
              
                }

              
              
                2
              
              
                3
              
              
                print
              
              
                "
              
              
                Value : %s
              
              
                "
              
               %  dict.keys()
              
                #
              
              
                Value : ['Age', 'Name']
              
            
dict.keys

dict.setdefault(key, default=None) #和get()類似, 但如果鍵不存在于字典中,將會添加鍵并將值設為default
dict.update(dict2) #把字典dict2的鍵-值對更新到dict里
dict.values() #以列表返回字典中的所有值
pop(key[,default]) #刪除字典給定鍵 key 所對應的值,返回值為被刪除的值。key值必須給出。 否則,返回default值。

              
                1
              
               site= {
              
                '
              
              
                name
              
              
                '
              
              : 
              
                '
              
              
                菜鳥教程
              
              
                '
              
              , 
              
                '
              
              
                alexa
              
              
                '
              
              : 10000, 
              
                '
              
              
                url
              
              
                '
              
              : 
              
                '
              
              
                www.runoob.com
              
              
                '
              
              
                }

              
              
                2
              
               pop_obj=site.pop(
              
                '
              
              
                name
              
              
                '
              
              
                )

              
              
                3
              
              
                print
              
              (pop_obj)    
              
                #
              
              
                 輸出 :菜鳥教程
              
              
                4
              
              
                print
              
              (site)    
              
                #
              
              
                {'alexa': 10000, 'url': 'www.runoob.com'}
              
            
site.pop()

popitem() #隨機返回并刪除字典中的一對鍵和值。

?

序列相關函數:
  len(),max(),min(),sum(),any(),all(){全部都為真都返回真}
列表中的方法:
    L.index(v) #返回元素對應的索引下標
    L.insert(index,obj)
  L.count(x)
  L.remove(obj)
  L.copy()
  L.append(x)
  L.extend(lst) #L +=lit
  L.clear()
  L.sort()
  L.pop(索引)
  L.reverse() #列表的反轉
深拷貝deep copy,淺拷貝shallow copy
字符串的方法:
  str.split() 分割 把字符串的空格用逗號分隔,返回列表
  str.join() 連接 字符串的分隔符換成join里面的數

小總結

1. 數據類型:
  數值類型:
 int, float, complex, bool
  容器:
    不可變的容器
str, tuple, frozenset, bytes (字節串)
    可變的容器
list, dict, set, bytearray (字節數組)

有序的容器

str(字符串) list(列表) tuple(元組) bytes(字節串) bytearray(字節數組)

無序的容器

set(集合) dict(字典) ?

?推導式總結:

    列表:[x for x in range(10)]返回列表

    集合:{x for x in range(10)}返回集合

    字典:{x:x**2 for x in range(10)}返回字典

2.值:
None, False, True

3. 運算符
  算術運算符
+ - * / // (保留整數)? % (求余)? ** (平方)
  比較運算符:
   < <= > >= == !=
    in / not in?
    is, is not
  布爾運算:
not (非) , and (與) , or (或)
+ (正號) - (負號)
 & (按位與) | (按位或) ^ (按位異或) ?~ (按位取反)
[] (索引,切片,鍵索引)


  表達式:
  1
  1 + 2
  max(1,2,3) # 函數調用是表達式
x if x > y else y , 條件表達式,把三條語句融合為一條

語句
表達式語句:
  所有的表達式都可以單獨寫在一行,形成一個語句,例:
  print("hello world")
  1 + 2
賦值語句:
  a = 100
  a = b = c = 100
  x, y = 100, 200  #交叉賦值
  a[0] = 100  #序列索引賦值
dict['name'] = 'tarena' 字典賦值
del 語句
if 語句
while 語句
for 語句
break 語句
continue 語句
pass 語句


內建函數:

len(x), max(x), min(x), sum(x), any(x), all(x)
  構造函數(用來創建同類型的數據對象)
  布爾值 bool(x), int(x), float(x), complex(x),
list(x), tuple(x), str(x), dict(x), set(x),
frozenset(x)
  abs(x)
  round(x[,n])   #四舍五入

              
                1
              
              
                print
              
              (round(80.63756, 2))   
              
                #
              
              
                 80.64保留小數點后兩位,對第三位進行四舍五入
              
              
                2
              
              
                print
              
              (round(56.6))  
              
                #
              
              
                57
              
            
round(x[,[n])

  pow(x, y, z=None)

              
                1
              
              
                print
              
              (pow(2,2)) 
              
                #
              
              
                   2**2 = 4
              
              
                2
              
              
                print
              
              (pow(2,2,2))   
              
                #
              
              
                 2 ** 2 % 2 = 0
              
            
pow(x,y[,z])

  bin(x), 返回一個整形int或者長整形long int的二進制表示

              
                print
              
              (bin(10))  
              
                #
              
              
                0b1010
              
            
bin(int)

  oct(x) 將一個整數轉換成8進制字符串

              
                print
              
              (oct(10))  
              
                #
              
              
                0o12
              
            
oct(int)

  hex(x) 將10進制整數轉換成16進制,以字符串形式表示

              
                print
              
              (hex(195))  
              
                #
              
              
                0xc3
              
            
hex(int)

  chr(x), 用一個范圍在0~255 整數 (ASCII)作參數,返回一個對應的 字符

              
                1
              
               >>>
              
                print
              
               chr(0x30), chr(0x31), chr(0x61)   
              
                #
              
              
                 十六進制
              
              
                2
              
               0 1
              
                 a

              
              
                3
              
               >>> 
              
                print
              
               chr(48), chr(49), chr(97)         
              
                #
              
              
                 十進制
              
              
                4
              
               0 1 a
            
chr(10進制或者16進制)

  ord(x) 一個字符 作為參數,返回對應的 ASCII 數值,或者 Unicode 數值,

              
                1
              
               >>>ord(
              
                '
              
              
                a
              
              
                '
              
              
                )

              
              
                2
              
               97

              
                3
              
               >>> ord(
              
                '
              
              
                b
              
              
                '
              
              
                )

              
              
                4
              
               98

              
                5
              
               >>> ord(
              
                '
              
              
                c
              
              
                '
              
              
                )

              
              
                6
              
               99
            
ord("一個字符")

  range(start, stop, step)
  input(x), print(x)


更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 波多野结衣一区在线 | 亚洲国产精品久久 | 欧洲做视频在线观看 | 精品免费视频 | 久青草国产观看在线视频 | 久久精品国产只有精品2020 | 中文精品久久久久国产不卡 | 免费看一区二区三区 | 国内精品久久久久久影院8f | 91精选国产 | 国产成人亚洲精品乱码在线观看 | 亚欧在线免费观看 | 亚洲日韩中文字幕在线播放 | 在线观看www成人影院 | 欧美性生活一级 | 99久久久免费精品免费 | 日韩中文字幕视频在线观看 | 欧美色88| 91久国产在线观看 | 国产精品夜色一区二区三区 | 亚洲天天在线日亚洲洲精 | 亚洲精品一区二区三区网址 | 激情综合婷婷亚洲图片 | 国产欧美精品一区二区 | 美女被爆羞羞网站 | 国产亚洲一区二区三区在线 | 亚洲狠狠婷婷综合久久久久网站 | 爱爱小视频在线观看网站 | 免费的毛片视频 | 国产欧美一级片 | 亚洲综合久久综合激情久久 | 日韩中文字幕推理片 | 久草国产在线观看 | 99视频国产在线 | 一本大道香蕉久在线不卡视频 | 特一级黄 | 四虎b7s22c0m| 99久久精品国产自免费 | 激情九月天 | 国产欧美成人一区二区三区 | 九九精品热线免费观看6 |