python語句與語法

Python的語句與語法

Python語句的格式

語句的開頭

在python里是不使用{}或者別的符號來限制語句的開始和結尾的，一個語句的開始(除了復合語句)，就是開頭，換行就是結束。在開頭，不能隨意增加空格：

>>> print (1)
1
>>>  print (1)
  File "<stdin>", line 1
    print (1)
    ^
IndentationError: unexpected indent

語句的對齊

在復合語句里也是同樣的，當你使用縮進時，必須一致：

>>> def add(str):
...     str=str
...    print(str)
  File "<stdin>", line 3
    print(str)
             ^
IndentationError: unindent does not match any outer indentation

復合語句

復合語句有單行寫法和多行寫法。從冒號后面就是復合語句的開始。
單行：復合語句只有一行時，可使用單行寫法，但是復合語句所包含的語句不是單行時，需要使用對齊的縮進來表示復合語句

#單行語句
>>> if 1>0: print(1)
...
1
#多行語句
>>> if 1>0:
...     int=1
...     print(int)
...
1

語句的結束

一般語句里，一行的結束就是此語句的結束。
在簡單語句可以使用分號來隔開多個語句。

>>> a=3;b=3;print(a+b)
6

使用列表，元組，字典的時候按照一定的方式可以把一個語句分成多行:

>>> dict={1:'first',
... 2:'second'}

處理錯誤

當我們所寫的語句有bug，會出現一些錯誤，程序會中斷運行。
但我們在這個時候，不想讓程序中斷但還是需要提示報錯的時候可以使用try:

>>> while True:
    _input=input("please input digit:")
    try:
        print("{:d} *10 is {:d}".format(int(_input),int(_input)*10))
        break
    except:
        print("{} is not a number".format(_input))

please input digit:a
a is not a number
please input digit:1
1 *10 is 10

變量賦值

變量命名規則

變量名可以使大小寫字母，數字和下劃線，但只能以大小寫字母和下劃線開頭，不能以數字開頭。變量名是區分大小寫的，保留字符是不能使用的。
python3.0里的保留字符：
false class finally is
None continue for lambda
True def from nonlocal
and del dlobal not
as elif if or
assert else import pass
break except in raise
特殊變量名：
main等，前后都有兩個下劃線的變量名，有很多是有特殊意義的

打印

print 函數

