Python基礎(四) 基礎拾遺、數據類型進階

一、基礎拾遺

       (一)、變量作用域

             外層變量，可以被內層變量直接調用；內層變量，無法被外層變量使用。這種說法在其它語言中適用，在python中除了棧以外，正常的變量作用域，只要執行聲明並在內存中存在，該變量就可以在下面的代碼中使用。

       (二)、位運算符、三元運算

　　1，位運算符，請看下面代碼

 128 64 32 16 8 4 2 1
   0  0  0  0 0 0 0 0
 
 
 #!/usr/bin/env python
  
  a=60      #00111100 (將十進制轉換成二進制,進行位運算)
  b=13      #00001101
  c=0
 
 
 c =  a&b  #00001100(12)  &:按位與運算符,取兩個數的交集
 
 c =  a|b  #00111101(61)  |:按位或運算符,兩個數只要有一個是1就行
 
 c =  a^b  #00110001(49)  ^:按位異或運算符, 取兩個值不同
 
 c =  ~a   #11000011(-61) ~:按位取反運算符
 
 c = a<<2  #11110000(240) <<:左移動運算符,向左移動兩位,結果就是11110000
 
 c = a>>2  #00001111(15)  >>:右移動運算符,向右移動兩位,結果就是00001111

　　2，三元運算

     result = 值1 if 條件 else 值2    #這裡我們用到了一個新的函數result，下面看下具體用法：

 name=input('name:')
 name:jack
 if name == 'jack':
     print('hello')
 else:
     print('see you')
 hello
 
 result = 'hello' if name == 'jack' else 'see you'            #使用result函數可以將上面復雜的流程判斷，放到一行就行判斷
 print(result)
 hello

 二、數據類型進階

        一切事物皆對象，首先看幾個查看對象的函數：

 type(類型名)                 #可以查看對象的類型
 dir(類型名)                  #查看類中提供的所有功能
 help(類型名)                 #查看類中所有詳細的功能
 help(類型名.功能名)           #查看類中某功能的詳細    

我們執行dir(list)的時候會出現帶__add__的和append等，這種都屬於類中的方法，分別是：

　　　1，　__方法__:內置方法，可能有多種執行方法，至少一種
　　   2，　方法：只用一種執行方法，對象.方法

下面分類型介紹其類中的方法：

        （一）、整數    

            整數：34、45、56、整數的功能如下:

class int(object):
    """
    int(x=0) -> int or long
    int(x, base=10) -> int or long
    
    Convert a number or string to an integer, or return 0 if no arguments
    are given.  If x is floating point, the conversion truncates towards zero.
    If x is outside the integer range, the function returns a long instead.
    
    If x is not a number or if base is given, then x must be a string or
    Unicode object representing an integer literal in the given base.  The
    literal can be preceded by '+' or '-' and be surrounded by whitespace.
    The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
    interpret the base from the string as an integer literal.
    >>> int('0b100', base=0)
    """
    def bit_length(self): 
        """ 返回表示該數字的時占用的最少位數 """
        """
        int.bit_length() -> int
        
        Number of bits necessary to represent self in binary.
        >>> bin(37)
        '0b100101'
        >>> (37).bit_length()
        """
        return 0

    def conjugate(self, *args, **kwargs): # real signature unknown
        """ 返回該復數的共轭復數 """
        """ Returns self, the complex conjugate of any int. """
        pass

    def __abs__(self):
        """ 返回絕對值 """
        """ x.__abs__() <==> abs(x) """
        pass

    def __add__(self, y):
        """ x.__add__(y) <==> x+y """
        pass

    def __and__(self, y):
        """ x.__and__(y) <==> x&y """
        pass

    def __cmp__(self, y): 
        """ 比較兩個數大小 """
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __coerce__(self, y):
        """ 強制生成一個元組 """ 
        """ x.__coerce__(y) <==> coerce(x, y) """
        pass

    def __divmod__(self, y): 
        """ 相除，得到商和余數組成的元組 """ 
        """ x.__divmod__(y) <==> divmod(x, y) """
        pass

    def __div__(self, y): 
        """ x.__div__(y) <==> x/y """
        pass

    def __float__(self): 
        """ 轉換為浮點類型 """ 
        """ x.__float__() <==> float(x) """
        pass

    def __floordiv__(self, y): 
        """ x.__floordiv__(y) <==> x//y """
        pass

    def __format__(self, *args, **kwargs): # real signature unknown
        pass

    def __getattribute__(self, name): 
        """ x.__getattribute__('name') <==> x.name """
        pass

    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        """ 內部調用 __new__方法或創建對象時傳入參數使用 """ 
        pass

    def __hash__(self): 
        """如果對象object為哈希表類型，返回對象object的哈希值。哈希值為整數。在字典查找中，哈希值用於快速比較字典的鍵。兩個數值如果相等，則哈希值也相等。"""
        """ x.__hash__() <==> hash(x) """
        pass

    def __hex__(self): 
        """ 返回當前數的 十六進制 表示 """ 
        """ x.__hex__() <==> hex(x) """
        pass

    def __index__(self): 
        """ 用於切片，數字無意義 """
        """ x[y:z] <==> x[y.__index__():z.__index__()] """
        pass

    def __init__(self, x, base=10): # known special case of int.__init__
        """ 構造方法，執行 x = 123 或 x = int(10) 時，自動調用，暫時忽略 """ 
        """
        int(x=0) -> int or long
        int(x, base=10) -> int or long
        
        Convert a number or string to an integer, or return 0 if no arguments
        are given.  If x is floating point, the conversion truncates towards zero.
        If x is outside the integer range, the function returns a long instead.
        
        If x is not a number or if base is given, then x must be a string or
        Unicode object representing an integer literal in the given base.  The
        literal can be preceded by '+' or '-' and be surrounded by whitespace.
        The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
        interpret the base from the string as an integer literal.
        >>> int('0b100', base=0)
        # (copied from class doc)
        """
        pass

    def __int__(self): 
        """ 轉換為整數 """ 
        """ x.__int__() <==> int(x) """
        pass

    def __invert__(self): 
        """ x.__invert__() <==> ~x """
        pass

    def __long__(self): 
        """ 轉換為長整數 """ 
        """ x.__long__() <==> long(x) """
        pass

    def __lshift__(self, y): 
        """ x.__lshift__(y) <==> x<<y """
        pass

    def __mod__(self, y): 
        """ x.__mod__(y) <==> x%y """
        pass

    def __mul__(self, y): 
        """ x.__mul__(y) <==> x*y """
        pass

    def __neg__(self): 
        """ x.__neg__() <==> -x """
        pass

    @staticmethod # known case of __new__
    def __new__(S, *more): 
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

    def __nonzero__(self): 
        """ x.__nonzero__() <==> x != 0 """
        pass

    def __oct__(self): 
        """ 返回改值的 八進制 表示 """ 
        """ x.__oct__() <==> oct(x) """
        pass

    def __or__(self, y): 
        """ x.__or__(y) <==> x|y """
        pass

    def __pos__(self): 
        """ x.__pos__() <==> +x """
        pass

    def __pow__(self, y, z=None): 
        """ 冪，次方 """ 
        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
        pass

    def __radd__(self, y): 
        """ x.__radd__(y) <==> y+x """
        pass

    def __rand__(self, y): 
        """ x.__rand__(y) <==> y&x """
        pass

    def __rdivmod__(self, y): 
        """ x.__rdivmod__(y) <==> divmod(y, x) """
        pass

    def __rdiv__(self, y): 
        """ x.__rdiv__(y) <==> y/x """
        pass

    def __repr__(self): 
        """轉化為解釋器可讀取的形式 """
        """ x.__repr__() <==> repr(x) """
        pass

    def __str__(self): 
        """轉換為人閱讀的形式，如果沒有適於人閱讀的解釋形式的話，則返回解釋器課閱讀的形式"""
        """ x.__str__() <==> str(x) """
        pass

    def __rfloordiv__(self, y): 
        """ x.__rfloordiv__(y) <==> y//x """
        pass

    def __rlshift__(self, y): 
        """ x.__rlshift__(y) <==> y<<x """
        pass

    def __rmod__(self, y): 
        """ x.__rmod__(y) <==> y%x """
        pass

    def __rmul__(self, y): 
        """ x.__rmul__(y) <==> y*x """
        pass

    def __ror__(self, y): 
        """ x.__ror__(y) <==> y|x """
        pass

    def __rpow__(self, x, z=None): 
        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
        pass

    def __rrshift__(self, y): 
        """ x.__rrshift__(y) <==> y>>x """
        pass

    def __rshift__(self, y): 
        """ x.__rshift__(y) <==> x>>y """
        pass

    def __rsub__(self, y): 
        """ x.__rsub__(y) <==> y-x """
        pass

    def __rtruediv__(self, y): 
        """ x.__rtruediv__(y) <==> y/x """
        pass

    def __rxor__(self, y): 
        """ x.__rxor__(y) <==> y^x """
        pass

    def __sub__(self, y): 
        """ x.__sub__(y) <==> x-y """
        pass

    def __truediv__(self, y): 
        """ x.__truediv__(y) <==> x/y """
        pass

    def __trunc__(self, *args, **kwargs): 
        """ 返回數值被截取為整形的值，在整形中無意義 """
        pass

    def __xor__(self, y): 
        """ x.__xor__(y) <==> x^y """
        pass

    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 分母 = 1 """
    """the denominator of a rational number in lowest terms"""

    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 虛數，無意義 """
    """the imaginary part of a complex number"""

    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 分子 = 數字大小 """
    """the numerator of a rational number in lowest terms"""

    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 實屬，無意義 """
    """the real part of a complex number"""


    

