入門Python，看完這篇就行了！

轉載請註明出處❤️

作者：測試蔡坨坨

原文連結：caituotuo.top/3bbc3146.html

---

你好，我是測試蔡坨坨。

眾所周知，Python語法簡潔、功能強大，通過簡單的程式碼就能實現很多實用、有趣的功能，因為它擁有豐富的標準模組和第三方庫，因此也成為自動化測試的熱門語言，當然除了Python，其他程式語言也能做自動化，至於自動化測試選擇什麼程式語言，可參考往期文章「做自動化測試選擇 Python 還是 Java？」。

要想使用Python語言編寫指令碼或開發平臺進行自動化測試，首先需要學習Python基礎語法，通過本篇文章，帶你快速入門Python並掌握Python基礎語法。

Python簡介

背景介紹

Python的格言：Life is short，use python. 即「人生苦短，我用Python。」

由Guido van Rossum於1989年聖誕節為打發無聊的時間，而開發的一個新的指令碼解釋程式，第一個公開發行版本於1991年。

至於為什麼選中Python作為語言名字，是因為他是一個叫Monty Python的喜劇團隊愛好者。

特點

優勢

• 優雅、明確、簡單。
• Python是一個下限特別低（少兒程式設計），上限特別高的程式語言（人工智慧）。
• 上手容易，特別適合沒有程式設計經驗的小白作為第一門程式語言，特別容易培養興趣。
• 語法簡潔，表達能力強，通過簡單程式碼就能實現很多實用的功能。
• 程式碼量小，維護成本低，程式設計效率高，標準庫強大，第三方庫非常豐富（比如自動化測試會用到的Selenium、Appium、Requests等），目前已經成為全世界最廣泛使用的程式語言之一。
• 同樣的問題，用不同的語言解決，程式碼量差距多，一般情況下Python是Java的1/5，Java需要十行，Python可能只需要兩行，所以說人生苦短，我用Python，多留點時間做點自己喜歡的事情吧，不要浪費太多時間在編碼上面。
• 解釋執行。Python是一種直譯語言（指令碼語言）。和C/C++不同，不是先將原始碼檔案轉化成可執行檔案，再執行，而是直接由Python直譯器一行一行的讀取原始碼，每讀一行就執行一行。但嚴格意義上講，Python算是一種「半編譯，半解釋」型語言。一方面，Python直譯器會按行讀取原始碼檔案，然後會將原始碼轉為供Python直譯器直接執行的「位元組碼」，然後再執行位元組碼。
• 跨平臺。Python是基於Python的直譯器來進行執行。只要某個作業系統/平臺上能執行Python直譯器，就可以完美的執行Python的原始碼。主流的Windows、Linux、Mac等作業系統上都能夠很好地支援Python。
• 可延伸性強。Python可以很容易的呼叫C/C++語言。如果覺得哪裡的邏輯效能不能滿足要求，可以使用C/C++重構部分模組，用Python呼叫。

劣勢

執行效率較低，因為Python是一種直譯語言，所以程式執行效率比較低，依賴直譯器。

什麼是編譯型語言和直譯語言？

• 編譯型語言：

  程式在執行之前需要一個專門的編譯過程，把程式編譯成為機器語言的檔案，執行時不需要重新翻譯，直接使用編譯的結果就行了。

  程式執行效率高，依賴編譯器，跨平臺性差些。如C、C++、Delphi等。

• 直譯語言：

  程式不需要編譯，程式在執行時才翻譯成機器語言，每執行一次都要翻譯一次。

  程式執行效率比較低，依賴直譯器，跨平臺性好。如Python、JavaScript、Perl、Shell等。

但是，在摩爾定律的作用下，硬體越來越便宜，反而是開發人員的成本越來越高，一些好的程式設計實踐可以幫助我們寫出比較高效能的程式碼，同時，Python直譯器的執行效率也在不斷被優化。

Python版本

Python3雖然是Python2的升級版，但是很多語法並不相容，因此現在不建議學習Python2，直接學習Python3即可。

關於相容性：

• C++能非常好的相容C語言（C語言寫的程式碼可以直接使用C++編譯器進行編譯），但是也意味著C++揹負著很多C語言的歷史包袱。
• 但是Python 3 和Python 2 很多地方不相容（Python 2 寫的程式碼，不能很順利的在Python 3 的直譯器上執行）。
• 這樣做是好還是壞，不便評說，還是要看幾年之後的最終結果是好是壞，才能蓋棺定論。這樣意味著很多已經用Python 2 寫好的程式碼不會很順利的升級到Python 3.。
• 但是這樣也意味著Python 3 可以不用揹負歷史包袱，大刀闊斧的把一些不合理的地方修改掉。
• 官方的說法是，Python 2 最多維護到2020年便停止更新。

