第二階段：python基礎

原創 DedicationYu 2020-06-21 22:05

1.2python基礎

1.2.1python簡介

1.2.1.1編譯型語言和解釋性語言

  1. 編譯器：計算機只能識別機器語言，而編程語言有很多種，編程語言要想被機器所識別就必須要有一個工具將編程語言轉化爲機器語言，這個工具就是編譯器，編譯器翻譯的方式有兩種，一種是編譯，一種是解釋，兩種方式之間的區別在於翻譯時間點的不同
  2. 解釋器：當編譯器以解釋的方式運行時，該編譯器就被稱爲解釋器，而這種使用解釋器解釋的語言則被稱爲解釋型語言
  3. 編譯型語言和解釋型語言的工作原理：
    • 編譯型語言：一次性執行所有代碼，編譯型語言不可以跨平臺，即在windows上編譯好的程序不可以在其它操作系統上執行
    • 解釋性語言：一行一行的執行代碼，解釋性語言可以跨平臺
    • 比較：編譯型語言執行的速度比解釋型語言更快

1.2.1.2python的特點

  1. python是完全面向對象的語言：面向對象是一種思維方式，要解決一個問題，有兩種解決問題的方式，一種是自己一件一件的完成，另一種是找一個會做這個問題的人來幫你解決這個問題，這裏的對象就是那個人；這個對象封裝了一個問題的解決方案，你只需調用這個對象就可以解決這個問題
  2. python擁有一個強大的標準庫，這些庫中封裝了很多解決問題的對象，用戶可以使用這些庫來解決不同的問題
  3. python社區提供了大量的第三方模塊，這些模塊是由當今的一些python愛好者開源出來的，這些模塊也包含大量的對象且這些模塊很多都涉及當前的許多前端領域：類似人工智能和大數據，用戶可以利用這些模塊中的對象來簡化解決問題的方法
  4. python語言具有可拓展性：在使用python編寫代碼的過程中如果希望某一段關鍵代碼運行的更快或者某些算法不公開，可以把這些代碼用c/c++編寫，然後在python中使用他們

1.2.2第一個程序

1.2.2.1python程序演練

  1. 在終端中運行python代碼：python python文件名(以.py結尾)

1.2.2.2代碼錯誤排查

  1. SystaxError：語法出錯；報錯提示中出現指示箭頭表示該位置代碼出錯(例如在一個單詞的下方有一個箭頭表示這個單詞python解釋器不認識，可能是語法出錯導致了該問題，會出現SystaxvError的錯誤提示，表示語法出錯)
  2. IndentationError：縮進錯誤；在報錯提示中會出現箭頭提示出錯的位置，同時說明unexpected indent表示不希望的縮進，表明縮進存在錯誤

1.2.2.3python2和python3的區別

  1. python2的解釋器是不支持中文的，但是python3的解釋器支持中文，在終端中輸入python3就可以用python3的解釋器執行程序(輸入python是使用python2進行執行)
  2. 現在建議使用python3以上的版本進行程序的編寫，但是如果在開發時，無法立刻使用python3以上的版本(還有極少的第三方庫不支持3.0的語法)，建議先使用python3的版本進行開發，然後使用python2.6或者python2.7這兩個過渡版本進行執行(這兩個版本支持python2和不分python3的語法)，在執行的過程中根據系統的提示對代碼進行一些兼容性的處理

1.2.3python執行方式和pycharm設置

1.2.3.1多種可以解析python的解釋器

  1. Cpython：使用c語言編寫的python解釋器，是官方版本的c語言實現
  2. Jython：可以運行在Java平臺的用java編寫的python解釋器
  3. IronPython：可以運行在.net平臺和mono平臺
  4. PyPy：使用python編寫的python解釋器，支持jit即時編譯

1.2.3.2官方解釋器交互式運行程序

  1. 直接在終端中運行python代碼會直接看到程序的執行結果，這種運行方式就是交互式運行程序
  2. 如何退出python的交互式運行程序：方法一：在>>>中輸入eixt()即可退出；方法二：在>>>中按住快捷鍵ctrl+d可以退出解釋器；小技巧：在輸入eixt後會提示退出解釋器的快捷鍵

1.2.3.3IPython交互式執行python

  1. 說明：IPython是一種shell，但這種shell比python官方的shell更適於編程
  2. 優點：
    • 支持自動補全(安裝tab鍵可以自動補全)
    • 支持自動縮進
    • 可以在IPython的shell中直接輸入Linux的終端命令，即支持bash shell命令
    • 內置了很多函數
  3. 使用：
    • python2的版本使用的解釋器是ipython
    • python3的版本使用的解釋器是ipython3
  4. 退出解釋器的方式
    • 直接輸入exit
    • 按住快捷鍵ctrl+d

1.2.3.4集成開發環境IDE簡介

  1. 集成開發環境(IDE簡稱Integrated Development Environment)集成了開發軟件所需要的所有工具，一般包括：圖形用戶界面、代碼編輯器、編譯器/解釋器、調試器(斷點/單步執行)

1.2.3.5pycharm斷點調試

  1. 在需要開始斷點調試的行號前單擊，生成一個紅色的原點，點擊編輯器右上角的小蟲子按鈕就可以從斷點出開始一行一行執行程序，每點擊一次f8按鈕就會在控制檯上輸出每一行的執行結果

1.2.3.6pycharm初始設置

  1. 恢復pycharm初始設置(mac)：可以重置所有相關的配置，恢復到剛安裝的模樣

    • 根據需要刪除以下目錄
    # Configuration
rm -rf ~/Library/Preferences/PyCharm*
# Caches
rm -rf ~/Library/Caches/PyCharm*
# Plugins
rm -rf ~/Library/Application Support/PyCharm*
# Logs
rm -rf ~/Library/Logs/PyCharm*

  2. 打開python項目

    • 在項目目錄下有一個隱藏目錄.idea(可以在終端下發現)，這個目錄用來保存項目的相關的信息，例如解釋器版本、項目包含的文件等等

  3. 修改python解釋器版本(Mac)

    • pycharm-preferences-project-project interpreter

  4. 命名規則

    • 項目名命名規則：項目名前以數字編號；如：01_python基礎
    • 文件名命名規則：建議只使用小寫字母、數字和下劃線

  5. 修改控制檯字體和編輯器字體

    • Pycharm-preferences-editor-font(修改編輯器字體)/color scheme-console font(修改控制檯字體)

  6. 在終端下安裝pycharm(Linux)

    • 在官網下載pycharm(安裝包的後綴是.tar.gz：表示這是一個tar形式的包並用gz壓縮後所形成的壓縮包)
    • 用tar的方式解壓縮壓縮包：tar -zxvf 壓縮包名
    • 將壓縮後的目錄移動到/opt目錄下(/opt目錄是額外軟件的安裝目錄)，方便其它用戶使用(如果目錄在某一個用戶下那麼其它的用戶就無法使用該軟件)：sudo mv 源文件地址 目標文件地址
    • 切換工作目錄：切換到解壓縮後的目錄下的bin目錄下：cd /opt/移動後的目錄/bin
    • 啓動pycharm：./pycharm.sh

  7. pycharm有關說明：

    • 在Ubuntu中，應用程序啓動的快捷方式通常保存在/usr/share/applications目錄下

  8. Ubuntu下卸載pycharm的步驟

    • 第一步：刪除解壓縮後的目錄：opt下的解壓縮文件
    • 第二步：刪除pycharm的配置文件：.Pycharm***，是一個隱藏目錄，在根目錄下
    • 第三步：刪除pycharm的快捷方式：在/usr/share/applications目錄下

1.2.4程序註釋和算術運算符

1.2.4.1程序的註釋

  1. 在python中默認在註釋後要空一格，即在#後面要空一格，如何讓所有未空一格的註釋都空一格：在pycharm中點擊註釋前面的燈泡，點擊reformate file就可以要所有的註釋都規範化
  2. 在python中默認註釋單獨一行要空一格，而在代碼尾部添加註釋要先空兩格再輸入註釋
  3. 在寫註釋時不要描述代碼，要寫爲什麼這裏要寫這個代碼
  4. pep8：pep是python enhancement proposals的簡稱，是python官方提供的文檔，其中第八遍文檔專門提到了python的代碼格式，因此說到pep8就是python的代碼格式建議

1.2.4.2算術運算符

  1. 相關算術運算符

    運算符 描述
    // 除法取整
    / 除法保留小數
    % 除法取餘
    ** 冪運算

  2. *運算符也可以用於字符串的輸出

    • “–” * 70：表示將字符串的內容連續輸出70次
    • 拼接字符串可以用+

  3. 算術運算符的優先級

    • 最高級：冪運算
    • 第二級：乘、除、取餘、取整
    • 最低級：加、減

1.2.5程序執行原理

1.2.5.1計算機中的三大件

  1. 一個程序要運行有三個核心的硬件：cpu、內存、硬盤
  2. Cpu：中央處理器，是一塊超大規模大集成電路，負責處理數據/計算
  3. 內存：臨時存儲數據(斷電後，數據會消失)，速度快，空間小(單位價格高)
  4. 硬盤：永久存儲數據，速度慢，空間大(單位價格低)

1.2.5.2程序執行原理簡介

  1. 程序運行之前是保存在硬盤中的，當要運行一個程序時，操作系統首先會讓cpu將程序複製到內存中然後cpu執行內存中的程序代碼
  2. 程序是用來處理數據的，而變量是用來存儲數據的
    • 在打開QQ軟件時，輸入的賬號和密碼是以變量的形式保存在內存中的，即數據是保存在變量中而變量是保存在內存中的

1.2.5.3python程序執行原理

  1. 執行原理：操作系統首先讓cpu將python解釋器的程序複製到內存中，python解釋器根據語法規則從上至下讓cpu翻譯python程序中的代碼，最後cpu執行翻譯完成的代碼

  2. 查看python解釋器的大小

    which python3
