請注意，本文編寫于 637 天前，最后修改于 624 天前，其中某些信息可能已經過時。

之前學了一些，現在全忘了。有時間所以又重新看了一下，并做以下記錄

有一門面向對象語言的基礎，30分鐘足夠看一遍Python的基礎了

基礎語法# 縮進取代大括號

# 用換行取代分號，也可以使用分號，無所謂

# 輸出

print();

# 輸入

input();

# 注釋

#單行注釋

"""

多行注釋1

"""

'''

多行注釋2

'''

# 申明變量

直接寫字母就行與數字、下劃線組合即可，不是保留字即可。

# if

if true:

print("true")

else:

print("false")

# while

i = 0;

while i <= 1:

#do something

print("cicle")

i+=1

# for

languages = ["C", "C++", "Perl", "Python"]

for x in languages:

print (x)

# range

range(5)函數返回數字0~4的數組

range(5,9) 函數返回數字5~8的數組

range(0,10,3) 函數返回從數字0開始，遞增3，直到最后一個數字小于10的數字數組

range(-10,-100,-30) 函數返回從-10開始，遞增-30，直到最后一個數組大于-100的數字數組

# for + range 帶索引遍歷數組

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']

for i in range(len(a))

print(i,a[i])

# while 帶索引遍歷數組

i = 0;

length = len(a);

while i < a:

print(i,a[i])

i+=1

# for + enumerate 帶索引遍歷數組

for i,value in enumerate(a):

print(i,value)

# 列表list

# python list 和java list性質很類似，而不是數組，它的大小可變，但是Python列表的元素可以使把不同的數據類型，非常靈活

# 創建新的list

list1 = []

list2 = ['bob',1,true]

# 增加元素

list1.append(233)

list1.insert(0,666) #插入到0位置，原來元素依次后移

# 刪除元素

list2.pop() #刪除末尾的元素

list2.pop(0)

# 修改元素 = 直接賦值

# 訪問指定位置元素

list1[2]

list1[-1] #表示最后一個元素

# 切片(返回一個子列表)

list2[0:2] #表示從索引0到1的元素

list2[-2:-1] #表示倒數第二個元素

list2[:3] #表示從0到2

list2[1:] #表示從1到結尾

# 元組tuple

# 與list列表區別是，tuple一旦初始化就不能修改。

# list使用[]方括號，tuple使用()圓括號

# 定義時候，只有一個元素，需要加一個,，避免歧義

t = (1,)

# 字典dict

# dict 和 java的map很類似。鍵值對，Python的dict很類似json的語法

# 定義

d = {'age':62, 'sex':'male'}

# 訪問值

d['age']

# 判斷key是否存在

d.get('name') #默認不存在返回none

d.get('name',-1) #指定不存在時候返回-1

'name' in d #不存在時候返回false

# 刪除key

d.pop('sex')

# 集合set

# 和java的set性質很類似，也是沒有重復元素的集合。

# 定義

s = set([1,1,2,2,2,3,3,'sex'])

# 添加元素

s.add(4)

s.add(4) # 重復元素添加操作不會生效

# 刪除元素

s.remove('sex') #參數是set元素的值，而不是索引

# 函數

# 定義函數

def my_function(x):

print(x);

# 調用函數

高級特性

列表生成式和生成器列表生成器

一種快速生成一個指定條件的列表的語法。

第一個例子：生成數字0~10的列表，可以使用range(0，11)函數，這個并不是列表生成器，只是引出這個概念。

第二個例子：生成[1x1, 2x2, 3x3, ..., 10x10] 這樣乘積結果形成的列表，普通寫法是一層循環：l = []

for x in range(1,11):

l.append(x*x)

# 或者下面的循環

i = 1

while i < 11:

l.append(i*i)

i+=1

現在使用列表生成式只需要一句代碼：[x*x for x in range(1,11)]

仔細看下上面代碼，可以發現，就是把l.append(x*x)替換成x*x，并寫在了for循環前面，而且整體用列表的符號[]包裹起來。

還可以更近一步，在for循環后面，寫if語句，進一步篩選需要生成的元素：[x * x for x in range(1, 11) if x % 2 == 0]

# [4, 16, 36, 64, 100]

可以說，列表生成式就是一種語法的簡化，沒什么新的功能。生成器

列表生成式是真實返回一個生成好的列表。

但是如果我們需要生成的列表特別大，被逼入100萬的成員，但我們只需要打印前幾個元素，后面那個多成員所占用的空間就浪費了：L = [x * x for x in range(1000000)]

print(L[0])

print(L[1])

上面寫法就是非常浪費，要遭到我們譴責的。可以用下面寫法：g = (x * x for x in range(1000000))

next(g)

next(g)

這種寫法的返回的并不是一個列表，而是一個生成器g。生成器就好比一個記住規則的工具，一開始并不會生成任何元素，通過調用next()一個個的生成數組元素。

加入我想生成10個元素，我可以迭代生成器：g = (x * x for x in range(10))

for x in g:

print(x)

上面語法可以創建一個生成器，還可以通過yield關鍵字使一個函數成為生成器：def odd():

