PythonBasic

Python程序的組成

程序由模塊組成

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

語句包含表達式

表達式建立并處理數據對象

Python運行

1、python3 hello.py

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

chomd u+x hello.py 之后用 ./hello.py

Python的交互提示模式

退出：ctrl+d / exit

# 井號開頭，注釋

Python核心數據類型

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

字符串

列表等

整型數int

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

如：-5、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 31

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

0b 1101 1001

0x d 9

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

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

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

浮點型數float

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

表示形式：

小數形式：3.14、3.1、3.、0.14、.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 變量

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

方法：

1、變量名必須為數字或下劃線開頭，后跟字母或下劃線或數字

2、不能使用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, …… = 序列

作用：

用于創建變量并將變量綁定（或關聯）在一個對象上

說明：

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

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

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

4、兩個變量可以同時綁定同一個對象

示例：

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)]

注：()內括起的部分代表可以省略

說明：

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

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

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

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:

語句

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

2、如果為True則執行語句快1，然后跳轉到第一步

3、如果為False則執行else字句部分的語句快2，然后結束此while語句的執行，如果沒有else子句，則直接結束此while語句

4、else子句部分可以省略（同if語句類似）

注意事項：

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

2、通常用真值表達式內的變量來控制循環條件

3、通常要在循環語句快內改變循環變量來控制熏昏的次數和變量的走向

示例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連用

說明：

1、當break語句執行后，此循環語句break之后的語句將不再執行

2、break語句通常和if語句組合使用

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

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

5、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、可迭代對象每次提供一個元素依次賦值給變量列表中的變量，賦值完畢后執行語句塊1，重復執行此步驟，直到可迭代對象不能提供數據為止。

2、可迭代對象提供完所有元素后，執行else子句部分的語句快2，然后退出此for語句。

3、else子句部分可以省略（同while類似）。

4、當在循環內部使用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之后的語句，重新開始一次新的循環

說明：

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

2、在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 字典

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

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

3、字典的數據沒有先后順序關系，字典的存儲是無序的

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

5、字典的鍵不能重復，且只能用不可變類型作為字典的鍵。

字典的字面值表示方式：

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

創建字典

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

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的basic和python_PythonBasic的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。