int

         （二）、字符串

           字符串：'name'、'file' ...字符串的功能如下:name = 'jack' 　　　　　　#聲明字符串的兩種方法

name = str('jack')

1、capitalize()                 　　　　 #capitalize將字符串首字母大寫
name.capitalize()           
'Jack'

2、center()                    　　　　　#center:內容居中,定義長度，空白用'_'填充
name.center(20,'_')            
'________jack________'

3、count()                    　　　　　 #count:找子序列的個數
name = 'my name is jack'
name.count('m')                
name.count('m',0,10)        　　　　　　 #從下標0到10之間,統計m出現的次數

4、decode()、encode()
編碼之間的關系：unicode萬國碼<---編碼、解碼--->utf-8/gbk

'無'                           
'\xce\xde'
name='\xce\xde'
name.decode('gbk')   　　　　　　　　　　 #用decode解碼成unicode，decode(當前使用的編碼格式)
u'\u65e0'                          
name.decode('gbk').encode('utf-8')   　#解碼成unicode,編碼成utf-8
'\xe6\x97\xa0'
print name.decode('gbk').encode('utf-8')   #打印出亂碼
鏃


5、endswith()、startswith()   　　　　  #判斷以什麼開始或結束
name = 'jack'
name.endswith('k')         　　　　　　 #以k結尾返回True
True
name.startswith('j')        　　　　　　#以j開始返回True
True

6、expandtabs()        　　　　　　　　  #將tab鍵轉換成空格，默認一個tab轉換8個空格
name = 'ja  ck'
name.expandtabs()    　　　　　　　　    #默認轉換成了8個空格
'ja      ck'
name.expandtabs(1)   　　　　　　　　　　 #設置轉換成1個空格
'ja ck'
name.expandtabs(0)     　　　　　　　　　 #去除空格
'jack'

7、find()                    　　　　　　#尋找第一個子序列的位置
name = 'jack'
name.find('c')            　　　　　　  #在字符串中找出c的下標
name.find('m')           　　　　　　   #如果字符串中不包含會返回-1
-1
name.find('ck')            　　　　　　 #如果輸入兩個，以第一個為准

8、format()               　　　　　　  #字符串格式化
name='my name is {0},age{1}'     　　  #定義占位符
name.format('jack',25)                #按順序加進去
'my name is jack,age 25'

