PythonBasic

PythonBasic

Python程序的組成

程序由模塊組成

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

語句包含表達式

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

Python運行

一、python3 hello.py

二、（前提：文件內加上#！ /usr/bin/python3）

chomd u+x hello.py 以後用 ./hello.py

Python的交互提示模式

退出：ctrl+d / exit

# 井號開頭，註釋

Python核心數據類型

數字（int；float；複數complex（real、image）；布爾類型）

字符串

列表等

整型數int

整型數是不帶小數部分的數字。包括天然數、0、負數

如：-五、10000、0等

進制：

十進制：10，20，

二進制：0b開頭，後面跟0～1

0b111；0b101；0b1111

八進制：0o開頭，後面跟0～7

0o177 #127

0o11  #9

十六進制：0x開頭，後面給0～9，A～F，a～f

0x11 #17

0xFF #255

ox1234ABCD

進制轉換：

十進制（十進一）

二進制（二進一）

八進制（八進一）

十六進制（十六進一）

二進制轉八進制：三個數爲一組

0b    11    011    001

0o    3 3 1

二進制轉十六進制：四個數爲一組

0b    1101    1001

0x     d       9

hex(i) 將整數轉換爲十六進制字符串

oct(i) 將整數轉換爲八進制字符串

bin(i) 將整數轉換爲二進制字符串

浮點型數float

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

表示形式：

小數形式：3.1四、3.一、3.、0.1四、.14

科學計數法：e/E（正負號）指數：6.18E-1=0.618

複數complex

分爲兩部分：

實部（real）

虛部（image）虛部以j或J結尾

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

布爾類型數bool

用來表示真和假兩個狀態的類型

True 表示真、值爲1（條件知足或成立）

Flase表示假、值爲0（條件不知足或不成立）

空值None

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

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

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

表達式expressioin

有一個數字或數字和運算符組成

做用：一般讓計算機是作一些事情並返回結果

例如：1 + 2

運算符：

算術運算符：+、-、*、/、//、%、**

除法：獲得的是浮點數，不會丟失小數部分

1/3 = 0.3333333333333333

4/2 = 2.0

地板除：除到的結果去掉小數部分向下取整

7/3 = 2.3333333333333335

7//3= 2

8//3= 2

3.25//1.5=2.0

求餘（取模）：

10 % 3 = 1

3.25 % 1.5 = 0.25

冪運算：

x ** y

4 ** 2 = 16

3.0 ** 4.0 = 27

5.6 ** 1.418 = 11.506165654866916

運算符的優先級

**

* / // %

+ -

括號分組子表達式

用()能夠將表達式分組，()內的表達式先進行計算

混合類型自動升級

1 + 2.14 返回浮點數3.14

variable 變量

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

方法：

一、變量名必須爲數字或下劃線開頭，後跟字母或下劃線或數字

二、不能使用python的關鍵字作變量名

合法示例：a a1 b bbb _aaa _Abcd var a1b2c2

不合法示例：1a 123 $ABC +a -b #ab @ab

python關鍵字：True, False, None, is, del, if, elif等

statement 賦值語句

語法：

變量名 = 表達式

變量名1 = 變量名2 = 表達式

變量名1, 變量名2, …… = 序列

做用：

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

說明：

一、當變量不存在時，建立該變量同時綁定在這個對象上

二、當變量存在時，改變次此量綁定的對象

三、一個變量只能綁定一個對象

四、兩個變量能夠同時綁定同一個對象

示例：

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

b = 20

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

a1 = b2 = c1 = 100

關聯、綁定、引用的含義

在python中，變量沒有類型

關聯、綁定、引用都是指變量和一個對象的關聯關係

在交互模式下查看變量綁定關係：help('__main__')

自動化內存管理

a = 10000

建立「10000」數據對象在內存；a和10000相關聯（經過a找到10000）；

b = 20000

建立「20000」數據對象在內存；a和10000相關聯（經過b找到20000）；

a = a + b

建立「30000」數據對象在內存；a和30000相關聯（經過a找到30000）； 10000被銷燬

python的內存管理和引用計數

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

序列賦值

變量名1, 變量名2, …… = 對象1, 對象2, ……

變量名1, 變量名2, …… = (對象1, 對象2, ……)