Python直譯器和PyCharm編輯器

Python直譯器的安裝

1. 在Python官網下載對應機器的安裝包：https://www.python.org

   

2. 雙擊下載好的Python安裝包

   

3. 如果未勾選Add Python 3.7 to PATH，需要手動設定環境變數（如果已勾選可跳過這一步，直接到第4步）

   • 計算機->屬性->高階系統設定：
   

   • 環境變數->系統變數->Path：

     

   • 將python.exe的路徑和pip命令的路徑設定到Path中：

     例如：D:\Python3

     

     例如：D:\Python3\Scripts

     

4. 在cmd命令下輸入python，驗證是否設定成功

   

PyCharm整合開發工具

PyCharm是一種Python IDE（Integrated Development Environment，整合式開發環境），帶有一整套可以幫助使用者在使用Python語言開發時提高其效率的工具，比如偵錯、語法高亮、專案管理、程式碼跳轉、智慧提示、自動完成、單元測試、版本控制。此外，該IDE提供了一些高階功能，以用於支援Django框架下的專業Web開發。

Python基礎語法

變數賦值

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/14 20:24

# 變數和賦值
# 動態型別 type(變數)
# Python中的變數不需要宣告，直接定義即可使用。會在初始化的時候決定變數的「型別」
# 使用 = 來進行初始化和賦值操作
counter = 0
miles = 1000.00
name = "poo-poo-cai"
kilometers = 1.666 * miles
print(counter, miles, name, kilometers)

# Python中也支援增量賦值
n = 10
n = n * 10  # 100
n *= 10  # 1000
print(n)

# 但是Python中不支援 ++/-- 這樣的自增、自減操作，只能寫成：
n += 1  # n = n + 1 == 1001
print(n)

# 執行結果：
# 0 1000.0 poo-poo-cai 1666.0
# 1000
# 1001

標準資料型別

Python3中有六個標準的資料型別：數位、字串、列表、元組、字典、集合。

Number（數位）

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 13:39

# Number（數位）
# Python沒有int，float這樣的關鍵字，但是實際上資料的型別是區分int，float這樣的型別的；
# Python3支援int（長整型）、float、bool、complex（複數）；
# 內建函數type()可以用來查詢變數所指的物件型別。

a = 1
print(type(a))
b = 0.1
print(type(b))
c = True
print(type(c))
d = 10 + 5j
print(type(d))

# 此外，還可以用insinstance來判斷
num = 222
result = isinstance(num, int)
print(result)

# 布林值表示真（True）和假（False）
# 布林型別的變數，也是一種特殊的整數型別，在和整數進行運算時，True被當做1，False被當作0
b1 = True
sum = b1 + 2
print(sum)  # 3

String（字串）

字串基礎應用：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 13:54

# Python中可以使用單引號（'）、雙引號（"）、三引號（'''/"""）來表示字串;
str1 = 'caituotuo'
str2 = "caituotuo"
str3 = """caituotuo"""
str4 = '''caituotuo'''
print(str1, str2, str3, str4)  # caituotuo caituotuo caituotuo caituotuo

# 字串中含有引號
str5 = 'I am "caituotuo"'
print(str5)  # I am "caituotuo"

# 同時使用反斜槓 \ 跳脫特殊字元，如：換行符 \n
name = 'My name is \n cai.'
print(name)
# 執行結果：
# My name is
#  cai.

# \ 本身需要 \\ 這樣的方式來表示
str6 = '\\index\\'
print(str6)  # \index

# 使用索引操作符[]或者切片操作符[:]來獲取子字串。（切片操作是一個前閉後開區間）
# 字串的索引規則：第一個字元索引是0，最後一個字元索引是-1。
str7 = 'hello world!'
print(str7[0])  # h
print(str7[-1])  # !
print(str7[1:3])  # el
print(str7[:3])  # hel
print(str7[3:])  # lo world!
print(str7[:])  # hello world!
print(str7[::2])  # hlowrd
print(str7[::-1])  # !dlrow olleh

# +用於字串連線運算；* 表示賦值當前字串，與之結合的數位為複製的次數。
str8 = 'tester'
str9 = 'cai'
print(str8 + str9)  # testercai
print(str8 * 1)  # tester
print(str8 * 0)  # 空
print(str8 * 3)  # testertestertester
print(str8 * -1)  # 空