# 返回結果/usr/bin/python3
ls -lh /usr/bin/python3
# 會出現一個軟鏈接：/usr/bin/python3 -> python3.6
ls -lh /usr/bin/python3.6

  3. 建立軟鏈接的目的是方便用戶執行程序而不需要每次都輸入python的版本

1.2.6變量

1.2.6.1變量的使用

  1. 交互式環境和編輯器中輸出變量的內容的區別：在交互式環境下可以直接輸入變量名就可以輸出變量的值，而在編輯器中要通過print函數來輸出變量的值
  2. pycharm中如何快速關閉當前運行程序外的所有其它python程序：鼠標右擊上方顯示的當前程序選項卡，選擇close others即可
  3. pycharm中調試代碼是需要佔用內存的，當代碼調試完畢會自動釋放內存(variables中的內容會被清空)

1.2.6.2變量的類型

  1. 使用type函數可以查看變量的類型：type(a)
  2. 在python3中將長整型和整型進行合併均稱爲整型(即在python3中只有int沒有long)

1.2.6.3變量間的計算

  1. 在使用bool進行計算時，默認將True認爲1，將False認爲是0

1.2.6.4變量的輸入輸出

  1. input()函數實現從鍵盤輸入，且所有輸入的內容都被認爲是字符串類型

  2. 類型轉換函數：int()和float()

  3. 格式化輸出

    price = 3
weight = 4
height = 3.0
# 變量的格式化輸出，佔位符輸出(將需要代替的內容用佔位符代替)
# print("格式化字符串" % （變量1,變量2，……）)
# 格式化字符：%s,%d,%f,%%;分別表示字符串，十進制整數，浮點數，輸出%
# %06d表示輸出位的顯示位數，不足的地方用0補全，如果超過6位就顯示原本的數字
# %.2f表示小數後只顯示2位,%.3f表示小數後只顯示3位
print("金額：%09d 價格：%.2f 重量：%d%%" % (price*weight,price*height,weight))
print("金額：%09d" % price*2)  # 直接在變量後面*2會導致輸出的內容連續輸出兩遍
print("金額：%09d" % (price*2))  # 變量後面*2後加上括號會將變量*2後輸出

1.2.6.5變量的命名

  1. 變量名不能以數字開頭，只能包括字母、下劃線和數字
  2. 命名規則：常用的變量命名規則右駝峯命名法，駝峯命名法又分爲小駝峯命名法和大駝峯命名法(區別在於第一個單詞的字母是否大寫)，但python不建議使用駝峯命名法，建議在定義變量時只使用小寫字母，當需要多個單詞組合時用下劃線隔開，例如：first_name
  3. if判斷語句的條件一般不用括號：if a > 4:

1.2.7if判斷語句

1.2.7.1pycharm代碼塊及光標位置提示

  1. 在pycharm中，在代碼的左邊和行數的右邊有一個加減號可以對同一類型的代碼進行收納，在代碼的下方和控制檯的上方有一個提示可以顯示當前的代碼處於哪個模塊之下(例如：如果光標在判斷語句的內部，那麼又會提示是處於哪個語句內部)
  2. 在pycharm中一般代碼下方出現波浪號且這種波浪號是淡色的，那一般是因爲代碼不符合官方的要求，點擊代碼前面的小燈泡進行修正即可

1.2.7.2邏輯運算

  1. 在編寫代碼時用and,or,not來表示與，或，非運算，其中非就是取反運算(True變爲False)

  2. 說明：在判斷語句中，bool型的變量可以直接作爲判斷條件，因爲正常語句的判斷的結果就是bool型(2==3的結果就是False)

  3. 代碼編寫技巧

    • 如果一行代碼過長會導致閱讀不方便，可以在大的條件上增加一個括號，然後對可以分行顯示的內容進行換行處理，換行後爲防止誤解建議將換行後的代碼再添加一個縮進(如果不添加縮進可能會錯誤的和後面的代碼理解爲處於同一級下：例如下面的代碼如果不添加縮進可能會將or後面的內容理解爲和print後面的內容都是執行語句)

      a = 1
b = 1
if((a == 1 and b == 1)
        or (a == 2 and b == 2)):
    print("exit")

  4. 隨機數的使用

    import random  # 使用隨機數需要導入random模塊
random.randint(2,4)  # randint(a,b)函數可以隨機產生a和b之間的隨機整數，包括a和b，其中a<=b

1.2.7.3if後面的內容

  1. if後面可以是一個等式，同時也可以是一個變量，這個變量可以是數字、元祖、字符串、None、False、True等。對於數字而言不是0就可以執行內部程序；對於元祖、字符串、列表這些而言只要不爲空就可以執行內部程序；只要不是None,False就可以執行內部代碼(原理就是if後面的內容只有一個結果要麼爲真要麼爲假，需要區分的就是各種類型的數據什麼情況下爲真什麼情況下爲假)

1.2.8while循環基本使用

1.2.8.1while循環基礎

  1. while循環的條件一般也不需要括號：while a > 4:
  2. 賦值運算符：例如：a += b表示a = a + b

1.2.8.2循環嵌套

  1. print輸出說明，print函數默認輸出後換行，如果不需要換行，可以如此做：print(“123”,end="")，其中end後面的內容就是在輸出內容後會增加的內容，內部寫什麼輸出什麼，print("")表示換行

1.2.8.3字符串中的轉義字符

  1. 轉義字符的介紹

    轉義字符 描述
    \t 橫向製表符
    \n 換行
    \\ 反斜槓符號
    \r 回車
    \’ 單引號
    \* 雙引號

  2. 說明：\t在控制檯輸出一個製表符，協助在輸出文本時垂直方向對齊，製表符的功能是在不使用表格的情況下在垂直方向按列對齊文本，在Unix系統下執行 換行操作 用“\n” 在windows 操作做系統下執行 換行操作 用“\r\n” 在Mac操作系統下執行 換行操作用“\r”

  3. 舉例說明：

    # 九九乘法表
row = 1
while row <= 9:
    line = 1
    while line <= row:
        print("%d*%d=%d" % (line, row,line * row), end="\t")
        line += 1
    print("")
    row += 1

1.2.9函數

1.2.9.1函數的基本使用

  1. 導入模塊事例：
    • 寫一個完成九九乘法表的函數multiplication_table()，將該函數所在的程序命名爲multiplication_table.py(現在，這個程序將相當於一個模塊，multiplication_table函數就是該模塊中用於實現九九乘法表的函數)
    • 在另一個程序中導入該模塊，import multiplication_table，在該程序中調用multiplication_table函數來實現輸出九九乘法表的功能：multiplication_table.multiplication_table()
  2. 說明：函數必須先定義再調用(因爲python時解釋型語言)
  3. 斷點調試：f8調試遇到函數時會直接輸出函數的結果不會進入到函數內部，而f7調試遇到函數時可以進入到函數內部一步一步執行。其它方面f7和f8基本沒有差別
  4. 函數的註釋(函數功能說明)
    • 一般官方要求在函數定義的上方必須空兩行
    • 書寫函數的功能註釋時再函數名的下方所在行用三個雙引號引起來書寫註釋
    • 在pycharm中選中函數名按住快捷鍵ctrl+q(有的是f1：查看view->quick documentation就可以查看註釋)就可以調出書寫的函數註釋

1.2.9.2函數的參數和返回值

  1. 函數參數的使用：

    """
   這裏函數的參數的作用就相當於定義變量，在調用時就相當於給這兩個變量賦值，
   函數內部就可以直接調用而不需要再定義
"""
def sum(a,b):  
    """求兩個數的和"""
    sum = a + b
    print(sum)
sum(1,2)

  2. 形參和實參

    • 在函數定義時使用的參數叫形參(定義時沒有賦予數據)，在函數調用時使用的參數叫實參(是實實在在的數據)
    • 形參的兩個作用：一個是定義變量可以在函數內部直接使用而不需要再次定義，另外一個是表示該函數可以賦予數據

  3. 函數的返回值

    • 返回值是函數完成後給調用者一個結果

    • 使用return關鍵字可以返回結果

    • 調用函數的一方可以使用變量來接受函數的返回結果

      """
   這裏函數的參數的作用就相當於定義變量，在調用時就相當於給這兩個變量賦值，
   函數內部就可以直接調用而不需要再定義
"""
def sum(a,b):
    """求兩個數的和"""
    return a + b


# python官方要求在函數的後面也要有兩行空格
result = sum(1,2)  # 使用result變量來接受函數的返回結果
print(result)

    • return後續的代碼不會被執行，所以return是函數的最後一行代碼

1.2.9.3函數的嵌套調用

  1. 事例：

    def line_line(char, time):
    """打印單行憑條"""
    return char * time


def line(char, time, row):  # 這裏python推薦再,後添加一個空格
    # 以下可以爲函數的參數添加註釋並按f1會有相關說明，注意下面的冒號後面應該有一個空格
    """打印多行憑條

    :param char: 要打印的字符
    :param time: 要打印的個數
    :param row: 要打印的行數
    """
    flat = 1
    while flat <= row:
        if flat != row:
            print(line_line(char, time))
        else:
            print(line_line(char, time), end="")
        flat += 1


"""以下定義的abc不要和函數內部的變量一致，否則會有提示：shadows name *** from outer scope，
   函數內部的變量，如果和函數被調用的外部的變量一樣的話，就被PyCharm中叫做shadows name，
   也就是說形參和實參最好不要用同一個變量名
   """
a = input("請輸入要打印的字符：")
b = int(input("請輸入要打印的個數："))
c = int(input("請輸入要打印的行數："))
line(a, b, c)

1.2.9.4模塊

  1. 模塊的概念：在python中每一個以.py結尾的源代碼文件就是一個模塊
  2. 模塊的命名：模塊名就是一個變量名，而變量名不能以數字開頭，所以一般定義文件名不以數字開頭
  3. 新版pycharm新建工程後會自動創建一個包venv，我們可以在該包下新建一個包src，然後在src下新建python文件
  4. 在一個python文件中導入一個模塊時，系統會自動創建一個模塊的編譯後的文件，後綴名爲.pyc，當調用模塊中的函數時達到快速執行的目的而不需再對函數一行一行的進行編譯執行，該文件存在於工程目錄下，用於提高程序的執行效率