變量名1, 變量名2, …… = [對象1, 對象2, ……]

x, y = 1, 2

變量的交換綁定

a, b = b, a

is / is not 運算符

做用：判斷兩個對象是否綁定同一個對象，若是是同一個對象，返回True，不然False。is not相反。

語法：

a = b = 10000

s is b # True

a = 10000

b = 10000

a is b # False，由於建立了新的對象，他們綁定的不是同一個對象

小整數對象池：Cpython中整數-5～256永遠存在與小整數對象池中，不會釋放，會重複使用。

a = 5

b = 5

a is b # True，由於在小整數對象池中的對象

id() 函數

做用：返回一個對象在內存中的地址

格式：id(對象)

del 語句

做用：用於刪除變量，同時刪除與對象的關聯關係。若是可能則釋放對象。

語法：del 變量名

python的內存管理和引用計數

每一個對象都會記錄有幾個變量引用自身，當引用的數量爲0時，則對象被銷燬，此種自動化內存管理方式叫作引用計數(reference 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

比較運算符

<

<=

>

>=

==

!=

語法：

左表達式 < 右表達式

說明：

比較運算符返回布爾類型的值

示例：

10 < 20 # True

1 + 10 > 2 + 8 # True

10 < 20 <= 30 # True

數值對象的構造函數

float(obj)

用字符串或數字轉換爲浮點數，若是不給出參數則返回0

int(x,base=10) 或 int(x=0); base是進制

用數字或字符串轉換爲整數，若是不給出參數，則返回0

compx(r=0.0, i=0.0)

用數字或字符建立一個複數

bool(x)

用x建立一個布爾值(True/False)

返回假值的狀況

None 空

False 假

0, 0.0, 0j

''

()

[]

{}

set()

函數調用

函數名(傳參列表)

說明：

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

內建數值型函數

abs() 取絕對值

round(x[, ndigits]) 四捨五入；ndigits正數時是向右取整的位數

round(x, -1)

pow(x, y) x ** y

help() 函數

做用：查看函數幫助文檔

用法：help(函數名)

statement 語句

語句是有一些表達式等組成，經過一條語句能夠獨立執行來完成一部分事情並造成結果

一天語句建議寫在一行內

多條語句寫在一行內須要用分號(;)分開

示例：

print("hello")

x = 100 + 200

print(x)

del x

換行：

顯式換行 \

隱式換行 括號內換行() [] {}

示例：

i = 1 + 2 + 3 \

  + 4 + 5

i = (1 + 2 + 3 

       + 4 + 5)

input() 基本輸入函數

做用：從標準輸入設置上讀取一個字符串（末尾的換行符會被刪除）

格式：input("提示字符串")

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

示例：

s = input("請輸入字符串:")

print("您輸入的字符串是:", s)

print(1+int(s)) 轉換整形

print() 基本輸出函數

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

格式：print(要打印的數據)；各數據能夠用逗號分隔開

示例：

print(1+2)

print("hello")

print("1 + 2 =", 1 + 2)

print(value,value, sep=''（分隔符號默認空格）,end='\n')

if 語句

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

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

語法：

if 真表達式1:

語句塊

elif 真表達式2:

語句塊2

elif 真表達式3:

語句塊3

……

else:

語句塊4

elif能夠有多個；else只能有0個或1個；

要求：if語句內部的語句一般要以4個空格的是縮進來表示包含關係，相同的縮進格式表明相同的所屬級別

s = input("請再輸入字符串:")

j = int(s)

if j > 100:

print("Bigger than 100")

elif 0 < j < 20:

print("Between 0 and 20")

else:

print("Other")

if 語句的真值表達式

if 100:

print("真值")

# 等同於

if bool(100):

print("真值")

if 語句嵌套

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

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

if 1 <= month <= 12:

print("是合法的月份")

if month <= 3:

print("是春季")

elif....

else:....

條件表達式

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

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

示例：

商場促銷滿100減20

money = int(input("請輸入商品總額"))

pay = money - 20 if money >= 100 else money

print("您須要支付", pay, "元")

pass 語句

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

語法：psss

示例：

g = int(input("請輸入學生的成績"))

if 0 <= g <= 100:

psss

else:print("不處於成績範圍")

布爾運算

運算符：

not and or

布爾非操做：not

語法：not x

做用：對x進行布爾取值，如bool(x)，爲True，返回False，不然返回True

示例：

not True = False

not 100 = False

布爾與操做：and

語法：x and y

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

示例：

True and True = True 

True and False = False

100 and 200 = 200

布爾或操做：or

語法：x or y

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

100 or 200 = 100 （都爲真優先返回左側的）

應用：

sore = int(input("請輸入成績：") or '0')

if score < 0 or score > 100:

print("您的成績不合法！！！")

else:

print("您輸入的成績是：", score)

正負號運算符

+（正號） -（負號）

語法：

+ 表達式

- 表達式

示例：

a = 5

b = -a

str 字符串

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

表示方法：

' 單引號

" 雙引號

單引號和雙引號的區別：

單引號內的雙引號不算結束符

雙引號內的單引號不算結束符

''' 三單引號

""" 三雙引號

三引號字符串：

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

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

s = '''Welcome to Beijing

I like Python!

I am learning!'''

print('Welcome to Beijing\nI like Python!\nI am learning!')

用轉義序列表明特殊字符

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

字符串中的轉義字符表

\' \" \\ 

\n \r(光標返回行首並替換) \f(換頁) \t(水平製表符) \v(垂直製表符) 

\b(倒退、刪除) \0(空字符) 

\0oo(oo爲兩位八進制表示的字符) 

\xXX(XX爲兩位十六進制表示的字符)

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

\uXXXXXXXX(Unicode16的十六進制表示的字符)

ASCII編碼

man ascii (八進制十六進制均可以表示)

經常使用ASCII：

字符  十進制  十六進制

'0'   48      0x30

'A'   65      0x41

'a'   97      0x61  

ord(c) 返回一個字符串的Unicode

chr(i) 返回i這個值所對應的字符

print(ord('A')) # 65

print(ord('中'))# 20013

raw 字符串（原始字符串）

字面格式：r'字符串內容'(""","")

做用：讓轉義字符\無效

示例：

a = 'C:\newfile\test.py'

print(a)

print(len(a))

a = r'C:\newfile\test.py'

print(a)

print(len(a))

字符串的運算

算術運算符：

+ += * *=

+ 加號運算符用於字符串的拼接

x = 'abcd' + 'efg'

print(x) # abcdefg

x += '123'  # abcdefg123

* 運算符用於生成重複的字符串

x = '123'

y = x * 2 # y = '123123'

比較運算符：

> >= < <= == !=

示例：

'A' < 'B' # True

'B' < 'a' # True

'AD'< 'ABC' # False 從左到右依次相比

'ABC' == 'abc' # False

in / not in

做用：用於序列、字典、集合，判斷某個值是否在該容器中返回TF

格式：對象 in 容器

示例：

s = 'Welcome to Ningbo!'

'to' in s #True

index 字符串的索引操做

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

index 索引

索引語法：字符串[整數表達式]

說明：

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

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

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

s[0] = s[-len(s)] # W

最後一個s[len(s) - 1] = s[-1]

slice 切片

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

語法：字符串[(開始索引b)]:(結束索引e):(步長s)]

注：()內括起的部分表明能夠省略

說明：

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

二、結束索引是切片的終止索引(但不包括終止索引)

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

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

2）當步長爲正整數時，取正向切片：

補償默認值爲1，開始索引默認值爲0，結束索引的默認值爲len(s)

[開始：結束：步長]

默認：[0:len(s):1]

反向：[::-1]

3）當步長爲負整數時，取反向切片：

反向切片時，默認的起始位置爲最後一個元素，默認停止爲第一個元素的前一個位置

示例：

s = 'ABCDE'

a = s[1:4] # a -> 'BCD'

a = s[1:]  # a -> 'BCDE'

a = s[:2]  # a -> 'AB'

a = s[:]   # a -> 'ABCDE'

a = s[1:4:2] # a -> 'BD'

a = s[::2] # a -> 'ACE'

經常使用的序列函數

len(seq) 返回序列長度

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

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

示例：

s = 'ABCDE'

len(s) 5

整數轉換爲字符串函數

ord(c) 返回一個字符串的Unicode編碼值

chr(i) 返回i這個值所對應的字符 = %c % i

hex(i) 將整數轉換爲十六進制字符串

oct(i) 將整數轉換爲八進制字符串

bin(i) 將整數轉換爲二進制字符串

str() 字符串的構造、建立函數

str(obj='') 將對象轉換爲字符串

常見的字符串方法

調用語法：對象.方法名()

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

示例：

'abc'.isalpha()

if 'abc'.isalpha():

print("True")

s.(30, '#') #給出寬度居中 默認爲空格

s.count('A', 3, 5) #返回3到5的A個數

s.find()

s.strip() #去掉左右側空白字符，lstrip，rstrip

s.upper() #返回大寫

s.lower() #返回小寫

s.replace(old, new, 個數)

s.startwith() #判斷開頭

s.endswith() #判斷結尾

s.title() #將開頭變成大寫

字符串格式化表達式

運算符：%

做用：生成必定格式的字符串

語法：

格式字符串 % 參數值

格式字符串 % (參數值1,參數值2,……)

格式字符串中的%爲佔位符

示例：

fmt = "姓名:%s, 年齡:%d"

name = input("請輸入姓名：")

age = int(input("請輸入年齡："))

s = fmt % (name, age)

print(s)

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

佔位符 意義

%s 字符串用str轉換

%r 字符串用repr轉換

%c 整數轉換爲單個字符

%d 十進制整數

%o 八進制整數

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

%X 十六進制整數（a-f大寫）

%e 指數型浮點數（e小寫）

%E 指數型浮點數（E大寫）

%f 浮點十進制

%g 自動轉換指數

%% %

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

語法：% [格式語法] 類型碼

- 左對齊

+ 顯示正號

0 補零

寬度（整數）

寬度.精度(整數)

例如：

'%10d' % 123 # '          123'

'%-+10d'% 123 # '+123          '

'%010d'% 123 # '0000000000123'

'%7.3f' % 3.1415926

format 函數格式化字符串

s = "I love {}".format("WW")

print(s)

s1 = "I love {0} and {1}".format("haha",99)

s2 = "haha {0}"

s2.format("shibushi")

while 循環語句

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

語法：

while 真表達式:

語句

else:

語句

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

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

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

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

注意事項：

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

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

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

示例1：

i = 1

while i < 5:

print("Hello World!")

i += 1

else:

print("條件不足，此時變量i=%d，循環結束" % i)

示例2: 只用一個變量

while 1 <= n:

print("Hello World!")

n -= 1

else:

print("條件不足，此時變量n=%d，循環結束" % n)

示例3:用while語句打印1～20的整數（包含20）

i = 1 

while i <= 20:

print(i)

i += 1

print("End!")

while 語句嵌套

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

語法：

while 真值表達式:

……

while 真值表達式2:

……

else:

……

……

else:

……

j = 1

while j <= 10:

i = 1 

while i <= 20:

print(i, end=' ')

i += 1

print("End!")

j += 1

break 語句：

做用：用於while、for語句停止當前循環的語句，經常和if連用

說明：

一、當break語句執行後，此循環語句break以後的語句將再也不執行

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

三、break語句停止循環時，循環語句的else子句的語句將不會執行

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

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

示例：

i = 1

while i <= 6:

print("本次循環開始時：", i)

if i ==3:

break

print("本次循環結束時：", i)

i += 1

死循環

概念：死循環是指循環條件一直成立的循環、一般用break語句來停止循環，死循環的else子句永遠不會執行

示例：

while True:

n = int(input("請輸入"))

if n == 0:

break

print(n)

for 語句

做用：用來遍歷可迭代對象的數據元素，可迭代對象是指能以此獲取數據元素的對象，可迭代對象包括：

字符串str、列表list、元組tuple、字典dict、集合set……

語法：

for 變量列表 in 可迭代對象：

語句快1

else: (結束循環後)

語句快2

說明：

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

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

三、else子句部分能夠省略（同while相似）。

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

示例：

s = 'ABCDE'

for ch in s:

print("ch--->", ch)

else:

print("for語句執行else語句")

print("程序退出")

for 語句嵌套

for 語句內部能夠放冉義語句，包含for語句和while語句

示例：

for x in 'ABC':

for y in '123':

print(x+y)

count = 0

for x in range(5):

for y in range(10):

count += 1

print(count)

range() 函數

格式見：help(range)

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

函數：

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

rang(start, stop[, step])

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

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

示例：

range(4) # 0, 1, 2, 3

range(3, 6) # 3, 4, 5

range(1, 10, 2) # 1, 3, 5, 7, 9

range(5, 0 , -2)# 5, 3, 1

range(4, 0) # 空

for x in range(4):

print(x)

for x in range(3, 6):

print(x)

continue 語句

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

說明：

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

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

示例：

for x in range(5):

if x == 2:

continue

print(x)

sequence 序列類型

字符串 str

列表 list

元組 tuple

字節串 bytes

字節數組 bytearray

list 列表

概念：列表式由一系列特定元素組成的，元素和元素之間沒有任何關聯關係，但他們之間有前後順序關係。列表式一種容器，是序列的一種，是能夠被改變的序列

建立列表：

L = [] # 空列表

L = [1, 2, 3, 4]

L = ["北京", "上海", "重慶"]

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

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

構造函數：list()、list(interable) 用可迭代對象建立一個列表

L = list(range(1, 10, 2))

L = list("ABCD")

list 運算

算術運算：

+ += * *=

+ 用於拼接

x = [1, 2, 3]

y = [4, 5, 6]

z = x + y  (拼接)

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

x += [4,5,6] -> [1,2,3,4,5,6]

x += 'ABC'   -> [1,2,3,4,5,6,'A','B','C']

* 用於生成重複的列表

x = [1, 2]

x *= 3 # x = [1,2,1,2,1,2]

比較運算：

< <= > >=  == !=

x = [1,2,3]

y = [2,3,4]

x != y  # True

x > [1,2] #True

x < y #True

[1,3,2] > [1,2,3] # True

['AB', 'CD'] > ['AC', 'BD'] #False

[1, 'two'] > ['two', 1]  # Typeerror

list in / not in

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

示例：

x = [1. 'Two', 3.14, '四']

1 in x    # True

2 in x    # True

'四' not in x # False

list index / slice

取值語法：列表[整數表達式]

取值用法：列表的索引取值與字符串的索引取值規則徹底相同，列表的索引爲分正向索引和反向索引

x = list(range(9))

y = x[1:9:2] # y = [1, 3, 5, 7]

索引賦值：列表式可變的序列，能夠經過索引賦值改變列表中地元素

索引語法：列表[索引] = 表達式

切片賦值語法：列表[切片] = 可迭代對象

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

切出來而後再賦值

示例：

L = [2, 3, 4]

L[0:1] = [1.1, 2.2] -> [1.1, 2.2, 3, 4]

L[1:2] = [1.1, 2.2] -> 

L[1:2] = [] 

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

L = list(range(1, 9))

L[1::2] = [2.2, 4.4, 6.6, 8.8]

print(L)

注意事項：對於步長不等於1的切片賦值，賦值運算符的右側的可迭代對象提供元素的個數必定要等於切片切出的段數

L += 'ABC' 會改變原有id，至關於新建變量

del 列表元素刪除

語法：del 列表[index/slice]

示例：

L = [1, 2, 3, 4, 5, 6]

del L[0]  #L = [2, 3, 4, 5, 6]

del L[-1] #L = [2, 3, 4, 5]

L = [1, 2, 3, 4, 5, 6]

del L[::2] # L = [2, 4, 6]

經常使用的序列函數

len(x) 返回序列的長度

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

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

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

any(x)  真值測試，若是列表中其中有一個值爲真

all(x) 真值測試，若是全部都爲真值

list 經常使用方法

L.index() 查詢元素的索引下標

L.insert(x,y) x索引 y內容

L.count(x) 返回列表中x的個數

L.remove(x)刪除第一次出現的x值

L.copy() 複製列表

L.append() 在列表中追加單個元素（排在最後）

L.extend() 追加一個列表，依次放入，相似 L+=

L.clear() 清空

L.sort(reverse=False) 按元素進行排序，默認爲從小到大升序

L.reverse() 反轉順序

L.pop([index]) 刪除元素，默認最後一個，會返回值

split/join 字符串文本解釋方法

S.split(sep=None)

使用sep做爲分隔符分隔s字符串，返回分割後的字符串列表，默認爲空白字符做文分隔符

S.join(interable)

使用可迭代對象的字符串，返回一箇中間用S進行分割的字符串

示例

s = 'Beijing is capital'

L = s.split() ->['Beijing', 'is', 'captial']

s = '\\'

L = ['C:', 'Programe files', 'python3']

s2 = s.join(L) -> s2 = 'C:\\Programe files\\python3'

深拷貝deep copy；淺拷貝shallow copy

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

深拷貝：深拷貝一般只對可變對象進行解釋不可變對象一般不變

L  = [3.1, 3.2]

L1 = [1, 2, L]

L2 = L1.copy 等同於 L1[:]  淺拷貝，改變L2[2][0]，L也會改變

import copy

L2 = copy.deepcopy(L1) 深拷貝

lsit comprehension 列表推導式

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

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

語法：

[表達式 for 變量 in 可迭代對象]

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

示例：

L = [x*x for x in range(1, 10)]

L = [i for i in range(1,100,2)] #打印出1-100之內的奇數

L = [i for i in range(1,100) if x % 2 ==1] #同上！！

--------------

嵌套：

[表達式1 for v1 in 迭代1 if 真表1 

for v2 迭代2 if 真表2 ……]

示例：

L1 = [2, 3, 5]

L2 = [7, 11, 13]

將L1中的所有元素與L2中的所有元素一次相乘後放到L3中

L3 = [x * y for x in L1 for y in L2]

print(L3)

tuple 元組

元祖是不可改變的序列，同list同樣元組能夠存聽任意類型的元素，一單元組生成，則他不能夠改變

表示方式：用小括號()括起來，單個元素括起來用逗號，區分是單個對象仍是元組。

t = ()

t = 200,

t = (20,)

t = (1, 2, 3)

t = 100, 200, 300

構造函數 tuple

tuple()生成一個空的元組，等同於()

tuple(interable) 用可迭代對象生成一個元組

示例：

t = tuple()

t = tuple(range(10))

t = tuple('hello')

t = tuple([1,2,3,4])

元組的算術運算：

+ += * *= 用法語列表的用法徹底相同

元組的比較運算：

< <= > >= == != 和列表用法徹底相同

in / not in 切片、索引規則與列表徹底相同

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

元祖的方法：help(tuple)

T.count(value) -> integer -- return number of occurrences of value

T.index(value, [start, [stop]]) -> integer -- return first index of value.

能夠用於序列的函數

len, max, min, sum, all, any

構造函數:

str(obj)

list(interable)

tuple(interable)

其餘函數：

reversed(seq) 返回反向順序的可迭代對象

sorted(interable, reversed=False) 返回排序的可迭代對象注意區分它和.sort()方法

返回已排序的列表

示例：

for x in reversed('ABCD')；

print(x)

L = [8,]

dict 字典

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

二、字典中的每一個數據都是‘鍵’(（key)進行索引，而不像序列能夠用下表來進行索引

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

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

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

字典的字面值表示方式：

用{}括起來，以冒號(:)分割 鍵——值對 ，各鍵值對 用分號(;)來分開

建立字典

d = {}

d = {'name': 'howie', 'age': 15}

d = {'姓名'： '小張'}

d = {1:'壹', 2:'貳'}

字典的構造函數

dict() 傳建一個空字典，等同於{}

dict(interable) 用可迭代對象初始化一個字典

dict(**kargs) 關鍵字傳參形式生成一個字典

示例：

d = dict()

d = dict([('name', 'Howie'), ('age', 15)])

d = dict(name = 'Howie', age = 15)

不可變類型（能夠做爲鍵）：int, float, complex, bool, str, tuple, frozensrt

可變類型：list, dict, set, bytearry（字節數組）

字典的鍵索引

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

語法：字典[鍵]

獲取數據元素

d = dict(name='Howie', age=15)

print(d['age'])

添加、修改字典元素

字典[鍵] = 表達式

d = {}

d['name'] = 'Howie'

d['age'] = 15

d['age'] =16

del 語句刪除字典的元素

語法：del 字典[鍵]

d = {'name': 'china', 'pos': 'asia'}

del d['pos']

print(d)

dict in / not in

能夠用in運算符來判斷一個‘鍵’是否存在於字典中，若是存在則返回True，不然返回False

示例：

d = {'a': 1, 'b': 2}

'a' in d # True

1 in d # False

100 not in d # True

2 not in d # True

dict 迭代訪問

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

d = {'name': 'Howie', (2002, 1, 1): '生日'}

for x in d:

print(x)

print(d[x])

dict 方法

D.clear() 清空字典

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

D.copy() 返回字典D的副本,只複製一層(淺拷貝)

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

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

D.keys() 返回可迭代的 dict_keys 集合對象

D.values() 返回可迭代的 dict_values 值對象

D.items() 返回可迭代的 dict_items 對象

示例：

for k, v in d.items():

print(k, v)

dict 推導式

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

語法：

{鍵表達式 : 真值表達式 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}

set 集合

集合是可變的容器

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

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

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

集合是可迭代的

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

建立集合

set()

s = {1, 2, 3}

set(interable)

示例：

s = set("ABC")

s = set('ABCCBA')

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

s = set([1, 3.14, False])

s = set((2, 3, 5, 7))

集合的運算：

交集，並集，補集，子集，超集

& 交集：

s1 = {1,2,3}

s2 = {2,3,4}

s3 = s1 & s2 # s3 = {2,3}

| 並集：

s1 = {1,2,3}

s2 = {2,3,4}

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

對於可變對象，不等用於 s1 |= s2

- 生成兩個集合的補集：生成屬於s1，但不屬於s2的全部元素集合

s1 = {1,2,3}

s2 = {2,3,4}

s3 = s1 - s2 # s3 = {1}

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

s1 = {1,2,3}

s2 = {2,3,4}

s3 = s1 ^ s2 # s3 = {1,4} 至關於 s3 = (s1-s2) | (s2-s1)

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

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

s1 = {1,2,3}

s2 = {2,3}

s2 < s1 # True s2是s1的子集

s1 > s2 # True s1是s2的超集

= ！= 判斷集合相不相同

s1 = {1,2,3}

s2 = {2,3,1}

s1 == s2 # True

s1 != s2 # False  集合的數據沒有前後順序

in / not in

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

not in 與 in 返回值相反

示例：

s = {1, 'Two', 3.14}

1 in s # True

3.14 not in s # False

可用於集合的函數：

len(x) max(x) min(x) sum(x) any(x) all(x)

集合是可迭代對象：不保證順序

s = {1, 2, 3}

for x in s:

print(x)

set 方法

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

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

S.discard(e) 從集合S中移除一個元素e,在元素e不存在時什麼都不作;

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

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

S.pop() 從集合S中刪除一個隨機元素;若是此集合爲空，則引起KeyError異常

S.update(s2) 用 S與s2獲得的全集更新變量S

S.difference(s2) 用S - 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(...) 若是S爲s2的子集返回True,不然返回False

S.symmetric_difference(s2) 返回對稱補集,等同於 S ^ s2

S.symmetric_difference_update(s2) 用 S 與 s2 的對稱補集更新 S

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

set 集合推導式

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

語法：

{表達式 for 變量 in 可迭代對象 [if 真值表達式]}

[]部分能夠省略

示例：

L = [2,3,5,7,3,5,7,11]

s = {x ** 2 for x in L}

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

{x + y for x in "ABC for y in "123"}

frozensey 固定集合

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

做用：

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

建立固定集合：

fs = frozenset()

fs = frozenset([2,3,5,7])

frozenset(interable)

固定集合的運算等同於集合運算

總結

不可變數據類型：

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

可變數據類型：

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

運算符：

+ - * / // % **

> >= < <= == !=

is  is not 

in  not in

not  and  or

&  |  ^

表達式：

1

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(x)

min(x)

sum(x)

any(x)

all(x)

----------

bool(x) int(x) float(x) complex(x) str(s) list(s) dict(s) set(s) frozenset(s)

----------

bin(x)

oct(x)

hex(x)

chr(x)

----------

range([sratr, ]stop[, step])

----------

input(x)

print()