人生苦短,我用Python

IT小學生蔡坨坨 發表於 2021-01-15

(一)認識Python

  1. Python背景介紹

    Python的格言:

    Life is short,use python.(人生苦短,我用Python。)

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

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

  2. 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呼叫。
  3. Python的缺點

    • 執行效率低
    • 但是,在摩爾定律的作用下,硬體越來越便宜,反而是開發人員的成本越來越高,一些好的程式設計實踐可以幫助我們寫出比較高效能的程式碼,Python直譯器的執行效率也在不斷被優化。
  4. 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年便停止更新。
  5. 認識Python直譯器和PyCharm工具

    • 安裝Python直譯器

      image-20201216111844837

      雙擊下載好的Python安裝包:

      image-20201216112229015

      如果未勾選Add Python 3.7 to PATH,需要手動配置環境變數:

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

        image-20201216112516264
      • 環境變數->系統變數->Path:

        image-20201216112746114
      • 將python.exe的路徑和pip命令的路徑配置到Path中:

        D:\Python3

        image-20201216113035996

        D:\Python3\Scripts

        image-20201216113112247
      • 在cmd命令下輸入python,驗證是否配置成功:

        image-20201216113413899

    • PyCharm(整合開發工具)

      image-20210114024803576

    • PyCharm是一個相當優秀的Python IDE。不過是付費軟體,可以網上找註冊碼,或者淘寶網買一個破解外掛。

    • 在PyCharm中左下角找到Python Console點選進入Python控制檯。

PyCharm相關使用和設定:

(二)快速入門

👶變數賦值
# -*- 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 = {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 >0')
    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 == '小高層'