1.2.10列表

1.2.10.1列表的定義及作用

  1. 列表是python中使用最頻繁的數據類型，在其它語言中通常叫數組
  2. 列表的定義：name_list = [“zhangsan”, “lisi”, “wangwu”]
  3. 在ipython3中如果想知道一個列表下面可以有哪些方法，可以輸入定義一個列表，然後輸入列表名，再寫.再按下tab鍵就可以看到方法

1.2.10.2列表的相關方法

  1. 知道內容取出在列表中對應的索引：index()

    name_list = ["zhangsan", "lisi", "wangwu"]
index_lisi = name_list.index("lisi")  # index()方法用來取出索引
print(index_lisi)

  2. 修改指定位置的內容：list_name[1] = “李四”

  3. 向列表增加數據：insert(),extend(),append()

    name_list = ["zhangsan", "lisi", "wangwu"]
name_list.append("zhaoliu")  # append方法就是將指定的內容追加到列表的末尾，如果追加的是一個列表則默認爲該列表是一個獨立的元素來插入原先列表中
name_list.insert(1, "guohuai")  # insert方法可以在列表的指定位置插入數據，原先位置的數據往後移
temp_list = ["張三", "李四"]
name_list.extend(temp_list)  # extend方法可以將指定列表插入到列表的末尾
print(name_list)

  4. 從列表中刪除數據：remove(),pop(),clear()

    name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
name_list.remove("lisi")  # remove方法用於刪除指定的數據，如果列表中有多個該數據會刪除第一個出現的指定數據
name_list.pop()  # pop方法如果不添加任何參數是刪除列表中最後一個數據
name_list.pop(1)  # pop方法可以刪除指定索引的數據
name_list.clear()  # clear方法可以清空整個列表
# del跟上列表變量名後再跟索引就可以刪除指定索引的數據
del name_list[2]  # del關鍵字可以從內存中刪除變量，後續不能使用被刪除後的變量
name = "123"
del name
# 在列表中刪除數據時建議使用列表提供的方法，不建議使用del
print(name_list)

  5. 列表統計：count(),len()

    name_list = ["張三", "李四", "王五"]
name_list.append("李四")
list_len = len(name_list)  # len函數用來統計列表中元素的總數
count = name_list.count("李四")  # count函數用來統計列表中某一個數據出現的次數
print(list_len)
print(count)
name_list.remove("李四")

  6. 說明：在使用pycharm時如果對某一個函數不清楚其具體作用可以使用f1來查看函數的具體作用(有的是ctrl+q)

  7. 列表的排序和反轉：sort(),reverse()

    name_list = ["lisi", "zhangsan", "wangwu"]
name_list.sort()  # sort函數默認將列表按照升序進行排列
name_list.sort(reverse=True)  # sort函數加上參數reverse(表示翻轉)就可以降序排列
name_list.reverse()  # reverse函數可以將列表中元素的順序進行反轉，將123變爲321(注意這沒有降序的功能)
print(name_list)

  8. 關鍵字、函數、方法的區別

    • 關鍵字後面不需要跟括號：如del 變量名

    • ipython3下查看python有多少關鍵字：

      import keyword
print(deyword.kwlist)

    • 函數和方法後面都需要帶括號而且函數和方法類似，但是函數需要死記硬背但方法不需要死記硬背，函數可以直接調用而方法需要對象名來調用，不知道函數名就無法使用函數，不知道方法名可以使用對象.來補全和查看方法名

  9. 列表的循環遍歷

    • 遍歷：就是從頭到尾依次從列表中獲取數據，在python中，可以使用for循環遍歷所有非數字類型的變量：列表、元祖、字典以及字符串

    • 使用for來實現遍歷

      name_list = ["lisi", "zhangsan", "wangwu"]
for name in name_list:  # for後面的變量是每一次遍歷所得到數據的存儲位置，in後面的內容是要遍歷的列表變量名
    print(name)  # 每遍歷一次都要執行for的內部內容

  10. 列表的應用場景：列表一般用來存儲具有相同類型的元素，一般很少用列表存儲不同類型的數據

1.2.11元祖

1.2.11.1元祖的定義

  1. 元祖與列表相似，但是元祖中的元素不能修改
  2. 元祖的定義：
    • Info_tuple = (“zhangsan”, 18, 1.75)
    • 定義一個只包含一個元素的元祖：info_tuple = (12, )
    • 說明：定義一個只包含一個元素的元祖必須在元素後面寫一個逗號，否則python不會將其識別爲一個元祖
  3. 通過索引查看元祖的數據：
    • Info_touple_first = info_touple[0]
    • 說明：通過索引查看元祖需要用[]而不是()

1.2.11.2元祖變量的相關操作

  1. 要一個變量有哪些方法，只需在變量後寫一個.然後根據提示就可知道有哪些方法(或者在ipython下輸入變量.然後雙擊tab鍵也可以查看)
  2. 取索引操作：和列表一樣，通過index()函數即可查看指定內容所對應的索引
  3. 統計某個元素出現的次數：和列表一樣使用count()函數就可以查看出現的次數
  4. 統計元祖包含元素的個數：和列表使用len函數(len(元祖變量名))
  5. 使用for循環遍歷元祖的數據：和列表遍歷一樣
  6. 在實際開發中元祖通常保存數據類型不同的數據，所以對元祖的循環遍歷通常不多(例如：很難對元祖中的數據進行拼接)

1.2.11.3元祖的應用場景

  1. 作爲函數的參數和返回值，一個函數可以接受任意多個參數或者返回多個數據

  2. 格式化字符串(在格式化輸出時，%後面括號內部的內容就是一個元祖)

    • print("%d %s %f" % (10, “123”, 1.22))

    • 元祖拼接字符串

      print("%d %s %f" % (10, "123", 1.22))
info_tuple = (10, "123", 1.22)
into_str = "%d %s %f" % info_touple  # 元祖拼接字符串最後得到的是一個字符串
print(into_str)

  3. 由於元祖內部的數據不可以修改所以間接保證了數據的安全，所以通常將列表轉化爲元祖以此來保證列表中數據的安全性

    • 利用list(元祖變量名)函數可以將元祖轉化爲列表
    • 利用tuple(列表變量名)函數可以將列表轉化爲元祖

1.2.12字典

1.2.12.1字典的定義

  1. 字典和列表的區別：列表是有序的對象集合(索引就是順序)，字典是無序的對象集合
  2. 字典的定義：{}
  3. 字典使用鍵值對存儲數據的，鍵值對之間用,隔開，鍵必須是唯一的，鍵用來表示數據，值用來保存數據
  4. 鍵key是索引，值value是數據，鍵和值之間用:分隔，鍵必須是唯一的，值可以取任何數據類型但鍵只能使用字符串、數字或者元祖
  5. 在日常開發中，字典通常用於存儲描述一個物體的相關信息

1.2.12.2字典的操作

  1. 字典的定義

    # 字典是一個無序的集合，通常輸出的順序不一定就是字典中定義的順序
xiaoming = {"name": "小明",  # 在日常字典的編寫中，每一個鍵值對通常只佔用一行，直接回車即可下一個鍵值對書寫
            "age": 18,
            "gender": True}
print(xiaoming)

  2. 字典的增刪改查等常用操作

    • 字典的取值

      xiaoming = {"name": "小明"}
print(xiaoming["name"])  # 在中括號中輸入要取出值的鍵

    • 增加鍵值對

      xiaoming = {"name": "小明"}
xiaoming["age"] = 18  # 添加鍵值對
xiaoming["name"] = "小李"  # 修改鍵值對中的值
print(xiaoming["name"])  # 在中括號中輸入要取出值的鍵

    • 修改鍵值對的值

      xiaoming = {"name": "小明"}
xiaoming["age"] = 18  # 添加鍵值對
xiaoming["name"] = "小李"  # 修改鍵值對中的值
print(xiaoming["name"])  # 在中括號中輸入要取出值的鍵

    • 刪除鍵值對

      xiaoming = {"name": "小明"}
xiaoming["age"] = 18  # 添加鍵值對
xiaoming["name"] = "小李"  # 修改鍵值對中的值
xiaoming.pop("age")  # 使用pop()函數來刪除指定的鍵值對
print(xiaoming["name"])  # 在中括號中輸入要取出值的鍵

  3. 字典的統計、合併、清空操作

    • 統計字典中鍵值對的數量：len()函數統計鍵值對的數量

    • 合併兩個字典

      xiaoming = {"name": "小明",
           "age": 18}
temp = {"height": 1.75,
       "age": 19}
xiaoming.update(temp)  # 使用update()函數來合併兩個字典，如果兩個字典有重複的鍵則括號內部的字典取代.前面的字典

    • 清空字典：使用clear()方法可以清空所有的鍵值對

    • 只有不可變類型纔可以用作字典的key，可變類型(列表和字典)不能定義爲字典的key

  4. 字典的循環遍歷

    xiaoming = {"height": 182,
           "age": 18}
# 在日常使用中一般不對字典進行遍歷，因爲字典的值類型不同，遍歷輸出類型無法統一
for temp in xiaoming:  # temp是獲取到到key
    print("%s-%d" % (temp,xiaoming[temp]))  # 此處temp不需要打引號，此處temp包括引號

1.2.12.3字典和列表組合的應用場景

  1. 在列表中插入字典，用字典當成列表的元素然後遍歷列表

    card_list = [
    {"name": "張三",
    "age": 19},
    {"name": "李四",
     "age": 20}
]
for k in card_list:
    print(k)

1.2.13字符串