name='my name is {aa},age {bb}'
name.format(aa='jack',bb=25)          #可以不按順序加到字符串中
'my name is jack,age 25'

name='my name is {0},age{1}'
list=['jack',25]
name.format(*list)                    #可以傳入列表加*
'my name is jack,age25'

dic={'ss':123,'dd':456}               #字典必須跟字符串的位置一樣
name='my name is {ss},age {dd}'
name.format(**dic)                          #傳入字典加**
'my name is 123,age 456'


9、index()                    #子序列位置,如果沒找到直接報錯
name='jack'
name.index('k')
name.index('m')            #index和find的區別就是index會報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

10、isalnum()               #判斷是不是字母或數字
name='jack'
name.isalnum()
True
name='呵呵'
name.isalnum()
False

11、isalpha()                  #判斷是不是字母

12、isdigit()                    #判斷是不是數字
name = '123'
name.isdigit()
True
name = 'jack'
name.isdigit()
False

13、islower()                    #判斷是不是都是小寫字母

14、isspace()                   #判斷是不是空格

15、istitle()                      #判斷是不是標題
name = 'jack'
name.title()                     #將name轉換成標題
'Jack'
name = 'Hello,Alex'          #直接將首字母大寫，就是標題
name.istitle()
True

16、isupper()                     #判斷是不是全部都是大寫

17、join()                          #連接
name = ['name','jack']
','.join(name)                     #將列表轉換成字符串用','分割
'name,jack'

18、ljust()                         #內容左對齊,右側自定義填充
name = 'Hello,Alex'
name.ljust(20,'=')              #20是寬度，'='為填充符
'Hello,Alex=========='

19、lower()                        #將大寫字母變小寫
name = 'Hello,Alex'
name.lower()                       #將大寫變小寫
'hello,alex'
name.upper()                       #將小寫變大寫
'HELLO,ALEX'
name.swapcase()                 #將小寫變大寫，大寫變小寫
'hELLO,aLEX'

20、lstrip()                       #移除左側空白

21、partition()                 #將字符串分割成前、中、後三部分
name = 'Hello,Alex'
name.partition('ll')           #按ll分割，將字符串分割成三部分
('He', 'll', 'o,Alex')

22、replace()                   #替換
name = 'Hello,Alex'
name.replace('Al','xx')
'Hello,xxex'

23、splitlines()               #根據換行分割

24、translate()               #轉換
>>> import string
>>> intab = 'aeiou'
>>> outtab = '12345'
>>> trantab = string.maketrans(intab,outtab)
>>> str = 'this is string example......wow!!!'
>>> print(str.translate(trantab,'xm'))
th3s 3s str3ng 21pl2......w4w!!!

更多字符串的功能使用請使用help(str),或在pycharm中按Ctrl + 左鍵點擊輸入的str可以調出幫助信息。

  (二)、列表

       列表:['jack','bob'],元組不再介紹，列表的具體用法如下：

1、append()                                                #添加到列表的最後
>>> name = ['jack','bob']
>>> name.append('tom')
>>> name
['jack', 'bob', 'tom']

2、count()                                                 #統計出現的次數

3、extend()                                                #將一個列表擴展到另一個列表裡
>>> name = ['jack','bob']
>>> name1 = ['henry','tom']
>>> name.extend(name1)
>>> name
['jack', 'bob', 'henry', 'tom']

4、index()                                                 #找到值第一次出現的下標

5、insert()                                                #在指定下標位置插入

6、pop()                                                   #刪除並返回指定下標的值，如果沒有指定返回最後一個下標的值，還可以使用del進行刪除
>>> name = ['jack','bob']
>>> name.pop()
'bob'
>>> name
['jack']

7、remove(值)                                              #移除列表裡的匹配的第一個值

8、reverse()                                               #反轉列表
>>> name = ['jack','bob']
>>> name.reverse()
>>> name
['bob', 'jack']

9、sort()                                                  #排序

