Python-初識python

時間 2019-11-16

標籤 python 欄目 Python 简体版

原文原文鏈接

python的簡介

創始人: Guido van Rossum(荷蘭人，學數學出身)python

時間：1989年聖誕節期間誕生c++

Python的命名：源於一個戲劇團（Monty Python）git

python的應用領域：web

系統運維
網絡編程
科學計算
人工智能，機器人
web開發
大數據及數據庫編程
雲計算：分佈式計算
教育：國外的第一門語言爲python語言，在中國第一語言爲c語言
遊戲，圖片
其餘

python的優缺點：數據庫

優勢：

面向對象（Java，c++，python）
免費
可移植:跨平帶運行，兼容多種平臺Windows/Linux/Unix
可混合編程（C/C++/Java/.net）
簡單易學易用
應用領域普遍
開發效率高:出錯概率比較小
開源

缺點

與C/C++相比執行速度不夠快
不能封閉源代碼

python的官網：www.python.orgexpress

python的版本：編程

python v2.7（2020年結束維護，出現bug以後沒辦法解決）windows

python v3.5（當前使用版本）api

python v3.8（最新版本，正在開發中，不穩定）數組

python的安裝：

能夠安裝在windows/Mac OS X /Unix....

python的運行

python的解釋器

CPython(python):用C語言編寫的
JPython：用Java語言編寫的
IronPython：.net語言編寫的
PyPy：用python語言編寫的

python的運行：

$ python3 hello.py

或者$ chmod u+x hello.py