1.2.13.1定義和基本使用

  1. python可以用雙引號或者單引號來定義一個字符串，但是在日常的編程學習過程中通常使用雙引號來定義字符串

  2. 單引號中使用雙引號可以輸出雙引號，雙引號中使用單引號可以輸出單引號

  3. 字符串的取值：

    str1 = "hello python"
print(str1[6])  # 通過索引取出字符串中的值

  4. 字符串的遍歷

    str1 = "hello python"
for k in str1:
    print(k, end="")

  5. len()函數統計字符串的長度

    str1 = "hello python"
print(len(str1))

  6. count()方法統計特定字符出現的次數

    str1 = "hello python"
print(str1.count("on"))

  7. 使用index()方法取出指定字符的索引位置

    str1 = "hello python"
print(str1.index("llo"))  # 當字符串出現多次時，默認顯示第一次出現的索引,取出字符串的索引時默認是該字符串第一個字符的位置

1.2.13.2字符串的常用方法

  1. 判斷類型的方法：

    • 判斷字符串是否是空白字符(\r\t\n以及空格都默認是空白字符)：isspace()，如果是就返回True

      str1 = "  \r"
print(str1.isspace())

    • String.isalnum()：如果一個字符串至少有一個字符並且所有的字符串都是字母或者數字則返回True

    • String.isalpha()：如果一個字符串至少有一個字符並且所有的字符串都是字母則返回True

    • String.isdecimal()：如果一個字符串只包含全角數字則返回True，不能判斷小數

    • String.isdigit()：如果一個字符串只包含數字(全角數字、(1)類型的數字(就是字符串內部的內容爲(1))、\u00b2)則返回True，不斷判斷小數

    • String.isnumeric()：如果一個字符串只包含數字(全角數字、漢字數字、(1)類型的數字(就是字符串內部的內容爲(1))、\u00b2)則返回True，不能判斷小數

    • String.istitle()：如果一個字符串每個單詞的首字母大寫則返回True

      str1 = "Hello python"
print(str1.istitle())

    • String.islower()：如果一個字符串全部都是小寫字母則返回True

    • String.isupper()：如果一個字符串全部都是大寫字母則返回True

  2. 字符串的查找和替換方法

    • String.startswith(str)：檢查字符串是否以str開頭，是則返回True

    • String.endswith(str)：檢查字符串是否以str結束，是則返回True

    • String.find(str, start=0, end=len(string))：檢測str是否包含在string中，如果start和end指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1

      str_01 = "qwertyuiop"
temp_01 = str_01.find("wer")  # 判斷字符串是否在指定字符串中，如果在返回索引，如果不在返回-1
temp_02 = str_01.find("ert",2,5)  # 判斷字符串是否在指定區間的字符串中，2和5表示索引，區間包括2但不包5，如果在返回索引，如果不在返回-1
print(temp_01, temp_02)

    • String.rfind(str, start=0, end=len(string))：類似於find()函數，不過是從右邊開始查找，但返回的仍然是第一個字符的索引而不是最後一個字符的索引

    • String.index(str,start=0,end=len(string))：跟find()方法相似，只不過如果str不在string會報錯

    • Sting.rindex(str,start=0,end=len(string))：類似於index()，不過是從右邊開始

    • String.replace(old_str,new_str,num=string.count(old))：把string中的old_string替換成new_string，如果num指定則替換不超過num次，但這種替換不會修改原來字符串的內容只是replace方法輸出的內容被改變

  3. 大小寫轉換

    • String.capitalize()：把字符串第一個字符大寫

    • String.title()：把字符串每個單詞的首字母大寫

      str_01 = "hello python"
temp_01 = str_01.capitalize()  # 只將索引爲0的字母變爲大寫
temp_02 = str_01.title()  # 將字符串中每個單詞的首字母變爲大寫
print(str_01)
print(temp_01)
print(temp_02)

    • String.lower()：轉換string中所有大寫字母爲小寫

    • String.upper()：轉換string中所有小寫字母爲大寫

    • String.swapcase()：翻轉string中的大小寫

  4. 文本對齊

    • String.ljust(width)：返回一個原字符串左對齊，並使用空格填充至長度width的新字符串

    • String.rjust(width)：返回一個原字符串右對齊，並使用空格填充至長度width的新字符串

    • String.center(width)：返回一個原字符串居中，並使用空格填充至長度width的新字符串

      poem = ["登鸛雀樓",           
        "王之渙",            
        "白日依山盡",          
        "黃河入海流",          
        "欲窮千里目",          
        "更上一層樓"]          
for poem_str in poem:     
    print("｜%s｜" % (poem_str.center(100," ")))  # 這裏不輸入空格只寫100也可以，表明使用默認的空格            
"""這裏的左對齊表示每行靠左頂格輸出且每行輸出後空
右對齊表示每行輸出靠右且每行輸出距離左邊邊界100個
居中對齊表示每行輸出距離左右邊界各5個空格"""

  5. 去除空白字符

    • String.lstrip()：截掉字符串左邊的空白字符
    • String.rstrip()：截掉字符串右邊的空白字符
    • String.strip()：截掉字符串左右兩邊的空白字符
    • 說明：上述三種方法都不能截掉字符串中間的空白字符

  6. 拆分和拼接字符串

    • String.partition(str)：把字符串string分成一個3元素的元祖(str前面，str，str後面)

    • String.rpartition(str)：類似partition方法，只不過是從右邊開始查找,但輸出仍然是從左邊開始輸出且輸出是一個元祖

    • String.split(str="",num)：以str爲分隔符拆分string，如果num有指定值則僅分割num+1個字符串,該方法返回的是一個列表；如果沒有指定str(即沒有指定分隔符)，則默認使用包含\r,\t,\n和空格的空白字符來進行分割

    • String.splitlines()：按照行(\r,\n,\r\n)分割，返回一個包含各行作爲元素的列表

    • String.join(seq)：以string作爲分隔符，將seq中所有的元素(的字符串表示)合併爲一個新的字符串

      str_01 = "   abc   def   ghi\t\n  hui\t"
print(str_01.split())  # 什麼參數都不寫會按照默認的空白字符來進行分割字符串，該函數返回的是一個列表
str_02 = "".join(str_01.split())  # 將括號內變量的內容進行連接，連接的字符爲""內部的字符，一般括號內部的內容是一個類似列表格式的元素
print(str_02)
print(str_02.partition("cde"))  # 返回的是一個元祖

  7. 切片和倒序索引

    • 切片適用於字符串、列表、元祖

    • 切片的語法：待切片的內容[開始索引:結束索引:步長]：開始索引就是第一刀的位置，結束索引就是第二刀的位置；按順序索引進行切片：結束索引所在的元素不在切片之內；如果設定開始索引爲0，步長爲2則表示隔一個字符進行切片，可以理解爲一個一個進行切片，第一個且索引爲0的元素，第二個切索引爲2的元素；如果將開始索引設置爲0，結束索引設置爲-1則最後一個元素不在切片內，可以將結束索引不寫就可以切到整個索引

    • 倒序索引：最後一個字符對應的索引爲-1，倒數第二個爲-2

    • 圖片理解切片

      [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-V17KeNJH-1581325663322)(/Users/dedicationyu/Pictures/Photos Library.photoslibrary/originals/6/6DD6233D-DA37-4A7A-B2F4-1D5146AA0FD5.png)]

    • 代碼理解切片

      num_str = "0123456789"
num_str_01 = num_str[1:4]  # 將123進行切片，同理包括左邊不包括右邊
num_str_02 = num_str[1:]  # 將1之後的內容進行切片，只用寫1所在的索引，結束索引不寫但冒號必須有
num_str_03 = num_str[:6]  # 將5之前但內容進行切片，只需寫5後面但索引，開始索引不需要寫但冒號必須有
num_str_04 = num_str[:]  # 截取完整但字符串
num_str_05 = num_str[::2]  # 從0開始每隔一個字符串取一個字符串
num_str_06 = num_str[-2:]  # 截取最後兩個字符89
num_str_07 = num_str[-1::-1]  # 倒序切片(將字符串通過切片的方式進行倒序輸出)，這裏也可以不寫開始索引，-1默認從最後一個開始切片
print(num_str_01)
print(num_str_02)
print(num_str_03)
print(num_str_04)
print(num_str_05)
print(num_str_06)
print(num_str_07)
# 總結：開始索引和結束索引確定切片的範圍，步長確定切片的內容，如果不指明步長就默認將範圍內的內容全部進行切片；對於步長而言，2表示從左至右隔一個切片，-2表示從右往左隔一個切片，切哪個索引就表示取出索引所在的字符

1.2.14公共方法

1.2.14.1python內置函數

  1. 公共方法的概念：就是列表、索引、字典、字符串等都可以使用的方法就是公共方法
  2. 內置函數的概念：就是不需要導入相應的模塊就可以直接使用的函數就是內置函數
  3. python的5大內置函數
    • len(item)：計算容器(item)中元素的個數，所謂容器可以形象的理解爲裝元素的東西，像集合、列表、元祖、字符串甚至一個變量都可以理解爲容器，它們內部都裝了元素
    • del(item)：刪除變量；在python中del有兩種表現形式，一種以關鍵字的形式出現，一種以函數的形式出現，這兩種方式效果完全一致，python爲了保證和其它函數的一致性就將del也以函數的形式出現
    • max(item)：返回容器中元素的最大值，如果容器是字典比較的是key的大小，返回的是最大的key,是一個字符串類型
    • min(item)：返回容器中元素的最小值，如果容器是字典比較的是key的大小，返回的是最小的key,是一個字符串類型
    • python3中可以用比較運算符比較容器的大小，對於像列表這種包含多個元素的容器而言，是按照順序從左至右比較大小的，但注意字典之間是不能比較大小的

1.2.14.2切片

  1. 切片的說明：切片是使用索引值來進行範圍限定，所以向元祖、列表、字符串這些有索引位置的都可以使用切片，但像字典這種沒有索引位置的不可以使用切片

