您现在的位置：程式師世界 >> 編程語言 > >> 更多編程語言 >> Python

Python從入門到入土-基礎語法

編輯：Python

文章目錄

- 看不見的開始和結束
- 函數
- 類
- 順序語句
- 循環語句
- 數據類型
- 內置類
- 常用內置方法

看不見的開始和結束

作用域是編程語言裡的一個重要的概念，特別是塊作用域，編程語言一般會使用明確的符號標記一個作用域的開始和結束。
例如 C、C++、Java、C#、Rust、Go、JavaScript 等常見語言都是用"{“和”}"來標記一個塊作用域的開始和結束：

// 這是一個C語言程序
if(i<10){

if(i<5){

print("win more!");
}else{

print("win");
}
}else{

print("loose");
}

// 這是一個 Rust 語言程序
if i<10 {

if i<5 {

println!("win more!");
}else{

println!("win");
}
}else{

println!("loose");
}

而 Python 程序則是用縮進來表示塊作用域的開始和結束：

# 這是一個 Python 程序
if i<10:
if i<5:
print("win more!")
else:
print("win")
else:
print("loose")

Python 對縮進有嚴格的要求，同一個源文件裡，縮進必須保持一致，例如都是2個空格或者4個空格。Python 這麼做的理由是使用縮進更簡潔，同時不用考慮"{"要放在哪一行，而且是用縮進足夠Python解釋器正確解析。但是使用縮進如果沒有編輯器自動檢測和格式化也會帶來一些不必要的麻煩。

函數

函數是代碼復用的最簡單形式。在第一章裡我們已經多次不經介紹地使用了函數來組織代碼。現在可以系統認識下函數的參數。

# -*- coding: UTF-8 -*-
def dump(index, default=0, *args, **kw):
print('打印函數參數')
print('---')
print('index:', index)
print('default:', default)
for i, arg in enumerate(args):
print(f'arg[{
i}]:', arg)
for key,value in kw:
print(f'keyword_argument {
key}:{
value}')
print('')
if __name__=='__main__':
dump(0)
dump(0,2)
dump(0,2,"Hello","World")
dump(0,2,"Hello","World", install='Python', run='Python Program')

Python函數的參數十分靈活，例如上面的例子：

index: 按順序位置指定的參數
default=0: 帶有默認值的參數
*args: 0個或多個可選的參數
**kw: 0個或多個關鍵字參數

類

類定義和使用如下：

class KeyValueSet:
def __init__(self) -> None:
self.dict = {
}
def set(self, key, value):
self.dict[key] = value
def get(self, key):
return self.dict.get(key)
def keys(self):
return self.dict.keys()

from com.zjq.python.base.classuse.KeyValueSet import KeyValueSet
class GuessSentenceGame:
def __init__(self):
self.kv = KeyValueSet()
self.score = 0
def setup(self, sentences):
for sentence in sentences:
self.append(sentence)
def append(self, sentence):
cut_pos = sentence.find(' ')
first_word, rest = sentence[0:cut_pos], sentence[cut_pos + 1:].strip()
self.kv.set(first_word, rest)
def guess(self, first_word):
ret = self.kv.get(first_word)
if ret is None:
return 1, None
else:
return 0, ret
def run(self):
self.score = 0
for first_word in self.kv.keys():
ret = input("猜一猜下半句是什麼？ {} -> :".format(first_word))
err, value = self.guess(first_word)
if err == 0:
print('你太厲害了，這都能猜得到！+10分！')
self.score += 10
else:
self.score -= 2
print('哈哈，肯定猜不到得啦：{}->{}，扣除2分！'.format(first_word, value))
print('游戲結束，你本次游戲得分：', self.score)
if __name__ == '__main__':
sentences = [
"hello world",
'monkey king',
'tomorrow is another day',
"good bye"
]
game = GuessSentenceGame()
game.setup(sentences)
game.run()

繼承使用如下：

from com.zjq.python.base.classuse.KeyValueSet import KeyValueSet
class HashKeyValueSet(KeyValueSet):
def __init__(self) -> None:
super().__init__()
def hset(self, hash_key, key, value):
self.set(hash_key, {
key: value})
def hget(self, hash_key, key):
hash_set = self.get(hash_key)
if hash_set is None:
return None
else:
return hash_set.get(key)
def hkeys(self, hash_key):
hash_set = self.get(hash_key)
if hash_set is None:
return []
else:
return hash_set.keys()
if __name__ == '__main__':
from com.zjq.python.base.classuse.HashKeyValueSet import HashKeyValueSet
hashset = HashKeyValueSet()
hashset.hset('puzzle', 'hello', 'world!')
hashset.hset('puzzle', 'monkey', 'king!')
hashset.hset('puzzle', 'tomorrow', 'is another day')
hashset.hset('puzzle', 'good', 'bye!')
keys = hashset.hkeys('puzzle')
for key in keys:
ret = input("猜一猜下半句是什麼？ {} -> :".format(key))
value = hashset.hget('puzzle', key)
if ret == value:
print('你太厲害了，這都能猜得到！')
else:
print('哈哈，肯定猜不到得啦：{}->{}'.format(key, value)).

