1.2 python簡介

Python簡介

程式設計語言分類

機器語言：計算機能夠了解的二進制代碼，通過高低電頻的變化實作的（執行效率最高，開發效率低，跨平台性差）
彙編語言：用英文符号代替二進制代碼，但是依舊是直接操作硬體，貼近計算機硬體，是一種低級語言（執行效率高，開發效率低，跨平台性差）
進階語言：用人類能夠了解的符号來編寫程式，進階語言直接調用的是作業系統，而不是直接操作硬體（執行效率低，開發效率高，跨平台型強）

進階程式設計語言的分類方法：

編譯型和解釋型：

編譯型語言：将程式一次性轉換成計算機能了解的二進制語言，執行效率高，開發效率差，跨平台性差

解釋性語言：沒寫完一行指令就轉換成中間格式（位元組碼），解釋一行執行一行，執行效率低，但是開發效率高，跨平台性強

混合型：例如Java語言

強類型和弱類型：

強類型：資料類型不可以被忽略的語言，即變量的資料類型一旦被定義，那就不會再改變，除非進行強轉。在python中，例如：name = '奇點'，這個變量name在被指派的那一刻，資料類型就被确定死了，是字元型，值為'奇點'。

弱類型：資料類型可以被忽略的語言，比如linux中的shell中定義一個變量，是随着調用方式的不同，資料類型可随意切換的那種。

總結：Python是一門解釋型的強類型的語言

Python語言的特點

程式設計語言是用來定義計算機程式的語言，用來向計算機發出指令。
python是一種面向對象的解釋型計算機程式設計語言。
創作者：Guido von Rossum（龜叔）荷蘭人，python語言的創造者。

運作python代碼的兩種方式

互動式：即時得到程式的運作結果，多用于調試
腳本的方式：将程式寫到檔案中，然後用python解釋器運作（python2.7 Python檔案的路徑）

python程式運作的三個步驟

先啟動Python解釋器
解釋器會發送系統套用，将檔案中的内容從硬碟存入記憶體，此時檔案中的字元是普通字元，沒有文法意義
解釋器開始解釋執行存入的代碼，并開始執行文法

文本編輯器編輯檔案的過程（對比）
首先打開文本編輯器
文本編輯器發送系統調用，将檔案内容從硬碟讀入到記憶體中
文本編輯器會将剛剛讀入的内容直接輸出在螢幕上，讓使用者看到結果

前兩步内容差不多，第三個階段不同而已，文本編輯器不會對python代碼進行檢查和執行，知識進行顯示

內建開發環境、虛拟環境

IDE全稱Integrated Development Environment，即內建開發環境，這裡選的是pycharm
虛拟環境：就是一個新的解釋器頁面（有點像微信雙開）

第一行代碼

print('hello world')
# 沒啥說的 print是一個列印函數，顯示相應的内容

常見問題（bug）

命名錯誤：NameError
縮進錯誤：IndentationError
文法錯誤：SyntaxError

debug（調試模式）

斷點調試，從控制台（console）進行控制。

注釋

print('你好')  # 這裡是一個注釋，單行的注釋(規範：如果寫在同行代碼的後面，格式應該是空二格井号空一格注釋内容)，注釋是對關鍵代碼進行注釋，不是全部都需要注釋

'''
這裡是多行的注釋
是不是很神奇
'''

快捷鍵ctrl+/

可以用注釋進行代碼的調，備注是的代碼是不會被執行的
對代碼的解釋說明
記錄工作日志 # TODO 注釋的内容，這樣會在TODO清單中找到需要做的注釋，類似于備忘錄。
通過注釋進行聊天（幾乎接觸不到）

代碼規範書寫--代碼換行

顯示超長行處理：

在連續書寫内容空格位置敲回車，會自動補入一個\，換行顯示，表示目前行沒有書寫完畢。
對于連續的獨立的内容兩端添加（），在括号内就可以任意換行，保持原始輸入單元獨立即可（就是将整體添加（），（）内任意換行，但是該方法不推薦使用）

變量

