資源簡介

2023屆新教材新選考一輪復習
信息技術
知識梳理
班級：_________ 姓名：_________
目 錄
必修基本概念 —————————————————————— 1
必修一 ————————————————————————————————————— 1
必修二 ————————————————————————————————————— 6
必修算法程序 —————————————————————— 16
Python基礎算法 ————————————————————————————— 16
Python常見程序 ————————————————————————————— 23
Pandas數據處理 ————————————————————————————— 30
Flask數據庫 ————————————————————————————— 40
SQLite數據庫 ————————————————————————————— 46
選擇性必修第一冊 —————————————————— 50
數組 —————————————————————————————————— 50
鏈表 —————————————————————————————————— 53
字符串 —————————————————————————————————— 59
隊列與棧 —————————————————————————————————— 63
樹與二叉樹 —————————————————————————————————— 69
迭代與遞歸 —————————————————————————————————— 73
排序算法 —————————————————————————————————— 75
查找算法 —————————————————————————————————— 85
必修基本概念
必修一
一、數據與信息
1. 數據是對客觀事物的符號表示，在計算機科學中，數據是指所有能輸入到計算機并被計算機程序處理的符號總稱，其表現形式可以是文字(數字)、圖形、圖像、音頻、視頻等。
2. 信息的一般定義是數據所包含的意義。在信息論中，香農給出的定義是用來消除隨機不確定的東西。
3. 信息的特征：
(1)載體依附性：即信息必須依附于載體存在，不存沒有載體的信息。
(2)時效性：信息(的內容或價值)會隨著時間的推移發生變化。
(3)共享性：信息可以共享，且在傳播的過程中不產生損耗。
(4)可加工處理性、真偽性：信息是可以進行加工的，加工后的信息具有真偽性。
(5)價值性：信息的價值包括顯性價值和隱形價值兩個方面，同時價值的高低具有相對性。
二、數字化
1. 數字化的定義：將模擬信號轉換為數字信號的過程稱為數字化。其中用到的主要設備是模數轉換器(ADC)。
2. 模擬量：模擬信號以連續變化的物理量存在，自然界中大多數信號都以模擬量形式存在。
3. 數字量：數字信號在取值上是離散的、不連續的信號。
4. 將模擬信號轉換成數字信號一般需要經過采樣、量化與編碼三個步驟。
(1)采樣的參數是采樣頻率，單位是赫茲(Hz)。根據采樣定理：當采樣頻率大于或等于被采樣信號最高頻率的兩倍時，得到的離散信號可以完整的保留原始信號的所有信息。
(2)量化指將信號的連續取值近似為有限個離散值的過程。量化主要參數是量化位數，單位是比特(bit)；量化位數越多，劃分的越精細，量化結果與實際數據也越接近。
三、數制
1.數據在計算機內部是以二進制的方式存儲和處理的。除了二進制(B)和十進制(D)，常用的還有八進制(O)和十六進制(H)。
2.進制轉換
(1)二進制轉十進制：基權相乘再相加
（110）2 = 1*22+1*21+0*20 =（6）10
(2)十進制轉二進制：除2取倒余
（173）10 = （10101101）2
(3)十六進制轉二進制： 1位轉4位 (4)二進制轉十六進制：4位轉1位
四、字符編碼
1. ASCII碼（美國信息交換標準代碼，半角字符）：主要用于顯示現代英語和其他西歐語言，屬于機內碼；編碼范圍：00H—7FH；常用字符內碼：字符“0”=48D=30H，字符“A”=65D=41H，字符“a”=97D=61H。
2. GB2312（國標碼，全角字符）：計算機中處理漢字需要經過外碼(輸入碼)，交換碼，機內碼和字形碼多種編碼過程。其中GB2312屬于交換碼，用兩個字節表示一個漢字。GB2312中對英文字符和標點符號也進行了重新編碼，在做題時需要根據具體情況確定其使用的編碼類型。
五、圖形編碼
1. 條形碼：常見的條形碼是由反差率相差很大的黑條和白條排成的平行圖案。我國普遍采用的條形碼是EAN13條形碼
2. 二維碼：用某種特定的幾何圖形按一定規律在平面上分布黑白相間的圖形記錄數據符號信息。相對條形碼，二維碼存儲信息量更大。
3. 對條形碼和二維碼的識別過程中雖然用到了攝像頭，但信息是直接從圖形編碼中獲取的，所以不涉及數字化的過程。
六、多媒體編碼
1. 容量單位換算：1Byte=8bit；1KB=1024B；1MB=1024KB；1GB=1024MB；1TB=1024GB
2. 圖像編碼
(1)矢量圖：基于數據方程的幾何元素描述的圖像，特點是放大不失真。
(2)未壓縮BMP格式圖像的容量計算公式：水平像素*垂直像素*顏色位深度(bit)/8
(3)常見顏色格式：RGB/8=全彩色=24位；256色圖=256階灰度=8位；黑白圖像=1位。
(4)常見圖像格式：
.bmp(未壓縮)；.jpg(靜態圖像有損壓縮)；.png(有透明像素)；
.gif(可將多張圖片壓縮進一個文件中，最多支持256種顏色)
3. 音頻編碼
(1)未壓縮Wave格式容量計算公式：采樣頻率(Hz)*量化位數(bit)*聲道數*時間(s)/8
(2)常見格式：.wav(未壓縮)；.mp3(有損壓縮)；.wma(微軟音頻)
4. 視頻編碼
(1)PAL制式每秒25幀，NTSC制式每秒30幀。
(2)未壓縮avi格式視頻容量計算公式：每張圖像容量*幀數*時間(s)
(3)常見視頻格式：.avi(可以未壓縮，也可壓縮)；.mp4(有損壓縮)；.mov(蘋果)
七、數據保存與數據安全
1. 計算機數據的管理已經經歷了人工管理、文件管理、數據庫管理三個階段。
2. 結構化、半結構化、非結構化數據
(1)結構化數據：也成為行數據，可以由二維表來進行邏輯表達和實現的數據
(2)非結構化數據：數據結構不規范，不完整，無法用二維表來進行邏輯呈現。
(3)半結構化數據：介于結構化和非結構化之間，具有一定的結構性
3. 通過保護介質實現數據安全的方法：磁盤陣列、數據備份、異地容災
4. 通過加密數據實現數據安全的方法：凱撒加密、換位密碼、簡單異或
5. 通過數據校驗保證數據完整的方法：MD5、CRC（奇偶校驗）、SHA-1
八、數據處理
1. 常見的數據問題及其處理方法：
(1)數據缺失：數據集中普遍存在的問題，一般可能是數據丟失或數據本身不完整
處理方法：忽略或采用平均值、中間值或概率統計值填充。
(2)數據重復：在多數據源合并時經常出現，導致資源冗余和浪費。
處理方法：進一步審核的基礎上進行合并或刪除。
(3)異常數據：數據集中的某些數據不符合一般規律，例:健康系統顯示體溫到達50攝氏度。
處理方法:這些有可能是要去掉的噪聲，也有可能是含有重要信息的數據對象。
(4)邏輯錯誤：屬性與實際不符，違背業務規則或邏輯，例:某人的生日為13月40日
處理方法：對應的字段需要設置取值范圍判斷。
(5)格式不一致：多出現在數據來源多樣的系統中
處理方法：將不同格式的數據轉換成統一格式后再進行處理。
2. 常用的數據處理和統計分析工具有Excel、SPSS、SAS、MATLAB等軟件，也可以通過R、Python、Java等計算機語言編程進行數據處理。
3. 常見的圖表類型有：柱形圖、折線圖、餅圖、雷達圖、散點圖、氣泡圖等。
九、大數據
1. 大數據的特征
(1)數據體量大 (2)速度快：包括產生速度和處理速度。
(3)數據類型多 (4)價值密度低
2. 大數據思維
(1)大數據分析全體數據而不是抽樣數據
(2)對數據不再追求精確性
(3)不強調因果性而強調相關性。
十、大數據處理
1. 大數據處理的基本思想：“分治思想”，即將一個復雜的問題拆分成兩個或多個相同或相似的子問題，找到求這幾個問題的解法之后，再找出合適的方法把它們組合成求整個問題的解法。
2. 大數據處理的數據類型：
(1)靜態數據：在處理時已經收集完成、在計算時不會發生改變的數據
處理方法：批處理
(2)流數據：不間斷地、持續地到達的實時數據。流數據的價值會隨著時間的流逝降低。
處理方法：流計算或實時分析計算
(3)圖數據：現實世界中以圖形式展現的數據。如社交網絡、道路交通等
處理方法：圖計算
3. 批處理
Hadoop是一個可運行于大規模計算機集群上的分布式系統基礎架構，適用于靜態數據的批量計算。Hadoop計算平臺主要包括Common公共庫、分布式文件系統HDFS、分布式數據庫HBase、分布式并行計算模型MapReduce等多個模塊。
(1)分布式文件系統(HDFS)：將大規模海量數據以文件的形式、用多個副本保存在不同的存儲節點中，并用分布式系統管理。HDFS是一個高度容錯性的文件系統，云盤、網盤的底層一般采用HDFS實現。
(2)分布式數據庫(HBase)：HBase建立在HDFS提供的底層存儲基礎上，采用基于列的存儲方式，主要存儲非結構化和半結構化的數據，具有良好的橫向擴展能力。
(3)分布式并行計算模型(MapReduce)：MapReduce是一種分布式并行編程模型，能夠進行大規模的并行計算。其核心處理思想是將任務分解并分發到多個節點上進行并行處理，最后匯總輸出。
4. 流計算
流計算主要用于處理流數據，如大型購物網絡的廣告推薦、社交網絡的個性化推薦等。處理流數據的軟件主要有Twitter Storm、Heron、Yahoo!S4等。Storm和S4是目前較為流行的開源分布式實時計算系統。
5. 圖計算
現實世界中的很多數據以圖的形式呈現，或者是需要轉換為圖后才能分析。目前圖處理的軟件主要分為兩類：圖數據庫和并行圖處理系統。
十一、文本數據處理
1. 文本數據處理主要應用在搜索引擎、情報分析、自動摘要、自動校對、論文查重、文本分類、垃圾郵件過濾、機器翻譯、自動應答等方面。
2. 典型的文本處理過程主要包括分詞、特征提取、數據分析、結果呈現等。
3. 中文分詞方法
(1)基于詞典的分詞方法：用詞典中的詞語進行比對。案例：Python中的jieba庫
(2)基于統計的分詞方法：根據上下文相鄰字出現的頻率統計。
(3)基于規則的分詞方法：根據現有資料和規律學習實現分詞。
4. 特征提取方法
(1)根據專家知識挑選有價值的特征。(約等于人工分析)
(2)用數學建模的方法構造評估函數自動選取特征。(目前大多采用)
5. 結果呈現方式：
(1)標簽云：用文字大小形式表現詞語的重要性
(2)文本情感分析：根據分析顆粒度可以分為詞語級、語句級、整篇文章級三類。
十二、數據可視化
1. 數據可視化是將數據以圖形、圖像等形式表示、直接呈現數據中蘊含信息的處理過程。
2. 可視化的作用：快速觀察與追蹤數據、實時分析數據、增強數據的解釋力和吸引力等。
3. 可視化的基本方法
(1)有關時間趨勢的可視化：展示隨時間的推移而變化的數據，可采用柱形圖、折線圖等。
(2)有關比例的可視化：展示各部分的大小及其占總體比例關系的數據，可以采用餅圖、環形圖(也稱面包圈圖)等。
(3)有關關系的可視化：探究具有關聯性數據的分布關系，可以使用散點圖、氣泡圖等。
(4)有關差異的可視化：包含多種變量的對象與同類之間的差異和聯系，可以采用雷達圖。
(5)有關空間關系的可視化：地理數據或者基于地理數據的分析結果可以運用不同顏色或圖表直接在地圖上進行展示。
十三、大數據的典型應用
1. 大數據應用領域：隨著大數據在各行業的應用，數據成為核心資產。目前，大數據廣泛應用于金融、交通、環境、醫療、能源、農業等領域，極大地促進了各行業的發展。
2. 大數據在電子商務方面的應用；精準營銷基于用戶購買行為挖掘用戶偏好；倉儲管理實現商品自動補貨；供應鏈管理實現最優配送路徑；智能網站分析用戶后向用戶智能推薦商品。
十四、人工智能
1. 人工智能的概念：人工智能是指以機器(計算機)為載體，模仿、延伸和擴展人類智能、其與人類或其他動物所呈現的生物智能有著重要區別。
2. 人工智能的主要方法
(1)符號主義：認為學習或者其他的智能特征原則上均可以被符號精確地描述，從而被機器仿真。符號主義方法包含知識庫和推理引擎兩個部分。它先將所有知識以邏輯形式表達，然后依靠推理引擎，去驗證命題或謂語正確與否，或者學習推導出新規則、新知識。
案例：“鴕鳥會飛”、專家系統
(2)聯結主義：通過模仿人類大腦中神經元之間的復雜交互來進行認知推理。多層神經網絡（包含輸入端、隱藏層和輸出端）是一種典型的深度學習模型。
(3)行為主義：認為智能體可以在與環境的交互中不斷學習，從而提升自己的智能水平。
案例：掃地機器人，阿爾法狗
3. 人工智能的應用分類
(1)領域人工智能：依賴于領域知識和數據的人工智能。
(2)跨領域人工智能：智能系統從一個領域快速跨越到另一個領域。
(3)混合增強人工智能：多種智能體的混合形式，他將人的作用或人的認知模型引入人工智能系統，形成“混合增強智能”的形態。需要注意的是，在智能疊加協調的回路中，人類智能是智能回路的開關。
4. 人工智能對社會的影響
(1)人工智能改善人類生活：智能家居、智慧城市、智能出行、智能購物等。
(2)人工智能促進經濟發展：提供虛擬勞動力、提高生產力、加快實體經濟轉型升級。
(3)人工智能帶來的社會擔憂：人工智能取代人類崗位，威脅人類安全。
必修二
一、信息技術及其發展歷史
1. 信息技術的定義：信息技術是指獲取、傳輸、存儲、加工和表達信息的各種技術的總和。
2. 信息技術的發展歷史（劃分依據：信息的輸入、加工、輸出和傳播）
(1)前機械時期：信息被文字存儲下來。
例：楔形文字、甲骨文、希臘字母、羅馬字母
(2)機械時期：信息檢索和加工技術發展。
例：活字印刷術、計算尺、加法器、萊布尼茲計算器
(3)電子機械時期：信息以電子脈沖方式傳輸。
例：電報、電話、收音機
(4)電子化時期：計算機技術的發展。
例：ENIAC誕生
二、信息系統
1. 信息系統的定義:由硬件軟件設施、通信網絡、數據和用戶構成的人機交互系統。
2. 信息系統的組成要素：(1)硬件、(2)軟件、(3)數據、(4)通信網絡、(5)用戶。
3. 信息系統的功能：數據收集和輸入功能、數據存儲功能、數據傳輸功能、數據加工處理功能、數據輸出功能、數據查詢功能。
4. 信息系統的分類：
(1)按信息系統規模分類：簡單系統和復雜系統。其中簡單系統可以是復雜系統的子系統，信息系統的硬件可以共用。
(2)按信息技術發展階段：數據處理系統(初級階段)、管理信息系統(發展階段)、決策信息系統(發展階段)
(3)按應用領域分類：通用信息系統、制造業信息系統、醫療保健信息系統、學校管理信息系統、銀行信息系統、政府信息系統等。
5. 信息系統的優勢
(1)規范工作流程，提高工作效率 (2)跨越時空限制，服務隨時隨處
(3)基于數據分析，支持科學決策 (4)便捷保存數據，利于共享追蹤
6. 信息系統的劣勢
(1)對外部環境有依賴性：受停電或極端天氣的影響
(2)本身有安全隱患：感染病毒、系統本身的漏洞、黑客入侵
(3)技術門檻可能加劇數字鴻溝：不同年齡段、不同地域學習成本不同
三、信息社會
1. 信息社會的基本內涵
(1)信息社會是以人為本的：社會發展必須以人為中心；以人為本才能體現信息社會具有包容性；以人為本才能實現全面發展(人與社會均衡發展)
(2)信息社會是可持續發展的
(3)信息社會是以信息和知識作為重要資源的
2. 信息社會的主要特征包括信息經濟、網絡社會、在線政府、數字生活四個方面。一般用和信息社會指數(ISI)衡量信息社會發展水平。
四、計算機硬件
1. 計算機發展經歷了電子管、晶體管、集成電路、大規模超大規模集成電路四個發展階段。未來計算機逐漸向巨型化(超級計算機)、微型化(民用計算機)、智能化(阿爾法狗)、網絡化(云計算)。
2. 計算機硬件主要由運算器、控制器、存儲器、存儲器、輸入設備和輸出設備五大部件組成。
3. 中央處理器(CPU)
(1)中央處理器是計算機最核心的部件，包括運算器和控制器兩個部分，現代處理器中還包括浮點處理部件(FPU)、內部高速緩沖存儲器(Cache)和存儲管理部件，以加快計算機執行指令的速度。
(2)CPU的性能指標包括：時鐘頻率(主頻)、字長、核心數量和高速緩存(Cache)。
1-時鐘頻率：計算機一般采用CPU的主頻來描述運算速度，主頻越高，運算速度越快。
2-字長：CPU在單位時間內能一次處理的二進制數的位數稱為字長，字長越長，處理 數據的能力越強，現在主流計算機該項參數一般為32位和64位。
3-核心數量：即CPU的內核數量
4-高速緩存：CPU內部存儲區，用于平衡CPU處理速度和內存的讀取速度。一般由多 級構成，即一級緩存、二級緩存等
4. 存儲器
(1)存儲器是計算機中存放程序和數據的地方。按用途可以分為主存(內存)、輔助存儲器(硬盤、U盤)、高速緩存(Cache)。讀寫速度由快到慢分別為：Cache、內存、硬盤、U盤
(2)RAM是隨機存儲器，它的特點是：讀寫速度相對較快、斷電后數據會丟失，一般用來做內存（運存）
(3)ROM是只讀存儲器，它的特點是：斷電后數據依然保留，但數據只能寫入一次，之后只能讀數據。后來它的衍生版本EEPROM成為現在外存(硬盤或手機存儲)的主要材料。
(4)內存的主要參數有：版本(DDR)、容量、電壓(標壓或低壓)
(5)硬盤主要有機械硬盤(HDD)和固態硬盤(SSD)兩種。相比HDD，SSD具有快速讀寫、重量輕、能耗低等特點。
(6)閃存盤(U盤)是閃存(flash)做為存儲介質，通常采用USB接口，即插即用。
5. 輸入輸出設備
(1)輸入設備：將程序和數據以機器能夠識別和接受的形式輸入計算機。
(2)輸出設備：將計算機的出理解結果以人們能接受的信息形式進行輸出。
(3)部分設備可以兼具輸入輸出功能，例如網卡（計算機與網線的連接）、聲卡（模擬和數字信號轉換）、光驅（光盤數據的讀取和刻錄）。
6. 計算機工作原理
(1)計算機處理信息主要包括：輸入、處理(運算和控制)、存儲、和輸出四個步驟。
(2)“存儲程序式”（馮·諾依曼式）體系結構
五、計算機軟件
計算機軟件可以分為系統軟件和應用軟件兩大類
1. 系統軟件包含三類：操作系統、數據庫軟件、編程語言。常見的操作系統有Windows(微軟)、Mac OS(蘋果)、Linux(開源免費)和UNIX。
2. 應用軟件：利用計算機的軟、硬件資源為解決某一應用領域的某個實際問題而專門開發的軟件。
六、移動終端
1. 移動終端也叫移動通信終端，是指可以在移動中使用的計算機設備。例：手機、平板、筆記本電腦等。
2. 移動終端的處理器是整個移動終端的控制核心。常見的處理器有蘋果、三星、高通(Qualcomm)、英特爾(Inter)、英偉達(Nvidia)、聯發科(MTK)等。麒麟(華為)是我國首款國產移動終端中央處理器。
3. X86架構(計算機處理器)和ARM(移動終端處理器)架構：
X86架構：使用標準指令集、效率一般、性能優越、擴展性強、功耗高
ARM架構：使用精簡指令集、效率高、性能一般、“夠用就好”、功耗低
4. 移動終端常見的操作系統：Android(基于Linux)、iOS(蘋果)、Windows、HarmonyOS(鴻蒙OS/華為)等。擴展知識：常見安卓手機操作系統有：MIUI(小米)、MagicUI(榮耀)、ColorOS(oppo)、OriginOS(vivo)等。
5. 移動終端上的常見傳感器及其功能
(1)光線傳感器：自動調節屏幕背光的亮度；
(2)距離傳感器：檢測手機是否貼在耳朵上打電話,以便自動調暗屏幕；
(3)重力傳感器：手機橫豎屏智能切換、拍照照片朝向轉換；
(4)加速度傳感器：計步、檢測睡眠；
(5)指紋傳感器：加密、解鎖、電子支付；
(6)霍爾傳感器：翻蓋自動解鎖、合蓋自動鎖屏；
(7)磁場傳感器：電子指南針、電子金屬探測器；
(8)光學心率傳感器：檢測用戶心率；
(9)皮電反應傳感器：檢測用戶的運動狀態；
七、傳感與控制
1. 現代信息系統的三大支柱：傳感器技術、通信技術、計算機技術。
2. 傳感器：能感受被測量并按照一定的規律轉換成可用輸出信號的器件或裝置，通常由敏感元件和轉換元件組成。
3. 傳感器與信息系統的連接
4. 串口：串行通信總線的簡稱。數據在串口上串行傳輸時，要求發送端和接收端必須設置相同的波特率，否則將無法正常通信。相比于并行通信，串行通信線路更簡單，一般只要一對傳輸線就可以實現。
5. 傳感技術負責將采集到的外部信息輸入信息系統；控制技術負責實現信息系統對外部世界的控制。根據控制不同，可以分為開環控制和閉環控制。
八、射頻識別(RFID)
1. 無源標簽的射頻識別過程
(1)讀寫器天線發射向外發射電磁波
(2)無源標簽被激活，內置芯片向外發送自身攜帶信息
(3)讀寫器通過天線讀取標簽發送的信息，經過解碼后傳輸到信息系統進行下一步操作
2. 電子標簽的分類
(1)電子標簽根據有無電池，分為有源標簽和無源標簽
(2)根據工作頻率不同分為低頻(LF)、高頻(HF)、超高頻(UHF)和微波頻段(MW)。
3. 無源RFID開發較早，應用廣泛，如公交卡、食堂餐卡、銀行卡(閃付)、門禁卡、二代居民身份證等。為了實現安全的移動支付，NFC應運而生，NFC是一種短距(運行于10cm內)高頻(13.56MHz)的無線識別技術，一般內置在手機中。
九、網絡系統
1. 網絡的功能與作用：數據通信功能、資源共享功能、分布處理功能(云計算、邊緣計算)。
2. 網絡的根據應用領域分為：計算機網絡、移動通訊網絡、廣播電視網絡。
3. 計算機網絡
(1)根據覆蓋范圍分類：局域網(LAN)、城域網(MAN)、廣域網(WAN)。
(2)根據拓撲結構分類：總線型、環型、星型、樹型、網型等。其中網型是目前使用最廣泛的網絡連接類型，優點是容錯率高，缺點是消耗資源多。
(3)根據數據交換方式分類：電路交換、報文交換、分組交換。現代計算機網絡中使用的交換技術是分組交換。
4. 移動通信網絡
(1)第一代(1G)移動通信網絡：僅能語音通話；
(2)第二代(2G)移動通信網絡：可以發送短信；
(3)第三代(3G)移動通信網絡：可以傳輸圖像和音樂；
(4)第四代(4G)移動通信網絡：實現在線看視頻；
(5)第五代(5G)移動通信網絡：現在，用于實現物聯網和車聯網。
5. 廣播電視網絡也稱為混合光纖同軸網絡(HFC)。廣播電視網絡具有頻帶寬、容量大、功能多、成本低、抗干擾能力強、支撐多種業務等優勢。但由于用戶數據都在一條線上傳輸，有被搭線竊聽的風險；其次其網絡結構為樹形結構，易造成單點故障；隨著用戶數量增加，網絡會產生擁堵，用戶體驗急劇下降。
6. 三網融合與發展：數字技術得到迅猛的發展(語音、視頻統一為二進制流傳輸)；光纖技術的廣泛應用和計算機網絡互連通信技術(IP技術)的進一步發展。
十、計算機網絡的構建與連接
1. 網址又稱統一資源定位符（URL），由3部分組成：
2. 負責將服務器網址轉為IP地址的系統稱為域名系統，英文縮寫為DNS。
3. 計算機網絡的組成：計算機系統、數據通信系統、網絡軟件和網絡協議。
(1)計算機系統包括服務器和終端兩個部分
(2)數據通信系統主要由傳輸介質和網絡互聯設備組成。其中傳輸介質分為有線傳輸介質(光纖、雙絞線等)和無線傳輸介質(Wifi、藍牙等)。網絡互聯設備主要包括調制解調器(Modem)、路由器(Router)、和交換機(Switch)。
(3)網絡軟件一般包括網絡操作系統、通信軟件以及管理和服務軟件，常見的網絡操作系統有UNIX、Windows Server、Linux。
(4)網絡協議從上到下分為三層：應用程序協議(AP)、傳輸控制協議(TCP)、網際協議(IP)。
4. 網絡的構建步驟
5. 縮寫中英對照
HTTP：超文本傳輸協議；
SMTP：簡單郵件傳輸協議(郵件發送)；
POP3：第三版郵局協議(郵件接收)；
FTP：文件傳輸協議；
HTML：超文本標記語言；
ISP：互聯網服務提供商；
DHCP:動態主機配置協議(動態IP)；
SSID：服務集標識(熱點名稱)；
十一、網絡應用軟件開發
1. 網絡應用軟件的實現框架：客戶端/服務器架構(C/S)、瀏覽器/服務器架構(B/S)。
2. C/S架構的優缺點
(1)優點：將任務合理的分配到客戶端和服務器端，降低了系統通信開銷和開發難度
(2)缺點：客戶端軟件必須安裝后才能使用，給應用程序升級維護帶來一定的困難
3. B/S架構的優缺點
(1)優點：升級和維護都比較方便，極大的降低了成本和工作量
(2)缺點：服務器的負荷較重，對服務器的要求較高。
4. SQLite數據庫的特點：輕量級、跨平臺、獨立性、零配置、開放性、占用資源低。
5. Python中常用的Web應用框架Flask、Django、Tronado。
6. 可靠的Web服務框架有很多，如IIS、Apache、Nginx、Tomcat、WebLogic。
十二、個人信息保護
1. 個人信息可以分為個人敏感信息和個人一般信息。個人敏感信息指一旦遭到泄露或修改，會對信息主體造成不良影響的信息，一般包括但不限于手機號，身份證號，政治觀點，基因，指紋等；個人一般信息是指除了個人敏感信息以外的個人信息。
2. 個人信息泄露的渠道
(1)注冊時無意泄露：網絡平臺賬號注冊；問卷調查填寫個人信息；軟件權限開放過度
(2)網上交流時被惡意竊取：上網瀏覽內容被記錄；病毒、黑客入侵；公共場所免費Wifi
3. 個人信息泄露的危害:輕者導致個人或家庭被騷擾，隱私被公開。嚴重時不法分子會利用泄露的信息從事各種犯罪活動。
4. 個人信息保護途徑
(1)通過國家立法保障實現對個人信息隱私權的保護；
(2)通過行業自律實現對個人信息的保護；
(3)加強個人信息意識；（定期修改口令；不隨意提供個人或親屬信息；一旦發現信息被盜用，第一時間報警或通過法律途徑維權）
十三、信息社會責任
1. 數字公民的定義：能夠安全的、合法的、符合道德規范的使用數字化信息和工具的人。數字公民應具較高的數據意識、計算思維能力，具備利用信息技術解決問題的能力。
2. 數字公民素養教育
(1)尊重(尊重自己/尊重他人)：數字禮儀、數字準入、數字法律
(2)教育(教育自己/鏈接他人)：數字通信、數字素養、數字商務
(3)保護(保護自己/保護他人)：數字權責、數字安全、數字健康
3. 知識產權
(1)知識產權通常是指法律規定的人們對于自己創造或擁有的智力成果所享有的各種權力的總稱，包括相應的人身權力和財產權力。
(2)就信息技術領域而言，知識產權的保護主要是對知識產權權利人在微電子設備、計算機設備、通信設備等硬件設計制造以及軟件的原創成果的保護。
(3)開發者設計開發的計算機軟件，在開發完成之日就受到法律保護。使用者應自覺使用正版軟件，抵制盜版及未經授權的軟件。未經軟件版權人的許可，不得對其軟件復制、修改、傳播等操作，更不能進行商業性轉讓、銷售等侵權活動。
4. 開源軟件雖然強調軟件要自由使用、復制、研究、修改和分發，但也需要遵循自由軟件授權協議；自由軟件的意義不在于完全替代現存的商業軟件，而在于自由軟件開放過程中所體現出的巨大開發能力及讓所有人可以參與的模式，通過該模式可以快速提高代碼質量。
5. 自媒體在享有通信自由權、信息傳播自由權、信息選擇權時，還應承擔道德上的責任和義務。在傳播信息時要提升自律能力，加強自身新聞素養，遵循傳播倫理規范，避免不良信息的產生和傳播。
十四、數據加密
1. 一個密碼系統至少由明文、密文、加密算法、解密算法和密鑰5個部分組成。其中密鑰是密碼算法中引入的控制參數，對同一個算法采用不同的參數值，其加密的結果就不同（凱撒加密中的位移量K就可以理解為密鑰，使用不同的位移量K，加密得到的結果不同）。其中我們又根據加密密鑰（Ke）和解密密鑰（Kd）是否相同分為：對稱加密（Ke = Kd）和非對稱加密（Ke ≠Kd）。
2. 替代密碼（凱撒密碼）通過字符轉換的方式實現加密，由于加密和解密時使用的密鑰相同，所以替代密碼是對稱加密。
3. 換位密碼的基本思想是將明文中的字母位置通過一定的規則重新排序（沒有增加或減少明文的字符），最簡單的換位就是逆序法。
4. 簡單異或加密就是將明文與密鑰進行異或運算（相同為0，相異為1）（注意異或是位運算符，所以需要將明文和密文都先轉換成對應的二進制才能運算）。解密則是將密文和密鑰異或運算。同樣的，簡單異或在加密和解密過程中使用的密鑰也是相同的，故異或加密也是對稱加密。
十五、身份認證和訪問控制(注意兩者的作用范圍和功能區別)
十六、病毒、漏洞、黑客、防火墻
1. 計算機病毒
(1)計算機病毒是指人為編制的能破壞計算機功能或者毀壞數據，影響計算機系統的使用，并能自我復制的一組計算機指令或者程序代碼。它具有傳染性、寄生性、隱蔽性、潛伏性、破壞性、可觸發性等特征。
(2)病毒防治手段：安裝并開啟防火墻；安裝應用系統補丁；安裝防病毒軟件；經常對系統和重要的數據進行備份；收到亂碼信息后，及時刪除；不接受陌生請求；保證下載內容的安全性；不隨意連接公共場合的WiFi。
2. 漏洞
(1)漏洞是指一個系統存在的弱點或缺陷。漏洞可能來自應用軟件或操作系統，由于設計時的缺陷或編碼時的錯誤而產生，也可能來自邏輯流程上的不合理或程序員為了某種方便而留下的隱患(如“后門”)。
(2)漏洞的防治手段：使用防火墻來制止外部網絡對內部網絡的未經授權訪問；經常使用安全監測與掃描工具來發現安全漏洞及薄弱環節，加強內部網絡與系統的安全防護性能和抗破壞能力；使用有效的控制手段抓住入侵者；經常備份系統，以便在被攻擊后能及時修復系統，將損失減少到最低程度。
3. 黑客：一般指熱衷于計算機技術或解決難題、突破限制的高手。但由于部分人到處搜集黑客工具，利用網路進行搗亂和破環，使“黑客”逐漸淪為貶義詞。
4. 防火墻
(1)防火墻一般是有硬件和軟件組合而成的復雜系統，也可以只是軟件系統。防火墻一般放在內部網絡和外部網絡之間，控制外網對內網的數據傳輸和訪問。防火墻主要由服務訪問規則、驗證工具、包過濾和應用網關組成。
(2)防火墻按技術分類，主要分為地址轉換防火墻、數據包過濾防火墻和代理防火墻；按形態分類分為硬件防火墻和軟件防火墻。
(3)數據從外網到內網的經過的設備
十七、信息系統搭建
1. 搭建信息系統的前期準備
(1)需求分析：搭建信息系統前要明確用戶對所搭建系統的目標期待，并由此分析需求。需求分析包括功能需求、性能需求、資源環境需求（軟硬件環境）、用戶界面需求、可擴展性需求。
(2)可行性分析：在需求分析的基礎上，針對系統的環境、同類產品在市面上的完善程度，判斷所提出的系統是否有必要搭建（必要性），有無實施的可能性（可行性）。必要性體現在搭建是否應該馬上開始，有沒有迫切需要。可行性分析主要從技術、經濟、社會意義等方面分析系統的可行性。
(3)開發模式選擇：在設計信息系統開發方案時，應根據信息系統的具體功能和應用場景確定開發模式。目前搭建信息系統一般采用C/S模式或B/S模式。
(4)概要設計：主要解決信息系統“怎么做”的問題，包括模塊結構設計、系統物理配置和數據庫管理系統選擇三個部分：
1-模塊結構設計：將信息系統分成若干模塊，并確定每個模塊的功能、模塊間的接口和關系。
2-系統物理配置：包括了硬件設備配置、應用軟件選擇和通信網絡的選擇和設計。
3-數據庫管理系統選擇：主要考慮數據庫的性能、類型、平臺和安全保密性能。
(5)詳細設計：是在概要設計的指導下，對系統進行詳細具體的設計。主要包括輸入設計、輸出設計、人機界面設計、數據庫設計、代碼設計、安全設計。
2. 搭建信息系統
(1)硬件搭建：一個信息系統，其硬件組成主要包括服務器、網絡設備、傳感設備、智能終端等。
(2)軟件開發：一般包括數據管理設計、服務器端程序、客戶端程序幾個部分。
3. 完善信息系統
(1)系統測試的目的是把測試結果與系統需求比較，發現問題并及時修正。系統測試包括軟件測試、硬件測試、網絡測試。
(2)軟件測試包括正確性證明、靜態測試和動態測試。正確性證明只選擇一些代表性的數據驗證程序的正確性，具有一定的局限性；靜態測試不實際運行程序，采用人工檢測和計算機輔助分析的手段，針對編程格式和結構進行評估；動態測試直接在客戶端或服務器上運行程序，觀察程序運行并發現錯誤。
4. 文檔編寫
(1)可行性研究報告：可行性分析階段形成的文檔，說明待開發系統在技術、經濟和社會意義三個方面的可行性。
(2)系統分析說明書：概要設計階段形成的文檔，說明項目的主要工作內容、系統需求說明、系統功能說明、系統的數據說明。
(3)系統設計說明數：詳細設計階段形成的文檔，包括模塊設計、代碼設計、輸入設計、輸出設計、數據庫設計、人機交互界面、網絡設計、安全設計等的實施方案。
(4)程序設計報告：軟件開發階段形成的文檔，包括程序結構圖、程序控制圖、算法、程序流程圖、源代碼和注釋等
(5)系統測試報告：系統測試報告，包括測試環境、測試內容、測試方案、測試結果等。
(6)系統使用和維護手冊：為用戶準備的文檔，主要包括使用說明和內容解釋。
(7)系統評價報告：系統開發完成后對整個系統和整個開發過程的評價文檔。
必修算法程序
Python基礎算法
一、算法概念
1. 廣義的講，“算法”指的是解決問題或完成任務的一系列步驟。在計算機科學領域內，“算法”指的是計算機解決問題的步驟，是為了解決問題而需要讓計算機有序執行的，無歧義的，有限步驟的集合。
2. 算法的特征：
(1)有窮性：一個算法的處理步驟必須是有限的。
(2)可行性：每一步的操作與要求都是可行的，并且能夠在有限時間內完成。
(3)確定性：每一步的執行描述必須是明確的
(4)0個或多個輸入
(5)1個或多個輸出
3. 描述算法的方法：1-自然語言描述；2-流程圖描述；3-偽代碼描述；4-用程序設計語言描述。
4. 編程解決問題的一般過程：1-抽象與建模；2-設計算法；3-編寫程序；4-調試運行程序。
二、流程圖基本圖形及功能
三、解析算法和枚舉算法
#雞兔同籠問題：今有雉兔同籠，上有三十五頭，下有九十四足，問雉兔各幾何
1. 解析算法：用數學公式或解題步驟計算結果
head,foot = eval(input("請輸入頭和足的數量，格式是:頭,足"))
rabbit = (foot-head*2)/2
chick = head-rabbit
print("兔子有{}只，雞有{}只".format(rabbit,chick)
2. 枚舉算法：按一定的順序一一列舉所有可能解
head,foot = eval(input("請輸入頭和足的數量，格式是:頭,足"))
for rabbit in range(foot//4):
if rabbit*4+(head-rabbit)*2==foot:
print("兔子有{}只，雞有{}只".format(rabbit,head-rabbit))
四、程序組成分析
1. 注釋：在代碼中添加注釋，可以對代碼功能進行解釋說明。注釋在代碼運行過程中不參與執行。Python中有兩種注釋方式：1.用’#’開頭的單行注釋；2.用三引號開頭和結尾的多行注釋，這種注釋本質是創建了一個多行字符串。
2. 變量和賦值：
程序中有些數據是未知或是可變的，為了零活的使用這些數據，可以使用變量進行存儲。示例第二行就創建了一個名為TempStr的變量，用于存儲外部輸入值。
(1)變量命名時需要遵循一些基本規則：
1-變量名只能由數字,字母和下劃線（英文）三種字符構成；
2-變量名不能用數字開頭；
3-變量名區分大小寫；
4-變量名不能和保留字相同；
這里特別需要指出兩點：
1-Python變量名支持中文字符，但考慮兼容性一般不建議使用；
2-Python共有35個保留字（見下圖），這些不可以被作為變量名使用。
(2)賦值語句：變量名=值；變量名=表達式；a,b=b,a
(3)賦值運算符：”=”、”+=”、”-=”、”*=”、”/=”、”%=”等
3. 數據類型：
Python共有四種數據類型：整型、浮點型(實型)、字符串型和布爾型
(1)整數類型(int)：Python不帶小數點的值都是整數類型。例：10；
除此之外整數類型可以用多種進制表示，二進制前綴0b或0B(10=0b1010)；八進制0o或0O(10=0o12)；十六進制前綴0x或0X(10=0xA)
(2)浮點類型(float)：帶小數點的數值類型。例10.0、1.0e1
(3)字符串型(str)：字符串可以用單引號、雙引號、三引號表示。
(4)布爾類型(Bool)：只有True和False兩個值。
4. 運算符和優先級
運算符 功能和作用 示例 優先級
( ) 小括號 略 0(最高)
** 冪運算 略 2
~ 按位取反 ~n = -n-1 1
*、/、//、% 乘，除，整除，取余 整除：不大于除法結果的最大整數；取余：x%y=x-y(x//y) 3
+、- 加法、減法 略 4
& 按位與 0b1111&0b1010=0b1010 5
^ 按位異或 0b1111^0b1010=0b0101 6
| 按位或 0b1111|0b1010=0b1111 7
<、>、==、<=、>=、!= 關系運算符 結果為布爾類型 8
in 、not in 存在性判斷 結果為布爾類型 9
not 非 結果為布爾類型 10
and 與 結果為布爾類型 11
or 或 結果為布爾類型 12
5. 表達式：變量、常量、運算符按一定規則組合構成的式子
(1)表達式中存在多種運算符時，按優先級運算，優先級相同則從左到右
(2)Python中認為”0”(數值0)、””(空字符串)和False等價，非零數和非空字符串和True等價
(3)字符串比較時，比較的是兩者的ASCII碼值，從左到右逐位比較。例”123”<”23”=True
(4)數值類型的運算結果保留更精確的值。例1+2.0=3.0
6. 常用內建函數
(1)input([prompt])：獲取輸入，函數的參數為輸出提示字符，返回值為字符串類型
(2)int(object[,base])：將數值字符串轉為整數類型，base聲明進制類型，默認base=10。返回值為十進制整數類型。例int(“FF”,16)=255
(3)float(object)：將數值字符串轉為浮點數類型
(4)abs(x)：返回x的絕對值
(5)len(seq)：返回列表或字符串的長度，整數類型
(6)str(x)：將x轉為字符串類型
(7)chr(x)：x為ASCII碼值，返回x對應的字符
(8)str(x)：x為字符串，返回x對應的ACSII碼值，整數類型
(9)round(x[,n])：對x四舍五入，保留n位小數。round(6,-1)=10
(10)max(),min()：返回列表中的最大值和最小值
(11)print()：輸出內容到控制臺。當參數只有一個，會自動將非字符類型轉為字符類型后輸出。當參數有多個，可以用逗號連接后轉換位字符串輸出。例：print(10)；print(10,”全”,10,”美”)
(12)eval()：刪除字符兩邊的雙引號。
7. 格式化字符串
(1)”%”
例1：print(‘轉換后的溫度是：%d℃’%22.5)
運行結果：轉換后的溫度是：22℃
注：%d為整數，%f為實數，%s為字符串
例2：print("轉換后的溫度％.2f℃,濕度％.2f"%(22.345,5.677))
運行結果：轉換后的溫度22.34℃,濕度5.67f
注：”.2”表示小數點后保留兩位
例3：print(“%40s”%”今天的溫度是十攝氏度”)
運行結果：' 今天的溫度是十攝氏度'
注：”40”表示占位寬度為40且默認右對齊
(2)format方法
例1：print(“圓周率可以近似為:{}".format(3.1415926))
運行結果：”圓周率可以近似為:3.1415926”
注：format方法以{}為占位符
例2：print("轉換后溫度{:.2f}℃,濕度{:.2f}".format(23.456,5.678))
運行結果："轉換后的溫度23.45℃,濕度5.67"
例3：print("轉換后溫度{1:5.2f}℃,濕度{0:-^20.2f}".format(23.456,,5.678))
運行結果：'轉換后的溫度 5.68℃,濕度-------23.46--------'
注：冒號前為參數序號，故兩個值的替換位置變化；根據對應規則”-”為填充字符，”^”為居中對齊，”20”為替換槽寬度。
8. 字符串類型(str)
(1)字符串一旦創建就無法更改
(2)字符串的索引方式有正負兩種
(3)字符串切片：字符串名[start:stop:step]，結果含頭不含尾，step可以為負。
(4)常用字符串操作方法
s.upper() #全部小寫轉大寫
s.lower() #全部大寫轉小寫
s.split(sep) #根據sep分割字符串s
s.find(y) #返回y第一次出現在s中的索引值,若未出現則為-1
s.replace(old,new[,max]) #將old用new替換，max為最大替換次數。
s.count(sub) #統計sub在s中出現的次數
s.join(iter) #用s對iter做分隔符
注意：由于字符串是不可變對象，所以以上方法不會改變s的值，只是將改變后的結果進行返回。
9. 列表類型(list)
(1)列表類型為可變對象，列表中的每個元素數據類型可以相同也可以不同，甚至可以嵌套列表類型；
(2)列表的訪問和切片和字符串基本相同；
(3)列表的常用操作方法：
l.append(x) #在列表的最后添加一個元素x
l.clear() #清空列表s中的所有元素
l.insert(i,x) #在s的第i位置增加元素x
l.pop(i) #將s第i 位置的元素刪除
l.remove(x) #將列表中第一次出現的x字符刪除
l.sort(reverse) #對序列排序 reverse=True(降序)/False(升序,默認)
l.reverse() #將s的內容反轉
注意：以上方法會直接改變列表l的值。
10. 字典類型(dic)
例：d = {"姓名"："小明","年齡":13,"性別":"男"}
(1)字典類型的特點是用花括號將各種元素放在一起，字典的每個值都由兩部分組成："鍵":"值"，整個合起來叫“鍵值對”。
(2)字典的值只能通過“鍵”索引，因為字典內部元素是無序排列的，沒有索引值的概念。
(3)字典添加值、修改值、刪除值：
修改：d["性別"] = "女"
添加：d["國籍"] = "中國"
刪除：del d["性別"]
(4)可以用d.key() 或 d.value() 單獨輸出字典的鍵和值
11. 分支結構
if <判斷條件>:
語句塊1
elif <判斷條件>:
語句塊2
else:
語句塊3
(1)Python用代碼縮進表示代碼間的包含關系，同一級別代碼縮進相同
(2)當<判斷條件>為True才執行對應分支語句塊
(3)elif 和 else 并非必須，且當前面有條件(if)滿足后，后面的判斷(elif)會直接跳過，不執行。
#例：
if 10>5:
print(10)
elif 20>10:
print(20)
#運行結果：10
12. 循環語句
for <循環變量> in <循環對象>：
語句塊
(1)for循環是有限次循環，<循環對象>可以是字符串、列表，也可以是range()函數。
(2)range(start,stop,step)格式和字符串或列表切片類似。
while <判斷語句>：
語句塊
(3)while的判斷語句不當，可能會造成“無限循環”。當<判斷語句>結果為Ture運行循環，為False退出循環。
(4)break:結束并退出當前層循環
(5)continue:結束當前次循環，進入下一次循環
13. 自定義函數
def <函數名>(<參數1>,<參數2>...)：
語句塊
[return [返回值]]
(1)函數命名規則同變量命名規則
(2)函數參數可以設置默認值：<參數3>=<默認值>
(3)return 語句用于返還函數處理結果，并且結束函數運行
(4)函數內部變量為局部變量，當需要使用全局變量時需要用global聲明
14. 第三方庫的使用
(1)import <庫名>
(2)import <庫名> as <重命名>
(3)from <庫名> import <函數名>
(4)from <庫名> import *
注：常用的math和random模塊函數見下頁圖表。
Python常見程序
1. 用輾轉相除法(歐幾里得算法)求最大公約數
def gcd(m,n):
while n != 0:
r = m%n; m = n; n = r
return m
print(gcd(24,15))
#注：m為兩數中的較大值，n為兩數中的較小值；通過m%n不斷取余和交換，當余數為零時，最后的較小值就是原數的最大公約數。
2. 求素數
def prime_number(num):
for i in range(2,int(num**0.5)):
if num%i==0:
return False
return True
print(prime_number(15))
#注：素數只能被1和它本身整除，不能被其他自然數整除。
3. 進制轉換
#(1)n進制轉十進制(2<=n<=16)
def n_to_shi(n,str):
num = 0
for ch in str:
if n>10:
if "A"<=ch<="F":
num = num*n+(ord(ch)-ord("A")+10)
elif "a"<=ch<="f":
num = num*n+(ord(ch)-ord("a")+10)
else:
return "輸入錯誤"
else:
if "0"<=ch<="9":
num = num*n+ch
else:
return "輸入錯誤"
return num
print(n_to_shi(16,"FF"))
#(2)十進制轉n進制(2<=n<=16)
def shi_to_n(num,n):
str = ""
while num>0:
r = num % n
if r<10:
str += str(r)
else:
str += chr(ord("A")+r-10)
num //= n
return str[::-1] #取倒余
print(shi_to_n(15,16))
4. 十進制拆解各個位
#在程序開始輸入[100,500]范圍內的正整數，程序輸出5個數字，生成規則為：該項的數字+該數百位上的數+該數十位上的數+該數個位上的數=下一項數字。例如:
#輸入：123
#輸出：第1項為129,第2項為141,第3項為147,第4項為159,第5項為174,
n = eval(input())
if 100<=n<=500:
for i in range(5):
a = n // 100 #百位
b = n // 10 % 10 #十位
c = n % 10 #個位
n = n + a + b + c
print("第"+str(i+1)+"項為"+str(n),end=",")
else:
print("輸入有誤！")
5. 英文字符的大小寫轉換
def change(str):
ans = ""
for ch in str:
if "a"<=ch<="z": #ch.islower()
ch = chr(ord(ch)-32) #ch.upper()
elif 'A'<=ch<='Z': #ch.isupper()
ch = chr(ord(ch)+32) #ch.lower()
ans += ch
return ans
print(change("Ab1Cd2EFG3hij"))
6. 凱撒加密(替代加密)
def encrypt(code,key): #加密過程
code_new = ''
for s in code:
if 'A' <= s <= 'Z':
s_new = (ord(s)-ord('A')+key)%26+ord('A')
code_new += chr(s_new)
elif 'a' <= s <= 'z':
s_new = (ord(s)-ord('a')+key)%26+ord('a')
code_new += chr(s_new)
else:
code_new += s
return code_new
def decrypt(code,key): #解密過程
code_new = ''
for s in code:
if 'A' <= s <= 'Z':
s_new = (ord(s)-ord('A')-key)%26+ord('A')
code_new += chr(s_new)
elif 'a' <= s <= 'z':
s_new = (ord(s)-ord('a')-key)%26+ord('a')
code_new += chr(s_new)
else:
code_new += s
return code_new
s = input("code=")
s1 = encrypt(s,3) #加密
print(s1)
print(decrypt(s1,3)) #解密
7. 字符串切片(以身份證號處理為例)
def cut(id_num):
year = id_num[6:10]
month = id_num[10:12]
day = id_num[12:14]
sex = "男" if int(id_num[-2])%2==1 else "女" #執行if語句
print("您的出生日期為:"+year+"年"+month+"月"+day+"日,性別為:"+sex)
idnum = "330326199807071166"
print(cut(idnum))
#注：身份證號只能使用字符串存儲，因為最后一位的校驗碼有可能為X。
#以下程序改編自必修教材例題
8. 角谷猜想
#以一個正整數n為例，當n是奇數時，下一步變為3n+1；當n是偶數時，下一步變為n/2。不斷重復這樣的運算，經過有限步后，一定可以得到1。
def conjecture(num):
s = str(num)+"->"
while True:
if num == 1:
break
elif num%2==1:
num = num*3+1
else:
num = num/2
s = s + str(num)+"->"
return s[:-2]
import random
print(conjecture(random.randint(0,1000)))
9. 圖像字符畫
ascil_char=list('"$_&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[] -/+@<>i!:;,\^`.')
def toText():
im = Image.open('二哈.jpg')
im.resize((100,100)) #修改圖像大小
txt =' '
for i in range(im.size[1]): #垂直方向
for j in range(im.size[0]): #水平方向
r,g.b=im.getpixel((j, i))
gray = int(0.2126 * r + 0.7152 * g + 0.0722 * b)
unit = 256 / len (ascil_char)
txt += ascil_char[int(gray//unit)]
txt += '\n'
fo = open('pic_char.txt', 'w')
fo.write(txt)
fo.close()
toText()
10. jieba分詞并制作詞云
import jieba
from wordcloud import WordCloud
import matplotlib.pyplot as plt
txt = open("你是我的榮耀.txt",'r',encoding='utf-8').read()
words = jieba.lcut(txt) #使用jieba庫函數分詞
counts = {}
for word in words:
if len(word) == 1: #排除長度為1的字符分詞結果
continue
else:
counts[word] = counts.get(word,0)+1 #新詞需要先新建，所以用get方法
items = list(counts.items()) #將字典中的鍵值對轉為元組
items.sort(key=lambda x:x[1],reverse=True) #按照統計結果降序排序
ciyun = []
for i in range(50):
word,count = items[i]
print(word,count)
ciyun.append(word)
text_cut = ' '.join(ciyun) #轉為字符串，并用空格分隔
wordscloud = WordCloud(background_color='white',font_path = '漢儀樂喵體.ttf',width=1000,height=1000,margin=2).generate(text_cut)
wordscloud.to_file("詞云.png")
plt.imshow(wordscloud)
plt.axis('off') #關閉坐標軸
plt.show()
#運行結果：
11. 答題卡處理
from PIL import Image
x_start = 11 # 起始點坐標
y_start = 92
fill_width = 24 # 信息點寬度
fill_height = 10 # 信息點高度
space_width = 15 # 間隔寬度
space_height = 12 # 間隔高度
num_length = 9 # 準考證號長度
def bw_judge(R, G, B): # bw_judge 用于判斷一個像素的填涂情況
Gray_scale = 0.299 * R + 0.587 * G + 0.114 * B
return Gray_scale < 132
def fill_judge(x, y): # fill_judge 用于判斷信息點的填涂情況
count = 0
for i in range(x, x+fill_width):
for j in range(y, y+fill_width):
R, G, B = pixels[i, j]
if bw_judge(R, G, B) == True:
count = count + 1
if count >= fill_width * fill_height * 0.64:
return True
total_width = fill_width + space_width
total_height = fill_height + space_height
image = Image.open("答題卡.bmp")
pixels = image.load()
num = ""
for col in range(num_length):
for row in range(10):
x = x_start + total_width * col
y = y_start + total_height * row
if fill_judge(x, y) == True:
num = num+str(row)
break
else: #十個點檢查完都沒有填涂for...else...特殊用法
num = num+"#"
print(num)
12. Image模塊(老虎圖片)
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
choice=128
img=np.array(Image.open("lena.jpg").convert('L'))
rows,cols=img.shape #圖像尺寸分別賦值
for i in range(rows): #依次取每個像素的坐標
for j in range(cols):
if (img[i,j]<=choice): #像素值小于等于指定值，賦值1，否則為0
img[i,j]=0
else:
img[i,j]=1
plt.figure("lena") #指定當前繪圖對象
plt.imshow(img,cmap='gray') #顯示灰度圖像
plt.axis('off') #關閉圖像坐標
plt.show() #彈出包含了圖片的窗口
Pandas數據處理
一、一維結構Series
1. 創建Series
import pandas as pd
s1 = pd.Series([166,178,180])
print(s1)
#運行結果:
0 166
1 178
2 180
dtype: int64
2. 左列為索引(index)，右列為數值(values)，左側索引默認從0開始遞增，但也可以在創建Series對象時直接指定索引名稱。
import pandas as pd
s1 = pd.Series([166,178,180],index=["s01","s02","s03"])
#創建Series并指定索引
print(s1)
#運行結果:
s01 166
s02 178
s03 180
dtype: int64
3. Series類型可以用屬性方法將索引和值分別輸出
print(s1.index) #運行結果Index(['s01', 's02', 's03'], dtype='object')
print(s1.values) #[166 178 180]
4. 當我們需要修改或輸出某個值時，方法和列表類似：s1[index]
print(s1["s02"]) #運行結果178
當然也可以用這種方法修改單個值
s1["s02"] = 180 #修改索引"s02"的值
5. 需要特殊指出的是，由于上面代碼指定索引時使用的是字符類型，默認的數值類型的索引值依然可用。
print(s1[1] ) #運行結果為180
s1[1] = 180 #修改索引1的值，和上面的s1["s02"] = 180等價
二、二維結構DataFrame
data1 = {"姓名":["張三","趙四","王五"],"性別":["男","女","男"],"年齡":[12,15,13]} #創建一個字典類型
df1 = pd.DataFrame(data1) #用字典類型生成DataFrame類型
print(df1)
#運行結果：
姓名 性別 年齡
0 張三 男 12
1 趙四 女 15
2 王五 男 13
和Series類似，第一列為索引值(index)，默認從0開始遞增。第一行是列標題，可以使用對應的方法輸出
df1.index = ["01","02","03","04"] #修改索引值
print(df1.columns) #輸出列標題
print(df1.values) #輸出值區域的內容
1. 輸出單列
print(df1.姓名)
print(df1["姓名"]) #兩行代碼等價，但注意兩者引用的格式不同
#運行結果:
0 張三
1 趙四
2 王五
2. 修改單列
df1.年齡=[14,14,14]
df1["年齡"]=[14,14,14] #兩行代碼等價，修改"年齡"列的值
3. 輸出單行
print(df1.loc[0]) #用loc函數輸出索引0的行
print(df1[0:1]) #輸出索引0的行，類似于截取，含頭不含尾
#這兩行代碼運行結果等價，運行結果如下
姓名 性別 年齡
0 張三 男 12
4. 修改單行
df1.loc[0] = ["錢六","男",24]
df1[0:1]=["錢六","男",24] #兩行代碼等價，修改索引0的行
5. 輸出或修改單個值,使用at(行，列)函數
print(df1.at[0,"年齡"]) #輸出張三的年齡,結果為12歲
df1.at[0,'年齡'] = 50 #修改張三的年齡為50歲
6. 二維結構轉置
print(df1.T)
#運行結果：
0 1 2
姓名 張三 趙四 王五
性別 男 女 男
年齡 12 15 13
7. 對DataFrame行/列的算數運算
1) sum(axis=0/1) #統計行或者列的數據和 #axis = 0統計列，axis = 1 統計行
print(df1.sum()) #統計各列數據和
#運行結果：
姓名 張三趙四王五
性別 男女男
年齡 40
dtype: object
2) count(axis=0/1) #統計列/行的非空（NaN）數據個數
print(df1.年齡.sum()) #求年齡列數據個數
3) mean(axis=0/1) #統計列/行的平均值
print(df1.年齡.mean()) #年齡列求平均值
4) max(axis=0/1) #統計列/行的最大值
print(df1['姓名'].max()) #姓名列求最大值
5) min(axis=0/1) #統計列/行的最小值
print(df1['年齡'].min()) #年齡列求最小值
8. 基本描述統計值函數describe()
print(df1.describe()) #返回各列的基本描述統計值，包括計數、平均、標準差、最大值、最小值等。（注：只對數值列生效）
#運行結果：
年齡
count 3.000000
mean 13.333333
std 1.527525
min 12.000000
25% 12.500000
50% 13.000000
75% 14.000000
max 15.000000
9. head(n),tail(n)返回前n行，后n行的數據，n默認為5
print(df1.head()) #返回前5行數據（由于df1只有三行，故全部輸出）
#運行結果：
姓名 性別 年齡
0 張三 男 12
1 趙四 女 15
2 王五 男 13
print(df1.tail(1)) #返回最后一行數據
#運行結果：
姓名 性別 年齡
2 王五 男 13
10. 根據條件篩選行輸出
print(df1[df1.性別=="男"]) #輸出性別==男的所有行
print(df1[df1["年齡"]>13]) #輸出年齡>13的所有行
11. 分類匯總groupby(列名,as_index=True/False)
#創建新df1,后面的函數均使用該新表為例
data1 = {"姓名":["張三","李四","張三","李四"],"科目":["語文","語文","數學","數學"],"成績":[60,70,50,80]}
df1 = pd.DataFrame(data1)
#運行結果：
姓名 科目 成績
0 張三 語文 60
1 李四 語文 70
2 張三 數學 50
3 李四 數學 80
觀察新表，我們現在需要統計張三和李四的總成績，需要對df1進行分類匯總
print(df1.groupby("姓名").sum()) #根據姓名列分類匯總后計算和
#運行結果：
姓名 成績
張三 110
李四 150
#但需要注意的是，這種使用方式會使分類列（姓名）成為索引，所以一般還需要設置as_index=False。
print(df1.groupby("姓名",as_index=False).sum()) #根據姓名列分類匯總計算和
#運行結果：
姓名 成績
0 張三 110
1 李四 150
12. 排序sort_values(列名,ascending=True/False,inplace=False/True)
print(df1.sort_values("成績",ascending=False))
#根據成績列排序，ascending確定升（True）降(False)序，默認升序（True）
#運行結果：
姓名 科目 成績
3 李四 數學 80
1 李四 語文 70
0 張三 語文 60
2 張三 數學 50
print(df1.sort_values("成績",inplace=True))
#成績列升序排序，inplace聲明是否用結果替換原表格，默認False不替換
#運行結果：
姓名 科目 成績
2 張三 數學 50
0 張三 語文 60
1 李四 語文 70
3 李四 數學 80
13. 刪除drop(axis = 0/1)
print(df1.drop("姓名",axis=1)) #刪除姓名列
print(df1.drop(0)) #刪除索引0的行
#需要特別指出，drop()的axis與前面算數運算行列定義相反，當要刪除列時，axis需要特別設置為1，否則默認0刪除的是行
14. 追加數據行append(ignore_index)
data2 = {"姓名":["張三","李四"],"科目":["英語","英語"],"成績":[60,70]}
df2 = pd.DataFrame(data2) #創建一張新的表用于追加
print(df2)
#運行結果：
姓名 科目 成績
0 張三 英語 60
1 李四 英語 70
print(df1.append(df2)) #將df2追加到df1后面
#運行結果：
姓名 科目 成績
0 張三 語文 60
1 李四 語文 70
2 張三 數學 50
3 李四 數學 80
0 張三 英語 60
1 李四 英語 70
#觀察運行結果，df2索引值也是直接追加到df1后面的，這會使得通過索引值輸出時，英語成績是無法輸出的。
print(df1.append(df2,ignore_index=True)) #將df2追加到df1后面，索引值連續
#運行結果：
姓名 科目 成績
0 張三 語文 60
1 李四 語文 70
2 張三 數學 50
3 李四 數學 80
4 張三 英語 60
5 李四 英語 70
15. 插入列insert(loc, column, value)
date = ["高一","高二","高一","高二"]
df1.insert(1,"年級",date)) #在第二列插入年級
print(df1)
#運行結果：
姓名 年級 科目 成績
0 張三 高一 語文 60
1 李四 高二 語文 70
2 張三 高一 數學 50
3 李四 高二 數學 80
16. 修改行列名稱rename(index, columns)
df1 = df1.rename(index={0:"a",1:"b"},columns={"姓名":"xingming"})
#修改行索引0,1為"a","b"；修改姓名列為xingming
print(df1)
運行結果：
xingming 科目 成績
a 張三 語文 60
b 李四 語文 70
2 張三 數學 50
3 李四 數學 80
17. 合并兩張表concat([表1,表2])
df3 = pd.concat([df1,df2])
print(df3)
運行結果：
姓名 科目 成績
0 張三 語文 60
1 李四 語文 70
2 張三 數學 50
3 李四 數學 80
0 張三 英語 60
1 李四 英語 70
#需要特別指出的是，兩表連接的結果與追加相似，并且索引也是直接連接。
18. plot()繪圖
import matplotlib.pyplot as plt
df1.plot(kind="bar") #用df1數據生成圖，kind聲明了生成的是柱狀圖
plt.show() #最后的圖像需要通過matplotlib庫的show()輸出
#運行結果：
#注：圖像中顯示的成績這一列的數據
#例題:利用Panda模塊處理成績單，輸出信息技術成績前10同學中男女同學的平均分。
import pandas as pd
df = pd.read_excel("成績單.xls") #導入excel并轉為DataFrame
df_sort = df.sort_values("信息技術",ascending=False) #根據信息技術成績升序
df_t = df_sort.head(10) #取前十名的成績
df_filter = df_t[["姓名","性別","信息技術"]] #只保留三列內容
df_group = df_filter.groupby("性別",as_index=False) #根據性別分類匯總
print(df_group.mean()) #根據分類結果計算平均值
運行結果:
性別 信息技術
0 女 45.000000
1 男 44.833333
三、matplotlib模塊
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0,10,1000) #生成一個等差數組,(頭,尾,數據個數)
y1 = np.sin(x)
y2 = np.sin(x**2)
plt.figure(figsize=(8,4)) #創建一個圖表對象
plt.title("sin(x) and sin(x**2)") #設置圖表標題
plt.plot(x,y1,label="sin(x)",color="r",linewidth=2) #繪制線型圖
plt.scatter(x,y2,label="sin(x**2)") #繪制散點圖
plt.ylim(-1.5,1.5) #設置y軸取值范圍
plt.xlim(0,10) #設置x軸取值范圍
plt.xlabel("x") #設置x軸標簽
plt.ylabel("y") #設置y軸標簽
plt.legend() #顯示圖例
plt.show() #顯示繪圖對象
#運行結果：
#垂直柱狀圖
import numpy as np
import matplotlib.pyplot as plt
X = np.linspace(0,10,10) #生成一個等差數組,(頭,尾,數據個數)
Y1 = np.random.uniform(0.5,1,10) #生成隨機數組
Y2 = np.random.uniform(0.5,1,10)
plt.figure(figsize=(8,4)) #創建一個圖表對象
plt.title("random") #設置圖表標題
plt.bar(X,Y1,label="Y1") #設置圖形為柱形圖
plt.bar(X,-Y2,label="Y2")
for x,y in zip(X,Y1): #添加y值顯示
plt.text(x+0.01,y+0.05,"%.2f"%y,ha="center",va="bottom")
for x,y in zip(X,Y2):
plt.text(x+0.01,-y-0.05,"%.3f"%-y,ha="center",va="top")
plt.ylim(-1.5,1.5) #設置y軸取值范圍
plt.xlim(-0.5,10.5) #設置x軸取值范圍
plt.legend() #顯示圖例
plt.show() #顯示繪圖對象
運行結果：
Flask數據庫
案例一：建立最簡單的網頁
Python代碼
控制臺輸出
倒數第二行給出的是網頁地址
當用瀏覽器打開網頁時，Web服務器將受到一條GET請求
瀏覽器界面
案例二：建立新路由
Python代碼
瀏覽器界面：注意URL的變化
案例三：使用變量
Python代碼
瀏覽器界面：注意URL和顯示內容
案例四：使用HTML模板，并向模板中傳遞變量
Python代碼
HTML代碼：注意變量的傳遞和HTML中變量的格式
瀏覽器顯示：注意網頁標題
注意：HTML模板需要放在templates文件夾下，這是Flask內部定義的默認路徑。
案例五：Flask_wtf表單庫的使用
Python代碼
注意：代碼中使用request.method == 'POST'接受按鍵按下后表單的返回值。課本上采用的是form.validate_on_submit()檢測按鍵按下事件，兩者效果基本等價。
load.html代碼
text.html代碼
瀏覽器登陸（load.html模板）
瀏覽器輸入admin結果
瀏覽器輸入Peter結果
附錄：flask_wtf內置標準表單字段
序號 字段 描述
1 StringField 單行文本輸入框（*）
2 TextField 單行文本輸入框
3 BooleanField 多選框
4 DecimalField 用于顯示帶小數的文本字段
5 IntegerField 用于顯示帶整數的文本字段
6 RadioField 單選框
7 SelectField 下拉列表框
8 TextAreaField 多行長文本輸入框
9 PasswordField 密碼輸入框（輸入內容自動變為*）（*）
10 SubmitField 提交按鈕（*）
SQLite數據庫
1. SQLite基本操作
import sqlite3
#連接/創建數據庫
conn = sqlite3.connect("Sqlite/text.db")
#創建游標
cu = conn.cursor()
#創建數據表(表名st)
#create table <表名>(<字段名> <字段數據類型>,……)
cu.execute('''
create table st
(
ID int primary key not NULL,
name text not NULL,
age int not NULL,
sex char(1) not NULL
)
''')
conn.commit() #保存并提交到數據庫
#向數據庫增加數據
#insert into <表名> (字段1,字段2,……) valuse(值1,值2,……)
cu.execute("insert into st(ID,name,age,sex) values(1,'Peter',15,'M')")
cu.execute("insert into st(ID,name,age,sex) values(2,'Jim',16,'M')")
cu.execute("insert into st(ID,name,age,sex) values(3,'Maray',14,'W')")
cu.execute("insert into st(ID,name,age,sex) values(4,'Brent',17,'M')")
conn.commit() #提交數據
#查找
#select <輸出列1>,<輸出列2> form <表名> where <篩選條件>
s = cu.execute("select * from st")
for i in s:
print(i)
s = cu.execute("select name,age from st")
for i in s:
print(i)
s = cu.execute("select name,age from st where age>15")
for i in s:
print(i)
#用fetchall() 獲取游標結果，返回的是列表類型
cu.execute("select name,age from st where age>=15")
print(cu.fetchall())
#刪除語句
#delete from <表名> where <篩選條件>
cu.execute("delete from st where ID=1 ")
conn.commit() #更新
cu.close()
conn.close()
2. 室內環境檢測系統flask代碼
import sqlite3 #導入 sqlite3 數據庫
import json
from flask import Flask,render_template, request
DATABASE = "./flask_class4/data/data.db" #定義數據庫路徑
app = Flask(__name__) #創建一個服務器實例
@app.route("/")
def hello():
db = sqlite3.connect(DATABASE) #連接數據庫 data.db
cur = db.cursor() #創建游標對象
cur.execute("SELECT * FROM sensorlog WHERE sensorid =1")
#Execute方法用來執行sql語句,當sensorid=1， 從"sensorlog" 表中選取所在列
data = cur.fetchall() #查詢所有數據
cur.close() #關閉游標，不自動提交保存。
db.close() #關閉數據庫，不自動提交保存。
temp1 = data[len(data) - 1] #獲取最新一行數據，[ID,TIME,TEMP]
temp = temp1[2] #獲取溫度
return render_template('vews1.html', data=data,temp=temp)
#Get data
@app.route("/get",methods=['GET']) #響應網頁的 get 請求，返回實時溫度
def get_data():
sensorid=int(request.args.get('id')) #獲取id值
db = sqlite3.connect(DATABASE) #連接數據庫 data.db
cur = db.cursor() #創建游標對象
cur.execute("SELECT * FROM sensorlog WHERE sensorid = %s"% sensorid)
#Execute方法用來執行sql語句,當sensorid=1， 從"sensorlog" 表中選取所在列
data = cur.fetchall() #查詢所有數據
dbsum=len(data) #所有數據的長度
dset={'sensorid':sensorid} #字典
temp=[] #空數組
for i in range(dbsum): #在該數據長度下輪詢
value={} #空的字典
value['sensorvalue']=data[i][2] #當前i值的溫度
value['updatetime']=data[i][3] #當前i值的時間
temp.append(value) #在temp對象末尾創建value值
#dset['value']={'sensorvalue':data[i-1][2],'updatetime':data[i-1][3]}
dset['value']=temp #在該字典后面放入溫度和時間
djson=json.dumps(dset)#把編碼字典數據
return djson #返回所有數據
#Adding data
@app.route("/input",methods=['POST','GET'])
#響應終端的 post和get 請求，獲取實時溫度
def add_data():
if request.method == 'POST':
sensorid = int(request.form.get('id'))
sensorvalue = float(request.form.get('val'))
else:
sensorid = int(request.args.get('id'))
sensorvalue = float(request.args.get('val'))
nowtime = datetime.datetime.now()
nowtime = nowtime.strftime('%Y-%m-%d %H:%M:%S')
db = sqlite3.connect(DATABASE)
cur = db.cursor()
cur.execute("INSERT INTO sensorlog(sensorid,sensorvalue,updatetime) VALUES(%d,%f,'%s')" %(sensorid,sensorvalue,nowtime) )
mit() #事務提交，保存修改內容。
cur.execute("SELECT * FROM sensorlist where sensorid = %d"% sensorid)
rv = cur.fetchall()
cur.close()
db.close() #關閉數據庫，不自動提交保存。
maxrv = rv[0][2]
minrv = rv[0][3]
if sensorvalue > maxrv or sensorvalue < minrv:
return '1'
else:
return '0'
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8080,threaded=True)
#綁定 Web 服務器的 IP 和端口
3. 室內環境檢測系統html代碼