順序語句

def test():
print("* 如果想計算一個長方形的面積")
print("* 那就先定義長寬，例如：x = 10, y=20")
print("* 緊接著，我們計算長方形的面積：s = x * y")
x = 10
y = 20
s = x * y
print("* 現在可以輸出結果了，該長方形的面積是：{}".format(s))
if __name__ == '__main__':
test()

循環語句

 # 使用 for 遍歷打印列表信息
list = [
{

"id": 966024429,
"number": 2341,
"title": "Question about license.",
"body": "I would like to create a [winget](https://github.com/microsoft/winget-cli) package for jq. "
},
{

"id": 962477084,
"number": 2340,
"title": "visibility of wiki pages",
"body": "The visibility of wiki pages to search engines is generally limited; for example, the search result for \"jq Cookbook\" looks like this:"
}
]
# 循環方式1
i = 0
for item in list:
print('')
print("## 第{}條信息".format(i))
print("* id: {}".format(item['id']))
print("* number: {}".format(item['number']))
print("* title: {}".format(item['title']))
print("* body: {}".format(item['body']))
i += 1
#循環方式2
for i in range(len(list)):
item = list[i]
print('')
print("## 第{}條信息".format(i))
print("* id: {}".format(item['id']))
print("* number: {}".format(item['number']))
print("* title: {}".format(item['title']))
print("* body: {}".format(item['body']))
# 循環方式3
for i, item in enumerate(list):
print('')
print("## 第{}條信息".format(i))
print("* id: {}".format(item['id']))
print("* number: {}".format(item['number']))
print("* title: {}".format(item['title']))
print("* body: {}".format(item['body']))
# while循環方式1
i = 0
while i < len(list):
item = list[i]
print('')
print("## 第{}條信息".format(i))
print("* id: {}".format(item['id']))
print("* number: {}".format(item['number']))
print("* title: {}".format(item['title']))
print("* body: {}".format(item['body']))
i += 1
# while循環方式2
i = 0
while True:
item = list[i]
print('')
print("## 第{}條信息".format(i))
print("* id: {}".format(item['id']))
print("* number: {}".format(item['number']))
print("* title: {}".format(item['title']))
print("* body: {}".format(item['body']))
i += 1
if i == len(list):
break

數據類型

if __name__ == '__main__':
# 字符串
print("字符串加法" + "字符串加法")
print("字符串乘法" * 3)
print(",".join(["字符串數組的聚合", "字符串數組的聚合", "字符串數組的聚合"]))
print("雙引號字符串")
print('單引號字符串')
triple = '''三引號字符串'''
print("雙引號字符串裡的單引號: 'hello world!'")
print('單引號字符串裡的雙引號: "hello world!"')
# 列表
array = []
array.append(10)
array.append(20)
array.pop(0)
array.append(30)
array.append(40)
array.pop(0)
# 元數組
tuple = ('紅色', '綠色', '藍色')
for element in tuple:
print(element)
import math
r, g, b = 0.6, 0.8, 0.3
hr, hg, hb = (math.pow(r, 3 / 2), math.pow(g, 4 / 5), math.pow(b, 3 / 2))
print("使用《黑客帝國》綠色濾鏡算法計算後的顏色[0-1]：({}, {}, {})".format(hr, hg, hb))
print("不帶括號的也是元組:")
r, g, b = 0.6, 0.8, 0.3
print("普通顏色[0-1]：({}, {}, {})".format(r, g, b))
# 字典（等同於java中的map）
map = {
}
map['name'] = "monkey"
map['age'] = 25
map['tags'] = "猴子"
map['tags'] = ['程序員', '戶外達人']
map['profile'] = {
'info1': "test", "info2": "test"}
print(map['tags'])
print(map['profile'].get("info3"))

內置類

#內置類的使用，列表元素去重+過濾小於3的元素
# 去重方式
def remove_duplicates(items):
res = list(set(items))
return res
# 過濾方式1
# def filter_element(items, bound):
# res = [item for item in items if item < bound]
# return res
# 過濾方式2
def filter_element(items, bound):
res = [item for item in items if item < bound]
return res
if __name__ == '__main__':
a = [1, 2, 3, 4, 4, 5, 5]
print('輸入: {}'.format(a))
res = remove_duplicates(a)
print('去重後的結果：{}'.format(res))
bound = 3
res = filter_element(a, bound)
print('過濾小於{}的元素:{}'.format(bound, res))

常用內置方法


# 內置方法
if __name__ == '__main__':
# assert abs(-1) == 1
# assert max(10, 100) == 100
# assert min(10, 100) == 10
# assert round(3.5) == 3
# assert pow(2, 4) == 16
# assert float(1) == 1.0
assert 'count' in dir([])
assert hash("a") == hash(chr(97))
assert type({
}) == type({
'a': 1})
assert all([True, True]) == True
assert any([True, False]) == True
assert bool({
}) == False
assert callable(abs) == True
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
assert len(seasons) == 4
shortcut = list(map(lambda s: s[0], seasons))
assert shortcut == ['S', 'S', 'F', 'W']