# Python沒有「字元型別」這樣的概念，單個字也是字串。
str10 = 'tester'
print(type(str10[0]))  # <class 'str'>

# 格式化字串：%s； 格式化整型：%d
name = 'caituotuo'
num = 1
print('尊敬的%s使用者，您抽到的碼號是%d' % (name, num))  # 尊敬的caituotuo使用者，您抽到的碼號是1

# 內建函數len獲取字串的長度
str11 = 'hello world!'
print(len(str11))  # 12

# 原始字串（raw strings）
print(r'/n hello /n world!')  # /n hello /n world!

字串合併和拆分：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 15:25

# 字串合併和拆分
# 將列表中的字串合併成一個字串
b = "-"
a = ["wel", "come", "to", "beijing"]
print(b.join(a))  # wel-come-to-beijing

# 按空格將字串拆分成列表
# 應用：介面自動化測時候，批次獲取csv檔案中的username，password
c = "he ll o wor l d !"
print(c.split(" "))  # ['he', 'll', 'o', 'wor', 'l', 'd', '!']

字串常用函數：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 15:33

# 字串常用函數
# 判定字串的開頭結尾，返回布林值
a = "hello world. my name is poo poo cai"
print(a.startswith("he"))
print(a.endswith("cai"))
print(a.startswith("cai"))
# 執行結果：
# True
# True
# False

# strip()去除字串開頭結尾的空格/換行符
b = "   welcome to my house \n  "
print(b)
print(b.strip(), end="---")
# 執行結果：
#    welcome to my house
#
# welcome to my house---

# 查詢子串
c = "hello world!"
print("\n")
print(c.find("wor"))  # 6 返回下標，下標從0開始
print(c[6])  # w
print(c.find("123"))  # -1 表示沒有找到

# 替換子串（字串是不可變物件，只能生成新字串）
d = "welcome to my house!"
print(d.replace("house", "home"))  # welcome to my home!
print(d)  # welcome to my house!

# 判定字串是字母還是數位
# str.isalpha()如果字串至少有一個字元並且所有字元都是字母，則返回True
# str.isdigit()如果字串只包含數位則返回True，否則返回False
e = "123456"
f = "abc"
g = "123abc"
print(e.isalpha())
print(e.isdigit())
print(f.isdigit(), f.isalpha(), g.isdigit(), g.isalpha())
# 執行結果：
# False
# True
# False True False False

List（列表）/Tuple（元組）

列表和元組基礎應用：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/7 18:13

# 列表和元組類似於C語言中的陣列，使用[]來表示列表，用()來表示元組。
# 物件有序排列，通過索引讀取，下標從0開始，最後一個下標為-1。
# 能儲存任意數量、任意型別的Python物件，可以是數位、字串、元祖、其他列表、字典。
a_list = [1, 3.666, [1, 2, 3], {"name": 20, 20: 10}, 4, (1, 2, 3, 4), "string", True]
print(a_list, type(a_list))
print(a_list[0], a_list[-1])

a_tuple = (1, 2, 3, 4)
print(a_tuple, type(a_tuple))

# 執行結果：
# [1, 3.666, [1, 2, 3], {'name': 20, 20: 10}, 4, (1, 2, 3, 4), 'string', True] <class 'list'>
# 1 True
# (1, 2, 3, 4) <class 'tuple'>

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 11:26

# 可以使用[:]切片操作得到列表或元組的子集。這個動作和字串操作是一樣的。
a_list = [1, 3.666, [1, 2, 3], {"name": 20, 20: 10}, 4, (1, 2, 3, 4), "string", True]
print(a_list[0:2])  # 從0索引開始，取兩個 [1, 3.666]
print(a_list[:])  # [1, 3.666, [1, 2, 3], {'name': 20, 20: 10}, 4, (1, 2, 3, 4), 'string', True]
print(a_list[::-1])  # 反轉 [True, 'string', (1, 2, 3, 4), 4, {'name': 20, 20: 10}, [1, 2, 3], 3.666, 1]

a_tuple = (1, 2, 3, 4)
# 列表和元組唯一的區別是：列表中的元素可以修改，但是元組中的元素不能修改。
a_list[0] = 0
print(a_list)  # [0, 3.666, ...]

# a_tuple[0] = 0  # TypeError: 'tuple' object does not support item assignment

