初識Python

基本數據類型

基本數據類型：

整數 十六進制用0x前綴和0-9，a-f表示

浮點數 整數運算永遠是精確的，而浮點數運算則可能會有四舍五入的誤差

字符串 以’‘或""括起來的任意文本，轉義字符 \ ，多行字符串，可以用’’’…’’'表示，字符串前面加個前綴 r 表示這是一個 raw 字符串，里面的字符就不需要轉義了

布爾值 只有True、False兩種值，布爾值可以用and、or和not運算

空值 用None表示

print 語句可以向屏幕上輸出指定的文字，逗號“,”會輸出一個空格

注釋以 # 開頭，后面的文字直到行尾都算注釋

變量名必須是大小寫英文、數字和下劃線(_)的組合，且不能用數字開頭

等差數列求和：

# -*- coding: utf-8 -*-

x1 = 1

d = 3 # 公差

n = 100

x100 = x1 + (n - 1) * d

s = (x1 + x100) * n / 2

print s

a = 'python'

print 'hello,', a or 'world' # hello, python

b = ''

print 'hello,', b or 'world' # hello, world

列表

Python內置的一種數據類型是列表：list。list是一種有序的集合，可以隨時添加和刪除其中的元素

L = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]

print L

L = [95.5,85,59]

print L[0]

print L[1]

print L[2]

print L[3] # 報錯

print L[-1]

print L[-2]

print L[-3]

L = ['Adam', 'Lisa', 'Bart']

L.append('Paul')

print L # ['Adam', 'Lisa', 'Bart', 'Paul']

L = ['Adam', 'Lisa', 'Bart']

L.insert(0, 'Paul')

print L # ['Paul', 'Adam', 'Lisa', 'Bart']

L = ['Adam', 'Lisa', 'Bart', 'Paul']

L.pop() # 'Paul'

print L # ['Adam', 'Lisa', 'Bart']

L = ['Adam', 'Lisa', 'Paul', 'Bart']

L.pop(2) # 'Paul'

print L # ['Adam', 'Lisa', 'Bart']

切片：

L = ['Adam', 'Lisa', 'Bart', 'Paul']

L[0:3] # ['Adam', 'Lisa', 'Bart']

L[:3] # ['Adam', 'Lisa', 'Bart']

L[1:3] # ['Lisa', 'Bart']

L[:] # ['Adam', 'Lisa', 'Bart', 'Paul']

L[::2] # ['Adam', 'Bart']，第三個參數表示每N個取一個

L = range(1, 101)

print L[:10] # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print L[2::3]

print L[4:50:5] # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]

L = ['Adam', 'Lisa', 'Bart', 'Paul']

L[-2:] # ['Bart', 'Paul']

L[:-2] # ['Adam', 'Lisa']

L[-3:-1] # ['Lisa', 'Bart']

L[-4:-1:2] # ['Adam', 'Bart']

L = range(1, 101)

print L[-10:]

print L[-46::5]

def firstCharUpper(s):

return s[0:1].upper() + s[1:]

print firstCharUpper('hello')

print firstCharUpper('sunday')

print firstCharUpper('september')

元組

tuple是另一種有序的列表，中文翻譯為“ 元組 ”。tuple 和 list 非常類似，但是，tuple一旦創建完畢，就不能修改了。

tuple沒有 append()方法，也沒有insert()和pop()方法

t = ('Adam', 'Lisa', 'Bart')

t = (0,1,2,3,4,5,6,7,8,9)

print t

t = (1)

print t # 1

t = (1,)

print t # (1,)

t = ('a', 'b', ['A', 'B'])

L = t[2]

L[0] = 'X'

L[1] = 'Y'

print t # ('a', 'b', ['X', 'Y'])

t = ('a', 'b', ('A', 'B'))

print t # ('a', 'b', ('a', 'b'))

流程控制

Python代碼的縮進規則，縮進請嚴格按照Python的習慣寫法：4個空格，不要使用Tab，更不要混合Tab和空格，否則很容易造成因為縮進引起的語法錯誤。

if 語句后接表達式，然后用:表示代碼塊開始

age = 20