變量是一種變化的量，程式執行的本質上就是一系列狀态的變化，變是程式執行的直接展現，是以需要一種機制能夠反映或者說是儲存下來程式執行時的狀态，以及狀态的變化，是以出現了變量
變量的使用：先定義後引用
- name='奇點' # 定義
- print(name) # 引用
變量的記憶體管理：
- 記憶體管理：垃圾回收機制，所謂垃圾，就是資料未被變量捆綁，這樣就無法通路該資料，就是垃圾
- 引用計數器：就是一個資料關聯了很多變量，每多一個變量綁定它，引用計數器就加一，當引用計數器為零時，就變成了垃圾（因為無法通過變量找到這個資料了，就相當于荒廢了）
- 引用計數：
- ```
x=10  # 引用計數器加一，為1
y=x   # 引用計數器加一，為2
z=y   # 引用計數器加一，為3
del x # 引用計數器減一，為2
del y # 引用計數器減一，為1
# 都是相對10這個資料來說的，針對的不是變量      
```
  python解釋器自動進行垃圾資料的清理，自動進行記憶體管理
變量的命名：遵循PEP8命名規範
變量的三大組成部分：
- 變量名：指向等号右側值得記憶體位址，用來通路等号右側的值
  
  命名原則：不要使用拼音，不要使用中文，在見名知意的基礎上，盡可能的短，可讀性要高，除此之外，還要符合以下原則
  
  數字字母下劃線組成
  
  不能以數字開頭
  
  不能是python的關鍵字，會造成關鍵字的覆寫，導緻關鍵字不能用了
  
  命名風格：
  
  純小寫加下劃線的方式birth_age（變量名命名建議這個）
  
  駝峰體:BirthAge
- 指派符号：将變量的記憶體位址綁定給變量名
- 變量值：代表記錄事物的狀态
  
  id：反映的是變量值的記憶體位址，記憶體位址不同，id不同——》id(變量名)進行查詢
  
  type：不同的值記錄不同的狀态——》type()
  
  value：代表的是值本身
is和==的差別：
- is是比較左右兩個值的身份id是否相同
- ==是比較兩個值是否相同
- 值相同，id不一定相同（兩塊不同的空間可以存儲一樣的值），id相同，值一定相同
小整數池：python解釋器啟動時，會在記憶體中申請一系列的空間存放常用的證書，友善python調用，這些整數的範圍是-5~256的整數，換句話說-5~256中的整數是一個記憶體空間，257是另外一個記憶體空間（可通過python解釋器驗證）

常量：

在程式運作中不會改變的量，在程式運作中，有些值是固定的，不應該被改變，比如圓周率π

python文法中沒有常量的概念，但是程式開發中會涉及常量的概念，是以約定俗成以全大寫的變量名為常量

基本資料類型

通過作用、定義、使用方法三個方面來學習

整型int：

就是整數

浮點型float：

就是小數

字元串類型str：

定義：'你好'/"你好"/"""你好"""/'''你好''' 四種定義方法（三連可以多行表示）

字元串中想要顯示引号的辦法：

内外的引号不一緻＇ａｂｃ＂ｄ＂＇

使用轉義字元反斜杠＇ａｂｃ＼＇ｄ＼＇＇

字元串之間可以相加，成為字元串的拼接，但是拼接的效率極低，是以不推薦使用

＂ａ＂＋＂ｂ＂＝＂ａｂ＂

清單類型list：

定義：中括号裡面放元素，清單是有序的資料類型——》ｌ＝［１，＇ａ＇，１．１，［１，２，３］］

取值：ｌ［０］——》結果是１

索引對應值，索引從０開始，０代表第一個，索引可以倒數取值，倒數第一個的索引是－１

用途：記錄多個值，通過索引精準定位取值

字典類型dict：

定義：key對應值，其中key通常是字元串類型d＝｛＇name＇：＇david＇，＇age＇：13｝，其中key必須是不可變的資料類型，value可以是任意的資料類型

作用：存儲多個值，每個值都有唯一一個key與之對應key對值有描述性功能

取值：通過key來取值——》d［＇name＇］結果是＇david＇

字典是沒有順序的資料類型

布爾類型bool：

定義：隻有兩個值true和false

顯式布爾值：就是比較的結果，比如3大于2的結果就是true，或者直接就是true

隐式布爾值：0、空字元串、空清單、空字元串、None代表的是false，其他的資料代表的都是true

作用：記錄真假兩種狀态

可變與不可變類型