# 理解元組的不可變
# 元組的不可變指的是元組元素的id不可變。就是說一個元組包含了幾個物件，
# 然後不可以給這幾個元組再新增或者刪除其中的某個物件，
# 也不可以將某個物件改成其他的物件。
# 但是，如果元組中的某個元素是可變物件（比如列表或字典），那麼仍然可以修改。
a_tuple02 = (1, 2, [1, 2, 3, 4])
print(a_tuple02)  # (1, 2, [1, 2, 3, 4])
a_tuple02[2][0] = 0
print(a_tuple02)  # (1, 2, [0, 2, 3, 4])

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 12:32

# 排序
# sorted()排序：這是一個非常有用的函數，返回一個有序的序列（輸入引數的副本）
a_list = [1, 5, 2, 3, 80, 55, 66]
a_list02 = sorted(a_list)  # 不會破壞原本的列表，而是自己生成一個排序後的新列表
print(a_list)  # [1, 5, 2, 3, 80, 55, 66]
print(a_list02)  # [1, 2, 3, 5, 55, 66, 80]

# sorted()支援自定義排序規則
# 逆序排序
print(sorted(a_list, reverse=True))  # [80, 66, 55, 5, 3, 2, 1]
# 按字串的長度排序
a_list03 = ["abc", "name", "u"]
print(sorted(a_list03, key=len))  # ['u', 'abc', 'name']

# sort()排序，會改變列表本身
a_list04 = [1, 5, 2, 6]
print(a_list04)  # [1, 5, 2, 6]
a_list04.sort()
print(a_list04)  # [1, 2, 5, 6]

列表常用操作：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 16:12

# append()：追加元素
a_list = [1, 2]
a_list.append(3)
print(a_list)  # [1, 2, 3]

# 刪除指定下標元素
a_list02 = [6, 5, 4, 3, 2, 1]
del a_list02[0]
print(a_list02)  # [5, 4, 3, 2, 1]

# remove()按值刪除元素
a_list02.remove(3)
print(a_list02)  # [5, 4, 2, 1]
# a_list02.remove("1")  # ValueError: list.remove(x): x not in list 刪除不存在的值會提示not in

# 列表比較操作：==/!= 判定所有元素都相等，則認為列表相等。
# < > <= >= 則是兩個列表從第一個元素開始依次比較，直到某一方勝出。
a = ["abc", 1233]
b = ["xyz", 789]
c = ["abc", 823]
print(a < b)
print(b < c)
print(b > c and a == c)

# 執行結果
# True
# False
# False

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 16:58

# 刪除列表中指定的值（全部刪除）
# 刪除列表中所有的2
a_list = [1, 2, 2, 3, 5, 2, 2, 8, 9, 2]
n = len(a_list)
new_list = []
for i in range(0, n):
    if a_list[i] == 2:
        pass
    else:
        new_list.append(a_list[i])
print(a_list)
print(new_list)
# 執行結果：
# [1, 2, 2, 3, 5, 2, 2, 8, 9, 2]
# [1, 3, 5, 8, 9]

列表和元組的區別？（面試題）

①列表和元組唯一的區別是：列表中的元素可以修改，但是元組中的元素不能修改。

②理解元組的不可變(子元素不可改，若子元素是一個列表那麼列表裡面的內容可以改)
# 元組的不可變指的是元組元素的id不可變。就是說一個元組包含了幾個物件，
# 然後不可以給這幾個元組再新增或者刪除其中的某個物件，
# 也不可以將某個物件改成其他的物件。
# 但是，如果元組中的某個元素是可變物件（比如列表或字典），那麼仍然可以修改。

Set（集合）

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 12:56

# 集合（set）是一個無序的不重複元素序列。
# 可以使用大括號 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，因為 { }是用來建立一個空字典。

# 建立格式：
a_set = {50, 20, 20}
print(a_set)  # {50, 20}
value = {50, 20, 20}
a_set02 = set(value)
print(a_set02)  # {50, 20}

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # {'apple', 'orange', 'banana', 'pear'}這裡演示的是去重功能

print('orange' in basket)  # True 快速判斷元素是否在集合內
print('crabgrass' in basket)  # False

# 下面展示兩個集合間的運算.
a = set('name')
b = set('username')
print(a)  # {'n', 'a', 'm', 'e'}
print(b)  # {'m', 's', 'r', 'n', 'a', 'u', 'e'}
print(a - b)  # set()空集合 集合a中包含而集合b中不包含的元素