（三）、字典

     字典{'name':'jack'},下面介紹字典的功能：

 1、clear()                                          #清空字典內容
 
 2、copy()                                           #淺拷貝
 
 3、get()                                            #根據key獲取值
 >>> dic={'name':'jack'}
 >>> dic['name']                                     #正常去key值的方法 
 'jack'
 >>> dic.get('name')                                 #使用get去取
 'jack'
 >>> dic.get('name1')
 >>> print(dic.get('name1'))                         #如果key不存在，默認會返回None
 None
 >>> print(dic.get('name1','ok'))                    #也可以定義返回值，這個返回ok
 ok
 
 4、has_keys()                                       #判key在不在字典裡
 >>> dic={'name':'jack'}
 >>> dic.has_key('name')                             #在python3中沒有此模塊，使用in來判斷在不在字典裡
 True
 
 5、items()                                          #所有項的列表形式
 >>> dic={'name':'jack'}
 >>> dic.items()
 [('name', 'jack')]
 
 6、iterkeys()                                       #key可迭代
 >>> dic={'name':'jack','age':17}
 >>> for i in dic.iterkeys():
 ...     print(i)
 ...
 age
 name
 
 7、iteritems()                                      #項可迭代
 
 8、itervalue()                                      #value值可迭代
 
 9、pop()                                            #獲取並在字典中刪除
 >>> dic={'name':'jack','age':17}
 >>> dic.pop('age')
 17
 >>> dic.items()
 [('name', 'jack')]
 
 10、setdefault()                                   #如果key不存在，則創建，如果存在，則返回已存在的值且不修改
 >>> dict ={}
 >>> dict['key']='a'
 >>> dict
 {'key': 'a'}
 >>> dict.setdefault('key','b')                    #如果key存在則返回存在的key
 'a'
 >>> dict.setdefault('key0','b')                   #不存在就會創建
 'b'
 >>> dict
 {'key0': 'b', 'key': 'a'}
 
 11、update()                                      #更新,用法類似列表extend
 >>> dic={'name':'jack','age':17}
 >>> dic1={'sex':'female'}
 >>> dic.update(dic1)
 >>> dic
 {'age': 17, 'name': 'jack', 'sex': 'female'}
 
 12、values()                                      #所有的值

   (四)、set集合

        python的set和其他語言類似, 是一個無序不重復元素集, 基本功能包括關系測試和消除重復元素。

>>> a = range(5,10)                               #生成一個5-10的列表
>>> b= range(7,12)                                #7-12的列表
>>> a,b
([5, 6, 7, 8, 9], [7, 8, 9, 10, 11])
>>> set(a)                                        #將a轉換成集合類型定義給c
set([8, 9, 5, 6, 7])
>>> c = set(a)
>>> c
set([8, 9, 5, 6, 7])
>>> d = set(b)                                   #將b轉換成集合類型定義給d
>>> c & d                                        #取 c 和 d 的交集,intersection()
set([8, 9, 7])
>>> c | d                                        #取 c 和 d 的並集union()
set([5, 6, 7, 8, 9, 10, 11])
>>> c - d                                        #取 c 和 d 的差集difference()
set([5, 6])
>>> c ^ d                                        #取 c 和 d 的對稱差集（項在t或s中，但不會同時出現在二者中）symmetric_difference()
set([5, 6, 10, 11])

    借鑒大王一個例子來闡述set在實際工作中的用途：

 練習：尋找差異
 # 數據庫中原有
 old_dict = {
     "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
     "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
     "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
 }
  
 # cmdb 新匯報的數據
 new_dict = {
     "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
     "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
     "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
 }
  
 需要刪除：？
 需要新建：？
 需要更新：？ 注意：無需考慮內部元素是否改變，只要原來存在，新匯報也存在，就是需要更新

 old_set = set(old_dict.keys())                              #將old_dict的key轉換成集合
 update_list = list(old_set.intersection(new_dict.keys()))   #對比old_dict的key值和new_doct的key值之間的交集保存成列表
 new_list = []
 del_list = []
 
 for i in new_dict.keys():
     if i not in update_list:     
         new_list.append(i)
 
 for i in old_dict.keys():
     if i not in update_list:
         del_list.append(i)
 
 print update_list,new_list,del_list