Python 基礎(chǔ)

此學(xué)習(xí)筆記參照廖雪峰老師的網(wǎng)上Python教程，參考鏈接：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

輸入輸出

輸出

使用print()可以向屏幕上輸出指定的文字：

>>> print('Hello world!')  
Hello world!

print()中可以接受多個字符串，當(dāng)用逗號隔開時會形成一連串的輸出,逗號相當(dāng)于空格：

>>> print('I','LOVE','Python')
I LOVE Python

print()也可以用于計(jì)算：

>>> print(100+100)
200
>>> print('100 + 100 =',100+100)
100 + 100 = 200

輸入

input()可以讓用戶輸入字符：

>>> aa=input()
Python
>>> aa
'Python'

還可以添加提示：

>>> name=input("請輸入你的名字：\n")
請輸入你的名字：
andy
>>> name
'andy'
>>> print('hello',name)
hello andy

字符串編碼

• ASCII:使用一個字節(jié)，此編碼包含大小寫英文字母，數(shù)字符號等。
• Unicode：一般使用兩個字節(jié)表示字符，可表示所有語言字符。

在使用Unicode表示ASCII字符的時候，只需要在二進(jìn)制的ASCII碼前補(bǔ)0即可。

• UTF-8：可變長編碼。將一個Unicode字符根據(jù)不同的數(shù)字大小轉(zhuǎn)化成1-6個字節(jié)，通常英文被轉(zhuǎn)化為1個字節(jié)，漢字通常是3個字節(jié)。

在保存和傳輸文件時為了節(jié)省空間都會轉(zhuǎn)化為UTF-8的字符編碼格式，當(dāng)需要在內(nèi)存中加載時再轉(zhuǎn)化為Unicode編碼。

轉(zhuǎn)化函數(shù)

可以使用ord()和chr()函數(shù)對字符和編碼進(jìn)行轉(zhuǎn)換：

>>> ord('A')
65
>>> ord('中') 
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

也可以使用16進(jìn)制的表示：

>>> '\u4e2d\u6587'
'中文'

str類型和bytes類型數(shù)據(jù)轉(zhuǎn)換

由于Python的字符串類型是str，在內(nèi)存中以Unicode表示，一個字符對應(yīng)若干個字節(jié)。如果要在網(wǎng)絡(luò)上傳輸，或者保存到磁盤上，就需要把str轉(zhuǎn)變?yōu)橐宰止?jié)為單位的bytes，Python 對字節(jié)類型的表示使用b表示，如要表示一個byte類型的數(shù)據(jù)，使用加b的前綴，用單引號或者雙引號：

x=b'ABC'

存儲或傳輸數(shù)據(jù)的時候，可以使用ASCII和UTF-8的編碼方式將str類型的數(shù)據(jù)裝換為byte類型，使用encode()方法（英文使用ascii的編碼方式，中文要使用utf-8的編碼方式）：

>>> 'abc'.encode('ascii')
b'abc'
>>> '中國'.encode('utf-8')
b'\xe4\xb8\xad\xe5\x9b\xbd'

反過來，如果我們從網(wǎng)絡(luò)或磁盤上讀取了字節(jié)流，那么讀到的數(shù)據(jù)就是bytes。要把bytes變?yōu)閟tr，就需要用decode()方法：

>>> b'abc'.decode('ASCII')
'abc'
>>> b'\xe4\xb8\xad\xe5\x9b\xbd'.decode('utf-8')
'中國'

數(shù)據(jù)長度計(jì)算

要計(jì)算str包含多少個字符，可以用len()函數(shù)：

>>> len('ABC')
3
>>> len('中國')
2

len()函數(shù)計(jì)算的是str的字符數(shù)，如果換成bytes，len()函數(shù)就計(jì)算字節(jié)數(shù)：

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe5\x9b\xbd')
6
>>> len('中國'.encode('utf-8'))
6

可見，1個中文字符經(jīng)過UTF-8編碼后通常會占用3個字節(jié)，而1個英文字符只占用1個字節(jié)。
當(dāng)Python解釋器讀取源代碼時，為了讓它按UTF-8編碼讀取，我們通常在文件開頭寫上這兩行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

格式化輸出

對于一些格式化的要求，一般使用%#的方式來表示不同的變量，在之后使用%（數(shù)值）來表示具體的數(shù)值：

>>> '你好，%s' %'Andy'
'你好，Andy'

多個不同類型的變量：

>>> 'hi %s,you age is %d' % ('Andy',24)
'hi Andy,you age is 24'