print(a | b)  # {'m', 'a', 's', 'u', 'r', 'e', 'n'} 集合a或b中包含的所有元素

print(a & b)  # {'m', 'a', 'e', 'n'}集合a和b中都包含了的元素

print(a ^ b)  # 'r', 's', 'u'} 不同時包含於a和b的元素

Dictionary（字典）

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 14:59

# 字典是Python中的對映資料型別，儲存鍵值對（key:value），無序（3.7有優化，相對有序，按輸入的順序顯示）
# 幾乎所有型別的Python物件都可以用作鍵。不過一般是數位和字串最常用，且key不能重複。
# 使用{}表示字典。

a_dic = {'name': 'poo-poo-cai', 'age': 21}  # 建立字典
print(type(a_dic))  # <class 'dict'>
print(a_dic["name"])  # poo-poo-cai 取字典中的元素
a_dic['name'] = "蔡坨坨"  # 修改值
print(a_dic["name"])  # 蔡坨坨
a_dic["address"] = "福建"  # 插入新的鍵值對
print(a_dic["address"])  # 福建

# 刪除某一個鍵值對，del
del a_dic['address']
print(a_dic)  # {'name': '蔡坨坨', 'age': 21}

# 使用clear()方法，清空整個字典中所有的鍵值對
a_dic02 = {"username": "007", 7: 8}
print(a_dic02)  # {'username': '007', 7: 8}
a_dic02.clear()
print(a_dic02)  # {}

# 使用pop()方法，刪除鍵值對同時獲取到值
a_dic03 = {"age": 20, "habits": "play computer"}
print(a_dic03)  # {'age': 20, 'habits': 'play computer'}
habits = a_dic03.pop("habits")
print(a_dic03)  # {'age': 20}
print(habits)  # play computer
# 注意：字典也是可變物件，但是鍵值對的key是不能修改的。

# keys()：返回一個列表，包含字典的所有key
# values()：返回一個列表，包含字典的所有value
# items()：返回一個列表，每一個元素都是一個元組，包含了key和value
a_dic04 = {'name': 'poo-poo-cai', 'age': 21, "address": "成都"}
print(a_dic04.keys())
print(a_dic04.values())
print(a_dic04.items())
# 執行結果：
# dict_keys(['name', 'age', 'address'])
# dict_values(['poo-poo-cai', 21, '成都'])
# dict_items([('name', 'poo-poo-cai'), ('age', 21), ('address', '成都')])

輸入輸出函數

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/7 17:26

# 輸入和輸出
# print函數，將結果輸出到標準輸出（顯示屏）上
# input函數，從標準輸入中獲取使用者輸入
name = input('請輸入你的姓名：')
print('你的姓名是：', name)
# 執行結果：
# 請輸入你的姓名：cai
# 你的姓名是： cai

# input返回的結果只是一個字串，如果需要獲取一個數位，需要使用int函數把字串轉換成數位。
num = input('please input a number:')
print('type:', type(num), end="---")  # type: <class 'str'>
num2 = int(num)
print('your number is:', num2, 'type:', type(num2))  # your number is: 20 type: <class 'int'>

註釋 & 編碼

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/7 17:36

# Python中使用 # 作為單行註釋，# 後面的內容都是註釋的內容。
a = 1.0  # define a

# 檢視系統預設編碼方式
import sys

print(sys.getdefaultencoding())

# 如果要包含中文，預設不是utf-8的話，需要在程式碼檔案最開頭的地方註明。
# -*- coding:utf-8 -*-

運運算元

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/7 17:47

# 操作符
# Python中支援 + - * / % （加、減、乘、除、取餘）這樣的操作符
a = 1
b = 2
print(a + b)  # 3
print(a - b)  # -1
print(a * b)  # 2
print(a / b)  # 0.5
print(a % b)  # 1

