001_第一部分_[Python基礎]

一.python基礎:

---

• 數據類型:

  原始類型:
     int float byte
  
     複合類型:
     由其餘原始類型組合起來的類型
     list dict cuple

• 運算符和表達式:

算術運算符:
                加 / 減 / 乘 / 除 / 取模 / 冪 / 地板除
                +    -    *    /     %     **     //

        python2 的 除:
        10 / float(20)

        位運算符[二進制之間的運算]:
        bin(60) 轉換成二進制數
        int('1100',2)   將二進制轉換成十進制
        &    按位與        都爲1 才爲1    
        |    按位或         存在1 即爲1
        ^    按位異或         相同的爲0,不一樣的爲1
        ~    按位取反         正數的補碼，反碼都是其自己
                        負數的補碼是:符號位不變,其他各位求反,末位加1 ，既11111
                        反碼是:符號位爲1,其他各位求反,但末位不加1 ，既11110
                    
                        假設有一個數~9，計算步驟以下，9=1001
                        其補碼爲01001，
                        對其取反10110，這個數是在內存中存放的，如今須要裝換成原碼，既先減1，而後取反得 
                        11010，符號位爲1是負數，既-10
        <<    左移
        >>  右移

• 按位取反:

• ---
      正數的補碼和反碼都是其自己,可是前面要加上正數的符號位 "0"
      ---
      負數的符號位是"1"
      負數的補碼是:符號位不變,其他各位求反,末位加1
      負數的反碼是:符號位不變,其他各位求反
      ---
      二進制數在內存中是以補碼的形式存放的
      ---

60的按位取反計算:
    
        第一步:
        計算60的 [補碼] 和 [反碼]:
    
                    原碼    補碼     反碼
            十進制    60
            二進制    111100  0111100    0111100
    
    
        第二步:
        取反[取反操做是對補碼進行取反]:
    
    
                            補碼
                            1000011
    
                                    反碼
                                    補碼 - 1
                                    1000010
                    原碼
                    1111101
                    1 表明是負數
                     111101 轉換成十進制爲61
                    -61

• 比較運算符[返回布爾類型]:

  ==    等於
     !=    不等於
     >   大於
     <   小於

• 邏輯運算符:

• and        與     同時True才爲True
     or        或  只要存在True 則爲True
     not     非  取反
  
     邏輯運算的短路功能:
     前面False後面就不會再計算:
     1+2 >4 and (2+2) == 4
  
     前面是True就不會再計算後面:
     1+2 <4 or (2+2) == 3　

  ---

  def add(x, y):
         print("%d + %d" %(x, y))
         return x+y
     add(1, 2) > 4 and add(2, 3) == 5
        ...: 
     1 + 2
     Out[2]: False

  ---

  def add(x, y):
         print("%d + %d" % (x, y))
         return x+y
     add(1, 2) < 4 and add(2,3) < 6
        ...: 
     1 + 2
     2 + 3
     True

  ---

  def add(x, y):
         print("%d + %d" % (x, y))
         return x+y
     add(1, 2) < 4 and add(2,3) < 4
        ...: 
     1 + 2
     2 + 3
     False

• 其餘運算符:

=        賦值運算符
    in         成員運算符
    not in     成員運算符
    is         身份運算符, 比較兩個元素的id; 列表不能用is 作比較
    is not     身份運算符
            is 使用的環境常常拿來判斷是否是None;

• 表達式與優先級:

1. 一元高於二元
        2. 數值高於邏輯
        3. 算術運算高於位運算
        4. 乘除高於加減
        5. 拿不許時加括號

• 程序結構:

1.    順序結構
        2.    分支結構
        3.    循環結構

        關於 SWITCH
        Python中並無switch結構,由於'switch'結構徹底能夠由'if elif else'語句來實現
        
        switch實現方法:
        粗糙版:
        #coding:utf8  
        #add minus divide using python  
        from __future__ import division  
        x=1  
        y=2  
        operator='/'  
        result={  
        "+":x+y,  
        "-":x-y,  
        "*":x*y,  
        "/":x/y  
        }  
        print(result.get(operator))         

        改進版:
        #!/usr/bin/env python
        # -*- encoding:utf-8 -*-
        
        class calculate:
            def __init__(self, x, op, y):
                self.x = x
                self.op = op
                self.y = y
        
            def count(self):
                result={
                "+":self.x+self.y,
                "-":self.x-self.y,
                "*":self.x*self.y,
                "/":self.x/self.y}
                print(result.get(self.op))
        
        mark = calculate(10,"+",2)
        mark.count()

• python的三元運算

a = 4
        b = a if a > 0 else 0

• RANGE函數

range(x)         [0,x)
        range(m, n)     [m, n)
        range(m, n, s)    [m,n),步長爲s

• break 子句

* 只能出如今循環結構中
        * 用於跳出當前循環結構

• continue子句:

* 只能出如今循環結構中
        * 用於跳過這次迭代的剩餘操做

• else子句:

循環結構的else子句是python特有的,用於表示一個循環不是通過'break'跳出循環,提早結束循環,而是正常退出的,纔會執行else中的語句;

二.內置容器:

---

• 列表

* list是最經常使用的線性數據結構
        * list是一系列元素的有序組合
        * list是可變的
        
        列表的操做:
        定義列表:
        li = []
        li = list()
        li = [1, 2, 3]

        查看幫助文檔:
        help(list)
        增:append, extend, insert
        刪:clear, pop, remove
        改:reverse, sort
        查:count, index
        其餘:copy

        增:
        li = []
        append:只能一個一個增長
        li.append(3)
        
        extend:擴展
        li.extend([5,6,7])
        li
        [3, 5, 6, 7]

        insert:位置以前插入
        li.insert(0, 0) 在第一個以前插入0

        刪:
        clear:清空列表
        li.clear()

        remove:從左開始刪除指定元素一個,若是刪除的元素不存在會報錯ValueError
        li.remove(3)  刪除元素3
        
        pop:刪除指定位置元素:若是不存在會報錯IndexError
        li.pop()    刪除最後一個元素
        li.pop(3)   刪除key是3的元素

        改:
        reverse:顛倒列表順序:
        sort:從小到大排序:    僅用於簡單數字排序
        sort(reverse=True) 從大到小排序:

        查:
        count:顯示匹配元素個數
        li.count(3)
        
        其餘:
        index(3):返回指定元素在列表中的位置;若是不存在會報ValueError:
        index(value, [start, [stop]]) 

        copy: 深拷貝,會生成一個新的list
                賦值是淺拷貝,淺拷貝的數據修改會對原來的list產生影響;

        下標操做:
        li[1]
        
        li[1] = 10

        切片:
        li[3:5]:  前面是閉區間  後面是開區間
        li[3:]
        li[:]  效果和copy是同樣的,效率會比copy快;
        li[:4] 
        li[4:-2]     切到倒數第二個;後面是開區間
        li[-4:-1]
        li[2:6:2]:    start, stop ,步長
        li[6:2:-1]  start,stop ,反向顯示,步長爲1
        li[6:2:-2]    start,stop,反向顯示,步長爲2
        li[::-1]
        li[::2]

• 元組[tuple]:

tuple和list大多數地方相似
        tuple是不可變結構
        tuple只能獲取值

        定義一個元組:
        t = ()
        t = tuple()

        count:統計元素個數
        index:返回指定元素在元組中的位置

        下標操做[經過下標獲取value]:
        t[1]

* PACKING & UNPACKING

        PACKING        :把多個變量的值變成一個元組或者列表,默認是變成元組
        UNPACKING    :也能夠把一個元組或者列表賦值給多個變量

    ---
        x, *y = (1, 2, 3, 4)
        print(x)
        1
        print(y)
        [2, 3, 4]

    ---
        *x, y = (1, 2, 3, 4)
        print(x)
        [1, 2, 3]
        print(y)
        4

    ---
        *_ 這個表示賦值給一個不能用的變量:

        x, *_, y = (1, 2, 3, 4)
        print(x)
        1
        print(y)
        4
        
    ---
        x, (y, z) = (1, (2, 3))
        print(x)
        1
        print(y)
        2
        print(z)
        3

    ---

• 集合:

集合的含義和數學上集合的含義相同
        集合不是線性結構
        * 集合元素是惟一的
        集合元素是可hash的
        
        集合的操做:
        初始化:
        s = set()
        s = set([1, 2, 3])

        增:
        s.add(3)                     //添加一個元素
        s.update([3, 4, 5, 6])        //集合添加list中的多個元素

        刪:
        remove:        刪除,刪除不存在的元素會拋出異常;
        discard:    刪除,刪除不存在的元素不會拋出異常;
        clear:        清空
        pop:        隨機刪除集合中的一個元素
        
        集合運算:
        union                    並集              a | b
        intersection            交集              a & b
        difference                差集,不可交換的    a - b
        symmetric_difference    集合之差的並集       a ^ b

        集合判斷[返回布爾值]:
        issubset    子集
        issuperset    超集
        isdisjoint

• 字典:

* 字典是一種無序集合
        * 字典是一種KV結構
        * value能夠是任何對象
        * key是惟一的
        * key必須是可hash對象

        字典的操做:
        d = dict()
        d = {'a':5, 'b':4}
        d['a']
        
        d.keys()
        dict_keys(['b', 'a'])

        遍歷 key:
        for key in d.keys():
            print(d[key])

        遍歷 value:
        for value in d.values():
            print(value)

        遍歷key和value:
        for key,value in d.iterms():
            print(key, value)
            print('%s => %s' %(key, value))

        d.iterkeys()    返回的是一個生成器;
        
        pop,popitem     用於刪除元素
        d.pop('key')    須要指定key,刪除不存在的值返回KeyError
        d.pop('key',6)    刪除不存在的值將返回 6
        
        增長字典元素:
        d['c'] = 7