1.2.14.3運算符

  1. +：在字符串、列表、元祖中都可以用來實現拼接(最後輸出一個新的字符串、列表、元祖)
  2. *：在字符串、列表、元祖中都可以用來實現重複(最後輸出一個新的字符串、列表、元祖)，由於字典的key唯一所以不能重複
  3. in：在字符串、列表、元祖、字典中都可以用來判斷元素是否存在(3 in (1,2,3)的結果爲True)，注意在字典中判斷的是key，被稱爲成員運算符
  4. not in：在字符串、列表、元祖、字典中都可以用來判斷元素是否不存在(4 not in (1,2,3)的結果爲True)，注意在字典中判斷的是key，被稱爲成員運算符
  5. >,<,<=,>=,==：在字符串、列表、元祖中用來進行元素比較

1.2.14.3完整的for循環語法

  1. 語法格式：

    for 變量 in 集合：

	循環體代碼
else:
  沒有通過break退出循環，循環結束後會執行的代碼

  2. for else循環的實際應用

    # 使用迭代遍歷來判斷容器中是否有我們所需要的值(判讀要查找的學生是否是本校的學生)
name = [
    {"name": "張三"},
    {"name": "李四"}
]
name_find = input("請輸入要查找的姓名：")
for name_stu in name:
    if name_stu["name"] == name_find:
        print("你所查找的姓名爲%s的在我們的學校" % name_find)
        break  # 查找成功則不需要繼續遍歷，結束循環
else:
    print("你所查找的姓名爲%s的不在我們的學校" % name_find)
print("查找完畢")

  3. 說明：在日常的開發中一般使用for遍歷不會使用else，當使用嵌套遍歷時來進行相關查詢時，如果需要輸出查詢未果的消息提示時可以使用else來進行實現

1.2.15名片管理系統

1.2.15.1框架搭建

1.2.15.1.1目標
  1. 準備文件，確定文件名，保證能夠在需要的都位置編寫代碼
  2. 編寫主運行循環，實現基本的用戶輸入和判斷
1.2.15.1.2文件準備
  1. 新建一個cards_main.py程序保存主程序功能代碼
  2. 新建一個cards_tools.py程序保存所有的名片和函數：
    • 將對名片的新增、查詢、刪除、修改等功能封裝在不同的函數中
1.2.15.1.3用戶輸入判斷和pass關鍵字

  1. 在主函數中實現用戶輸入的判斷

    action_str = input("請輸入你要執行的操作：")
print("你選擇的操作是【%s】" % action_str)
# 輸入其它內容提示輸入錯誤請重新輸入
else:
    print("你的輸入不正確請重新輸入")
1.2.15.1.4無限循環保證用戶能夠重複選擇操作

  1. TODO註釋的使用：

    • 格式：# TODO([email protected]): Use a “*” here for string repetition.
    • 說明：TODO註釋應該在所有開頭處包含”TODO”字符串, 緊跟着是用括號括起來的你的名字, email地址或其它標識符. 然後是一個可選的冒號. 接着必須有一行註釋, 解釋要做什麼. 主要目的是爲了有一個統一的TODO格式, 這樣添加註釋的人就可以搜索到(並可以按需提供更多細節). 寫了TODO註釋並不保證寫的人會親自解決問題. 當你寫了一個TODO, 請註上你的名字.
    • 應用：在日常開發中當一個功能需要實現但還未實現爲防止遺忘該處有一個共功能需要實現就需要寫TODO註釋用來標註這裏有一個什麼樣的功能需要誰來實現，括號內寫需要實現該功能的程序員，冒號後面寫需要實現什麼樣的功能，按住alt+6就可以快速查看一個程序中有哪些功能還未實現，並通過點擊的形式快速定位到這些TODO註釋以便來進行代碼說明
    • 問題：在pycharm中出現TODO無法使用的情況即該註釋無法使用

  2. 在主函數中實現無限循環

    while True:
    action_str = input("請輸入你要執行的操作：")
    print("你選擇的操作是【%s】" % action_str)
    # 1,2,3是針對名片的操作
    if action_str in ["1", "2", "3"]:
        pass  # 在開始編寫框架時不寫具體要實現的功能但爲了保證代碼能夠過運行可以使用pass關鍵字來進行佔位
    # 0是退出系統
    elif action_str == "0":
        print("歡迎再次使用名片管理系統")
        break
    # 輸入其它內容提示輸入錯誤請重新輸入
    else:
        print("你的輸入不正確請重新輸入")
1.2.15.1.5if嵌套判斷用戶的具體操作預留代碼位置

  1. 在主函數中實現循環嵌套判斷用戶操作

    # 無限循環執行操作，由用戶決定什麼時候退出循環
while True:
    action_str = input("請輸入你要執行的操作：")  # 這裏不要使用int進行轉換，否則用戶輸入不是數字時會報錯
    print("你選擇的操作是【%s】" % action_str)
    # 1,2,3是針對名片的操作
    if action_str in ["1", "2", "3"]:  # 可以在此處增加斷點來判斷所寫的判斷語句是否可以達到功能需求
        # 新增名片
        if action_str == "1":
            pass
        # 顯示全部名片
        elif action_str == "2":
            pass
        # 查詢名片
        elif action_str == "3":
            pass
    # 0是退出系統
    elif action_str == "0":
        print("歡迎再次使用名片管理系統")
        break
    # 輸入其它內容提示輸入錯誤請重新輸入
    else:
        print("你的輸入不正確請重新輸入")
1.2.15.1.6顯示歡迎界面及功能菜單

  1. 在tools函數中實現歡迎界面的函數編寫

    def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)

  2. 在主函數中調用tools中有關歡迎界面的函數來實現歡迎界面的功能

    import cards_tools
# 無限循環執行操作，由用戶決定什麼時候退出循環
while True:
    cards_tools.show_menu()  # 導入show_menu()函數來實現歡迎界面的顯示
    action_str = input("請輸入你要執行的操作：")  # 這裏不要使用int進行轉換，否則用戶輸入不是數字時會報錯
    print("你選擇的操作是【%s】" % action_str)
    # 1,2,3是針對名片的操作
    if action_str in ["1", "2", "3"]:  # 可以在此處增加斷點來判斷所寫的判斷語句是否可以達到功能需求
        # 新增名片
        if action_str == "1":
            pass
        # 顯示全部名片
        elif action_str == "2":
            pass
        # 查詢名片
        elif action_str == "3":
            pass
    # 0是退出系統
    elif action_str == "0":
        print("歡迎再次使用名片管理系統")
        break
    # 輸入其它內容提示輸入錯誤請重新輸入666
    else:
        print("你的輸入不正確請重新輸入")
1.2.15.1.7準備名片操作函數

  1. 在tools函數中編寫名片相關的操作函數

    def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")


def search_card():
    """搜索名片"""
    print("搜索名片")

  2. 在主函數調用相關的名片操作函數

    import cards_tools
# 無限循環執行操作，由用戶決定什麼時候退出循環
while True:
    cards_tools.show_menu()  # 導入show_menu()函數來實現歡迎界面的顯示
    action_str = input("請輸入你要執行的操作：")  # 這裏不要使用int進行轉換，否則用戶輸入不是數字時會報錯
    print("你選擇的操作是【%s】" % action_str)
    # 1,2,3是針對名片的操作
    if action_str in ["1", "2", "3"]:  # 可以在此處增加斷點來判斷所寫的判斷語句是否可以達到功能需求
        # 新增名片
        if action_str == "1":
            cards_tools.new_card()  # 調用new_card()函數來實現新增名片的功能
        # 顯示全部名片
        elif action_str == "2":
            cards_tools.show_all()  # 調用show_all()函數來實現顯示全部名片的功能
        # 查詢名片
        elif action_str == "3":
            cards_tools.search_card()  # 調用search_card()函數來實現查詢名片的功能
    # 0是退出系統
    elif action_str == "0":
        print("歡迎再次使用名片管理系統")
        break
    # 輸入其它內容提示輸入錯誤請重新輸入666
    else:
        print("你的輸入不正確請重新輸入")

1.2.15.2數據結構的確定

1.2.15.2.1確定名片管理系統的數據結構

  1. 在tools中定義列表變量

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")


def search_card():
    """搜索名片"""
    print("搜索名片")

1.2.15.3新增名片

1.2.15.3.1新增名片功能實現

  1. 在tools中實現新增名片的功能

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")


def search_card():
    """搜索名片"""
    print("搜索名片")

  2. pycharm批量修改變量名的技巧

    • 在需要修改的變量名上右擊鼠標選擇Refactor(重構)然後選擇Rename，當變量名出現紅色邊框時即可開始修改，按住回車鍵就可以結束脩改

1.2.15.4顯示全部

1.2.15.4.1遍歷列表顯示字典

  1. 在tools中通過遍歷將列表中的信息全部顯示

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
1.2.15.4.2判斷列表數量，列表中沒有任何名片直接輸出提示不輸出其它內容

  1. 在tools中實現列表爲空時輸出提示同時不輸出任何其它內容

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行，return語句時函數的最後一行代碼，後面的內容都不會執行，不管return後面有沒有語句
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")

1.2.15.5查詢名片

1.2.15.5.1查詢功能的實現

  1. 在tools中實現查詢功能

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
    # 提示用戶輸入要搜索的姓名
    name_find = input("請輸入要搜索的姓名：")
    # 遍歷名片列表，查詢要搜索的姓名，如果沒有找到需要提示用戶
    for find_temp in card_list:
        if find_temp["name"] == name_find:  # 如果查詢到要搜索的姓名則輸出對應的信息
            print("------搜索到%s的信息------" % name_find)
            for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:  # 打印表頭
                print(card_table_head, end="\t\t")  # \t的數量多少影響空格的大小
            print("")
            print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                find_temp["phone"],
                                                find_temp["email"],
                                                find_temp["qq"]))
            break  # 查詢到就結束遍歷
        else:
            print("抱歉沒有查到%s的相關信息" % name_find)