# // 是地板除，無論運算元型別如何，都會對結果進行取地板運算（向下取整）
print(a // b)  # 0

# ** 表示乘方運算
c = 3
print(c ** 3)  # 27

# 比較運運算元，>、<、==、>=、<=、!= ，返回一個布林值。
print(2 < 3)  # True
print(2 > 3)  # False
print(2 == 3)  # False
print(2 >= 3)  # False
print(2 <= 3)  # True
print(2 != 3)  # True

# 邏輯運運算元and、or、not

# 字串之間可以使用== 或者 ！= 來判斷字串的內容是否相同。
'test' == 'tester'  # False
'test' != 'tester'  # True

# 字串之間也可以比較大小，這個大小的結果取決於字串的字典序
# 從小到大 0-9 A-Z a-z
'a' < 'bb'  # True

物件和變數參照

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 14:51

# 理解除參照
# Python中可以用id這個內建函數,檢視變數的地址
# 物件的三要素；1.type 2.id 3.value
a = 100
print(type(a), id(a), a)
a = 200
print(type(a), id(a), a)
b = a
print(type(b), id(b), b)
b = 300
print(type(b), id(b), b)
# 執行結果：
# <class 'int'> 140708135988976 100
# <class 'int'> 140708135992176 200
# <class 'int'> 140708135992176 200
# <class 'int'> 2225255404560 300

# 給a重新賦值成200，相當於新建立了一個200這樣的物件，然後將變數名a重新系結到200這個物件上。
# 將a賦值給b，相當於又建立了一個變數名為b的物件，並將b這個名字和200這個物件繫結到一起。
# 再次修改b的值，可以看出其實是又建立了一個300的物件，將b繫結到300這個物件上。
# 像建立的a，b這樣的變數名，其實只是一個物件的別名。或者叫做變數的「參照」。

條件判斷語句

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 15:07

# if語句
if 2 > 3:
    print('dei')  # dei

# if else
if 2 > 3:
    print('dei')
else:
    print('bu dei')  # bu dei

# 非0 || True
if 1:
    print('非0')  # 非0

if '':
    print('非0')
else:
    print('空字串')  # 空字串

if []:
    print('非0')
else:
    print('空列表')  # 空列表

if {}:
    print('非0')
else:
    print('空字典')  # 空字典

x = int(input("please input x's value:"))
y = int(input("please input x's value:"))
if x > 0:
    if y > 0:
        print('x and y >０')
    else:
        print('y <= 0')
else:
    print('x <= 0')

迴圈語句

while迴圈語句：

# while迴圈
n = 1
while n < 4:
    print('這是我回圈的第%d次' % n)
    n += 1

for迴圈語句：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 15:31

# for迴圈
# 迴圈字串
name = 'caituotuo'
for n in name:
    print(n)

# 迴圈列表
lists = [1, 1.5, True, 5 + 10j, 'cai', (1, 2, 3)]
for list in lists:
    print(list)

dicts = {'id': 666, 'name': 'caituotuo', 'sex': 'boy'}
for dict in dicts:
    print(dict)
for k in dicts.keys():
    print(k)
for v in dicts.values():
    print(v, end=' ')  # 666 caituotuo boy
print('\n')
for k, v in dicts.items():
    print(k, end=' ')
    print(v, end=' ')  # id 666 name caituotuo sex boy

print('\n')
for n in range(1, 5):  # 左閉右開
    print(n)
# 1
# 2
# 3
# 4

常用內建函數/模組（abs、divmod、round、break、continue、pass）：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 15:50

# continue、break、pass
# 查詢[1,100)第一個3的倍數
for n in range(1, 100):
    if n % 3 == 0:
        print(n)
        break # 跳出當前迴圈

for n in range(1, 100):
    if n % 3 != 0:
        continue  # 終止一次迴圈
    print(n)
    break

if 3 == 3:
    pass # 空語句，用來佔位

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 17:43

# abs：求一個數的絕對值
a = -20
print(abs(a))  # 20

# divmod：返回一個元組，同時計算商和餘數
a, b = divmod(10, 3)
print(a, b)  # 3 1

# round：對浮點數進行四捨五入
# round有兩個引數，第一個是要進行運算的值，第二個是保留小數點後多少位。
r = round(1.66666, 2)
print(r)  # 1.67

使用for生成列表：

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2021/1/15 17:36

# 生成列表
# 使用for迴圈將生成的值存放到一個列表中
# 生成[0,4)的數位的平方列表
s = [x ** 2 for x in range(4)]
print(s)  # [0, 1, 4, 9]

# 還可以搭配使用if語句
# 獲取[0,8)區間中的所有奇數
e = [x for x in range(8) if x % 2 == 1]
print(e)  # [1, 3, 5, 7]

自定義函數 & 不定長引數

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 16:16

# 函數
# 一些可以被重複使用的程式碼，可以提取出來放到函數中
# Python使用def來定義一個函數，使用return來返回結果
def add(num=3):
    num = num + 1
    return num


# 呼叫函數
num = add()
print(num)
num = add(5)
print(num)


# 理解「形參」和「實參」：形參相當於數學中的未知數這樣的概念。實參就是給未知數確定具體的數值。
# Python中相同名字的函數，後面的會覆蓋前面的。
# Python支援預設引數。函數的引數可以具備預設值。
def fun(x=1):
    y = x ** 3
    z = y + x
    return x, y, z


# Python解包（unpack）語法，函數返回多個值，但是我只關注z，不想關注x、y，可以使用_作為預留位置。
_, _, z = fun(2)
print(z)


# 我們實現一個列印紀錄檔的函數。這個函數第一個引數是一條紀錄檔的字首，後續可能有n個引數。
# n個引數之間使用\t（tab鍵）分割。join()方法用於將序列中的元素以指定的字元連線成一個新的字串。
def log(prefix, *data):
    print(prefix + "\t".join(data))


# 呼叫函數
log('[Notice]', "hello", "world")  # [Notice]hello	world


# 不定長引數
def bdc(*canshu):
    print(canshu)


bdc(1, 1.5, True, 'hello')  # (1, 1.5, True, 'hello')


# 通過在引數名前加兩個星號，星號後面的部分表示傳入的引數是一個字典。
# 這時候呼叫函數就可以按照鍵值對的方式傳參。
# 成對傳參
def chengdu(**kv):
    print(kv)


chengdu(name='cai', age=21)  # {'name': 'cai', 'age': 21}

作用域 & 檔案字串

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/6 16:31

# 作用域
# Python中，def、class會改變變數的作用域
# if else elif while for try 不會改變變數的作用域
# global

for i in range(3):
    print(i)
print(i)  # 即使出了for迴圈語句塊，變數i仍然存取到i變數


def fun(**kv):
    """全域性變數"""
    global new_kv
    new_kv = kv
    return kv


# 0
# 1
# 2
# 2

kv = fun(name='cai', age=21)
print(kv)
print(new_kv)


# {'name': 'cai', 'age': 21}
# {'name': 'cai', 'age': 21}

# 檔案字串
# 寫註釋對於提升程式的可讀性有很大的幫助，前面我們介紹了 # 來表示單行註釋。
# 對於多行註釋。我們可以使用三引號('''/""")在函數/類開始位置表示。這個東西也被稱為檔案字串。


def fun():
    """檔案字串"""


# 使用物件的doc屬性就能看到這個幫助檔案
print(fun.__doc__)  # 檔案字串
# 或者內建函數help也可以做到相同的效果
help(fun)
# Help on function fun in module __main__:
#
# fun()
#     檔案字串

# 注意：檔案字串一定要放在函數或者類的開始位置，否者上述兩個函數無法來存取。

檔案操作

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/9 21:25

# 檔案操作
# 使用內建函數 open() 開啟一個檔案
# handle = open('file_name','r')
#
# 第一個引數file_name是檔案的名字，可以是一個絕對路徑，也可以是一個相對路徑。
# 第二個引數是檔案的開啟方式，選項有：
# 'r':唯讀
# 'w':覆蓋寫
# 'a':追加寫

# 方式一（使用相對路徑）：
handle = open('test.txt', 'r', encoding='utf-8')  # 指定編碼格式encoding，預設是gbk
# 方式二（使用絕對路徑）：
# handle = open(r'D:\Desktop\Python_Study\Python_Study\bcbx_test\檔案操作\test.txt', 'r', encoding='utf-8')

# handle是一個檔案控制程式碼，是一個可迭代的物件，可以直接使用for迴圈按行讀取檔案內容
for line in handle:
    print(line.strip())  # strip()去除空格和換行
# handle使用完畢，需要close掉，否則會引起資源洩露（一個程序能開啟的控制程式碼數目是有限的）
handle.close()

print(handle.read(3))
# 讀取一行，前面如果讀過則不會重複讀取，自動從未讀取部分往下讀
print(handle.readline())
# 讀取所有行，將結果儲存在result中，第一行的索引為0，以此類推
result = handle.readlines()
print(result[0].strip())
handle.close()

異常

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/9 21:52

# 在我們前面經常提到「程式執行出錯」這樣的概念。實際上，這是Python直譯器丟擲了一個異常。
list01 = [1, 2, 3]
try:
    print(list01[2])  # IndexError: list index out of range，try except捕獲異常，後面程式正常執行

    handle = open(r'test02.txt', 'r', encoding='utf-8')  # No such file or directory: 'test02.txt'
except Exception as error:
    # except IndexError:
    print(error)
    print(type(error))
    if str(error) == 'list index out of range':
        print('IndexError')
    elif str(error) == "[Errno 2] No such file or directory: 'test02.txt'":
        print('FileNotFoundError')

# print(list01[3])  # 沒有拋異常，後面的程式無法執行

print('成功捕獲異常')

模組

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/9 22:13

# 模組
# 當程式碼量比較大的時候，我們最好把程式碼拆分成一些有組織的程式碼片段。
# 每個程式碼片段裡面包含一組邏輯上有關聯的函數或類。
# 每一個片段裡放在一個獨立的檔案中。這樣的片段就成為模組（module）
# 使用import可以在一個Python檔案中引入其他的模組。
# 既然模組也是一個物件，那麼可以給這個物件賦值（相當於定義別名）
# 使用import 模組 as 別名


def bubble_sort(ls):
    # 檢測列表的資料個數
    n = len(ls)  # n=6
    # i為資料排序的輪次
    for i in range(n - 1):
        # j為列表資料的下標
        for j in range(0, n - i - 1):
            # 比較相鄰兩個數的大小
            if ls[j] > ls[j + 1]:
                # 相鄰兩個數交換位置
                ls[j], ls[j + 1] = ls[j + 1], ls[j]
    # 輸出排序後的資料列表
    print(ls)

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/9 22:13

from c_bcbx.Python基礎.模組.test01 import bubble_sort as b

b([2, 3, 5, 22, 2, 1, 99, 0, 2])  # [0, 1, 2, 2, 2, 3, 5, 22, 99]

注意事項：

• .py檔案的命名可以使用數位、字母、下劃線。
• 當檔案作為主程式執行時，檔名開頭可以隨意，以數位，字母，下劃線開始都可以，如：666_cai.py，cai.py，_cai666.py，cai1.py，_666cai.py；
• 但是，當.py檔案作為模組被匯入到其他檔案中呼叫時，則作為模組的.py檔案不能以數位開頭命名，可以用下劃線和字母開頭，如：cai.py，_cai666.py，cai666.py，_666cai.py，若命名為666cai.py則會出錯。
• 同理，若作為模組的.py檔案位於某個包下，則這個包的命名也不能以數位開頭。

包

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/12 22:23

# 包（Package）
# 當我們程式碼量進一步變大時，光拆分成多個檔案已經不足以滿足需求，
# 還需要能按照一定的目錄結構層次化的組織這些模組，同時包也可以解決模組之間的名字衝突問題。

# 例如，我們可以以下面的方式組織程式碼結構：
# test.py
# bao_package/
#       add.py
#       divide.py
#       __init__.py
# 在bao_package目錄中增加一個__init__.py檔案，bao_package這個目錄就成了包。
# 可以在test.py中import bao_package中的模組

from c_bcbx.Python基礎.包.bao_package import add, divide

# 呼叫add.py檔案
add
# 呼叫divide.py檔案
divide

# __init__.py 是在包載入的時候會進行執行，負責一些包的初始化操作，一般是空檔案即可。

類

# -*- coding:utf-8 -*-
# 作者：測試蔡坨坨
# 時間：2020/12/11 21:11

# 類

# 物件導向：封裝

# 物件導向-oop是一種程式設計思想，萬物皆物件，物件導向提高了程式設計效率，重複利用性高，
# 一個物件包含了資料和運算元據的函數。

# 抽象
# 抽象是指對現實世界問題和實體的本質表現、行為、特徵進行建模，抽象的反義詞是具體。
# 抽象的本質，是抓住我們重點關注的主體，而忽略一些我們不需要關注的細節。
# 寫程式也一樣，我們不可能把一個現實事物所有的資訊都在程式中表示出來，而是隻表示我們需要用到的。

# 類和範例
# 類是施工圖紙。裡面有房子的重要資訊（比如：戶型、面積、朝向、層高等）
# 範例是造好的房子，房子造好了，才能住進去。
# 通過同一張圖紙可以建造出N個相同格局的房子，那麼N個範例就都是屬於同一個類。


# 建立一個新的類
class Tester:
    # 類的特殊方法,__init__方法裡面定義的引數在範例化類的時候必須要傳參
    def __init__(self, house_type):
        self.house_type = house_type

    developer = 'SOHO'

    def show_price(self, s):
        if self.house_type == '洋房':
            print('單價30000/每平米')
            print('整套的價格是：%d' % (30000 * s))
        elif self.house_type == '小高層':
            print('單價25000/每平米')
        else:
            print('單價20000/每平米')


# 範例化類
cai = Tester('洋房')
cai.show_price(100)
cai.house_type == '小高層'