if age >= 18:

print 'your age is', age # your age is 20

print 'adult' # adult

score = 55

if score >= 60:

print 'passed'

else:

print 'failed'

score = 85

if score >= 90:

print 'excellent'

elif score >= 80:

print 'good'

elif score >= 60:

print 'passed'

else:

print 'failed'

for 循環可以依次把list或tuple的每個元素迭代出來

L = [75, 92, 59, 68]

sum = 0.0

for i in L:

sum += i

print sum / 4

和 for 循環不同的另一種循環是 while 循環，while 循環不會迭代 list 或 tuple 的元素，而是根據表達式判斷循環是否結束

break退出循環

continue繼續循環

sum = 0

x = 1

while x < 100:

sum += x

x += 2

print sum

sum = 0

x = 1

n = 1

while True:

sum += x

x = 2 * x

n += 1

if n > 20:

break

print sum

sum = 0

x = 0

while True:

x = x + 1

if x > 100:

break

if x % 2 == 0:

continue

sum += x

print sum

for x in [1,2,3,4,5,6,7,8,9]:

for y in [1,2,3,4,5,6,7,8,9]:

if x < y:

print x * 10 + y

dict

花括號 {} 表示這是一個dict，然后按照 key: value, 寫出來即可。最后一個 key: value 的逗號可以省略。

通過 key 訪問 dict 的value，只要 key 存在，dict就返回對應的value。如果key不存在，會直接報錯：KeyError。

要避免 KeyError 發生，有兩個辦法：

一是先判斷一下 key 是否存在，用 in 操作符

二是使用dict本身提供的一個 get 方法，在Key不存在的時候，返回None

dict的第一個特點是查找速度快，無論dict有10個元素還是10萬個元素，查找速度都一樣。而list的查找速度隨著元素增加而逐漸下降。

dict的第二個特點就是存儲的key-value序對是沒有順序的！這和list不一樣

dict的第三個特點是作為 key 的元素必須不可變，Python的基本類型如字符串、整數、浮點數都是不可變的，都可以作為 key。但是list是可變的，就不能作為 key。

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59,

'Paul': 75

}

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

print 'Adam:', d['Adam']

print 'Lisa:', d['Lisa']

print 'Bart:', d['Bart']

d = {

95: 'Adam',

85: 'Lisa',

59: 'Bart'

}

d[72] = 'Paul'

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

for key in d:

print key,':',d[key]

dict的作用是建立一組 key 和一組 value 的映射關系，dict的key是不能重復的。

set 持有一系列元素，這一點和 list 很像，但是set的元素沒有重復，而且是無序的，這點和 dict 的 key很像。

set的內部結構和dict很像，唯一區別是不存儲value，因此，判斷一個元素是否在set中速度很快。

set存儲的元素和dict的key類似，必須是不變對象，因此，任何可變對象是不能放入set中的。

s = set(['A', 'B', 'C', 'C'])

print s # set(['A', 'C', 'B'])

len(s) # 3

s = set(['adam', 'lisa', 'bart', 'paul'])

print 'adam' in s

print 'bart' in s

months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])

x1 = 'Feb'

x2 = 'Sun'

if x1 in months:

print 'x1: ok'

else:

print 'x1: error'

if x2 in months:

print 'x2: ok'

else:

print 'x2: error'

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for x in s:

print x[0],':',x[1]

set存儲的是一組不重復的無序元素，因此，更新set主要做兩件事：

一是把新的元素添加到set中，二是把已有元素從set中刪除。

s = set(['Adam', 'Lisa', 'Paul'])

L = ['Adam', 'Lisa', 'Bart', 'Paul']

for x in L:

if x in s:

s.remove(x)

else:

s.add(x)

print s

函數

在交互式命令行通過 help(abs) 查看abs函數的幫助信息

調用函數的時候，如果傳入的參數數量不對，會報TypeError的錯誤

如果傳入的參數數量是對的，但參數類型不能被函數所接受，也會報TypeError的錯誤

abs(-20) # 20

cmp(1, 2) # -1

cmp(2, 1) # 1

cmp(3, 3) # 0

int('123') # 123

