python入門推薦：A byte of python

連結：http://pan.baidu.com/s/1boZ8auF

如何退出直譯器？
（1）windows下 :按下ctrl+z 並敲擊enter
（2）GNU/Linux 或 OS X 上的 Shell 程式，可以通過按下 [ctrl + d] 組
合鍵或是輸入 exit()

==學習使用Vim或者Emacs==

通過‘#’即可實現註釋

寫程式註釋很重要。

字面常量。

數字：整數，浮點數。
字串：就是很多字元，嗯，沒錯，就是這樣。可以通過單引號，雙引號，三引號來指定字串。當然，三引號更多的用來表示多行字串。

字串是不可變得，一經建立，則不可修改。

>>>name='liudongqing'
>>>name[0]='a‘

#這種操作是錯誤的。對，沒錯，沒有這樣的操作，而不是“字串居然有這樣的操作”

當需要從其他資訊中構建字串時，可使用format()

age = 20
name = 'Swaroop'
print('{0} was {1} years old when he wrote this book'.format(name, age))
print('Why is {0} playing with that python?'.format(name))
 

print(x,end=’…’) #可以規定所列印的內容以什麼結尾

轉義符 \

原始字串，在字串之前新增’r’

Python將程式中的一切均看為物件。是強面向物件的語言，數字，字串，函式均被看作字串。

物理行：就是你所能看到的一行行程式碼
邏輯行：Python所看到的單個語句，Python會假定一個物理行對應一個邏輯行。

縮排在Python中很重要。它確定了程式的不同塊。Python官方推薦使用 四個空格作為縮排。

運算子與表示式。
** 乘方 //整除

程式控制語句

if語句

if condition:
    execute this

input()返回的為字串型別的資料

while語句
for語句

for x in range(10):
    print(x)

range(1,5) 包括起始但不包括結束。
[1,2,3,4]
還可以設定第三個引數，選擇以多少遞增。

range() 每次只會生成一個數字，如果你希望獲得完整的數字列表，要
在使用 range() 時呼叫 list() 。

break 語句用以中斷（Break）迴圈語句，也就是中止迴圈語句的執行。

continue 語句用以告訴 Python 跳過當前迴圈塊中的剩餘語句，並繼續該迴圈的下一次迭代。

函式

函式就是一段可以重複使用的程式碼。通過def關鍵字定義，後面跟函式名，(形參),再以冒號結尾。

def functionName():
    print("Python is the best programminglanguage")

functionName()

函式引數

def loveConnect(name1,name2):
    print(name1 + 'love' + name2)

loveConnect('ldq','SQ')

區域性變數

x1=0
def change():
    x2=1
change()
print(x1)   #用來觀察x1是否會受到區域性變數x2的影響
#此處x2就是區域性變數

需要定義一個全域性的變數時，需要使用global語句。

預設引數值，當你不傳入引數時，即為預設值。

def Infor(name,city='beijing'):
    print(name + 'live in' + city)

Infor('zhangsan')
Infor('liudongqing','lanzhou')

==只有那些位於引數列表末尾的引數才能被賦予預設引數值，意即在函式的引數列表中擁
有預設引數值的引數不能位於沒有預設引數值的引數之前==

關鍵字引數

def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7)
func(25, c=24)
func(c=50, a=100)

可變引數

引數數量是可變的，可以通過*實現

文件字串(DocStrings)

def print_max(x, y):
    '''Prints the maximum of two numbers.列印兩個數值中的最大數。
The two values must be integers.這兩個數都應該是整數'''
    # 如果可能，將其轉換至整數型別
    x = int(x)
    y = int(y)
    if x > y:
        print(x, 'is maximum')
    else:
     print(y, 'is maximum')
print_max(3, 5)
print(print_max.__doc__)

該文件字串所約定的是一串多行字串，其中第一行以某一大寫字母開始，以句號結束。
第二行為空行，後跟的第三行開始是任何詳細的解釋說明

模組(module)

import sys
print('The command line arguments are:')
for i in sys.argv:
    print(i)    
    //sys.argv  變數是一系列字串的列表（List）
print('\n\nThe PYTHONPATH is', sys.path, '\n')

from … import …語句

如果希望匯入sys模組中的argv變數，可以採用from sys import args。當然，應該儘可能避免這種方式，因為這樣有可能在你的程式中造成同名衝突。

from math import sqrt
print("Square root of 16 is", sqrt(16))

模組的name