1.2.15.5.2處理名片函數

  1. 在tools中對查詢到的名片進行處理操作，封裝一個處理名片的函數，然後在查詢函數中調用來實現處理的功能

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
    # 提示用戶輸入要搜索的姓名
    name_find = input("請輸入要搜索的姓名：")
    # 遍歷名片列表，查詢要搜索的姓名，如果沒有找到需要提示用戶
    for find_temp in card_list:
        if find_temp["name"] == name_find:  # 如果查詢到要搜索的姓名則輸出對應的信息
            print("------搜索到%s的信息------" % name_find)
            for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:  # 打印表頭
                print(card_table_head, end="\t\t")  # \t的數量多少影響空格的大小
            print("")
            print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                find_temp["phone"],
                                                find_temp["email"],
                                                find_temp["qq"]))
            # 針對查找到的信息進行修改和刪除的操作
            deal_card(find_temp)
            break  # 查詢到就結束遍歷
        else:
            print("抱歉沒有查到%s的相關信息" % name_find)


def deal_card(find_dict):
    """處理名片"""
    print(find_dict)

1.2.15.6處理名片

1.2.15.6.1增加分支判斷用戶的操作類型

  1. 在tools中對查詢到指定信息後的用戶操作進行一個判斷

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
    # 提示用戶輸入要搜索的姓名
    name_find = input("請輸入要搜索的姓名：")
    # 遍歷名片列表，查詢要搜索的姓名，如果沒有找到需要提示用戶
    for find_temp in card_list:
        if find_temp["name"] == name_find:  # 如果查詢到要搜索的姓名則輸出對應的信息
            print("------搜索到%s的信息------" % name_find)
            for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:  # 打印表頭
                print(card_table_head, end="\t\t")  # \t的數量多少影響空格的大小
            print("")
            print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                find_temp["phone"],
                                                find_temp["email"],
                                                find_temp["qq"]))
            # 針對查找到的信息進行修改和刪除的操作
            deal_card(find_temp)
            break  # 查詢到就結束遍歷
        else:
            print("抱歉沒有查到%s的相關信息" % name_find)


def deal_card(find_dict):
    """處理名片"""
    print("-" * 30)
    # 提示用戶要執行的操作
    action_str = input("輸入數字1修改名片的相關信息，"
                       "輸入數字2刪除所找名片，"
                       "輸入數字0返回上一級，"
                       "請輸入你要執行的操作：")  # 按回車鍵可以將一個字符串分行輸出，使代碼閱讀起來更加清晰
    # 判斷用戶的操作
    if action_str == "1":
        print("修改名片")
    if action_str == "2":
        print("刪除名片")
    # 這裏不需要對輸入0的情況進行判斷，因爲在主函數中的框架下無論用戶輸入什麼內容系統最後都會返回主界面
1.2.15.6.2刪除名片

  1. 在tools程序中執行刪除指定名片的操作

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
    # 提示用戶輸入要搜索的姓名
    name_find = input("請輸入要搜索的姓名：")
    # 遍歷名片列表，查詢要搜索的姓名，如果沒有找到需要提示用戶
    for find_temp in card_list:
        if find_temp["name"] == name_find:  # 如果查詢到要搜索的姓名則輸出對應的信息
            print("------搜索到%s的信息------" % name_find)
            for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:  # 打印表頭
                print(card_table_head, end="\t\t")  # \t的數量多少影響空格的大小
            print("")
            print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                find_temp["phone"],
                                                find_temp["email"],
                                                find_temp["qq"]))
            # 針對查找到的信息進行修改和刪除的操作
            deal_card(find_temp)
            break  # 查詢到就結束遍歷
        else:
            print("抱歉沒有查到%s的相關信息" % name_find)


def deal_card(find_dict):
    """處理名片"""
    print("-" * 30)
    # 提示用戶要執行的操作
    action_str = input("輸入數字1修改名片的相關信息，"
                       "輸入數字2刪除所找名片，"
                       "輸入數字0返回上一級，"
                       "請輸入你要執行的操作：")  # 按回車鍵可以將一個字符串分行輸出，使代碼閱讀起來更加清晰
    # 判斷用戶的操作
    if action_str == "1":
        print("修改名片")
    if action_str == "2":
        card_list.remove(find_dict)  # 使用列表中的remove()方法來刪除列表中指定的元素
        print("刪除名片%s成功" % find_dict["name"])

    # 這裏不需要對輸入0的情況進行判斷，因爲在主函數中的框架下無論用戶輸入什麼內容系統最後都會返回主界面
1.2.15.6.3修改名片

  1. 在tools程序中對要修改的名片進行相關操作，實現用戶輸入來修改名片的相關內容

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
    # 提示用戶輸入要搜索的姓名
    name_find = input("請輸入要搜索的姓名：")
    # 遍歷名片列表，查詢要搜索的姓名，如果沒有找到需要提示用戶
    for find_temp in card_list:
        if find_temp["name"] == name_find:  # 如果查詢到要搜索的姓名則輸出對應的信息
            print("------搜索到%s的信息------" % name_find)
            for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:  # 打印表頭
                print(card_table_head, end="\t\t")  # \t的數量多少影響空格的大小
            print("")
            print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                find_temp["phone"],
                                                find_temp["email"],
                                                find_temp["qq"]))
            # 針對查找到的信息進行修改和刪除的操作
            deal_card(find_temp)
            break  # 查詢到就結束遍歷
        else:
            print("抱歉沒有查到%s的相關信息" % name_find)


def deal_card(find_dict):
    """處理名片"""
    print("-" * 30)
    # 提示用戶要執行的操作
    action_str = input("輸入數字1修改名片的相關信息，"
                       "輸入數字2刪除所找名片，"
                       "輸入數字0返回上一級，"
                       "請輸入你要執行的操作：")  # 按回車鍵可以將一個字符串分行輸出，使代碼閱讀起來更加清晰
    # 判斷用戶的操作
    if action_str == "1":
        find_dict["name"] = input("輸入新名字：")
        find_dict["phone"] = input("輸入新電話：")
        find_dict["email"] = input("輸入新郵件：")
        find_dict["qq"] = input("輸入新QQ：")
        print("修改名片成功")
    if action_str == "2":
        card_list.remove(find_dict)  # 使用列表中的remove()方法來刪除列表中指定的元素
        print("刪除名片%s成功" % find_dict["name"])

    # 這裏不需要對輸入0的情況進行判斷，因爲在主函數中的框架下無論用戶輸入什麼內容系統最後都會返回主界面
1.2.15.6.4修改名片功能升級

  1. 在tools程序中新增一個函數用來實現修改名片的相關操作

    # 記錄所有的名片字典
card_list = []  # 定義一個初始爲空的名片列表


def show_menu():
    """顯示菜單"""
    print("*" * 50)
    print("歡迎使用【名片管理系統】V1.0")
    print("輸入數字1可以新增名片")
    print("輸入數字2可以顯示全部")
    print("輸入數字3可以搜索名片")
    print("輸入數字0可以退出系統")
    print("*" * 50)


def new_card():
    """新增名片"""
    print("新增名片")
    # 1.提示用戶輸入名片的詳細信息
    name_str = input("請輸入姓名：")
    phone_str = input("請輸入電話：")
    email_str = input("請輸入郵箱：")
    qq_str = input("請輸入QQ：")
    # 2.將用戶的輸入信息封裝成一個名片字典
    card_dict = {"name": name_str,
                 "phone": phone_str,
                 "email": email_str,
                 "qq": qq_str}
    # 3.將名片字典添加到名片列表中
    card_list.append(card_dict)
    print(card_list)
    # 4.提示用戶添加成功
    print("添加%s的名片成功" % name_str)


def show_all():
    """顯示所有名片"""
    print("顯示所有名片")
    # 判斷列表中是否有值，當列表爲空時輸出提示同時不輸出其它任何信息
    if len(card_list) == 0:
        print("當前列表中沒有任何名片記錄")
        return  # 在函數中return關鍵字如果不添加任何內容表示該函數中return後面的內容都不會執行
    # 打印表頭
    for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:
        print(card_table_head,end="\t\t")  # \t的數量多少影響空格的大小
    print("")  # 輸出一個空字符保證表頭部分輸出完畢後換行
    # 遍歷顯示列表中所有名片的字典信息
    for card_dict_temp in card_list:
        print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                            card_dict_temp["phone"],
                                            card_dict_temp["email"],
                                            card_dict_temp["qq"]))



def search_card():
    """搜索名片"""
    print("搜索名片")
    # 提示用戶輸入要搜索的姓名
    name_find = input("請輸入要搜索的姓名：")
    # 遍歷名片列表，查詢要搜索的姓名，如果沒有找到需要提示用戶
    for find_temp in card_list:
        if find_temp["name"] == name_find:  # 如果查詢到要搜索的姓名則輸出對應的信息
            print("------搜索到%s的信息------" % name_find)
            for card_table_head in ["姓名", "電話", "郵箱", "QQ"]:  # 打印表頭
                print(card_table_head, end="\t\t")  # \t的數量多少影響空格的大小
            print("")
            print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                find_temp["phone"],
                                                find_temp["email"],
                                                find_temp["qq"]))
            # 針對查找到的信息進行修改和刪除的操作
            deal_card(find_temp)
            break  # 查詢到就結束遍歷
        else:
            print("抱歉沒有查到%s的相關信息" % name_find)