室內環境監測系統

當前室內溫度：`temp`

刷新歷史數據列表：

選擇性必修第一冊
數組
1. 創建數組
s1 = [0]*9 #間接創建(一維)
s1 = [1,2,3,4] #直接創建(一維)
s2 = [[0 for i in range(4)]for i in range(4)] #間接創建(二維)
s2 = [[0]*4]*4 #間接創建(二維)，但修改某行元素時，同一列的都會被改
s2 = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] #直接創建(二維)
2. 列表生成式
d1 = [i*i for i in range(10)]
print("d1=",d1)
d2 = [i*i for i in range(10) if i%2==0]
print("d2=",d2)
d3 = [m+n for m in 'ABC' for n in 'XYZ']
print("d3=",d3)
d4 = [s.lower() for s in ["ABC",'EDG','LSP']]
print("d4=",d4)
#運行結果
d1= [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
d2= [0, 4, 16, 36, 64]
d3= ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
d4= ['abc', 'edg', 'lsp']
3. 在數組中插入數據(while循環版)
a = [1,3,5,7,9,11,13,15,17,19,0] #最后一位空出來給待插入的數
num = 6 #待插入數據
i = 0
while iif a[i]i = i + 1
else:
break
j = len(a)-1
while j > i: #循環控制向后移位
a[j] = a[j-1] #注意移動位置是從后向前移動
j = j - 1
a[i] = num
print(a)
4. 在數組中刪除數據(while循環版)
a = [1,3,5,7,9,11,13,15,17,19]
num = 9 #需要刪除的元素
i = 0
while iif a[i] == num:
break
i = i + 1
while ia[i] = a[i+1]
i = i+1
a[i] = 0 #末尾清空
print(a)
5. 在數組中插入數據(for循環版)
a = [1,3,5,7,9,11,13,15,17,19,0] #最后一位空出來給待插入的數
num = 6 #待插入數據
for i in range(len(a)):
if a[i] > num:
break
for j in range(len(a)-1,i,-1): #循環控制向后移位
a[j] = a[j-1] #注意移動位置是從后向前移動
a[i] = num
print(a)
6. 在數組中刪除數據(for循環版)
a = [1,3,5,7,9,11,13,15,17,19]
num = 9 #需要刪除的元素
for i in range(len(a)): #查找元素所在位置
if a[i] == num:
break
for j in range(i+1,len(a)):
a[i] = a[i+1]
i = i + 1
a[len(a)-1] = 0 #末尾清空
print(a)
7. 常用的列表操作
1) s.append(x) #在列表的最后追加元素x,x整體被作為單個元素追加到最后
s = [1,2,3,4]
s.append(["5",6])
#結果為[1,2,3,4,["5",6]]
2) s.insert(i,x) #在s的第i索引位置增加元素x,x整體被作為單個元素插入序列
s = [1,2,4,5]
s.insert(2,[5,6])
#結果為[1,2,[5,6],3,4]
3) s.clear() #清空列表s中的所有元素
s = [1,2,3,4]
s.clear()
#結果為[]
4) s.pop(i) #將s第i索引位置的元素刪除，默認值為i值為-1，
s = [1,2,3,4,5]
s.pop()
#結果是[1,2,3,4]
5) s.remove(x) #將列表中第一次出現的x字符刪除
s = [1,2,2,3,2,4]
s.remove(2)
print(s)
#結果是[1,2,3,2,4]
6) s.reverse() #將s的內容反轉
s = [1,2,3,4,5]
s.reverse()
print(s)
#結果是[5,4,3,2,1]
7) s.sort() #將s的內容升序排列
s = [2,3,6,1,4,5]
s.sort()
print(s)
#結果是[1,2,3,4,5,6]
鏈表
1. 創建空鏈表
item=[] #存儲空間
head=-1 #頭指針
2. 單向鏈表元素的遍歷
head = 4
item = [[5,2],[7,3],[9,5],[2,-1],[1,0],[3,1]]
p = head
str1 = ''
while p != -1:
str1 += str(item[p][0])+"->"
p = item[p][1] #切換到下一節點
print(str1[:-2]) #清除最后的"->"
#運行結果
1->5->9->3->7->2
3. 在單向鏈表中插入數據
head = 0
item = [[99,1],[98,2],[97,3],[95,4],[94,-1]]
num = 96 #被插入數據
p = head
while p != -1: #未到尾部
if item[p][0] < num:
if p==head:
item.append([num,p]) #插入并復制前序next值
head = len(item)-1 #更新head值
break
else:
item.append([num,item[q][1]]) #插入并復制前序next值
item[q][1] = len(item)-1 #更新前序next值
break
q = p #存儲前序節點
p = item[p][1] #切換到下一節點
if p == -1: #在鏈表尾部插入
item.append([num,-1])
item[q][1] = len(item)-1
print(head,item)
#運行結果
num = 96 #中間插入
head=0
item=[[99, 1], [98, 2], [97, 5], [95, 4], [94, -1], [96, 3]]
num = 100 #頭部插入
head = 5
item = [[99, 1], [98, 2], [97, 3], [95, 4], [94, -1], [100, 0]]
num = 93 #尾部插入
head = 0
item = [[99, 1], [98, 2], [97, 3], [95, 4], [94, 5], [93, -1]]
4. 在單向鏈表中刪除數據
head = 0
item = [[99,1],[98,2],[97,3],[96,-1]]
num = 99 #被刪除數據
p = head
while p != -1: #未到尾部
if item[p][0] == num:
if p==head:
head = item[p][1] #更新頭指針位置
else:
item[q][1] = item[p][1] #更新前序節點next值
q = p #存儲前序節點
p = item[p][1] #切換到下一節點
print(head,item)
#運行結果
num = 97 #刪除中間
head = 0
item = [[99, 1], [98, 3], [97, 3], [96, -1]]
num = 99 #刪除頭部
head = 1
item = [[99, 1], [98, 2], [97, 3], [96, -1]]
num = 96 #刪除尾部
head = 0
item = [[99, 1], [98, 2], [97, -1], [96, -1]]
5. 雙向鏈表的插入
#雙向鏈表節點格式[num, prev, next]
head = 0
item = [[99,-1,1],[98,0,2],[97,1,3],[95,2,4],[94,3,-1]]
num = 96 #被插入數據
p = head
while p != -1:
if item[p][0] < num:
if p==head:
item.append([num,-1,head]) #item.append([num,-1,p])
head = len(item)-1
item[p][1]=len(item)-1
break
else:
item.append([num,item[p][1],p])
item[item[p][1]][2] = len(item)-1 #注意先后順序
item[p][1] = len(item)-1 #注意先后順序
break
p = item[p][2]
if item[p][2] == -1: #判斷是否為最后一個節點
if item[p][0] > num: #判斷是不是在尾部插入
item.append([num,p,-1])
item[p][2] = len(item)-1
break
print(head,item)
#運行結果
num = 96 #中間插入
head = 0
item = [[99, -1, 1], [98, 0, 2], [97, 1, 5], [95, 5, 4], [94, 3, -1], [96, 2, 3]]
num = 100 #頭部插入
head = 5
item = [[99, 5, 1], [98, 0, 2], [97, 1, 3], [95, 2, 4], [94, 3, -1], [100, -1, 0]]
num = 93 #尾部插入
head = 0
item = [[99, -1, 1], [98, 0, 2], [97, 1, 3], [95, 2, 4], [94, 3, 5], [93, 4, -1]]
6. 雙向鏈表的刪除
head = 0
item = [[99,-1,1],[98,0,2],[97,1,3],[95,2,4],[94,3,-1]]
num = 94 #被刪除入數據
p = head
while p != -1:
if item[p][0] == num:
if p==head:
head = item[p][2] #更新頭指針
item[item[p][2]][1]=-1 #更新下一跳的前向指針
else:
item[item[p][1]][2] = item[p][2]
if item[p][2] != -1:
item[item[p][2]][1] = item[p][1]
#item[item[p][2]][1] = item[p][1] #運行這句話其實并沒有報錯
p = item[p][2]
print(head,item)
#運行結果
num = 97 #中間刪除
head = 0
item = [[99, -1, 1], [98, 0, 3], [97, 1, 3], [95, 1, 4], [94, 3, -1]]
num = 99 #頭部刪除
head = 1
item = [[99, -1, 1], [98, -1, 2], [97, 1, 3], [95, 2, 4], [94, 3, -1]]
num = 94 #尾部刪除
head = 0
item = [[99, -1, 1], [98, 0, 2], [97, 1, 3], [95, 2, -1], [94, 3, -1]]
7. 拓展：鏈表類
class LinkNode: #定義單節點類
def __init__(self,data_,next_=None): #注意默認值的使用
self.data = data_
self.next = next_
class LinkList: #定義單鏈表類
def __init__(self): #生成實例初始化設置
self.head=None
def __str__(self): #類實例字符串格式輸出設置
s = ""
cur=self.head
while cur is not None:
s+=f"{cur.data}->" #format變種,與等價"{}->".format(cur.data)
cur=cur.next
return s[:-2] #刪除多余的“->”
def len(self):
num = 0
cur = self.head
while cur is not None:
num += 1
cur = cur.next
return num
def perpend(self,data_): #頭插法
if self.head is None:
self.head=LinkNode(data_)
else:
self.head=LinkNode(data_,self.head)
def append(self,data_): #尾插法
if self.head is None:
self.head = LinkNode(data_)
else:
cur = self.head
while cur.next is not None:
cur = cur.next
cur.next = LinkNode(data_)
def insert(self,index,data_): #指定位置插入節點
if index<0 or index>=self.len(): #位置不存在
self.append(data_) #用尾插法插入
else:
cur = self.head
while index>1:
cur = cur.next
index -= 1
cur.next = LinkNode(data_,cur.next)
def pop(self,index=-1): #指定位置刪除
if index<0 or index>=self.len(): #越界則默認刪除最后一個
index = self.len()
if index == 0:
self.head = self.head.next
else:
cur = self.head
while index>2:
cur = cur.next
index -= 1
print(cur.data)
cur.next = cur.next.next
a = LinkList()
for i in range(5):
a.perpend(i)
b = LinkList()
for i in range(5):
b.append(i)
print(a,b)
a.insert(1,10)
print(a)
a.pop(10)
print(a)
字符串
1. 字符串特性
1) 字符串有限序列性：
字符串是一種線性表結構，它的元素個數是有限的。字符串中的每個元素都可以用正負兩種索引獲取。
2) 字符串可比性：
當字符串中的字符來自同一字符集(以ASCII為例)時,可以按照碼值進行比較。
比較規則是從左至右，依次比較兩個字符串中對應位置上的字符碼值。
2. 字符串基本操作
1) 字符串連接
s = "Hello" + ' ' + "World"
#運行結果：s = "Hello World"
2) 字符串復制
s = "ha"*3
#運行結果：s = "hahaha"
3) 子串（存在性）判斷
print("hel" in "hello")
#運行結果：True
4) 字符串切片 s[首:尾:步長] 含頭不含尾
s = "千山鳥飛絕，萬徑人蹤滅"
print(s[:-5:-2])
#運行結果： 滅人
5) len(s)求字符串長度
s = "Hello World"
print(len(s))
#運行結果：11
6) s.find(y)
#返回字串在字符串中首次出現的位置(數值類型)，若找不到返回-1
num = "hello".find("ell")
print(num)
#運行結果：1
7) s.split(sep[,num])
#根據sep分割字符串s，num指定切分個數，生成結果為列表類型，sep參數默認為空格
s = "1,2,3,4,5,6"
s1 = s.split(',')
s2 = s.split(',',3)
print(s1)
print(s2)
#運行結果：
['1', '2', '3', '4', '5', '6']
['1', '2', '3', '4,5,6']
8) s.replace(old,new[,max])
#將字符串s中的old用new替換掉，max定義最大替換次數
s = "is is is is"
s1 = s.replace("is","was")
s2 = s.replace("is","was",3)
print(s1,s2)
#運行結果: was was was was was was was is
9) 大小寫轉換
#s.upper() 全部小寫轉大寫
#s.lower() 全部大寫轉小寫
s = "abcDEF"
s1=s.upper()
s2=s.lower()
print(s1,s2)
#運行結果: ABCDEF abcdef
10) s.count(sub) #統計sub在字符串s中出現的次數
s = "is is is is"
print(s.count('is ')) #注意空格
#運行結果：3
11) iter.join(s) #用iter對s做分隔
s = '12345'
s1 = ','.join(s)
print(s1)
#運行結果：1,2,3,4,5
12) s.strip(iter) #刪除首尾的iter字符，iter默認為空格
s = " a b c d e"
s1=s.strip()
print(s1)
x = "_a b c d e"
s2=s.strip("_")
print(s2)
#運行結果：a b c d e a b c d e
3.

展開更多......

收起↑