print('step 1')

yield 1

print('step 2')

yield(3)

print('step 3')

yield(5)

g = odd()

next(g) # step 1

next(g) # step 2

next(g) # step 3

next(g) # StopIteration

同樣可以使用for循環迭代這個生成器：for x in odd():

print(x) # 依次返回1 3 5

一個函數成為生成器，使用next調用函數，遇到yield語句會返回yield申明的值(常量/變量)。再次調用next從上次返回的位置繼續，直到遇到下一個yield語句。

迭代器

首先需要區分兩個概念：迭代器(Iterator)和可迭代對象(Iterable)：可迭代對象：可以使用for遍歷，但是不能被next()調用，不斷的返回下一個值。

迭代器：可以通過調用next(Iterator)，不斷返回迭代器內部的值

通過isinstance([變量] , Iterator)或isinstance([變量] , Iterable) 判斷變量是否是迭代器或是可迭代對象

list、dict、str本身不是迭代器，可以通過iter(Iterable)返回迭代器對象

生成器本身就是迭代器對象。l = [1, 2, 3, 4, 5]

lIter = iter(l)

next(lIter) # 返回1

函數式編程

裝飾器

設計模式里有一個設計模式就是裝飾器模式，其實很容易理解，就是對函數進行擴展功能。但是又不想通過繼承的方式。

用裝飾器函數把原函數包裹起來，先執行裝飾器的功能，再調用原函數。

所以裝飾器的參數首先需要原函數func_name，而且裝飾器內部還需要定義一個函數wrapper，參數是*args, **kw，表示任意參數，用來接收調用原函數的參數。

舉個例子，定義一個log的裝飾器，可以裝飾在任何函數上(方式是在需要裝飾的函數頂部寫@裝飾器名稱)，執行原函數，會輸出該函數的調用信息：def log(func):

def wrapper(*args, **kw):

print("調用函數%s()"% func.__name__)

return func(*args, **kw)

return wrapper

@log

def now(str):

print("一個測試函數 + %s" % str)

當我們執行now("哈哈")，實際上執行的是log(now("哈哈"))，然后log函數內部調用wrapper("哈哈")，先打印測試時間，再執行了now("哈哈")

裝飾器也可以傳值，但是裝飾器內部再多一個函數，用來接收需要裝飾的函數名：def log(text):

def decorator(func):

def wrapper(*args, **kw):

print("調用函數%s()時間為，測試文字 %s" % (func.__name__ ,text))

return func(*args, **kw)

return wrapper

return decorator

@log("自定義文字")

def now(str2):

print("一個測試函數 + %s" % str2)

這樣調用now("哈哈")，實際上調用了log("自定義文字")now("哈哈")，然后執行decorator(now("哈哈"))，下面的調用過程和之前一樣了。

被裝飾器修飾的函數，會有一個問題：打印他的函數名稱會有問題：

比如now.__name__，會輸出wrapper，我們可以在wrapper的函數，上面寫一句：import functools

def log(func):

@functools.wraps(func)

def wrapper(*args, **kw):

print("調用函數%s()"% func.__name__)

return func(*args, **kw)

return wrapper

這句注解自動會幫我們wrapper.__name__ = func.__name__賦值。

面向對象編程

我們用java的類概念來引入Python的面向對象的所有概念：類class Student(object):

def __init__(self, name, score, sex):

self.name = name

self.score = score

self.__sex = sex;

def print_score(self):

print('%s: %s' % (self.name, self.score))

st = Student("hewro",120,"male")

print(st.name)

st.print_sore()

從上面代碼，我們可以看出：成員變量是在__init__中定義，而不是直接申明變量

構造函數名稱是__init__，Python不支持函數重載，自然只能有一個構造函數了。而且第一個參數一定是self，生成實例的時候，不需要手動調用該參數。

在類的內部使用本身的變量，需要在函數第一個參數添加self，很麻煩

繼承父類的寫法不是extend，而是(父類)

python 的私有變量定義也沒有關鍵字，只是定義變量名稱前面加兩個下劃線__，如__sex，就無法直接打印std.__sex關于多態

我們知道多態是繼承帶來的一個很好特性。java、Python都有。但是Python本身變量不需要申明類型，所以多態實現，并不一定需要是定義父類的子類，而只要是該對象也擁有指定的方法即可(即鴨子類型)。

比如我們有一個Animal的父類，還有繼承Animal的Dog和Cat 子類class Animal(object):

def run(self):

print('Animal is running...')

class Dog(Animal):

def run(self):

print('Dog is running...')

class Cat(Animal):

def run(self):

print('Cat is running...')

class Tortoise(Animal):

def run(self):

print('Tortoise is running slowly...')

# 這個函數的參數實際上是沒有申明類型的

def run_twice(animal):

animal.run()

animal.run()

所以執行run_twince()參數可以是dog實例，也可以是Tortoise的實例，雖然Tortoise并不繼承于Animal。

總結

以上是生活随笔為你收集整理的python语法速成方法_30分钟学完Python基础语法的全部內容，希望文章能夠幫你解決所遇到的問題。

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