def deal_card(find_dict):
    """處理名片"""
    print("-" * 30)
    # 提示用戶要執行的操作
    action_str = input("輸入數字1修改名片的相關信息，"
                       "輸入數字2刪除所找名片，"
                       "輸入數字0返回上一級，"
                       "請輸入你要執行的操作：")  # 按回車鍵可以將一個字符串分行輸出，使代碼閱讀起來更加清晰
    # 判斷用戶的操作
    if action_str == "1":  # 修改名片的相關信息
        find_dict["name"] = input_card_info(find_dict["name"],"輸入新名字(直接按回車鍵可以不修改)：")
        find_dict["phone"] = input_card_info(find_dict["phone"],"輸入新電話(直接按回車鍵可以不修改)：")
        find_dict["email"] = input_card_info(find_dict["email"],"輸入新郵件(直接按回車鍵可以不修改)：")
        find_dict["qq"] = input_card_info(find_dict["qq"],"輸入新QQ(直接按回車鍵可以不修改)：")
        print("修改名片成功")
    if action_str == "2":  # 刪除相關的名片
        card_list.remove(find_dict)  # 使用列表中的remove()方法來刪除列表中指定的元素
        print("刪除名片%s成功" % find_dict["name"])

    # 這裏不需要對輸入0的情況進行判斷，因爲在主函數中的框架下無論用戶輸入什麼內容系統最後都會返回主界面


def input_card_info(dict_value, tip_message):
    """函數用來實現刪除名片的操作

    :param dict_value: 參數傳入的是原先字典中的值，用來實現不修改相關內容時可以輸出原有的值
    :param tip_message: 傳入提示用戶修改的信息，實現修改名片的操作
    :return: 如果修改就返回修改後的值如果沒有修改就返回原先的值
    """
    # 1.提示用戶輸入內容
    result_str = input(tip_message)
    # 2.針對用戶的輸入進行判斷，如果用戶輸入了內容，直接返回結果
    if len(result_str) > 0:
        return result_str
    # 3.如果用戶不輸入內容，返回字典中原有的值
    else:
        return dict_value

1.2.15.7執行程序

  1. 在終端下執行python程序的兩種方式
    • 第一種：直接在python終端下通過python3+代碼源程序執行
    • 第二種：在要執行的python主程序代碼下的第一行輸入#! python3編輯器的位置(在終端中通過which python3來查找python3的位置)

1.2.15.8管理系統總結

1.2.15.8.1系統搭建步驟
  1. 確定系統的主界面(畫出界面圖)
  2. 確定要寫幾個程序(一般至少有兩個程序，一個主程序負責運行和主界面的設置，一個功能程序負責主界面中相關功能的實現)並創建這些程序
  3. 在主函數對主界面進行代碼編寫，其具體實現部分用pass代替，然後運行代碼保證程序能夠正常運行
  4. 在功能程序中對相關的功能進行完整編寫，每實現一個功能在主函數中調用相關函數對代碼進行測試來保證代碼能夠正常運行
  5. 最後進行總體測試和功能完善

1.2.16變量的引用以及是否可變

1.2.16.1變量的引用

  1. 變量和數據是分開存儲的，變量和數據都是保存在內存中的，數據是保存在內存中的一個位置而變量是保存着數據在內存中的位置，變量中記錄着數據在內存中的地址這就叫引用

  2. 使用id()函數可以查看變量中保存數據的地址,在計算機中地址的本質就是一個數字

  3. 在內存中對於不可變的類型數據而言同一個數據只會有一個內存給它，不會用兩個內存來保存兩個同樣的數據，即同樣的數據其內存地址是唯一的；但對於可變類型的數據而言就不存在唯一性

    a = 1
id(a)
b = 1
id(b)
a = [1,2,3]
id(a)
b = [1,2,3]
id(b)

  4. 在函數中實參向形參傳遞的是數據的內存地址

  5. 函數的返回值返回的也是數據的內存地址

1.2.16.2可變類型和不可變類型

  1. 不可變類型中的數據一旦在內存中被開發和定義後就無法修改，而可變類型的數據可以修改內存中的數據而不更改數據在內存中的地址，可以通過相關的方法來修改內存中的數據
  2. 可變類型：列表、字典
  3. 不可變類型：數字類型(類似int,float等)、字符串、元祖

1.2.16.3哈希(hash)

  1. python中有一個內置的函數hash()，接受一個不可變類型作爲一個參數，返回結果是一個整數(一般返回的是參數的內存位置)
  2. 哈希是一種算法，其作用是提取數據的特徵碼(指紋)：相同的內容得到相同的結果，不同的內容得到不同的結果
  3. 在python中，設置字典的鍵值對時會首先對key進行hash已決定如何在內存中保存字典的數據以便後期的增刪改查

1.2.17局部變量和全局變量

1.2.17.1基本概念

  1. 局部變量是在函數內部定義的變量，只能在函數內部使用
  2. 全局變量是在函數外部定義的變量，所有的函數都可以使用這個變量
  3. 提示：在其它開發語言中，不建議使用全局變量，因爲可變範圍太大導致程序不好維護

1.2.17.2局部變量

  1. 局部變量的生命週期：在函數執行時局部變量被定義，當函數執行完畢後局部變量的生命週期結束，內存被回收
  2. 在不同函數的內部可以定義相同的局部變量

1.2.17.3全局變量

  1. pycharm中當調試一個程序時，frames欄中會顯示當前正在執行的程序是哪一個模塊(函數)以及當前正在執行第幾行(一般在函數外執行會顯示一個模塊，模塊名就是程序名，在函數內執行會顯示函數名)，在frames欄中可以通過切換函數和模塊然後點擊variables來查看函數和模塊內部的內存使用情況(變量的定義情況)，variables欄中會顯示當前模塊(函數)中的內存分配情況(就是變量的定義情況)

  2. 在函數內部賦值語句不能修改全局變量的值：函數內部對全局變量的相關操作是在函數內部又重新定義了一個和全局變量同名的局部變量，所有的操作都是對該局部變量進行操作和全局變量沒有任何關係，局部變量只會在函數內部實用，當函數執行完畢後局部變量生命週期結束

  3. 在函數內部進行變量的相關操作時，系統會先在函數內部查找是否有相關的變量，如果有就使用該變量來進行相關的操作，如果沒有就在函數外部來進行查找使用

  4. global關鍵字修改全局變量(在函數內部修改)：

    def demo_1():
    global num  # global關鍵字會告訴解釋器後面的變量是全局變量，可以在函數內部修改全局變量的值
    num = 2
    print(num)


def demo_2():
    print(num)
    print(num_1)


num = 1
num_1 = 2
demo_1()
demo_2()

  5. 在實際開發過程中，將所有的全局變量都定義到函數的上方，防止函數在執行時會回出現全局變量未定義的錯誤(當全局變量定義在執行函數的下方而函數內部要調用該全局變量)

  6. 當局部變量和全局變量同名時，在局部變量的下方pycharm會顯示一個灰色的波浪線，當將鼠標移動到上方時會顯示一句話：shadows name *** from outer scope，表明該局部變量有一個同名的全局變量，在實際開發中在全局變量前面加一個前綴g_或者gl__來強調這是一個全局變量

    gl_num = 1  # 表明這是一個全局變量


def test():
    num = 2  # 表明這是一個局部變量
    print(num)
    print(gl_num)
    
    
test()

1.2.18函數的返回值和參數進階

1.2.18.1函數參數和返回值的作用

  1. 當外界希望在函數內部處理數據時可以通過參數向函數內部傳遞要處理的數據，一般在實際開發中，如果函數內部處理的數據不確定時就可以通過參數的形式將外界的數據傳遞到函數內部來進行處理
  2. 函數通過返回值向外界傳遞函數的執行結果，在實際開發中，如果希望一個函數執行完畢後向外界輸出一個執行結果則需要設置返回值

1.2.18.2函數的返回值

1.2.18.2.1利用元祖返回多個值
def measure():
    temp_01 = 1
    temp_02 = 2
    """
    在python中通過返回一個數組可以實現返回多個返回值，其中python返回一個元祖時不需要寫括號，如果寫括號python系統會提示不符合規則但不會報錯，需要知道當看見返回值是多個值時就要知道這是一個元祖
    """
    return temp_01, temp_02  


gl_temp = measure()
print(gl_temp)
1.2.18.2.2接受返回元祖函數的方式

  1. 使用多個變量來接受函數的多個返回值

    def measure():
    temp_01 = 1
    temp_02 = 2
    """
    在python中通過返回一個數組可以實現返回多個返回值，其中python返回一個元祖時不需要寫括號，
    如果寫括號python系統會提示不符合規則但不會報錯，需要知道當看見返回值是多個值時就要知道這
    是一個元祖
    """
    return temp_01, temp_02


# 使用多個變量來接受函數的多個返回值，其中變量的個數要和函數的返回值個數相同，其中變量分別對應每個返回值
gl_temp_01, gl_temp_02 = measure()
print(gl_temp_01)
1.2.18.2.3交換兩個變量的值(不使用其它變量：面試題)

  1. 解法1(常規解法)：

    a = 6
b = 100
# 解法1：常規解法
a = a + b
b = a - b
a = a - b
print(a)
print(b)

  2. 解法2(python獨特解法：用元祖實現變量的交換)：

    a = 6
b = 100
# 解法2：python中使用元祖來交換兩個變量的值
a, b = b, a  # 右邊省略了括號，其實是一個元祖，左邊用兩個變量來接受元祖中的兩個值
print(a)
print(b)

1.2.18.3函數的參數

1.2.18.3.1在函數內部使用方法修改可變參數會影響外部實參
gl_temp_list = [1, 2, 3]


def temp_list(temp_list):
    temp_list.append(4)


temp_list(gl_temp_list)
print(gl_temp_list)
"""
起初定義的gl_temp_list變量指向列表[1, 2, 3]的位置，調用temp_list函數後將gl_temp_list變量指向的位置
傳遞給形式參數temp_list，則變量temp_list指向列表[1, 2, 3]的位置，然後使用temp_list.append(4)方法
向列表[1, 2, 3]末尾添加一個數字4則原列表變爲[1, 2, 3, 4]，而此時gl_temp_list變量指向的是該列表的位置，
因此輸出gl_temp_list會得到[1, 2, 3, 4]，即原列表的數據被修改了
"""
1.2.18.3.2在函數內部對形參賦值不會影響外部實參
gl_temp_list = [1, 2, 3]


def temp_list(temp_list):
    temp_list = [1, 2, 3, 4]