可變資料類型：值改變時，id不改變，證明改變的是資料本身，證明原值是可以改變的

list、dict

不可變資料類型：值改變時，id改變，證明産生了新的值，原值沒有改變，無法被修改

int、float、str、bool

簡單的說，以不可變的資料類型被認為是python中元素的最小機關，不可再被分割引用，但是可變的資料類型，可被看成是一個容器，其中存放的是元素的位址，當元素改變時，改變是其實是裡面的元素的位址改變了，可變資料類型本身的位址沒變

垃圾回收機制（jc）：

Python自帶的記憶體管理機制，主要針對的是記憶體中的堆區

引用計數：直接引用和間接引用都會将應用計數加一，引用計數為零的資料就是記憶體垃圾，需被清理

直接引用：指的是從棧區出發直接引用到的記憶體位址

間接引用：指的是從棧區出發引用到堆區後，在通過進一步引用才能到達的記憶體位址

容器類資料類型的記憶體原理：清單在記憶體中開辟一個空間，存儲的是索引和索引對應值的記憶體位址，然後值的記憶體位址再指向值，字典的話，存儲的就是鍵和值的記憶體位址（存的是變量的話，就是變量指向的資料的記憶體位址）

# 一個例題
x=10
l=[1,2,x]  # 相當于存放的是[資料1的記憶體位址，資料2的記憶體位址，10的記憶體位址]
x=123
print(l[2])
# 最後列印的結果還是10，不會改變

标記清除

循環引用：

l1=[111]
l2=[222]
l1.append(l2)  # [111的記憶體位址，l2清單的記憶體位址]
l2.append(l1)  # [222的記憶體位址，l1清單的記憶體位址]
# 互相引用，就是循環引用
del l1  # 删除l1的直接引用
del l2  # 删除l2的直接引用
# 一旦将直接引用摘掉之後，還剩下一個間接引用，兩個資料都無法被通路到，但是兩個資料還都不是垃圾，這樣會造成無法清理的垃圾，這就叫記憶體洩漏
# 如何解決：标記清除

标記清除：

記憶體中分為很多區，有一個是棧區，棧區存放的是變量名和記憶體位址的映射關系，一個是堆區，堆區存放的是資料，當存在間接引用時，間接引用的位址都是存放在堆區裡面的（上面例子中的[111的記憶體位址，l2清單的記憶體位址]全都存放在堆區裡面），當删除直接引用之後，還存在間接引用，這時，python解釋器會掃描棧區，将棧區中能夠直接引用或者間接引用能夠通路到的堆區中的資料标記為存活，不能通路的資料标記為非存活對象，應該删除，先标記都清除，是以叫标記清除機制

變量的指派，傳參實際上傳遞的都是棧區的資料，棧的資料就是變量名與記憶體位址的對應關系

分代回收

在曆經多次掃描的情況下，都沒有被回收的變量，gc機制就會認為，該變量是常用變量，gc對其掃描的頻率會降低

分代指的是根據存活時間來為變量劃分不同等級（也就是不同的代）

新定義的變量，放到新生代這個等級中，假設每隔1分鐘掃描新生代一次，如果發現變量依然被引用，那麼該對象的權重（權重本質就是個整數）加一，當變量的權重大于某個設定得值（假設為3），會将它移動到更高一級的青春代，青春代的gc掃描的頻率低于新生代（掃描時間間隔更長），假設5分鐘掃描青春代一次，這樣每次gc需要掃描的變量的總個數就變少了，節省了掃描的總時間，接下來，青春代中的對象，也會以同樣的方式被移動到老年代中。也就是等級（代）越高，被垃圾回收機制掃描的頻率越低

分代回收是為了解決标記清除時反複掃描記憶體效率低下的問題，是典型的空間換時間（掃描的時候需要記住變量引用次數）

使用者互動（輸入輸出）

将結果輸出給使用者：print()函數

格式化輸出：

# 1 %字元串格式化輸出
'my name is %s,my age is %s' %('libai','18')  # 按位置傳值
'my name is %(name)s,my age is %(age)s' %{'name':'libai','age':'18'}  # 以字典的形式傳值

# %s可以接受任意類型
# %d隻能接受數字