int(12.34) # 12

str(123) # '123'

str(1.23) # '1.23'

L = []

for i in range(1, 101):

L.append(i * i)

print sum(L)

在Python中，定義一個函數要使用 def 語句，依次寫出函數名、括號、括號中的參數和冒號:，然后，在縮進塊中編寫函數體，函數的返回值用 return 語句返回。

如果沒有return語句，函數執行完畢后也會返回結果，只是結果為 None。return None可以簡寫為return。

def square_of_sum(L):

sum = 0

for i in L:

sum += i * i

return sum

print square_of_sum([1, 2, 3, 4, 5])

print square_of_sum([-5, 0, 5, 15, 25])

math包提供了sin()和 cos()函數，我們先用import引用它

Python的函數返回多值其實就是返回一個tuple

import math

def quadratic_equation(a, b, c):

t = math.sqrt(b * b - 4 * a * c)

return (-b + t) / (2 * a),( -b - t )/ (2 * a)

print quadratic_equation(2, 3, 0)

print quadratic_equation(1, -6, 5)

def move(n, a, b, c): # 遞歸

if n == 1:

print a, '-->', c

return

move(n-1, a, c, b)

print a, '-->', c

move(n-1, b, a, c)

move(4, 'A', 'B', 'C')

def greet(x='world'): # 默認參數

print 'Hello,',x,'.'

greet()

greet('Bart')

def average(*args): # 可變參數

sum = 0.0

if len(args) == 0:

return sum

for x in args:

sum = sum + x

return sum / len(args)

print average()

print average(1, 2)

print average(1, 2, 2, 3, 4)

迭代

在Python中，如果給定一個list或tuple，我們可以通過for循環來遍歷這個list或tuple，這種遍歷我們成為迭代(Iteration)。

因為 Python 的 for循環不僅可以用在list或tuple上，還可以作用在其他任何可迭代對象上。

迭代操作就是對于一個集合，無論該集合是有序還是無序，我們用 for 循環總是可以依次取出集合的每一個元素。

集合是指包含一組元素的數據結構，我們已經介紹的包括：

有序集合：list，tuple，str和unicode；

無序集合：set

無序集合并且具有 key-value 對：dict

Python中，迭代永遠是取出元素本身，而非元素的索引。使用 enumerate() 函數

實際上，enumerate() 函數把：[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]

變成了類似：[(0, ‘Adam’), (1, ‘Lisa’), (2, ‘Bart’), (3, ‘Paul’)]

dict 對象有一個 values() 方法，這個方法把dict轉換成一個包含所有value的list

dict除了values()方法外，還有一個 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一樣

items() 方法把dict對象轉換成了包含tuple的list

for i in range(1,101):

if i % 7 == 0:

print i

L = ['Adam', 'Lisa', 'Bart', 'Paul']

for index, name in enumerate(L):

print index, '-', name

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }

sum = 0.0

for v in d.itervalues():

sum += v

print sum / len(d)

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }

sum = 0.0

for k, v in d.items():

sum = sum + v

print k,':',v

print 'average', ':', sum / len(d)

列表生成式

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我們可以用range(1, 11)

要生成[1x1, 2x2, 3x3, …, 10x10]，方法一是循環

但是循環太繁瑣，而列表生成式則可以用一行語句代替循環生成上面的list：[x * x for x in range(1, 11)]

range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,…]

列表生成式的 for 循環后面還可以加上 if 判斷：[x * x for x in range(1, 11) if x % 2 == 0]

print [n * (n+1) for n in range(1, 100, 2)] # [1x2, 3x4, 5x6, 7x8, ..., 99x100]

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

def generate_tr(name, score):

if score < 60:

return '

%s%s' % (name, score)

return '

%s%s' % (name, score)

tds = [generate_tr(name, score) for name, score in d.iteritems()]

print '

print '

NameScore'

print '\n'.join(tds)

print '

'

def toUppers(L):

return [x.upper() for x in L if isinstance(x, str)]

print toUppers(['Hello', 'world', 101])

print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]

總結

以上是生活随笔為你收集整理的慕课网初识python_初识Python笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

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