每個模組都有一個名稱，而模組中的語句可以找到它們所處的模組的名稱。這對於確定模組
是獨立執行的還是被匯入進來執行的這一特定目的來說大為有用。正如先前所提到的，當模
塊第一次被匯入時，它所包含的程式碼將被執行。

//儲存為module.py
if __name__=='__main__':
    print('I am running by myself')
else:
    print('I am imported')

//在相同目錄下建立一個py檔案，匯入moudle
import module

每一個 Python 模組都定義了它的 name 屬性。如果它與 main 屬性相同則代表這一
模組是由使用者獨立執行的

編寫自己的模組

//儲存為my_module.py
def say():
    print("I am happy to learn python")
__version__=‘1.0’

在另一程式中匯入my_module，注意，這兩個檔案需要在同一個目錄之下。

import my_module

my_module.say()
print('version: ',my_module.__version__)

dir函式

該函式會返回由物件所定義的名稱列表。如果該列表為一模組，則會返回模組所定義的函式，類，變數。

該函式接受引數。 如果引數是模組名稱，函式將返回這一指定模組的名稱列表。 如果沒有提

供引數，函式將返回當前模組的名稱列表

包

當需要組織很多模組的時候，就需要包(package)。

包是指一個包含模組與一個特殊的 init.py 檔案的資料夾，後者向 Python 表明這一文
件夾是特別的，因為其包含了 Python 模組。

資料結構

Python 中有四種內建的資料結構——列表（List）、元組（Tuple）、字典（Dictionary）和集
合（Set）

nameList=['ldq','zhangsan','lisi']

nameList.append('this is added at end')//將元素新增至末尾

//列表是可變的(mutable)

nameTuple=(1,2,3,4)

元組如同字串一樣是不可變的。

一個demo

zoo = ('python', 'elephant', 'penguin')
print('Number of animals in the zoo is', len(zoo))
new_zoo = 'monkey', 'camel', zoo
print('Number of cages in the new zoo is', len(new_zoo))
print('All animals in new zoo are', new_zoo)
print('Animals brought from old zoo are', new_zoo[2])
print('Last animal brought from old zoo is', new_zoo[2][2])
print('Number of animals in the new zoo is',
len(new_zoo)-1+len(new_zoo[2]))

//一個空的元組
zoo=()

//一個元素的元祖
zoo(1,)

字典

d = {key : value1 , key2 : value2}

//key必須是不可變物件

dict={
    'name':'DoctorLDQ','age':'19','sex':'male'
} 
//字典中的成對的鍵值—值配對不會以任何方式進行排序

ab = {
'Swaroop': '[email protected]',
'Larry': '[email protected]',
'Matsumoto': '[email protected]',
'Spammer': '[email protected]'
}
print("Swaroop's address is", ab['Swaroop'])
# 刪除一對鍵值—值配對
del ab['Spammer']
print('\nThere are {} contacts in the address-book\n'.format(len(ab)))
for name, address in ab.items():
qprint('Contact {} at {}'.format(name, address))
# 新增一對鍵值—值配對
ab['Guido'] = '[email protected]'
if 'Guido' in ab:
    print("\nGuido's address is",ab['Guido'])

字典的item()方法獲取字典中每一對鍵值對的資訊。

集合(set)簡單物件的無序集合。

fruit1=set(['apple','strawberry','lemon'])
fruit.add('banana')
fruit
fruit.remove('apple')
fruit1 & fruit2 //可用來求公共集合
fruit1.issuperset(fruit2)   //判斷是否為set

==如果你希望建立一份諸如序列等複雜物件的副本（而非整數這種簡單的物件
（Object）），你必須使用切片操作來製作副本==

字串

name='liudongqing'

if name.startswith('l'):
    print('Start with l')
if 'a' in name:
    print('a is in name')
if name.find('ing')!=-1:    //如果找不到則返回-1
    print('contain ing')


delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print(delimiter.join(mylist))

軟體開發流程

1. What/做什麼（分析）
2. How/怎麼做（設計）
3. Do It/開始做（執行）
4. Test/測試（測試與修復錯誤）
5. Use/使用（操作或開發）
6. Maintain/維護（改進
7.

類與物件

class my:
    def say_hello(self):
        print('Learing python')
p=my()
p.say_hello()

init方法是類中一個特殊的方法，在物件被例項化時會立即呼叫。不會顯示呼叫它。

class my:
    def __init__(self,name):
        self.name = name
    def say_hello(self):
        print(' Learing python',self.name)
p=my('liudongqing')
p.say_hello()