$ ./hello.py(在python文件中的第一行寫入#！ /usr/bin/python3)

python的交互提示模式：

$ python3

>>> 能夠在提示符下輸入語句

退出：ctrl+d

>>>quit()

>>>exit()

python程序的組成：

程序由模塊組成

模塊由語句，函數，類，數據等組成

語句包含表達式

表達式創建並處理數據對象

python的註釋：

# 井號開頭，直至末尾：讓註釋內容不參加解釋執行

python的核心數據類型

數字（整數，浮點數，複數，布爾型）

整型數 int：是不帶小數部分的數字。包括天然數，0，以及負數如：-5 ，1000，0等

整型數的字面值表示：十進制表示（逢十進一）：（人們爲何使用十進制數：由於人有10隻手指）

二進制表示（逢二進一）：以0b開頭的數字表示二進制數，0b111，0b0111

八進制表示（逢八進一）：以0o開頭，後跟0~7

十六進制表示（逢十六進一）：以0x開頭，後跟0~9，A~F，a~f（不分大小寫）

2.浮點型數 float

浮點型數是帶有小數部分的數字

表示方式：小數形式：3.14 3.1 3. 0.14 .14

科學計數法：格式: 小數e/E(正負號) 指數，如：6.18E-1，2.9979e8

3. 複數 complex

分爲兩部分：實部（real）、虛部（image）虛部以j或J結尾(數學中是以i結尾的)

字面值：1j, (2j), 1+1J , 3-4J, (-100+100J)

布爾型數 bool ：

用來表示真和假來兩個狀態的類型，True表示真（條件知足或成立用1表示）False表示假（條件不成立或不成立用0表示）

　　　　　　　　bool值爲假的有：空字符，空列表，空字典，空元祖，空集合，None

空值 None 對象(整個python程序中全部的None)

None是一個表示不存在的特殊對象

做用：用來佔位，用來變量解除綁定

字符串

字符串 str

　　做用：用來記錄文本（文字）信息

　　表示方法;在非註釋中，凡是用引號括起來的部分都是字符串。單引號（'），雙引號（"），三單引號（'''），三雙引號（"""）

　　單引號和雙引號的區別：單引號內的雙引號不算結束符。雙引號內的單引號不算結束符

　　三引號字符串：

　　　　做用：三引號字符串的換行會自動轉換爲換行符'\n'

　　　　　　　三引號內能夠包含單引號和雙引號

　　用轉義序列表明特殊字符：

　　　　字符串字面值中，用字符反斜槓（\）後跟一些字符表明一個字符

　　　　字符串中的轉義字符表：

　　　　　　\' 　　　　表明一個單引號

　　　　　　\"　　　　表明一個雙引號

　　　　　　\\　　　　表明一個反斜槓

　　　　　　\n　　　　換行

　　　　　　\r　　　　返回光標只行首：print（aaaaa\rb）的結果爲baaaaa

　　　　　　\f　　　　換頁

　　　　　　\t　　　　水平製表符：print（"a\tb）的結果是b的前面有8個空格包括a若是a的個數爲8則再新添加8個空格

　　　　　　\v　　　　垂直製表符

　　　　　　\b　　　　倒退：print（"ABCD\bE"）的結果爲ABCE

　　　　　　\0　　　　空字符，字符值爲0

　　　　　　\0XX　　 XX爲兩位八進制表示的字符：'\012'表示\n

　　　　　　\xXX　　　XX爲兩位十六進制的字符：\'00A'表示\n

　　　　　　\uXXXX 　 Unicode16的十六進制表示的字符

　　　　　　\UXXXXXXXX Unicode32的十六進制表示的字符

ASCII編碼：(0~127(2**8-1))共有128個/Unicode16（65535個）

　　ASCII字符表

　　經常使用ASCCII編碼：

　　　　字符　　　　十進制　　　　十六進制

　　　　‘0’　　　　　　48　　　　　　0x30

　　　　'A'　　　　　　65　　　　　　0x41

　　　　'a'　　　　　　97　　　　　　0x61

raw 字符串（原始字符串）

　　字面值格式：r'字符串內容' r"字符串內容" r'''字符串內容''' r"""字符串內容"""

　　做用：讓轉義字符\無效

　　示例：

字符串的運算：

　　算術運算符： + += * *=

　　+ 運算符用於字符串的拼接（只能拼接類型相同的兩個對象，如：不能將字符串與整數拼接）

　　* 運算符用於生成重複的字符串（字符串只能與整數（int）相乘，與0相乘表示控字符串）

練習：打印一個長爲（自由輸入）寬爲4的長方形，用*表示邊框

w = int(input("請輸入長方形的長："))
symbol = "*"
line1 = symbol * w
line2 = symbol + (w-2) * " " + symbol
print(line1)
print(line2)
print(line2)
print(line1)

字符串的比較運算：

　　運算符：> >= < <= == !=

　　比較方法：字符串相比至關於字符對應的ASCII值的比較，從第一個字符一次日後比較，ord('a')表明97 chr(97）表明a

in / not in 運算符：

　　做用：用於序列，字典，集合中，用於判斷某個值是否存在於容器中，若是存在則返回True

　　格式：對象 in 容器；對象 not in 容器

字符串的索引操做：

　　python字符串str是不能夠改變的字符序列

　　索引 index

　　　　索引語法：字符串[整數表達式]。（表達式的值爲整數int）

　　　　說明：python序列均可以用索引（index）來訪問序列中的對象（元素），

　　　　　　　python序列的正向索引是從0開始的，第二個因此爲1，最後的一個索引爲len（s）-1

　　　　　　　python序列的反向索引是從-1開始的，-1表明最後一個，-2表明倒數第二個，-len（s）表明第一個

切片 slice：

　　做用：從字符串中取出一部分相應的元素重新組成一個新的字符串

　　語法：字符串[（開始索引b）：（結果索引e）：（（步長s））]

　　注：（）內括起來的部分表明能夠省略，左閉右開，開始索引/結束索引能夠越界

　　說明：一、開始索引是切片開始切下的位置0表明第一個元素，-1表明最後一個元素

　　　　　二、結束索引是切片的終止索引（但不包括終止索引，左開右閉）

　　　　　三、步長是切片每次獲取當前索引後移動的方向和位移量

　　　　　　 1）沒有步長，至關於取值完成後向後移動一個索引的位置（默認爲1）

　　　　　　 2）當步長爲正整數時，取正向切片：步長默認值爲1，開始索引默認值爲0，結束索引默認值爲len（s）。

　　　　　　 3）當步長爲負整數時，取反向切片；默認的起始位置爲最後一個元素，默認終止的位置爲第一個元素的前一個位置。

　　示例：s ="ABDC"

　　　　　print(s[ : ]) #ABCD

　　　　　print(s[1：10000]) #BCD

　　　　　print(s[ : : 1]) #ABCD

　　　　　print(s[ : : 1-]) #ABCD

　　　　 print(s[ 3: 2])　　　 #爲空

練習：輸入任意一個字符串，判斷這個字符串是不是迴文（中心對稱的字符串）

str = input("請輸入任意的字符串：")
centre_index = round(len(str)/2)
print("你輸入的是迴文字符串") if str[ : centre_index ] == str[ : -(centre_index+1) :-1] else print("你輸入的不是迴文字符串")
################################################################################################################################
str = input("請輸入任意的字符串：")
str1 = str[  :  : -1]
print("你輸入的是迴文字符串") if str == str1 else print("你輸入的不是迴文字符串")

python3中經常使用的序列函數：

　　len(seq) 返回序列的長度

　　max(x) 返回序列的最大值元素

　　min(x) 返回序列的最小值元素

　　示例：s = "ABCD"

　　　　　print(len(s)) #4

　　　　 print(max(s)) #D(根據ASCII值進行比較)

print(min(s)) #A(根據ASCII值進行比較)

字符串編碼轉換函數：

　　ord（c）返回一個字符串的Unicode編碼值

　　chr（i）返回i這個值所對應的字符 i表明大於等於0的整數

整數轉換爲字符串函數：

　　hex（i）　　將整數轉換爲十六進制的字符串

　　oct（i）　　將整數轉換爲八進制的字符串

　　bin（i）　　將整數轉換爲二進制的字符串

字符串的構造（建立）函數 str

　　str（obj=「」）將對象裝換爲字符串

經常使用的字符串方法：

　　字符串方法的調用語法：對象.方法名（方法傳參）

　　注：方法的調用屬於表達式，一般能夠返回一個值或None

　　示例：'abc'.isalpha() #正確（是否是字母a-zA-Z），中文也被看作爲字母

　　S.isdigit()　　　　是否所有爲數字

　　S.islower()　　　是否所有小寫

　　S.isupper()　　　　是否所有大寫

　　S.isspace()　　　　是否所有爲空格（空白字符是指，水平製表符\t，換行符\n等不可見的字符）

　　S.center（width[,fill]）將字符串按width的寬度居中，[]爲可選參數默認爲空格，必須是str類型的，寬度能夠小於字符串的長度

　　S.count（sub[,start[,end]]） sub字符在S字符串中有幾個。start/end是字符串的索引，不包含end　　

　　S.find(sub[,strat[,end]]) 返回字符串中字串sub的第一個索引，失敗返回-1

　　S.strip（）去掉字符串左右的空白字符

　　S.lstrip（）去掉左邊的空白字符

　　S.rstrip（）去掉右邊的空白字符

　　S.upper（）轉換英文字母爲大寫

　　S.lower（）轉換英文字母爲小寫

　　S.swapcase（）　　　　　大小寫互轉，遇到數字類型的字符串是不改變

　　S.capitalize()　　　　　　字符串結尾的大寫字母轉換爲小寫

　　S.replace(old,new[,count]) 將原字符串的old用new代替，生成一個新的字符串，count爲替換的個數（超過old的次數或負值時所有替換），默認爲所有替換。　　

　　S.startswith(prefix[,start[,end]]) 返回S是否爲prefix開頭，若是是則返回True，不然返回False

　　S.endswith(suffix[,start[,end]]) 返回S是否爲suffix開頭，若是是則返回True，不然返回False，（不包括end）

不經常使用的函數「

　　S.title()　　　　　　　　　　生成每一個英文單詞的首字母大寫字符串

　　S.isnumeric()　　　　　　　　判斷字符串是否所有爲數字字符

字符串格式化表達式：

　　運算符：%

　　做用：生成一個格式的字符串

　　語法：格式字符串 % 參數值。

　　　　　格式字符串 % （參數值1，參數值2，參數值3.......）

　　　　　格式化字符串中 % 爲佔位符，佔位符的位置將用參數值替換

格式化字符串中的佔位符和類型編碼：

　　　　佔位符　　　　　　　　意義

　　　　　%s　　　　　　字符串，使用str（）函數轉換

　　　　　%r　　　　　　字符串，使用repr（）函數轉換

　　　　　%c　　　　　　整數轉換爲單個字符

　　　　　%d　　　　　　十進制整數

　　　　　%o　　　　　　八進制整數

　　　　　%x　　　　　　十六進制整數（a-f小寫）

　　　　　%X　　　　　　十六進制整數（A-F大寫）

　　　　　%e　　　　　　指數型浮點數（e小寫）如：2.9e+10

　　　　　%E　　　　　　指數型浮點數（E大寫）如：2.9E+10

　　　　　%f, %F　　　　浮點十進制形式

　　　　　%g, %G　　　　十進制形式浮點數或指數型浮點數自動轉換，整數部分超過6位就會轉換爲指數型，不足6爲則轉換爲十進制型浮點數，g對應e,G對應E

　　　　　　　　　　　　若是整數部分不足6位可是與小數部分加起來超過6位則會截取小數部分最後保留6位的浮點數

　　　　　%%　　　　　　等同於一個%字符（用於生成百分數）

佔位符和類型碼之間的格式語法：

　　% [格式語法] 類型碼

　　格式語法：

　　　　-　　　　左對齊

　　　　+　　　　右對齊

　　　　0　　　　補零

　　　　寬度（整數）：寬度不能是變量

　　　　寬度.精度(整數)

　　　　示例：

　　　　練習：輸入三行字符串，以三行中最長字符串的長度爲標準進行右對齊輸出

s1 = input(">")
s2 = input(">>")
s3 = input(">>>")
w = max(len(s1),len(s2),len(s3))
fmt = "%%%ds" %w #生成一個含有佔位符的字符串("%ws")
print(fmt %s1)
print(fmt %s2)
print(fmt % s3)

列表

列表list

　　列表是由一系列特定的元素組成的，元素和元素之間沒有任何關聯關係，但他們之間有前後順序關係

　　列表是一種容器

　　列表是序列的一種

　　列表是能夠被改變的序列

python中的序列類型簡介（sequence）（5中內建的序列容器）

　　字符串　　　　str

　　列表　　　　　list

　　元祖　　　　　tuple

　　字節串　　　　bytes

　　字節數組　　　bytearrag

建立一個空列表的字面值：

　　L = []　　　　#L綁定空列表

建立非空列表：

　　L = [1,2,3,4]

　　L = ["北京","上海","成都"]

　　L = [1,"two",3,"四"]

　　L = [1,2,[3.1,3.2,3.3,],4]

列表的構造（建立）函數 list

　　list（）　　　　　　生成一個空的列表等同於 [] 如：L = list（）

　　list(iterable) 　　　用迭代對象建立一個列表如　L = list（「ABCD」） L= lsit（range（1，10，2））

列表的運算：

　　算數運算：+ += * *=

　　+　　用於拼接列表

　　+= 　用於元列表與左側可迭代對象進行拼接，生成新的列表

　　　　X = [1,2,3]

　　　　X += "ABC" #[1,2,3,"A","B","C"]　　右側必須是可迭代對象

　　* 　　生成重複的列表

　　*=　　用於生成重複的列表，同時用變量綁定新列表（乘數必須是整數，若是是0或負整數則變爲空列表）

　　比較運算：<　　<= 　　>　　>=　　==　　!=

　　　　　　根據索引最小的字符的ASCII的編碼值進行比較，可是整數與字符串比較大小時回報TypeError，比較是否相等是能夠正常運行的

列表的 in/ not in :

　　一、判斷一個數據元素是否存在於容器（列表）內，若是存在返回True，不然返回False

　　二、not in 的返回值與 in運算符相反

列表的索引index / 切片 slice

列表的索引語句：

　　列表[整數表達式]

　　用法：列表的索引取值與字符串的索引取值規則徹底相同

　　　　　列表的索引分爲正向索引和反向索引

列表的切片

　　列表[:]

　　列表[: :]

　　列表的切片取值返回一個列表，規則等同於字符串的切片規則

列表的切片賦值語法：

　　列表[切片] =可迭代對象

　　說明:切片賦值的賦值運算符的右側必須是一個可迭代對象

切片步長不爲1的切片賦值：

　　切片注意事項：

　　對於步長不爲1的切片的賦值，賦值運算符的右側的可迭代對象提供元素的個數必定要等於切片切出的段數（-1一樣須要知足相同）

del 語句用於刪除列表中的元素

　　語法：del 列表 [索引]

　　　　　del 列表 [切片]

python3中經常使用的序列函數：

　　len（x）　　　　返回列表的長度

　　max（x）　　　返回列表中最大的元素

　　min（x）　　　返回列表中最小額元素

　　sum（x）　　　返回列表中全部元素的和（元素必須是整數值類型）

　　any（x）　　　　真值測試，若是列表中其中一個元素爲真值則返回True，不然返回False

　　all（x）　　　　真值測試，若是列表中全部元素都爲真值，則返回True，只要有一個爲假，則返回False

python3中常見的列表方法：

　　L.index(v[,begin[,end]])　　返回對應元素的索引下標，begin爲開始索引，end爲結束索引，當不存在時觸發ValueError錯誤

　　L.insert(index,obj)　　　　將某個元素插入到列表中的指定位置,

　　L.count(x)　　　　　　　返回列表中元素的個數，沒有則返回0

　　L.remove(x)　　　　　　從列表中刪除第一次出如今列表中的值，若是不存在則會報ValueError

　　L.copy()　　　　　　　　複製此列表（只複製一層，不會複製深層對象）

　　L.append(z)　　　　　　向列表中追加單個元素

　　L.extend(lst)　　　　　　向列表中追加了一個了表

　　L.clear()　　　　　　　　清空列表，等同於L[:] = []

　　L.sort(reverse=False) 　　將列表中的元素進行排序，默認是按小到大的順序排序，當reverse=True時，按從多大到小排序，列表中元素必須是同類型的數據

　　L.reverse()　　　　　　　列表的反轉，用來改變原列表的前後順序

　　L.pop([index])　　　　　刪除索引對應的元素，若是不加索引，默認刪除最後的元素，同時把刪除的元素返回

字符串文本解析方法split 和 join

　　S.split(Sep=None)　　　　將字符串使用sep做爲分隔符分割S字符串，返回分割後的字符串的列表，當不給定參數時，使用空白字符做爲分隔符進行分割

　　S.join（iterable）　　　　用可迭代對象中的字符串，返回一箇中間用S進行分割的字符串。

深拷貝 deep copy 和 shallow copy

淺拷貝：是指在複製過程當中只複製一層變量，不會複製深層變量綁定的對象的複製過程

深拷貝：是指在複製過程當中複製多層變量（不侷限於兩層），複製深層變量綁定的對象的複製過程

列表推導式 list comprehension

　　列表推導式是用可迭代對象依次生成帶有多個元素的列表的表達式

　　做用：用簡單方法生成列表

　　語法：[表達式 for 變量 in可迭代對象] 或[表達式 for 變量 in 可迭代對象 if 真值表達式（真值表達式須要真執行表達式，爲False時表達式不執行直接執行for語句）]

　　示例：L = [x*x for x in range(1,10)] #生成1-9的平方值的列表

　　　　　L = [x for x in range(1,100) if x%2!=0] #生成1-100內的奇數的列表

列表推導式的嵌套：

　　語法：[表達式1

　　　　　　for 變量1 in 可迭代對象1 if 真值表達式1

　　　　　　　　　for 變量2 in 可迭代對象2 if 真值表達式2

　　　　　　　.......]

　　示例：

元組tuple

元組是不可改變的序列，同list同樣，元組能夠存聽任何類型的元素，一旦元組生成，則它不能夠改變

元組的表達方式：

　　用小括號（）括起來，單個元素括起來用逗號（，）區分是單個對象仍是元組如：type（（2））爲int，可是type（（2，））爲tuple

　　建立空元組的字面值：t = （）

　　建立非空元組的字面值：t = 200，

　　　　　　　　　　　　　t = （200，）

　　　　　　　　　　　　　t = （1，2，3）

　　　　　　　　　　　　　t = 100 ，200，300

元組的錯誤示例：t = （20）　　t綁定的是整數20

　　　　　　　　x， y，z =100，200，300 #序列賦值

　　　　　　　　x，y，z =「ABC」 # x=「A」，y=「B」，z="C"

　　　　　　　　x，y，z = [10，20，30]

元組的構造函數 tuple

　　tuple（）生成一個空的元組，等同於（）

　　tuple（interable）用可迭代對象生成一個元組

　　示例：t = tuple（）

　　　　　t = tuple（range（10））

　　　　　t = tuple（‘hello’）

　　　　　t = tuple（[1,2,3,4]）

元組的算數運算： + += * *=，用法與列表的用法徹底相同（有有點不一樣：列表的+=，*=運算先後列表的內存地址（id）沒有發生變化，元組要發生變化）

元組的比較運算： < <= > >= == != 規則與列表徹底相同

in / not in

索引取值

切片取值

　　規則與列表徹底相同

　　區別：元組是不可變對象，不支持索引賦值和切片賦值

元組的方法：

　　T.index(v[,begin[,end]) 用於獲取元組中v所在的索引位置，若是v不在元組中就會報錯ValueError: tuple.index(x): x not in tuple

　　T.count(v)　　　　　　　用於獲取元組中v的個數（同list.count()方法）

能夠用於序列的函數：

　　len ，max，min，sum ,all, any

三個構造函數：用於建立相應的對象

　　str（obj）

　　list（iterable）

　　tuple（iterable）

其餘函數：

　　reverse（sep）返回反向順序的可迭代對象

　　sorted（iterable，reverse=False）返回已排序的列表

　　示例： for x in reverse("ABCD"):

　　　　　　　　print(x) # D C B A

字典 dict

一、字典是一種可變的容器，能夠儲存任意類型的數據

二、字典中的每個數據都是用「鍵」（key）進行索引，而不像序列能夠用下標進行索引

三、字典的數據沒有前後順序關係，字典的儲存是無序的

四、字典中的數據以鍵（key）—值（value）對進行映射存儲

五、字典的鍵不能重複，且只能用不可變類型做爲字典的鍵

字典的字面值表示方式：

　　用{} 括起來，以冒號（：）分割鍵-值對，各鍵值對用逗號分隔開

建立空字典：d = { }

建立非空的字典：

　　d = {"name":"xdl","age":20}

　　d = {「姓名」：「小徐」}

　　d = {1:"壹"，2：「貳」}

字典的構造函數dict

　　dict（）　　　　建立一個空字典，等同於{}

　　dict（iterable）　用可迭代對象初始化一個字典

　　dict（**kwargs）關鍵字傳參形式生成一個字典

示例：

　　d = dict()

　　d = dict([("name","xdl"),("age",20)])

　　d = dict(name="xdl",age=20) 若是d = dict(1="xdl",age=20)則會報語法錯誤：SyntaxError: keyword can't be an expression

不可變類型：

　　int , float, complex, bool, str ,tuple, frozenset(固定集合)，bytes(字節串)

可變類型：

　　list , dict, set， bytearray(字節數組)

字典的鍵索引：

　　用[] 運算符能夠獲取字典內「鍵」所對應的「值」

　　語法：字典[鍵]

　　獲取數據元素：

　　　　d =dict(name="xdl",age=20)

　　　　print(d["age"]) #20

添加和修改字典的元素

　　字典[鍵] = 表達式

　　示例：d ={}

　　　　　d["name"] ="xdl"　　建立一個新的鍵值對

　　　　　d["age"] = 20 　　　建立鍵值對

　　　　　d["age"] = 25 　　　修改age對應的的值

del 語句刪除字典的元素

　　語法：del 字典[鍵]

字典的 in/ not in 運算

　　能夠用in運算符來判斷一個「鍵」是否存在與字典中，若是存在則返回True，不然返回False ，not in 與 in返回值相反，判斷的速度比在列表中要快。

字典的迭代訪問：

　　字典是可迭代對象，字典只能對鍵進行迭代訪問

可用於字典的內建函數：

　　len（x）　　返回字典鍵-值對的個數

　　max（x）　　返回字典的鍵的最大值

　　min（x）　　返回字典的鍵的最小值

　　sum（x）　　返回字典全部鍵的和

　　any（x）　　真值測試，只對鍵測試，若是其中一個鍵爲True，結果爲True

　　all（x）　　真值測試，所有鍵爲True時，結果才返回True

字典的方法：

　　D.clear()　　　　　　　　清空字典

　　D.pop(key)　　　　　　　移除鍵，同時返回此鍵對應的值

　　D.copy()　　　　　　　　返回字典D的副本，值複製一層（淺拷貝）

　　D.update(D2)　　　　　　將字典D2合併到D中，若是鍵值相同，則此鍵的值取D2的值做爲新值

　　D.get(key,default)　　　　返回鍵key所對應的值，若是沒有此鍵，則返回default，默認爲None

　　D.keys()　　　　　　　　返回可迭代的dict_keys對象　　　　#dict_keys([0, 9, 3, 6])

　　D.values()　　　　　　　返回可迭代的dict_values對象　　 #dict_values([0, 81, 9, 36])

　　D.items()　　　　　　　返回可迭代的dict_items對象　　　　#dict_items([(0, 0), (9, 81), (3, 9), (6, 36)])

字典推導式：

　　字典推導式是用可迭代對象依次生成字典內元素的表達式

　　語法：{鍵表達式：值表達式 for 變量 in 可迭代對象 [ if 真值表達式] }，[]的內容是表明能夠省略，能夠嵌套循環

　　示例：d = { x : x**2 for x in range(10)}　

　　　　 d = { x : x**2 for x in range(10) if x%3 ==0}

字典 vs列表

　　一、都是可變的容器

　　二、索引方式不一樣，（列表是整數索引，字典是用鍵索引）

　　三、字典的查找速度可能快於列表（重要），數據量越大越明顯，可是當只有單個數據時可能會慢

　　四、列表的儲存是有序的，字典的儲存是無序的

集合 set

　　集合是可變的容器

　　集合內的數據對象是惟一的（不能重複屢次的）

　　集合是無序的存儲結構，集合中的數據沒有前後關係

　　集合內的元素必須是不可變對象

　　集合是可迭代的

　　集合是至關於只有鍵沒有值的字典（鍵則是集合的數據）

建立空的集合：

　　s = set（） #set（）建立一個空的集合

建立非空的集合：

　　s = {1，2，3} 集合中三個整數1，2，3　

集合的構造函數 set

　　set（）　　　　建立空集合

　　set（iterable）　用可迭代對象建立一個新的集合對象

　　示例：s = set("ABC") 　　　　　　　　#{'C', 'B', 'A'}

　　　　　s= set("AABBCCDD")　　　　　 #{'C', 'B', 'D', 'A'}

　　　　　s= set({1:"一",2:"二",5:"五"})　　 #{1, 2, 5}

　　　　　s=set([1,3.14,False])　　　　　 #{False, 1, 3.14}

　　　　　s=set((2,3.5,7)) 　　　　　　　 #{2, 3.5, 7}

　　　　　s= set([1,2,[3.1,3.2],4])　　　　 #由於列表中的列表是可變的對象，因此會報錯：TypeError: unhashable type: 'list'

集合的運算：

　　交集&：生成兩個集合的交集

　　　　　 s1 = {1,2,3}

　　　　　　s2 ={2,3,4}

　　　　　　s3=s1&s2 #{2,3}

　　並集|：生成兩個集合的並集

　　　　　 s4 = s1 | s2 #{1, 2, 3, 4}　

　　補集-：生成兩個集合的補集

　　　　　s5 = s1 - s2 #{1}

　　對稱補集^：生成兩個集合的對稱補集

　　　　　s6 = s1 ^s3 #{1, 4} 等同於（s1 -s2）| (s2-s1)

　　子集<：判斷一個集合是另外一個集合的子集

　　　　　 s1 = {1,2,3}

　　　　　s2 = {1,2}

　　　　　s2 < s1 #True 表示s2是s1的子集

　　超集>：判斷一個集合是另外一個集合的超集

　　　　　s1 >s2 #True 表示s1是s2的超集

　　== / != :集合相同/不一樣，兩個集合的元素和個數相同便可，沒有順序之分

in / not in 運算符

　　等同於字典，in運算符用於集合中，當某個值存在於集合中，則爲真，不然爲假，not in 與in 返回值相反

python3中可用於集合的函數：len（），max（）min（） sum（） any（） all（）

思考：

　　集合是可變對象，有方法能添加，刪除集合的數據嗎？

集合的方法：

　　S.add(e)　　　　　　　　　在集合中添加一個新元素e，若是元素已經存在，則不添加

　　S.remove(e) 　　　　從集合中刪除一個元素e，若是元素不存在於集合中，則會產生:KeyError: 'a'的錯誤

　　S.discard(e)　　　　　　　從集合中移除一個元素e，若是元素不存在則什麼都不作

　　S.clear()　　　　　　　　　清空集合內的全部元素

　　S.copy()　　　　　　　　　將集合進行一次淺拷貝

　　S.pop()　　　　　　　　　從集合中刪除一個隨機元素，並返回該元素，若是此集合爲空，則引起：KeyError: 'pop from an empty set'

　　S.update(S2)　　　　　　　用S和S2獲得的全集更新變量S 。S2可迭代對象，當不是可迭代對象時，報錯：TypeError: 'int' object is not iterable

　　S.difference(S2) 　　　　　用S - S2運算，

　　S.difference_update(S2) 　　等同於S = S - S2

　　S.intersection(S2)　　　　　等同於S & S2

　　S.intersection_update(S2) 等同於S = S& S2

　　S.isdisjoint(S2)　　　　　　若是S 和S2的交集爲空則返回True,不然返回False

　　S.issubset(S2)　　　　　　若是S 和S2的交集不爲空則返回True,不然返回False

　　S.issuperset(S2)　　　　　　若是S是S2的超集返回True，不然返回False

　　S.symmetric_difference(S2) 等同於S^S2

　　S.symmetric_difference_upate(S2) 用S與S2的對稱補集更新S

　　S.union(S2) 　　　　　　　　生成S與S2的全集

對於可變的對象，有時複合賦值運算符不等同於運算後再賦值

　　如：s1 = s1 |s2 不等同於 s1 |=S2

集合推導式：用可迭代對象建立（生成）集合的表達式

　　語法：{表達式 for 變量 in 可迭代對象 [if 真值表達式]} []括號部分的內容表明能夠省略

　　示例：L = [2,3,5,7,3,5,7,11]

　　　　　s = { x**2 for x in L } #{9, 4, 121, 25, 49}

集合推導式的嵌套與列表推導式嵌套規則相同

固定集合 frozenset

　　固定集合是不可變的，無序的，含有惟一元素的集合

　　做用：固定集合能夠做爲字典的鍵，也能夠做爲集合的值（元素）

　　建立空的固定集合：fs =frozenset()

　　建立非空的固定集合：fs = frozenset([2,3,4,7]）

　　構造函數：

　　　　frozenset()

　　　　frozenset(iterable) #同set函數一致，返回固定集合

　　固定集合的運算：

　　　　&交集。|並集。-補集。^對稱補集。> >= < <= == != in /not in (以上運算規則等同於set中的用法)

　　固定集合的方法：

　　　　至關於集合的所有方法去掉修改集合的方法

表達式和運算符（也叫操做符）

表達式expression：由一個數字或數字和運算符組成，必定會返回一個對象（數據）

做用：一般讓計算機作一些事情並返回結果，如：1+2

運算符：

　　算數運算符：

+ 加法（1.0000+1.34=2.34）

- 減法

* 乘法

/ 除法（除法獲得的數是浮點數，不會丟棄小數部分 4/2=2.0)

// 地板除（除的結果去掉小數部分向下取整，3/2=1,3.25//1.5=2.0),

% 求餘(取模mod）10%3=1 10.0%3=1.0

** 冪運算（乘方）

　　比較運算符：<　　小於

<=　　小於等於

> 　　大於

　　　　　　　　>=　　大於等於

　　　　　　　　==　　等於

　　　　　　　　！=　　不等於

語法：左邊表達式 < 右邊表達式。比較運算符返回布爾類型的數值

示例：10 < 20 #True, 1+10 < 2+8 #False

　　布爾運算符：not and or

　　　　布爾非操做 not

　　　　　　語法：not x

　　　　　　做用：對x進行布爾取值，如bool（x）爲Tue，則返回False，不然返回True

　　　　布爾與操做 and

　　　　　　語法：x and y 注：x，y表明表達式

　　　　　　做用：優先返回假值對象，當bool（x）的值爲False時，返回x，不然返回y

　　　　　　示例：（）and 2 返回值爲（），由於（）爲空的元祖布爾值爲False

　　　　布爾或操做 or

　　　　　　語法：x or y

　　　　　　做用：優先返回真值對象，當bool（x）爲True時，則返回x，不然返回y

　　　　　　示例：

score = input("請輸入成績：") or "0"#若是什麼都不輸直接回車則score="0"
score = int(score)
if score < 0 or score >100:
    print("您輸入的成績不合法！！！")
else:
    print("您輸入的成績是：",score)

　　正負號運算符(一元運算符)：+（正號） -（負號）

　　　　語法：+ 表達式

　　　　　　　- 表達式

練習：

　　一、收費標準：3千米之內收費13元，超過3千米後基本單價爲2.3元/千米，

　　　空駛費：超過15千米後，每千米加收基本單價的50%做爲返程的空駛費（3.45元/千米）

　　　要求：輸入千米數，打印出費用的金額（以元爲單位進行四捨五入）

try:
    mileage =int(input("請輸入千米數：") or "0")
    #mileage = int(mileage)
    if 0 <= mileage <=3:
        total_prices = round(13)
        print("您須要支付%s元" %total_prices)
    elif 3 < mileage <=15:
        total_prices = round(13 + (mileage-3)*2.3)
        print("您須要支付%s元" % total_prices)
    elif mileage > 15:
        total_prices = round(13 +(mileage-3)*2.3 + (3.45-2.3)*(mileage-15))
        print("您須要支付%s元" % total_prices)
    else:
        print("請輸入有效的數值！！！")
except Exception as e:
    print("請輸入有效的數值！！！")

　　二、給出一個年份，判斷是否爲閏年並打印結果

　　　閏年的規則：每四年一閏，每百年不閏，四百年又是一個閏年（2016年是閏年，2100年不是閏年，2400年是閏年）

year = int(input("請輸入年份："))
if year % 400 == 0:
    print("是閏年")
elif year % 100 ==0:
    print("不是閏年")
elif year % 4 ==0:
    print("是閏年")
else:
    print("不是閏年")

運算符的優先級：（**）→（* / // %)→（+ -）

數值對象的構造（建立）函數

　　float(obj)：用字符串或數字轉換爲浮點數，若是不給參數則返回0.0如float（）返回值爲0.0

　　int("x", base=10) ：x必須爲有效的字符串（0~9，a~f，A~F），base表示前面的字符串是多少進制的數最大爲36，默認爲十進制，如int("110",2)返回結果爲6

或 int（x=0）：用數字或字符串轉換爲整數，若是不給參數，則返回0，如int() 返回值爲0，

　　complex（r, i):用數字建立一個複數，r表示實部，i表示虛部，如complex(1,2)返回1+2j，若是不給值則返回0j

　　bool(x):用x建立一個布爾值（True/False）

返回Flase的狀況：一切空的東西皆爲假

　　　　　　　　　　　　None、Flase、0、0.0、0j、0J、''、""、（）、[]、{}、set（）

　　函數調用：函數名()

說明：函數調用是表達式，必定返回一個對象的引用關係

基本輸入、輸出函數

　　輸入函數input：是一個阻塞函數

　　　　做用：從標準輸入設備上讀如一個字符串（末尾的換行符會被刪除（回車鍵））

　　　　格式：input（'提示字符串'）

　　　　說明：返回輸入的字符串（僅python3）’提示字符串‘能夠爲空

　　輸出函數print：

　　　　做用：將一系列的值以字符串的形式輸出到標準輸出設備上，默認爲終端

　　　　格式：print(value,.....,sep=' ',end='\')

　　　　選項的關鍵字參數：sep兩個值之間的分隔符（，），默認爲一個空格

　　　　　　　　　　　　　end輸出完畢後在流末尾自動追加一個字符，默認爲換行符'\n'

變量 variable

什麼是變量：變量是用來綁定數據對象的標識符

變量名的命名方法：

變量名必須爲字母或下劃線開頭，後面跟字母或下劃線或數字
不能使用python的關鍵字作變量名（大概有30多個）
變量不是使用表達式如 a+b =「hello」，會報語法錯誤SyntaxError: can't assign to operator，不等同於ab=「hello」

賦值語句 statement

　　語法：變量名 = 表達式如：a = 10

　　　　變量名1=變量名2=表達式如：a = b = 20

變量名1，變量名2 = 對象1，對象2 如 a ，b = 10， 20

　　做用：用於建立變量並將變量綁定（或關聯）在一個對象上

　　說明：

1. 當變量不存在時，建立該變量同時綁定在這個對象上
2. 當變量存在時，改變此變量的綁定的對象
3. 一個變量只能綁定一個對象
4. 兩個變量能夠同時綁定同一個對象如 a = b =10，或a = 10 b = a （不能這樣賦值a，b = 10）

　　實例：

a = 10 # 建立一個變量，和10綁定在一塊兒

b = 20

c = a + b #建立變量c和10+20的結果綁定在一塊兒

is / is not 運算符　　

　　做用：判斷兩個變量是否綁定同一個對象，若是是同一個對象返回True，不然返回False

小整數對象池：

　　CPython中整數-5~256永遠存在於小整數池中，不會釋放並可重複使用

del 語句（del是delete的縮寫）

　　做用：用於刪除變量，同時刪除與對象的關聯關係。若是可能則釋放對象（a，b =10，10，此時10對象被a，b兩個變量所綁定，刪除其中一個則對象10不會倍釋放）

　　語法：del 變量名1，變量名2......

　　python的內存管理和引用計數

　　　　每一個對象都會記錄有幾個變量引用自身，當引用的數量爲0時，則對象被銷燬，此時自動化內存管理的方式叫引用計數（refrence count）

複合賦值算術運算符：

運算符	等同於
y += x	y = y + x
y -= x	y = y - x
y *= x	y = y * x
y /= x	y = y / x
y //= x	y = y // x
y %= x	y = y % x
y **= x	y = y ** x

練習：

在終端輸出圖像
中國古代的稱是16兩一斤，請問216兩是古代的幾斤幾兩？寫程序打印出來
```
a, b=216, 16
print("216兩是古代的%s斤%s兩" %(a // b,a % b))#216兩是古代的13斤8兩
```
從凌晨0：0：0計時，到如今已通過了63320秒，請問如今是幾時，幾分，幾秒？寫程序打印出如今的時間（提示：可使用地板除和求餘實現）

seconds = 63320
hours = seconds//60**2
minutes = seconds % 60**2 // 60
now_seconds = seconds - hours *60**2 - minutes * 60
print("如今是%s:%s:%s" %(hours,minutes,now_seconds))#如今是17:35:20

內建的數值型函數：

abs（x）取x的絕對值
round(number [,ndigits]) 對數值進行四捨五入，ndigits是小數向右取整的位數，負數表示向左取整，是二進制的四捨五入可能有十進制的不一樣

pow（x，y，z=None）至關於x**y 或 x**y % z

語句 statement

　　語句是由一些表達式等組成，一般一條語句能夠獨立執行來完成一部分事情並造成結果。一條語句建議寫在一行內，多條語句寫在一行內須要有分號（；）分開

　　語句分爲：（賦值語句、del語句、if語句、表達式語句）

　　示例：print("hello")

　　　　 x = 100 + 200

　　　　 print("hello");x=100+200#多條語句寫在一行用分號分開

換行：

　　顯示換行：折行號 \

　　隱藏式換行：全部的括號內、三單引號內和三雙引號內換行、，稱爲隱式換行，括號：（），[], {}

if語句

　　做用：讓程序根據條件選擇性的執行某一條語句或某些語句

　　說明：if語句又叫條件語句，也叫分支語句

　　語法：if 真值表達式（必須返回True或False）1：

　　　　　　　　語句塊1（四個空格的縮進）

　　　　　elif 真值表達式2:

　　　　　　　　語句塊2

　　　　　......

　　　　　else:

　　　　　　　　最終的語句塊

　　語法說明：elif子句能夠有0個，1個或多個

　　　　　　　else子句能夠有0個或1個且只能放在if語句的最後

if 語句的真值表達式：

　　if 100：

　　　　print（「真值」）

　　等同於 if bool（100）：

　　　　　　print（「真值」）

if語句的嵌套：

　　if語句自己是由多條子句組成的一條複合語句

　　if語句能夠做爲語句嵌套到另外一個語句的內部

條件表達式：

　　語法：表達式1 if 真值表達式 else 表達式2

　　做用：若是真值表達式的布爾環境值爲True，則執行表達式1並返回結果的引用，不然執行表達式2並返回結果的引用

money = int(input("請輸入商品總額："))
pay = money -20 if money > 100 else money#若是money>100成立則返回前面的結果
print("您須要支付%s元"% pay)

pass語句

　　做用：一般用來填充語法空白，pass語句又名空語句

　　語法： pass

循環語句：

　　while語句

　　　　做用：根據必定條件，重複的執行一條語句或多條語句

　　　　語法：while 真值表達式：

　　　　　　　　　　語句塊1（爲真執行，一直循環）

　　　　　　　else：

　　　　　　　　　　語句塊2（爲假執行，結束循環）

　　　　說明：一、先執行真值表達式，判斷True/False

　　　　　　　二、若是爲True則執行語句塊1，而後跳轉到第一步

　　　　　　　三、若是爲False則執行else子句部分的語句塊2，而後結束此while語句的執行，若是沒有else子句，則直接結束此while語句

　　　　　　　四、else子句部分能夠省略（同if語句相似）

　　　　注意事項：

　　　　　　　一、要控制真值表達式來防止死循環

　　　　　　　二、一般用真值表達式內的變量來控制循環條件

　　　　　　　三、一般要在循環語句塊內改變循環變量來控制循環的次數和變量走向

　　　　while語句嵌套

　　　　　　　while語句自己是語句，和其餘語句同樣，能夠放在其餘複合語句的內部：

　　　　　　　while 真值表達式1：

　　　　　　　　　　...

　　　　　　　　　　while 真值表達式2：

　　　　　　　　　　　　...

　　　　　　　　　　else:

　　　　　　　　　　　　...

　　　　　　　　　　...#控制外循環的次數

　　　　　　　else:

　　　　　　　　　　...　　　　　　　　

　　for語句

　　　　做用：用來遍歷可迭代對象的數據元素（可迭代對象是指能依次獲取數據元素的對象）

　　　　可迭代對象包括：

　　　　　　　列表 list

　　　　　　　元祖 tuple

　　　　　　　字典 dict

　　　　　　　集合 set

　　　　語法：

　　　　　　　for 變量列表 in 可迭代對象：（爲何是變量列表？）

　　　　　　　　　　語句塊1

　　　　　　　else：

　　　　　　　　　　語句塊2

　　　　說明：

　　　　　　　一、可迭代對象每次提供一個元素依次賦值給變量列表中的變量，賦值完畢後執行語句塊1，重複執行此步驟，直到可迭代對象不能提供數據爲止

　　　　　　　二、可迭代對象提供完全部元素後，執行else子句部分的語句塊2，而後退出for語句

　　　　　　　三、else子句能夠省略（同while語句相似）

　　　　　　　四、當在循環內部用break終止循環時，else子句部分語句不會執行

　　　　for語句的嵌套

　　　　　　　for語句內部能夠聽任意語句，包括for語句和while語句

break 語句：

　　做用：用於循環語句（while，for語句）中，用來終止當前循環語句的執行

　　說明：一、當brek語句執行後，此循環語句brek以後的語句將再也不執行

　　　　　二、brek語句一般和if語句組合使用

　　　　　三、brek語句用於終止循環，循環語句的else子句的語句將不會執行

　　　　　四、brek語句只能終止當前循環語句的執行，若是有循環嵌套時，不會跳出嵌套的外部循環

　　　　　五、brek語句只能在循環語句（while或for語句）內部使用

死循環（death loop）：

　　　　死循環是指循環條件一直成立的循環

　　　　死循環一般用break語句來終止循環

　　　　死循環的else子句永遠不會執行

range 函數：

　　range（stop）：從零開始，每次生成一個整數後加1操做，直到stop爲止（不包括stop）

　　range（start，stop[,step]）：從start開始，每次生成一個整數後移動step，直到stop爲止（不包括stop，且step能夠是負整數）

　　做用：用來建立一個生成一系列整數的可迭代對象（也叫作整數序列生成器）

　　說明：range返回的對象是可迭代對象，能夠用於for語句中

continue語句

　　做用：用於循環語句（while，for語句）中，再也不執行本次循環內continue以後的語句，重複開始新的循環

　　說明：一、在while語句中，執行continue語句將會直接跳轉到while語句的真值表達式處從新判斷循環條件

　　　　　二、在for語句中，執行continue語句，將會從可迭代對象中取下一個元素，綁定變量後再次執行循環

階段總結：

數據類型：

　　不可變數據類型：

　　　　bool, int , float, complex, str, tuple, frozenset, bytes

　　可變的數據類型：

　　　　list， dict， set ，bytearray（字節數組）

　　值：

　　　　None ，True， False ....

運算符：

　　+ - * / // % **

　　> >= < <= == ! =

　　is is not

　　in not in

　　not and or

　　& | ^ -

　　+(正號)　 - （負號）

表達式：

　　1+2

　　len（[1,2,3]）

　　條件表達式 x if x >y else y

　　所有的推導式：列表，字典，集合推導式（三種）

語句：

　　表達式語句：

　　　　print（「abc」）

　　　　「hello」

　　賦值語句

　　　　a = 100

　　　　a = b =c =200

　　　　x，y = 100，200

　　if語句，

　　while語句

　　for語句

　　break語句

　　continue語句

　　pass語句

　　del語句

內建函數：

　　len（x）

　　max（）

　　min（）

　　sum（）

　　any（）

　　all（）

***************************

　　bool（）

　　int（）

　　float（）

　　complex（）

　　str（）

　　list（）

　　tuple（）

　　dict（）

　　set（）

　　frozenset（）

**************************************

　　abs（）

　　round（）

　　pow（）

**************************************

　　bin（）

　　oct（）

　　hex（）

　　chr（）

　　ord（）

***************************************

　　range（[start,] stop[,step]）

***************************************

　　input()

　　print()　　　

清除文本中的標點符號

import unicodedata as ucd
import sys
text_data = ["xdl!@","abd*&^ds","!@#$%^&*()~"]
#建立一個標點字典{31232: None}
punctuation = dict.fromkeys(i for i in range(sys.maxunicode) if ucd.category(chr(i)).startswith("P"))
res = [string.translate(punctuation) for string in text_data]
print(res)
#['xdl', 'abd^ds', '$^~']