# 2 str.format方法
'my name is {},my age is {}' .format('libai','18') # 按照位置傳值
'my name is {0},my age is {1}' .format('libai','18') # 按照索引
'my name is {name},my age is {age}' .format(name='libai',age='18')  # 按照鍵值對進行傳值
# 格式化顯示
'my name is {name=<10}'.format(name='libai')
# 表示的含義是共10個字元的長度，name靠左顯示，剩下的位置用等号填充,"libai====="，大于号是靠右顯示，^是居中顯示
'my age is {age:.3f}'.format(age=18.1111111)
# 顯示的是保留三位小數，處理的方式是四舍五入

# 3 f字元串方法
f'my name is {name},my age is {age}' # 這種方法python3.5以後才有 
f'{print('nihao')}'--->nihao
f'{10+3}'--->13
# 花括号内的字元串會被當做表達式來運作
# 最快的是第三種，第二種第二快，第一種最慢

# 占位符
# %s ：字元串
# %d ：整數
# %6d ：整數，數字用于設定位數，不足補空白‘  1234’
# %f ：浮點數
# %.4f ：設定小數位數，四舍五入，省略數字表示取整1.2000
# %% ：輸出%

接收使用者輸入：input("請輸入你的賬号：")函數

python3中輸入的内容是字元串

在python2中有一個函數raw_input():用法與input一緻，在python2中，input的用法不同，在輸入時必須聲明資料的類型，輸入的資料是什麼類型，就存成什麼類型的資料

pycharm中的提示性資訊

三種波浪線：

灰色是顯示文法存在錯誤，但是不影響使用。
綠色是單詞的拼寫可能存在問題，不影響使用。
紅色是文法的錯誤，必須要進行修改。

運算符

1.算術運算符

+、-、*、/、//整除、%取餘（模運算）、**乘方

優先級與算術運算一緻。

2.比較運算符

==	等于（=是指派）
！=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于

字元串的比較運算

==、！=比較的是字元串是不是一緻

<、> 等判斷時比較的是字元的ASCII碼

總的來說就是數字<大寫字母<小寫字母

當多個字元的時候，比較的原理是第一個和第一個比，再第二個和第二個比……

3.指派運算符

變量的指派：=
增量指派：a+=1（a=a+1）、-=、*=、/=、**=
鍊式指派：x=y=z=10（注意是從右向左開始指派的）
交叉指派：m=10 n=20 交換值 ——》 m,n=n,m
解壓指派：l=[1,2,3,4,5,6] a,b,c,d,e,f=l 解壓指派，必須一一對應，當清單元素特别多時用a,b,c,*_=l，abc一一對應，4,5,6三個資料會被星号聚合成清單傳遞給下劃線，下劃線接收廢棄的資料，但是這種方法隻能幫助取兩邊的值，不能取中間的值（解壓字典預設解壓的是key）

4.邏輯運算符

and：與，兩者必須同時為真才為真，比較非零數字的時候取後面
or：或，兩者滿足一個是真就為真，非零數字比較的時候須選前面
not：非，就是取反
優先級：算術運算>比較運算>not>or>and

短路運算：

10>13 and true
# 所謂短路運算就是進行邏輯運算時，判斷and（或者or）時如果前面是false，就不繼續向下判斷，直接傳回前面的結果false，同理，or運算前面是true的時候，直接傳回true，不會繼續向下運算

5.成員運算符

in 和 not in：判斷元素是否在容器類資料類型中（字元串也可以使用）

6.身份運算符

is ：判斷id是否相同，如果兩個資料的id相同，則一定是相等得（==），但是如果兩個資料的值相等，id不一定相同

流程控制：

if判斷：

if 條件:
    執行的代碼内容
 # 條件為真，執行代碼

# 例如：
a=10
if a>=1 and a<=10:  # 條件1
    print('大于1')
elif a>10 and a<=100:  # 條件2
    print('大于10')
elif a>100 and a<1000:  # 條件3
    print('大于100')
else:  # 條件4，else表示的是剩下的所有情況，如果隻有兩個條件，隻用if和else就行了
    print('大于1000')

# 嵌套用法
if a>=1 and a<=10:
    if a>=5 and a<=10:
        print('比5分高')
    else:
        print('比5分低')
else:
    print('比10分高')

while循環：

通常用循環的變量來控制循環的執行次數。

變量一般是從0開始，判斷時一般是小于，而不是小于等于。