temp_list(gl_temp_list)
print(gl_temp_list)
"""
起初定義的gl_temp_list變量指向列表[1, 2, 3]的位置，調用temp_list函數後將gl_temp_list變量指向的位置
傳遞給形式參數temp_list，則變量temp_list指向列表[1, 2, 3]的位置，然後使用temp_list = [1, 2, 3, 4]
對變量temp_list進行新的賦值則temp_list變量斷開與列表[1, 2, 3]的指向而指向新的列表[1, 2, 3, 4]，
此時gl_temp_list變量指向的是原先列表[1, 2, 3]的位置，
因此輸出gl_temp_list會得到[1, 2, 3]，即原列表的數據沒有被修改了
"""
1.2.18.3.3列表使用+=本質上是調用extend()方法

  1. 面試題：+=

    gl_temp_list = [1, 2, 3]


def temp_list(temp_list_temp):
    temp_list_temp += temp_list_temp  # +=在列表中的功能就相當於extend()函數，用於向一個列表末尾添加一個新的列表


temp_list(gl_temp_list)
print(gl_temp_list)  # 由於對可變參數使用來方法，因此外部變量會受影響

1.2.18.4缺省參數

1.2.18.4.1缺省參數對概念和作用

  1. 定義函數時，可以給某個參數指定一個默認的值，具有默認值的參數就是缺省參數

  2. 調用函數時，如果沒有傳入缺省參數的值，則在函數內默認使用定義函數時使用的參數默認值

  3. 將常見的值設置爲函數的缺省參數，從而簡化函數的調用(在日常開發中，通常將參數使用最多的值設置爲該參數的值以便簡便使用該參宿而不需要再次傳遞參數)

    gl_temp_list = [1, 3, 2]


def temp_list(temp_list_temp):
    # sort()方法沒有返回值
    temp_list_temp.sort()  # 這裏的參數reverse就是缺省參數，系統默認的值爲False，所有可以不寫表示默認
    list_01 = temp_list_temp
    print(list_01)
    temp_list_temp.sort(reverse=True)
    list_02 = temp_list_temp
    return list_02


a = temp_list(gl_temp_list)
print(a)
1.2.18.4.2指定缺省參數的默認值
def temp(name, gender=True):  # 指定缺省參數的默認值爲True，一般指定缺省參數的的默認值都是以True和False來指定
    if not gender:  # 只有if後面爲真時才運行後面的程序
        print("%s是%s" % (name, "女生"))
    else:
        print("%s是%s" % (name, "男生"))



temp("yfx")  # 默認使用缺省參數值爲True
temp("lm", gender=False)  # 指定缺省參數值爲False
1.2.18.4.3缺省參數定義的注意事項
  1. 缺省參數定義必須在函數參數的末尾，也就是說缺省參數後面不能定義非缺省參數
  2. 在pycharm中如何快速爲新增加的函數參數添加註釋說明：將鼠標移動至新增的參數上，然後點擊出現的小燈泡，選擇add docstring parameter **就可以快速添加參數註釋

1.2.18.5多值參數

1.2.18.5.1定義和作用

  1. 有時可能需要一個函數能夠處理的參數時不確定的，這個時候就可以使用多值參數

  2. python中有兩種多值參數

    • 參數名前增加一個*可以接受元祖
    • 參數名前增加兩個*可以接受字典

  3. 一般在給多值參數命名時，習慣使用以下兩個名字

    • *args：存放元祖參數(arguments：有變量的含義)
    • **kwargs：存放字典參數(keyword arguments：鍵值對參數)

  4. 代碼演練

    def demo(num, *args, **kwargs):
    print(num)
    print(args)
    print(kwargs)

# 這裏可以輸入任意個參數，其中1會被自動傳給num,234會被當作元祖中的元素傳遞給args,後面的內容會被傳遞給字典
demo(1,2,3,4,name="yfx",age=18)
1.2.18.5.2元祖和字典的拆包

  1. 在調用帶有多值參數的函數時，如果希望將一個元祖變量直接傳遞給args或者將一個字典變量直接傳遞給kwargs就可以使用拆包，用來簡化參數的傳遞

  2. 拆包的方式：

    • 在元祖變量前增加一個*
    • 在字典變量前增加兩個*

  3. 代碼演練

    tuple_temp = (1, 2, 3)
dict_temp = {"name":"yfx",
             "age":18}


def demo(*args, **kwargs):
    print(args)
    print(kwargs)


# demo(tuple_temp,dict_temp)  # 這樣系統會將tuple_temp和dict_temp都傳遞給args，不會傳遞給kwargs
demo(*tuple_temp,**dict_temp)  # 這樣系統會將tuple_temp傳遞給args，將dict_temp傳遞給kwargs
# demo(1, 2, 3, name="yfx", age=18)
"""
拆包就是將元祖或者字典中都元素拆分開，*tuple_temp拆包後的效果就是1, 2, 3；
**dict_temp拆包後的效果就是name="yfx", age=18
"""

1.2.18.6遞歸

1.2.18.6.1遞歸的特點

  1. 函數調用自身就稱爲遞歸(在函數內部自己調用自己)

  2. 遞歸函數必須有一個出口，否則會出現死循環(就是對參數進行判斷，當參數滿足某個條件時不再執行函數)

  3. 代碼演練

    def number(num):
    print(num)
    # 遞歸的出口
    if num == 1:
        return
    # 自己調用自己
    number(num - 1)  # 在該處打一個斷點可以觀察到遞歸函數的執行情況
    print("test")
    “”“
    遞歸函數執行時會不斷深入進行函數調用，也就是說會不斷執行內部的函數，當執行到最內層函數時會遇到遞歸的出口，然後一層一層往上執行直到第一層函數執行完畢
    ”“”

number(3)
1.2.18.6.2遞歸實現數字累加
# 定義一個函數sum_numbers
# 能夠接受一個num的整數參數
# 計算1+2+3+……+num的結果
def sum_numbers(num):
    # 出口
    if num == 1:
        return 1
    # 數字的累加：num+(1+2+3+……+num-1)
    temp = sum_numbers(num - 1)  # temp用來接受遞歸函數的返回值
    return num + temp


result = sum_numbers(7)
print(result)
"""
思路分析：
1.確定函數的出口：這裏爲遞歸到1時出來
2.確定遞歸的參數：這裏遞歸的是要求和的參數
2.確定每層函數的返回值：每層函數返回每層的遞歸參數和之前所有曾遞歸函數的返回值的和
3.進入到最底層函數然後慢慢往上進行代碼的書寫和判斷

"""
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

第六階段：多任務

2.2多任務 2.2.1線程 2.2.1.1多任務介紹 相關概念介紹 對於一個計算機而言，一個cpu一次只可以運行一個任務，對於單核的cpu的計算機而言，當有多個任務需要運行時，必須先執行一個任務，只有該任務停止後才能執行另

DedicationYu 2020-06-21 22:05:41

第四階段：飛機大戰項目實戰

1.4項目飛機大戰 1.4.1項目準備 1.4.1.1確定模塊pygame是否安裝成功 安裝pygame模塊時要注意python的版本是否有對應的pygame版本 https://pypi.org/project/pygam

DedicationYu 2020-06-21 22:05:36

第三階段：面向對象

1.3面向對象 1.3.1面向對象基礎 1.3.1.1面向對象 1.3.1.1.1基本概念 過程和函數 過程類似於函數，只能執行，但是沒有返回值 函數不僅能執行而且有返回結果 簡單來說，面向對象就是相對於函數而言更大的封裝

DedicationYu 2020-06-21 22:05:36

第一階段：Linux基礎

1.1Linux基礎 1.1.1課程簡介 python體驗和勵志公式 在Linux終端下直接輸入python會顯示電腦中python的版本，同時進入python的編輯環境 代碼演示 # 每天進步0.01，堅持365天后

DedicationYu 2020-06-21 22:05:36

第五階段：網絡編程

2.1網絡編程 2.1.1基本概念 2.1.1.1查看IP地址 Ubuntu下查看IP地址及相關操作 關閉網卡：sudo ifconfig 網卡名 down 快捷鍵操作：ctrl+a：快速回到行首；ctrl+e：快速回到行尾

DedicationYu 2020-06-21 21:32:42

第六階段：多任務

2.2多任務 2.2.1線程 2.2.1.1多任務介紹 相關概念介紹 對於一個計算機而言，一個cpu一次只可以運行一個任務，對於單核的cpu的計算機而言，當有多個任務需要運行時，必須先執行一個任務，只有該任務停止後才能執行另

DedicationYu 2020-06-21 22:05:41

第四階段：飛機大戰項目實戰

1.4項目飛機大戰 1.4.1項目準備 1.4.1.1確定模塊pygame是否安裝成功 安裝pygame模塊時要注意python的版本是否有對應的pygame版本 https://pypi.org/project/pygam

DedicationYu 2020-06-21 22:05:36

第三階段：面向對象

1.3面向對象 1.3.1面向對象基礎 1.3.1.1面向對象 1.3.1.1.1基本概念 過程和函數 過程類似於函數，只能執行，但是沒有返回值 函數不僅能執行而且有返回結果 簡單來說，面向對象就是相對於函數而言更大的封裝

DedicationYu 2020-06-21 22:05:36

第一階段：Linux基礎

1.1Linux基礎 1.1.1課程簡介 python體驗和勵志公式 在Linux終端下直接輸入python會顯示電腦中python的版本，同時進入python的編輯環境 代碼演示 # 每天進步0.01，堅持365天后

DedicationYu 2020-06-21 22:05:36

第五階段：網絡編程

2.1網絡編程 2.1.1基本概念 2.1.1.1查看IP地址 Ubuntu下查看IP地址及相關操作 關閉網卡：sudo ifconfig 網卡名 down 快捷鍵操作：ctrl+a：快速回到行首；ctrl+e：快速回到行尾

DedicationYu 2020-06-21 21:32:42