Python 基礎

輸入輸出

輸出

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

>>> print('Hello world!')

Hello world!

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

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

I LOVE Python

print()也可以用于計算：

>>> 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字符的時候，只需要在二進制的ASCII碼前補0即可。

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

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

轉化函數(shù)

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

>>> ord('A')

65

>>> ord('中')

20013

>>> chr(66)

'B'

>>> chr(25991)

'文'

也可以使用16進制的表示：

>>> '\u4e2d\u6587'

'中文'

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

由于Python的字符串類型是str，在內存中以Unicode表示，一個字符對應若干個字節(jié)。如果要在網絡上傳輸，或者保存到磁盤上，就需要把str轉變?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'

反過來，如果我們從網絡或磁盤上讀取了字節(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ù)長度計算

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

>>> len('ABC')

3

>>> len('中國')

2

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

>>> len(b'ABC')

3

>>> len(b'\xe4\xb8\xad\xe5\x9b\xbd')

6

>>> len('中國'.encode('utf-8'))

6

可見，1個中文字符經過UTF-8編碼后通常會占用3個字節(jié)，而1個英文字符只占用1個字節(jié)。

當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'

常用的占位符表示：

%d

整數(shù)

%f

浮點數(shù)

%s

字符串

%x

十六進制整數(shù)

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

>>> '%2d-%02d' % (3, 1)

' 3-01'

>>> '%.2f' % 3.1415926

'3.14

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

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

'Age: 25. Gender: True'

當字符串里面的%是一個普通字符時，就需要轉義，用%%來表示一個%：

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

'growth rate: 7 %'

list和tuple

list

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

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

>>> a

['a', 'b', 'c']

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

>>> len(a)

3

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

>>> a [0]

'a'

>>> a [2]

'c'

如果要取最后一個元素，除了計算索引位置外，還可以使用倒序的方式，用負數(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']

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

>>> 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 "", line 1, in

AttributeError: 'tuple' object has no attribute 'append'

不可變的tuple有什么意義？因為tuple不可變，所以代碼更安全。如果可能，能用tuple代替list就盡量用tuple。

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

>>> t = (1, 2)

>>> t

(1, 2)

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

>>> t = ()

>>> t

()

只有1個元素的tuple定義時必須加一個逗號,，來消除歧義,如果不加逗號，相當于賦值運算：

>>> 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'])

條件語句

if ... else 條件判斷：

if :

elif :

elif :

else:

示例(縮進敏感，默認使用4個空格)：

age = 3

if age >= 18:

print('adult')

elif age >= 6:

print('teenager')

else:

print('kid')

if語句執(zhí)行有個特點，它是從上往下判斷，如果在某個判斷上是True，把該判斷對應的語句執(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()可以轉換為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 用來結束循環(huán)

continue 跳過當前的循環(huán)，繼續(xù)下一次循環(huán)

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

dict和set

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

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

>>> aa['b']

2

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

>>> aa['a']=100

>>> aa['a']

100

如果key不存在，dict就會報錯：

>>> aa['d']

Traceback (most recent call last):

File "", line 1, in

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)方法，對應的value也會從dict中刪除：

>>> aa.pop('c')

3

>>> aa.get('c')

>>>

>>> aa

{'a': 100, 'b': 2}

注意： dict內部存放的順序和key放入的順序是沒有關系的。

和list比較，dict有以下幾個特點：

查找和插入的速度極快，不會隨著key的增加而變慢；

需要占用大量的內存，內存浪費多。

list有與之相反的特性：

查找和插入的時間隨著元素的增加而增加；

占用空間小，浪費內存很少。

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

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

set

set和dict類似，也是一組key的集合，但不存儲value。由于key不能重復，而且元素是無序的，所以，在set中，沒有重復的key。

要創(chuàng)建一個set，需要提供一個list作為輸入集合：

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

>>> s

{1, 2, 3}

重復元素在set中自動被過濾：

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

>>> s

{1, 2, 3}

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

>>> s.remove(4)

>>> s

{1, 2, 3}

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

>>> s1 = set([1, 2, 3])

>>> s2 = set([2, 3, 4])

>>> s1 & s2

{2, 3}

>>> s1 | s2

{1, 2, 3, 4}

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

>>> a

{8, 9, 10}

>>> a.add(list)

Traceback (most recent call last):

File "", line 1, in

TypeError: unhashable type: 'list'

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結

以上是生活随笔為你收集整理的python初学篇笔记_Python学习笔记（基础篇）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。