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