從python3.0開始print變成了函數，但返回值為None，print函數的格式如下：
print([object,...][,sep=''][,end='\'][file=sys.stdout])
在這里，object是要打印的內容。object可以是任意對象。默認是沒有。
sep是兩個object之間隔開的字符。默認是一個空格。
end是結尾，默認為換行。
file為輸出目標，默認為標準輸出流。

>> print(1,2,3,sep=';')
1;2;3
>>> print(1,2,3,sep=':')
1:2:3
>>> print(1,2,3,end='')
1 2 3
>>> print(1,2,3,end='');print (4,5,6,end='')
1 2 34 5 6
>>> print(1,2,3,end='\n');print (4,5,6,end='')
1 2 3
4 5 6
>>> print(1,2,3,file=open(r'D:\ruanjian\1.txt','wt'))
>>> file=open(r'D:\ruanjian\1.txt')

>>> file.read()

'1 2 3\n'

判斷語句

真值測試

在if語句里的<'test'>位置里的就是判斷語句，結果為True，就能進入子語句，判斷語句包含：

• 比較運算符：==,!=,>,<,>=,<=
• 邏輯運算符：and,or,not
• 成員運算符：in，not in
• 身份運算符：is，is not
• 其他：對象為空，0，None等的時候是False,其他為True

  >>> 1<2
  True
  >>> True and True
  True
  >>> 1 and True
  True
  >>> True or False
  True
  >>> not True
  False
  >>> not False
  True
  >>> 1 in [1,2]
  True
  >>> 1 in (1,2)
  True
  >>> 1 in {'1':1}
  False

邏輯運算符

當我們使用and和or的時候，返回結果不一定是True或False:
and:當其中一個或多個測試值為false的時候，取第一個false的值

False
>>> 1 and [] and {}
[]

and:當全部值得測試值為True的時候，取最后一個值

>>> 1 and 2 and True
True
>>> 1 and 2 and True
True
>>> 1 and 2 and True and 3
3

or:當其中一個或多個值為True的時候，取第一個True的值

>>> 0 or [1] or {1:'1'}
[1]
>>> 1 or 0 or 2
1

or:當全部值為false的時候，去左后一個false值

>>> 0 or [] or {}
{}
>>> False or 0 or {}
{}

三元表達式

三元表達式的格式如下：
<'value1'>if <''test'> else <'value2'>
當測試值為真的時候取<'value1'>,假的時候取<'value2'>

>>> 1 if True else 2
1
>>> 1 if False else 2
2
>>> 'True' if 1>2 else 'False'
'False'
>>> 'True' if 1<2 else 'False'
'True'

這個還可以如下運用：
[<'value2'>,<'value1'>][<'test'>]

>>> [2,1][True]
1
>>> [2,1][False]
2
>>> ['False','True'][1>2]
'False'
>>> ['False','True'][1<2]
'True'

while語句

whil語句一般格式：

while <'test1'>:
    <'statement1'>
else:
    <'statement2'>

只要測試語句為真，會一直循環<'statement1'>。當test1為假的時候會運行else語句里的內容。從這里，退出循環的方法有：
1.在<'statement1'>里的語句更改<'test1'>的結果為False
2.在<'statement1'>里的語句里增加break語句來跳出循環
3.在<'statement1'>里的語句里增加exit()來退出python循環，不過這里會退出整個的python程序

例子

>>> a=0;b=10
>>> while a<b:
    print(a,end='')
    a+=1

0123456789

break,continue語句

break語句用來退出最近所在的for語句或while語句。
continue語句是用來跳到最近所在的for語句或者while語句的結尾。

>>> a=0;b=10
>>> while a<b:
    a+=1
    if a==3: continue
    if a ==7: break
    print (a,end='')

12456

pass語句

pass語句是占位的空語句，在有些復合語句里，可能沒有具體的語句，但需要正常運行，這就需要設置空語句（pass）來代替
例子

>>> if True:
    print('true')
else: pass

true

else語句

else語句，只有在for語句和while語句正常結束后，會運行：

>>> a=0;b=10
>>> while a<b:
    print(a,end='')
    a+=1
else:
    print('end')

0123456789end

for語句

for語句在python里是一個通用的序列迭代器：可以遍歷任何有序的序列對象內的元素。可用于字符串、列表、元組、其他內置可迭代對象以及之后我們能通過類所創建的新對象。
一般格式：

for <target> in <object>:
    <statements>
else:
    <statements>

在這里object需是可迭代的對象。每次從object里提取一個元素付給target，之后循環statements里的語句。
例子

>>> for i in a:
    print (i,end='')

12345

用法

使用for循環時，其他開發語言會使用一個變量，定義起始，結束，遞增值。但python里只能做迭代。這個時候可以使用range函數來代替。
range函數格式：
range([起始值,]結束值,[遞增值])
在這里，起始值默認是0，遞增值默認為1。

>>> a=range(10)
>>> for i in a:
    print(i,end='')

0123456789

當迭代后的元素為固定長度的元組。列表的時候：

>>> for a,b,c in [(1,2,3),(4,5,6),(7,8,9)]:
    print (a,b,c)

1 2 3
4 5 6
7 8 9

嵌套循環（不一定是固定長度）：

>>> for l in [(1,2,3),(4,5,6),(7,8,9)]:
    for i in l:
        print(i,end='')
    print()

123
456
789

迭代器和解析

文件迭代器

文件訪問方式如下：

• <'file'>.read():一次性讀取全部內容。
• <'file'>.readline():一次讀取一行。
• <'file'>.readlines():生成列表，每一行是每個元素。
• <'file'>.next():跟readline()差不多，但讀取完之后報錯。

__next__()報錯為stoplteration。在python中任何這類對象都認為是可迭代的。在python里迭代工具（比如for）會調用__next__()來獲取數據，并以stoplteration來確認何時離開。

盡量不要使用readlines()函數，因為這個會一次性得把所有內容讀取到內存里（轉換為列表），運行速度會比較慢。

手動迭代

為了支持手動迭代代碼，python支持next()函數，它會自動讀取__next__()函數。
next(X)等同于X.__next__()。

>>> file=open(r'D:\ruanjian\1.txt')
>>> file.__next__()
'hello,world'
>>> file.seek(0)
0
>>> next(file)
'hello,world'
>>> next(file)
Traceback (most recent call last):
  File "<pyshell#135>", line 1, in <module>
    next(file)
StopIteration

這個會從第一行開始讀取內容，但是這個文本文件就一行，所以讀完之后再讀會報錯。
迭代協議里，當時用for函數進行迭代時，會傳遞給iter()內置函數，以便可迭代對象中獲取迭代器。返回的對象中有next()方法

>>> li=[1,2,3]
>>> i=iter(li)
>>> next(i)
1
>>> next(i)
2
>>> next(i)
3
>>> next(i)
Traceback (most recent call last):
  File "<pyshell#141>", line 1, in <module>
    next(i)
StopIteration

對于文件來說，不需要轉換成iter類型的這一步，
因為文件對象就是自己的迭代器。

>>> file=open(r'D:\ruanjian\1.txt')
>>> file is iter(file)
True

但列表，元組，字符串就不是了。

>>> s='123';l=[1,2,3];t=(1,2,3)
>>> s is iter(s)
False
>>> l is iter(l)
False
>>> t is iter(t)
False

如果要使用next方法就需要先將字符串，列表，元組轉換成迭代器

其他內置類型迭代器

除了文件以及像列表這樣的實際的序列外，其他類型也有其適用的迭代器。例如，遍歷字典鍵的經典方法是明確的獲取其鍵的列表。

>>> dic={'a':1,'b':2,'c':3}
>>> for key in dic.keys():
    print(key,dic[key])

a 1
b 2
c 3

這個迭代器也可以直接對字典進行迭代：

>>> iter1=iter(dic)
>>> iter1.__next__()
'a'
>>> next(iter1)
'b'
>>> next(iter1)
'c'

列表解析

遍歷列表時，使用for循環來修飾它:

>>> li=[1,2,3,4,5]
>>> for i in range(len(li)):
    li[i]+=10

>>> li
[11, 12, 13, 14, 15]

但這樣看來并不簡便，我們可以使用產生所需列表的一個單個表達式來完成上面的循環

>>> li=[1,2,3,4,5]
>>> li=[i+10 for i in li ]
>>> li
[11, 12, 13, 14, 15]

這個先是運算[i+10 for i in li]之后，再把此值賦給li,具體的運算是先是對li進行迭代，每次把單個值賦給i，在進行i+10,成為新列表的單個元素。

擴展用法

我們可以使用如下方法，將列表的某一項排除

>>> li=[1,2,3,4,5]
>>> li=[i+10 for i in li if i != 3]
>>> li
[11, 12, 14, 15]

也可以在列表中進行循環嵌套,可以看到y的循環嵌套在了x循環里

>>> [x+y for x in [1,2,3] for y in [10,20,30]]
[11, 21, 31, 12, 22, 32, 13, 23, 33]

其他迭代環境

map也可用在迭代

>>> list(map(str.upper,open(r'D:\ruanjian\1.txt')))
['HELLO,WORLD']

map函數是把后面的可迭代的每個值當做前面的參數傳入。
上面的語句可以如下解釋：

>>> tmp=[]
>>> for line in open(r'D:\ruanjian\1.txt'):
    tmp.append(str.upper(line))

>>> tmp
['HELLO,WORLD']

相應的也有sorted會對迭代對象進行排序后生成列表

>>> sorted(open(r'D:\ruanjian\1.txt'))
['hello,world']

numerate也會對迭代對象進行運算后生成可迭代列表。enumerate就是在原有的順序中添加序列號。

>>> list(enumerate(open(r'D:\ruanjian\1.txt')))
[(0, 'hello,world')]

sum、any、all、max、min也可使用迭代器。

>>> max([3,5,1,6,4]),min([3,6,8,2,4])
(6, 2)
>>> any([1,[],'True']),all([1,[],'True'])
(True, False)

python3中新的可迭代對象

在python3中函數生成的是可迭代的特定對象：

>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]

python3的這種方式會延遲計算，在提取內容的時候計算結果，這樣會節省內存空間，不需要提前計算后放進內存，迭代對象迭代完成后不能再次讀取

>>> def printlist(list1):
    for i in list1:
        print('function print:{}'.format(i))
        yield 'Result: {}'.format(i)

>>> li=[1,2,3,4,5]
>>> s=printlist(li)
>>> s.__next__()
function print:1
'Result: 1'
>>> s.__next__()
function print:2
'Result: 2'
>>> s.__next__()
function print:3
'Result: 3'

歡迎各位關注本人微信公眾號“沒有故事的陳師傅”