常用的占位符表示：

其中，格式化整數(shù)和浮點(diǎn)數(shù)還可以指定是否補(bǔ)0和整數(shù)與小數(shù)的位數(shù)：

>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14

如果你不太確定應(yīng)該用什么，%s永遠(yuǎn)起作用，它會把任何數(shù)據(jù)類型轉(zhuǎn)換為字符串：

>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'

當(dāng)字符串里面的%是一個普通字符時，就需要轉(zhuǎn)義，用%%來表示一個%：

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'

list和tuple

list

1. list是一種有序的集合，可以隨時添加和刪除其中的元素。

   >>> a = ['a', 'b', 'c']
   >>> a
   ['a', 'b', 'c']
   

• 用len()函數(shù)可以獲得list元素的個數(shù)：

  >>> len(a)
  3
  

• 用索引來訪問list中每一個位置的元素，記得索引是從0開始的：

  >>> a [0]
  'a'
  >>> a [2]
  'c'
  

• 如果要取最后一個元素，除了計(jì)算索引位置外，還可以使用倒序的方式，用負(fù)數(shù)表示，最后一個為-1，直接獲取最后一個元素：

  >>> a[-1]
  'c'
  >>> a[-2]
  'b'
  

• list是一個可變的有序表，所以，可以往list中追加元素到末尾，使用append（）函數(shù)：

  >>> a.append('x')
  >>> a
  ['a', 'b', 'c', 'x']
  

• 指定索引位置插入,使用insert(,)函數(shù)：

  >>> a.insert(1,'y')
  >>> a
  ['a', 'y', 'b', 'c', 'x']
  

• 刪除list末尾的元素，用pop()方法：

  >>> a.pop()
  'x'
  >>> a
  ['a', 'y', 'b', 'c']
  

• 刪除指定位置的元素，用pop(i)方法，其中i是索引位置：

  >>> a.pop(1)
  'y'
  >>> a
  ['a', 'b', 'c']
  

• 要把某個元素替換成別的元素，可以直接賦值給對應(yīng)的索引位置：

  >>> a[1]='hello'
  >>> a
  ['a', 'hello', 'c']
  

• list里面的元素的數(shù)據(jù)類型也可以不同，比如：

  >>> L = ['Apple', 123, True]
  

• list中還可以嵌套其他list,且可以是變量：

  >>> s = ['python', 'java', ['asp', 'php'], 'scheme']
  

  >>> p = ['asp', 'php']
  >>> s = ['python', 'java', p, 'scheme']
  

• 要拿到'php'可以寫p[1]或者s[2][1]，因此s可以看成是一個二維數(shù)組，類似的還有三維、四維……數(shù)組，不過很少用到。

• 如果一個list中一個元素也沒有，就是一個空的list，它的長度為0：

  >>> L = []
  >>> len(L)
  0  
  

tuple

另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，它沒有append()，insert()這樣的方法。其他獲取元素的方法和list是一樣的，你可以正常地使用b[0]，b[-1]，但不能賦值成另外的元素。

>>> b = ('a','b','c')
>>> b[1]
'b'
>>> b.append('x')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'

不可變的tuple有什么意義？因?yàn)閠uple不可變，所以代碼更安全。如果可能，能用tuple代替list就盡量用tuple。

tuple的陷阱：當(dāng)你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來，比如：

>>> t = (1, 2)
>>> t
(1, 2)

• 如果要定義一個空的tuple，可以寫成()：

  >>> t = ()
  >>> t
  ()
  

• 只有1個元素的tuple定義時必須加一個逗號,，來消除歧義,如果不加逗號，相當(dāng)于賦值運(yùn)算：

  >>> t = (1,)
  >>> t
  (1,)
  

• 在tuple中定義list,那么tuple中的list部分就是可變的：

  >>> t = ('a', 'b', ['A', 'B'])
  >>> t[2][0] = 'X'
  >>> t[2][1] = 'Y'
  >>> t
  ('a', 'b', ['X', 'Y'])
  

條件語句

1. if ... else 條件判斷：

   if <條件判斷1>:
    <執(zhí)行1>
   elif <條件判斷2>:
    <執(zhí)行2>
   elif <條件判斷3>:
    <執(zhí)行3>
   else:
    <執(zhí)行4>
   

   示例(縮進(jìn)敏感，默認(rèn)使用4個空格)：

   age = 3
   if age >= 18:
       print('adult')
   elif age >= 6:
       print('teenager')
   else:
       print('kid')
   

   if語句執(zhí)行有個特點(diǎn)，它是從上往下判斷，如果在某個判斷上是True，把該判斷對應(yīng)的語句執(zhí)行后，就忽略掉剩下的elif和else：

   age = 20
   if age >= 6:
       print('teenager')
   elif age >= 18:
       print('adult')
   else:
       print('kid') 
   

   if判斷條件還可以簡寫(x只要為非空的數(shù)值、字符串、list等，就判斷為True,否則為False):

   if x:
       print('True')
   

