（一）認識Python
-
Python背景介紹
Python的格言：
Life is short，use python.（人生苦短，我用Python，）
由Guido van Rossum于1989年圣誕節為打發無聊時間，而開發的一個新的腳本解釋程式，第一個公開發行版本于1991年，
至于為什么選中Python作為語言名字，是因為他是一叫Monty Python的喜劇團隊的愛好者，
-
Python的特點
- 優雅、明確、簡單，
- Python是一個
下限特別低（少兒編程），上限特別高的編程語言（人工智能）， - 下限特別低：上手容易，特別適合啥都不懂的小白作為第一門編程語言，通過簡單的代碼就能做出實用的功能，特別容易培養興趣，
- Python
語法簡潔，表達能力強， - Python
代碼量小，維護成本低，編程效率高，標準庫強大，第三方庫非常豐富（比如：selenium、appium、requests等），目前已經成為全世界最廣泛使用的編程語言之一， - 同樣的問題，用不同的語言解決，代碼量差距多，一般情況下Python是Java的1/5，所以說人生苦短，我用Python，多留點時間做點自己喜歡的事情吧，不要浪費太多時間在編碼上面，
- 解釋運行，Python是一種
解釋型語言（腳本語言），和C/C++不同，不是先將源代碼檔案轉化成可執行檔案，再執行，而是直接由Python解釋器一行一行的讀取源代碼，每讀一行就執行一行，但嚴格意義上講，Python算是一種“半編譯，半解釋”型語言，一方面，Python解釋器會按行讀取源代碼檔案，然后會將源代碼轉為供Python解釋器直接執行的“位元組碼”，然后再執行位元組碼， 跨平臺，Python是基于Python的解釋器來進行執行，只要某個作業系統/平臺上能運行Python解釋器，就可以完美的運行Python的源代碼，主流的windows、Linux、Mac等作業系統上都能夠很好地支持Python，可擴展性強，Python可以很容易的呼叫C/C++語言，如果覺得哪里的邏輯性能不能滿足要求，可以使用C/C++重構部分模塊，用Python呼叫，
-
Python的缺點
執行效率低，- 但是，在摩爾定律的作用下，硬體越來越便宜，反而是開發人員的成本越來越高，一些好的編程實踐可以幫助我們寫出比較高性能的代碼，Python解釋器的執行效率也在不斷被優化，
-
Python版本問題
- Python3雖然是Python2的升級版，但是很多語法并不兼容，
- 關于兼容性：
- 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解釋器
-
python官網：https://www.python.org/
下載對應機器的安裝包：
雙擊下載好的Python安裝包：
如果未勾選Add Python 3.7 to PATH，需要手動配置環境變數：
-
計算機->屬性->高級系統設定
-
環境變數->系統變數->Path：
-
將python.exe的路徑和pip命令的路徑配置到Path中：
D:\Python3
D:\Python3\Scripts
-
在cmd命令下輸入python，驗證是否配置成功：
-
-
PyCharm（集成開發工具）
-
PyCharm是一個相當優秀的Python IDE，不過是付費軟體，可以網上找注冊碼，或者淘寶網買一個破解插件，
-
在PyCharm中左下角找到Python Console點擊進入Python控制臺，
-
PyCharm相關使用和設定：
-
控制臺換行顯示：
-
代碼自動對齊快捷鍵：
Ctrl + alt + l -
PyCharm如何設定 “ctrl+滾輪” 實作字體的放大和縮小
https://cnblogs.com/caituotuo/p/14281497.html
-
后續在進行UI自動化測驗、介面自動化測驗的時候會用到pip命令下載第三方庫，因為pip源鏡像是在國外，所以我們在install 第三方庫的時候往往需要加上 -i http://國內鏡像的地址，這里直接將本地電腦的默認鏡像修改成國內地址，這樣就不用手動加了，參考方法：
https://www.cnblogs.com/caituotuo/p/14159989.html
（二）快速入門
??變數賦值
# -*- coding:utf-8 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：2021/1/15 12:56
# 集合（set）是一個無序的不重復元素序列，
# 可以使用大括號 { } 或者 set() 函式創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { }是用來創建一個空字典，
# 創建格式：
a_set = {50, 20, 20}
print(a_set) # {50, 20}
value = https://www.cnblogs.com/caituotuo/p/{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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：2020/12/7 17:36
# Python中使用 # 作為單行注釋，# 后面的內容都是注釋的內容，
a = 1.0 # define a
# 查看系統默認編碼方式
import sys
print(sys.getdefaultencoding())
# 如果要包含中文，默認不是utf-8的話，需要在代碼檔案最開頭的地方注明，
# -*- coding:utf-8 -*-
??運算子
# -*- coding:utf-8 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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]
??Tips：
- .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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 -*-
# 作者：IT小學生蔡坨坨
# 時間：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 == '小高層'
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/249330.html
標籤：Python