格式：
while 條件：
	反複執行的代碼
else：
	在while循環結束之後執行的，循環的結束不是在break的情況下結束的

# 舉例    
i=0
while i<5:
    print('hello python')
    i+=1

循環的終止與跳出（break與continue）

break：終止循環，執行循環後面的語句（隻跳出本身所在的循環）
continue：結束本輪循環
break與continue都必須出現在循環體中，其隻能控制本身所在的循環，不能控制其他循環

i=100
while i<1000:
    if i//100 == 3:
        break
    print(i)
    i+=1
# 隻列印100到299    
i=100
while i<1000:
    if i//100 == 5:
        continue
    print(i)
    i+=1
# 500-599的内容都不列印

循環終止的另一種方法：改變條件的方式

tag = true
name = input('姓名：')
pwd = input('密碼：')
while tag:
    if name == 'libai' and pwd == '123':
        print('登陸成功')
        tag = false
    else:
        print('請重試')

循環的嵌套

# 理清嵌套的邏輯
i=1
while i<10:
    j=1
    while j<5:
        print(j)
        j+=1
    print(i)
    i+=1
# 對于很多層的嵌套，tag停止循環的方法比break方法要好很多

for循環

for循環在周遊取值上面比while更加的友善

他能夠循環列印可疊代對象中的每一個元素

文法：

for i in 可疊代對象: # 可疊代對象包括清單、字典、字元串、元組、集合

循環的代碼内容

for i in [1,2,3,'nihao']:
    print(i)  # 列印清單裡面的所有元素

# range（）函數

for i in range(0,10,1): # 括号裡面的數字依次是起始值，終止值與步長，如果隻寫一個數字，預設從0開始，實際上就是産生了一個從零開始，步長為一的清單

print(i)

# 列印結果是0到9

在for循環中同樣可以使用break、continue和else，效果和while循環中一樣

for循環可以嵌套使用

補充：實際上range隻是在效果上和清單一樣，但是實際上相當于疊代器，比清單更加的節省存儲空間

函數介紹print（）和len（）

print（）函數就是列印，需要注意的是，print這個函數是沒有傳回值的，無法傳遞給變量，也就是傳遞給變量之後，顯示的結果是none

列印多個對象的時候用逗号隔開就行

end是設定每一行結束之後的标點，預設情況下是換行（end='\n'），這也是為什麼兩個print的内容預設呈現兩行的原因

len（）函數是将可疊代對象的長度計算出來

深淺copy

淺copy：

l1=[1,2,3,[1,2]]
l2=l1.copy
# 此時兩個清單的id不同

淺copy是将清單内容（清單裡面放的是元素索引和元素資料的位址）複制一份給新的清單（新的清單和舊的清單id是不同的），對于清單裡面的元素，用的都是一個（簡單的來說就是将清單的殼複制了一份，裡面裝的東西還是一樣的）

當需要對清單裡面的資料進行改變的時候，可變類型和不可變類型的資料有所不同，不可變的資料類型如果更改（例如将l2清單的1換成100），就直接建立一個新的資料，指向新的資料（例子中的100），原清單（l1）不受影響，但是對于可變的資料類型（例如l2裡面的[1,2]），更改裡面的資料（将[1,2]裡面的2換成200）會直接影響原來的資料（這時l1裡面的[1,2]也會變成[1,200]）

簡單的說就是複制一個外殼，裡面的資料用的都是一樣的，但是改變元素的時候，可變類型的元素不共用，可變類型的資料共用一套

深copy：

import copy
l1=[1,2,3,[1,2]]
l3=copy.deepcopy(l1)
# 此時兩個清單的id也不同

深copy的時候，不可變的元素共用，但是修改的時候建立一個新的資料，指向新的資料（這和淺copy是一樣的），對于可變的元素（例如l1裡面的[1,2]），是複制一個新的外殼（id不一樣），裡面的元素還是共用，但是修改的時候，是會指向新的資料，對原來的清單沒有影響（解決了可變類型的元素共用的問題，修改元素時互不影響）

資料類型裝換和方法

整型

在python中，age=10,相當于age=Int（10），int（）函數就是将一個對象轉換成整型的資料，需要注意的是，轉換字元串的時候，隻能将純數字的字元串轉換成整型（浮點數也一樣），否則會報錯

十進制轉換成二進制bin（）函數

十進制轉換成八進制oct（）函數

十進制轉換成十六進制hex（）函數

二進制轉換成十進制 int（'10010',2）第二個數字2是說明前面的數字是二進制的意思，八進制就寫8，十六進制就寫16

内置方法：基本上沒啥方法，多在算數運算和比較運算中使用

浮點型

float（）将一個對象轉換成浮點數類型，

虛數

complex（實部，虛部）

可以了解一下位運算相關知識

字元串類型

str（）将任意類型的資料轉換成字元串

s1='hello world'

# 按照索引取值和切片

s1[3] # 得到l

s1[1:7:2] # 從索引1開始到索引8結束，每隔兩個字元(步長)取一個值得到el o

s1[-1:-3] # 得到lr

s1[::-1] # 倒着取全部的字元串

## 需要注意的是字元串不能通過索引進行改值，因為是不可變的資料類型

# 統計長度

len(s1)

# in和not in

判斷字元是否存在在字元串中，傳回true或false

'l'in s1 # true

# strip() 移除字元串兩側的符号，隻去除兩邊，不去除中間的

s2='nihao/.//*'

s3=s2.strip('') # 括号裡面是想要去掉的符号，剩下nihao/.//</span>

s4=s2.strip('*/.') # 去掉兩邊的多種符号,隻剩下nihao

lstrip() # 隻去除左邊的（left）

rstrip() # 隻去除右邊的（right）

## 應用在輸入的時候對字元串進行處理（去掉兩邊的空格）

# split和rsplit切分方法，按照某種分隔符進行拆分，得到的是一個清單(預設分隔符是空格)

s1.split(' ') # 按照空格進行拆分，得到['hello','world']

s1.split(' ',1) # 設定分隔次數(就是從第一個空格開始分隔，分成兩個元素的清單)

s1.rsplit(' ',1) # 從右向左開始切分

# s1.upper() 英文字母全部大寫 HELLO WORLD

s1.isupper() # 判斷是否全是大寫

s1.lower() 英文字母全部小寫 hello world

s1.islower() # 判斷是否全是小寫

s1.isdigit() # 判斷是否全是數字

s1.title() 對單詞的首字母的大寫 Hello World

s1.startswith('h') 判斷是不是以h開頭的字元串

s1.endswith('d') 判斷是不是以d結尾的字元串

# join()将清單拼接成字元串

l1=['ni','hao','ya']

'!'.join(l1) # 用！l1的三個元素連起來——》'ni!hao!ya'

# replace()替換方法

s1.replace("l",'L',1) # 将第一個l替換成大寫的L，如果不寫數字預設替換掉所有

# 了解内容

find()和index()

s1.find('ll')

s1.index('ll')

# 兩者都是傳回查找的子字元串的第一個字元的索引，不同之處在于find如果找不到傳回的是-1，index如果找不到直接報錯，是以使用find要好一點

# s1.count('l') # 傳回l在字元串中出現了多少次

# center()rjust()ljust()zfill()

'nihao'.center(20,'') # 創造一個20字元長度的字元串，nihao居中顯示，其他的位置用填充

'nihao'.rjust(20,'') # 創造一個20字元長度的字元串，nihao右對齊顯示，其他的位置用填充

'nihao'.ljust(20,'') # 創造一個20字元長度的字元串，nihao左對齊顯示，其他的位置用填充

'nihao'.zfill(20) # 創造一個20字元長度的字元串，nihao右對齊顯示，其他的位置用0填充，z是zero的意思

# s1.expandtabs(10) # 當s1中有制表符時，指定制表符的長度，這裡指定的是10個字元長度

# s1.capitalize() # Hello world整個字元串的第一個首字母大寫

s1.swapcase() # 将字元串中的大寫字元變成小寫，小寫字元變成大寫

# is系列，判斷字元串中的字元的種類，傳回true和false

.islower() # 全是小寫

.isupper() # 全是大寫

.istitle() # 單詞的首字母是大寫

.isalnum() # 全是字母或者數字

.isalpha() # 全是字母

.isdecimal() # 全是數字

.isspace() # 全是空格

.isidentifier() # 判斷辨別符是不是合法的，如果是關鍵字的話傳回true

# .numberic()和.digit()和.isdecimal()的差別

.isnumberic() # 能夠判斷是不是阿拉伯數字、羅馬數字、中文數字

.isdigit() # 隻能判斷是不是阿拉伯數字（Unicode和bytes類型的數字）

.isdecimal() # 智能判斷是不是unicode顯示的數字（python3中預設是unicode）

清單

list()方法，将一個可疊代對象變成清單，元素就是可疊代對象的每一個元素，清單式有序的

清單可以通過切片和索引進行取值

l1=[111,'nihao',3.3]
# 查
l1[0]  # 結果是111
l1[0:3:2]  # 結果是切片相當于一種copy，是一種淺copy，不改變本身的值，隻是複制一份
# 改
l1[0] =222  # 索引存在的話可以直接改值，不存在的話直接報錯[222,'nihao',3.3]
# 增
l1.append('qidian')  # 在清單後面追加值[222,'nihao',3.3,'qidian']
l1.insert(0,'ni')  # 在索引為0的位置直接添加值['ni',222,'nihao',3.3,'qidian']
l1.extend('abc')  # 疊代着追加在清單的後面['ni',222,'nihao',3.3,'qidian','a','b','c']
# 删
del l1[0]  # 通用的删除方法，單純的删除，但是沒有傳回值，無法指派
l1.pop(2)  # 根據索引删，不指定索引（括号裡面不填值），預設删除最後一個，有傳回值，傳回删除的那個值
l1.romove('nihao')  # 按照對象删，制定删除的對應元素,傳回值是none

# in和 not in 也适用于清單

# 一些需要掌握的内置方法

l1.count() # 查找元素出現的次數

l1.index() # 查找元素的索引

l1.clear() # 清空元素，将清單變為空清單

l1.reverse() # 将元素的順序颠倒

l1.sort() # 預設是從小到大排序（升序），傳入參數reverse=true（預設是false），變成元素從大到小排序（降序）

## 在使用sort方法時，清單内元素必須是同種類型才可以，字元串的排序是按照ASCII碼表的順序來比較的，在進行字元串的比較的時候，是按照相對應的位置的字元來比較的，同理清單的比較也一樣

不建議在循環中修改清單等可變資料類型，因為這樣會改變清單的索引

隊列和堆棧

隊列：一種資料結構，特點是FIFO（first in first out）像是管道

堆棧：特點是LIFO（last in first out）像是水桶

元組

元組是一種不可變得資料類型，相當于一個不可變的清單，但是元組内的元素不能重複，元組的作用就是按照索引存放多個值，隻用于讀不能修改

對于元組中存放的可變的資料類型（比如說清單），是可以進行修改的，但是清單的記憶體位址是沒有改變的

元祖的函數是tuple()

元祖的表示是（1,2,3,4,5,6），需要注意的是，隻存放一個資料的時候，表示為（1，）（1）表示的是整數1

# 無法進行修改，是以增删改都不可以使用，隻能使用索引檢視，可以切片檢視，可以使用in和 not in判斷，方法隻能使用index和count，與上面的原理一樣，這裡就不說了

字典是鍵值對組成的，鍵（key）和值（value）是一一對應的

key必須是不可變的資料類型，并且不可重複，value可以是任何類型

表示{'name':'david','age':18}

建立字典的函數方式：dict（）

# 空字典{}
# 字典的建立
d=dict(x=1,y=2,c=3)

l=[[1,'a'],[2,'b'],[3,'c']]

d1=dict(l) # 直接得到字典{1:'a',2:'b',3:'c'}

key1=[1,2,3]

none

{}.fromkeys(key1,none) # 得到字典{1：none,2:none,3:none}，原理将前面的可疊代對象的每一個元素都當做key，值是同一個，都是none，這種方式常常用于快速初始化一個字典，值的部分通常不使用可變的資料類型，一般是none，或者是可變的資料類型

# 改/增

d1={1:'a',2:'b',3:'c'}

d1[1] # 檢視值，如果鍵值對不存在會直接報錯

d1.get(1，'當key不存在的時候get方法的傳回值') # 是為了彌補使用索引進行查詢的時候，如果字典中沒有對應的鍵會直接報錯，但是get方法會傳回none

d1[1]='asd' # 鍵存在的話就是直接修改值

d1[4]='d' # 如果key不存在的話就直接增加鍵值對

len(d1) # 計算長度

# 成員運算in 和 not in判斷的是key

# 删除

del d1[1] # 直接删除鍵值對

d1.pop(1) # 預設删除最後一個，或者按照鍵删除，傳回删除的key對應的值

d1.popitem() # 随機删除，傳回删除鍵值對組成的元組

# 其他的一些方法，下面是在python2中得到的結果，在python3中進行了優化，将每個得到的結果換成了疊代器，為了節省記憶體空間

d1.keys() # 得到key組成的清單

d1.values() # 得到value組成的清單

d1.items() # 得到鍵值對組成的元組形成的清單

d1.clear() # 全删除，清空

d1.update(d2) # 在d1中有的鍵值對，還繼續保留，d1中沒有d2中有的鍵值對，将其增加到d1中

d1.setdefault(1，'abc') # 如果鍵值在原字典中存在，就不會對原字典進行修改

d1.setdefault(5,'e') # 如果鍵不存在，就将鍵和預設值形成鍵值對添加到字典中

集合

在{}内用逗号分隔開多個元素，元素滿足以下條件：

集合内元素必須是不可變類型

集合内元素無序

集合内元素沒有重複

{}是空集合，集合的函數是set（）

集合有兩個用處，一個是關系運算，一個是去重

# 類型轉換
s=set('abcde')  # {'a','b','c','d','e'}要注意的是，集合裡面放的是不可變的資料類型
# 集合的關系運算與相關的内置方法
s1={1,2,3,4,5}
s2={2,3,4,5,6}
# 取交集，兩個集合共有的元素
s1&s2  # {2,3,4,5}
s1.intersection(s2)
# 取并集，兩個集合相加去重
s1|s2  # {1，2,3,4,5，6}
s1.union(s2)
# 取s1獨有的元素（差集）
s1-s2  # {1}
s1.difference(s2)
# 對稱差集，就是兩個元組所獨有的元素組成的集合
s1^s2  # {1，6}
s1.symmetric_difference(s2)
# 父子集，包含的關系若s1的元素包含s2裡面的元素，就稱s1是父集合，s2是子集合（兩個集合相等就互為父子）
s1>s2  # 用大于小于表示，傳回true或者false，這裡的s1和s2不存在父子關系，傳回false
s1.issuperset(s2)
s1.subset(s2)

# 集合的去重（有局限性）

局限1.隻能針對不可變得資料類型進行去重

局限2.無法保證原來的順序

# 集合可以計算長度len()方法

集合可以進行成員運算in和not in

集合可以用for方法進行循環

s1.remove(1) # 可以删除元素，但是删除不存在的元素會報錯是以有了discard方法

s1.discard(9) # 同樣可以删除，但是删除不存在的元素的時候什麼都不會做，相當于沒進行操作

s1.update(s3) # 将新集合加到原來的集合中在将重複的去掉（相當于取并集）

update方法可以和交集并集等方法運算的函數結合使用，下面舉個例子就明白了

s1.deiierence_update(s2) # 就是先去差集然後在進行update

s1.clear() # 将集合進行清空

s1.pop() # 随機删除

s1.add(8) # 增加元素

s1.isdisjoint() # 如果兩個集合完全獨立，沒有共同部分，傳回true

資料類型總結

按照存值個數區分
隻能存一個值，稱為标量/原子類型	數字、字元串
可以存多個量，稱為容器類型	清單、元組、字典

按通路方式區分
直接通路，隻能通過變量值通路某個值	數字
順序通路：可以通過索引通路，也叫序列類型	字元串、清單、元組
key通路：又被稱為映射類型	字典

按照可變不可變區分
可變類型	清單、字典
不可變類型	數字、字元串、元組

案例：列印三位回文數（第一位和第三位相同的數字）

i=100
while i<1000:
    if i//100 == i%10:
        print(i)
    i+=1

案例：列印乘法表

i=1
while i < 10:
    j=1
    while j <i+1:
        print('%d*%d=%d' %(i,j,i*j),end=' ')
        j+=1
    print()
    i+=1

案例：累加求和

# 列印1到100的和
i=0
j=0
while j<=100:
    j+=1
    i=i+j
    print(i)