• 循環(huán)語句

• for 循環(huán)：

  sum = 0
  for x in range(101):
      sum = sum + x
  print(sum)
  

  rang()函數(shù)可以生成一個序列，使用list（）可以轉(zhuǎn)換為list:

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

• while循環(huán)：

  sum = 0
  n = 99
  while n > 0:
      sum = sum + n
      n = n - 2
  print(sum) 
  

• break 用來結(jié)束循環(huán)
• continue 跳過當(dāng)前的循環(huán)，繼續(xù)下一次循環(huán)

break語句可以在循環(huán)過程中直接退出循環(huán)，而continue語句可以提前結(jié)束本輪循環(huán)，并直接開始下一輪循環(huán)。這兩個語句通常都必須配合if語句使用。不要濫用break和continue語句。break和continue會造成代碼執(zhí)行邏輯分叉過多，容易出錯。大多數(shù)循環(huán)并不需要用到break和continue語句，上面的兩個例子，都可以通過改寫循環(huán)條件或者修改循環(huán)邏輯，去掉break和continue語句。

dict和set

Python內(nèi)置了字典：dict的支持，dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存儲，具有極快的查找速度。

>>> aa={'a':1,'b':2,'c':3}
>>> aa['b']
2

1. 把數(shù)據(jù)放入dict的方法，除了初始化時指定外，還可以通過key放入。由于一個key只能對應(yīng)一個value，所以，多次對一個key放入value，后面的值會把前面的值沖掉：

>>> aa['a']=100
>>> aa['a']
100

• 如果key不存在，dict就會報(bào)錯：

  >>> aa['d']
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  KeyError: 'd'
  

• 可以通過如下兩種方法判斷KEY值是否存在：

  • 使用in判斷key值是否存在：

    >>> 'd' in aa
    False
    >>> 'a' in aa 
    True
    

  • 通過dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

    >>> aa.get('c','xx')
    3
    >>> aa.get('d','xx')
    'xx'
    >>> aa.get('d')     
    >>> 
    

  • 要刪除一個key，用pop(key)方法，對應(yīng)的value也會從dict中刪除：

    >>> aa.pop('c')
    3
    >>> aa.get('c')
    >>>
    >>> aa
    {'a': 100, 'b': 2} 
    

  注意： dict內(nèi)部存放的順序和key放入的順序是沒有關(guān)系的。

• 和list比較，dict有以下幾個特點(diǎn)：

  • 查找和插入的速度極快，不會隨著key的增加而變慢；
  • 需要占用大量的內(nèi)存，內(nèi)存浪費(fèi)多。

• list有與之相反的特性：

  • 查找和插入的時間隨著元素的增加而增加；
  • 占用空間小，浪費(fèi)內(nèi)存很少。

提示：dict可以用在需要高速查找的很多地方，在Python代碼中幾乎無處不在，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變對象。dict根據(jù)key來計(jì)算value的存儲位置，如果每次計(jì)算相同的key得出的結(jié)果不同，那dict內(nèi)部就完全混亂了。這個通過key計(jì)算位置的算法稱為哈希算法（Hash）。

要保證hash的正確性，作為key的對象就不能變。在Python中，字符串、整數(shù)等都是不可變的，因此，可以放心地作為key。而list是可變的，就不能作為key.

set

set和dict類似，也是一組key的集合，但不存儲value。由于key不能重復(fù)，而且元素是無序的，所以，在set中，沒有重復(fù)的key。
要創(chuàng)建一個set，需要提供一個list作為輸入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

重復(fù)元素在set中自動被過濾：

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

通過remove(key)方法可以刪除元素：

>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成數(shù)學(xué)意義上的無序和無重復(fù)元素的集合，因此，兩個set可以做數(shù)學(xué)意義上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一區(qū)別僅在于沒有存儲對應(yīng)的value，但是，set的原理和dict一樣，所以，同樣不可以放入可變對象，因?yàn)闊o法判斷兩個可變對象是否相等，也就無法保證set內(nèi)部“不會有重復(fù)元素”。

>>> a
{8, 9, 10}
>>> a.add(list)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'