類變數與物件變數

數
據部分——也就是欄位——只不過是繫結（Bound）到類與物件的名稱空間（Namespace）
的普通變數

欄位（Filed）有兩種型別——類變數與物件變數。

類變數是共享的，可以被類的所有例項訪問。該變數只有一個副本，當一個發生變化時，其它例項中也會有所體現。

物件變數（Object variable）由類的每一個獨立的物件或例項所擁有。

==每個物件可以都通過

self.class 屬性來引用它的類

定義一個classmethod

@classmethod
def how_many(cls):
"""打印出當前的人口數量"""
print("We have {:d} robots.".format(cls.population))

私有變數：__name

任何在類或物件之中使用的變數其命名應以2個下劃線開頭，其
它所有非此格式的名稱都將是公開的，並可以為其它任何類或物件所使用

class schoolWorker:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def tell(self):
        print("My name is {0}.I am {1} years old".format(self.name,self.age),end='.')
class Teacher(schoolWorker):
    def __init__(self,name,age,job):
        schoolWorker.__init__(self,name,age)
        self.job=job
    def tell(self):
        schoolWorker.tell(self)
        print('My job is {}'.format(self.job),end='\n')

class student(schoolWorker):
    def __init__(self,name,age,job):
        schoolWorker.__init__(self,name,age)
        self.job=job
    def tell(self):
        schoolWorker.tell(self)
        print("My job is {}".format(self.job))


ST=Teacher('liudongqing',19,'teacher')
ST.tell()

SS=student('liudongqing','20','student')
SS.tell()

mem=[ST,SS]
for x in mem:
   x.tell()

==如果在子類中定義了init(),則Python不會自動呼叫基類的init(),你需要在子類的init()中顯示呼叫。如果我們沒有在一個子類中定義一個 init 方法，Python 將會自動呼叫基類的構
造函式==
記到這裡的感覺就是python真的是一種包容性很強的語言。

如果繼承元組（Inheritance Tuple）中有超過一個類，這種情
況就會被稱作多重繼承（Multiple Inheritance）

輸入與輸出

get=input("Input a word:")  //讓使用者輸入，所獲取的值是一個字串
rget=get[::-1]  //可以將一個字串進行反轉
if(get==rget):
    print("It is a palindrom!")
else:
    print("It is not a palindrom!")
print(rget)

Pickle模組，可以將任何純Python物件儲存到一個檔案中，並在之後將其取回。

try…except處理異常。

可以有一個else語句與try..except語句塊相關聯。

我們自己可以通過raise引發一次異常，需要提供異常名或錯誤名，以及要丟擲異常的物件。

class MathException(Exception):     //注意此處，自己通過raise所引發的異常必須是Exception的子類
    def __init__(self,number):
        Exception.__init__(self)    //因為寫了__init__方法，所以此處需要顯示呼叫基類__init__方法
        self.number=number

try:
    number=int(input("Input a number :"))   //通過input()得到的是一個字串，此處需要轉換為一個數字，當然還可以採用float()
    if (number == 0):
        raise MathException(0)
    else:
        print("The number is {}".format(number))
except MathException:   //捕獲自己所引發的異常。
    print("0 運算元不能進行操作")

當程式在執行時，可以通過ctrl+c停止程式執行

with語句

with  open('except.txt') as f
for line in f:
    print(line,end=' ')

標準庫

//之後進行補充。

從一個函式返回兩個數值如何實現？
哈哈，當然是返回一個元組

def get():
    return ('liudongqing',19)

v=get()
print(v)

//當然，我在書中看到python所實現的一種極為簡單的交換我數的方法。但是，現在不太清楚原理是什麼。。。。。
a,b=b,a

列表推導式

>>> li=[1,2,3,4,5,6,7,8,9,10]
>>> litwo=[x * x for x in li if x%2==0]
>>> litwo
[4, 16, 36, 64, 100]

在函式中接收元組與字典

分別使用* 或 **作為元組和字典的字首，來使它們作引數為函式所接收。

//此段程式碼沒有自己完成
>>> def powersum(power, *args):
... '''Return the sum of each argument raised to the specified power.'''
...     total = 0
...     for i in args:
...         total += pow(i, power)
...         return total
...
>>> powersum(2, 3, 4)
25
>>> powersum(2, 10)
100

assert語句。
可以用來斷言某種情況為真或假

>>> assert len(list)
>>> list.pop()
'item'
>>> list
[]
>>> assert len(list)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError